Creazione di una routine di previsione personalizzata con scikit-learn

Logo Colab Esegui questo tutorial come blocco note in Colab Logo di GitHub Visualizza il notebook su GitHub

Panoramica

Questo tutorial mostra come eseguire il deployment di un modello scikit-learn addestrato in AI Platform Prediction e come fornire le previsioni utilizzando una routine di previsione personalizzata. In questo modo, puoi personalizzare il modo in cui AI Platform Prediction risponde a ogni richiesta di previsione.

In questo esempio, utilizzerai una routine di previsione personalizzata per eseguire la preelaborazione dell'input di previsione mediante la scalabilità e il post-trattamento dell'output di previsione mediante la conversione dei numeri di classe in stringhe di etichette.

Il tutorial illustra diversi passaggi:

  • Addestramento di un semplice modello scikit-learn in locale (in questo notebook)
  • Creazione ed esecuzione di una routine di previsione personalizzata in AI Platform Prediction
  • Pubblicazione delle richieste di previsione da quel deployment

Set di dati

Questo tutorial utilizza il set di dati Iris di R.A. Fisher, un piccolo set di dati molto utilizzato per provare le tecniche di machine learning. Ogni istanza ha quattro caratteristiche numeriche, ovvero misurazioni diverse di un fiore, e un'etichetta target che lo contrassegnava come uno dei tre tipi di iris: Iris setosa, Iris versicolor o Iris virginica.

Questo tutorial utilizza la copia del set di dati Iris inclusa nella libreria scikit-learn.

Obiettivo

L'obiettivo è addestrare un modello che utilizzi le misurazioni di un fiore come input per prevedere di che tipo di iris si tratta.

Questo tutorial si concentra più sull'utilizzo di questo modello con AI Platform Prediction che sul design del modello stesso.

Costi

Questo tutorial utilizza i componenti fatturabili di Google Cloud:

  • AI Platform Prediction
  • Cloud Storage

Scopri i prezzi di AI Platform Prediction e i prezzi di Cloud Storage e utilizza il Calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto.

Prima di iniziare

Prima di poter addestrare e implementare un modello in AI Platform Prediction, devi svolgere diverse operazioni:

  • Configura l'ambiente di sviluppo locale.
  • Configura un progetto Google Cloud con la fatturazione e le API necessarie abilitate.
  • Crea un bucket Cloud Storage per archiviare il pacchetto di addestramento e il modello addestrato.

Configura l'ambiente di sviluppo locale

Per completare questo tutorial, devi disporre di quanto segue:

  • Python 3
  • virtualenv
  • Google Cloud SDK

La guida di Google Cloud alla configurazione di un ambiente di sviluppo Python fornisce istruzioni dettagliate per soddisfare questi requisiti. I passaggi riportati di seguito forniscono un insieme di istruzioni condensate:

  1. Installa Python 3.

  2. Installa virtualenv e crea un ambiente virtuale che utilizzi Python 3.

  3. Attiva l'ambiente.

  4. Completa i passaggi descritti nella sezione seguente per installare l'Google Cloud SDK.

Configurare 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

Autentica il tuo account Google Cloud

Per configurare l'autenticazione, devi creare una chiave dell'account di servizio e impostare una variabile di ambiente per il percorso del file della chiave dell'account di servizio.

  1. Crea un account di servizio:

    1. Nella console Google Cloud, vai alla pagina Crea account di servizio.

      Vai a Crea account di servizio

    2. Inserisci un nome nel campo Nome account di servizio.
    3. (Facoltativo) Nel campo Descrizione account di servizio, inserisci una descrizione.
    4. Fai clic su Crea.
    5. Fai clic sul campo Seleziona un ruolo. In Tutti i ruoli, seleziona AI Platform > Amministratore AI Platform.
    6. Fai clic su Aggiungi un altro ruolo.

    7. Fai clic sul campo Seleziona un ruolo. In Tutti i ruoli, seleziona Storage > Storage Object Admin.

    8. Fai clic su Fine per creare l'account di servizio.

      Non chiudere la finestra del browser. Lo utilizzerai nel passaggio successivo.

  2. Crea una chiave dell'account di servizio per l'autenticazione:

    1. Nella console Google Cloud, fai clic sull'indirizzo email dell'account di servizio che hai creato.
    2. Fai clic su Chiavi.
    3. Fai clic su Aggiungi chiave, quindi su Crea nuova chiave.
    4. Fai clic su Crea. Un file della chiave JSON viene scaricato sul computer.
    5. Fai clic su Chiudi.

  3. Imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS sul percorso del file JSON contenente la chiave dell'account di servizio. Questa variabile si applica solo alla sessione di shell corrente, quindi se apri una nuova sessione, imposta di nuovo la variabile.

Crea un bucket Cloud Storage

Per eseguire il deployment di una routine di previsione personalizzata, devi caricare gli elementi del modello addestrato e il codice personalizzato su Cloud Storage.

Imposta il nome del bucket Cloud Storage come variabile di ambiente. Deve essere univoco in tutti i bucket Cloud Storage:

BUCKET_NAME="your-bucket-name"

Seleziona una regione in cui è disponibile AI Platform Prediction e crea un'altra variabile di ambiente.

REGION="us-central1"

Crea il bucket Cloud Storage in questa regione e, in un secondo momento, utilizza la stessa regione per l'addestramento e la previsione. Esegui il comando seguente per creare il bucket se non esiste già:

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

Creazione e addestramento di un modello scikit-learn

Spesso non puoi utilizzare i dati nella loro forma non elaborata per addestrare un modello di machine learning. Anche quando è possibile, la pre-elaborazione dei dati prima di utilizzarli per l'addestramento talvolta può migliorare il modello.

Supponendo che prevedi che l'input per la previsione abbia lo stesso formato dei tuoi dati di addestramento, devi applicare un pre-trattamento identico durante l'addestramento e la previsione per assicurarti che il modello effettui previsioni coerenti.

In questa sezione, crea un modulo di preelaborazione e utilizzalo nell'addestramento. Quindi, esporta un pre-processore con le caratteristiche apprese durante l'addestramento da utilizzare più avanti nella routine di previsione personalizzata.

Installa le dipendenze per l'addestramento locale

L'addestramento locale richiede diverse dipendenze:

pip install numpy>=1.16.0 scikit-learn==0.20.2

Scrivi il preprocessore

La scalatura dei dati di addestramento in modo che ogni colonna di funzionalità numerica abbia una media di 0 e una deviazione standard di 1 può migliorare il tuo modello.

Crea preprocess.py, che contiene un corso per eseguire questa scalabilità:

import numpy as np

class MySimpleScaler(object):
  def __init__(self):
    self._means = None
    self._stds = None

  def preprocess(self, data):
    if self._means is None: # during training only
      self._means = np.mean(data, axis=0)

    if self._stds is None: # during training only
      self._stds = np.std(data, axis=0)
      if not self._stds.all():
        raise ValueError('At least one column has standard deviation of 0.')

    return (data - self._means) / self._stds

Tieni presente che un'istanza di MySimpleScaler salva le medie e le deviazioni standard di ogni colonna di funzionalità al primo utilizzo. Poi utilizza queste statistiche di riepilogo per scalare i dati che incontra in seguito.

In questo modo puoi memorizzare le caratteristiche della distribuzione di addestramento e utilizzarle per una pre-elaborazione identica al momento della previsione.

Addestra il modello

Poi, utilizza preprocess.MySimpleScaler per pre-elaborare i dati dell'iris e addestra un modello utilizzando scikit-learn.

Al termine, esporta il modello addestrato come file joblib (.joblib) ed esporta la tua istanza MySimpleScaler come file pickle (.pkl):

import pickle

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib

from preprocess import MySimpleScaler

iris = load_iris()
scaler = MySimpleScaler()
X = scaler.preprocess(iris.data)
y = iris.target

model = RandomForestClassifier()
model.fit(X, y)

joblib.dump(model, 'model.joblib')
with open ('preprocessor.pkl', 'wb') as f:
  pickle.dump(scaler, f)

Eseguire il deployment di una routine di previsione personalizzata

Per eseguire il deployment di una routine di previsione personalizzata per fornire le previsioni del modello addestrato, segui questi passaggi:

  • Creare un predittore personalizzato per gestire le richieste
  • Impacchetta il predittore e il modulo di preelaborazione
  • Carica gli elementi del modello e il codice personalizzato in Cloud Storage
  • Esegui il deployment della routine di previsione personalizzata in AI Platform Prediction

Creare un predittore personalizzato

Per eseguire il deployment di una routine di previsione personalizzata, devi creare una classe che implementi l'interfaccia Predictor. In questo modo, AI Platform Prediction sa come caricare il modello e come gestire le richieste di previsione.

Scrivi il seguente codice in predictor.py:

import os
import pickle

import numpy as np
from sklearn.datasets import load_iris
from sklearn.externals import joblib

class MyPredictor(object):
  def __init__(self, model, preprocessor):
    self._model = model
    self._preprocessor = preprocessor
    self._class_names = load_iris().target_names

  def predict(self, instances, **kwargs):
    inputs = np.asarray(instances)
    preprocessed_inputs = self._preprocessor.preprocess(inputs)
    if kwargs.get('probabilities'):
      probabilities = self._model.predict_proba(preprocessed_inputs)
      return probabilities.tolist()
    else:
      outputs = self._model.predict(preprocessed_inputs)
      return [self._class_names[class_num] for class_num in outputs]

  @classmethod
  def from_path(cls, model_dir):
    model_path = os.path.join(model_dir, 'model.joblib')
    model = joblib.load(model_path)

    preprocessor_path = os.path.join(model_dir, 'preprocessor.pkl')
    with open(preprocessor_path, 'rb') as f:
      preprocessor = pickle.load(f)

    return cls(model, preprocessor)

Tieni presente che, oltre a utilizzare il pre-processore definito durante l'addestramento, questo predittore esegue un passaggio di post-elaborazione che converte l'output della previsione dagli indici di classe (0, 1 o 2) in stringhe di etichetta (il nome del tipo di fiore).

Tuttavia, se l'algoritmo di previsione riceve un argomento della parola chiave probabilities con il valore True, restituisce un array di probabilità, che indica la probabilità che ciascuna delle tre classi sia l'etichetta corretta (in base al modello). L'ultima parte di questo tutorial mostra come fornire un argomento parola chiave durante la previsione.

Esegui il packaging del codice personalizzato

Devi pacchettizzare predictor.py e preprocess.py come pacchetto di distribuzione di origine .tar.gz e fornirlo ad AI Platform Prediction in modo che possa utilizzare il tuo codice personalizzato per fornire le previsioni.

Scrivi quanto segue setup.py per definire il pacchetto:

from setuptools import setup

setup(
    name='my_custom_code',
    version='0.1',
    scripts=['predictor.py', 'preprocess.py'])

Quindi, esegui il seguente comando per creare dist/my_custom_code-0.1.tar.gz:

python setup.py sdist --formats=gztar

Carica gli elementi del modello e il codice personalizzato in Cloud Storage

Prima di poter eseguire il deployment del modello per la pubblicazione, AI Platform Prediction deve accedere ai seguenti file in Cloud Storage:

  • model.joblib (elemento del modello)
  • preprocessor.pkl (elemento del modello)
  • my_custom_code-0.1.tar.gz (codice personalizzato)

Gli elementi del modello devono essere archiviati insieme in una directory del modello, a cui il predittore può accedere come argomento model_dir nel metodo della classe from_path. Il codice personalizzato non deve trovarsi nella stessa directory. Esegui i seguenti comandi per caricare i file:

gcloud storage cp ./dist/my_custom_code-0.1.tar.gz gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz
gcloud storage cp model.joblib preprocessor.pkl gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/

Esegui il deployment della routine di previsione personalizzata

Crea una risorsa modello e una risorsa versione per eseguire il deployment della routine di previsione personalizzata. Per prima cosa, definisci le variabili di ambiente con i nomi delle risorse:

MODEL_NAME='IrisPredictor'
VERSION_NAME='v1'

Poi crea il tuo modello:

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

Poi, crea una versione. In questo passaggio, fornisci i percorsi agli elementi e al codice personalizzato che hai caricato su Cloud Storage:

gcloud components install beta

gcloud beta ai-platform versions create $VERSION_NAME \
  --model $MODEL_NAME \
  --runtime-version 1.13 \
  --python-version 3.5 \
  --origin gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/ \
  --package-uris gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz \
  --prediction-class predictor.MyPredictor

Scopri di più sulle opzioni che devi specificare quando implementi una routine di previsione personalizzata.

Pubblicazione di previsioni online

Prova il deployment inviando una richiesta di previsione online. Innanzitutto, installa la libreria client delle API di Google per Python:

pip install --upgrade google-api-python-client

Quindi, invia due istanze di dati sull'iris alla versione di cui è stato eseguito il deployment eseguendo il seguente codice Python:

import googleapiclient.discovery

instances = [
  [6.7, 3.1, 4.7, 1.5],
  [4.6, 3.1, 1.5, 0.2],
]

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

response = service.projects().predict(
    name=name,
    body={'instances': instances}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])

['versicolor', 'setosa']

Invio di argomenti di parole chiave

Quando invii una richiesta di previsione a una routine di previsione personalizzata, puoi fornire campi aggiuntivi nel corpo della richiesta. Il metodo predict del predittore li riceve come campi del dizionario **kwargs.

Il seguente codice invia la stessa richiesta di prima, ma questa volta aggiunge un probabilities campo al corpo della richiesta:

response = service.projects().predict(
    name=name,
    body={'instances': instances, 'probabilities': True}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])

[[0.0, 1.0, 0.0], [1.0, 0.0, 0.0]]

Pulizia

Per eliminare tutte le risorse Google Cloud utilizzate in questo progetto, puoi eliminare il progetto Google Cloud utilizzato per il tutorial.

In alternativa, puoi ripulire le singole risorse eseguendo i seguenti comandi:

# Delete version resource
gcloud ai-platform versions delete $VERSION_NAME --quiet --model $MODEL_NAME

# Delete model resource
gcloud ai-platform models delete $MODEL_NAME --quiet

# Delete Cloud Storage objects that were created
gcloud storage rm gs://$BUCKET_NAME/custom_prediction_routine_tutorial --recursive

Passaggi successivi