Creazione di una routine di previsione personalizzata con Keras

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

Questo tutorial mostra come eseguire il deployment di un modello Keras 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 scalatura e il post-trattamento dell'output di previsione mediante la conversione delle uscite di probabilità softmax in stringhe di etichette.

Il tutorial illustra diversi passaggi:

  • Addestramento di un semplice modello Keras localmente
  • 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

Creare e addestrare un modello Keras

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 scikit-learn 'tensorflow=2.3'

Scrivi il pre-processore

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 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, quindi addestra una semplice rete neurale utilizzando Keras.

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

import pickle

from sklearn.datasets import load_iris
import tensorflow as tf

from preprocess import MySimpleScaler

iris = load_iris()
scaler = MySimpleScaler()
num_classes = len(iris.target_names)
X = scaler.preprocess(iris.data)
y = tf.keras.utils.to_categorical(iris.target, num_classes=num_classes)

model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(25, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(num_classes, activation=tf.nn.softmax))
model.compile(
  optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X, y, epochs=10, batch_size=1)

model.save('model.h5')
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
import tensorflow as tf

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)
    outputs = self._model.predict(preprocessed_inputs)
    if kwargs.get('probabilities'):
      return outputs.tolist()
    else:
      return [self._class_names[index] for index in np.argmax(outputs, axis=1)]

  @classmethod
  def from_path(cls, model_dir):
    model_path = os.path.join(model_dir, 'model.h5')
    model = tf.keras.models.load_model(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 softmax della rete neurale (un array che indica la probabilità che ogni etichetta sia quella corretta) nell'etichetta con la probabilità più alta.

Tuttavia, se il predittore riceve un argomento parola chiave probabilities con il valore True, restituisce l'array di probabilità. L'ultima parte di questo tutorial mostra come fornire questo argomento parola chiave.

Esegui il packaging del codice personalizzato

Devi pacchettizzare predictor.py e preprocess.py come pacchetto di distribuzione di origine .tar.gz e fornire il pacchetto 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.h5 (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.h5 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

Successivamente, crea una versione. In questo passaggio, fornisci i percorsi degli elementi e del 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 2.3 \
  --python-version 3.7 \
  --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.0019204545533284545, 0.8623144626617432, 0.13576509058475494], [0.999488353729248, 0.000511515187099576, 1.293626752385535e-07]]

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