 Voir sur TensorFlow.org |  Exécuter dans Google Colab |  Voir sur GitHub |  Télécharger le carnet |  Courir à Kaggle |
TensorFlow Cloud est une bibliothèque qui facilite la formation et le réglage des hyperparamètres des modèles Keras sur Google Cloud.
À l'aide de l'API run de TensorFlow Cloud, vous pouvez envoyer le code de votre modèle directement à votre compte Google Cloud et utiliser les ressources de calcul de Google Cloud sans avoir besoin de vous connecter et d'interagir avec l'interface utilisateur Cloud (une fois que vous avez configuré votre projet dans la console).
Cela signifie que vous pouvez utiliser vos ressources de calcul Google Cloud directement depuis un notebook Python : un notebook comme celui-ci ! Vous pouvez également envoyer des modèles à Google Cloud à partir d'un simple script Python .py .
Exemple simple
Il s'agit d'un exemple d'introduction simple pour montrer comment entraîner un modèle à distance à l'aide de TensorFlow Cloud et de Google Cloud.
Vous pouvez simplement le lire pour avoir une idée de son fonctionnement, ou vous pouvez exécuter le bloc-notes dans Google Colab. L'exécution du bloc-notes nécessite une connexion à un compte Google Cloud et la saisie de vos informations d'identification et de votre ID de projet. Consultez Configuration et connexion à votre compte Google Cloud si vous n'avez pas encore de compte ou si vous ne savez pas comment configurer un projet dans la console.
Importer les modules requis
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
Configurations de projet
Définir les paramètres du projet. Si vous ne savez pas quel devrait être votre GCP_PROJECT_ID ou GCS_BUCKET , consultez Configuration et connexion à votre compte Google Cloud .
Le JOB_NAME est facultatif et vous pouvez le définir sur n’importe quelle chaîne. Si vous effectuez plusieurs expériences de formation (par exemple) dans le cadre d'un projet plus vaste, vous souhaiterez peut-être attribuer à chacune d'elles un JOB_NAME unique.
# 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")
Authentifier le notebook pour utiliser votre projet Google Cloud
Ce code authentifie le notebook, en vérifiant vos informations d'identification et votre identité Google Cloud valides. Il se trouve à l'intérieur du bloc if not tfc.remote() pour garantir qu'il est exécuté uniquement dans le notebook et qu'il ne sera pas exécuté lorsque le code du notebook est envoyé à 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
Configuration du modèle et des données
À partir de là, nous suivons la procédure de base pour configurer un modèle Keras simple pour exécuter la classification sur l'ensemble de données MNIST.
Charger et diviser des données
Lisez les données brutes et divisez-les pour former et tester des ensembles de données.
(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
Créer un modèle et préparer la formation
Créez un modèle simple et configurez quelques rappels pour celui-ci.
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'])
Formation de validation rapide
Nous entraînerons le modèle pendant une (1) époque juste pour nous assurer que tout est configuré correctement, et nous intégrerons cette commande d'entraînement dans if not tfc.remote , afin qu'elle ne se produise qu'ici, dans l'environnement d'exécution dans lequel vous vous lisez ceci, pas lorsqu'il est envoyé à 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)
Préparez-vous à une formation à distance
Le code ci-dessous ne s'exécutera que lorsque le code du notebook sera envoyé à Google Cloud, et non dans le runtime dans lequel vous lisez ceci.
Tout d’abord, nous mettons en place des rappels qui vont :
- Créez des journaux pour TensorBoard .
- Créez des points de contrôle et enregistrez-les dans le répertoire de points de contrôle spécifié ci-dessus.
- Arrêtez la formation du modèle si la perte ne s’améliore pas suffisamment.
Ensuite, nous appelons model.fit et model.save , qui (lorsque ce code est exécuté sur Google Cloud) exécutent réellement la formation complète (100 époques), puis enregistrent le modèle entraîné dans le compartiment GCS et le répertoire définis ci-dessus.
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)
Commencer la formation à distance
TensorFlow Cloud récupère tout le code de son environnement d'exécution local (ce bloc-notes), l'encapsule et l'envoie à Google Cloud pour exécution. (C'est pourquoi les wrappers if et if not tfc.remote sont importants.)
Cette étape préparera votre code à partir de ce notebook pour une exécution à distance, puis lancera une tâche de formation à distance sur Google Cloud Platform pour entraîner le modèle.
Nous ajoutons d'abord le package Python tensorflow-cloud à un fichier requirements.txt , qui sera envoyé avec le code de ce notebook. Vous pouvez ajouter d'autres packages ici selon vos besoins.
Ensuite, un GPU et une image CPU sont spécifiés. Il vous suffit de préciser l'un ou l'autre ; le GPU est utilisé dans le code qui suit.
Enfin, le cœur du cloud TensorFlow : l'appel à tfc.run . Lorsque cette opération est exécutée dans ce notebook, tout le code de ce notebook, ainsi que le reste des fichiers de ce répertoire, seront empaquetés et envoyés à Google Cloud pour exécution. Les paramètres de la méthode run spécifient les détails des images CPU GPU qui sont spécifiés. Il vous suffit de préciser l'un ou l'autre ; le GPU est utilisé dans le code qui suit.
Enfin, le cœur du cloud TensorFlow : l'appel à tfc.run . Lorsque cette opération est exécutée dans ce notebook, tout le code de ce notebook, ainsi que le reste des fichiers de ce répertoire, seront empaquetés et envoyés à Google Cloud pour exécution. Les paramètres de la méthode run spécifient les détails des images GPU et CPU. Il vous suffit de préciser l'un ou l'autre ; le GPU est utilisé dans le code qui suit.
Enfin, le cœur du cloud TensorFlow : l'appel à tfc.run . Lorsque cette opération est exécutée dans ce notebook, tout le code de ce notebook, ainsi que le reste des fichiers de ce répertoire, seront empaquetés et envoyés à Google Cloud pour exécution. Les paramètres de la méthode run spécifient les détails de l'environnement d'exécution et la stratégie de distribution (le cas échéant) à utiliser.
Une fois le travail soumis, vous pouvez passer à l'étape suivante pour suivre la progression des travaux via 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}
)
Résultats de la formation
Reconnectez votre instance Colab
La plupart des emplois de formation à distance durent de longue durée. Si vous utilisez Colab, celui-ci peut expirer avant que les résultats de l'entraînement ne soient disponibles.
Dans ce cas, réexécutez les sections suivantes afin de vous reconnecter et de configurer votre instance Colab pour accéder aux résultats de la formation.
- Importer les modules requis
- Configurations de projet
- Authentifier le notebook pour utiliser votre projet Google Cloud
NE réexécutez PAS le reste du code.
Charger le tableau tenseur
Pendant que la formation est en cours, vous pouvez utiliser Tensorboard pour afficher les résultats. Notez que les résultats ne s'afficheront qu'après le début de votre entraînement. Cela peut prendre quelques minutes.
%load_ext tensorboard
%tensorboard --logdir $TENSORBOARD_LOGS_DIR
Chargez votre modèle entraîné
Une fois la formation terminée, vous pouvez récupérer votre modèle à partir du bucket GCS que vous avez spécifié ci-dessus.
trained_model = tf.keras.models.load_model(SAVED_MODEL_DIR)
trained_model.summary()