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 e pubblicare pipeline scikit-learn su 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 Jupyter Notebook.

Come portare il 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 su Cloud Storage
• Creare una risorsa modello in 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 Google Cloud, attivare l'API AI Platform Prediction e installare e attivare l'Cloud SDK.

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.

   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.

   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 riportate di seguito per configurare l'ambiente localmente su macOS o in un ambiente remoto su Cloud Shell.

Per gli utenti di macOS, ti 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 lo sviluppo continuo.

Installare framework

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

pip install --user scikit-learn pandas

Scarica i dati

Il set di dati censuatari sul reddito utilizzato da questo esempio per l'addestramento è ospitato dal repository di machine learning dell'Università di Irvine. Per ulteriori informazioni, consulta la sezione 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 prepararli all'utilizzo con scikit-learn.
2. Addestrare un modello semplice in scikit-learn.
3. Salva il modello in un file che può essere caricato in AI Platform Prediction.

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

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 caratteristiche categoriche in valori numerici, li combina e utilizza un 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 Python pickle:

from sklearn.externals import joblib

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

# 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 su Cloud Storage deve avere il nome model.pkl o model.joblib, a seconda della libreria utilizzata. Questa limitazione garantisce che AI Platform Prediction utilizzi lo stesso schema per ricostruire il modello all'importazione di quello utilizzato durante l'esportazione.

Per le iterazioni future del modello, organizza il bucket Cloud Storage 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 bucket Cloud Storage dedicato nello stesso progetto che utilizzi per 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 richiesta di creazione di una versione del modello di AI Platform Prediction non va a buon fine. Scopri di più sulla concessione delle autorizzazioni per lo spazio di archiviazione.

Configura il bucket Cloud Storage

Questa sezione spiega come creare un nuovo bucket. Puoi utilizzare un bucket esistente, ma deve trovarsi nella stessa regione in cui prevedi di eseguire i job di AI Platform. 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 i bucket di 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 prevedi di eseguire i job di AI Platform Prediction. 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 su 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

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 Prediction. Assicurati che il formato delle istanze di input corrisponda a quello previsto dal modello.

    [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"]

{
  "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"]
  ]
}

Testa il tuo modello con le previsioni locali

Puoi utilizzare il comando gcloud ai-platform local predict per verificare in che modo il modello genera 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 restituisce i risultati nello stesso formato utilizzato da gcloud ai-platform predict per eseguire le 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 il comando gcloud ai-platform local predict con una routine di previsione personalizzata.

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 modello

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

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

In questo momento devi anche decidere se vuoi che le versioni del modello appartenenti a questo modello esportano eventuali log quando generano previsioni. Gli esempi riportati di seguito non attivano il logging. Scopri come attivare il logging.

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

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

Per ulteriori dettagli, consulta l'API del modello AI Platform Prediction.

Creare una versione del modello

Ora puoi creare una versione del modello con il modello addestrato caricato in precedenza su Cloud Storage. Quando crei una versione, puoi specificare una serie di parametri. L'elenco seguente descrive i parametri comuni, alcuni dei quali sono obbligatori:

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

• deploymentUri: il percorso della directory del modello in Cloud Storage.

  • Se stai eseguendo il deployment di un modello TensorFlow, si tratta di una directory SavedModel.
  • Se stai eseguendo il deployment di un modello scikit-learn o XGBoost, si tratta della directory contenente il file model.joblib, model.pkl o model.bst.
  • Se stai implementando una routine di previsione personalizzata, questa è la directory contenente tutti gli elementi del modello. La dimensione totale di questa directory deve essere inferiore o pari a 500 MB.

• 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 prevedi di utilizzare la versione del modello per le previsioni in batch, devi utilizzare la versione di runtime 2.1 o precedente.

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

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

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 regionale, assicurati di creare anche la versione sullo stesso endpoint regionale.

Inviare una 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 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 visualizzare i primi dieci risultati.

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"

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

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]))

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 nella sezione Dettagli della richiesta di previsione dell'API AI Platform Prediction.

Informazioni sui dati

Il set di dati censuatari sul reddito utilizzato da questo esempio per l'addestramento è ospitato dal repository di machine learning dell'Università di Irvine.

Dati del censimento forniti da: Lichman, M. (2013). UCI Machine Learning Repository http://archive.ics.uci.edu/ml. Irvine, CA: University of California, School of Information and Computer Science. Questo set di dati è disponibile pubblicamente per chiunque lo voglia utilizzare ai 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 Jupyter Notebook su GitHub.
• Consulta altri notebook scikit-learn di esempio su GitHub.