 Visualizza su TensorFlow.org |  Esegui in Google Colab |  Visualizza su GitHub |  Scarica il taccuino |  Corri a Kaggle |
TensorFlow Cloud è una libreria che semplifica l'addestramento e l'ottimizzazione degli iperparametri dei modelli Keras su Google Cloud.
Utilizzando l'API run di TensorFlow Cloud, puoi inviare il codice del modello direttamente al tuo account Google Cloud e utilizzare le risorse di elaborazione 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 tue 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 .py Python.
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 blocco note 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 , vedi Configurazione e connessione al tuo account Google Cloud .
JOB_NAME è facoltativo e puoi impostarlo su qualsiasi stringa. Se stai svolgendo 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 progetto Google Cloud
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
Impostazione del modello e dei dati
Da qui seguiremo 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 dividili per addestrare e testare 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 sulla convalida
Addestreremo il modello per una (1) epoca solo per assicurarci che tutto sia impostato correttamente e inseriremo il comando di addestramento in 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)
Prepararsi 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 stai leggendo questo articolo.
Innanzitutto, impostiamo i callback 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 sufficientemente.
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 racchiude 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 , che verrà inviato insieme al codice in questo notebook. Puoi aggiungere altri pacchetti qui secondo necessità.
Quindi vengono specificate una GPU e un'immagine 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 questa operazione viene eseguita 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 nel metodo run specificano i dettagli delle immagini della CPU GPU specificate. 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 questa operazione viene eseguita 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 nel metodo 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 questa operazione viene eseguita 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 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
Riconnetti la tua istanza Colab
La maggior parte dei lavori di formazione a distanza sono di lunga durata. Se utilizzi Colab, potrebbe verificarsi un timeout prima che i risultati della formazione siano disponibili.
In tal caso, esegui nuovamente le seguenti sezioni per riconnetterti e configurare la tua istanza Colab per accedere ai risultati della formazione.
- Importa i moduli richiesti
- Configurazioni di progetto
- Autenticazione del notebook 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. L'operazione 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()