Generazione di previsioni online con scikit-learn

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questo esempio addestra un modello per prevedere il livello di reddito di una persona in base al set di dati relativo al reddito del censimento. Dopo aver addestrato e salvato il modello in locale, ne esegui il deployment in AI Platform Prediction e ne esegui la query per ricevere previsioni online.

Puoi eseguire il deployment e pubblicare pipekit-learn pipelines su AI Platform Prediction. Il modulo Pipeline in scikit-learn ti consente di applicare più trasformazioni di dati prima dell'addestramento con uno stimetor. che incapsula più passaggi dell'elaborazione dei dati e garantisce che vengano utilizzati gli stessi dati di addestramento in ogni passaggio.

Questo tutorial è disponibile anche su GitHub come blocco note Jupyter.

Come portare il tuo modello su AI Platform Prediction

Puoi inserire il tuo modello in AI Platform Prediction per ottenere previsioni in cinque passaggi:

  • Salva il modello in un file
  • Carica il modello salvato in Cloud Storage
  • Crea una risorsa del modello su AI Platform Prediction
  • Crea una versione del modello, collegando il modello salvato
  • Fare una previsione online

Prima di iniziare

Completa i seguenti passaggi per configurare un account GCP, attivare l'API AI Platform Prediction e installare e attivare Cloud SDK.

Configura il tuo progetto GCP

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Abilita le API AI Platform Training & Prediction and Compute Engine.

    Abilita le API

  5. Installa Google Cloud CLI.

  6. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente: 

    gcloud init
    7.

  7. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  8. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  9. Abilita le API AI Platform Training & Prediction and Compute Engine.

    Abilita le API

  10. Installa Google Cloud CLI.

  11. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente: 

    gcloud init
    12.

Configura l'ambiente

Scegli una delle opzioni seguenti per configurare l'ambiente localmente su macOS o un ambiente remoto su Cloud Shell.

Per gli utenti di macOS, consigliamo di configurare l'ambiente utilizzando la scheda MACOS di seguito. Cloud Shell, visualizzato nella scheda CLOUD SHELL, è disponibile su macOS, Linux e Windows. Cloud Shell offre un modo rapido per provare AI Platform Prediction, ma non è adatto per un lavoro di sviluppo continuo.

macOS

  1. Controlla l'installazione di Python
    Verifica di avere installato Python e, se necessario, di installarlo.

    python -V

  2. Verifica l'installazione di pip
    pip è il gestore dei pacchetti di Python incluso nelle versioni attuali di Python. Verifica di avere già installato pip eseguendo pip --version. Se non è così, scopri come installare pip.

    Puoi eseguire l'upgrade di pip utilizzando il seguente comando:

    pip install -U pip

    Consulta la documentazione relativa a pip per ulteriori dettagli.

  3. Installa virtualenv
    virtualenv è uno strumento per creare ambienti Python isolati. Verifica di avere già installato virtualenv eseguendo virtualenv --version. In caso contrario, installa virtualenv: 

    pip install --user --upgrade virtualenv

    Per creare un ambiente di sviluppo isolato per questa guida, crea un nuovo ambiente virtuale in virtualenv. Ad esempio, il seguente comando attiva un ambiente denominato aip-env:

    virtualenv aip-env
source aip-env/bin/activate

  4. Ai fini di questo tutorial, esegui il resto dei comandi nel tuo ambiente virtuale.

    Leggi ulteriori informazioni sull'utilizzo di virtualenv. Per uscire da virtualenv, esegui deactivate.

Cloud Shell

  1. Apri la console Google Cloud.

    Console Google Cloud

  2. Fai clic sul pulsante Attiva Google Cloud Shell nella parte superiore della finestra della console.

    Attiva Google Cloud Shell

    Viene aperta una sessione di Cloud Shell all'interno di un nuovo frame nella parte inferiore della console e mostra un prompt della riga di comando. L'inizializzazione della sessione shell può richiedere alcuni secondi.

    Sessione di Cloud Shell

    La tua sessione di Cloud Shell è pronta per l'uso.

  3. Configura lo strumento a riga di comando gcloud in modo da utilizzare il progetto selezionato. 

    gcloud config set project [selected-project-id]

    dove [selected-project-id] è l'ID progetto. Ometti le parentesi quadre.

Installazione di framework

macOS

Nel tuo ambiente virtuale, esegui il comando seguente per installare le versioni di scikit-learn e panda utilizzate in Runtime versione 2.11 di AI Platform Prediction:

(aip-env)$ pip install scikit-learn==1.0.2 pandas==1.3.5

Se fornisci i numeri di versione nel comando precedente, ti assicuri che le dipendenze nel tuo ambiente virtuale corrispondano alle dipendenze nella versione di runtime. Ciò consente di evitare comportamenti imprevisti quando il codice viene eseguito in AI Platform Prediction.

Per saperne di più, sulle opzioni di installazione e sulle informazioni per la risoluzione dei problemi, consulta le istruzioni di installazione per ciascun framework:

Cloud Shell

Esegui il comando seguente per installare scikit-learn e pandas:

pip install --user scikit-learn pandas

Per saperne di più, sulle opzioni di installazione e sulle informazioni per la risoluzione dei problemi, consulta le istruzioni di installazione per ciascun framework:

Scarica i dati

Il set di dati sul reddito del censimento utilizzato da questo campione per l'addestramento è ospitato dal repository di machine learning della UC. Per saperne di più, consulta Informazioni sui dati.

  • Il file di addestramento è adult.data
  • Il file di valutazione è adult.test

Addestra e salva un modello

Per addestrare e salvare un modello, completa i seguenti passaggi:

  1. Carica i dati in un DataFrame pandas per prepararlo all'uso con scikit-learn.
  2. Addestra un modello semplice in scikit-learn.
  3. Salva il modello in un file che può essere caricato su AI Platform Prediction.

Se hai già un modello addestrato da caricare, scopri come esportare il modello.

Carica e trasforma i dati

Puoi esportare gli oggetti Pipeline utilizzando la versione di joblib inclusa in scikit-learn o pickle, in modo simile all'esportazione degli stimatori di scikit-learn. L'esempio seguente utilizza le pipeline per convertire singole caratteristiche categoriche in valori numerici, le combina e utilizza un comando RandomForestClassifier per addestrare il modello.

from sklearn.externals import joblib
import json
import numpy as np
import os
import pandas as pd
import pickle
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import FeatureUnion
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import LabelBinarizer

# Define the format of your input data, including unused columns.
# These are the columns from the census data files.
COLUMNS = (
    'age',
    'workclass',
    'fnlwgt',
    'education',
    'education-num',
    'marital-status',
    'occupation',
    'relationship',
    'race',
    'sex',
    'capital-gain',
    'capital-loss',
    'hours-per-week',
    'native-country',
    'income-level'
)

# Categorical columns are columns that need to be turned into a numerical value to be used by scikit-learn
CATEGORICAL_COLUMNS = (
    'workclass',
    'education',
    'marital-status',
    'occupation',
    'relationship',
    'race',
    'sex',
    'native-country'
)

# Load the training census dataset
with open('./census_data/adult.data', 'r') as train_data:
    raw_training_data = pd.read_csv(train_data, header=None, names=COLUMNS)

# Remove the column we are trying to predict ('income-level') from our features list
# Convert the Dataframe to a lists of lists
train_features = raw_training_data.drop('income-level', axis=1).as_matrix().tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
train_labels = (raw_training_data['income-level'] == ' >50K').as_matrix().tolist()

# Load the test census dataset
with open('./census_data/adult.test', 'r') as test_data:
    raw_testing_data = pd.read_csv(test_data, names=COLUMNS, skiprows=1)
# Remove the column we are trying to predict ('income-level') from our features list
# Convert the Dataframe to a lists of lists
test_features = raw_testing_data.drop('income-level', axis=1).as_matrix().tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
test_labels = (raw_testing_data['income-level'] == ' >50K.').as_matrix().tolist()

# Since the census data set has categorical features, we need to convert
# them to numerical values. We'll use a list of pipelines to convert each
# categorical column and then use FeatureUnion to combine them before calling
# the RandomForestClassifier.
categorical_pipelines = []

# Each categorical column needs to be extracted individually and converted to a numerical value.
# To do this, each categorical column will use a pipeline that extracts one feature column via
# SelectKBest(k=1) and a LabelBinarizer() to convert the categorical value to a numerical one.
# A scores array (created below) will select and extract the feature column. The scores array is
# created by iterating over the COLUMNS and checking if it is a CATEGORICAL_COLUMN.
for i, col in enumerate(COLUMNS[:-1]):
    if col in CATEGORICAL_COLUMNS:
        # Create a scores array to get the individual categorical column.
        # Example:
        #  data = [39, 'State-gov', 77516, 'Bachelors', 13, 'Never-married', 'Adm-clerical',
        #         'Not-in-family', 'White', 'Male', 2174, 0, 40, 'United-States']
        #  scores = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        #
        # Returns: [['Sate-gov']]
        scores = []
        # Build the scores array
        for j in range(len(COLUMNS[:-1])):
            if i == j: # This column is the categorical column we want to extract.
                scores.append(1) # Set to 1 to select this column
            else: # Every other column should be ignored.
                scores.append(0)
        skb = SelectKBest(k=1)
        skb.scores_ = scores
        # Convert the categorical column to a numerical value
        lbn = LabelBinarizer()
        r = skb.transform(train_features)
        lbn.fit(r)
        # Create the pipeline to extract the categorical feature
        categorical_pipelines.append(
            ('categorical-{}'.format(i), Pipeline([
                ('SKB-{}'.format(i), skb),
                ('LBN-{}'.format(i), lbn)])))

# Create pipeline to extract the numerical features
skb = SelectKBest(k=6)
# From COLUMNS use the features that are numerical
skb.scores_ = [1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0]
categorical_pipelines.append(('numerical', skb))

# Combine all the features using FeatureUnion
preprocess = FeatureUnion(categorical_pipelines)

# Create the classifier
classifier = RandomForestClassifier()

# Transform the features and fit them to the classifier
classifier.fit(preprocess.transform(train_features), train_labels)

# Create the overall model as a single pipeline
pipeline = Pipeline([
    ('union', preprocess),
    ('classifier', classifier)
])

Esporta il tuo modello

Per esportare il modello, puoi utilizzare joblib o la libreria pickle di Python:

lib

from sklearn.externals import joblib

# Export the model to a file
joblib.dump(pipeline, 'model.joblib')

sottaceto

# Export the model to a file
with open('model.pkl', 'wb') as model_file:
  pickle.dump(pipeline, model_file)

Requisiti di denominazione dei file modello

Il file del modello salvato che carichi in Cloud Storage deve avere un nome model.pkl o model.joblib, a seconda della libreria utilizzata. Questa restrizione garantisce che AI Platform Prediction utilizzi lo stesso pattern per ricostruire il modello durante l'importazione utilizzato durante l'esportazione.

Libreria utilizzata per esportare il modello Nome del modello corretto
pickle model.pkl
sklearn.externals.joblib model.joblib

Per le iterazioni future del tuo modello, organizza il tuo bucket Cloud Storage in modo che ogni nuovo modello abbia una directory dedicata.

Archivia il tuo modello in Cloud Storage

Ai fini di questo tutorial, è più semplice utilizzare un bucket Cloud Storage dedicato nello stesso progetto che utilizzi per AI Platform Prediction.

Se utilizzi un bucket in un progetto diverso, devi assicurarti che l'account di servizio AI Platform Prediction possa accedere al modello in Cloud Storage. Senza le autorizzazioni appropriate, la tua richiesta di creazione di una versione del modello di previsione AI Platform non andrà a buon fine. Scopri di più sulla concessione delle autorizzazioni per lo spazio di archiviazione.

Configura il tuo bucket Cloud Storage

Questa sezione mostra come creare un nuovo bucket. Puoi utilizzare un bucket esistente, ma deve essere nella stessa regione in cui prevedi di eseguire i job AI Platform. Inoltre, se non fa parte del progetto che stai utilizzando per eseguire AI Platform Prediction, devi concedere esplicitamente l'accesso agli account di servizio AI Platform Prediction.

  1. Specifica un nome per il nuovo bucket. Il nome deve essere univoco in tutti i bucket in Cloud Storage.

    BUCKET_NAME="YOUR_BUCKET_NAME"

    Ad esempio, utilizza il nome del progetto con -aiplatform aggiunto: 

    PROJECT_ID=$(gcloud config list project --format "value(core.project)")
BUCKET_NAME=${PROJECT_ID}-aiplatform

  2. Controlla il nome del bucket che hai creato.

    echo $BUCKET_NAME

  3. Seleziona una regione per il bucket e imposta una variabile di ambiente REGION.

    Utilizza la stessa regione in cui intendi eseguire job di AI Platform Prediction. Consulta le regioni disponibili per i servizi di AI Platform Prediction.

    Ad esempio, il seguente codice crea REGION e lo imposta su us-central1: 

    REGION=us-central1

  4. Crea il nuovo bucket:

    gsutil mb -l $REGION gs://$BUCKET_NAME

Carica il file del modello esportato in Cloud Storage

Esegui questo comando per caricare il file del modello salvato nel bucket in Cloud Storage:

gsutil cp ./model.joblib gs://your_bucket_name/model.joblib

Formattare i dati per la previsione

Prima di inviare una richiesta di previsione online, devi formattare i dati di test per prepararli all'utilizzo da parte del servizio di previsione AI Platform. Assicurati che il formato delle istanze di input corrisponda a quanto previsto dal modello.

gcloud

Crea un file input.json con ogni istanza di input su una riga separata. L'esempio seguente utilizza le prime dieci istanze di dati nell'elenco test_features definite nei passaggi precedenti.

    [25, "Private", 226802, "11th", 7, "Never-married", "Machine-op-inspct", "Own-child", "Black", "Male", 0, 0, 40, "United-States"]
    [38, "Private", 89814, "HS-grad", 9, "Married-civ-spouse", "Farming-fishing", "Husband", "White", "Male", 0, 0, 50, "United-States"]
    [28, "Local-gov", 336951, "Assoc-acdm", 12, "Married-civ-spouse", "Protective-serv", "Husband", "White", "Male", 0, 0, 40, "United-States"]
    [44, "Private", 160323, "Some-college", 10, "Married-civ-spouse", "Machine-op-inspct", "Husband", "Black", "Male", 7688, 0, 40, "United-States"]
    [18, "?", 103497, "Some-college", 10, "Never-married", "?", "Own-child", "White", "Female", 0, 0, 30, "United-States"]
    [34, "Private", 198693, "10th", 6, "Never-married", "Other-service", "Not-in-family", "White", "Male", 0, 0, 30, "United-States"]
    [29, "?", 227026, "HS-grad", 9, "Never-married", "?", "Unmarried", "Black", "Male", 0, 0, 40, "United-States"]
    [63, "Self-emp-not-inc", 104626, "Prof-school", 15, "Married-civ-spouse", "Prof-specialty", "Husband", "White", "Male", 3103, 0, 32, "United-States"]
    [24, "Private", 369667, "Some-college", 10, "Never-married", "Other-service", "Unmarried", "White", "Female", 0, 0, 40, "United-States"]
    [55, "Private", 104996, "7th-8th", 4, "Married-civ-spouse", "Craft-repair", "Husband", "White", "Male", 0, 0, 10, "United-States"]

Tieni presente che il formato delle istanze di input deve corrispondere a quanto previsto dal modello. In questo esempio, il modello del censimento richiede 14 funzionalità, quindi l'input deve avere una matrice di forma (num_instances, 14).

API REST

Creare un file input.json formattato con ogni istanza di input su una riga separata. L'esempio seguente utilizza le prime dieci istanze di dati nell'elenco test_features definite nei passaggi precedenti.

{
  "instances": [

    [25, "Private", 226802, "11th", 7, "Never-married", "Machine-op-inspct", "Own-child", "Black", "Male", 0, 0, 40, "United-States"],
    [38, "Private", 89814, "HS-grad", 9, "Married-civ-spouse", "Farming-fishing", "Husband", "White", "Male", 0, 0, 50, "United-States"],
    [28, "Local-gov", 336951, "Assoc-acdm", 12, "Married-civ-spouse", "Protective-serv", "Husband", "White", "Male", 0, 0, 40, "United-States"],
    [44, "Private", 160323, "Some-college", 10, "Married-civ-spouse", "Machine-op-inspct", "Husband", "Black", "Male", 7688, 0, 40, "United-States"],
    [18, "?", 103497, "Some-college", 10, "Never-married", "?", "Own-child", "White", "Female", 0, 0, 30, "United-States"],
    [34, "Private", 198693, "10th", 6, "Never-married", "Other-service", "Not-in-family", "White", "Male", 0, 0, 30, "United-States"],
    [29, "?", 227026, "HS-grad", 9, "Never-married", "?", "Unmarried", "Black", "Male", 0, 0, 40, "United-States"],
    [63, "Self-emp-not-inc", 104626, "Prof-school", 15, "Married-civ-spouse", "Prof-specialty", "Husband", "White", "Male", 3103, 0, 32, "United-States"],
    [24, "Private", 369667, "Some-college", 10, "Never-married", "Other-service", "Unmarried", "White", "Female", 0, 0, 40, "United-States"],
    [55, "Private", 104996, "7th-8th", 4, "Married-civ-spouse", "Craft-repair", "Husband", "White", "Male", 0, 0, 10, "United-States"]
  ]
}

Tieni presente che il formato delle istanze di input deve corrispondere a quello previsto dal modello. In questo esempio, il modello Census richiede 14 funzionalità, quindi l'input deve essere una matrice di forma (num_instances, 14).

Scopri di più sulla formattazione dell'input per la previsione online.

Testa il tuo modello con le previsioni locali

Puoi utilizzare il comando gcloud ai-platform local predict per testare come il modello pubblica le previsioni prima di eseguirne il deployment in AI Platform Prediction. Il comando utilizza le dipendenze nel tuo ambiente locale per eseguire la previsione e restituire i risultati nello stesso formato usato da gcloud ai-platform predict quando esegue previsioni online. Il test delle previsioni a livello locale può aiutarti a rilevare gli errori prima che ti vengano addebitati costi per le richieste di previsione online.

Per l'argomento --model-dir, specifica una directory contenente il modello di machine learning esportato, sulla macchina locale o in Cloud Storage. Per l'argomento --framework, specifica tensorflow, scikit-learn o xgboost. Non puoi utilizzare il comando gcloud ai-platform local predict con una routine di previsione personalizzata.

L'esempio seguente mostra come eseguire la previsione locale:

gcloud ai-platform local predict --model-dir LOCAL_OR_CLOUD_STORAGE_PATH_TO_MODEL_DIRECTORY/ \
  --json-instances LOCAL_PATH_TO_PREDICTION_INPUT.JSON \
  --framework NAME_OF_FRAMEWORK

Deployment di modelli e versioni

AI Platform Prediction organizza i tuoi modelli addestrati utilizzando le risorse model e version. Un modello di previsione AI Platform è un container per le versioni del tuo modello di machine learning.

Per eseguire il deployment di un modello, devi creare una risorsa del modello in AI Platform Prediction, creare una versione del modello, quindi collegare la versione del modello al file del modello archiviato in Cloud Storage.

Crea una risorsa del modello

AI Platform Prediction utilizza le risorse del modello per organizzare diverse versioni del modello.

Devi decidere in questo momento se vuoi che le versioni del modello appartenenti a questo modello utilizzino un endpoint a livello di regione o l'endpoint globale. Nella maggior parte dei casi, scegli un endpoint a livello di regione. Se hai bisogno di funzionalità disponibili solo sui tipi di macchine legacy (MLS1), utilizza l'endpoint globale.

Devi anche decidere in questa fase se vuoi che le versioni del modello appartenenti a questo modello esportino i log quando forniscono previsioni. I seguenti esempi non abilitano il logging. Scopri come abilitare il logging.

console

  1. Apri la pagina Modelli di previsione di AI Platform nella console Google Cloud:

    Vai alla pagina Modelli

  2. Fai clic sul pulsante Nuovo modello nella parte superiore della pagina Modelli. Viene visualizzata la pagina Crea modello.

  3. Inserisci un nome univoco per il modello nel campo Nome modello.

  4. Quando la casella di controllo Utilizza endpoint a livello di regione è selezionata, AI Platform Prediction utilizza un endpoint a livello di regione. Per utilizzare l'endpoint globale, deseleziona la casella di controllo Utilizza endpoint a livello di regione.

  5. Nell'elenco a discesa Regione, seleziona una località per i nodi di previsione. Le regioni disponibili variano a seconda che tu utilizzi un endpoint a livello di area geografica o globale.

  6. Fai clic su Crea.

  7. Verifica di essere tornato alla pagina Modelli e che il nuovo modello venga visualizzato nell'elenco.

gcloud

Endpoint a livello di regione

Esegui questo comando:

gcloud ai-platform models create MODEL_NAME \
  --region=REGION

Sostituisci quanto segue:

Se non specifichi il flag --region, l'interfaccia a riga di comando gcloud ti chiede di selezionare un endpoint a livello di regione (o di utilizzare us-central nell'endpoint globale).

In alternativa, puoi impostare la proprietà ai_platform/region su una regione specifica per assicurarti che l'interfaccia alla gcloud CLI utilizzi sempre l'endpoint della regione corrispondente per AI Platform Prediction, anche quando non specifichi il flag --region. (Questa configurazione non si applica ai comandi del gruppo di comandi gcloud ai-platform operations).

Endpoint globale

Esegui questo comando:

gcloud ai-platform models create MODEL_NAME \
  --regions=REGION

Sostituisci quanto segue:

Se non specifichi il flag --regions, l'interfaccia a riga di comando gcloud richiede di selezionare un endpoint a livello di regione (o di utilizzare us-central1 nell'endpoint globale).

API REST

Endpoint a livello di regione

  1. Formatta la richiesta inserendo l'oggetto modello nel corpo della richiesta. Specifica almeno un nome per il modello sostituendo MODEL_NAME nell'esempio seguente:

    {
  "name": "MODEL_NAME"
}

  2. Effettua una chiamata API REST al seguente URL, sostituendo PROJECT_ID con il tuo ID progetto Google Cloud:

    POST https://REGION-ml.googleapis.com/v1/projects/PROJECT_ID/models/

    Sostituisci quanto segue:

    Ad esempio, puoi effettuare la seguente richiesta utilizzando il comando curl. Questo comando autorizza la richiesta utilizzando le credenziali associate all'installazione di Google Cloud CLI.

    curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "MODEL_NAME"}' \
  -H "Authorization: Bearer `gcloud auth print-access-token`" \
  "https://REGION-ml.googleapis.com/v1/projects/PROJECT_ID/models"

    L'API restituisce una risposta simile alla seguente:

    {
  "name": "projects/PROJECT_ID/models/MODEL_NAME",
  "regions": [
    "REGION"
  ]
}

Endpoint globale

  1. Formatta la richiesta inserendo l'oggetto modello nel corpo della richiesta. Come minimo, specifica un nome per il modello sostituendo MODEL_NAME nell'esempio seguente e specifica una regione sostituendo REGION con una regione che supporta i tipi di macchine legacy (MLS1):

    {
  "name": "MODEL_NAME",
  "regions": ["REGION"]
}

  2. Effettua una chiamata API REST al seguente URL, sostituendo PROJECT_ID con il tuo ID progetto Google Cloud:

    POST https://ml.googleapis.com/v1/projects/PROJECT_ID/models/

    Ad esempio, puoi effettuare la seguente richiesta utilizzando il comando curl. Questo comando autorizza la richiesta utilizzando le credenziali associate all'installazione di Google Cloud CLI.

    curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "MODEL_NAME", "regions": ["REGION"]}' \
  -H "Authorization: Bearer `gcloud auth print-access-token`" \
  "https://ml.googleapis.com/v1/projects/PROJECT_ID/models"

    L'API restituisce una risposta simile alla seguente:

    {
  "name": "projects/PROJECT_ID/models/MODEL_NAME",
  "regions": [
    "REGION"
  ]
}

Per maggiori dettagli, consulta l'API AI Platform Prediction Model.

Crea una versione del modello

Ora è tutto pronto per creare una versione con il modello addestrato caricato in precedenza in Cloud Storage. Quando crei una versione, puoi specificare un numero di parametri. Di seguito sono riportati i parametri comuni, alcuni dei quali sono obbligatori:

  • name: deve essere univoco all'interno del modello Previsione di AI Platform.

  • deploymentUri: il percorso della directory dei modelli in Cloud Storage.

    • Se stai eseguendo il deployment di un modello TensorFlow, questa è una directory ModelModel.
    • Se stai eseguendo il deployment di un modello scikit-learn o XGBoost, questa è la directory contenente il tuo file model.joblib, model.pkl o model.bst.
    • Se stai eseguendo il deployment di una routine di previsione personalizzata, questa è la directory che contiene tutti gli artefatti del modello. Le dimensioni totali di questa directory devono essere al massimo 500 MB.

  • framework: TENSORFLOW, SCIKIT_LEARN o XGBOOST.

  • runtimeVersion: una versione di runtime in base alle dipendenze necessarie al modello. Se stai eseguendo il deployment di un modello scikit-learn o di un modello XGBoost, deve essere almeno 1,4. Se prevedi di utilizzare la versione del modello per la previsione batch, devi utilizzare la versione del runtime 2.1 o precedenti.

  • pythonVersion: deve essere impostato su "3.5" (per le versioni di runtime da 1.4 a 1.14) o "3.7" (per le versioni di runtime 1.15 e successive) per essere compatibile con i file modello esportati con Python 3. Può essere impostato anche su "2.7" se utilizzato con runtime 1.15 o versioni precedenti.

  • (Facoltativo) machineType: il tipo di macchina virtuale che AI Platform Prediction utilizza per i nodi che gestiscono le previsioni. Scopri di più sui tipi di macchine. Se non è configurato, il valore predefinito è n1-standard-2 negli endpoint a livello di regione e mls1-c1-m2 nell'endpoint globale.

Consulta ulteriori informazioni su ciascuno di questi parametri e altri parametri meno comuni nel riferimento API per la risorsa versione.

Inoltre, se hai creato il modello su un endpoint a livello di regione, assicurati di creare anche la versione sullo stesso endpoint a livello di regione.

console

  1. Apri la pagina Modelli di previsione di AI Platform nella console Google Cloud:

    Vai alla pagina Modelli

  2. Nella pagina Modelli, seleziona il nome della risorsa del modello che vuoi utilizzare per creare la versione. Viene visualizzata la pagina Dettagli modello.

  3. Fai clic sul pulsante Nuova versione nella parte superiore della pagina Dettagli modello. Viene visualizzata la pagina Crea versione.

  4. Inserisci il nome della versione nel campo Nome. Se vuoi, inserisci una descrizione per la versione nel campo Descrizione.

  5. Inserisci le seguenti informazioni su come addestrare il modello nelle caselle a discesa corrispondenti:

  6. Seleziona un tipo di macchina per eseguire la previsione online.

  7. Nel campo URI del modello, inserisci la posizione del bucket Cloud Storage in cui hai caricato il file del modello. Puoi utilizzare il pulsante Sfoglia per trovare il percorso corretto.

    Assicurati di specificare il percorso della directory contenente il file, non il percorso del file del modello stesso. Ad esempio, utilizza gs://your_bucket_name/model-dir/ invece di gs://your_bucket_name/model-dir/saved_model.pb o gs://your_bucket_name/model-dir/model.pkl.

  8. Seleziona un'opzione di Scalabilità per il deployment della previsione online:

    • Se selezioni "Scalabilità automatica", viene visualizzato il campo facoltativo Numero minimo di nodi. Puoi inserire il numero minimo di nodi da mantenere in esecuzione in qualsiasi momento durante lo scale down del servizio.

    • Se selezioni "Scalabilità manuale", devi inserire il numero di nodi che vuoi mantenere sempre in esecuzione.

    Scopri come le opzioni di scalabilità variano in base al tipo di macchina.

    Scopri di più sui prezzi per i costi di previsione.

  9. Per completare la creazione della versione del modello, fai clic su Salva.

gcloud

  1. Imposta le variabili di ambiente per archiviare il percorso della directory Cloud Storage in cui si trova il programma binario del modello, il nome del modello, il nome della versione e la scelta del framework.

    Quando crei una versione con l'interfaccia a riga di comando gcloud, puoi inserire il nome del framework in lettere maiuscole con trattini bassi (ad es. SCIKIT_LEARN) o lettere minuscole con trattini (ad es. scikit-learn). Entrambe le opzioni portano a un comportamento identico.

    Sostituisci [VALUES_IN_BRACKETS] con i valori appropriati:

    MODEL_DIR="gs://your_bucket_name/"
VERSION_NAME="[YOUR-VERSION-NAME]"
MODEL_NAME="[YOUR-MODEL-NAME]"
FRAMEWORK="[YOUR-FRAMEWORK_NAME]"

  2. Crea la versione:

    gcloud ai-platform versions create $VERSION_NAME \
  --model=$MODEL_NAME \
  --origin=$MODEL_DIR \
  --runtime-version=2.11 \
  --framework=$FRAMEWORK \
  --python-version=3.7 \
  --region=REGION \
  --machine-type=MACHINE_TYPE

    Sostituisci quanto segue:

    La creazione della versione richiede alcuni minuti. Quando è tutto pronto, dovresti vedere il seguente output:

    Creating version (this might take a few minutes)......done.

  3. Informazioni sulla nuova versione:

    gcloud ai-platform versions describe $VERSION_NAME \
  --model=$MODEL_NAME

    Dovresti vedere un output simile al seguente:

    createTime: '2018-02-28T16:30:45Z'
deploymentUri: gs://your_bucket_name
framework: [YOUR-FRAMEWORK-NAME]
machineType: mls1-c1-m2
name: projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]
pythonVersion: '3.7'
runtimeVersion: '2.11'
state: READY

API REST

  1. Formatta il corpo della richiesta per contenere l'oggetto versione. Questo esempio specifica le versioni name, deploymentUri, runtimeVersion, framework e machineType. Sostituisci [VALUES_IN_BRACKETS] con i valori appropriati:

    {
  "name": "[YOUR-VERSION-NAME]",
  "deploymentUri": "gs://your_bucket_name/",
  "runtimeVersion": "2.11",
  "framework": "[YOUR_FRAMEWORK_NAME]",
  "pythonVersion": "3.7",
  "machineType": "[YOUR_MACHINE_TYPE]"
}

  2. Chiama l'API REST al seguente percorso, sostituendo [VALUES_IN_BRACKETS] con i valori appropriati:

    POST https://REGION-ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions

    Sostituisci REGION con la regione dell'endpoint a livello di regione in cui hai creato il tuo modello. Se hai creato il modello nell'endpoint globale, utilizza la ml.googleapis.com.

    Ad esempio, puoi effettuare la seguente richiesta utilizzando il comando curl:

    curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "[YOUR-VERSION-NAME]", "deploymentUri": "gs://your_bucket_name/", "runtimeVersion": "2.11", "framework": "[YOUR_FRAMEWORK_NAME]", "pythonVersion": "3.7", "machineType": "[YOUR_MACHINE_TYPE]"}' \
  -H "Authorization: Bearer `gcloud auth print-access-token`" \
  "https://REGION-ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions"

    La creazione della versione richiede alcuni minuti. Quando è tutto pronto, dovresti vedere un output simile al seguente:

    {
  "name": "projects/[YOUR-PROJECT-ID]/operations/create_[YOUR-MODEL-NAME]_[YOUR-VERSION-NAME]-[TIMESTAMP]",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.ml.v1.OperationMetadata",
    "createTime": "2018-07-07T02:51:50Z",
    "operationType": "CREATE_VERSION",
    "modelName": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]",
    "version": {
      "name": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]",
      "deploymentUri": "gs://your_bucket_name",
      "createTime": "2018-07-07T02:51:49Z",
      "runtimeVersion": "2.11",
      "framework": "[YOUR_FRAMEWORK_NAME]",
      "machineType": "[YOUR_MACHINE_TYPE]",
      "pythonVersion": "3.7"
    }
  }
}

Invia richiesta di previsione online

Dopo aver creato correttamente una versione, AI Platform Prediction avvia un nuovo server pronto per gestire le richieste di previsione.

Questa sezione mostra quanto segue:

  1. Come testare il tuo modello con gcloud inviando richieste per set di dati più piccoli.
  2. Come inviare richieste più grandi per il set di dati di test completo utilizzando la libreria client Python e visualizza i primi dieci risultati.

gcloud

Questa sezione spiega come inviare una richiesta di previsione utilizzando il file input.json creato in un passaggio precedente.

  1. Imposta le variabili di ambiente per il nome del modello, della versione e del file di input. Sostituisci [VALUES_IN_BRACKETS] con i valori appropriati:

    MODEL_NAME="[YOUR-MODEL-NAME]"
VERSION_NAME="[YOUR-VERSION-NAME]"
INPUT_FILE="input.json"

  2. Invia la richiesta di previsione:

    gcloud ai-platform predict --model $MODEL_NAME --version \
  $VERSION_NAME --json-instances $INPUT_FILE

    I risultati della previsione restituiscono True se il reddito dell'utente è superiore a 50.000 $all'anno e False in caso contrario. Ad esempio, i primi dieci risultati potrebbero essere simili al seguente:

    [False, False, False, True, False, False, False, False, False, False]

API REST

Questa sezione spiega come inviare una richiesta di previsione utilizzando il file input.json creato nel passaggio precedente.

Invia le richieste di previsione:

curl -X POST -H "Content-Type: application/json" -d @input.json \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
"https://ml.googleapis.com/v1/projects/${PROJECT_ID}/models/${MODEL_NAME}/versions/${VERSION_NAME}:predict"

I risultati della previsione restituiscono True se il reddito previsto della persona è superiore a 50.000 $all'anno e False in caso contrario. I risultati della previsione vengono visualizzati nella console come un elenco di valori booleani. Ad esempio, i primi dieci risultati potrebbero essere simili ai seguenti:

{"predictions": [false, false, false, true, false, false, false, false, false, false]}

Python

Questo esempio utilizza la libreria client Python per inviare richieste di previsione per l'intero set di dati di censimento e stampa i primi dieci risultati. Leggi ulteriori informazioni su come utilizzare la libreria client di Python.

Sostituisci [VALUES_IN_BRACKETS] con i valori appropriati:

import googleapiclient.discovery

# Fill in your PROJECT_ID, VERSION_NAME and MODEL_NAME before running
# this code.

PROJECT_ID = [YOUR PROJECT_ID HERE]
VERSION_NAME = [YOUR VERSION_NAME HERE]
MODEL_NAME = [YOUR MODEL_NAME HERE]

service = googleapiclient.discovery.build('ml', 'v1')
name = 'projects/{}/models/{}'.format(PROJECT_ID, MODEL_NAME)
name += '/versions/{}'.format(VERSION_NAME)

# Due to the size of the data, it needs to be split in 2
first_half = test_features[:int(len(test_features)/2)]
second_half = test_features[int(len(test_features)/2):]

complete_results = []
for data in [first_half, second_half]:
    responses = service.projects().predict(
        name=name,
        body={'instances': data}
    ).execute()

    if 'error' in responses:
        print(response['error'])
    else:
        complete_results.extend(responses['predictions'])

# Print the first 10 responses
for i, response in enumerate(complete_results[:10]):
    print('Prediction: {}\tLabel: {}'.format(response, test_labels[i]))

I risultati della previsione restituiscono True se il reddito dell'utente è superiore a 50.000 $all'anno e False in caso contrario. Ad esempio, i primi dieci risultati potrebbero essere simili ai seguenti:

Prediction: False Label: False
Prediction: False Label: False
Prediction: True  Label: True
Prediction: True  Label: True
Prediction: False Label: False
Prediction: False Label: False
Prediction: False Label: False
Prediction: True  Label: True
Prediction: False Label: False
Prediction: False Label: False

Scopri di più su ciascun parametro di input nei dettagli della richiesta di previsione dell'API AI Platform Prediction.

Informazioni sui dati

Il set di dati sul reddito del censimento utilizzato da questo campione per l'addestramento è ospitato dal repository di machine learning della UC.

Dati del censimento per gentile concessione di: Lichman, M. (2013), Repository di machine learning UCI http://archive.ics.uci.edu/ml. Irvine, CA: Università della California, Scuola dell'informazione e informatica. Questo set di dati è disponibile pubblicamente per chiunque ai sensi dei seguenti termini forniti dall'origine del set di dati - http://archive.ics.uci.edu/ml - e viene fornito "così com'è" senza alcuna garanzia, espressa o implicita, da parte di Google. Google esclude qualsiasi responsabilità per eventuali danni, diretti o indiretti, derivanti dall'uso del set di dati.

Passaggi successivi