Optimiser BERT avec Cloud TPU : tâches de classification de phrases et de paires de phrases (TF 2.x)

Ce tutoriel vous explique comment entraîner le modèle BERT (Bidirectional Encoder Representations from Transformers) sur Cloud TPU.

BERT est une méthode permettant de pré-entraîner des représentations du langage. Le pré-entraînement fait référence à la façon dont le modèle BERT est entraîné pour la première fois à partir d'une importante source de texte, telle que Wikipédia. Vous pouvez ensuite appliquer les résultats de l'entraînement à d'autres tâches de traitement du langage naturel, tels que des systèmes de questions-réponses et l'analyse des sentiments. BERT et Cloud TPU vous permettent d'entraîner de nombreux modèles de traitement du langage naturel en environ 30 minutes.

Pour en savoir plus sur BERT, consultez les ressources suivantes :

Objectifs

  • Créer un bucket Cloud Storage pour stocker votre ensemble de données et la sortie du modèle
  • Exécuter la tâche d'entraînement
  • Vérifier les résultats

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

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 compte de service pour le projet Cloud TPU.

    gcloud beta services identity create --service tpu.googleapis.com --project $PROJECT_ID
    

    La commande renvoie un compte de service Cloud TPU au format suivant :

    service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com
    
  5. 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. L'outil ctpu up utilisé dans ce tutoriel définit les autorisations par défaut pour le compte de service Cloud TPU que vous avez configuré à l'étape précédente. Si vous souhaitez utiliser des autorisations plus précises, vérifiez les autorisations de niveau d'accès.

    L'emplacement du bucket doit être situé dans la même région que votre Compute Engine (VM) et votre nœud Cloud TPU.

  6. Lancez une VM Compute Engine et Cloud TPU à l'aide de la commande ctpu up.

    $ ctpu up --tpu-size=v3-8 \
      --name=bert-tutorial \
      --machine-type=n1-standard-8 \
      --zone=europe-west4-a \
      --tf-version=2.3.1
    

    Description des options de commande

    tpu-size
    Type du Cloud TPU à créer.
    name
    Nom du Cloud TPU à créer.
    machine-type
    Type de machine de la VM Compute Engine à créer.
    zone
    Zone dans laquelle vous prévoyez de créer votre Cloud TPU.
    tf-version
    La version de Tensorflow que ctpu installe sur la VM.

    Pour plus d'informations sur l'utilitaire CTPU, consultez la section Référence CTPU.

  7. La configuration que vous avez spécifiée apparaît. Saisissez y pour approuver ou n pour annuler.

  8. 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 bert-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.

  9. Créez une variable d'environnement pour le nom du TPU.

    (vm)$ export TPU_NAME=bert-tutorial
    

Préparer l'ensemble de données

  1. Depuis votre machine virtuelle (VM) Compute Engine, installez le fichier requirements.txt.

    (vm)$ sudo pip3 install -r /usr/share/models/official/requirements.txt
    
  2. Facultatif : téléchargez download_glue_data.py

    Ce tutoriel utilise l'analyse comparative GLUE (General Language Understanding Evaluation, évaluation de la compréhension générale du langage) pour évaluer et analyser les performances du modèle. Pour ce tutoriel, les données GLUE sont fournies à l'adresse gs://cloud-tpu-checkpoints/bert/classification.

    Si vous souhaitez utiliser des données GLUE brutes et créer des enregistrements TFRecord, suivez les instructions de traitement de l'ensemble de données sur GitHub.

Définir les valeurs des paramètres

Définissez plusieurs valeurs de paramètres requises lors de l'entraînement et de l'évaluation du modèle :

(vm)$ export STORAGE_BUCKET=gs://bucket-name
(vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/models"
(vm)$ export BERT_BASE_DIR=gs://cloud-tpu-checkpoints/bert/keras_bert/uncased_L-24_H-1024_A-16
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/bert-output
(vm)$ export GLUE_DIR=gs://cloud-tpu-checkpoints/bert/classification
(vm)$ export TASK=mnli

Entraîner le modèle

Exécutez la commande suivante depuis votre VM Compute Engine :

(vm)$ python3 /usr/share/models/official/nlp/bert/run_classifier.py \
  --mode='train_and_eval' \
  --input_meta_data_path=${GLUE_DIR}/${TASK}_meta_data \
  --train_data_path=${GLUE_DIR}/${TASK}_train.tf_record \
  --eval_data_path=${GLUE_DIR}/${TASK}_eval.tf_record \
  --bert_config_file=${BERT_BASE_DIR}/bert_config.json \
  --init_checkpoint=${BERT_BASE_DIR}/bert_model.ckpt \
  --train_batch_size=32 \
  --eval_batch_size=32 \
  --learning_rate=2e-5 \
  --num_train_epochs=1 \
  --model_dir=${MODEL_DIR} \
  --distribution_strategy=tpu \
  --tpu=${TPU_NAME} \
  --steps_per_loop=1000

Description des options de commande

mode
Si défini sur train_and_eval, ce script entraîne et évalue le modèle. Si défini sur "export_only", il exporte un modèle enregistré.
input_meta_data_path
Chemin d'accès à un fichier contenant des métadonnées sur l'ensemble de données à utiliser pour l'entraînement et l'évaluation.
train_data_path
Chemin d'accès Cloud Storage pour l'entrée d'entraînement. Dans cet exemple, il est défini sur l'ensemble de données fake_imagenet.
eval_data_path
Chemin d'accès Cloud Storage pour l'entrée d'évaluation. Dans cet exemple, il est défini sur l'ensemble de données fake_imagenet.
init_checkpoint
Chemin d'accès au fichier JSON contenant le point de contrôle initial du modèle BERT pré-entraîné.
train_batch_size
Taille de lot d'entraînement.
eval_batch_size
Taille de lot d'évaluation.
learning_rate
Taux d'apprentissage.
num_train_epochs
Nombre d'entraînements du modèle utilisant l'ensemble de données complet.
model_dir
Spécifie le répertoire dans lequel les points de contrôle et les résumés sont stockés lors de l'entraînement du modèle. Si ce dossier n'existe pas, le programme le crée. Lorsque vous utilisez un Cloud TPU, le répertoire model_dir doit être un chemin d'accès à Cloud Storage ("gs://..."). Vous pouvez réutiliser un dossier existant pour charger les données de point de contrôle actuelles et stocker des points de contrôle supplémentaires tant que les points de contrôle précédents ont été créés avec un TPU de la même taille et la même version de TensorFlow.
distribution_strategy
Pour entraîner le modèle ResNet sur un TPU, vous devez définir distribution_strategy sur tpu.
tpu
Nom du Cloud TPU. Cette valeur est définie en spécifiant la variable d'environnement (TPU_NAME).

Vérifier les résultats

L'entraînement dure environ deux minutes sur un TPU v3-8. Une fois le script terminé, des résultats semblables aux lignes suivantes devraient s'afficher :

Training Summary:
{'total_training_steps': 12271, 'train_loss': 0.0, 'last_train_metrics': 0.0,
 'eval_metrics': 0.8608226180076599}

Pour améliorer la précision, définissez --num_tain_epochs=3. L'entraînement du script prend environ une heure.

Nettoyer

  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 votre environnement Cloud Shell, exécutez ctpu delete avec les indicateurs --name et --zone que vous avez utilisés lors de la configuration de la VM Compute Engine et du Cloud TPU. Cela supprime à la fois votre VM et votre Cloud TPU.

    $ ctpu delete --name=bert-tutorial \
      --zone=europe-west4-a
    
  3. Exécutez ctpu status pour vérifier qu'il ne reste aucune instance allouée afin d'éviter des frais inutiles liés à l'utilisation des ressources TPU. La suppression peut prendre plusieurs minutes. Si vous n'avez plus d'instances allouées, une réponse de ce type s'affiche :

    $ ctpu status --name=bert-tutorial --zone=europe-west4-a
    
    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 BERT à 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.