Régler 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 les composants facturables suivants de Google Cloud :

Compute Engine
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.

Ouvrez une fenêtre Cloud Shell.

Ouvrir Cloud Shell
Créez une variable pour l'ID de votre projet.
```
export PROJECT_ID=project-id
```
Configurez Google Cloud CLI pour utiliser le projet dans lequel vous souhaitez créer Cloud TPU.
```
gcloud config set project ${PROJECT_ID}
```

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

Créez un bucket Cloud Storage à l'aide de la commande suivante :

Remarque : Dans la commande suivante, remplacez bucket-name par le nom que vous souhaitez attribuer au bucket.
```
gsutil mb -p ${PROJECT_ID} -c standard -l us-central1 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. La commande permettant de créer un TPU (gcloud compute tpus execution-groups create pour l'architecture du nœud TPU ou gcloud compute tpus tpu-vm create pour l'architecture de la VM TPU) configure 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.
Lancez une VM Compute Engine et Cloud TPU à l'aide de la commande gcloud. La commande à utiliser varie selon que vous utilisez une VM TPU ou un nœud TPU. Pour en savoir plus sur les deux architectures de VM, consultez la page Architecture du système. Pour en savoir plus sur la commande gcloud, consultez la documentation de référence de gcloud.
VM TPU
```
$ gcloud compute tpus tpu-vm create bert-tutorial \
--zone=us-central1-b \
--accelerator-type=v3-8 \
--version=tpu-vm-tf-2.11.0
```
Description des options de commande

zone

Zone dans laquelle vous prévoyez de créer votre Cloud TPU.

accelerator-type

Le type de Cloud TPU à créer.

version

Version du logiciel Cloud TPU.
Nœud TPU
```
$ gcloud compute tpus execution-groups create \
  --name=bert-tutorial \
  --zone=us-central1-b \
  --tf-version=2.11.0 \
  --machine-type=n1-standard-1 \
  --accelerator-type=v3-8 
```
Description des options de commande

name

Nom du Cloud TPU à créer.

zone

Zone dans laquelle vous prévoyez de créer votre Cloud TPU.

tf-version

La version de TensorFlow ctpu est installée sur la VM.

machine-type

Type de machine de la VM Compute Engine à créer.

accelerator type

Type de Cloud TPU à créer.
Remarque : Si vous avez plusieurs projets, vous devez spécifier l'ID du projet avec l'option --project.
Si vous n'êtes pas automatiquement connecté à l'instance Compute Engine, connectez-vous en exécutant la commande ssh suivante. Lorsque vous êtes connecté à la VM, votre invite d'interface système passe de username@vm-name à username@projectname :
VM TPU
```
gcloud compute tpus tpu-vm ssh bert-tutorial --zone=us-central1-b
```
Nœud TPU
```
gcloud compute ssh bert-tutorial --zone=us-central1-b
```
À mesure que vous appliquez ces instructions, exécutez chaque commande commençant par (vm)$ dans la fenêtre de session de la VM.
Créez une variable d'environnement pour le nom du TPU.
VM TPU
```
(vm)$ export TPU_NAME=local
```
Nœud TPU
```
(vm)$ export TPU_NAME=bert-tutorial
```

Préparer l'ensemble de données

Définissez le bucket de stockage nécessaire pour stocker le modèle et l'ensemble de données:
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```

Copiez les fichiers de point de contrôle et de vocabulaire pré-entraînés dans votre bucket de stockage:

  (vm)$ curl https://storage.googleapis.com/tf_model_garden/nlp/bert/v3/uncased_L-12_H-768_A-12.tar.gz -o uncased_L-12_H-768_A-12.tar.gz
  (vm)$ mkdir -p uncased_L-12_H-768_A-12
  (vm)$ tar -xvf uncased_L-12_H-768_A-12.tar.gz
  (vm)$ mv tmp/temp_dir/raw/* uncased_L-12_H-768_A-12
  (vm)$ gsutil -m cp -R uncased_L-12_H-768_A-12 gs://bucket-name

Entraîner le modèle

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

  (vm)$ export INIT_CHECKPOINT=${STORAGE_BUCKET}/uncased_L-12_H-768_A-12/bert_model.ckpt
  (vm)$ export TFDS_DIR=${STORAGE_BUCKET}/tfds
  (vm)$ export VOCAB_FILE=${STORAGE_BUCKET}/uncased_L-12_H-768_A-12/vocab.txt
  (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/bert-output
  (vm)$ export TASK=mnli

Installez la configuration requise pour TensorFlow.

La commande à utiliser varie selon que vous utilisez une VM TPU ou un nœud TPU.

VM TPU

(vm)$ pip3 install -r /usr/share/tpu/models/official/requirements.txt

Nœud TPU

(vm)$ pip3 install --user -r /usr/share/models/official/requirements.txt
(vm)$ pip3 install tensorflow-datasets==4.6.0

Définir la variable d'environnement PYTHONPATH

VM TPU

(vm)$ export PYTHONPATH=/usr/share/tpu/models

Nœud TPU

(vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/models"

Accédez au répertoire où le modèle est stocké :
VM TPU
```
(vm)$ cd /usr/share/tpu/models
```
Nœud TPU
```
(vm)$ cd /usr/share/models
```

Exécutez le script d'entraînement :

(vm)$ python3 official/nlp/train.py \
  --tpu=${TPU_NAME} \
  --experiment=bert/sentence_prediction_text \
  --mode=train_and_eval \
  --model_dir=${MODEL_DIR} \
  --config_file=official/nlp/configs/experiments/glue_mnli_text.yaml \
  --params_override="runtime.distribution_strategy=tpu, task.init_checkpoint=${INIT_CHECKPOINT}, task.train_data.tfds_data_dir=${TFDS_DIR}, task.train_data.vocab_file=${VOCAB_FILE}, task.validation_data.tfds_data_dir=${TFDS_DIR}, task.validation_data.vocab_file=${VOCAB_FILE}, trainer.train_steps=2000"

Description des options de commande

tpu: Nom du Cloud TPU à utiliser pour l'entraînement.
mode: Valeurs possibles : train, eval, train_and_eval ou predict.
model_dir: Chemin d'accès Cloud Storage où les points de contrôle et les résumés sont stockés lors de l'entraînement du modèle. Vous pouvez réutiliser un dossier existant pour charger les points de contrôle générés précédemment et stocker des points de contrôle supplémentaires si les points de contrôle précédents ont été créés à l'aide d'un Cloud TPU de la même taille et de la même version TensorFlow.

Le script effectue un entraînement pour 2 000 étapes, puis exécute 307 étapes d'évaluation. Sur un TPU v3-8, après environ cinq minutes, le script d'entraînement doit se terminer et afficher des résultats semblables à ceux-ci:

I0719 00:47:52.683979 140297079573568 controller.py:457] train | step:   2000 | steps/sec:   26.3 | output:
{'cls_accuracy': 0.7249375,
 'learning_rate': 1.4670059e-05,
 'training_loss': 0.6740678}
train | step:   2000 | steps/sec:   26.3 | output:
{'cls_accuracy': 0.7249375,
 'learning_rate': 1.4670059e-05,
 'training_loss': 0.6740678}
I0719 00:47:53.184051 140297079573568 controller.py:277]  eval | step:   2000 | running 307 steps of evaluation...
eval | step:   2000 | running 307 steps of evaluation...

Effectuer un nettoyage

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.
Supprimez vos ressources Cloud TPU et Compute Engine. La commande à utiliser pour supprimer vos ressources varie selon que vous utilisez des VM TPU ou des nœuds TPU. Pour en savoir plus, consultez la page Architecture du système.
VM TPU
```
$ gcloud compute tpus tpu-vm delete bert-tutorial \
--zone=us-central1-b
```
Nœud TPU
```
$ gcloud compute tpus execution-groups delete bert-tutorial \
--zone=us-central1-b
```
Vérifiez que les ressources ont été supprimées en exécutant la commande gcloud compute tpus execution-groups list. La suppression peut prendre plusieurs minutes. La sortie de la commande suivante ne doit inclure aucune des ressources créées dans ce tutoriel :
VM TPU
```
$ gcloud compute tpus tpu-vm list --zone=us-central1-b
```
Nœud TPU
```
$ gcloud compute tpus execution-groups list --zone=us-central1-b
```
Supprimez votre bucket Cloud Storage à l'aide de gsutil, comme indiqué ci-dessous. Remplacez bucket-name par le nom de votre bucket Cloud Storage.
```
$ gsutil rm -r gs://bucket-name
```

Étapes suivantes

Les tutoriels TensorFlow Cloud TPU permettent généralement d'entraîner le modèle à 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. Pour utiliser un modèle d'inférence, vous pouvez entraîner les données sur un ensemble de données public ou sur votre propre ensemble de données. Les modèles TensorFlow entraînés sur des Cloud TPU nécessitent généralement 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 page TFRecord et tf.Example.

Réglages d'hyperparamètres

Pour améliorer les performances du modèle sur 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 aux modèles 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 votre modèle entraîné, vous pouvez l'utiliser pour l'inférence (également appelée prédiction). AI Platform est une solution 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.

Découvrez les outils TPU dans TensorBoard.