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

Exécuter MNIST sur Cloud TPU (TF 2.x)

Ce tutoriel propose une vue d'ensemble du modèle MNIST, décrit comment télécharger l'exemple de code de TPU MNIST TensorFlow et fournit un guide relatif à l'exécution du code sur Cloud TPU.

Clause de non-responsabilité

Ce tutoriel utilise un ensemble de données tiers. Google ne fournit aucune représentation, une autre garantie quant à la validité ou à tout autre aspect ensemble de données.

Description du modèle

L'ensemble de données MNIST contient un grand nombre d'images de chiffres manuscrits compris entre 0 et 9, ainsi que les étiquettes qui identifient le chiffre de chaque image.

Ce tutoriel entraîne un modèle de machine learning afin de classer des images en se basant sur l'ensemble de données MNIST. Après l'entraînement, le modèle classe les images entrantes en 10 catégories (0 à 9) en fonction de ce qu'il a appris sur les images manuscrites dans l'ensemble de données MNIST. Vous pouvez ensuite envoyer au modèle une image qu'il n'a pas encore vue et le modèle identifie le chiffre de l'image en fonction de ce qu'il appris pendant l'entraînement.

L'ensemble de données MNIST a été divisé en trois parties :

60 000 exemples de données d'entraînement
10 000 exemples de données de test
5 000 exemples de données de validation

Le modèle est constitué d'une combinaison de sept couches :

deux couches de convolution
deux couches de pooling maximal
deux couches denses (entièrement connectées)
une couche d'abandon

La perte est calculée à l'aide de l'entropie croisée catégorique.

Cette version du modèle MNIST utilise l'API Keras, qui est recommandée pour créer et exécuter un modèle de machine learning sur un Cloud TPU.

Keras simplifie le processus de développement des modèles en masquant la plupart des qui vous permet également de basculer entre le TPU et d'autres plates-formes de test comme les GPU ou les CPU.

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}
```
La première fois que vous exécutez cette commande dans une nouvelle VM Cloud Shell, une page Authorize Cloud Shell s'affiche. Cliquez sur Authorize en bas de la page pour autoriser gcloud à effectuer des appels d'API Google Cloud avec vos identifiants.

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 gcloud utilisée dans ce tutoriel configure les autorisations par défaut pour le compte de service Cloud TPU que vous avez configurés dans à l'étape précédente. Si vous souhaitez utiliser des autorisations plus précises, vérifiez les autorisations de niveau d'accès.
Créez une VM TPU à l'aide de la commande gcloud.
```
$ gcloud compute tpus tpu-vm create mnist-tutorial \
   --zone=us-central1-b \
   --accelerator-type=v3-8 \
   --version=tpu-vm-tf-2.17.0-pjrt \
 
```
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.

Pour en savoir plus sur la commande gcloud, consultez la documentation de référence de gcloud.
Connectez-vous à l'instance Compute Engine via SSH. Lorsque vous êtes connecté à la VM, l'invite de l'interface système passe de username@projectname à username@vm-name:
```
gcloud compute tpus tpu-vm ssh mnist-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
```

Installez la configuration requise pour TensorFlow.

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

Entraîner le modèle

Le code source du modèle de TPU MNIST est disponible sur GitHub.

Définissez ces variables : Remplacez bucket-name par le nom de votre bucket :

(vm)$ export STORAGE_BUCKET=gs://bucket-name
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/mnist
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/data

Définissez la variable d'environnement PYTHONPATH.

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

Lorsque vous créez votre TPU, si vous définissez le paramètre --version sur une version se terminant par -pjrt, définissez les variables d'environnement suivantes pour activer l'environnement d'exécution PJRT :
```
  (vm)$ export NEXT_PLUGGABLE_DEVICE_USE_C_API=true
  (vm)$ export TF_PLUGGABLE_DEVICE_LIBRARY_PATH=/lib/libtpu.so
```

Accédez au répertoire où le modèle est stocké :

(vm)$ cd /usr/share/tpu/models/official/legacy/image_classification

Exécutez le script d'entraînement MNIST :
```
(vm)$ python3 mnist_main.py \
  --tpu=${TPU_NAME} \
  --model_dir=${MODEL_DIR} \
  --data_dir=${DATA_DIR} \
  --train_epochs=10 \
  --distribution_strategy=tpu \
  --download
```
Description des options de commande

tpu

Nom du Cloud TPU. S'il n'est pas spécifié lors de la configuration de la VM Compute Engine et du Cloud TPU, votre nom d'utilisateur est utilisé par défaut.

model_dir

Bucket Cloud Storage où sont stockés les points de contrôle et les résumés pendant l'entraînement. Vous pouvez utiliser un dossier existant pour le charger des points de contrôle générés sur un TPU de même taille et sur TensorFlow version.

data_dir

Chemin d'accès Cloud Storage de l'entrée d'entraînement. Il est défini sur fake_imagenet dans cet exemple.

train_epochs

Nombre d'époques d'entraînement du modèle.

distribution_strategy

Pour entraîner le modèle ResNet sur un Cloud TPU, définissez distribution_strategy à tpu.

download

Si la valeur est true, le script télécharge et prétraite l'ensemble de données MNIST, s'il n'a pas déjà été téléchargé.

Le script d'entraînement s'exécute en moins de cinq minutes sur un Cloud TPU v3-8 et affiche un résultat semblable à celui-ci :

Run stats:
{
  'accuracy_top_1': 0.9762369990348816,
  'eval_loss': 0.07863274961709976,
  'loss': 0.1111728847026825,
  'training_accuracy_top_1': 0.966645359992981
}

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

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 mnist-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 la commande suivante. 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'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 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. 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 prédiction). Vous pouvez utiliser l'outil de conversion d'inférence Cloud TPU pour préparer et optimiser un 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.

Exécutez un colab Cloud TPU qui montre comment exécuter un modèle de classification d'images à l'aide de vos propres données d'image.
Découvrez les autres tutoriels Cloud TPU.
Apprenez à utiliser les outils de surveillance TPU dans TensorBoard.
Vérifiez les performances sur un modèle à grande échelle en exécutant l'exemple ResNet.