Generazione di previsioni online con scikit-learn

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 localmente, esegui il deployment in AI Platform Prediction ed esegui query per ottenere previsioni online.

Puoi eseguire il deployment di scikit-learn e pipeline on AI Platform Prediction. Il modulo Pipeline in scikit-learn ti consente di applicare più trasformazioni dei dati prima dell'addestramento con un estimatore. In questo modo vengono incapsulati più passaggi nell'elaborazione dei dati e viene garantito che gli stessi dati di addestramento vengano utilizzati in ogni passaggio.

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

Come portare il tuo modello in AI Platform Prediction

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

• Salvare il modello in un file
• Carica il modello salvato in Cloud Storage
• Creare una risorsa modello in AI Platform Prediction
• Crea una versione del modello, collegando il modello salvato
• Fai una previsione online

Prima di iniziare

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

Configura il progetto Google Cloud

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the AI Platform Training & Prediction and Compute Engine APIs.

   Enable the APIs

5. Install the Google Cloud CLI.

6. To initialize the gcloud CLI, run the following command:

   gcloud init

7. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

8. Make sure that billing is enabled for your Google Cloud project.

9. Enable the AI Platform Training & Prediction and Compute Engine APIs.

   Enable the APIs

10. Install the Google Cloud CLI.

11. To initialize the gcloud CLI, run the following command:

    gcloud init

Configura l'ambiente

Scegli una delle opzioni seguenti per configurare il tuo ambiente localmente su macOS oppure in un ambiente remoto su Cloud Shell.

Per gli utenti di macOS, consigliamo di configurare l'ambiente utilizzando MACOS sotto. Cloud Shell, mostrato 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 lo sviluppo continuo.

macOS

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

   python -V

2. Controlla l'installazione di pip
pip è il gestore di pacchetti di Python, incluso nelle versioni correnti di Python. Per verificare se pip è già installato, esegui pip --version. In caso contrario, scopri come installare pip.

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

   pip install -U pip

   Per ulteriori dettagli, consulta la documentazione di pip.

3. Installa virtualenv
virtualenv è uno strumento per creare ambienti Python isolati. Per verificare se hai già installato virtualenv, esegui 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 gli altri comandi all'interno completamente gestito di Google Cloud.

   Consulta 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.

   

   Una sessione di Cloud Shell si apre all'interno di un nuovo frame nella parte inferiore della console Cloud e visualizza un prompt della riga di comando. L'operazione può richiedere alcuni secondi per inizializzare la sessione di shell.

   

   La sessione di Cloud Shell è pronta per essere utilizzata.

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 tra parentesi quadre che racchiudono il testo.

Installa framework

macOS

Nell'ambiente virtuale, esegui questo comando per installare le versioni di scikit-learn e pandas utilizzate in AI Platform Prediction versione runtime 2,11

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

Fornendo i numeri di versione nel comando precedente, ti assicuri che le dipendenze nel tuo ambiente virtuale corrispondano a quelle nella versione di runtime. Ciò aiuta a evitare comportamenti imprevisti quando il codice viene eseguito su AI Platform Prediction.

Per ulteriori dettagli, opzioni di installazione e informazioni sulla risoluzione dei problemi, consulta le istruzioni di installazione per ogni framework:

• istruzioni per l'installazione con scikit-learn
• istruzioni per l'installazione di pandas

Cloud Shell

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

pip install --user scikit-learn pandas

Per ulteriori dettagli, opzioni di installazione e informazioni sulla risoluzione dei problemi, consulta le istruzioni di installazione per ciascun framework:

• Istruzioni di installazione di scikit-learn
• istruzioni per l'installazione di pandas

Scarica i dati

Il set di dati sul reddito da censimento usati da questo esempio per l'addestramento, UC Irvine Machine Learning Repository. Per ulteriori informazioni, consulta la sezione Informazioni sui dati.

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

Nota: il file adult.test.csv contiene un punto finale estraneo in alla fine di ogni riga.

Addestra e salva un modello

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

1. Carica i dati in un DataFrame pandas per prepararli per l'utilizzo con scikit-learn.
2. Addestra un modello semplice in scikit-learn.
3. Salva il modello in un file da caricare su AI Platform Prediction.

Se hai già un modello addestrato da caricare, consulta 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 a come esporti gli stimatori di Scikit-learn. L'esempio seguente utilizza le pipeline per convertire le singole funzionalità categoriche in valori numerici, li combina e utilizza un RandomForestClassifier per addestrare il modello.

Nota: per esportare un artefatto del modello joblib compatibile con AI Platform Prediction, devi utilizzare la versione di joblib distribuita con scikit-learn, non la versione autonoma. Per importare questa libreria in Python, utilizza l'istruzionefrom sklearn.externals import joblib.

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 Python:

joblib

Nota: per esportare un artefatto del modello joblib compatibile con AI Platform Prediction, devi utilizzare la versione di joblib distribuita con scikit-learn, non la versione autonoma. Per importare questa libreria in Python, utilizza l'istruzione from sklearn.externals import joblib.

from sklearn.externals import joblib

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

pickle

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

Requisiti per la denominazione dei file del modello

Il file del modello salvato che carichi in Cloud Storage deve essere denominato model.pkl o model.joblib, a seconda della libreria utilizzata. Questo assicura che AI Platform Prediction utilizzi lo stesso pattern per ricostruisci il modello al momento dell'importazione così come è stato utilizzato durante l'esportazione.

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

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

Memorizza il modello in Cloud Storage

Ai fini di questo tutorial, è più semplice utilizzare un modello Bucket Cloud Storage nello stesso progetto che stai utilizzando AI Platform Prediction.

Se utilizzi un bucket in un altro progetto, devi assicurarti che il tuo account di servizio AI Platform Prediction possa accedere al tuo modello in Cloud Storage. Senza le autorizzazioni appropriate, la tua richiesta di creare un La versione del modello AI Platform Prediction ha esito negativo. Scopri di più sulla concessione delle autorizzazioni per lo spazio di archiviazione.

Configura il tuo bucket Cloud Storage

Questa sezione spiega come creare un nuovo bucket. Puoi utilizzare un modello esistente ma deve trovarsi nella stessa regione in cui prevedi di eseguire AI Platform di lavoro. Inoltre, se non fa parte del progetto che utilizzi per eseguire AI Platform Prediction, devi esplicitamente concedere accesso agli account di servizio AI Platform Prediction.

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

   BUCKET_NAME="YOUR_BUCKET_NAME"

   Ad esempio, utilizza il nome del progetto aggiungendo -aiplatform:

   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 prevedi di eseguire AI Platform Prediction di lavoro. Consulta le regioni disponibili per i servizi AI Platform Prediction.

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

   REGION=us-central1

4. Crea il nuovo bucket:

   gcloud storage buckets create gs://$BUCKET_NAME --location=$REGION

Carica il file del modello esportato in Cloud Storage

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

gcloud storage cp ./model.joblib gs://your_bucket_name/model.joblib

Formatta i dati per la previsione

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

Nota: per pulire i dati, assicurati che le stringhe siano racchiuse tra virgolette doppie (") anziché tra virgolette singole ("). In questo modo eviterai un errore di analisi sintattica JSON.

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 in l'elenco test_features definito 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 quello del modello si aspetta. In questo esempio, il modello del censimento richiede 14 caratteristiche, pertanto il input deve essere una matrice di forma (num_instances, 14).

API REST

Crea un file input.json formattato con ogni istanza di input su un oggetto separato dalla riga di comando. L'esempio seguente utilizza le prime dieci istanze di dati nell'elenco test_features definito 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 del modello si aspetta. In questo esempio, il modello Censimento richiede 14 caratteristiche, l'input deve essere una matrice di forma (num_instances, 14).

Leggi ulteriori informazioni su formattare l'input per la previsione online.

Testa il modello con previsioni locali

Puoi utilizzare lo gcloud ai-platform local predict per testare il modo in cui il modello fornisce le previsioni prima di eseguirne il deployment AI Platform Prediction. Il comando utilizza le dipendenze nel tuo ambiente locale eseguire la previsione e restituire i risultati nello stesso formato gcloud ai-platform predict quando esegue previsioni online. Testare le previsioni in locale può aiutarti a scoprire gli errori prima di sostenere i costi delle richieste di previsione online.

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

L'esempio seguente mostra come eseguire una 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

Esegui il deployment di modelli e versioni

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

Per eseguire il deployment di un modello, crea una risorsa modello in AI Platform Prediction, crea una versione del modello e poi collega 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 le diverse versioni del modello.

Al momento devi decidere se vuoi ricevere versioni del modello appartenenti a questo questo modello per utilizzare un endpoint a livello di regione o endpoint. Nella maggior parte dei casi, scegli un endpoint regionale. Se hai bisogno di funzionalità che siano disponibili solo su tipi di macchine legacy (MLS1), quindi utilizza l'endpoint globale.

A questo punto devi anche decidere se vuoi che le versioni del modello appartenenti a questo modello esportano eventuali log quando generano previsioni. I seguenti esempi includono non abilitare il logging. Scopri come attivare la funzionalità il logging.

console

1. Apri la pagina Modelli di AI Platform Prediction nella Console Google Cloud:

   Vai alla pagina Modelli

2. Fai clic sul pulsante Nuovo modello nella parte superiore della pagina Modelli. Questo per accedere alla 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 invece l'endpoint globale, deseleziona la casella di controllo Utilizza endpoint a livello di regione.

5. Dall'elenco a discesa Regione, seleziona una posizione per i nodi di previsione. Le regioni disponibili variano a seconda sia che utilizzi un endpoint a livello di regione o di endpoint globale.

6. Fai clic su Crea.

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

gcloud

Endpoint regionale

Esegui questo comando:

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

Sostituisci quanto segue:

• MODEL_NAME: un nome scelto per il modello.
• REGION: la regione della regione endpoint in cui vuoi eseguire la previsione nodi da eseguire. Deve essere una regione che supporta Tipi di macchine di Compute Engine (N1).

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

In alternativa, puoi impostare la proprietà ai_platform/region su una regione specifica per assicurarti che l'interfaccia a riga di comando gcloud utilizzi sempre l'endpoint regionale corrispondente per AI Platform Prediction, anche se non specifichi il flag --region. Questa configurazione non si applica ai comandi nel gruppo di comandi gcloud ai-platform operations.

Endpoint globale

Esegui questo comando:

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

Sostituisci quanto segue:

• MODEL_NAME: un nome scelto da te per il modello.
• REGION: la regione sull'endpoint globale in cui vuoi nodi di previsione da eseguire. Deve essere una regione che supporta tipi di macchine legacy (MLS1).

Se non specifichi il flag --regions, l'interfaccia a riga di comando gcloud ti chiede di selezionare un endpoint regionale (o di utilizzare us-central1 per l'endpoint globale).

API REST

Endpoint regionale

1. Formatta la richiesta inserendo l'oggetto modello nel corpo della richiesta. Come minimo, specifica un nome per il modello sostituendoMODEL_NAME nel seguente esempio:

   {
     "name": "MODEL_NAME"
   }
   

2. Esegui una chiamata all'API REST al seguente URL, sostituendo PROJECT_ID con l'ID progetto Google Cloud:

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

   Sostituisci quanto segue:

   • REGION: la regione dell'endpoint a livello di regione di cui eseguire il deployment del modello. Deve essere una regione che supporta Tipi di macchine di Compute Engine (N1).

   • PROJECT_ID: l'ID del tuo progetto Google Cloud.

   Ad esempio, puoi effettuare la richiesta seguente utilizzando l'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 nella corpo della richiesta. Come minimo, specifica un nome per il modello sostituendo MODEL_NAME nel seguente esempio e specifica una regione per sostituendo REGION con una regione che supporta 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 ulteriori dettagli, consulta l'API AI Platform Prediction.

Creare una versione del modello

Ora è tutto pronto per creare una versione del modello con il modello addestrato che in precedenza in Cloud Storage. Quando crei una versione, puoi specificare una serie di parametri. Il seguente elenco descrive i parametri comuni, alcuni dei quali sono obbligatori:

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

• deploymentUri: il percorso del modello in di archiviazione ideale in Cloud Storage.

  • Se stai eseguendo il deployment di un modello TensorFlow, si tratta di una directory SavedModel.
  • Se esegui il deployment di un modello scikit-learn o XGBoost, questa è la directory contenente model.joblib, model.pkl o model.bst file.
  • Se stai implementando una routine di previsione personalizzata, questa è la directory contenente tutti gli elementi del modello. Le dimensioni totali di questa directory devono essere 500 MB o inferiori.

• framework: TENSORFLOW, SCIKIT_LEARN o XGBOOST.

• runtimeVersion: una versione di runtime in base alle dipendenze di cui ha bisogno il modello. Se stai implementando un modello scikit-learn o XGBoost, deve essere almeno 1.4. Se hai intenzione di usa la versione del modello per la previsione batch, quindi devi utilizzare la versione del runtime 2.1 o precedente.

• pythonVersion: deve essere impostato su "3,5" (per le versioni di runtime da 1.4 a 1,14) o "3,7" (per runtime versioni 1.15 e successive) per essere compatibile con i file di modello esportati con Python 3. Può essere impostato anche su "2,7" se utilizzato con della versione 1.15 o precedenti del runtime.

• machineType (facoltativo): il tipo di macchina virtuale utilizzata da AI Platform Prediction per i nodi che forniscono le previsioni. Scopri di più sui tipi di macchina. Se non viene impostato, il valore predefinito è n1-standard-2 per gli endpoint regionali e mls1-c1-m2 per l'endpoint globale.

  Se la versione del modello utilizza un tipo di macchina Compute Engine (N1) e meno di due nodi, viene esclusa dall'Accordo sul livello del servizio (SLA) di AI Platform Training e AI Platform Prediction.

  In altre parole, se utilizzi un tipo di macchina Compute Engine (N1), devi impostare manualScaling.nodes o autoScaling.minNodes a 2 o a un livello superiore affinché la versione del modello sia coperta dallo SLA (accordo sul livello del servizio).

  Inoltre, l'utilizzo della scalabilità automatica con le GPU è disponibile in anteprima. Pertanto, le versioni del modello che utilizzano la scalabilità automatica con le GPU non sono coperte dall'SLA.

Per ulteriori informazioni su ciascuno di questi parametri, nonché su altri parametri meno comuni, consulta la documentazione di riferimento dell'API per la risorsa versione.

Inoltre, se hai creato il modello su un endpoint a livello di regione, assicurati di Inoltre, crea la versione nella stessa regione endpoint.

console

1. Apri la pagina Modelli di AI Platform Prediction nella Console Google Cloud:

   Vai alla pagina Modelli

2. Nella pagina Modelli, seleziona il nome della risorsa modello che vuoi utilizzare per creare la versione. Questo ti porta Pagina Dettagli modello.

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

4. Inserisci il nome della versione nel campo Nome. Se vuoi, inserisci un della tua versione nel campo Descrizione.

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

   • Seleziona la versione Python che hai utilizzato per addestrare il modello.
   • Seleziona la Versione frame e Framework.
   • Seleziona la versione del runtime ML. Scopri di più su Versioni del runtime di AI Platform Prediction.

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

7. Nel campo URI modello, inserisci la località 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/ anziché 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. Quando il servizio è stato ridotto, puoi inserire il numero minimo di nodi da mantenere in esecuzione in qualsiasi momento.

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

   Scopri come le opzioni di scalabilità variano a seconda del computer del testo.

   Scopri di più sulla determinazione del prezzo 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 memorizzare il percorso della directory Cloud Storage in cui si trova il file binario del modello, il nome del modello, il nome della versione e il framework scelto.

   Quando crei una versione con gcloud CLI, puoi fornire il nome del framework in maiuscolo con trattini bassi (ad esempio, SCIKIT_LEARN) o in lettere minuscole con trattini (ad esempio, scikit-learn). Entrambe le opzioni generano 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:

   • REGION: la regione della regione endpoint su cui hai creato modello. Se hai creato il modello sull'endpoint globale, ometti il flag --region.

   • MACHINE_TYPE: una macchina type, determinando le risorse di calcolo disponibili per i nodi di previsione.

   La creazione della versione richiede alcuni minuti. Al termine, dovresti vedere il seguente output:

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

3. Ricevi informazioni sulla nuova versione:

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

   Dovresti visualizzare 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 in modo che contenga il oggetto versione. Questo esempio specifica la versione 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. Effettua la chiamata 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 regionale in cui hai creato il tuo modello. Se hai creato il modello sulla endpoint globale, usa ml.googleapis.com.

   Ad esempio, puoi effettuare la richiesta seguente utilizzando l'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. Una volta pronto, vedi un output simile a questo:

   {
     "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 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 modello con gcloud inviando richieste per e dei set di dati.
2. Come inviare richieste più grandi per il set di dati di test completo utilizzando Python libreria client e visualizzare i primi dieci risultati.

gcloud

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

Nota: se scegli di inviare una richiesta per l'intero set di dati di test, tieni presente che la quantità massima di dati che può essere inviata in una singola richiesta è di 1,5 MB. Poiché la dimensione del set di dati di test del censimento supera questo limite, dividere il set di dati a metà e inviare due richieste.

1. Imposta le variabili di ambiente per il nome del modello, il nome della versione e del nome del file di input. Sostituisci [VALUES_IN_BRACKETS] con 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 è previsto il reddito della persona superiore a 50.000 $all'anno e False in caso contrario. Ad esempio, i primi dieci risultati potrebbero essere simili ai seguenti:

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

API REST

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

Nota: se scegli di inviare una richiesta per l'intero set di dati di test, mantieni tieni presente che la quantità massima di dati che può essere inviata in una singola richiesta è 1,5 MB. Poiché la dimensione del set di dati di test del censimento supera questo limite, dividere il set di dati a metà e inviare due richieste.

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 si prevede che il reddito della persona sia superiore a 50.000 $ all'anno e False in caso contrario. I risultati della previsione vengono visualizzati nella console come 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 del censimento e stampa i primi dieci risultati. Espandi informazioni sull'utilizzo della libreria client Python.

Nota: la quantità massima di dati che è possibile inviare in una singola richiesta è di 1,5 MB. Poiché la dimensione del set di dati di test del censimento supera questo limite, nell'esempio riportato di seguito suddivide il set di dati a metà e invia due richieste.

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 si prevede che il reddito della persona sia 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 in Dettagli della richiesta di previsione dell'API AI Platform Prediction.

Informazioni sui dati

Il set di dati sul reddito da censimento usati da questo esempio per l'addestramento, UC Irvine Machine Learning Repository.

Dati del censimento forniti da: Lichman, M. (2013); Repository di machine learning UCI http://archive.ics.uci.edu/ml. Irvine, CA: University of California, School of Information and Computer Science. Questo set di dati è disponibile pubblicamente e può essere utilizzato da chiunque ai sensi del seguenti termini forniti dall'origine del set di dati: http://archive.ics.uci.edu/ml - ed è 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

• Prova questo tutorial come Blocco note Jupyter su GitHub.
• Vedi altri blocchi note scikit-learn di esempio su GitHub.