Utiliser des outils Cloud TPU

Après avoir exécuté un script d'entraînement sur Cloud TPU, vous pouvez analyser les performances de votre modèle sur Cloud TPU à l'aide de TensorBoard.

TensorBoard est une suite d'outils conçus pour afficher visuellement les métriques TensorFlow. À l'aide du plug-in TensorBoard Cloud TPU Profiler, vous pouvez accéder aux données de profilage Cloud TPU dans TensorBoard. Le plug-in Cloud TPU Profiler permet de visualiser les performances des nœuds Cloud TPU de toutes tailles.

Lorsque vous installez le plug-in Cloud TPU Profiler, le script capture_tpu_profile est également installé. Vous utilisez le script capture_tpu_profile pour capturer un profil ou surveiller votre tâche Cloud TPU en continu (consultez la section Surveiller une tâche).

.

Lorsque vous utilisez le script capture_tpu_profile pour capturer un profil, deux fichiers (.trace et .traceable) sont enregistrés dans le bucket Google Cloud Storage que vous spécifiez. Le fichier .trace contient jusqu'à un million d'événements de trace pouvant être affichés dans le lecteur de traces. Le fichier .tracetable contient jusqu'à 2 Go d'événements de trace pouvant être affichés dans le lecteur de traces en flux continu.

Prérequis

Pour pouvoir utiliser les outils de profilage Cloud TPU décrits dans ce guide, vous devez effectuer les opérations suivantes :

Créer des ressources Cloud TPU

Vous aurez besoin d'une VM et d'un TPU pour suivre ce tutoriel. Suivez les instructions du tutoriel Cloud TPU EfficientNet jusqu'à la section Entraîner et évaluer le modèle EfficientNet avec fake_imagenet. N'exécutez pas encore le script d'entraînement. Le tutoriel EfficientNet vous explique comment créer une VM et un TPU, installer certaines bibliothèques et exécuter le script d'entraînement.

Installer le plug-in Cloud TPU Profiler TensorBoard

Ouvrez une nouvelle invite de commande et connectez-vous à la VM que vous avez créée dans la section précédente à l'aide de cette commande :

    (vm)$ gcloud compute ssh efficientnet-tutorial --zone=us-central1-b

Utilisez les commandes suivantes pour installer ou mettre à niveau le plug-in Cloud TPU Profiler TensorBoard :

  (vm)$ pip3 install --upgrade "cloud-tpu-profiler>=2.3.0"
  (vm)$ sudo pip3 install --upgrade -U "tensorboard>=2.3"
  (vm)$ sudo pip3 install --upgrade -U "tensorflow>=2.3"

Créez les variables d'environnement suivantes :

  (vm)$ export STORAGE_BUCKET=gs://bucket-name
  (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/efficientnet-2x
  (vm)$ export PATH="$PATH:`python -m site --user-base`/bin"
  (vm)$ export TPU_NAME=efficientnet-tutorial"

Capturer un profil

Dans votre première invite de commande, exécutez le script d'entraînement. Attendez que le résultat indique que votre modèle est en cours d'entraînement. La taille de ce fichier dépend de votre code ou de votre modèle. Recherchez un résultat semblable à Epoch 1/100. Vous pouvez également accéder à la page Cloud TPU, sélectionner votre TPU et afficher le graphe d'utilisation du processeur. Bien que cela n'indique pas l'utilisation du TPU, il s'avère utile de savoir que le TPU entraîne votre modèle. Pour capturer un profil, exécutez la commande suivante à partir de votre deuxième invite de commande :

  (vm)$ capture_tpu_profile --tpu=$TPU_NAME \
      --logdir=${MODEL_DIR}

Pendant l'exécution du modèle, le script capture_tpu_profile crée un répertoire (objet) et écrit les données de profilage dans le bucket Compute Engine que vous spécifiez avec le paramètre --logdir. Par défaut, capture_tpu_profile capture une trace de 2 secondes. Vous pouvez définir la durée de la trace à l'aide de l'option de ligne de commande --duration_ms.

Ouvrez une nouvelle invite de commande et connectez-vous à votre VM à l'aide de la commande suivante :

  (vm)$ gcloud compute ssh efficientnet-tutorial \
  --zone=us-central1-b \
  --ssh-flag=-L6006:localhost:6006

Créez les variables d'environnement suivantes.

  (vm)$ export STORAGE_BUCKET=gs://bucket-name
  (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/efficientnet-2x

Exécutez TensorBoard et faites-le pointer vers le répertoire contenant les données de profilage :

  (vm)$ tensorboard --logdir=${MODEL_DIR}

TensorBoard démarre un serveur Web et affiche son URL :

Serving TensorBoard on localhost; to expose to the network, use a proxy or pass --bind_all
TensorBoard 2.3.0 at http://localhost:6006/ (Press CTRL+C to quit)

Afficher les données de profilage dans TensorBoard

Ouvrez un navigateur Web et accédez à l'URL affichée dans le résultat de TensorBoard. Assurez-vous que TensorBoard a chargé entièrement les données de profilage en cliquant sur le bouton d'actualisation situé en haut et à droite de la page TensorBoard. Par défaut, la page TensorBoard affiche l'onglet "Scalars".

image

Graphes

TensorBoard fournit un certain nombre de visualisations, ou graphes, de votre modèle et de ses performances. Utilisez les graphes avec le lecteur de traces ou le lecteur de traces en flux continu pour affiner vos modèles et améliorer leurs performances sur Cloud TPU.

Graphe TensorFlow

Lors de la compilation du modèle, avant que celui-ci ne soit exécuté, TensorFlow génère un graphe exécuté sur Cloud TPU. Les données du graphe sont stockées dans le répertoire MODEL_DIR du bucket de stockage que vous spécifiez avec le paramètre --logdir. Vous pouvez afficher ce graphe sans exécuter capture_tpu_profile.

Pour afficher le graphe TensorFlow d'un modèle, sélectionnez l'onglet Graphes dans TensorBoard. La valeur par défaut de Color (Couleur) est Structure.

image

Un seul nœud dans le graphe de structure représente une opération TensorFlow.

Graphe de compatibilité TPU

L'onglet Graphs (Graphes) inclut un module de vérification de la compatibilité qui recherche et affiche les opérations TensorFlow pouvant potentiellement causer des problèmes lors de l'exécution d'un modèle.

Pour afficher le graphe de compatibilité TPU d'un modèle, sélectionnez l'onglet Graphs (Graphes) dans TensorBoard, puis sélectionnez TPU Compatibility (Compatibilité TPU). Le graphe indique les opérations compatibles (valides) en vert et les opérations incompatibles (non valides) en rouge.

image

Un nœud donné peut afficher les deux couleurs, chacune sous la forme d'un pourcentage des opérations compatibles avec Cloud TPU pour ce nœud. Pour voir un exemple, consultez la section Interpréter les résultats de compatibilité.

Le panneau de résumé de la compatibilité qui s'affiche à droite du graphe indique le pourcentage de toutes les opérations compatibles avec Cloud TPU, leurs attributs et la liste des opérations incompatibles pour un nœud sélectionné.

Cliquez sur une opération du graphe pour afficher ses attributs dans le panneau de résumé.

image

Notez que le vérificateur de compatibilité n'évalue pas les opérations attribuées de manière explicite à un appareil non-TPU qui utilise le placement manuel sur un appareil. De plus, il ne compile pas réellement le modèle pour l'exécution. Par conséquent, veillez à interpréter les résultats comme une estimation de la compatibilité.

Interpréter les résultats de compatibilité

Le diagramme suivant, généré à partir du modèle Abalone, présente un exemple de résumé de la compatibilité. Plusieurs opérations non disponibles y sont indiquées :

image

Aucun placement manuel sur un appareil n'a été spécifié pour ce modèle. Par conséquent, toutes les opérations ont été vérifiées, même celles devant toujours être exécutées sur le processeur, telles que les opérations "save" et "report_uninitialized_variables" affichées.

Deux opérations "AssignAdd" dans "root_mean_squared_error" représentent des problèmes potentiels.

Vous pouvez voir dans le code source que "root_mean_squared_error" n'est employé qu'en tant que métrique d'évaluation supplémentaire :

    # Calculate root mean squared error as additional eval metric
    eval_metric_ops = {
        "rmse": tf.metrics.root_mean_squared_error(
            tf.cast(labels, tf.float64), predictions)
    }

À moins qu'elle ne se produise dans une boucle d'entraînement, cette opération est normalement exécutée sur le processeur, donc le rapport d'erreurs peut être ignoré. En conclusion, le modèle est prêt à être exécuté sur Cloud TPU.

Profil

L'onglet Profil s'affiche une fois que vous avez capturé des données de modèle. Vous devrez peut-être cliquer sur le bouton d'actualisation situé en haut et à droite de la page TensorBoard. Une fois les données disponibles, cliquez sur l'onglet Profil pour afficher une sélection d'outils d'aide à l'analyse des performances :

Page de présentation du profil

La page de présentation (overview_page), disponible sous Profil, offre une vue générale des performances du modèle lors de la réalisation d'une capture. Elle propose une vue d'ensemble combinée de tous les TPU, ainsi qu'une analyse globale du pipeline d'entrée. La liste déroulante "Hôte" comporte une option permettant de sélectionner des TPU individuels.

La page affiche les données dans les panneaux suivants :

image

  • Performance summary (Résumé des performances)

    • Durée moyenne des étapes : durée moyenne des étapes calculée pour toutes les étapes échantillonnées
    • Durée d'inactivité de l'hôte : pourcentage de durée d'inactivité de l'hôte
    • Durée d'inactivité du TPU : pourcentage de durée d'inactivité du TPU
    • Utilisation de FLOPS : pourcentage d'utilisation des unités matricielles du TPU
    • Utilisation de la bande passante mémoire : pourcentage de la bande passante mémoire utilisée
  • Step-time graph (Graphe de durée des étapes). Affiche un graphe de la durée des étapes sur l'appareil (en millisecondes) pour toutes les étapes échantillonnées. La zone bleue correspond à la part du temps pendant laquelle les TPU ont été inactifs, dans l'attente des données d'entrée de l'hôte. La zone rouge indique la durée pendant laquelle Cloud TPU a réellement fonctionné.

  • Top 10 TensorFlow operations on TPU (Les 10 principales opérations TensorFlow sur TPU). Affiche les opérations TensorFlow ayant consommé le plus de temps :

    Chaque ligne affiche le temps propre d'une opération (en pourcentage du temps nécessaire à toutes les opérations), le temps cumulé, la catégorie, le nom et le taux de FLOPS atteint.

  • Run Environment (Environnement d'exécution)

    • Nombre d'hôtes utilisés
    • Type de TPU utilisé
    • Nombre de cœurs de TPU
    • Taille du lot d'entraînement
  • Recommendation for Next Steps (Recommandation pour les étapes suivantes). Indique quand un modèle est subordonné aux entrées et chaque fois que des problèmes surviennent avec Cloud TPU. Suggère des outils que vous pouvez employer pour localiser les goulots d'étranglement en matière de performances.

Analyseur du pipeline d'entrée

L'analyseur du pipeline d'entrée fournit des informations sur les résultats de performance issus du fichier input_pipeline.json qui est collecté par l'outil capture_tpu_profile.

Cet outil vous indique immédiatement si votre programme est subordonné aux entrées. Il peut vous guider dans l'analyse côté appareil et côté hôte pour déboguer toutes les étapes du pipeline qui créent des goulots d'étranglement.

Consultez les conseils en matière de performances du pipeline d'entrée pour obtenir des informations plus détaillées sur leur optimisation.

Pipeline d'entrée

Lorsqu'un programme TensorFlow lit les données d'un fichier, il commence en haut du graphe TensorFlow à la manière d'un pipeline. Le processus de lecture est divisé en plusieurs étapes de traitement des données connectées en série, la sortie d'une étape étant l'entrée de la suivante. Ce système de lecture se nomme pipeline d'entrée.

Pour lire des enregistrements à partir de fichiers, un pipeline type comprend les étapes suivantes :

  1. Lecture des fichiers
  2. Prétraitement des fichiers (facultatif)
  3. Transfert des fichiers de la machine hôte vers l'appareil

Un pipeline d'entrée inefficace peut considérablement ralentir votre application. Une application est considérée comme subordonnée aux entrées lorsqu'elle passe une part importante de son temps dans son pipeline d'entrée. Utilisez l'analyseur du pipeline pour comprendre d'où vient cette inefficacité.

Tableau de bord du pipeline d'entrée

Pour ouvrir l'analyseur du pipeline d'entrée, sélectionnez Profil, puis input_pipeline_analyzer dans la liste déroulante Outils.

Le tableau de bord contient trois sections :

image

  1. Summary (Résumé). Fournit un résumé global du pipeline d'entrée. Indique si votre application est subordonnée aux entrées et, le cas échéant, dans quelle mesure.
  2. Device-side analysis (Détails de l'analyse côté appareil). Affiche les résultats détaillés de l'analyse côté appareil, y compris la durée des étapes sur l'appareil et la plage de temps passé par celui-ci à attendre les données d'entrée sur les cœurs à chaque étape.
  3. Host-side analysis (Détails de l'analyse côté hôte). Affiche une analyse détaillée côté hôte, y compris une répartition du temps de traitement des entrées sur l'hôte.
Résumé du pipeline d'entrée

La première section indique si votre programme est subordonné aux entrées en présentant le pourcentage de temps que l'appareil a passé à attendre une entrée de l'hôte. Si vous utilisez un pipeline d'entrée standard qui a été mis en œuvre, l'outil indique à quoi la majeure partie du temps de traitement des entrées est employée. Par exemple :

image

Analyse côté appareil

La deuxième section détaille l'analyse côté appareil. Elle fournit des informations sur le temps passé sur l'appareil par rapport à l'hôte, et sur le temps que l'appareil a passé à attendre les données d'entrée de l'hôte.

image

  1. Statistiques sur la durée des étapes sur l'appareil. Indique la moyenne, l'écart type et la plage (minimum, maximum) de la durée des étapes sur l'appareil.
  2. Durée des étapes Affiche un graphe de la durée des étapes sur l'appareil (en millisecondes) pour toutes les étapes échantillonnées. La zone bleue correspond à la part du temps pendant laquelle les TPU ont été inactifs, dans l'attente des données d'entrée de l'hôte. La zone rouge indique la durée pendant laquelle Cloud TPU a réellement fonctionné.
  3. Pourcentage de temps d'attente des données d'entrée. Indique la moyenne, l'écart type et la plage (minimum, maximum) de la fraction de temps que l'appareil a passé à attendre les données d'entrée, normalisée par rapport à la durée totale des étapes sur l'appareil.
  4. Intervalle de temps que l'appareil a passé à attendre des données d'entrée sur les cœurs, par numéro d'étape. Affiche un graphe en courbes indiquant le temps (exprimé en pourcentage de la durée total des étapes) que l'appareil a passé à attendre le traitement des données d'entrée. La fraction de temps passée varie d'un cœur à l'autre. Par conséquent, la plage des fractions pour chaque cœur est également représentée pour chaque étape. Comme le temps nécessaire à la réalisation d'une étape est déterminé par le cœur le plus lent, la plage doit être la plus petite possible.
Analyse côté hôte

La troisième section présente les détails de l'analyse côté hôte. Elle indique l'heure du traitement d'entrée (temps passé sur les opérations de l'API Dataset) sur l'hôte divisé en plusieurs catégories :

  • Mise en file d'attente des données à transférer sur l'appareil. Temps passé à placer des données dans une file d'attente d'alimentation avant de les transférer sur l'appareil.
  • Data preprocessing (Prétraitement des données). Temps consacré aux opérations de prétraitement, telles que la décompression d'images.
  • Reading data from files in advance (Lecture à l'avance des données de fichiers). Temps consacré à la lecture des fichiers avec mise en cache, prérécupération et entrelacement.
  • Reading data from files on demand (Lecture des données de fichiers à la demande). Temps consacré à la lecture des données de fichiers sans mise en cache, prérécupération et entrelacement.
  • Autres opérations de lecture ou de traitement de données. Temps consacré à d'autres opérations d'entrée n'utilisant pas tf.data.

image

Pour afficher les statistiques des opérations d'entrée individuelles et leurs catégories réparties par temps d'exécution, développez la section "Afficher les statistiques des opérations d'entrée".

Une table de données source de ce type s'affiche :

image

Chaque entrée de la table contient les informations suivantes :

  1. Input Op (Opération d'entrée). Affiche le nom de l'opération d'entrée TensorFlow.
  2. Count (Nombre). Affiche le nombre total d'instances de l'opération exécutées au cours de la période de profilage.
  3. Total Time (in ms) [Temps total (en ms)]. Affiche le cumul du temps passé sur chacune des instances d'opération.
  4. Temps total en %. Affiche le temps total passé sur une opération sous la forme d'une fraction du temps total consacré au traitement des entrées.
  5. Temps propre total (en ms). Affiche le cumul du temps propre passé sur chacune de ces instances. Le temps propre mesure le temps passé dans le corps de la fonction, à l'exclusion du temps passé dans la fonction appelée. Par exemple, le Iterator::PaddedBatch::Filter::ForeverRepeat::Map est appelé par Iterator::PaddedBatch::Filter. Par conséquent, le temps propre total de l'un est exclu du temps propre total de l'autre.
  6. Temps propre total en %. Indique le temps propre total sous la forme d'une fraction du temps total consacré au traitement des entrées.
  7. Catégorie. Affiche la catégorie de traitement de l'opération d'entrée.

Profil d'opération

Le profil d'opération est un outil Cloud TPU qui affiche les statistiques de performances des opérations XLA exécutées au cours d'une période de profilage. Le profil d'opération affiche les informations suivantes :

  • Le degré d'utilisation de la ressource Cloud TPU par l'application, sous la forme d'un pourcentage du temps consacré aux opérations par catégorie et de l'utilisation des FLOPS TPU.
  • Les opérations les plus longues (qui constituent des cibles potentielles d'optimisation).
  • Des détails sur les opérations individuelles, y compris la forme, le remplissage et les expressions utilisant ces opérations.

Le profil d'opération peut vous permettre de trouver de bonnes cibles d'optimisation. Par exemple, si votre modèle n'atteint que 5 % du pic de FLOPS TPU, vous pouvez utiliser cet outil pour identifier les opérations XLA dont l'exécution prend le plus de temps et le nombre de FLOPS TPU qu'elles consomment.

Utiliser un profil d'opération

Lors de la collecte des profils, capture_tpu_profile crée également un fichier op_profile.json contenant les statistiques de performance des opérations XLA.

Pour afficher les données d'op_profile dans TensorBoard, cliquez sur l'onglet Profile (Profil) en haut de l'écran, puis sélectionnez op_profile dans la liste déroulante Tools (Outils). Voici ce qui s'affiche :

image

  1. Section de présentation. Indique l'utilisation de Cloud TPU et fournit des suggestions d'optimisation.
  2. Panneau de configuration. Contient des commandes qui vous permettent de définir le nombre d'opérations affichées dans la table, les opérations à afficher et leur mode de tri.
  3. Table d'opérations. Tableau répertoriant les principales catégories d'opération TensorFlow associées aux opérations XLA. Ces opérations sont triées en fonction du pourcentage d'utilisation de Cloud TPU.
  4. Cartes de détails de l'opération. Détails qui s'affichent lorsque vous passez la souris sur une opération dans la table. Ceux-ci incluent l'utilisation de FLOPS, l'expression dans laquelle l'opération est utilisée et la disposition de l'opération (ajustement).
Table d'opérations XLA

La table d'opérations répertorie les catégories d'opération XLA dans l'ordre, par pourcentage décroissant d'utilisation de Cloud TPU. Initialement, la table indique le pourcentage de temps passé, le nom de la catégorie d'opération, le nom d'opération TensorFlow associé et le pourcentage d'utilisation de FLOPS correspondant à la catégorie. Pour afficher (ou masquer) les 10 opérations XLA les plus longues d'une catégorie, cliquez sur le triangle en regard du nom de la catégorie dans la table.

image

  1. Time. Affiche le pourcentage total du temps passé par toutes les opérations de cette catégorie. Vous pouvez cliquer pour développer l'entrée et voir la répartition du temps passé par opération.
  2. 10 principales opérations. Le bouton d'activation en regard du nom d'une catégorie affiche/masque les 10 opérations les plus longues de cette catégorie. Si une entrée d'opération de fusion est affichée dans la liste des opérations, vous pouvez la développer pour afficher les opérations de non-fusion, élément par élément, qu'elle contient.
  3. TensorFlow Op (Opération TensorFlow). Affiche le nom d'opération TensorFlow associé à l'opération XLA.
  4. FLOPS. Affiche l'utilisation de FLOPS, qui est le nombre mesuré de FLOPS exprimé en pourcentage du pic de FLOPS Cloud TPU. Plus le pourcentage d'utilisation de FLOPS est élevé, plus les opérations sont rapides. Les cellules de cette colonne incluent un code couleur : vert en cas d'utilisation élevée des FLOPS (bonne) et rouge en cas de faible utilisation des FLOPS (mauvaise).
Cartes de détails de l'opération

Lorsque vous sélectionnez une entrée de table, une fiche apparaît à gauche avec des détails sur l'opération XLA ou la catégorie d'opération. Une carte type se présente comme suit :

image

  • Nom et Catégorie. Affiche le nom et la catégorie de l'opération XLA en surbrillance.
  • FLOPS utilization (Utilisation des FLOPS). Affiche l'utilisation des FLOPS, sous la forme d'un pourcentage du nombre total de FLOPS possible.
  • Expression. Affiche l'expression XLA contenant l'opération.
  • Memory utilization (Utilisation de la mémoire). Affiche le pourcentage d'utilisation maximale de la mémoire par votre programme.
  • Layout (Disposition) (opérations de convolution uniquement). Indique la forme et la disposition d'un Tensor, y compris si sa forme présente un ajustement parfait par rapport aux unités matricielles, ainsi que le mode de remplissage de la matrice.
Interpréter les résultats

Dans le cas des opérations de convolution, l'utilisation des FLOPS TPU peut être faible pour l'une des raisons suivantes, ou pour les deux :

  • Remplissage (les unités matricielles sont partiellement utilisées)
  • Opération de convolution subordonnée à la mémoire

Cette section donne une interprétation des données d'un modèle différent, dans lequel les FLOPS étaient faibles. Dans cet exemple, la convolution et la fusion de la sortie ont dominé le temps d'exécution. Une longue queue d'opérations vectorielles ou scalaires, présentant un nombre très bas de FLOPS, a également été observée.

Une stratégie d'optimisation pour ce type de profil consiste à transformer les opérations vectorielles ou scalaires en opérations de convolution.

Dans l'exemple suivant, %convolution.399 affiche une utilisation des FLOPS et de la mémoire inférieure à celle de %convolution.340 dans l'exemple précédent.

image

Examinez la disposition. Notez que la taille de lot (16) a été complétée de façon à atteindre 128, et que la taille de caractéristique (3) a été complétée de façon à atteindre 8, ce qui indique que seulement 5 % des unités matricielles sont effectivement utilisées. (Dans cet exemple, le calcul du pourcentage d'utilisation est le suivant : (((délai_batch * nb._fonctionnalités) / taille_compl.) / nb._cœurs). Comparez les FLOPS de cet exemple à l'opération %convolution.340 de l'exemple précédent, qui présente un ajustement parfait par rapport à la matrice.

Lecteur de pod

Le lecteur de pod fournit des visualisations des performances de chaque cœur d'un pod et affiche l'état des canaux de communication pour l'ensemble des cœurs. Le lecteur de pod peut identifier et mettre en évidence les éventuels goulots d'étranglement et zones à optimiser. L'outil fonctionne pour les pods complets et pour toutes les tranches de pod v2 et v3.

Pour afficher le lecteur de pod, procédez comme suit :

  1. Sélectionnez Profile (Profil) dans le bouton de menu situé en haut à droite de la fenêtre TensorBoard.
  2. Cliquez sur le menu Tools (Outils) à gauche de la fenêtre et sélectionnez pod_viewer.

L'interface utilisateur du lecteur de pod comprend les éléments suivants :

  1. Un curseur de pas, qui vous permet de sélectionner le pas que vous souhaitez examiner.
  2. Un graphique de topologie, qui représente de manière interactive vos cœurs de TPU dans l'ensemble du système TPU.
  3. Un graphique des liens de communication, qui représente les canaux d'envoi et de réception du graphique de topologie.
  4. Un graphique à barres indiquant la latence des canaux d'envoi et de réception. Lorsque vous passez la souris sur une barre de ce graphique, les liens de communication sont activés dans le graphique de liens de communication. Une carte des détails du canal s'affiche dans la barre de gauche, fournissant des informations détaillées sur le canal, telles que la taille des données transférées, la latence et la bande passante.
  5. Un graphique de répartition des pas, qui indique la répartition d'un pas pour tous les cœurs. Il permet de suivre les goulots d'étranglement et de déterminer si un cœur spécifique ralentit le système.

image

Curseur de pas

Utilisez le curseur pour sélectionner un pas. Le reste de l'outil affiche des statistiques, telles que la répartition du pas et les liens de communication de celui-ci.

Graphique de topologie

Le graphique de topologie est organisé hiérarchiquement par hôte, puce et cœur. Les plus petits rectangles représentent des cœurs de TPU. Deux cœurs ensemble forment une puce TPU, tandis que quatre puces forment un hôte.

image

Le graphique de topologie est également une carte de densité. Elle est codée par couleur en fonction du pourcentage de temps pris par une répartition (par exemple, calcul élevé de flops, affichage, envoi, etc.) lors d'une étape choisie. La barre située juste en dessous du graphique de topologie (illustrée dans le graphique suivant) affiche un code couleur pour l'utilisation des cœurs et des puces. La couleur des cœurs varie du jaune au bleu. Pour le calcul de l'utilisation intensive de FLOPS, les valeurs élevées (couleurs foncées) indiquent un temps de calcul plus long. Pour toutes les autres répartitions, les valeurs faibles (couleurs claires) indiquent des temps d'attente plus courts. Un cœur plus foncé que les autres indique une éventuelle zone problématique, ou hotspot.

Cliquez sur le sélecteur de menu déroulant à côté du nom du système (entouré dans le schéma ci-dessus) pour choisir le type de répartition que vous souhaitez examiner.

Passez la souris sur l'un des petits rectangles (cœurs uniques) pour afficher une info-bulle indiquant la position du cœur dans le système, son ID de puce global ainsi que son nom d'hôte. L'info-bulle affiche également la durée de la catégorie de répartition sélectionnée (par exemple, "Calcul de l'utilisation intensive de FLOPS") et son pourcentage d'utilisation en dehors d'un pas.

image

Canaux de communication

Cet outil permet de visualiser les liens d'envoi et de réception si votre modèle les utilise pour la communication entre les cœurs. Lorsque votre modèle contient des options d'envoi et de réception, vous pouvez utiliser un sélecteur d'ID de la chaîne pour sélectionner un ID de la chaîne. Un lien provenant du cœur de la source (src) et du cœur de la destination (dst) représente le canal de communication. Ce lien s'affiche dans le graphique de topologie lorsque vous passez la souris sur les barres du graphique de latence des canaux d'envoi et de réception.

image

Une carte apparaît dans la barre de gauche et vous fournit plus de détails sur le canal de communication. Une carte type se présente comme suit :

image

  1. Data Transferred (Données transférées) : affiche les données transférées par le canal d'envoi et de réception, en mébioctets (Mio).
  2. Latency (Latence) : indique la durée en microsecondes entre le début de l'événement d'envoi et la fin de l'événement de réception terminée.
  3. BW, qui indique la quantité de données transférées, en gibioctets (Gio), entre le cœur de source et le cœur de destination au cours d'une période donnée.
  4. Send Delay (Délai d'envoi) : indique la durée en microsecondes entre le début de l'opération de réception terminée et le début de l'envoi. Si l'opération de réception terminée démarre après le début de l'opération d'envoi, le délai est de zéro.
  5. Hlo Names (Noms HLO) : affiche les noms d'opérations XLA HLO associés à ce canal. Ces noms HLO sont associés aux statistiques affichées dans d'autres outils TensorBoard tels que op_profile et memory_viewer.

Graphique de répartition des pas

Ce graphique fournit des détails sur chaque pas d'entraînement ou d'évaluation.

L'axe des abscisses représente l'ID de puce global et l'axe des ordonnées la durée en microsecondes. Ce graphique vous permet d'identifier la distribution du temps dans un pas d'entraînement spécifique, de localiser les goulots d'étranglement et de savoir si la charge sur les puces est déséquilibrée.

image

Une carte apparaît dans la barre de gauche et vous fournit plus de détails sur la répartition du pas. Une carte type se présente comme suit :

image

Les champs de la carte spécifient les éléments suivants :

  1. High flops compute (Calcul de l'utilisation intensive de FLOPS) : temps consacré aux opérations de convolution ou de fusion de la sortie.
  2. Low flops compute (Calcul de la faible utilisation de FLOPS) : calculé en déduisant toutes les autres répartitions de la durée totale.
  3. Infeed (Flux d'entrée) : temps que le TPU passe à attendre l'hôte.
  4. Outfeed (Flux de sortie) : temps que l'hôte passe à attendre la sortie du TPU.
  5. AllReduce sync (Synchronisation AllReduce) : temps consacré aux opérations CrossReplicaSum en attente de synchronisation avec d'autres cœurs. Les opérations CrossReplicaSum calculent la somme sur plusieurs instances dupliquées.
  6. AllReduce compute (Calcul AllReduce) : temps de calcul réellement consacré aux opérations CrossReplicaSum.
  7. Chip to chip send ops (Opérations d'envoi puce à puce) : temps consacré aux opérations d'envoi.
  8. Chip to chip recv-done ops (Opérations de réception terminée puce à puce) : temps consacré aux opérations de réception.

Lecteur de traces

Le lecteur de traces est un outil d'analyse des performances Cloud TPU disponible sous Profil. Comme il utilise le lecteur de profilage d'événements de trace Chrome, il ne fonctionne que dans le navigateur Chrome.

Le lecteur de traces affiche une chronologie indiquant :

  • la durée des opérations exécutées par le modèle TensorFlow ;
  • la partie du système (TPU ou machine hôte) qui a exécuté une opération. En règle générale, la machine hôte exécute des opérations d'alimentation, qui prétraitent les données d'entraînement et les transfèrent au TPU, tandis que ce dernier se charge de l'entraînement du modèle proprement dit.

Le lecteur de traces vous permet d'identifier les problèmes de performances dans le modèle, puis de prendre des mesures pour les résoudre. Par exemple, de manière générale, vous pouvez déterminer si les opérations d'alimentation ou d'entraînement du modèle prennent la majorité du temps. En affichant le détail, vous pouvez identifier les opérations TensorFlow dont l'exécution est la plus longue.

Notez que le lecteur de traces est limité à un million d'événements par ressource Cloud TPU. Si vous devez évaluer davantage d'événements, le lecteur de traces en flux continu est préférable.

Interface du lecteur de traces

Pour ouvrir le lecteur de traces, accédez à TensorBoard, cliquez sur l'onglet Profil en haut de l'écran, puis choisissez trace_viewer dans le menu déroulant Outils. Le lecteur affiche l'exécution la plus récente :

image

Les principaux éléments de cet écran sont les suivants (ils sont indiqués par des numéros) :

  1. Liste déroulante Runs (Exécutions). Contient toutes les exécutions pour lesquelles vous avez capturé des informations de trace. Par défaut, elle affiche l'exécution la plus récente, mais vous pouvez en sélectionner une autre dans le menu déroulant.
  2. Liste déroulante Tools (Outils). Permet de sélectionner différents outils de profilage.
  3. Liste déroulante Hosts (Hôtes). Permet de sélectionner un hôte contenant une ressource Cloud TPU définie.
  4. Volet de chronologie. Affiche les opérations que Cloud TPU et la machine hôte ont exécutées au fil du temps.
  5. Volet de détails. Affiche des informations supplémentaires sur les opérations sélectionnées dans le volet de chronologie.

Examinez de plus près le volet de chronologie :

image

Ce volet contient les éléments suivants :

  1. Barre supérieure. Contient divers contrôles auxiliaires.
  2. Axe de temps. Affiche le temps par rapport au début de la trace.
  3. Étiquettes de section et de piste. Chaque section contient plusieurs pistes. Sur sa gauche figure également un triangle sur lequel vous pouvez cliquer pour la développer et la réduire. Il y a une section pour chaque élément de traitement du système.
  4. Sélecteur d'outils. Contient divers outils permettant d'interagir avec le lecteur de traces.
  5. Événements. Indiquent le temps nécessaire à l'exécution d'une opération ou la durée de méta-événements, tels que les étapes d'entraînement.
  6. Barre d'onglets verticale. Cette fonctionnalité n'est pas utile pour Cloud TPU. Cette barre fait partie de l'outil de lecture des traces à usage général fourni par Google Chrome, qui est utilisé pour diverses tâches d'analyse des performances.
Sections et pistes

Le lecteur de traces comporte les sections suivantes :

  • Une section pour chaque nœud TPU, étiquetée avec le numéro de la puce TPU et du nœud TPU que celle-ci contient (par exemple, "Chip 2: TPU Core 1" [Puce 2 : Cœur de TPU 1]). Chaque section de nœud TPU contient les pistes suivantes :
    • Step (Étape). Affiche la durée des étapes d'entraînement exécutées sur le TPU.
    • TensorFlow Ops (Opérations TensorFlow). Affiche les opérations TensorFlow exécutées sur le TPU.
    • XLA Ops (Opérations XLA). Affiche les opérations XLA exécutées sur le TPU. Chaque opération TensorFlow est traduite en une ou plusieurs opérations XLA. Le compilateur XLA traduit les opérations XLA en code qui s'exécute sur le TPU.)
  • Une section pour les threads s'exécutant sur le processeur de la machine hôte, avec l'étiquette "Threads hôtes". La section contient une piste pour chaque thread du processeur. Remarque : Vous pouvez ignorer les informations affichées à côté des étiquettes de section.
Sélecteur d'outils de chronologie

Vous pouvez interagir avec la vue de chronologie à l'aide du sélecteur d'outils de chronologie inclus dans TensorBoard. Pour activer et sélectionner un outil de chronologie, cliquez dessus ou utilisez les raccourcis clavier indiqués ci-après. Pour déplacer le sélecteur d'outils de chronologie, cliquez dans la zone en pointillés en haut, puis faites-le glisser à l'emplacement souhaité.

Utilisez les outils de chronologie comme suit :

Outil de sélection
Cliquez sur un événement pour le sélectionner ou faites-le glisser pour sélectionner plusieurs événements. Des informations supplémentaires sur les événements sélectionnés (nom, heure de début et durée) s'affichent dans le volet de détails.

Outil de panorama
Faites glisser pour effectuer un panoramique de la chronologie horizontalement et verticalement.

Outil de zoom
Faites glisser vers le haut pour effectuer un zoom avant ou vers le bas pour effectuer un zoom arrière le long de l'axe horizontal (temps). La position horizontale du curseur de la souris détermine le centre autour duquel le zoom est effectué.

Remarque : L'outil de zoom présente un bug connu. Le zoom reste actif si vous relâchez le bouton de la souris alors que le curseur de la souris se trouve en dehors de l'affichage de la chronologie. Le cas échéant, cliquez simplement sur la vue de chronologie pour arrêter le zoom.

Outil de synchronisation
Faites glisser horizontalement pour marquer un intervalle de temps. Sa longueur apparaît sur l'axe de temps. Pour ajuster l'intervalle, faites glisser ses extrémités. Pour l'effacer, cliquez n'importe où dans la vue de chronologie.

Notez que l'intervalle reste marqué si vous sélectionnez l'un des autres outils.
Événements

Les événements de chronologie s'affichent dans différentes couleurs, qui n'ont pas de signification particulière.

Barre supérieure du volet de chronologie

La barre supérieure du volet de chronologie contient plusieurs contrôles auxiliaires :

image

  1. Affichage des métadonnées. Non utilisé pour les TPU.
  2. View Options (Options d'affichage). Non utilisé pour les TPU.
  3. Champ de recherche. Saisissez du texte pour retrouver tous les événements dont le nom le contient. Cliquez sur les flèches à droite du champ de recherche pour avancer et reculer dans les événements correspondants, en sélectionnant chaque événement à tour de rôle.
  4. Bouton de la console. Non utilisé pour les TPU.
  5. Bouton d'aide. Cliquez dessus pour afficher un résumé de l'aide.
Raccourcis clavier

Vous trouverez ci-dessous les raccourcis clavier disponibles dans le lecteur de traces. Cliquez sur le bouton d'aide (?) dans la barre supérieure pour afficher d'autres raccourcis clavier.

    w Zoom in
    s Zoom out
    a Pan left
    d Pan right
    f Zoom to selected event(s)
    m Mark time interval for selected event(s)
    1 Activate selection tool
    2 Activate pan tool
    3 Activate zoom tool
    4 Activate timing tool

Le raccourci f peut être très utile. Testez-le en sélectionnant une étape puis en appuyant sur f pour effectuer un zoom rapide sur cette étape.

Événements caractéristiques

Vous trouverez ci-dessous certains types d'événements qui peuvent s'avérer très utiles pour analyser les performances du TPU.

image

  • InfeedDequeueTuple. Cette opération TensorFlow s'exécute sur un TPU et reçoit les données d'entrée provenant de l'hôte. Lorsque l'alimentation prend beaucoup de temps, cela peut signifier que les opérations TensorFlow qui prétraitent les données sur la machine hôte ne peuvent pas suivre le rythme de consommation des données du TPU. Vous pouvez afficher les événements correspondants dans les traces de l'hôte nommées InfeedEnqueueTuple. Pour afficher une analyse plus détaillée du pipeline d'entrée, utilisez l'analyseur du pipeline d'entrée.

  • CrossReplicaSum. Cette opération TensorFlow s'exécute sur un TPU et calcule une somme sur plusieurs instances dupliquées. Étant donné que chaque instance dupliquée correspond à un nœud TPU différent, l'opération doit attendre que tous les nœuds TPU aient terminé une étape. Si cette opération prend beaucoup de temps, cela ne signifie pas nécessairement que l'opération de sommation est lente, mais plutôt qu'un nœud TPU attend un autre nœud TPU dont l'alimentation en données est lente.

image

  • Opérations d'ensemble de données. Le lecteur de traces permet de visualiser les opérations de l'ensemble de données effectuées lors du chargement des données à l'aide de l'API Dataset. Dans l'exemple, Iterator::Filter::Batch::ForeverRepeat::Memory est compilé et correspond à l'opération dataset.map() . Le lecteur de traces permet d'examiner les opérations de chargement pendant le débogage et la réduction des goulots d'étranglement du pipeline d'entrée.

image

  • Threads de prérécupération. L'utilisation de dataset.prefetch() pour mettre en mémoire tampon les données d'entrée peut éviter des ralentissements sporadiques de l'accès aux fichiers qui créent des goulots d'étranglement dans le pipeline d'entrée.
Problèmes susceptibles de survenir

Voici des problèmes potentiels dont vous devez tenir compte lors de l'utilisation du lecteur de traces :

  • Limite d'affichage des événements. Le lecteur de traces affiche un million d'événements au maximum. Si vous avez capturé davantage d'événements, seul le premier million d'entre eux s'affiche. Les autres sont ignorés. Pour capturer davantage d'événements TPU, vous pouvez utiliser l'option --include_dataset_ops=False pour demander explicitement à capture_tpu_profile d'exclure les opérations d'ensemble de données.
  • Événements très longs. Les événements commençant avant le début d'une capture ou se terminant après la fin de celle-ci ne sont pas visibles dans le lecteur de traces. Par conséquent, vous pouvez passer à côté.
  • Quand commencer la capture de la trace. Veillez à démarrer la capture de la trace une fois que vous savez que Cloud TPU est en cours d'exécution. Si vous la lancez avant, il se peut que le lecteur de traces n'affiche que quelques événements, voire aucun. Vous pouvez augmenter la durée du profil à l'aide de l'option --duration_ms et définir des tentatives automatiques à l'aide de l'option --num_tracing_attempts . Exemple :

      (vm)$ capture_tpu_profile --tpu=$TPU_NAME
        --logdir=${MODEL_DIR} --duration_ms=60000 --num_tracing_attempts=10
        

Lecteur de mémoire

Le lecteur de mémoire vous permet de visualiser le pic d'utilisation de la mémoire correspondant à votre programme, ainsi que les tendances d'utilisation de la mémoire pendant toute la durée de vie de celui-ci.

L'interface utilisateur du lecteur de mémoire se présente comme suit :

image

  1. Liste déroulante Hosts (Hôtes). Permet de sélectionner un hôte TPU et des modules HLO (High Level Optimizer) XLA à visualiser.
  2. Informations générales sur la mémoire. Affiche le pic d'allocation de mémoire et la taille sans remplissage.
  3. Graphique de l'espace de travail. Affiche le pic d'utilisation de la mémoire, ainsi qu'un tracé des tendances d'utilisation de la mémoire pendant toute la durée de vie du programme. Si vous passez la souris sur un tampon dans l'un des graphiques de tampons, vous ajoutez une annotation concernant la durée de vie du tampon et la carte de détails du tampon.
  4. Graphiques de tampons. Deux graphiques affichant l'allocation des tampons au moment du pic d'utilisation de la mémoire, comme indiqué par la ligne verticale dans le tracé de l'espace de travail. Si vous passez la souris sur un tampon dans l'un des graphiques de tampons, deux éléments s'affichent : la barre de durée de vie du tampon dans le graphique de l'espace de travail et une carte de détails sur la gauche.
  5. Carte de détails d'allocation du tampon. Affiche les détails d'allocation correspondant à un tampon.
Panneau d'informations générales sur la mémoire

Le panneau d'informations générales sur la mémoire (en haut) affiche le nom du module et le pic d'allocation de mémoire défini lorsque la taille totale d'allocation du tampon atteint son maximum. La taille maximale d'allocation sans remplissage est également indiquée à titre de comparaison.

image

Graphique de l'espace de travail

Ce graphique affiche le pic d'utilisation de la mémoire et un tracé des tendances d'utilisation de la mémoire sur toute la durée de vie du programme. La ligne qui va de haut en bas dans le tracé indique le pic d'utilisation de la mémoire correspondant au programme. Ce point détermine si un programme peut tenir dans l'espace mémoire global disponible.

image

Chaque point du tracé de ligne sus-jacent représente un "point de programme" dans le programme HLO de XLA, tel que prévu par le compilateur. La ligne donne une idée de l'ampleur du pic d'utilisation.

Interaction avec les éléments des graphiques de tampons

Lorsque vous passez la souris sur un tampon figurant dans l'un des graphiques de tampons sous le graphique de l'espace de travail, une ligne de durée de vie horizontale apparaît pour ce tampon dans l'espace de travail. Elle est de la même couleur que le tampon mis en évidence.

image

L'épaisseur de la ligne horizontale indique la magnitude relative de la taille de la mémoire tampon par rapport au pic d'allocation de mémoire. La longueur de la ligne correspond à la durée de vie du tampon. Elle débute au point du programme où l'espace du tampon a été alloué et se termine là où il a été libéré.

Graphiques de tampons

Deux graphiques présentent la répartition de l'utilisation de la mémoire au moment du pic d'utilisation (indiqué par la ligne verticale dans le tracé situé au-dessus des graphiques).

image

  • By Program Order (En fonction de l'ordre dans le programme). Affiche les tampons de gauche à droite, dans l'ordre dans lequel ils ont été actifs pendant l'exécution du programme. Les tampons actifs le plus longtemps se trouvent du côté gauche du graphique.

  • By Size (En fonction de la taille). Affiche les tampons actifs pendant l'exécution du programme par ordre décroissant de taille. Les tampons présentant l'impact le plus important au moment du pic d'utilisation de la mémoire se trouvent à gauche.

Carte de détails d'allocation de tampon

Lorsque vous passez la souris sur un tampon figurant dans l'un des graphiques de tampons, une carte de détails d'allocation apparaît (en plus de la ligne de durée de vie qui s'affiche dans le graphique de l'espace de travail). Une carte de détails type se présente comme suit :

image

  1. Nom. Nom de l'opération XLA.
  2. Catégorie. Catégorie d'opération.
  3. Size (Taille). Taille de l'allocation de tampon (remplissage compris).
  4. Unpadded size (Taille sans remplissage). Taille de l'allocation de tampon sans remplissage.
  5. Expansion. Magnitude relative de la taille de la mémoire tampon avec remplissage par rapport à la taille sans remplissage.
  6. Extra memory (Mémoire supplémentaire). Indique la quantité de mémoire supplémentaire utilisée pour le remplissage.
  7. Shape (Forme). Décrit le rang, la taille et le type de données du tableau à n dimensions.
  8. TensorFlow op name (Nom de l'opération TensorFlow). Affiche le nom de l'opération TensorFlow associée à l'allocation de tampon.
  9. Allocation type (Type d'allocation). Indique la catégorie d'allocation de tampon. Les types sont les suivants : "Paramètre", "Sortie", "Thread local" et "Temporaire" (par exemple, allocation de tampon dans une fusion).
Erreurs de type "mémoire insuffisante"

Si vous exécutez un modèle et que vous obtenez une erreur de type "mémoire insuffisante", capturez un profil de mémoire et affichez-le dans le lecteur de mémoire à l'aide de la commande ci-après. Veillez à définir la valeur appropriée pour "duration_ms", de sorte que la période de profilage chevauche celle de la compilation du programme. Le résultat de la commande peut vous aider à comprendre la cause de l'erreur :

  (vm)$ capture_tpu_profile --tpu=$TPU_NAME --logdir=${MODEL_DIR} --duration_ms=60000
  

Lecteur de traces en flux continu

Le lecteur de trace en flux continu (trace_viewer) est un outil d'analyse des performances Cloud TPU, disponible pour TensorFlow version 2.1 ou ultérieure, qui fournit des rendus de trace dynamiques. Comme il utilise le lecteur de profilage d'événements de trace Chrome, cet outil ne fonctionne que dans le navigateur Chrome.

Lorsque vous utilisez capture_tpu_profile 2.3.0 pour enregistrer un profil, un fichier .tracetable est enregistré dans votre bucket Google Cloud Storage. Ce fichier contient un grand nombre d'événements de trace pouvant être visualisés à la fois dans le lecteur de traces et dans le lecteur de traces en flux continu.

Utiliser le lecteur de traces en flux continu

Pour utiliser le lecteur de traces en flux continu, trace_viewer, vous devez arrêter votre session TensorBoard existante, puis relancer TensorBoard à l'aide de l'adresse IP du TPU que vous souhaitez examiner. Le lecteur de traces en flux continu nécessite que TensorBoard effectue un appel de procédure à distance (GRPC) à une adresse IP pour Cloud TPU. Le canal GRPC n'est pas chiffré.

Vous trouverez l'adresse IP d'un hôte Cloud TPU sur la page Cloud TPU. Recherchez votre Cloud TPU, puis son adresse IP la colonne Adresse IP interne.

Dans votre VM, exécutez TensorBoard comme suit pour remplacer tpu-ip par l'adresse IP de votre TPU :

  (vm)$ tensorboard --logdir=${MODEL_DIR} \
    --master_tpu_unsecure_channel=tpu-ip

L'outil TensorBoard s'affiche dans la liste déroulante Outils.

image

Dans la chronologie, vous pouvez faire un zoom avant et arrière pour voir les événements de trace se charger dynamiquement dans votre navigateur.

image

Surveiller une tâche Cloud TPU

Cette section décrit comment utiliser capture_tpu_profile pour capturer un profil unique ou surveiller en continu votre tâche Cloud TPU dans l'interface de ligne de commande, en temps réel. En définissant la valeur de l'option --monitoring_level sur 0 (par défaut), 1 ou 2, vous obtenez respectivement un profil unique, une surveillance de base ou une surveillance détaillée.

Ouvrez une nouvelle session Cloud Shell et connectez-vous via SSH à la VM (dans la commande, remplacez "vm-name" par le nom de la VM) :

  (vm)$ gcloud compute ssh vm-name \
  --ssh-flag=-L6006:localhost:6006

Dans la nouvelle version de Cloud Shell, exécutez capture_tpu_profile avec l'option --monitoring_level définie sur 1 ou 2, comme suit :

  (vm)$ capture_tpu_profile --tpu=$TPU_NAME \
   --monitoring_level=1

La définition de monitoring_level=1 produit un résultat semblable à celui-ci :

    TPU type: TPU v2
    Utilization of TPU Matrix Units is (higher is better): 10.7%

La définition de monitoring_level=2 affiche des informations plus détaillées :

    TPU type: TPU v2
    Number of TPU Cores: 8
    TPU idle time (lower is better): 0.091%
    Utilization of TPU Matrix Units is (higher is better): 10.7%
    Step time: 1.95 kms (avg), 1.90kms (minute), 2.00 kms (max)
    Infeed percentage: 87.5% (avg). 87.2% (min), 87.8 (max)

Indicateurs de surveillance

  • --tpu (obligatoire) spécifie le nom du Cloud TPU que vous souhaitez surveiller.
  • --monitoring_level. Modifiez le comportement de capture_tpu_profile, qui passe de la génération d'un seul profil à une surveillance continue de base ou détaillée. Il existe trois niveaux disponibles : "Niveau 0" (par défaut), qui génère un seul profil, puis sort ; "Niveau 1", qui affiche la version du TPU et son utilisation ; "Niveau 2", qui affiche l'utilisation du TPU, son temps d'inactivité et le nombre de cœurs de TPU utilisés. Fournit également les durées d'étapes minimale, moyenne et maximale, ainsi que la contribution au pourcentage de file d'attente d'alimentation.
  • --duration_ms (facultatif ; la valeur par défaut est de 1 000 ms) indique la durée nécessaire au profilage de l'hôte TPU au cours de chaque cycle. En règle générale, cette durée doit être suffisamment longue pour enregistrer au moins un pas d'entraînement de données. Une seconde capture une étape d'entraînement dans la plupart des modèles, mais si la durée des étapes de votre modèle est très longue, vous pouvez définir la valeur sur 2 x step_time (en ms).
  • --num_queries indique le nombre de cycles à exécuter capture_tpu_profile. Pour surveiller en continu la tâche de TPU, définissez la valeur sur un nombre élevé. Pour vérifier rapidement la durée des pas de votre modèle, définissez une valeur faible.