Réserve cette date! Google I / O revient du 18 au 20 mai S'inscrire maintenant
Cette page a été traduite par l'API Cloud Translation.
Switch to English

Entraîner des modèles Keras avec TensorFlow Cloud

Voir sur TensorFlow.org Exécuter dans Google Colab Afficher la source sur GitHub Télécharger le cahier

introduction

TensorFlow Cloud est un package Python qui fournit des API pour une transition transparente du débogage local à la formation distribuée dans Google Cloud. Il simplifie le processus de formation des modèles TensorFlow sur le cloud en un seul et simple appel de fonction, nécessitant une configuration minimale et aucune modification de votre modèle. TensorFlow Cloud gère automatiquement les tâches spécifiques au cloud, telles que la création d'instances de VM et de stratégies de distribution pour vos modèles. Ce guide expliquera comment s'interfacer avec Google Cloud via TensorFlow Cloud et la large gamme de fonctionnalités fournies dans TensorFlow Cloud. Nous allons commencer par le cas d'utilisation le plus simple.

Installer

Nous commencerons par installer TensorFlow Cloud et importer les packages dont nous aurons besoin dans ce guide.

pip install -q tensorflow_cloud
import tensorflow as tf
import tensorflow_cloud as tfc

from tensorflow import keras
from tensorflow.keras import layers

Présentation de l'API: un premier exemple de bout en bout

Commençons par un script d'entraînement de modèle Keras, tel que le CNN suivant:

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

model = keras.Sequential(
    [
        keras.Input(shape=(28, 28)),
        # Use a Rescaling layer to make sure input values are in the [0, 1] range.
        layers.experimental.preprocessing.Rescaling(1.0 / 255),
        # The original images have shape (28, 28), so we reshape them to (28, 28, 1)
        layers.Reshape(target_shape=(28, 28, 1)),
        # Follow-up with a classic small convnet
        layers.Conv2D(32, 3, activation="relu"),
        layers.MaxPooling2D(2),
        layers.Conv2D(32, 3, activation="relu"),
        layers.MaxPooling2D(2),
        layers.Conv2D(32, 3, activation="relu"),
        layers.Flatten(),
        layers.Dense(128, activation="relu"),
        layers.Dense(10),
    ]
)

model.compile(
    optimizer=keras.optimizers.Adam(),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=keras.metrics.SparseCategoricalAccuracy(),
)

model.fit(x_train, y_train, epochs=20, batch_size=128, validation_split=0.1)

Pour entraîner ce modèle sur Google Cloud, il suffit d'ajouter un appel à run() au début du script, avant les importations:

tfc.run()

Vous n'avez pas à vous soucier des tâches spécifiques au cloud, telles que la création d'instances de VM et de stratégies de distribution lors de l'utilisation de TensorFlow Cloud. L'API inclut des valeurs par défaut intelligentes pour tous les paramètres - tout est configurable, mais de nombreux modèles peuvent s'appuyer sur ces valeurs par défaut.

Lors de l'appel de run() , TensorFlow Cloud:

  • Préparez votre script Python ou votre notebook à la distribution.
  • Convertissez-le en une image Docker avec les dépendances requises.
  • Exécutez la tâche d'entraînement sur une VM alimentée par GPU GCP.
  • Diffusez des journaux et des informations sur les travaux pertinents.

La configuration de VM par défaut est 1 chef et 0 ouvrier avec 8 cœurs de processeur et 1 GPU Tesla T4.

Configuration de Google Cloud

Afin de faciliter les voies appropriées pour la formation Cloud, vous devrez effectuer une première configuration. Si vous êtes un nouvel utilisateur de Google Cloud, vous devrez suivre quelques étapes préliminaires:

  1. Créer un projet GCP;
  2. Activer les services AI Platform;
  3. Créez un compte de service;
  4. Téléchargez une clé d'autorisation;
  5. Créez un bucket Cloud Storage.

Vous trouverez des instructions de configuration détaillées pour la première fois dans le fichier README de TensorFlow Cloud , et un exemple de configuration supplémentaire est affiché sur le blog TensorFlow .

Flux de travail courants et stockage dans le cloud

Dans la plupart des cas, vous souhaiterez récupérer votre modèle après l'entraînement sur Google Cloud. Pour cela, il est crucial de rediriger l'enregistrement et le chargement vers Cloud Storage lors de l'entraînement à distance. Nous pouvons diriger TensorFlow Cloud vers notre bucket Cloud Storage pour une variété de tâches. Le compartiment de stockage peut être utilisé pour enregistrer et charger des ensembles de données d'entraînement volumineux, stocker des journaux de rappel ou des pondérations de modèle et enregistrer des fichiers de modèle entraînés. Pour commencer, configurons fit() pour enregistrer le modèle sur un stockage cloud et configurons la surveillance TensorBoard pour suivre la progression de l'entraînement.

def create_model():
    model = keras.Sequential(
        [
            keras.Input(shape=(28, 28)),
            layers.experimental.preprocessing.Rescaling(1.0 / 255),
            layers.Reshape(target_shape=(28, 28, 1)),
            layers.Conv2D(32, 3, activation="relu"),
            layers.MaxPooling2D(2),
            layers.Conv2D(32, 3, activation="relu"),
            layers.MaxPooling2D(2),
            layers.Conv2D(32, 3, activation="relu"),
            layers.Flatten(),
            layers.Dense(128, activation="relu"),
            layers.Dense(10),
        ]
    )

    model.compile(
        optimizer=keras.optimizers.Adam(),
        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
        metrics=keras.metrics.SparseCategoricalAccuracy(),
    )
    return model

Sauvegardons les journaux TensorBoard et les points de contrôle du modèle générés lors de la formation dans notre bucket de stockage cloud.

import datetime
import os

# Note: Please change the gcp_bucket to your bucket name.
gcp_bucket = "keras-examples"

checkpoint_path = os.path.join("gs://", gcp_bucket, "mnist_example", "save_at_{epoch}")

tensorboard_path = os.path.join(  # Timestamp included to enable timeseries graphs
    "gs://", gcp_bucket, "logs", datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
)

callbacks = [
    # TensorBoard will store logs for each epoch and graph performance for us.
    keras.callbacks.TensorBoard(log_dir=tensorboard_path, histogram_freq=1),
    # ModelCheckpoint will save models after each epoch for retrieval later.
    keras.callbacks.ModelCheckpoint(checkpoint_path),
    # EarlyStopping will terminate training when val_loss ceases to improve.
    keras.callbacks.EarlyStopping(monitor="val_loss", patience=3),
]

model = create_model()

Ici, nous chargerons directement nos données depuis Keras. En général, il est recommandé de stocker votre ensemble de données dans votre bucket Cloud Storage, mais TensorFlow Cloud peut également accueillir des ensembles de données stockés localement. Cela est couvert dans la section Multi-fichiers de ce guide.

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

L'API TensorFlow Cloud fournit la fonction remote() pour déterminer si le code est exécuté localement ou sur le cloud. Cela permet la désignation séparée des paramètres fit() pour l'exécution locale et distante, et fournit des moyens pour un débogage facile sans surcharger votre machine locale.

if tfc.remote():
    epochs = 100
    callbacks = callbacks
    batch_size = 128
else:
    epochs = 5
    batch_size = 64
    callbacks = None

model.fit(x_train, y_train, epochs=epochs, callbacks=callbacks, batch_size=batch_size)
Epoch 1/5
938/938 [==============================] - 6s 3ms/step - loss: 0.4867 - sparse_categorical_accuracy: 0.8556
Epoch 2/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0638 - sparse_categorical_accuracy: 0.9796
Epoch 3/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0411 - sparse_categorical_accuracy: 0.9870
Epoch 4/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0333 - sparse_categorical_accuracy: 0.9895
Epoch 5/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0278 - sparse_categorical_accuracy: 0.9910
<tensorflow.python.keras.callbacks.History at 0x7fa57866c4e0>

Sauvegardons le modèle dans GCS une fois la formation terminée.

save_path = os.path.join("gs://", gcp_bucket, "mnist_example")

if tfc.remote():
    model.save(save_path)

Nous pouvons également utiliser ce compartiment de stockage pour la création d'images Docker, au lieu de votre instance Docker locale. Pour cela, ajoutez simplement votre bucket au paramètre docker_image_bucket_name .

tfc.run(docker_image_bucket_name=gcp_bucket)

Après avoir entraîné le modèle, nous pouvons charger le modèle enregistré et afficher nos journaux TensorBoard pour surveiller les performances.

model = keras.models.load_model(save_path)
!tensorboard dev upload --logdir "gs://keras-examples-jonah/logs/fit" --name "Guide MNIST"

Projets de grande envergure

Dans de nombreux cas, votre projet contenant un modèle Keras peut englober plusieurs scripts Python ou impliquer des données externes ou des dépendances spécifiques. TensorFlow Cloud est entièrement flexible pour un déploiement à grande échelle et fournit un certain nombre de fonctionnalités intelligentes pour aider vos projets.

Points d'entrée: prise en charge des scripts Python et des notebooks Jupyter

Votre appel à l'API run() ne sera pas toujours contenu dans le même script Python que le code d'entraînement de votre modèle. Pour cela, nous fournissons un paramètre entry_point . Le paramètre entry_point peut être utilisé pour spécifier le script ou le bloc-notes Python dans lequel réside le code de formation de votre modèle. Lorsque vous appelez run() partir du même script que votre modèle, utilisez la entry_point par défaut entry_point de None .

dépendances de pip

Si votre projet fait appel à des dépendances pip supplémentaires, il est possible de spécifier les bibliothèques requises supplémentaires en incluant un fichier requirements.txt . Dans ce fichier, mettez simplement une liste de toutes les dépendances requises et TensorFlow Cloud se chargera de les intégrer dans votre build cloud.

Cahiers Python

TensorFlow Cloud est également exécutable à partir de notebooks Python. De plus, votre point d' entry_point spécifié peut être un bloc-notes si nécessaire. Il y a deux différences clés à garder à l'esprit entre TensorFlow Cloud sur les notebooks et les scripts:

  • Lorsque vous appelez run() partir d'un notebook, un bucket Cloud Storage doit être spécifié pour créer et stocker votre image Docker.
  • L'authentification GCloud s'effectue entièrement via votre clé d'authentification, sans spécification de projet. Un exemple de flux de travail utilisant TensorFlow Cloud à partir d'un ordinateur portable est fourni dans la section «Assembler le tout» de ce guide.

Projets multi-fichiers

Si votre modèle dépend de fichiers supplémentaires, il vous suffit de vous assurer que ces fichiers résident dans le même répertoire (ou sous-répertoire) du point d'entrée spécifié. Chaque fichier stocké dans le même répertoire que le point d' entry_point spécifié sera inclus dans l'image Docker, ainsi que tous les fichiers stockés dans les sous-répertoires adjacents au point d' entry_point . Cela est également vrai pour les dépendances dont vous pourriez avoir besoin et qui ne peuvent pas être acquises via pip

Pour un exemple de point d'entrée personnalisé et de projet multi-fichiers avec des dépendances pip supplémentaires, jetez un œil à cet exemple multi-fichiers sur le référentiel cloud TensorFlow . Par souci de concision, nous allons simplement inclure l'appel run() l'exemple:

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    entry_point="train_model.py",
    requirements="requirements.txt"
)

Configuration de la machine et formation distribuée

La formation de modèle peut nécessiter un large éventail de ressources différentes, en fonction de la taille du modèle ou de l'ensemble de données. Lors de la prise en compte des configurations avec plusieurs GPU, il devient essentiel de choisir une stratégie de distribution adaptée. Ici, nous décrivons quelques configurations possibles:

Distribution multi-travailleurs

Ici, nous pouvons utiliser COMMON_MACHINE_CONFIGS pour désigner 1 processeur principal et 4 GPU de travail.

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS['CPU'],
    worker_count=2,
    worker_config=tfc.COMMON_MACHINE_CONFIGS['T4_4X']
)

Par défaut, TensorFlow Cloud choisit la meilleure stratégie de distribution pour la configuration de votre machine avec une formule simple utilisant les chief_config , worker_config et worker_count fournis.

Distribution de TPU

Entraînons le même modèle sur TPU, comme indiqué:

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS["CPU"],
    worker_count=1,
    worker_config=tfc.COMMON_MACHINE_CONFIGS["TPU"]
)

Stratégie de distribution personnalisée

Pour spécifier une stratégie de distribution personnalisée, formatez votre code normalement comme vous le feriez selon le guide de formation distribué et définissez distribution_strategy sur None . Ci-dessous, nous allons spécifier notre propre stratégie de distribution pour le même modèle MNIST.

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

mirrored_strategy = tf.distribute.MirroredStrategy()
with mirrored_strategy.scope():
  model = create_model()

if tfc.remote():
    epochs = 100
    batch_size = 128
else:
    epochs = 10
    batch_size = 64
    callbacks = None

model.fit(
    x_train, y_train, epochs=epochs, callbacks=callbacks, batch_size=batch_size
)

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS['CPU'],
    worker_count=2,
    worker_config=tfc.COMMON_MACHINE_CONFIGS['T4_4X'],
    distribution_strategy=None
)

Images Docker personnalisées

Par défaut, TensorFlow Cloud utilise une image de base Docker fournie par Google et correspondant à votre version actuelle de TensorFlow. Cependant, vous pouvez également spécifier une image Docker personnalisée pour répondre aux exigences de votre build, si nécessaire. Pour cet exemple, nous allons spécifier l'image Docker d'une ancienne version de TensorFlow:

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    base_docker_image="tensorflow/tensorflow:2.1.0-gpu"
)

Métriques supplémentaires

Vous trouverez peut-être utile de baliser vos tâches Cloud avec des étiquettes spécifiques ou de diffuser les journaux de votre modèle pendant la formation Cloud. C'est une bonne pratique de maintenir un étiquetage approprié sur tous les travaux Cloud, pour la tenue de registres. À cette fin, run() accepte un dictionnaire d'étiquettes jusqu'à 64 paires clé-valeur, visibles depuis les journaux de compilation Cloud. Les journaux tels que les performances d'époque et les données internes de sauvegarde de modèle sont accessibles à l'aide du lien fourni en exécutant tfc.run ou imprimés sur votre terminal local à l'aide de l'indicateur stream_logs .

job_labels = {"job": "mnist-example", "team": "keras-io", "user": "jonah"}

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    job_labels=job_labels,
    stream_logs=True
)

Mettre tous ensemble

Pour un Colab approfondi qui utilise de nombreuses fonctionnalités décrites dans ce guide, suivez cet exemple pour former un modèle de pointe à reconnaître les races de chiens à partir de photos à l'aide de l'extraction de fonctionnalités.