 Esegui
questo tutorial come blocco note in Colab
|
Visualizza il blocco note su GitHub
|
Questo tutorial mostra come addestrare una rete neurale su AI Platform utilizzando l'API sequenziale Keras e come fornire previsioni da quel modello.
Keras è un'API di alto livello per la creazione e l'addestramento di modelli di deep learning. tf.keras è l'implementazione di TensorFlow di questa API.
Le prime due parti del tutorial illustrano l'addestramento di un modello su AI Platform utilizzando codice Keras precompilato, il deployment del modello addestrato su AI Platform e la fornitura di previsioni online dal modello di cui è stato eseguito il deployment.
L'ultima parte del tutorial illustra il codice di addestramento utilizzato per questo modello e ne verifica la compatibilità con AI Platform. Per saperne di più in generale sulla creazione di modelli di machine learning in Keras, leggi i tutorial su Keras di TensorFlow.
Set di dati
Questo tutorial utilizza il set di dati relativo al reddito del censimento degli Stati Uniti fornito da UC Irvine Machine Learning Repository. Questo set di dati contiene informazioni su persone provenienti da un database del Censimento del 1994, tra cui età, istruzione, stato civile, occupazione e se guadagnano più di 50.000 dollari all'anno.
Scopo
L'obiettivo è addestrare una rete neurale profonda (DNN) utilizzando Keras,che prevede se una persona guadagna più di 50.000 $all'anno (etichetta target) in base ad altre informazioni del censimento sulla persona (caratteristiche).
Questo tutorial è incentrato più sull'utilizzo di questo modello con AI Platform che sulla progettazione del modello stesso. Tuttavia, quando si creano sistemi di machine learning, è sempre importante tenere conto dei potenziali problemi e delle conseguenze indesiderate. Consulta l'esercizio relativo al corso accelerato sul machine learning sull'equità per saperne di più sulle fonti di bias nel set di dati del censimento e sull'equità del machine learning in modo più generale.
Costi
Questo tutorial utilizza i componenti fatturabili di Google Cloud (Google Cloud):
- AI Platform Training
- AI Platform Prediction
- Cloud Storage
Scopri di più sui prezzi di AI Platform Training, 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, devi eseguire diverse operazioni:
- Configura l'ambiente di sviluppo locale.
- Configura 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:
- Git
- 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
Quando invii un job di addestramento utilizzando Cloud SDK, carichi un pacchetto Python contenente il tuo codice di addestramento in un bucket Cloud Storage. AI Platform esegue il codice da questo pacchetto. In questo tutorial, AI Platform salva anche il modello addestrato risultante dal tuo job nello stesso bucket. Puoi quindi creare una versione del modello AI Platform in base a questo output per fornire previsioni online.
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 sono disponibili AI Platform Training e AI Platform Prediction e crea un'altra variabile di ambiente. Ad esempio:
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
Guida rapida per l'addestramento in AI Platform
Questa sezione del tutorial illustra come inviare un job di addestramento ad AI Platform. Questo job esegue un codice campione che utilizza Keras per addestrare una rete neurale profonda sui dati del censimento degli Stati Uniti. Restituisce il modello addestrato come directory SaveModel di TensorFlow nel tuo bucket Cloud Storage.
Ricevi codice e dipendenze di addestramento
Per prima cosa, scarica il codice di addestramento e modifica la directory di lavoro:
# Clone the repository of AI Platform samples
git clone --depth 1 https://github.com/GoogleCloudPlatform/cloudml-samples
# Set the working directory to the sample code directory
cd cloudml-samples/census/tf-keras
Tieni presente che il codice di addestramento è strutturato come un pacchetto Python nella sottodirectory trainer/:
# `ls` shows the working directory's contents. The `p` flag adds trailing
# slashes to subdirectory names. The `R` flag lists subdirectories recursively.
ls -pR
.: README.md requirements.txt trainer/ ./trainer: __init__.py model.py task.py util.py
Quindi, installa le dipendenze Python necessarie per addestrare il modello localmente:
pip install -r requirements.txt
Quando esegui il job di addestramento in AI Platform, le dipendenze sono preinstallate in base alla versione di runtime scelta.
Addestra il modello in locale
Prima di addestrare AI Platform, addestra il job in locale per verificare che la struttura e la pacchettizzazione dei file siano corrette.
Per un job complesso o che richiede molte risorse, puoi eseguire l'addestramento in locale su un piccolo campione del tuo set di dati per verificare il codice. Poi puoi eseguire il job su AI Platform per addestrare l'intero set di dati.
Questo esempio esegue un job relativamente rapido su un set di dati di piccole dimensioni, quindi l'addestramento locale e il job AI Platform eseguono lo stesso codice sugli stessi dati.
Esegui questo comando per addestrare un modello in locale:
# This is similar to `python -m trainer.task --job-dir local-training-output`
# but it better replicates the AI Platform environment, especially
# for distributed training (not applicable here).
gcloud ai-platform local train \
--package-path trainer \
--module-name trainer.task \
--job-dir local-training-output
Osserva i progressi dell'addestramento nel shell. Alla fine, l'applicazione di addestramento esporta il modello addestrato e stampa un messaggio come il seguente:
Model exported to: local-training-output/keras_export/1553709223
Addestra il modello utilizzando AI Platform
Quindi, invia un job di addestramento ad AI Platform. Viene eseguito il modulo di addestramento nel cloud ed esporta il modello addestrato in Cloud Storage.
Per prima cosa, assegna un nome al job di addestramento e scegli una directory all'interno del bucket Cloud Storage per salvare i file intermedi e di output. Impostale come variabili di ambiente. Ad esempio:
JOB_NAME="my_first_keras_job"
JOB_DIR="gs://$BUCKET_NAME/keras-job-dir"
Esegui questo comando per pacchettizzare la directory trainer/, caricala nel
--job-dir specificato e indica ad AI Platform di eseguire il modulo
trainer.task da quel pacchetto.
Il flag --stream-logs consente di visualizzare i log di addestramento nella shell. Puoi anche visualizzare i log e altri dettagli del job nella Google Cloud Console.
gcloud ai-platform jobs submit training $JOB_NAME \
--package-path trainer/ \
--module-name trainer.task \
--region $REGION \
--python-version 3.7 \
--runtime-version 1.15 \
--job-dir $JOB_DIR \
--stream-logs
Questa operazione potrebbe richiedere più tempo dell'addestramento locale, ma puoi osservare i progressi dell'addestramento nella shell in modo simile. Alla fine, il job di addestramento esporta il modello addestrato nel bucket Cloud Storage e stampa un messaggio simile al seguente:
INFO 2019-03-27 17:57:11 +0000 master-replica-0 Model exported to: gs://your-bucket-name/keras-job-dir/keras_export/1553709421 INFO 2019-03-27 17:57:11 +0000 master-replica-0 Module completed; cleaning up. INFO 2019-03-27 17:57:11 +0000 master-replica-0 Clean up finished. INFO 2019-03-27 17:57:11 +0000 master-replica-0 Task completed successfully.
Ottimizzazione degli iperparametri
Facoltativamente, puoi eseguire l'ottimizzazione degli iperparametri utilizzando il file di configurazione hptuning_config.yaml incluso. Questo file indica ad
AI Platform di ottimizzare le dimensioni del batch e il tasso di apprendimento per l'addestramento
su più prove per massimizzare l'accuratezza.
In questo esempio, il codice di addestramento utilizza un callback TensorBoard, che crea Summary
Event TensorFlow durante l'addestramento. AI Platform usa questi eventi per monitorare
la metrica che vuoi ottimizzare. Scopri di più sull'ottimizzazione degli iperparametri in AI Platform Training.
gcloud ai-platform jobs submit training ${JOB_NAME}_hpt \
--config hptuning_config.yaml \
--package-path trainer/ \
--module-name trainer.task \
--region $REGION \
--python-version 3.7 \
--runtime-version 1.15 \
--job-dir $JOB_DIR \
--stream-logs
Guida rapida per previsioni online in AI Platform
Questa sezione mostra come utilizzare AI Platform e il modello addestrato della sezione precedente per prevedere la fascia di reddito di una persona in base ad altre informazioni relative al censimento.
Creazione di risorse per modello e versione in AI Platform
Per fornire previsioni online utilizzando il modello che hai addestrato ed esportato nella guida rapida per l'addestramento, crea una risorsa model in AI Platform e una risorsa model al suo interno. La risorsa versione è ciò che usa effettivamente il modello addestrato per fornire le previsioni. Questa struttura ti consente di regolare e riaddestrare il modello più volte e di organizzare tutte le versioni insieme in AI Platform. Scopri di più su modelli e versioni.
Innanzitutto, assegna un nome e crea la risorsa del modello:
MODEL_NAME="my_first_keras_model"
gcloud ai-platform models create $MODEL_NAME \
--regions $REGION
Created ml engine model [projects/your-project-id/models/my_first_keras_model].
Quindi, crea la versione del modello. Il job di addestramento della guida rapida per l'addestramento ha esportato una directory SaveModel di TensorFlow con timestamp nel bucket Cloud Storage. AI Platform usa questa directory per creare una versione del modello. Scopri di più su SharedModel e AI Platform.
Potresti trovare il percorso di questa directory nei log del job di addestramento. Cerca una riga simile a:
Model exported to: gs://your-bucket-name/keras-job-dir/keras_export/1545439782
Esegui questo comando per identificare la directory savedModel e utilizzala per creare una risorsa della versione del modello:
MODEL_VERSION="v1"
# Get a list of directories in the `keras_export` parent directory. Then pick
# the directory with the latest timestamp, in case you've trained multiple
# times.
SAVED_MODEL_PATH=$(gsutil ls $JOB_DIR/keras_export | head -n 1)
# Create model version based on that SavedModel directory
gcloud ai-platform versions create $MODEL_VERSION \
--model $MODEL_NAME \
--region $REGION \
--runtime-version 1.15 \
--python-version 3.7 \
--framework tensorflow \
--origin $SAVED_MODEL_PATH
Prepara l'input per la previsione
Per ricevere previsioni valide e utili, devi pre-elaborare l'input per la previsione nello stesso modo in cui sono stati pre-elaborati i dati di addestramento. In un sistema di produzione, ti consigliamo di creare una pipeline di pre-elaborazione che possa essere utilizzata in modo identico durante l'addestramento e la previsione.
Per questo esercizio, utilizza il codice di caricamento dei dati del pacchetto di addestramento per selezionare un campione casuale dai dati di valutazione. Questi dati sono nella forma utilizzata per valutare l'accuratezza dopo ogni epoca di addestramento, quindi possono essere utilizzati per inviare previsioni di test senza ulteriore pre-elaborazione.
Apri l'interprete Python (python) dalla directory di lavoro attuale per eseguire i successivi snippet di codice:
from trainer import util
_, _, eval_x, eval_y = util.load_data()
prediction_input = eval_x.sample(20)
prediction_targets = eval_y[prediction_input.index]
prediction_input
| età | classe lavoro | education_num | marital_status | professione | relazione | gruppo etnico | capital_gain | capital_loss | hours_per_week | native_country | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 1979 | 0,901213 | 1 | 1,525542 | 2 | 9 | 0 | 4 | - 0,144792 | - 0,217132 | -0,437544 | 38 |
| 2430 | -0,922154 | 3 | - 0,419265 | 4 | 2 | 3 | 4 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
| 4214 | -1,213893 | 3 | - 0,030304 | 4 | 10 | 1 | 4 | - 0,144792 | - 0,217132 | 1,579979 | 38 |
| 10389 | -0,630415 | 3 | 0,358658 | 4 | 0 | 3 | 4 | - 0,144792 | - 0,217132 | -0,679647 | 38 |
| 14525 | -1,505632 | 3 | -1,586149 | 4 | 7 | 3 | 0 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
| 15040 | -0,119873 | 5 | 0,358658 | 2 | 2 | 0 | 4 | - 0,144792 | - 0,217132 | -0,841048 | 38 |
| 8409 | 0,244801 | 3 | 1,525542 | 2 | 9 | 0 | 4 | - 0,144792 | - 0,217132 | 1,176475 | 6 |
| 10628 | 0,098931 | 1 | 1,525542 | 2 | 9 | 0 | 4 | 0,886847 | - 0,217132 | - 0,034039 | 38 |
| 10942 | 0,390670 | 5 | - 0,030304 | 2 | 4 | 0 | 4 | - 0,144792 | - 0,217132 | 4,727315 | 38 |
| 5129 | 1,120017 | 3 | 1,136580 | 2 | 12 | 0 | 4 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
| 2096 | -1,286827 | 3 | - 0,030304 | 4 | 11 | 3 | 4 | - 0,144792 | - 0,217132 | -1,648058 | 38 |
| 12463 | -0,703350 | 3 | - 0,419265 | 2 | 7 | 5 | 4 | - 0,144792 | 4,502280 | -0,437544 | 38 |
| 8528 | 0,536539 | 3 | 1,525542 | 4 | 3 | 4 | 4 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
| 7093 | -1,359762 | 3 | - 0,419265 | 4 | 6 | 3 | 2 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
| 12565 | 0,536539 | 3 | 1,136580 | 0 | 11 | 2 | 2 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
| 5655 | 1,338821 | 3 | - 0,419265 | 2 | 2 | 0 | 4 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
| 2322 | 0,682409 | 3 | 1,136580 | 0 | 12 | 3 | 4 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
| 12652 | 0,025997 | 3 | 1,136580 | 2 | 11 | 0 | 4 | - 0,144792 | - 0,217132 | 0,369465 | 38 |
| 4755 | - 0,411611 | 3 | - 0,419265 | 2 | 11 | 0 | 4 | - 0,144792 | - 0,217132 | 1,176475 | 38 |
| 4413 | 0,390670 | 6 | 1,136580 | 4 | 4 | 1 | 4 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
Tieni presente che i campi categorici, come occupation, sono già stati convertiti in numeri interi (con la stessa mappatura utilizzata per l'addestramento). I campi numerici, come age, sono stati adattati al punteggio z.
Alcuni campi sono stati eliminati dai dati originali. Confronta l'input di previsione con i dati non elaborati per gli stessi esempi:
import pandas as pd
_, eval_file_path = util.download(util.DATA_DIR)
raw_eval_data = pd.read_csv(eval_file_path,
names=util._CSV_COLUMNS,
na_values='?')
raw_eval_data.iloc[prediction_input.index]
| età | classe lavoro | fnlwgt | education | education_num | marital_status | professione | relazione | gruppo etnico | genere | capital_gain | capital_loss | hours_per_week | native_country | income_bracket | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1979 | 51 | Pubblica amministrazione locale | 99064 | Master | 14 | Coniuge civile sposato | Specializzato in professione | Marito | Bianco | Maschile | 0 | 0 | 35 | Stati Uniti | <=50.000 |
| 2430 | 26 | Privato | 197967 | HS-grad | 9 | Mai sposato/a | Artigianato-riparazione | Tuo figlio | Bianco | Maschile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
| 4214 | 22 | Privato | 221694 | Università | 10 | Mai sposato/a | Servizio di protezione | Non in famiglia | Bianco | Maschile | 0 | 0 | 60 | Stati Uniti | <=50.000 |
| 10389 | 30 | Privato | 96480 | Assoc-voc | 11 | Mai sposato/a | Adm-clerical | Tuo figlio | Bianco | Femminile | 0 | 0 | 32 | Stati Uniti | <=50.000 |
| 14525 | 18 | Privato | 146225 | 10 | 6 | Mai sposato/a | Altro-servizio | Tuo figlio | Amer-indiano-eschimese | Femminile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
| 15040 | 37 | Self-emp-not-inc | 50096 | Assoc-voc | 11 | Coniuge civile sposato | Artigianato-riparazione | Marito | Bianco | Maschile | 0 | 0 | 30 | Stati Uniti | <=50.000 |
| 8409 | 42 | Privato | 102988 | Master | 14 | Coniuge civile sposato | Specializzato in professione | Marito | Bianco | Maschile | 0 | 0 | 55 | Ecuador | > 50.000 |
| 10628 | 40 | Pubblica amministrazione locale | 284086 | Master | 14 | Coniuge civile sposato | Specializzato in professione | Marito | Bianco | Maschile | 7688 | 0 | 40 | Stati Uniti | > 50.000 |
| 10942 | 44 | Self-emp-not-inc | 52505 | Università | 10 | Coniuge civile sposato | Agricoltura e pesca | Marito | Bianco | Maschile | 0 | 0 | 99 | Stati Uniti | <=50.000 |
| 5129 | 54 | Privato | 106728 | Lauree | 13 | Coniuge civile sposato | Assistenza tecnica | Marito | Bianco | Maschile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
| 2096 | 21 | Privato | 190916 | Università | 10 | Mai sposato/a | Vendite | Tuo figlio | Bianco | Femminile | 0 | 0 | 20 | Stati Uniti | <=50.000 |
| 12463 | 29 | Privato | 197565 | HS-grad | 9 | Coniuge civile sposato | Altro-servizio | Moglie | Bianco | Femminile | 0 | 1902 | 35 | Stati Uniti | > 50.000 |
| 8528 | 46 | Privato | 193188 | Master | 14 | Mai sposato/a | Dirigente | Celibe/nubile | Bianco | Maschile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
| 7093 | 20 | Privato | 273147 | HS-grad | 9 | Mai sposato/a | Configurazione automatica | Tuo figlio | Nero | Maschile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
| 12565 | 46 | Privato | 203653 | Lauree | 13 | Divorziato/a | Vendite | Altro relativo | Nero | Maschile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
| 5655 | 57 | Privato | 174662 | HS-grad | 9 | Coniuge civile sposato | Artigianato-riparazione | Marito | Bianco | Maschile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
| 2322 | 48 | Privato | 232149 | Lauree | 13 | Divorziato/a | Assistenza tecnica | Tuo figlio | Bianco | Femminile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
| 12652 | 39 | Privato | 82521 | Lauree | 13 | Coniuge civile sposato | Vendite | Marito | Bianco | Maschile | 0 | 0 | 45 | Stati Uniti | > 50.000 |
| 4755 | 33 | Privato | 330715 | HS-grad | 9 | Coniuge civile sposato | Vendite | Marito | Bianco | Maschile | 0 | 0 | 55 | Stati Uniti | <=50.000 |
| 4413 | 44 | Stato-gov | 128586 | Lauree | 13 | Mai sposato/a | Agricoltura e pesca | Non in famiglia | Bianco | Maschile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
Esporta l'input di previsione in un file JSON delimitato da nuova riga:
import json
with open('prediction_input.json', 'w') as json_file:
for row in prediction_input.values.tolist():
json.dump(row, json_file)
json_file.write('\n')
Esci dall'interprete Python (exit()). Dalla shell, esamina
prediction_input.json:
cat prediction_input.json
[0.9012127751273994, 1.0, 1.525541514460902, 2.0, 9.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.43754385253479555, 38.0] [-0.9221541171760282, 3.0, -0.4192650914017433, 4.0, 2.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [-1.2138928199445767, 3.0, -0.030303770229214273, 4.0, 10.0, 1.0, 4.0, -0.14479173735784842, -0.21713186390175285, 1.5799792247041626, 38.0] [-0.6304154144074798, 3.0, 0.35865755094331475, 4.0, 0.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.6796466218034705, 38.0] [-1.5056315227131252, 3.0, -1.5861490549193304, 4.0, 7.0, 3.0, 0.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [-0.11987268456252011, 5.0, 0.35865755094331475, 2.0, 2.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.8410484679825871, 38.0] [0.24480069389816542, 3.0, 1.525541514460902, 2.0, 9.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 1.176474609256371, 6.0] [0.0989313425138912, 1.0, 1.525541514460902, 2.0, 9.0, 0.0, 4.0, 0.8868473744801746, -0.21713186390175285, -0.03403923708700391, 38.0] [0.39067004528243965, 5.0, -0.030303770229214273, 2.0, 4.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 4.7273152251969375, 38.0] [1.1200168022038106, 3.0, 1.1365801932883728, 2.0, 12.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [-1.2868274956367138, 3.0, -0.030303770229214273, 4.0, 11.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -1.6480576988781703, 38.0] [-0.7033500900996169, 3.0, -0.4192650914017433, 2.0, 7.0, 5.0, 4.0, -0.14479173735784842, 4.5022796885373735, -0.43754385253479555, 38.0] [0.5365393966667138, 3.0, 1.525541514460902, 4.0, 3.0, 4.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [-1.3597621713288508, 3.0, -0.4192650914017433, 4.0, 6.0, 3.0, 2.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [0.5365393966667138, 3.0, 1.1365801932883728, 0.0, 11.0, 2.0, 2.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [1.338820829280222, 3.0, -0.4192650914017433, 2.0, 2.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [0.6824087480509881, 3.0, 1.1365801932883728, 0.0, 12.0, 3.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0] [0.0259966668217541, 3.0, 1.1365801932883728, 2.0, 11.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 0.3694653783607877, 38.0] [-0.4116113873310685, 3.0, -0.4192650914017433, 2.0, 11.0, 0.0, 4.0, -0.14479173735784842, -0.21713186390175285, 1.176474609256371, 38.0] [0.39067004528243965, 6.0, 1.1365801932883728, 4.0, 4.0, 1.0, 4.0, -0.14479173735784842, -0.21713186390175285, -0.03403923708700391, 38.0]
Lo strumento a riga di comando gcloud accetta JSON delimitato da nuova riga per la previsione online e questo particolare modello Keras prevede un elenco semplice di numeri per ogni esempio di input.
AI Platform richiede un formato diverso quando effettui richieste di previsione
online all'API REST senza utilizzare lo strumento gcloud. Anche il modo in cui strutturi il modello può cambiare il modo in cui devi formattare i dati per la previsione.
Scopri di più sulla formattazione dei dati per la previsione online.
Invia la richiesta di previsione online
Utilizza gcloud per inviare la tua richiesta di previsione online:
gcloud ai-platform predict \
--model $MODEL_NAME \
--region $REGION \
--version $MODEL_VERSION \
--json-instances prediction_input.json
DENSE_4 [0.6854287385940552] [0.011786997318267822] [0.037236183881759644] [0.016223609447479248] [0.0012015104293823242] [0.23621389269828796] [0.6174039244651794] [0.9822691679000854] [0.3815768361091614] [0.6715215444564819] [0.001094043254852295] [0.43077391386032104] [0.22132840752601624] [0.004075437784194946] [0.22736871242523193] [0.4111979305744171] [0.27328649163246155] [0.6981356143951416] [0.3309604525566101] [0.20807647705078125]
Poiché l'ultimo livello del modello utilizza una funzione sigmoidale per l'attivazione, gli output compresi tra 0 e 0,5 rappresentano previsioni negative ("<=50K") e gli output tra 0,5 e 1 rappresentano previsioni positive (">50.000").
Sviluppo del modello Keras da zero
A questo punto, hai addestrato un modello di machine learning su AI Platform, hai eseguito il deployment del modello addestrato come risorsa di versione su AI Platform e hai ricevuto previsioni online dal deployment. La sezione successiva illustra come ricreare il codice Keras utilizzato per addestrare il modello. Descrive le seguenti parti dello sviluppo di un modello di machine learning da utilizzare con AI Platform:
- Download e pre-elaborazione dei dati
- Progettazione e addestramento del modello
- Visualizzazione dell'addestramento ed esportazione del modello addestrato
Anche se questa sezione fornisce insight più dettagliati sulle attività completate nelle
parti precedenti, per saperne di più sull'utilizzo di tf.keras, leggi la guida di TensorFlow
a Keras.
Per saperne di più sulla strutturazione del codice come pacchetto di addestramento per AI Platform, consulta Packaging di un'applicazione di addestramento e fai riferimento al codice di addestramento completo, che è strutturato come pacchetto Python.
Importa librerie e definisci le costanti
Innanzitutto, importa le librerie Python necessarie per l'addestramento:
import os
from six.moves import urllib
import tempfile
import numpy as np
import pandas as pd
import tensorflow as tf
# Examine software versions
print(__import__('sys').version)
print(tf.__version__)
print(tf.keras.__version__)
Quindi, definisci alcune costanti utili:
- Informazioni per scaricare i dati di addestramento e valutazione
- Informazioni necessarie a Panda per interpretare i dati e convertire i campi categoriali in caratteristiche numeriche
- Iperparametri per l'addestramento, ad esempio tasso di apprendimento e dimensione del batch
### For downloading data ###
# Storage directory
DATA_DIR = os.path.join(tempfile.gettempdir(), 'census_data')
# Download options.
DATA_URL = 'https://storage.googleapis.com/cloud-samples-data/ai-platform' \
'/census/data'
TRAINING_FILE = 'adult.data.csv'
EVAL_FILE = 'adult.test.csv'
TRAINING_URL = '%s/%s' % (DATA_URL, TRAINING_FILE)
EVAL_URL = '%s/%s' % (DATA_URL, EVAL_FILE)
### For interpreting data ###
# These are the features in the dataset.
# Dataset information: https://archive.ics.uci.edu/ml/datasets/census+income
_CSV_COLUMNS = [
'age', 'workclass', 'fnlwgt', 'education', 'education_num',
'marital_status', 'occupation', 'relationship', 'race', 'gender',
'capital_gain', 'capital_loss', 'hours_per_week', 'native_country',
'income_bracket'
]
_CATEGORICAL_TYPES = {
'workclass': pd.api.types.CategoricalDtype(categories=[
'Federal-gov', 'Local-gov', 'Never-worked', 'Private', 'Self-emp-inc',
'Self-emp-not-inc', 'State-gov', 'Without-pay'
]),
'marital_status': pd.api.types.CategoricalDtype(categories=[
'Divorced', 'Married-AF-spouse', 'Married-civ-spouse',
'Married-spouse-absent', 'Never-married', 'Separated', 'Widowed'
]),
'occupation': pd.api.types.CategoricalDtype([
'Adm-clerical', 'Armed-Forces', 'Craft-repair', 'Exec-managerial',
'Farming-fishing', 'Handlers-cleaners', 'Machine-op-inspct',
'Other-service', 'Priv-house-serv', 'Prof-specialty', 'Protective-serv',
'Sales', 'Tech-support', 'Transport-moving'
]),
'relationship': pd.api.types.CategoricalDtype(categories=[
'Husband', 'Not-in-family', 'Other-relative', 'Own-child', 'Unmarried',
'Wife'
]),
'race': pd.api.types.CategoricalDtype(categories=[
'Amer-Indian-Eskimo', 'Asian-Pac-Islander', 'Black', 'Other', 'White'
]),
'native_country': pd.api.types.CategoricalDtype(categories=[
'Cambodia', 'Canada', 'China', 'Columbia', 'Cuba', 'Dominican-Republic',
'Ecuador', 'El-Salvador', 'England', 'France', 'Germany', 'Greece',
'Guatemala', 'Haiti', 'Holand-Netherlands', 'Honduras', 'Hong', 'Hungary',
'India', 'Iran', 'Ireland', 'Italy', 'Jamaica', 'Japan', 'Laos', 'Mexico',
'Nicaragua', 'Outlying-US(Guam-USVI-etc)', 'Peru', 'Philippines', 'Poland',
'Portugal', 'Puerto-Rico', 'Scotland', 'South', 'Taiwan', 'Thailand',
'Trinadad&Tobago', 'United-States', 'Vietnam', 'Yugoslavia'
]),
'income_bracket': pd.api.types.CategoricalDtype(categories=[
'<=50K', '>50K'
])
}
# This is the label (target) we want to predict.
_LABEL_COLUMN = 'income_bracket'
### Hyperparameters for training ###
# This the training batch size
BATCH_SIZE = 128
# This is the number of epochs (passes over the full training data)
NUM_EPOCHS = 20
# Define learning rate.
LEARNING_RATE = .01
Scaricare e pre-elaborare i dati
Scarica i dati
Successivamente, definisci le funzioni per scaricare i dati di addestramento e valutazione. Queste funzioni correggeno anche piccole irregolarità nella formattazione dei dati.
def _download_and_clean_file(filename, url):
"""Downloads data from url, and makes changes to match the CSV format.
The CSVs may use spaces after the comma delimters (non-standard) or include
rows which do not represent well-formed examples. This function strips out
some of these problems.
Args:
filename: filename to save url to
url: URL of resource to download
"""
temp_file, _ = urllib.request.urlretrieve(url)
with tf.gfile.Open(temp_file, 'r') as temp_file_object:
with tf.gfile.Open(filename, 'w') as file_object:
for line in temp_file_object:
line = line.strip()
line = line.replace(', ', ',')
if not line or ',' not in line:
continue
if line[-1] == '.':
line = line[:-1]
line += '\n'
file_object.write(line)
tf.gfile.Remove(temp_file)
def download(data_dir):
"""Downloads census data if it is not already present.
Args:
data_dir: directory where we will access/save the census data
"""
tf.gfile.MakeDirs(data_dir)
training_file_path = os.path.join(data_dir, TRAINING_FILE)
if not tf.gfile.Exists(training_file_path):
_download_and_clean_file(training_file_path, TRAINING_URL)
eval_file_path = os.path.join(data_dir, EVAL_FILE)
if not tf.gfile.Exists(eval_file_path):
_download_and_clean_file(eval_file_path, EVAL_URL)
return training_file_path, eval_file_path
Utilizza queste funzioni per scaricare i dati per l'addestramento e verificare di disporre di file CSV per l'addestramento e la valutazione:
training_file_path, eval_file_path = download(DATA_DIR)
Successivamente, carica questi file utilizzando Pandas ed esamina i dati:
# This census data uses the value '?' for fields (column) that are missing data.
# We use na_values to find ? and set it to NaN values.
# https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html
train_df = pd.read_csv(training_file_path, names=_CSV_COLUMNS, na_values='?')
eval_df = pd.read_csv(eval_file_path, names=_CSV_COLUMNS, na_values='?')
La seguente tabella mostra un estratto dei dati (train_df.head()) prima della pre-elaborazione:
| età | classe lavoro | fnlwgt | education | education_num | marital_status | professione | relazione | gruppo etnico | genere | capital_gain | capital_loss | hours_per_week | native_country | income_bracket | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 39 | Stato-gov | 77516 | Lauree | 13 | Mai sposato/a | Adm-clerical | Non in famiglia | Bianco | Maschile | 2174 | 0 | 40 | Stati Uniti | <=50.000 |
| 1 | 50 | Self-emp-not-inc | 83311 | Lauree | 13 | Coniuge civile sposato | Dirigente | Marito | Bianco | Maschile | 0 | 0 | 13 | Stati Uniti | <=50.000 |
| 2 | 38 | Privato | 215646 | HS-grad | 9 | Divorziato/a | Addetti alle pulizie | Non in famiglia | Bianco | Maschile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
| 3 | 53 | Privato | 234721 | 11 | 7 | Coniuge civile sposato | Addetti alle pulizie | Marito | Nero | Maschile | 0 | 0 | 40 | Stati Uniti | <=50.000 |
| 4 | 28 | Privato | 338409 | Lauree | 13 | Coniuge civile sposato | Specializzato in professione | Moglie | Nero | Femminile | 0 | 0 | 40 | Cuba | <=50.000 |
Pre-elaborare i dati
Il primo passaggio di pre-elaborazione rimuove determinate caratteristiche dai dati e converte le caratteristiche categoriche in valori numerici per l'utilizzo con Keras.
Scopri di più su feature engineering e differenze nei dati.
UNUSED_COLUMNS = ['fnlwgt', 'education', 'gender']
def preprocess(dataframe):
"""Converts categorical features to numeric. Removes unused columns.
Args:
dataframe: Pandas dataframe with raw data
Returns:
Dataframe with preprocessed data
"""
dataframe = dataframe.drop(columns=UNUSED_COLUMNS)
# Convert integer valued (numeric) columns to floating point
numeric_columns = dataframe.select_dtypes(['int64']).columns
dataframe[numeric_columns] = dataframe[numeric_columns].astype('float32')
# Convert categorical columns to numeric
cat_columns = dataframe.select_dtypes(['object']).columns
dataframe[cat_columns] = dataframe[cat_columns].apply(lambda x: x.astype(
_CATEGORICAL_TYPES[x.name]))
dataframe[cat_columns] = dataframe[cat_columns].apply(lambda x: x.cat.codes)
return dataframe
prepped_train_df = preprocess(train_df)
prepped_eval_df = preprocess(eval_df)
La seguente tabella (prepped_train_df.head()) mostra in che modo la pre-elaborazione ha modificato i dati. Tieni presente che income_bracket, l'etichetta che stai
addestrando il modello a prevedere, è cambiata da <=50K e >50K a 0 e
1:
| età | classe lavoro | education_num | marital_status | professione | relazione | gruppo etnico | capital_gain | capital_loss | hours_per_week | native_country | income_bracket | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 39,0 | 6 | 13.0 | 4 | 0 | 1 | 4 | 2174,0 | 0.0 | 40.0 | 38 | 0 |
| 1 | 50.0 | 5 | 13.0 | 2 | 3 | 0 | 4 | 0.0 | 0.0 | 13.0 | 38 | 0 |
| 2 | 38.0 | 3 | 9.0 | 0 | 5 | 1 | 4 | 0.0 | 0.0 | 40.0 | 38 | 0 |
| 3 | 53,0 | 3 | 7.0 | 2 | 5 | 0 | 2 | 0.0 | 0.0 | 40.0 | 38 | 0 |
| 4 | 28.0 | 3 | 13.0 | 2 | 9 | 5 | 2 | 0.0 | 0.0 | 40.0 | 4 | 0 |
Quindi, separa i dati in caratteristiche ("x") ed etichette ("y") e rimodella gli array di etichette in un formato da utilizzare con tf.data.Dataset in un secondo momento:
# Split train and test data with labels.
# The pop() method will extract (copy) and remove the label column from the dataframe
train_x, train_y = prepped_train_df, prepped_train_df.pop(_LABEL_COLUMN)
eval_x, eval_y = prepped_eval_df, prepped_eval_df.pop(_LABEL_COLUMN)
# Reshape label columns for use with tf.data.Dataset
train_y = np.asarray(train_y).astype('float32').reshape((-1, 1))
eval_y = np.asarray(eval_y).astype('float32').reshape((-1, 1))
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.
In un sistema di produzione, puoi salvare le medie e le deviazioni standard del set di addestramento e utilizzarle per eseguire una trasformazione identica sui dati di test al momento della previsione. Per praticità, combina temporaneamente i dati di addestramento e valutazione per applicarli tutti su larga scala:
def standardize(dataframe):
"""Scales numerical columns using their means and standard deviation to get
z-scores: the mean of each numerical column becomes 0, and the standard
deviation becomes 1. This can help the model converge during training.
Args:
dataframe: Pandas dataframe
Returns:
Input dataframe with the numerical columns scaled to z-scores
"""
dtypes = list(zip(dataframe.dtypes.index, map(str, dataframe.dtypes)))
# Normalize numeric columns.
for column, dtype in dtypes:
if dtype == 'float32':
dataframe[column] -= dataframe[column].mean()
dataframe[column] /= dataframe[column].std()
return dataframe
# Join train_x and eval_x to normalize on overall means and standard
# deviations. Then separate them again.
all_x = pd.concat([train_x, eval_x], keys=['train', 'eval'])
all_x = standardize(all_x)
train_x, eval_x = all_x.xs('train'), all_x.xs('eval')
La tabella successiva (train_x.head()) mostra l'aspetto dei dati completamente pre-elaborati:
| età | classe lavoro | education_num | marital_status | professione | relazione | gruppo etnico | capital_gain | capital_loss | hours_per_week | native_country | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0,025997 | 6 | 1,136580 | 4 | 0 | 1 | 4 | 0,146933 | - 0,217132 | - 0,034039 | 38 |
| 1 | 0,828278 | 5 | 1,136580 | 2 | 3 | 0 | 4 | - 0,144792 | - 0,217132 | -2,212964 | 38 |
| 2 | -0,046938 | 3 | - 0,419265 | 0 | 5 | 1 | 4 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
| 3 | 1,047082 | 3 | -1,197188 | 2 | 5 | 0 | 2 | - 0,144792 | - 0,217132 | - 0,034039 | 38 |
| 4 | -0,776285 | 3 | 1,136580 | 2 | 9 | 5 | 2 | - 0,144792 | - 0,217132 | - 0,034039 | 4 |
Progettare e addestrare il modello
Creazione di set di dati di addestramento e convalida
Crea una funzione di input per convertire caratteristiche ed etichette in un elemento tf.data.Dataset per l'addestramento o la valutazione:
def input_fn(features, labels, shuffle, num_epochs, batch_size):
"""Generates an input function to be used for model training.
Args:
features: numpy array of features used for training or inference
labels: numpy array of labels for each example
shuffle: boolean for whether to shuffle the data or not (set True for
training, False for evaluation)
num_epochs: number of epochs to provide the data for
batch_size: batch size for training
Returns:
A tf.data.Dataset that can provide data to the Keras model for training or
evaluation
"""
if labels is None:
inputs = features
else:
inputs = (features, labels)
dataset = tf.data.Dataset.from_tensor_slices(inputs)
if shuffle:
dataset = dataset.shuffle(buffer_size=len(features))
# We call repeat after shuffling, rather than before, to prevent separate
# epochs from blending together.
dataset = dataset.repeat(num_epochs)
dataset = dataset.batch(batch_size)
return dataset
Quindi, crea questi set di dati di addestramento e valutazione.Utilizza gli iperparametri NUM_EPOCHS e BATCH_SIZE definiti in precedenza per definire il modo in cui il set di dati di addestramento fornisce esempi al modello durante l'addestramento. Configura il set di dati di convalida per fornire tutti gli esempi in un unico batch, per un'unica fase di convalida alla fine di ogni periodo di addestramento.
# Pass a numpy array by using DataFrame.values
training_dataset = input_fn(features=train_x.values,
labels=train_y,
shuffle=True,
num_epochs=NUM_EPOCHS,
batch_size=BATCH_SIZE)
num_eval_examples = eval_x.shape[0]
# Pass a numpy array by using DataFrame.values
validation_dataset = input_fn(features=eval_x.values,
labels=eval_y,
shuffle=False,
num_epochs=NUM_EPOCHS,
batch_size=num_eval_examples)
Progetta un modello Keras
Progetta la tua rete neurale utilizzando l'API Keras Sequential.
Questa rete neurale profonda (DNN) ha diversi livelli nascosti e l'ultimo livello utilizza una funzione di attivazione sigmoidale per generare un valore compreso tra 0 e 1:
- Il livello di input ha 100 unità che utilizzano la funzione di attivazione ReLU.
- Il livello nascosto ha 75 unità che utilizzano la funzione di attivazione ReLU.
- Il livello nascosto ha 50 unità che utilizzano la funzione di attivazione ReLU.
- Il livello nascosto ha 25 unità che utilizzano la funzione di attivazione ReLU.
- Il livello di output ha 1 unità che utilizza una funzione di attivazione sigmoide.
- L'ottimizzatore utilizza la funzione di perdita di entropia incrociata binaria, appropriata per un problema di classificazione binaria come questo.
Non esitare a modificare questi livelli per provare a migliorare il modello:
def create_keras_model(input_dim, learning_rate):
"""Creates Keras Model for Binary Classification.
Args:
input_dim: How many features the input has
learning_rate: Learning rate for training
Returns:
The compiled Keras model (still needs to be trained)
"""
Dense = tf.keras.layers.Dense
model = tf.keras.Sequential(
[
Dense(100, activation=tf.nn.relu, kernel_initializer='uniform',
input_shape=(input_dim,)),
Dense(75, activation=tf.nn.relu),
Dense(50, activation=tf.nn.relu),
Dense(25, activation=tf.nn.relu),
Dense(1, activation=tf.nn.sigmoid)
])
# Custom Optimizer:
# https://www.tensorflow.org/api_docs/python/tf/train/RMSPropOptimizer
optimizer = tf.keras.optimizers.RMSprop(
lr=learning_rate)
# Compile Keras model
model.compile(
loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
return model
Quindi, crea l'oggetto modello Keras:
num_train_examples, input_dim = train_x.shape
print('Number of features: {}'.format(input_dim))
print('Number of examples: {}'.format(num_train_examples))
keras_model = create_keras_model(
input_dim=input_dim,
learning_rate=LEARNING_RATE)
L'esame del modello con keras_model.summary() dovrebbe restituire un risultato simile al seguente:
Number of features: 11 Number of examples: 32561 WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version. Instructions for updating: Colocations handled automatically by placer. _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense (Dense) (None, 100) 1200 _________________________________________________________________ dense_1 (Dense) (None, 75) 7575 _________________________________________________________________ dense_2 (Dense) (None, 50) 3800 _________________________________________________________________ dense_3 (Dense) (None, 25) 1275 _________________________________________________________________ dense_4 (Dense) (None, 1) 26 ================================================================= Total params: 13,876 Trainable params: 13,876 Non-trainable params: 0 _________________________________________________________________
Addestra e valuta il modello
Definisci un decadimento del tasso di apprendimento per incoraggiare i parametri del modello ad apportare modifiche più piccole durante l'addestramento:
# Setup Learning Rate decay.
lr_decay_cb = tf.keras.callbacks.LearningRateScheduler(
lambda epoch: LEARNING_RATE + 0.02 * (0.5 ** (1 + epoch)),
verbose=True)
# Setup TensorBoard callback.
JOB_DIR = os.getenv('JOB_DIR')
tensorboard_cb = tf.keras.callbacks.TensorBoard(
os.path.join(JOB_DIR, 'keras_tensorboard'),
histogram_freq=1)
Infine, addestra il modello. Fornisci il steps_per_epoch appropriato per il modello per l'addestramento sull'intero set di dati di addestramento (con BATCH_SIZE esempi per passaggio) durante ogni epoca. e indica al modello di calcolare l'accuratezza
con un unico batch di convalida alla fine di ogni epoca.
history = keras_model.fit(training_dataset,
epochs=NUM_EPOCHS,
steps_per_epoch=int(num_train_examples/BATCH_SIZE),
validation_data=validation_dataset,
validation_steps=1,
callbacks=[lr_decay_cb, tensorboard_cb],
verbose=1)
L'avanzamento dell'addestramento potrebbe avere il seguente aspetto:
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version. Instructions for updating: Use tf.cast instead. Epoch 00001: LearningRateScheduler reducing learning rate to 0.02. Epoch 1/20 254/254 [==============================] - 1s 5ms/step - loss: 0.6986 - acc: 0.7893 - val_loss: 0.3894 - val_acc: 0.8329 Epoch 00002: LearningRateScheduler reducing learning rate to 0.015. Epoch 2/20 254/254 [==============================] - 1s 4ms/step - loss: 0.3574 - acc: 0.8335 - val_loss: 0.3861 - val_acc: 0.8131 ... Epoch 00019: LearningRateScheduler reducing learning rate to 0.010000038146972657. Epoch 19/20 254/254 [==============================] - 1s 4ms/step - loss: 0.3239 - acc: 0.8512 - val_loss: 0.3334 - val_acc: 0.8496 Epoch 00020: LearningRateScheduler reducing learning rate to 0.010000019073486329. Epoch 20/20 254/254 [==============================] - 1s 4ms/step - loss: 0.3279 - acc: 0.8504 - val_loss: 0.3174 - val_acc: 0.8523
Visualizza l'addestramento ed esporta il modello addestrato
Visualizzazione dell'addestramento
Importa matplotlib per visualizzare come il modello ha appreso durante il periodo di addestramento.
Se necessario, installalo prima con pip install matplotlib.
from matplotlib import pyplot as plt
Traccia la perdita (entropia incrociata binaria) e l'accuratezza del modello, misurata alla fine di ogni epoca di addestramento:
# Visualize History for Loss.
plt.title('Keras model loss')
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['training', 'validation'], loc='upper right')
plt.show()
# Visualize History for Accuracy.
plt.title('Keras model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.legend(['training', 'validation'], loc='lower right')
plt.show()
Nel tempo, la perdita diminuisce e l'accuratezza aumenta. Ma convergono a un livello stabile? Ci sono grandi differenze tra le metriche di addestramento e convalida (un segno di overfitting)?
Scopri come migliorare il tuo modello di machine learning. Poi, regola gli iperparametri o l'architettura del modello e addestra di nuovo.
Esporta il modello per la pubblicazione
Usa tf.contrib.saved_model.save_keras_model per esportare una directory SaveModel di TensorFlow. Questo è il formato richiesto da AI Platform quando crei una risorsa della versione del modello.
Poiché non tutti gli ottimizzatori possono essere esportati nel formato SaveModel, è possibile che vengano visualizzati avvisi durante il processo di esportazione. Se esporti correttamente un grafico di pubblicazione, AI Platform può usare il modello savedModel per fornire previsioni.
# Export the model to a local SavedModel directory
export_path = tf.contrib.saved_model.save_keras_model(keras_model, 'keras_export')
print("Model exported to: ", export_path)
WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0. For more information, please see: * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md * https://github.com/tensorflow/addons If you depend on functionality not listed there, please file an issue. WARNING:tensorflow:This model was compiled with a Keras optimizer (<tensorflow.python.keras.optimizers.RMSprop object at 0x7fc198c4e400>) but is being saved in TensorFlow format with `save_weights`. The model's weights will be saved, but unlike with TensorFlow optimizers in the TensorFlow format the optimizer's state will not be saved. Consider using a TensorFlow optimizer from `tf.train`. WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/network.py:1436: update_checkpoint_state (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version. Instructions for updating: Use tf.train.CheckpointManager to manage checkpoints rather than manually editing the Checkpoint proto. WARNING:tensorflow:Model was compiled with an optimizer, but the optimizer is not from `tf.train` (e.g. `tf.train.AdagradOptimizer`). Only the serving graph was exported. The train and evaluate graphs were not added to the SavedModel. WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/saved_model/signature_def_utils_impl.py:205: build_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version. Instructions for updating: This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.build_tensor_info or tf.compat.v1.saved_model.build_tensor_info. INFO:tensorflow:Signatures INCLUDED in export for Classify: None INFO:tensorflow:Signatures INCLUDED in export for Regress: None INFO:tensorflow:Signatures INCLUDED in export for Predict: ['serving_default'] INFO:tensorflow:Signatures INCLUDED in export for Train: None INFO:tensorflow:Signatures INCLUDED in export for Eval: None INFO:tensorflow:No assets to save. INFO:tensorflow:No assets to write. INFO:tensorflow:SavedModel written to: keras_export/1553710367/saved_model.pb Model exported to: b'keras_export/1553710367'
Puoi esportare una directory SaveModel nel tuo file system locale o in Cloud Storage, purché tu disponga delle autorizzazioni necessarie. Nel tuo ambiente attuale, hai concesso l'accesso a Cloud Storage autenticando il tuo account Google Cloud e impostando la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. Inoltre, i job di addestramento di AI Platform possono essere esportati direttamente in Cloud Storage, poiché gli account di servizio AI Platform hanno accesso ai bucket Cloud Storage nel loro progetto.
Prova a esportare direttamente in Cloud Storage:
JOB_DIR = os.getenv('JOB_DIR')
# Export the model to a SavedModel directory in Cloud Storage
export_path = tf.contrib.saved_model.save_keras_model(keras_model, JOB_DIR + '/keras_export')
print("Model exported to: ", export_path)
WARNING:tensorflow:This model was compiled with a Keras optimizer (<tensorflow.python.keras.optimizers.RMSprop object at 0x7fc198c4e400>) but is being saved in TensorFlow format with `save_weights`. The model's weights will be saved, but unlike with TensorFlow optimizers in the TensorFlow format the optimizer's state will not be saved. Consider using a TensorFlow optimizer from `tf.train`. WARNING:tensorflow:Model was compiled with an optimizer, but the optimizer is not from `tf.train` (e.g. `tf.train.AdagradOptimizer`). Only the serving graph was exported. The train and evaluate graphs were not added to the SavedModel. INFO:tensorflow:Signatures INCLUDED in export for Classify: None INFO:tensorflow:Signatures INCLUDED in export for Regress: None INFO:tensorflow:Signatures INCLUDED in export for Predict: ['serving_default'] INFO:tensorflow:Signatures INCLUDED in export for Train: None INFO:tensorflow:Signatures INCLUDED in export for Eval: None INFO:tensorflow:No assets to save. INFO:tensorflow:No assets to write. INFO:tensorflow:SavedModel written to: gs://your-bucket-name/keras-job-dir/keras_export/1553710379/saved_model.pb Model exported to: b'gs://your-bucket-name/keras-job-dir/keras_export/1553710379'
Ora puoi eseguire il deployment di questo modello in AI Platform e fornire previsioni seguendo i passaggi della guida rapida per la previsione.
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 model version resource
gcloud ai-platform versions delete $MODEL_VERSION --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 $JOB_DIR
# If training job is still running, cancel it
gcloud ai-platform jobs cancel $JOB_NAME --quiet
Se il bucket Cloud Storage non contiene altri oggetti e vuoi eliminarlo, esegui gsutil rm -r gs://$BUCKET_NAME.
Che cosa succede dopo?
- Visualizza il codice di addestramento completo utilizzato in questa guida, che struttura il codice in modo da accettare iperparametri personalizzati come flag della riga di comando.
- Scopri di più sul codice di pacchettizzazione per un job di addestramento AI Platform.
- Ulteriori informazioni sull'esecuzione del deployment di un modello per fornire le previsioni.