Creazione di una routine di previsione personalizzata con scikit-learn

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

Panoramica

Questo tutorial mostra come eseguire il deployment di un modello scikit-learn addestrato in Previsione di AI Platform 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 pre-elaborare tramite la scalabilità e l'elaborazione dell'output della previsione convertendo i numeri delle classi in stringhe di etichette.

Il tutorial illustra diversi passaggi:

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

Set di dati

Questo tutorial utilizza R.A. Set di dati Iris di Fisher, un piccolo set di dati molto diffuso per provare le tecniche di machine learning. Ogni istanza ha quattro caratteristiche, che sono misure diverse di un fiore, e un'etichetta target che lo contrassegna come uno dei tre tipi di iris: Iris setosa, Iris versicolorour 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 che tipo di iris sia.

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 di più su AI Platform Prediction prezzi e Cloud Storage prezzi, e utilizza la funzionalità Prezzi Calcolatrice per generare una stima dei costi in base all'utilizzo previsto.

Prima di iniziare

Devi fare diverse cose prima di poter addestrare un modello ed eseguirne il deployment AI Platform Prediction:

  • Configura il tuo ambiente di sviluppo locale.
  • Configura un progetto Google Cloud con la fatturazione e i necessari API abilitate.
  • Crea un bucket Cloud Storage per archiviare il pacchetto di addestramento e il modello addestrato.

Configurare l'ambiente di sviluppo locale

Per completare questo tutorial sono necessari i seguenti requisiti:

  • Python 3
  • virtualenv
  • Google Cloud SDK

Guida di Google Cloud alla configurazione di uno sviluppo Python ambiente 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 nella sezione seguente per installare 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 un 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. Nel campo Nome account di servizio, inserisci un nome.
    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 > Amministratore oggetti Storage.

    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 è stato creato.
    2. Fai clic su Chiavi.
    3. Fai clic su Aggiungi chiave, quindi su Crea nuova chiave.
    4. Fai clic su Crea. Sul computer viene scaricato un file della chiave JSON.
    5. Fai clic su Chiudi.

  3. Imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS al 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 AI Platform Prediction è disponibile e creo 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 questo comando 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 a volte 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 pretrattamento identico durante l'addestramento e la previsione per assicurarti che il modello effettui previsioni coerenti.

In questa sezione, creerai un modulo di pre-elaborazione da utilizzare come parte dell'addestramento. Quindi esporta un preprocessore con le caratteristiche apprese durante l'addestramento per in un secondo momento nella tua 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 tuo 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'apposita classe:

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 lo standard deviazioni di ciascuna colonna delle caratteristiche al primo utilizzo. Poi utilizza questi dati di riepilogo per scalare i dati che incontra in seguito.

Ciò ti consente di archiviare le caratteristiche della distribuzione dell'addestramento e di 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 pubblicare previsioni dal tuo segui questi passaggi:

  • Crea un predittore personalizzato per gestire le richieste
  • Pacchettizzazione del predittore e del modulo di pre-elaborazione
  • Carica gli elementi del modello e il codice personalizzato in Cloud Storage
  • Esegui il deployment della routine di previsione personalizzata in AI Platform Prediction

crea un predittore personalizzato

Per eseguire il deployment di una routine di previsione personalizzata, devi creare una classe che implementi il predittore a riga di comando. Questo indica ad AI Platform Prediction come caricare il modello e come gestirlo 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 il predittore riceve un argomento parola chiave probabilities con il parametro valore True, restituisce invece una matrice 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.

Crea un pacchetto con il 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 richiede l'accesso ai file seguenti 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 questo comando 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 tua 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

Successivamente, crea una versione. In questo passaggio, fornisci i percorsi degli artefatti 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 esegui il deployment di 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 iris alla versione di cui hai eseguito il deployment eseguendo con 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: fornisci campi aggiuntivi sulla tua richiesta del testo. 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 ripulire tutte le risorse Google Cloud utilizzate in questo progetto, puoi eliminare la risorsa progetto che hai usato 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