 Esegui
questo tutorial come blocco note in Colab
|
Visualizza il blocco note su GitHub
|
Questo tutorial mostra come eseguire il deployment di un modello Keras addestrato in AI Platform Prediction e fornire previsioni utilizzando una routine di previsione personalizzata. Ciò consente di 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 l'input di previsione scalandolo e per post-elaborare l'output della previsione convertendo gli output di probabilità softmax in stringhe di etichetta.
Il tutorial illustra diversi passaggi:
- Addestramento locale di un semplice modello Keras
- Creazione e deployment di una routine di previsione personalizzata in AI Platform Prediction
- Gestione 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 popolare per provare le tecniche di machine learning. Ogni istanza presenta quattro caratteristiche numeriche, che sono le diverse misure di un fiore, e un'etichetta target che lo contrassegna come uno dei tre tipi di iride: Iris setosa, Iris versicolour o Iris virginica.
Questo tutorial utilizza la copia del set di dati Iris incluso nella libreria scikit-learn.
Scopo
L'obiettivo è addestrare un modello che utilizzi le misure di un fiore come input per prevedere il tipo di iride.
Questo tutorial è incentrato più sull'utilizzo di questo modello con AI Platform Prediction che sulla progettazione del modello stesso.
Costi
Questo tutorial utilizza i componenti fatturabili di Google Cloud:
- AI Platform Prediction
- Cloud Storage
Scopri di più sui prezzi di AI Platform Prediction e sui prezzi di Cloud Storage e utilizzare il Calcolatore prezzi per generare una stima dei costi in base all'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 fatturazione e le API necessarie abilitate.
- Creare un bucket Cloud Storage per archiviare il pacchetto di addestramento e il modello addestrato.
Configura l'ambiente di sviluppo locale
Per completare questo tutorial, sono necessari:
- 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 seguenti passaggi forniscono un insieme ridotto di istruzioni:
Installa virtualenv e crea un ambiente virtuale che utilizza Python 3.
Attiva l'ambiente.
Completa i passaggi nella sezione seguente per installare Google Cloud SDK.
Configura il tuo progetto Google Cloud
- 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.
-
Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API AI Platform Training & Prediction and Compute Engine.
- Installa Google Cloud CLI.
-
Per initialize gcloud CLI, esegui questo comando:
gcloud init
-
Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API AI Platform Training & Prediction and Compute Engine.
- Installa Google Cloud CLI.
-
Per initialize gcloud CLI, esegui questo comando:
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 alla chiave dell'account di servizio.
-
Crea un account di servizio:
-
Nella console Google Cloud, vai alla pagina Crea account di servizio.
- Inserisci un nome nel campo Nome account di servizio.
- (Facoltativo) Nel campo Descrizione account di servizio, inserisci una descrizione.
- Fai clic su Crea.
- Fai clic sul campo Seleziona un ruolo. In Tutti i ruoli, seleziona AI Platform > Amministratore AI Platform.
- Fai clic su Aggiungi un altro ruolo.
-
Fai clic sul campo Seleziona un ruolo. In Tutti i ruoli, seleziona Archiviazione > Amministratore oggetti Storage.
-
Fai clic su Fine per creare l'account di servizio.
Non chiudere la finestra del browser. Lo utilizzerai nel passaggio successivo.
-
-
Crea una chiave dell'account di servizio per l'autenticazione:
- Nella console Google Cloud, fai clic sull'indirizzo email dell'account di servizio che hai creato.
- Fai clic su Chiavi.
- Fai clic su Aggiungi chiave, quindi su Crea nuova chiave.
- Fai clic su Crea. Sul computer viene scaricato un file della chiave JSON.
- Fai clic su Chiudi.
-
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 di shell attuale. Pertanto, 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 artefatti del modello addestrati 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 è disponibile AI Platform Prediction e crea un'altra variabile di ambiente.
REGION="us-central1"
Crea il tuo bucket Cloud Storage in questa regione e, in seguito, utilizza la stessa regione per l'addestramento e la previsione. Esegui questo comando per creare il bucket, se non esiste già:
gsutil mb -l $REGION gs://$BUCKET_NAME
Creazione e addestramento di un modello Keras
Spesso, non è possibile 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 l'input per la previsione abbia lo stesso formato dei dati di addestramento, devi applicare la stessa pre-elaborazione durante l'addestramento e la previsione per assicurarti che il modello effettui previsioni coerenti.
In questa sezione, crea un modulo di pre-elaborazione e utilizzalo come parte della formazione. Poi esporta un preprocessore con caratteristiche apprese durante l'addestramento da usare in seguito nella tua 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'
Scrivere il preprocessore
Scalare i dati di addestramento in modo che ogni colonna di caratteristiche numeriche abbia una media pari a 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 le medie e le deviazioni standard di ogni colonna delle caratteristiche al primo utilizzo. Poi utilizza queste statistiche riepilogative
per scalare i dati rilevati in seguito.
Ciò 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, usa preprocess.MySimpleScaler per pre-elaborare i dati relativi all'iride, quindi addestra una
semplice rete neurale con Keras.
Al termine, esporta il tuo modello Keras addestrato come file HDF5 (.h5) ed esporta l'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)
Deployment di una routine di previsione personalizzata
Per eseguire il deployment di una routine di previsione personalizzata per fornire previsioni dal modello addestrato, segui questi passaggi:
- Crea un predittore personalizzato per gestire le richieste
- pacchettizza il predittore e il modulo di pre-elaborazione
- Carica gli artefatti del modello e il tuo codice personalizzato in Cloud Storage
- Esegui il deployment della tua 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 l'interfaccia Predittore. Questo indica ad AI Platform Prediction come caricare il modello e come gestire le richieste di previsione.
Scrivi il seguente codice a 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 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 di parola chiave probabilities con il valore True, restituisce invece l'array di probabilità. L'ultima parte di questo tutorial mostra come fornire questo argomento per le parole chiave.
Crea un pacchetto di codice personalizzato
Devi pacchettizzare predictor.py e preprocess.py come pacchetto di distribuzione sorgente .tar.gz e fornire il pacchetto ad AI Platform Prediction in modo che possa utilizzare il tuo codice personalizzato per generare 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 questo comando 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 su 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 suo metodo della classe from_path.
Il codice personalizzato non deve necessariamente trovarsi nella stessa directory. Esegui questi comandi per caricare i tuoi 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 risorsa model e una risorsa model per eseguire il deployment della tua routine di previsione personalizzata. Definisci innanzitutto 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
Quindi, crea una versione. In questo passaggio, fornisci i percorsi per gli artefatti e il codice personalizzato che hai caricato 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 da specificare quando esegui il deployment di una routine di previsione personalizzata.
Fornitura 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 hai 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 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 predettore riceve questi dati come campi del dizionario **kwargs.
Il codice seguente 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]]
Eseguire la pulizia
Per eseguire la pulizia di tutte le risorse Google Cloud utilizzate in questo progetto, puoi eliminare il progetto Google Cloud che hai utilizzato per il tutorial.
In alternativa, puoi eseguire la pulizia delle singole risorse eseguendo i comandi seguenti:
# 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
- Scopri di più sulle routine di previsione personalizzate.
- Scopri come esportare un modello per fornire previsioni senza una routine di previsione personalizzata.