Partecipa al simposio Women in ML il 7 dicembre Registrati ora

TensorFlow Cloud

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Visualizza su TensorFlow.org Esegui in Google Colab Visualizza su GitHub Scarica quaderno Logo KaggleCorri a Kaggle

TensorFlow Cloud è una libreria che semplifica l'addestramento e l'ottimizzazione degli iperparametri dei modelli Keras su Google Cloud.

Utilizzando l'API di run di TensorFlow Cloud, puoi inviare il codice del tuo modello direttamente al tuo account Google Cloud e utilizzare le risorse di calcolo di Google Cloud senza dover accedere e interagire con l'interfaccia utente di Cloud (dopo aver impostato il progetto nella console).

Ciò significa che puoi utilizzare le risorse di calcolo di Google Cloud direttamente dall'interno di un notebook Python: un notebook proprio come questo! Puoi anche inviare modelli a Google Cloud da un semplice script Python .py .

Esempio semplice

Questo è un semplice esempio introduttivo per dimostrare come addestrare un modello in remoto utilizzando TensorFlow Cloud e Google Cloud.

Puoi semplicemente leggerlo per avere un'idea di come funziona, oppure puoi eseguire il notebook in Google Colab. L'esecuzione del notebook richiede la connessione a un account Google Cloud e l'immissione delle credenziali e dell'ID progetto. Consulta Configurazione e connessione al tuo account Google Cloud se non disponi ancora di un account o non sei sicuro di come configurare un progetto nella console.

Importa i moduli richiesti

import tensorflow as tf
tf.version.VERSION
'2.6.0'
! pip install -q tensorflow-cloud
import tensorflow_cloud as tfc
print(tfc.__version__)
import sys

Configurazioni di progetto

Imposta i parametri del progetto. Se non sai quale dovrebbe essere il tuo GCP_PROJECT_ID o GCS_BUCKET , consulta Configurazione e connessione al tuo account Google Cloud .

JOB_NAME è facoltativo e puoi impostarlo su qualsiasi stringa. Se stai facendo più esperimenti di formazione (ad esempio) come parte di un progetto più ampio, potresti voler assegnare a ciascuno di essi un JOB_NAME univoco .

# Set Google Cloud Specific parameters

# TODO: Please set GCP_PROJECT_ID to your own Google Cloud project ID.
GCP_PROJECT_ID = 'YOUR_PROJECT_ID'

# TODO: set GCS_BUCKET to your own Google Cloud Storage (GCS) bucket.
GCS_BUCKET = 'YOUR_GCS_BUCKET_NAME'

# DO NOT CHANGE: Currently only the 'us-central1' region is supported.
REGION = 'us-central1'

# OPTIONAL: You can change the job name to any string.
JOB_NAME = 'mnist'

# Setting location were training logs and checkpoints will be stored
GCS_BASE_PATH = f'gs://{GCS_BUCKET}/{JOB_NAME}'
TENSORBOARD_LOGS_DIR = os.path.join(GCS_BASE_PATH,"logs")
MODEL_CHECKPOINT_DIR = os.path.join(GCS_BASE_PATH,"checkpoints")
SAVED_MODEL_DIR = os.path.join(GCS_BASE_PATH,"saved_model")

Autenticazione del notebook per utilizzare il tuo Google Cloud Project

Questo codice autentica il notebook, controllando le credenziali e l'identità Google Cloud valide. Si trova all'interno del blocco if not tfc.remote() per garantire che venga eseguito solo nel notebook e non venga eseguito quando il codice del notebook viene inviato a Google Cloud.

# Using tfc.remote() to ensure this code only runs in notebook
if not tfc.remote():

    # Authentication for Kaggle Notebooks
    if "kaggle_secrets" in sys.modules:
        from kaggle_secrets import UserSecretsClient
        UserSecretsClient().set_gcloud_credentials(project=GCP_PROJECT_ID)

    # Authentication for Colab Notebooks
    if "google.colab" in sys.modules:
        from google.colab import auth
        auth.authenticate_user()
        os.environ["GOOGLE_CLOUD_PROJECT"] = GCP_PROJECT_ID

Modello e configurazione dei dati

Da qui stiamo seguendo la procedura di base per impostare un semplice modello Keras per eseguire la classificazione sul set di dati MNIST.

Carica e dividi i dati

Leggi i dati grezzi e li dividi per addestrare e testare i set di dati.

(x_train, y_train), (_, _) = tf.keras.datasets.mnist.load_data()

x_train = x_train.reshape((60000, 28 * 28))
x_train = x_train.astype('float32') / 255

Crea un modello e preparati per l'allenamento

Crea un modello semplice e imposta alcuni callback per esso.

from tensorflow.keras import layers

model = tf.keras.Sequential([
  tf.keras.layers.Dense(512, activation='relu', input_shape=(28 * 28,)),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(loss='sparse_categorical_crossentropy',
              optimizer=tf.keras.optimizers.Adam(),
              metrics=['accuracy'])

Formazione di convalida rapida

Addestreremo il modello per una (1) epoca solo per assicurarci che tutto sia impostato correttamente e avvolgeremo quel comando di addestramento in if not tfc.remote , in modo che avvenga solo qui nell'ambiente di runtime in cui tu stanno leggendo questo, non quando viene inviato a Google Cloud.

if not tfc.remote():
    # Run the training for 1 epoch and a small subset of the data to validate setup
    model.fit(x=x_train[:100], y=y_train[:100], validation_split=0.2, epochs=1)

Preparati per la formazione a distanza

Il codice seguente verrà eseguito solo quando il codice del notebook viene inviato a Google Cloud, non all'interno del runtime in cui lo stai leggendo.

Innanzitutto, impostiamo le richiamate che:

  • Crea log per TensorBoard .
  • Crea checkpoint e salvali nella directory dei checkpoint specificata sopra.
  • Interrompere l'addestramento del modello se la perdita non migliora a sufficienza.

Quindi chiamiamo model.fit e model.save , che (quando questo codice è in esecuzione su Google Cloud) eseguono effettivamente l'addestramento completo (100 epoche) e quindi salvano il modello addestrato nel bucket GCS e nella directory definita sopra.

if tfc.remote():
    # Configure Tensorboard logs
    callbacks=[
        tf.keras.callbacks.TensorBoard(log_dir=TENSORBOARD_LOGS_DIR),
        tf.keras.callbacks.ModelCheckpoint(
            MODEL_CHECKPOINT_DIR,
            save_best_only=True),
        tf.keras.callbacks.EarlyStopping(
            monitor='loss',
            min_delta =0.001,
            patience=3)]

    model.fit(x=x_train, y=y_train, epochs=100,
              validation_split=0.2, callbacks=callbacks)

    model.save(SAVED_MODEL_DIR)

Inizia la formazione a distanza

TensorFlow Cloud prende tutto il codice dal suo ambiente di esecuzione locale (questo notebook), lo avvolge e lo invia a Google Cloud per l'esecuzione. (Ecco perché i wrapper if e if not tfc.remote sono importanti.)

Questo passaggio preparerà il codice da questo notebook per l'esecuzione remota e quindi avvierà un processo di formazione remota su Google Cloud Platform per addestrare il modello.

Per prima cosa aggiungiamo il pacchetto Python tensorflow-cloud a un file Requirements.txt requirements.txt che verrà inviato insieme al codice in questo notebook. Puoi aggiungere altri pacchetti qui, se necessario.

Quindi vengono specificate una GPU e un'immagine CPU. Devi solo specificare l'uno o l'altro; la GPU viene utilizzata nel codice che segue.

Infine, il cuore del cloud TensorFlow: la chiamata a tfc.run . Quando questo viene eseguito all'interno di questo notebook, tutto il codice di questo notebook e il resto dei file in questa directory verranno compressi e inviati a Google Cloud per l'esecuzione. I parametri sul metodo di run specificano i dettagli delle immagini della CPU della GPU. Devi solo specificare l'uno o l'altro; la GPU viene utilizzata nel codice che segue.

Infine, il cuore del cloud TensorFlow: la chiamata a tfc.run . Quando questo viene eseguito all'interno di questo notebook, tutto il codice di questo notebook e il resto dei file in questa directory verranno compressi e inviati a Google Cloud per l'esecuzione. I parametri sul metodo di run specificano i dettagli della GPU e vengono specificate le immagini della CPU. Devi solo specificare l'uno o l'altro; la GPU viene utilizzata nel codice che segue.

Infine, il cuore del cloud TensorFlow: la chiamata a tfc.run . Quando questo viene eseguito all'interno di questo notebook, tutto il codice di questo notebook e il resto dei file in questa directory verranno compressi e inviati a Google Cloud per l'esecuzione. I parametri sul metodo run specificano i dettagli dell'ambiente di esecuzione e la strategia di distribuzione (se presente) da utilizzare.

Una volta inviato il lavoro, puoi passare al passaggio successivo per monitorare l'avanzamento dei lavori tramite Tensorboard.

# If you are using a custom image you can install modules via requirements
# txt file.
with open('requirements.txt','w') as f:
    f.write('tensorflow-cloud\n')

# Optional: Some recommended base images. If you provide none the system
# will choose one for you.
TF_GPU_IMAGE= "tensorflow/tensorflow:latest-gpu"
TF_CPU_IMAGE= "tensorflow/tensorflow:latest"

# Submit a single node training job using GPU.
tfc.run(
    distribution_strategy='auto',
    requirements_txt='requirements.txt',
    docker_config=tfc.DockerConfig(
        parent_image=TF_GPU_IMAGE,
        image_build_bucket=GCS_BUCKET
        ),
    chief_config=tfc.COMMON_MACHINE_CONFIGS['K80_1X'],
    job_labels={'job': JOB_NAME}
)

Risultati della formazione

Riconnetti la tua istanza Colab

La maggior parte dei lavori di formazione a distanza sono di lunga durata. Se si utilizza Colab, potrebbe verificarsi un timeout prima che i risultati dell'allenamento siano disponibili.

In tal caso, esegui nuovamente le sezioni seguenti per riconnetterti e configurare la tua istanza Colab per accedere ai risultati della formazione.

  1. Importa i moduli richiesti
  2. Configurazioni di progetto
  3. Autenticazione del notebook per utilizzare il tuo Google Cloud Project

NON rieseguire il resto del codice.

Carica Tensorboard

Mentre l'allenamento è in corso, puoi utilizzare Tensorboard per visualizzare i risultati. Nota che i risultati verranno visualizzati solo dopo l'inizio dell'allenamento. Questo potrebbe richiedere alcuni minuti.

%load_ext tensorboard
%tensorboard --logdir $TENSORBOARD_LOGS_DIR

Carica il tuo modello addestrato

Una volta completato l'addestramento, puoi recuperare il tuo modello dal GCS Bucket specificato sopra.

trained_model = tf.keras.models.load_model(SAVED_MODEL_DIR)
trained_model.summary()