TensorFlow Cloud

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

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

Utilizzando l'API di run TensorFlow Cloud, puoi inviare il codice del 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 configurato 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 .

Semplice esempio

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 taccuino in Google Colab. L'esecuzione del notebook richiede la connessione a un account Google Cloud e l'inserimento di credenziali e ID progetto. Vedi Configurazione e connessione al tuo account Google Cloud se non hai ancora un account o non sei sicuro di come impostare 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 del 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 taccuino per utilizzare il tuo progetto Google Cloud

Questo codice autentica il taccuino, controllando le tue credenziali e identità valide di Google Cloud. Si trova all'interno del blocco if not tfc.remote() per garantire che venga eseguito solo nel notebook e non verrà 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 suddividi 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 la formazione

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 rapida per la convalida

Addestreremo il modello per una (1) epoca solo per assicurarci che tutto sia impostato correttamente e inseriremo quel comando di addestramento if not tfc.remote , in modo che avvenga solo qui nell'ambiente di runtime in cui 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 l'addestramento 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 stai leggendo questo.

Innanzitutto, configuriamo i callback che:

  • Crea log per TensorBoard .
  • Crea punti di controllo e salvali nella directory dei punti di controllo specificata sopra.
  • Interrompere l'addestramento del modello se la perdita non sta migliorando a sufficienza.

Quindi chiamiamo model.fit e model.save , che (quando questo codice è in esecuzione su Google Cloud) che esegue effettivamente l'addestramento completo (100 epoche) e quindi salva il modello addestrato nel Bucket GCS e nella directory definiti 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 lavoro di formazione remoto su Google Cloud Platform per addestrare il modello.

Per prima cosa aggiungiamo il pacchetto Python tensorflow-cloud a un file 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 della CPU. Devi solo specificare l'uno o l'altro; la GPU è utilizzata nel codice che segue.

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

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

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

Una volta inviato il lavoro, puoi andare 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

Ricollega la tua istanza Colab

La maggior parte dei lavori di formazione a distanza è di lunga durata. Se stai usando Colab, potrebbe scadere prima che i risultati dell'allenamento siano disponibili.

In tal caso, riesegui le sezioni seguenti per riconnetterti e configurare la tua istanza Colab per accedere ai risultati dell'addestramento.

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

NON rieseguire il resto del codice.

Carica Tensorboard

Mentre la formazione è in corso, puoi utilizzare Tensorboard per visualizzare i risultati. Tieni presente 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 Bucket GCS specificato sopra.

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