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

Entraîner le modèle Mask RCNN sur Cloud TPU (TF 2.x)

Présentation

Ce tutoriel explique comment exécuter le modèle Mask RCNN à l'aide de Cloud TPU. avec l'ensemble de données COCO.

Mask RCNN est un réseau de neurones profond conçu pour détecter des objets la segmentation d'image, l'un des défis les plus complexes de la vision par ordinateur.

Le modèle Mask RCNN génère des cadres de délimitation et des masques de segmentation pour chaque une instance d'objet dans l'image. Le modèle est basé sur Réseau de pyramides à caractéristiques (FPN) et réseau backbone ResNet50.

Ce tutoriel utilise l'API Tensorflow Keras pour entraîner le modèle. Keras Il s'agit d'une API TensorFlow de haut niveau qui permet de créer et d'exécuter de machine learning sur Cloud TPU. L'API simplifie le développement du modèle en masquant la majeure partie de l'implémentation de bas niveau, ce qui facilite la basculer entre un TPU et d'autres plates-formes telles que des GPU ou des processeurs.

Ces instructions partent du principe que vous savez déjà entraîner un modèle Cloud TPU. Si vous découvrez Cloud TPU, vous trouverez les instructions de base sur la page Démarrage rapide.

Objectifs

Préparer l'ensemble de données COCO
Créer un bucket Cloud Storage pour stocker votre ensemble de données et la sortie du modèle
Configurer les ressources TPU pour l'entraînement et l'évaluation
Exécuter les tâches d'entraînement et d'évaluation sur un seul Cloud TPU ou sur un pod Cloud TPU

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

Avant de commencer ce tutoriel, vérifiez que votre projet Google Cloud est correctement configuré.

Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Ce tutoriel utilise des composants facturables de Google Cloud. Consultez la grille tarifaire de Cloud TPU pour estimer vos coûts.

Préparer l'ensemble de données COCO

Ce tutoriel utilise l'ensemble de données COCO. L'ensemble de données doit être au format TFRecord sur un bucket Cloud Storage pour l'entraînement.

Si l'ensemble de données COCO est déjà préparé dans un bucket Cloud Storage se trouve dans la zone que vous utiliserez pour entraîner le modèle, vous pouvez passer directement à l'entraînement sur un seul appareil. Sinon, suivez les étapes suivantes pour préparer le jeu de données.

Ouvrez une fenêtre Cloud Shell.

Ouvrir Cloud Shell

Dans Cloud Shell, configurez gcloud avec votre projet. ID.

export PROJECT_ID=project-id
gcloud config set project ${PROJECT_ID}

Dans Cloud Shell, 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-central2
```

Créer une VM Compute Engine pour télécharger et prétraiter l'ensemble de données Pour plus pour en savoir plus, consultez Créez et démarrez une instance Compute Engine.

$ gcloud compute instances create vm-name \
    --zone=us-central2-b \
    --image-family=ubuntu-2204-lts \
    --image-project=ubuntu-os-cloud \
    --machine-type=n1-standard-16 \
    --boot-disk-size=300GB

Connectez-vous en SSH à la VM Compute Engine:
```
$ gcloud compute ssh vm-name --zone=us-central2-b
```
Lorsque vous vous connectez à la VM, l'invite de l'interface système passe De username@projectname à username@vm-name.
Configurez deux variables, l'une pour le bucket de stockage créé précédemment et une pour le répertoire qui contient les données d'entraînement (DATA_DIR) dans le bucket de stockage.
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
```
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
```

Installez les packages nécessaires au prétraitement des données.

(vm)$ sudo apt-get update && \
  sudo apt-get install python3-pip && \
  sudo apt-get install -y python3-tk && \
  pip3 install --user Cython matplotlib opencv-python-headless pyyaml Pillow numpy absl-py tensorflow && \
  pip3 install --user "git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI"

Exécutez le script download_and_preprocess_coco.sh pour convertir l'ensemble de données COCO dans un ensemble de fichiers TFRecord (*.tfrecord) que l'entraînement s'attend à l'application.
```
(vm)$ git clone https://github.com/tensorflow/tpu.git
(vm)$ sudo bash tpu/tools/datasets/download_and_preprocess_coco.sh ./data/dir/coco
```
Cela installe les bibliothèques requises et exécute le script de prétraitement. Elle génère les fichiers *.tfrecord dans votre répertoire de données local. L'exécution du script de téléchargement et de conversion COCO prend environ une heure.
Copiez les données dans votre bucket Cloud Storage.

Après avoir converti les données au format TFRecord, copiez-les depuis le stockage local dans votre bucket Cloud Storage à l'aide de gcloud CLI. Vous devez copier également les fichiers d'annotation. Ces fichiers permettent de valider des performances.
```
(vm)$ gcloud storage cp ./data/dir/coco/*.tfrecord ${DATA_DIR}
(vm)$ gcloud storage cp ./data/dir/coco/raw-data/annotations/*.json ${DATA_DIR}
```
Déconnectez-vous de la VM Compute Engine :
```
(vm)$ exit
```
Votre invite devrait maintenant être username@projectname, indiquant que vous êtes dans Cloud Shell.

Supprimez votre VM Compute Engine:

$ gcloud compute instances delete vm-name \
--zone=us-central2-b

Entraînement sur un seul appareil Cloud TPU

Ouvrez une fenêtre Cloud Shell.

Ouvrir Cloud Shell
Créez une variable d'environnement 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 la 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. de la page pour permettre à gcloud d'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

Exporter les variables de configuration TPU

Exportez votre ID de projet, le nom que vous souhaitez utiliser pour vos ressources TPU, et la zone dans laquelle vous allez entraîner le modèle. le modèle et stocker toutes les données liées à l'entraînement.
```
$ export TPU_NAME=mask-rcnn-tutorial
$ export ZONE=europe-west4-a
```
Lancez une VM Compute Engine et Cloud TPU
```
$ gcloud compute tpus tpu-vm create mask-rcnn-tutorial \
   --zone=${ZONE} \
   --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.

Remarque :La première fois que vous créez une VM TPU sur un projet, il faut plusieurs minutes pour effectuer des tâches de démarrage, telles que la propagation de clé SSH et l'activation de l'API.

Pour en savoir plus sur la commande gcloud, consultez la documentation de référence de gcloud.
Connectez-vous à l'instance Compute Engine à l'aide de 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 mask-rcnn-tutorial --zone=${ZONE}
```
Important :À partir de ce moment-là, le préfixe (vm) $ signifie que vous devez exécuter sur l'instance de VM Compute Engine.

Installez la configuration requise pour TensorFlow.

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

Définissez la variable de nom Cloud TPU.
```
(vm)$ export TPU_NAME=local
```
Configurez les variables d'environnement suivantes en remplaçant bucket-name par le nom du bucket Cloud Storage qui stocke l'ensemble de données COCO :
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```

Ajoutez les variables d'environnement pour les répertoires de données et de modèles.

(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/mask-rcnn

Ajoutez les variables d'environnement requises supplémentaires :

(vm)$ export RESNET_CHECKPOINT=gs://cloud-tpu-checkpoints/retinanet/resnet50-checkpoint-2018-02-07
(vm)$ export TRAIN_FILE_PATTERN=${DATA_DIR}/train-*
(vm)$ export EVAL_FILE_PATTERN=${DATA_DIR}/val-*
(vm)$ export VAL_JSON_FILE=${DATA_DIR}/instances_val2017.json

Définissez la variable d'environnement PYTHONPATH :

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

Lors de la création de 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/vision
```

Le script suivant exécute un exemple d'entraînement pour 10 étapes d'entraînement. et 10 étapes d'évaluation. Cela prend environ 6 minutes sur un v3-8. L'entraînement vers la convergence nécessite environ 22 500 pas et environ 6 heures sur un TPU v3-8.

Exécutez la commande suivante pour entraîner le modèle Mask-RCNN :

(vm)$ python3 train.py \
  --tpu=${TPU_NAME} \
  --experiment=maskrcnn_resnetfpn_coco \
  --mode=train_and_eval \
  --config_file=configs/experiments/maskrcnn/r50fpn_640_coco_scratch_tpu4x4.yaml \
  --model_dir=${MODEL_DIR} \
  --params_override="task.train_data.input_path=${TRAIN_FILE_PATTERN},task.validation_data.input_path=${EVAL_FILE_PATTERN},task.annotation_file=${VAL_JSON_FILE},runtime.distribution_strategy=tpu,trainer.train_steps=10,trainer.validation_steps=10,task.train_data.global_batch_size=8,task.validation_data.global_batch_size=8"

Description des options de commande

strategy_type: Stratégie de distribution.
tpu: Nom de votre TPU.
model_dir: Spécifie le répertoire dans lequel sont stockés les points de contrôle et les résumés. pendant l'entraînement du modèle. Si ce dossier est absent, le programme crée 1. Lorsque vous utilisez un Cloud TPU, la classe model_dir doit être un chemin d'accès Cloud Storage ("gs://..."). Vous pouvez réutiliser dossier existant pour charger les données de point de contrôle actuelles et les stocker des points de contrôle supplémentaires tant que les précédents créés à l'aide d'un TPU de même taille et de la même version de TensorFlow.

Une fois l'entraînement terminé, un message semblable au suivant s'affiche :

{'frcnn_box_loss': 0.033865165,
 'frcnn_cls_loss': 1.2535654,
 'learning_rate': 0.008266499,
 'mask_loss': 1.2039567,
 'model_loss': 2.821458,
 'rpn_box_loss': 0.034982488,
 'rpn_score_loss': 0.2950886,
 'total_loss': 4.340171,
 'training_loss': 4.340171}
train | step:     10 | steps/sec:    0.1 | output:
{'frcnn_box_loss': 0.033865165,
 'frcnn_cls_loss': 1.2535654,
 'learning_rate': 0.008266499,
 'mask_loss': 1.2039567,
 'model_loss': 2.821458,
 'rpn_box_loss': 0.034982488,
 'rpn_score_loss': 0.2950886,
 'total_loss': 4.340171,
 'training_loss': 4.340171}

Elle est suivie du résultat des étapes d'évaluation.

Vous avez terminé l'entraînement et l'évaluation sur un seul appareil. Utilisez les pour supprimer les ressources TPU actuelles sur un seul appareil.

Déconnectez-vous de l'instance Compute Engine :
```
(vm)$ exit
```
Votre invite devrait maintenant être username@projectname, indiquant que vous êtes dans Cloud Shell.
Supprimez la ressource TPU.
```
$ gcloud compute tpus tpu-vm delete mask-rcnn-tutorial \
    --zone=europe-west4-a
```
Description des options de commande

zone

Zone où se trouvait votre Cloud TPU.

À ce stade, vous pouvez terminer ce tutoriel et effectuer un nettoyage, ou continuer à explorer l'exécution du modèle sur des pods Cloud TPU.

Mettre à l'échelle votre modèle avec les pods Cloud TPU

L'entraînement de votre modèle sur des pods Cloud TPU peut nécessiter quelques modifications à votre script d'entraînement. Pour en savoir plus, consultez la section Entraîner sur des pods TPU.

Entraînement avec un pod TPU

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. de la page pour permettre à gcloud d'effectuer des appels d'API Google Cloud avec vos identifiants.
Créez un compte de service pour le projet Cloud TPU.

Les comptes de service permettent au service Cloud TPU d'accéder à d'autres aux services Google Cloud.
```
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
```
Si vous avez déjà préparé l'ensemble de données COCO et l'avez déplacé vers votre espace de stockage vous pouvez l'utiliser à nouveau pour l'entraînement des pods. Si vous n'avez pas encore préparé préparez l'ensemble de données COCO et revenez ici pour le configurer la formation.
Lancer un pod Cloud TPU

Ce tutoriel spécifie un pod v3-32. Pour connaître les autres options de pod, consultez Versions de TPU.
<ph type="x-smartling-placeholder">
</ph> Remarque:Si la capacité actuellement disponible est insuffisante pour créer le pod TPU, vous pouvez mettre votre requête en file d'attente à l'aide de ressources en file d'attente. Les ressources en file d'attente vous permettent de recevoir de la capacité une fois qu'elle devient disponible. Pour demander vos ressources Cloud TPU en tant que ressources en file d'attente, utilisez la gcloud compute tpus queued-resources create. Pour en savoir plus, consultez Gérer les ressources en file d'attente
```
$ gcloud compute tpus tpu-vm create mask-rcnn-tutorial \
  --zone=${ZONE} \
  --accelerator-type=v3-32 \
  --version=tpu-vm-tf-2.17.0-pod-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.

Remarque :La première fois que vous exécutez gcloud sur un projet, prend environ cinq minutes pour effectuer des tâches de démarrage, telles que l'utilisation de clés SSH et l'activation de l'API.
Remarque :La première exécution de gcloud sur un projet prend environ cinq minutes. pour effectuer des tâches de démarrage telles que la propagation de clé SSH et l'activation de l'API.
Connectez-vous à l'instance Compute Engine à l'aide de 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 mask-rcnn-tutorial --zone=${ZONE}
```
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.

Installez la configuration requise pour TensorFlow.

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

Le script d'entraînement nécessite un package supplémentaire. Installez-le maintenant :
```
(vm)$ pip3 install --user tensorflow-model-optimization>=0.1.3
```

Définissez la variable de nom Cloud TPU.

(vm)$ export TPU_NAME=mask-rcnn-tutorial

Configurez les variables d'environnement suivantes en remplaçant bucket-name par le nom de votre bucket Cloud Storage :
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```

Ajoutez les variables d'environnement requises supplémentaires :

(vm)$ export RESNET_CHECKPOINT=gs://cloud-tpu-checkpoints/retinanet/resnet50-checkpoint-2018-02-07
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco
(vm)$ export TRAIN_FILE_PATTERN=${DATA_DIR}/train-*
(vm)$ export EVAL_FILE_PATTERN=${DATA_DIR}/val-*
(vm)$ export VAL_JSON_FILE=${DATA_DIR}/instances_val2017.json
(vm)$ export MODEL_DIR=${STORAGE_BUCKET}/mask-rcnn-pod

Définissez la variable d'environnement PYTHONPATH :

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

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

(vm)$ cd /usr/share/tpu/models/official/vision

(vm)$ cd /usr/share/models/official/legacy/detection

Entraîner le modèle

Cette procédure entraîne le modèle sur l'ensemble de données COCO en 10 étapes d'entraînement. Cette formation prend environ 10 minutes sur un Cloud TPU v3-32.

Remarque : Une fois l'entraînement lancé, vous pouvez vérifier qu'il est en cours d'exécution en surveillant votre activité TPU dans la console Cloud TPU. Depuis Compute Engine -> TPU, cliquez sur votre entrée de TPU. Une page présentant votre configuration TPU s'affiche. détails et un lien vers SUIVI. Cliquez sur SURVEILLANCE pour voir la situation actuelle activité TPU.
```
(vm)$ python3 train.py \
  --tpu=${TPU_NAME} \
  --experiment=maskrcnn_resnetfpn_coco \
  --mode=train_and_eval \
  --config_file=configs/experiments/maskrcnn/r50fpn_640_coco_scratch_tpu4x4.yaml \
  --model_dir=${MODEL_DIR} \
  --params_override="task.train_data.input_path=${TRAIN_FILE_PATTERN},task.validation_data.input_path=${EVAL_FILE_PATTERN},task.annotation_file=${VAL_JSON_FILE},runtime.distribution_strategy=tpu,trainer.train_steps=10,trainer.validation_steps=10,task.train_data.global_batch_size=256,task.validation_data.global_batch_size=256"
```
Description des options de commande

tpu

Nom de votre TPU.

model_dir

Spécifie le répertoire dans lequel sont stockés les points de contrôle et les résumés lors de l'entraînement du modèle. Si ce dossier est absent, le programme le crée. Lorsque vous utilisez un Cloud TPU, la classe 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 pour stocker des points de contrôle supplémentaires tant que les précédents créé à l'aide de Cloud TPU de même taille et de TensorFlow version.

params_override

Chaîne JSON qui remplace les paramètres de script par défaut.

Une fois l'entraînement terminé, un message semblable au suivant s'affiche:

 I0706 19:47:16.108213 139955064548416 controller.py:457] train | step: 10 | steps/sec:    0.1 | output:
    {'frcnn_box_loss': 0.05632668,
     'frcnn_cls_loss': 1.3012192,
     'learning_rate': 0.008266499,
     'mask_loss': 1.2371812,
     'model_loss': 2.9746659,
     'rpn_box_loss': 0.08227444,
     'rpn_score_loss': 0.2976642,
     'total_loss': 4.493513,
     'training_loss': 4.493513}
train | step:     10 | steps/sec:    0.1 | output:
    {'frcnn_box_loss': 0.05632668,
     'frcnn_cls_loss': 1.3012192,
     'learning_rate': 0.008266499,
     'mask_loss': 1.2371812,
     'model_loss': 2.9746659,
     'rpn_box_loss': 0.08227444,
     'rpn_score_loss': 0.2976642,
     'total_loss': 4.493513,
     'training_loss': 4.493513}

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.

Après avoir exécuté l'entraînement, supprimez la VM TPU et votre bucket de stockage.

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. Votre invite devrait maintenant être username@projectname, ce qui indique que vous êtes dans Cloud Shell.

Supprimez vos ressources Cloud TPU et Compute Engine.

$ gcloud compute tpus tpu-vm delete mask-rcnn-tutorial \
--zone=${ZONE}

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 TPU créées dans ce tutoriel:
```
$ gcloud compute tpus tpu-vm list --zone=${ZONE}
```
Exécutez la gcloud CLI comme indiqué, en remplaçant bucket-name par nom du bucket Cloud Storage que vous avez créé pour ce tutoriel:
```
$ 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.