Creazione di una routine di previsione personalizzata con Keras

Logo Colab corsa 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 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 in locale di un semplice modello Keras
  • Creazione e deployment di una routine di previsione personalizzata su AI Platform Prediction
  • Fornisce 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 incluso nel documento scikit-learn libreria di Google.

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 di più sull'utilizzo di questo modello con AI Platform Prediction rispetto 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 eseguire 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 tuo pacchetto di addestramento addestrato al modello.

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.

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

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 che hai 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 il modello addestrato gli artefatti 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 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 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 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, 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 in locale richiede diverse dipendenze:

pip install numpy scikit-learn 'tensorflow=2.3'

Scrivi il preprocessore

Scalare i dati di addestramento in modo che ogni colonna di caratteristiche numeriche abbia una media pari a 0 e una la deviazione standard di 1 può migliorare modello.

Crea preprocess.py, che contiene una classe per eseguire questo ridimensionamento:

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 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, 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 pubblicare previsioni dal tuo segui questi passaggi:

  • Creare un predittore personalizzato per gestire le richieste
  • Impacchetta il predittore e il modulo di preelaborazione
  • Carica gli artefatti del modello e il codice personalizzato su 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 il predittore a riga di comando. 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 preprocessore che hai definito durante questo predittore esegue una fase di post-elaborazione che converte l'output softmax della rete (una matrice che indica la probabilità che ogni etichetta venga quella corretta) nell'etichetta con la probabilità più alta.

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

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 artefatti del modello e codice personalizzato su 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 artefatti del modello devono essere archiviati insieme in una directory del modello, Il predittore può accedere come argomento model_dir nella sua 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 tua routine di previsione personalizzata

Crea una risorsa modello e una risorsa versione per eseguire il deployment della routine di previsione personalizzata. Innanzitutto, definisci le variabili di ambiente con i nomi delle tue 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 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.

Offerta di previsioni online

Prova il tuo deployment inviando una richiesta di previsione online. Innanzitutto, installa la libreria client dell'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 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 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