Cloud TensorFlow

Voir sur TensorFlow.org Exécuter dans Google Colab Afficher sur GitHub Télécharger le cahier Logo KaggleCourir à Kaggle

TensorFlow Cloud est une bibliothèque qui facilite la formation et le réglage d'hyperparamètres des modèles Keras sur Google Cloud.

À l'aide de l'API d' run TensorFlow Cloud, vous pouvez envoyer votre code de 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 l'intérieur d'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

Ceci est 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 exécuter le bloc-notes dans Google Colab. Pour exécuter le notebook, vous devez vous connecter à un compte Google Cloud et saisir vos informations d'identification et votre ID de projet. Consultez la section 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éfinissez les paramètres du projet. Si vous ne savez pas ce que devrait être votre GCP_PROJECT_ID ou GCS_BUCKET , consultez la section 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")

Authentification du notebook pour utiliser votre projet Google Cloud

Ce code authentifie le notebook, 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 n'est exécuté que dans le bloc-notes et ne sera pas exécuté lorsque le code du bloc-notes 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 fractionner 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éez un modèle et préparez-vous à 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 à la validation rapide

Nous allons former le modèle pour une (1) époque juste pour nous assurer que tout est correctement configuré, et nous allons envelopper cette commande d'entraînement dans if not tfc.remote , de sorte que cela ne se produise qu'ici dans l'environnement d'exécution dans lequel 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 à la formation à distance

Le code ci-dessous ne s'exécutera que lorsque le code du bloc-notes sera envoyé à Google Cloud, et non dans l'environnement d'exécution dans lequel vous lisez ceci.

Tout d'abord, nous mettons en place des rappels qui:

  • Créez des journaux pour TensorBoard .
  • Créez des points de contrôle et enregistrez-les dans le répertoire des 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 s'exécute sur Google Cloud) exécutent réellement l'entraînement complet (100 époques), puis enregistrent le modèle entraîné dans le bucket 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)

Démarrez la formation à distance

TensorFlow Cloud prend tout le code de son environnement d'exécution local (ce bloc-notes), l'enveloppe 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 démarrera une tâche d'entraînement à distance sur Google Cloud Platform pour entraîner le modèle.

Tout d'abord, nous ajoutons le tensorflow-cloud Python tensorflow-cloud à un fichier requirements.txt , qui sera envoyé avec le code de ce notebook. Vous pouvez ajouter d'autres packages ici si nécessaire.

Ensuite, un GPU et une image CPU sont spécifiés. Il vous suffit de spécifier 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 . Une fois cette opération exécutée dans ce bloc-notes, tout le code de ce bloc-notes, 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 d' run spécifient que les détails des images du processeur GPU sont spécifiés. Il vous suffit de spécifier 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 . Une fois cette opération exécutée dans ce bloc-notes, tout le code de ce bloc-notes, 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 d' run spécifient les détails du GPU et les images CPU sont spécifiées. Il vous suffit de spécifier 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 . Une fois cette opération exécutée dans ce bloc-notes, tout le code de ce bloc-notes, 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 d' 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 surveiller 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 tâches de formation à distance durent longtemps. Si vous utilisez Colab, le délai 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.

  1. Importer les modules requis
  2. Configurations de projet
  3. Authentification du notebook pour utiliser votre projet Google Cloud

NE réexécutez PAS le reste du code.

Charge Tensorboard

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()