Per iniziare: addestramento e previsione 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 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 questa API da parte di TensorFlow.

Le prime due parti del tutorial illustrano l'addestramento di un modello AI Platform utilizzando il codice Keras già scritto, eseguendo il deployment del modello addestrato ad AI Platform e fornire previsioni online dalle un modello di machine learning.

L'ultima parte del tutorial illustra il codice di addestramento utilizzato per il modello e la compatibilità con AI Platform. Per scoprire di più su per creare modelli di machine learning in Keras in generale, leggi il documento TensorFlow Tutorial Keras.

Set di dati

Questo tutorial utilizza il report sul reddito del censimento degli Stati Uniti Set di dati fornite 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, professione e se guadagnano più di 50.000 $l'anno.

Obiettivo

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 altri Informazioni sul censimento della persona (caratteristiche).

Questo tutorial si concentra più sull'utilizzo di questo modello con AI Platform che su il design del modello stesso. Tuttavia, è sempre importante pensare potenziali problemi e conseguenze indesiderate durante lo sviluppo del machine learning sistemi diversi. Vedi l'esercizio Crash Course sul machine learning equità per saperne di più sulle fonti di bias nel set di dati del Censimento, nonché sui modelli equità dell'apprendimento in generale.

Costi

Questo tutorial utilizza i componenti fatturabili di Google Cloud (Google Cloud):

  • AI Platform Training
  • AI Platform Prediction
  • Cloud Storage

Scopri di più su AI Platform Training prezzi, AI Platform Prediction prezzi, e Cloud Storage prezzi, e utilizza la pagina 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:

  • Configura il tuo ambiente di sviluppo locale.
  • Configura un progetto Google Cloud con la fatturazione e le API necessarie in un bucket in cui è abilitato il controllo delle versioni.
  • 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:

  • Git
  • Python 3
  • virtualenv
  • Google Cloud SDK
di Gemini Advanced.

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:

  1. Installa Python 3.

  2. Installa virtualenv e creerai un ambiente virtuale che utilizza Python 3.

  3. Attivare l'ambiente.

  4. Completa i passaggi nella sezione seguente per installare Google Cloud SDK.

Configura il progetto Google Cloud

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

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  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. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  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

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.

  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 Spazio di archiviazione > 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 è stato 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

Quando invii un job di addestramento utilizzando Cloud SDK, carichi un pacchetto Python contenente il codice di addestramento in un bucket Cloud Storage. AI Platform esegue il codice da questo pacchetto. In questo tutorial, AI Platform salva inoltre 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 AI Platform Training e AI Platform Prediction e creare un'altra variabile di ambiente. Ad esempio:

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à:

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 Vertex 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 i dati modello TensorFlow SavedModel Google Cloud nel tuo bucket Cloud Storage.

Ottieni codice di addestramento e dipendenze

Innanzitutto, 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

Nota che il codice di addestramento è strutturato come pacchetto Python 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 preinstallate in base al runtime versione che scegli.

Addestra il modello in locale

Prima di eseguire l'addestramento su AI Platform, addestra il job in locale per verificare la struttura e la pacchettizzazione dei file sono corrette.

Per un lavoro complesso o che richiede molte risorse, potresti voler eseguire l'addestramento in locale un piccolo campione del tuo set di dati per verificare il codice. Poi puoi eseguire il job AI Platform per eseguire l'addestramento sull'intero set di dati.

Questo esempio esegue un job relativamente rapido su un set di dati di piccole dimensioni, quindi l'ambiente mentre il job di AI Platform esegue 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 nella tua shell. Al termine, l'applicazione di addestramento esporta il modello addestrato e visualizza un messaggio simile al 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 l'addestramento nel cloud ed esporta il modello addestrato in Cloud Storage.

Innanzitutto, assegna un nome al job di addestramento e scegli una directory all'interno Bucket Cloud Storage per il salvataggio dei file intermedi e di output. Imposta 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 nella specificato --job-dir e indica ad AI Platform di eseguire il trainer.task modulo dal pacchetto.

Il flag --stream-logs ti consente di visualizzare i log di addestramento nella shell. Puoi anche visualizza 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 rispetto a quella locale, ma puoi osservare i progressi dell'addestramento nella shell in modo simile. Al termine, il job di addestramento esporta addestrato al tuo bucket Cloud Storage e stampa un messaggio simile al le seguenti:

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 di configurazione di hptuning_config.yaml. Questo file indica AI Platform per ottimizzare la dimensione del batch e il tasso di apprendimento per l'addestramento in più prove per massimizzare la precisione.

In questo esempio, il codice di addestramento utilizza una classe TensorBoard callback, che crea TensorFlow Summary Event sec durante l'addestramento. AI Platform utilizza 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 le previsioni online in AI Platform

Questa sezione mostra come utilizzare AI Platform e il modello addestrato da la sezione precedente per prevedere la fascia di reddito di una persona da un altro censimento informazioni che li riguardano.

Creazione di risorse per modelli e versioni in AI Platform

Per pubblicare previsioni online utilizzando il modello che hai addestrato ed esportato nel guida rapida per addestramento, crea una risorsa modello in AI Platform e una risorsa versione al suo interno. La risorsa versione è ciò che utilizza effettivamente il modello addestrato per per fornire previsioni. Questa struttura consente di regolare e addestrare nuovamente il modello volte e organizzare tutte le versioni insieme in AI Platform. Impara scopri di più sui modelli le versioni secondarie.

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 formazione ha esportato un file TensorFlow SavedModel con timestamp directory al tuo bucket Cloud Storage. AI Platform utilizza questo per creare una versione del modello. Scopri di più su SavedModel e AI Platform.

Potresti riuscire a 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 nello stesso modo in cui i dati di addestramento venivano pre-elaborati. In un ambiente di produzione di sistema, potresti voler creare una pipeline di pre-elaborazione che possa essere utilizzata in modo identico al momento dell'addestramento e al momento della previsione.

Per questo esercizio, usa il codice di caricamento dati del pacchetto di addestramento per selezionare campione casuale dai dati di valutazione. Questi dati sono nel formato utilizzato per valutare l'accuratezza dopo ogni epoca di addestramento, in modo da poter essere utilizzata per inviare le previsioni senza ulteriori pre-elaborazioni.

Apri l'interprete Python (python) dalla directory di lavoro corrente in per eseguire i prossimi 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 di 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, ad esempio occupation, sono già stati convertiti a numeri interi (con la stessa mappatura utilizzata per l'addestramento). Numerica come age, sono stati scalati a un z-score. Alcuni campi sono stati eliminati dai dati originali. Confronta la 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 di 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 Governo locale 99064 Master 14 Coniuge/coniuge sposata Specializzazione Marito Bianco Uomo 0 0 35 Stati Uniti <= 50.000
2430 26 Privato 197967 Grado HS 9 Mai sposato Riparazione artigianale Figlio Bianco Uomo 0 0 40 Stati Uniti <= 50.000
4214 22 Privato 221694 Università 10 Mai sposato Serv.prot. Non appartenente alla famiglia Bianco Uomo 0 0 60 Stati Uniti <= 50.000
10389 30 Privato 96480 Assoc-voc 11 Mai sposato Adm-clericale Figlio Bianco Donna 0 0 32 Stati Uniti <= 50.000
14525 18 Privato 146225 10 6 Mai sposato Altro servizio Figlio Amer-indiano-eschimese Donna 0 0 40 Stati Uniti <= 50.000
15040 37 Self-emp-not-inc 50096 Assoc-voc 11 Coniuge/coniuge sposata Riparazione artigianale Marito Bianco Uomo 0 0 30 Stati Uniti <= 50.000
8409 42 Privato 102988 Master 14 Coniuge/coniuge sposata Specializzazione Marito Bianco Uomo 0 0 55 Ecuador > 50.000
10628 40 Governo locale 284086 Master 14 Coniuge/coniuge sposata Specializzazione Marito Bianco Uomo 7688 0 40 Stati Uniti > 50.000
10942 44 Self-emp-not-inc 52505 Università 10 Coniuge/coniuge sposata Agricoltura-pesca Marito Bianco Uomo 0 0 99 Stati Uniti <= 50.000
5129 54 Privato 106728 Lauree 13 Coniuge/coniuge sposata Assistenza tecnica Marito Bianco Uomo 0 0 40 Stati Uniti <= 50.000
2096 21 Privato 190916 Università 10 Mai sposato Vendite Figlio Bianco Donna 0 0 20 Stati Uniti <= 50.000
12463 29 Privato 197565 Grado HS 9 Coniuge/coniuge sposata Altro servizio Moglie Bianco Donna 0 1902 35 Stati Uniti > 50.000
8528 46 Privato 193188 Master 14 Mai sposato Esecutivo-manageriale Celibe/nubile Bianco Uomo 0 0 40 Stati Uniti <= 50.000
7093 20 Privato 273147 Grado HS 9 Mai sposato Machine-op-inspct Figlio Nero Uomo 0 0 40 Stati Uniti <= 50.000
12565 46 Privato 203653 Lauree 13 Divorziato/a Vendite Altro correlato Nero Uomo 0 0 40 Stati Uniti <= 50.000
5655 57 Privato 174662 Grado HS 9 Coniuge/coniuge sposata Riparazione artigianale Marito Bianco Uomo 0 0 40 Stati Uniti <= 50.000
2322 48 Privato 232149 Lauree 13 Divorziato/a Assistenza tecnica Figlio Bianco Donna 0 0 40 Stati Uniti <= 50.000
12652 39 Privato 82521 Lauree 13 Coniuge/coniuge sposata Vendite Marito Bianco Uomo 0 0 45 Stati Uniti > 50.000
4755 33 Privato 330715 Grado HS 9 Coniuge/coniuge sposata Vendite Marito Bianco Uomo 0 0 55 Stati Uniti <= 50.000
4413 44 Stato-gov 128586 Lauree 13 Mai sposato Agricoltura-pesca Non appartenente alla famiglia Bianco Uomo 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 tua 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 i file e questo particolare modello Keras si aspetta un elenco fisso di numeri per ogni esempio di input.

AI Platform richiede un formato diverso quando crei contenuti online richieste di previsione all'API REST senza utilizzare lo strumento gcloud. Il modo in cui struttura del modello può cambiare anche il modo in cui devi formattare i dati per la previsione. Scopri di più sulla formattazione dei dati per online per la previsione.

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 strato del modello utilizza una funzione sigmoidale per la sua attivazione, gli output tra 0 e 0,5 rappresentano previsioni negative ("<=50K") e le uscite comprese tra 0,5 e 1 rappresentano quelle positive (">50K").

Sviluppo del modello Keras da zero

A questo punto, hai addestrato un modello di machine learning AI Platform, ha eseguito il deployment del modello addestrato come risorsa di versione AI Platform e ricevuto previsioni online dal deployment. La la prossima sezione illustra come ricreare il codice Keras utilizzato per addestrare il modello. e tratta le seguenti parti dello sviluppo di un modello di machine learning per l'uso con AI Platform:

  • Download e pre-elaborazione dei dati
  • Progettazione e addestramento del modello
  • Visualizzazione dell'addestramento e dell'esportazione del modello addestrato

Questa sezione fornisce informazioni più dettagliate sulle attività completate in parti precedenti, per ulteriori informazioni sull'uso di tf.keras, leggi la guida di TensorFlow a Keras. Per scoprire di più su come strutturare il codice come pacchetto di addestramento AI Platform, leggi l'articolo Presentazione di una formazione applicazione e consulta l'addestramento completo codice, strutturato come pacchetto Python.

Importa le 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 Pandas per interpretare i dati e convertire i campi categorici in caratteristiche numeriche
  • Iperparametri per l'addestramento, come 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 correggere anche le irregolarità minori 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 avere File CSV per l'addestramento e la valutazione:

training_file_path, eval_file_path = download(DATA_DIR)

Quindi, 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 tabella seguente mostra un estratto dei dati (train_df.head()) prima pre-elaborazione:

età classe di 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 Adm-clericale Non appartenente alla famiglia Bianco Uomo 2174 0 40 Stati Uniti <= 50.000
1 50 Self-emp-not-inc 83311 Lauree 13 Coniuge/coniuge sposata Esecutivo-manageriale Marito Bianco Uomo 0 0 13 Stati Uniti <= 50.000
2 38 Privato 215646 Grado HS 9 Divorziato/a Addetti alle pulizie dei gestori Non appartenente alla famiglia Bianco Uomo 0 0 40 Stati Uniti <= 50.000
3 53 Privato 234721 11 7 Coniuge/coniuge sposata Addetti alle pulizie dei gestori Marito Nero Uomo 0 0 40 Stati Uniti <= 50.000
4 28 Privato 338409 Lauree 13 Coniuge/coniuge sposata Specializzazione Moglie Nero Donna 0 0 40 Cuba <= 50.000

Pre-elabora i dati

La prima fase di pre-elaborazione rimuove alcune caratteristiche dai dati e converte le caratteristiche categoriche in valori numerici per l'uso con Keras.

Scopri di più sulle funzionalità tecnica e pregiudizi dei 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 come è cambiata la pre-elaborazione i dati. Nota in particolare che income_bracket, l'etichetta che stai addestrare il modello per eseguire la previsione, è cambiata da <=50K e >50K a 0 e 1:

età classe di 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 il etichetta gli array 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 la deviazione standard di 1 può migliorare modello.

In un sistema di produzione, potresti voler salvare le medie e le deviazioni standard del set di addestramento e utilizzarli per eseguire una trasformazione identica al momento della previsione. Per praticità in questo esercizio, combinare i dati di addestramento e valutazione per scalarli tutti:

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 come appaiono i dati completamente pre-elaborati come:

età classe di 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

Progetta e addestra il modello

Creare set di dati di addestramento e convalida

Creare una funzione di input per convertire caratteristiche ed etichette in un tf.data.Dataset per addestramento o 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 il NUM_EPOCHS e BATCH_SIZE iperparametri definiti in precedenza per definire le modalità di fornisce esempi al modello durante l'addestramento. Configurare la convalida set di dati per fornire tutti i relativi esempi in un solo batch, per un'unica fase di convalida al termine di ogni epoca 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)

Progettare un modello Keras

Progetta la tua rete neurale utilizzando il metodo Keras Sequential tramite Google Cloud.

Questa rete neurale profonda (DNN, Deep Neural Network, rete neurale profonda) ha diversi strati nascosti e l'ultimo utilizza una funzione di attivazione sigmoidea per restituire un valore compreso tra 0 e 1:

  • Il livello di input ha 100 unità che utilizzano la funzione di attivazione ReLU.
  • Lo strato nascosto ha 75 unità che utilizzano la funzione di attivazione ReLU.
  • Lo strato nascosto ha 50 unità che utilizzano la funzione di attivazione ReLU.
  • Lo strato nascosto ha 25 unità che utilizzano la funzione di attivazione ReLU.
  • Il livello di output ha 1 unità che utilizza una funzione di attivazione sigmoidea.
  • L'ottimizzatore usa la funzione di perdita di entropia incrociata binaria, appropriato per un problema di classificazione binaria come questo.

Se vuoi, puoi modificare questi strati 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 di 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 a questo:

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 a ridurre le dimensioni cambiamenti con il procedere dell'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 codice steps_per_epoch appropriato per da addestrare sull'intero set di dati di addestramento (con BATCH_SIZE esempi per passaggio) durante ogni epoca. e istruire il modello di calcolare l'accuratezza della convalida. con un grande 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 può 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.

Visualizza l'addestramento

Importa matplotlib per visualizzare l'apprendimento del modello durante il periodo di addestramento. Se necessario, installala prima con pip install matplotlib.

from matplotlib import pyplot as plt

Tracciare la perdita (entropia incrociata binaria) e l'accuratezza del modello, misurate 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 la precisione aumenta. Ma convergono verso un stabile? Ci sono grandi differenze tra addestramento e convalida (un segno di overfitting)?

Scopri come migliorare il tuo machine learning modello. Quindi, non esitare a modificare gli iperparametri o l'architettura del modello e ad addestrare di nuovo.

Esporta il modello per la pubblicazione

Utilizza le funzionalità di tf.contrib.saved_model.save_keras_model per esportare una directory SavedModel di TensorFlow. Questo è il formato AI Platform richiede la creazione di una versione del modello risorsa.

Poiché non tutti gli ottimizzatori possono essere esportati nel formato SavedModel, potresti notare durante il processo di esportazione. Se esporti correttamente una pubblicazione AI Platform può utilizzare 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 SavedModel nel file system locale o in Cloud Storage, purché tu disponga delle autorizzazioni necessarie. Nel tuo ambiente attuale, hai concesso l'accesso a Cloud Storage l'autenticazione dell'account Google Cloud e l'impostazione GOOGLE_APPLICATION_CREDENTIALS variabile di ambiente. AI Platform i job di addestramento possono anche essere esportati direttamente in Cloud Storage, Gli account di servizio AI Platform hanno accesso a Cloud Storage bucket 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 su AI Platform e fornire previsioni seguendo i passaggi della guida rapida per la previsione.

esegui la pulizia

Per eseguire la pulizia di tutte le risorse Google Cloud utilizzate in questo progetto, puoi eliminare l'account Google Cloud progetto che hai usato per il tutorial.

In alternativa, puoi pulire le singole risorse eseguendo questo :

# 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.

Passaggi successivi