 corsa
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 su AI Platform Prediction. fornire previsioni utilizzando una previsione personalizzata di Cloud Shell. In questo modo puoi personalizzare il modo in cui AI Platform Prediction risponde a ogni previsione richiesta.
In questo esempio, utilizzerai una routine di previsione personalizzata per pre-elaborare tramite la scalabilità e l'elaborazione dell'output della previsione conversione softmax la probabilità nelle stringhe di etichetta.
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 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 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 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 che tipo di iris sia.
Questo tutorial si concentra di più sull'utilizzo di questo modello con AI Platform Prediction rispetto sulla progettazione 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
Prima di poter addestrare un modello ed eseguirne il deployment, devi prima 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 tuo pacchetto di addestramento addestrato al modello.
Configura il tuo ambiente di sviluppo locale
Per completare questo tutorial, è necessario quanto segue:
- Python 3
- virtualenv
- Google Cloud SDK
Guida di Google Cloud alla configurazione di uno sviluppo Python ambiente fornisce istruzioni dettagliate per soddisfare questi requisiti. Le seguenti i passaggi forniscono un insieme breve di istruzioni:
Installa virtualenv e creerai un ambiente virtuale che utilizza Python 3.
Attivare l'ambiente.
Completa i passaggi nella sezione seguente per installare Google Cloud SDK.
Configura il 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.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API AI Platform Training & Prediction and Compute Engine.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API AI Platform Training & Prediction and Compute Engine.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
Autenticare l'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.
-
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 Spazio di 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 è stato 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 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 tuo bucket Cloud Storage in questa regione e, successivamente, utilizza nella 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 è possibile utilizzare i dati nel loro formato non elaborato per addestrare un modello di machine learning un modello di machine learning. Anche quando è possibile, pre-elaborare i dati prima di utilizzarli per l'addestramento a volte possono migliorare il tuo modello.
Supponendo che ti aspetti che l'input per la previsione abbia lo stesso formato devi applicare la stessa pre-elaborazione durante l'addestramento e per assicurare che il modello faccia 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 in locale richiede diverse dipendenze:
pip install numpy scikit-learn 'tensorflow=2.3'
Scrivi il tuo 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 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'iride, poi addestra un
ovvero una semplice rete neurale con Keras.
Al termine, esporta il modello Keras addestrato come file HDF5 (.h5) ed esportalo.
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)
Deployment di una routine di previsione personalizzata
Per eseguire il deployment di una routine di previsione personalizzata per pubblicare previsioni dal tuo procedi nel seguente modo:
- Crea un predittore personalizzato per gestire le richieste
- Pacchettizzazione del predittore e del modulo di pre-elaborazione
- Carica gli artefatti del modello e il codice personalizzato su Cloud Storage
- Esegui il deployment della tua routine di previsione personalizzata su 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
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
il valore True, restituisce invece la matrice della probabilità. L'ultima parte
mostra come fornire questo argomento parola chiave.
Crea un pacchetto con il codice personalizzato
Devi pacchettizzare predictor.py e preprocess.py come origine .tar.gz
di distribuzione del pacchetto e lo fornirà ad AI Platform Prediction in modo che possa
utilizzare il codice personalizzato
per fornire 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 questo comando per crearedist/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 distribuzione, AI Platform Prediction deve accedere ai file seguenti 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,
Il predittore può accedere come argomento model_dir nella sua classe from_path
.
Il codice personalizzato non deve trovarsi necessariamente 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.h5 preprocessor.pkl gs://$BUCKET_NAME/custom_prediction_routine_tutorial/model/
Esegui il deployment della tua routine di previsione personalizzata
Creare una risorsa di modello e una versione delle risorse per eseguire il deployment della tua routine di previsione personalizzata. Innanzitutto, definisci le variabili di ambiente con i nomi delle tue risorse:
MODEL_NAME='IrisPredictor'
VERSION_NAME='v1'
Quindi, crea il tuo modello:
gcloud ai-platform models create $MODEL_NAME \
--regions $REGION
Quindi, 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 esegui il deployment di 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 degli argomenti delle 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 dell'elemento **kwargs
dizionario.
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]]
esegui la pulizia
Per eseguire la pulizia di tutte le risorse Google Cloud utilizzate in questo progetto, puoi eliminare la risorsa progetto che hai usato per il tutorial.
In alternativa, puoi pulire le singole risorse eseguendo questo :
# 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
- Scopri di più sulla previsione personalizzata .
- Scopri come esportare un modello per fornire previsioni senza una routine di previsione personalizzata.