 Visualizza su TensorFlow.org |  Esegui in Google Colab |  Visualizza su GitHub |  Scarica taccuino |  Corri 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.
- Importa i moduli richiesti
- Configurazioni del progetto
- 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()