Exécuter le modèle Transformer avec Tensor2Tensor sur Cloud TPU

Ce tutoriel explique comment entraîner le modèle Transformer issu de l'article Attention Is All You Need) avec Tensor2Tensor sur un appareil Cloud TPU.

Description du modèle

Le modèle Transformer exploite des piles de couches d'auto-attention et à propagation avant pour traiter des entrées séquentielles telles que du texte. Il est compatible avec les variantes suivantes :

  • transformer (décodeur uniquement) pour la modélisation de séquences uniques. Exemple de cas d'utilisation : modélisation du langage.
  • transformer (encodeur/décodeur) pour la modélisation séquence-séquence. Exemple de cas d'utilisation : traduction.
  • transformer_encoder (encodeur uniquement), qui n'exécute que l'encodeur pour la modélisation séquence-classe. Exemple de cas d'utilisation : classification des sentiments.

Le modèle Transformer ne constitue qu'un des modèles de la bibliothèque Tensor2Tensor. Tensor2Tensor (T2T) est une bibliothèque de modèles et d'ensembles de données de deep learning ainsi qu'un ensemble de scripts permettant d'entraîner les modèles et de télécharger et préparer les données.

Objectifs

  • Générer l'ensemble de données d'entraînement
  • Entraîner un modèle de langage sur un seul Cloud TPU ou sur un pod Cloud TPU
  • Entraîner un modèle de traduction anglais/allemand sur un seul Cloud TPU
  • Entraîner un classificateur de sentiments sur un seul Cloud TPU
  • Nettoyer les ressources Cloud TPU

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

  • Instance
  • Cloud TPU
  • Cloud Storage

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

Si vous prévoyez d'effectuer l'entraînement sur une tranche de pod TPU, consultez la section Entraîner sur des pods TPU qui explique les points particuliers à prendre en compte lors d'un entraînement sur une tranche de pod.

Avant de commencer ce tutoriel, suivez les étapes ci-dessous pour vérifier que votre projet Google Cloud est correctement configuré.

Cette section fournit des informations sur la configuration du bucket Cloud Storage et d'une VM Compute Engine.

  1. Ouvrez une fenêtre Cloud Shell.

    Ouvrir Cloud Shell

  2. Créez une variable pour l'ID de votre projet.

    export PROJECT_ID=project-id
    
  3. Configurez l'outil de ligne de commande gcloud pour utiliser le projet dans lequel vous souhaitez créer Cloud TPU.

    gcloud config set project ${PROJECT_ID}
    
  4. Créez un bucket Cloud Storage à l'aide de la commande suivante :

    gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 -b on gs://bucket-name
    

    Ce bucket Cloud Storage stocke les données que vous utilisez pour entraîner votre modèle, ainsi que les résultats de l'entraînement.

  5. Lancez une VM Compute Engine à l'aide de la commande ctpu up.

    ctpu up --zone=europe-west4-a \
    --vm-only \
    --disk-size-gb=300 \
    --machine-type=n1-standard-8 \
    --tf-version=1.15.3 \
    --name=transformer-tutorial
    
  6. La configuration que vous avez spécifiée apparaît. Saisissez y pour approuver ou n pour annuler.

  7. Une fois l'exécution de la commande ctpu up terminée, vérifiez que l'invite de l'interface système est passée de username@projectname à username@vm-name. Cette modification indique que vous êtes maintenant connecté à votre VM Compute Engine.

    gcloud compute ssh transformer-tutorial --zone=europe-west4-a
    

    À mesure que vous appliquez ces instructions, exécutez chaque commande commençant par (vm)$ dans la fenêtre de session de la VM.

Sur la VM Compute Engine, effectuez les étapes ci-dessous :

  1. Créez les variables d'environnement suivantes :

    (vm)$ export STORAGE_BUCKET=gs://bucket-name
    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/transformer
    (vm)$ export DATA_DIR=${STORAGE_BUCKET}/data
    (vm)$ export TMP_DIR=${HOME}/t2t_tmp
  2. Créez un répertoire pour stocker les fichiers temporaires :

    (vm)$ mkdir ${TMP_DIR}
  3. Ajoutez le chemin d'accès aux scripts tensor2tensor utilisés pour traiter les données du modèle :

    (vm)$ export PATH=.local/bin:${PATH}

Entraîner un modèle de langage sur un seul Cloud TPU

  1. Générez l'ensemble de données d'entraînement pour le modèle de langage.

    (vm)$ t2t-datagen --problem=languagemodel_lm1b32k_packed \
     --data_dir=${DATA_DIR} \
     --tmp_dir=${TMP_DIR}
  2. Exécutez la commande suivante pour créer votre ressource Cloud TPU.

    (vm)$ ctpu up --tpu-only \
     --tf-version=1.15.3 \
     --name=transformer-tutorial
  3. Définissez une variable d'environnement pour le nom du TPU.

    (vm)$ export TPU_NAME=transformer-tutorial
  4. Exécutez le script d'entraînement.

    (vm)$ t2t-trainer \
     --model=transformer \
     --hparams_set=transformer_tpu \
     --problem=languagemodel_lm1b32k_packed \
     --eval_steps=3 \
     --data_dir=${DATA_DIR} \
     --output_dir=${MODEL_DIR}/language_lm1b32k \
     --use_tpu=True \
     --cloud_tpu_name=${TPU_NAME} \
     --train_steps=10

    La commande ci-dessus exécute 10 pas d'apprentissage, puis trois pas d'évaluation. Le processus prend environ 5 minutes sur un nœud TPU v3-8. Pour améliorer la précision de ce modèle, vous devez augmenter le nombre de pas d'entraînement en ajustant l'indicateur --train_steps. Il est recommandé d'entraîner le modèle en utilisant au moins 40 000 pas. Le modèle atteint habituellement sa qualité maximale au bout d'environ 250 000 pas.

  5. Supprimez la ressource Cloud TPU que vous avez créée.

    (vm)$ ctpu delete --tpu-only --zone=europe-west4-a --name=transformer-tutorial

Entraîner un modèle de langage sur un pod Cloud TPU

  1. Exécutez la commande ctpu up à l'aide du paramètre tpu-size pour spécifier la tranche de pod que vous souhaitez utiliser. Par exemple, la commande suivante utilise une tranche de pod v2-32.

    (vm)$ ctpu up --tpu-only \
     --tpu-size=v2-32 \
     --zone=europe-west4-a \
     --tf-version=1.15.3 \
     --name=transformer-tutorial-pod
  2. Définissez une variable d'environnement pour le nouveau nom de TPU.

    (vm)$ export TPU_NAME=transformer-tutorial-pod
  3. Exécutez le script d'entraînement.

    (vm)$ t2t-trainer \
     --model=transformer \
     --hparams_set=transformer_tpu \
     --problem=languagemodel_lm1b32k_packed \
     --eval_steps=3 \
     --data_dir=${DATA_DIR} \
     --output_dir=${MODEL_DIR}/language_lm1b32k_pod \
     --use_tpu=True \
     --cloud_tpu_name=${TPU_NAME} \
     --tpu_num_shards=32  \
     --schedule=train \
     --train_steps=25000

    La commande ci-dessus exécute 25 000 pas d'entraînement, puis trois pas d'évaluation. Cet entraînement prend environ 30 minutes sur un Cloud TPU v2-32.

    Il est recommandé d'entraîner le modèle en utilisant au moins 40 000 pas. Le modèle atteint habituellement sa qualité maximale au bout d'environ 250 000 pas.

  4. Supprimez la ressource Cloud TPU que vous avez créée pour entraîner le modèle sur un seul appareil.

    (vm)$ ctpu delete --tpu-only \
     --zone=europe-west4-a \
     --name=transformer-tutorial-pod

Entraîner un modèle de traduction anglais/allemand sur un seul Cloud TPU

  1. Utilisez le script t2t-datagen pour générer les données d'entraînement et d'évaluation du modèle de traduction sur le bucket Cloud Storage :

    (vm)$ t2t-datagen \
     --problem=translate_ende_wmt32k_packed \
     --data_dir=${DATA_DIR} \
     --tmp_dir=${TMP_DIR}
  2. Exécutez la commande suivante pour créer votre ressource Cloud TPU.

    (vm)$ ctpu up --tpu-only \
     --tf-version=1.15.3 \
     --name=transformer-tutorial
  3. Définissez une variable d'environnement pour le nouveau nom de TPU.

    (vm)$ export TPU_NAME=transformer-tutorial
  4. Exécutez t2t-trainer pour entraîner et évaluer le modèle:

    (vm)$ t2t-trainer \
     --model=transformer \
     --hparams_set=transformer_tpu \
     --problem=translate_ende_wmt32k_packed \
     --eval_steps=3 \
     --data_dir=${DATA_DIR} \
     --output_dir=${MODEL_DIR}/translate_ende \
     --use_tpu=True \
     --cloud_tpu_name=${TPU_NAME} \
     --train_steps=10

    La commande ci-dessus exécute 10 pas d'apprentissage, puis trois pas d'évaluation. Le processus prend environ 5 minutes sur un nœud TPU v3-8. Vous pouvez (et devez) augmenter le nombre de pas d'entraînement en ajustant l'indicateur --train_steps. Les traductions commencent généralement à être acceptables après environ 40 000 pas. Le modèle atteint habituellement sa qualité maximale au bout d'environ 250 000 pas.

  5. Supprimez la ressource Cloud TPU que vous avez créée pour entraîner le modèle sur un seul appareil.

    (vm)$ ctpu delete --tpu-only --zone=europe-west4-a --name=transformer-tutorial

Entraîner un classificateur de sentiments sur un seul Cloud TPU

  1. Générez l'ensemble de données du modèle de classificateur de sentiments.

    (vm)$ t2t-datagen --problem=sentiment_imdb \
     --data_dir=${DATA_DIR} \
     --tmp_dir=${TMP_DIR}
  2. Exécutez la commande suivante pour créer votre ressource Cloud TPU.

    (vm)$ ctpu up --tpu-only \
     --tf-version=1.15.3 \
     --name=transformer-tutorial
  3. Exécutez le script d'entraînement.

    (vm)$ t2t-trainer \
     --model=transformer_encoder \
     --hparams_set=transformer_tiny_tpu \
     --problem=sentiment_imdb \
     --eval_steps=1 \
     --data_dir=${DATA_DIR} \
     --output_dir=${MODEL_DIR}/sentiment_classifier \
     --use_tpu=True \
     --cloud_tpu_name=${TPU_NAME} \
     --train_steps=10
    

    La commande ci-dessus exécute 10 pas d'apprentissage, puis trois pas d'évaluation. Le processus prend environ 5 minutes sur un nœud TPU v3-8. Le modèle atteint une précision avoisinant les 85 % après environ 2 000 pas.

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform :

  1. Déconnectez-vous de l'instance Compute Engine, si vous ne l'avez pas déjà fait :

    (vm)$ exit
    

    Votre invite devrait maintenant être username@projectname, indiquant que vous êtes dans Cloud Shell.

  2. Dans Cloud Shell, exécutez la commande ctpu delete avec l'option --zone utilisée lors de votre configuration Cloud TPU pour supprimer votre VM Compute Engine et votre Cloud TPU :

    $ ctpu delete --zone=europe-west4-a \
    --name=transformer-tutorial
    
  3. Exécutez la commande suivante pour vérifier que la VM Compute Engine et Cloud TPU ont été arrêtés :

    $ ctpu status --zone=europe-west4-a
    

    La suppression peut prendre plusieurs minutes. Si vous n'avez plus d'instances allouées, une réponse de ce type s'affiche :

    2018/04/28 16:16:23 WARNING: Setting zone to "europe-west4-a"
    No instances currently exist.
     Compute Engine VM:     --
     Cloud TPU:             --
    
  4. Exécutez gsutil comme indiqué, en remplaçant bucket-name par le nom du bucket Cloud Storage que vous avez créé pour ce tutoriel :

    $ gsutil rm -r gs://bucket-name
    

Étape suivante

Dans ce tutoriel, vous avez entraîné le modèle Transformer à l'aide d'un exemple d'ensemble de données. Les résultats de cet entraînement ne sont pas utilisables pour l'inférence dans la plupart des cas. Afin d'utiliser un modèle pour l'inférence, vous pouvez entraîner les données sur un ensemble de données accessible au public ou sur votre propre ensemble de données. Les modèles entraînés sur des appareils Cloud TPU nécessitent des ensembles de données au format TFRecord.

Vous pouvez utiliser l'exemple d'outil de conversion d'ensemble de données pour convertir un ensemble de données de classification d'images au format TFRecord. Si vous n'utilisez pas de modèle de classification d'images, vous devez convertir vous-même votre ensemble de données au format TFRecord. Pour en savoir plus, consultez la section TFRecord et tf.Example.

Réglages d'hyperparamètres

Pour améliorer les performances du modèle avec votre ensemble de données, vous pouvez régler ses hyperparamètres. Vous trouverez des informations sur les hyperparamètres communs à tous les modèles compatibles avec des TPU sur GitHub. Des informations sur les hyperparamètres spécifiques au modèle sont disponibles dans le code source de chaque modèle. Pour en savoir plus sur ces réglages, consultez les pages Présentation des réglages d'hyperparamètres, Utiliser le service de réglage d'hyperparamètres et Régler les hyperparamètres.

Inférence

Une fois que vous avez entraîné votre modèle, vous pouvez l'utiliser pour l'inférence (également appelée prédiction). AI Platform est une solution basée sur le cloud permettant de développer, d'entraîner et de déployer des modèles de machine learning. Une fois un modèle déployé, vous pouvez utiliser le service AI Platform Prediction.