Cette page a été traduite par l'API Cloud Translation.

Optimisation de 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

Dans ce document, vous utilisez 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 la 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 à votre bucket.
```
gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=us-central1
```
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 que vous utilisez pour créer un TPU gcloud compute tpus tpu-vm create configure les autorisations par défaut pour 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 se trouver dans la même région que votre TPU (VM).
Lancez une VM TPU à l'aide de gcloud. Pour en savoir plus, consultez les Documentation de référence gcloud
```
$ gcloud compute tpus tpu-vm create bert-tutorial \
  --zone=us-central1-b \
  --accelerator-type=v3-8 \
  --version=tpu-vm-tf-2.17.0-se
```
Description des options de commande

zone

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

accelerator-type

Le type d'accélérateur spécifie la version et la taille de la ressource Cloud TPU que vous souhaitez créer. Pour en savoir plus sur les types d'accélérateurs compatibles avec chaque version de TPU, consultez Versions de TPU.

version

Version logicielle de Cloud TPU.

Remarque : Si vous avez plusieurs projets, vous devez spécifier l'ID du projet avec l'option --project.
Se connecter à l'instance de VM TPU à l'aide de SSH Une fois connecté à la VM, l'invite de l'interface système passe de username@projectname à username@vm-name:
```
gcloud compute tpus tpu-vm ssh bert-tutorial --zone=us-central1-b
```
Important :À partir de ce moment-là, le préfixe (vm) $ signifie que vous devez exécutez la commande sur l'instance de VM Compute Engine.
Créez une variable d'environnement pour le nom du TPU.
```
(vm)$ export TPU_NAME=local
```

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)$ gcloud storage cp uncased_L-12_H-768_A-12 ${STORAGE_BUCKET} --recursive

Entraîner le modèle

Définissez plusieurs valeurs de paramètre requises lorsque vous pour entraîner et évaluer le 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.

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

Définir la variable d'environnement PYTHONPATH

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

Accédez au répertoire où le modèle est stocké :
```
(vm)$ cd /usr/share/tpu/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: Une des personnes suivantes : train, eval, train_and_eval, ou predict.
model_dir: Chemin d'accès Cloud Storage où sont stockés les points de contrôle et les résumés pendant l'entraînement du modèle. Vous pouvez réutiliser un dossier existant pour le charger précédemment des points de contrôle générés et de stocker des points de contrôle supplémentaires les points de contrôle précédents ont été créés à l'aide d'un Cloud TPU et la même version de TensorFlow.

Le script effectue 2 000 pas d'entraînement, puis 307 pas d'évaluation. Sur un TPU v3-8, après environ cinq minutes, le script d'entraînement devrait effectuer 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.

$ gcloud compute tpus tpu-vm delete bert-tutorial \
  --zone=us-central1-b

Vérifiez que les ressources ont été supprimées en exécutant la commande gcloud compute tpus tpu-vm list. La suppression peut prendre plusieurs minutes. Le résultat de la commande suivante ne doit inclure aucune des ressources créées dans ce tutoriel:
```
$ gcloud compute tpus tpu-vm list --zone=us-central1-b
```
Supprimez votre bucket Cloud Storage à l'aide de gcloud CLI, comme indiqué. dans l'exemple suivant. Remplacez bucket-name par le nom de votre bucket Cloud Storage.
```
$ gcloud storage rm gs://bucket-name --recursive
```

Étape suivante

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. À utiliser un modèle pour l'inférence, vous pouvez entraîner les données sur une couche ensemble de données ou votre propre jeu de données. Modèles TensorFlow entraînés sur des Cloud TPU nécessitent généralement des jeux de données TFRecord.

Vous pouvez utiliser l'outil de conversion des ensembles de données exemple pour convertir une image de classification au format TFRecord. Si vous n'utilisez pas d'image vous devrez convertir votre ensemble de données Format TFRecord vous-même. Pour en savoir plus, consultez les sections 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 hyperparamètres. Vous trouverez des informations sur les hyperparamètres communs à tous Modèles compatibles TPU sur GitHub Pour en savoir plus sur les hyperparamètres propres au modèle, consultez la source de code pour chaque du modèle de ML. Pour en savoir plus sur le réglage des hyperparamètres, consultez la section Présentation réglage des hyperparamètres et régler hyperparamètres.

Inférence

Une fois votre modèle entraîné, vous pouvez l'utiliser pour l'inférence (également appelée des prédictions). Vous pouvez utiliser le convertisseur d'inférence Cloud TPU de Google pour préparer et optimiser Modèle TensorFlow pour l'inférence sur Cloud TPU v5e. Pour plus à propos de l'inférence sur Cloud TPU v5e, consultez la page Inférence Cloud TPU v5e présentation.

Découvrez les outils TPU dans TensorBoard.