Creazione di una routine di previsione personalizzata con Keras

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.
Logo Colab Esegui questo tutorial come blocco note in Colab Logo di GitHub Visualizza il blocco note su GitHub

Questo tutorial mostra come eseguire il deployment di un modello Keras addestrato in AI Platform Prediction e pubblicare previsioni utilizzando una routine di previsione personalizzata. In questo modo puoi personalizzare la risposta di AI Platform Prediction a ogni richiesta di previsione.

In questo esempio, utilizzerai una routine di previsione personalizzata per pre-elaborare l'input di previsione scalandolo e per post-output dell'output di previsione convertendo gli output di probabilità softmax in stringhe di etichette.

Il tutorial illustra vari passaggi:

  • Addestrare un semplice modello Keras in locale
  • Creazione e deployment di una routine di previsione personalizzata in AI Platform Prediction
  • Gestione delle richieste di previsione del deployment in questione

Set di dati

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

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

Obiettivo

L'obiettivo è addestrare un modello che utilizza le misurazioni di un fiore come input per prevedere il tipo di iride.

Questo tutorial è incentrato sull'utilizzo di questo modello con AI Platform Prediction rispetto alla progettazione 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 al tuo utilizzo previsto.

Prima di iniziare

Prima di poter addestrare ed eseguire il deployment di un modello in AI Platform Prediction, devi eseguire diverse operazioni:

  • Configura l'ambiente di sviluppo locale.
  • Configurare 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.

Configurare l'ambiente di sviluppo locale

Per completare il tutorial, occorre quanto segue:

  • Python 3
  • Virtualenv
  • Google Cloud SDK

La guida di Google Cloud per configurare un ambiente di sviluppo Python fornisce istruzioni dettagliate per soddisfare questi requisiti. I passaggi seguenti forniscono un insieme condensato di istruzioni:

  1. Installa Python. 3.

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

  3. Attiva l'ambiente.

  4. Per installare Google Cloud SDK, completa i passaggi riportati nella sezione seguente.

Configura il tuo progetto Google Cloud

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Abilita le API AI Platform Training & Prediction and Compute Engine.

    Abilita le API

  5. Installa Google Cloud CLI.
  6. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:

    gcloud init
  7. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  8. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  9. Abilita le API AI Platform Training & Prediction and Compute Engine.

    Abilita le API

  10. Installa Google Cloud CLI.
  11. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:

    gcloud init

Autenticare l'account GCP

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

  1. Crea un account di servizio:

    1. In Google Cloud Console, 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 > AI Platform Admin (Amministratore di AI Platform).
    6. Fai clic su Aggiungi un altro ruolo.
    7. Fai clic sul campo Seleziona un ruolo. In Tutti i ruoli, seleziona Archiviazione > Amministratore oggetti Storage.

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

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

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

    1. In Google Cloud Console, 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. Il file di una 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 che contiene la chiave dell'account di servizio. Questa variabile si applica solo alla sessione shell corrente, quindi se apri una nuova sessione, impostala di nuovo.

Crea un bucket Cloud Storage

Per eseguire il deployment di una routine di previsione personalizzata, devi caricare gli artefatti del modello addestrato e il codice personalizzato in 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 un'area geografica in cui AI Platform Prediction è disponibile e crea un'altra variabile di ambiente.

REGION="us-central1"

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

gsutil mb -l $REGION gs://$BUCKET_NAME

Creazione e addestramento di un modello Keras

Spesso non puoi utilizzare i dati nella loro forma non elaborata per addestrare un modello di machine learning. Anche quando puoi, pre-elaborare i dati prima di utilizzarli per l'addestramento a volte può migliorare il tuo modello.

Supponendo che l'input per la previsione abbia lo stesso formato dei dati di addestramento, devi applicare una pre-elaborazione identica durante l'addestramento e la previsione per garantire che il modello preveda previsioni coerenti.

In questa sezione, crea un modulo di pre-elaborazione e utilizzalo come parte dell'addestramento. Quindi esporta un preprocessore con le caratteristiche apprese durante l'addestramento per utilizzarlo in seguito nella tua routine di previsione personalizzata.

Installare le dipendenze per l'addestramento locale

L'addestramento a livello locale richiede diverse dipendenze:

pip install numpy scikit-learn 'tensorflow=2.3'

Scrivi il pre-responsabile

Scalabilità dei dati di addestramento in modo che ogni colonna delle caratteristiche numeriche abbia una media di 0 e una deviazione standard di 1 può migliorare il tuo modello.

Crea preprocess.py, che contiene una classe 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 il mezzo e le deviazioni standard di ogni colonna di funzionalità al primo utilizzo. Quindi utilizza queste statistiche di riepilogo per scalare i dati raccolti successivamente.

Questo consente di archiviare le caratteristiche della distribuzione di addestramento e di utilizzarle per la pre-elaborazione identica al momento della previsione.

Addestra il modello

Quindi, utilizza preprocess.MySimpleScaler per pre-elaborare i dati di iris, quindi addestra una rete neurale semplice utilizzando Keras.

Alla fine, esporta il tuo modello Keras addestrato come file HDF5 (.h5) ed esporta la tua istanza MySimpleScaler come file sottaceto (.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)

Deployment di una routine di previsione personalizzata

Per eseguire il deployment di una routine di previsione personalizzata per gestire le previsioni del modello addestrato, procedi nel seguente modo:

  • Creare un predittore personalizzato per gestire le richieste
  • Pacchettizza il tuo predittore e il modulo di pre-elaborazione
  • Carica gli artefatti del modello e il codice personalizzato in Cloud Storage
  • Esegui il deployment della tua 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 del predittore. Questo indica ad AI Platform Prediction 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 preprocessore definito durante l'addestramento, questo predittore esegue un passaggio post-elaborazione che converte l'output softmax della rete neurale (un array che indica la probabilità di ogni etichetta è quella corretta) nell'etichetta con la probabilità più elevata.

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

Crea un pacchetto di 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 pubblicare previsioni.

Scrivi il seguente 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 comando seguente per creare dist/my_custom_code-0.1.tar.gz:

python setup.py sdist --formats=gztar

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

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

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

Gli artefatti del modello devono essere archiviati insieme in una directory del modello, a cui il predittore può accedere come argomento model_dir nel metodo from_path della classe. Non è necessario che il codice personalizzato si trovi nella stessa directory. Esegui questi comandi per caricare i file:

gsutil cp ./dist/my_custom_code-0.1.tar.gz gs://$BUCKET_NAME/custom_prediction_routine_tutorial/my_custom_code-0.1.tar.gz
gsutil cp model.h5 preprocessor.pkl gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/

Esegui il deployment della tua routine di previsione personalizzata

Crea una versione di una risorsa e una versione risorsa per eseguire il deployment della tua 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

Crea una versione. In questo passaggio, fornisci i percorsi agli artefatti e al codice personalizzato caricati in 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 esegui il deployment di una routine di previsione personalizzata.

Pubblicazione di previsioni online

Prova il tuo 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 di iris alla versione di cui hai eseguito il deployment eseguendo questo 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 della parola 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 viene ricevuto come campi del dizionario **kwargs.

Il seguente codice invia la stessa richiesta di prima, ma questa volta aggiunge un campo probabilities 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 pulire tutte le risorse GCP utilizzate in questo progetto, puoi eliminare il progetto GCP che hai utilizzato per il tutorial.

In alternativa, puoi pulire le singole risorse eseguendo questi 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
gsutil -m rm -r gs://$BUCKET_NAME/custom_prediction_routine_tutorial

Passaggi successivi