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

Optimize TensorFlow performance using the Profiler

Utilisez les outils disponibles avec le Profiler pour suivre les performances de vos modèles TensorFlow. Voyez comment votre modèle fonctionne sur l'hôte (CPU), le périphérique (GPU) ou sur une combinaison de l'hôte et du ou des périphériques.

Le profilage vous aide à comprendre la consommation de ressources matérielles (temps et mémoire) des différentes opérations TensorFlow (ops) de votre modèle et à résoudre les goulots d'étranglement des performances et, en fin de compte, à accélérer l'exécution du modèle.

Ce guide vous expliquera comment installer le Profiler, les différents outils disponibles, les différents modes de collecte des données de performances par le Profiler et quelques bonnes pratiques recommandées pour optimiser les performances du modèle.

Si vous souhaitez profiler les performances de votre modèle sur les Cloud TPU, reportez-vous au guide Cloud TPU .

Installez les prérequis du Profiler et du GPU

Installez Profiler en téléchargeant et en exécutant le script install_and_run.py partir du référentiel GitHub .

Pour profiler sur le GPU, vous devez:

  1. Installez CUDA® Toolkit 10.1 ou plus récent. CUDA® Toolkit 10.1 prend en charge uniquement le profilage GPU unique. Pour profiler plusieurs GPU, consultez Profilage de plusieurs GPU . Assurez-vous que la version du pilote CUDA® que vous installez est au moins 440.33 pour Linux ou 441.22 pour Windows.
  2. Assurez-vous que CUPTI existe sur le chemin:
/sbin/ldconfig -N -v $(sed 's/:/ /g' <<< $LD_LIBRARY_PATH) | \
grep libcupti

Si vous n'avez pas CUPTI sur le chemin, ajoutez son répertoire d'installation à la variable d'environnement $LD_LIBRARY_PATH en exécutant:

export LD_LIBRARY_PATH=/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH

Exécutez à nouveau la commande ldconfig ci-dessus pour vérifier que la bibliothèque CUPTI est trouvée.

Profilage de plusieurs GPU

TensorFlow prend actuellement en charge le profilage de plusieurs GPU uniquement pour les systèmes hôtes uniques. Le profilage GPU multiple pour les systèmes multi-hôtes n'est actuellement pas pris en charge. Installez CUDA® Toolkit 10.2 ou version ultérieure pour profiler plusieurs GPU. Comme TensorFlow ne prend en charge que les versions de CUDA® Toolkit jusqu'à 10.1, créez des liens symboliques vers libcudart.so.10.1 et libcupti.so.10.1 .

sudo ln -s /usr/local/cuda/lib64/libcudart.so.10.2 /usr/local/cuda/lib64/libcudart.so.10.1
sudo ln -s /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.2 /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.1

Pour profiler les configurations GPU multi-travailleurs, profilez les différents travailleurs indépendamment.

Résoudre les problèmes de privilège

Lorsque vous exécutez le profilage avec CUDA® Toolkit 10.1 dans un environnement Docker ou sous Linux, vous pouvez rencontrer des problèmes liés à des privilèges CUPTI insuffisants ( CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ). Consultez la documentation du développeur NVIDIA pour en savoir plus sur la manière de résoudre ces problèmes sous Linux.

Pour résoudre les problèmes de privilèges CUPTI dans un environnement Docker, exécutez

docker run option '--privileged=true'

Outils de profilage

Accédez au profileur à partir de l'onglet Profil dans TensorBoard qui apparaît uniquement après avoir capturé certaines données de modèle.

Le Profiler dispose d'une sélection d'outils pour aider à l'analyse des performances:

  • Page de présentation
  • Analyseur de pipeline d'entrée
  • Statistiques de TensorFlow
  • Visionneuse de traces
  • Statistiques du noyau GPU
  • Outil de profil de mémoire

Page de présentation

La page de présentation fournit une vue de haut niveau sur les performances de votre modèle lors de l'exécution d'un profil. La page présente une page de présentation agrégée de votre hôte et de tous les appareils, ainsi que des recommandations pour améliorer les performances d'entraînement de votre modèle. Vous pouvez également sélectionner des hôtes individuels dans la liste déroulante Hôte.

La page de présentation affiche les données comme suit:

image

  • Résumé des performances - Affiche un résumé de haut niveau des performances de votre modèle. Le résumé des performances comprend deux parties:

    1. Répartition du temps de pas - Décompose le temps de pas moyen en plusieurs catégories de temps passé:

      • Compilation - Temps passé à compiler les noyaux
      • Entrée - Temps passé à lire les données d'entrée
      • Sortie - Temps passé à lire les données de sortie
      • Lancement du noyau - Temps passé par l'hôte pour lancer les noyaux
      • Temps de calcul de l'hôte
      • Temps de communication appareil à appareil
      • Temps de calcul sur l'appareil
      • Tous les autres, y compris les frais généraux Python
    2. Précisions de calcul de l'appareil - Indique le pourcentage de temps de calcul de l'appareil qui utilise des calculs 16 et 32 ​​bits

  • Graphique pas à pas - Affiche un graphique du temps de pas de l'appareil (en millisecondes) sur toutes les étapes échantillonnées. Chaque étape est divisée en plusieurs catégories (avec des couleurs différentes) où le temps est passé. La zone rouge correspond à la partie du temps pendant lequel les périphériques étaient inactifs en attente de données d'entrée de l'hôte. La zone verte indique combien de temps l'appareil fonctionnait réellement

  • Top 10 des opérations TensorFlow sur l'appareil - Affiche les opérations sur l'appareil qui ont été exécutées le plus longtemps.

    Chaque ligne affiche le temps propre d'une opération (en pourcentage du temps pris par toutes les opérations), le temps cumulé, la catégorie et le nom.

  • Environnement d' exécution - Affiche un résumé de haut niveau de l'environnement d'exécution du modèle, notamment:

    • Nombre d'hôtes utilisés
    • Type d'appareil (GPU / TPU)
    • Nombre de cœurs de périphérique
  • Recommandation pour les étapes suivantes - Signale lorsqu'un modèle est lié à l'entrée et recommande les outils que vous pouvez utiliser pour localiser et résoudre les goulots d'étranglement des performances du modèle

Analyseur de pipeline d'entrée

Lorsqu'un programme TensorFlow lit des données à partir d'un fichier, il commence en haut du graphique TensorFlow en pipeline. Le processus de lecture est divisé en plusieurs étapes de traitement de données connectées en série, où la sortie d'un étage est l'entrée de la suivante. Ce système de lecture de données s'appelle le pipeline d'entrée .

Un pipeline typique pour lire des enregistrements à partir de fichiers comporte les étapes suivantes:

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

Un pipeline d'entrée inefficace peut ralentir considérablement votre application. Une application est considérée comme liée à l'entrée lorsqu'elle passe une partie importante de son temps dans le pipeline d'entrée. Utilisez les informations obtenues à partir de l'analyseur de pipeline d'entrée pour comprendre où le pipeline d'entrée est inefficace.

L'analyseur de pipeline d'entrée vous indique immédiatement si votre programme est lié à l'entrée et vous guide tout au long de l'analyse côté périphérique et côté hôte pour déboguer les goulots d'étranglement des performances à n'importe quel stade du pipeline d'entrée.

Consultez les conseils sur les performances du pipeline d'entrée pour connaître les meilleures pratiques recommandées pour optimiser vos pipelines d'entrée de données.

Tableau de bord du pipeline d'entrée

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

image

Le tableau de bord contient trois sections:

  1. Résumé: résume le pipeline d'entrée global avec des informations indiquant si votre application est liée à l'entrée et, le cas échéant, de combien
  2. Analyse côté périphérique - Affiche les résultats détaillés de l'analyse côté périphérique, y compris le temps de passage de l'appareil et la plage de temps de périphérique passé à attendre les données d'entrée entre les cœurs à chaque étape
  3. Analyse côté hôte - Affiche une analyse détaillée du côté hôte, y compris une ventilation du temps de traitement des entrées sur l'hôte

Résumé du pipeline d'entrée

Le résumé signale si votre programme est lié à l'entrée en présentant le pourcentage de temps passé sur le périphérique à attendre l'entrée de l'hôte. Si vous utilisez un pipeline d'entrée standard qui a été instrumenté, l'outil indique où la plupart du temps de traitement d'entrée est passé.

Analyse côté appareil

L'analyse côté périphérique fournit des informations sur le temps passé sur le périphérique par rapport à l'hôte et sur le temps passé sur le périphérique à attendre les données d'entrée de l'hôte.

  1. Temps de pas tracé par rapport au numéro de pas - Affiche un graphique du temps de pas de l'appareil (en millisecondes) sur toutes les étapes échantillonnées. Chaque étape est divisée en plusieurs catégories (avec des couleurs différentes) où le temps est passé. La zone rouge correspond à la partie du temps pendant lequel les périphériques étaient inactifs en attente de données d'entrée de l'hôte. La zone verte indique combien de temps l'appareil fonctionnait réellement
  2. Statistiques de temps de pas - Indique la moyenne, l'écart type et la plage ([minimum, maximum]) du temps de pas de l'appareil

Analyse côté hôte

L'analyse côté hôte rapporte une ventilation du temps de traitement des entrées (le temps passé sur les tf.data API tf.data ) sur l'hôte en plusieurs catégories:

  • Lecture de données à partir de fichiers à la demande - Temps passé à lire des données à partir de fichiers sans mise en cache, prélecture et entrelacement
  • Lecture préalable des données des fichiers - Temps passé à lire les fichiers, y compris la mise en cache, la prélecture et l'entrelacement
  • Prétraitement des données - Temps consacré aux opérations de prétraitement, telles que la décompression d'image
  • Mise en file d'attente des données à transférer vers l'appareil - Temps passé à mettre les données dans une file d'attente d'alimentation avant de transférer les données vers l'appareil

Développez l'entrée Op statistiques pour voir les statistiques pour les opérations d'entrée individuelles et leurs catégories ventilées par temps d'exécution.

image

Un tableau de données source apparaît avec chaque entrée contenant les informations suivantes:

  1. Op d'entrée - Affiche le nom de l'opération TensorFlow de l'opération d'entrée
  2. Count - Affiche le nombre total d'instances d'exécution d'opérations pendant la période de profilage
  3. Temps total (en ms) - Affiche la somme cumulée du temps passé sur chacune de ces instances
  4. Total Time% - Affiche le temps total passé sur une opération sous forme de fraction du temps total passé dans le traitement des entrées
  5. Temps propre total (en ms) - Affiche la somme cumulée du temps libre passé sur chacune de ces instances. Le self time mesure ici le temps passé à l'intérieur du corps de la fonction, à l'exclusion du temps passé dans la fonction qu'il appelle.
  6. Temps propre total% . Affiche l'autonomie totale sous forme de 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

Statistiques de TensorFlow

L'outil TensorFlow Stats affiche les performances de chaque opération TensorFlow (op) exécutée sur l'hôte ou le périphérique au cours d'une session de profilage.

image

L'outil affiche les informations sur les performances dans deux volets:

  • Le volet supérieur affiche jusqu'à quatre graphiques à secteurs:

    1. La distribution du temps d'auto-exécution de chaque opération sur l'hôte
    2. La distribution du temps d'auto-exécution de chaque type d'opération sur l'hôte
    3. La répartition du temps d'auto-exécution de chaque opération sur l'appareil
    4. La distribution du temps d'auto-exécution de chaque type d'opération sur l'appareil
  • Le volet inférieur affiche un tableau qui rapporte des données sur les opérations TensorFlow avec une ligne pour chaque opération et une colonne pour chaque type de données (trier les colonnes en cliquant sur l'en-tête de la colonne). Cliquez sur le bouton Exporter au format CSV sur le côté droit du volet supérieur pour exporter les données de cette table sous forme de fichier CSV.

    Notez que:

    • Si des opérations ont des opérations enfants:

      • Le temps total "accumulé" d'une opération comprend le temps passé dans les opérations enfants

      • Le temps total "auto" d'une opération n'inclut pas le temps passé dans les opérations enfants

    • Si un op s'exécute sur l'hôte:

      • Le pourcentage du temps libre total sur l'appareil encouru par l'opération sera de 0
      • Le pourcentage cumulé du temps libre total sur l'appareil jusqu'à et y compris cette opération sera de 0
    • Si une opération s'exécute sur l'appareil:

      • Le pourcentage du temps libre total sur l'hôte encouru par cette opération sera de 0
      • Le pourcentage cumulé du temps libre total sur l'hôte jusqu'à et y compris cette opération sera de 0

Vous pouvez choisir d'inclure ou d'exclure les temps d'inactivité dans les graphiques à secteurs et le tableau.

Visionneuse de traces

Le visualiseur de trace affiche une chronologie qui montre:

  • Durées des opérations exécutées par votre modèle TensorFlow
  • Quelle partie du système (hôte ou périphérique) a exécuté une opération. En règle générale, l'hôte exécute les opérations d'entrée, prétraite les données d'entraînement et les transfère vers l'appareil, tandis que l'appareil exécute l'entraînement réel du modèle

Le visualiseur de traces vous permet d'identifier les problèmes de performances de votre modèle, puis de prendre des mesures pour les résoudre. Par exemple, à un niveau élevé, vous pouvez identifier si la formation d'entrée ou de modèle prend la majorité du temps. En explorant, vous pouvez identifier les opérations qui prennent le plus de temps à exécuter. Notez que le visualiseur de trace est limité à 1 million d'événements par appareil.

Interface de la visionneuse de traces

Lorsque vous ouvrez le visualiseur de trace, il apparaît affichant votre exécution la plus récente:

image

Cet écran contient les principaux éléments suivants:

  1. Volet Timeline - Affiche les opérations exécutées par l'appareil et l'hôte au fil du temps
  2. Volet Détails - Affiche des informations supplémentaires sur les opérations sélectionnées dans le volet Chronologie

Le volet Chronologie contient les éléments suivants:

  1. Barre supérieure - Contient diverses commandes auxiliaires
  2. Axe du temps - Affiche le temps par rapport au début de la trace
  3. Étiquettes de section et de piste - Chaque section contient plusieurs pistes et comporte un triangle sur la gauche sur lequel vous pouvez cliquer pour développer et réduire la section. Il y a une section pour chaque élément de traitement dans le système
  4. Sélecteur d'outils - Contient divers outils pour interagir avec le visualiseur de trace tels que Zoom, Panoramique, Sélection et Minutage. Utilisez l'outil de chronométrage pour marquer un intervalle de temps.
  5. Événements - Ceux - ci montrent le temps pendant lequel une opération a été exécutée ou la durée des méta-événements, tels que les étapes d'entraînement
Sections et pistes

Le visualiseur de traces contient les sections suivantes:

  • Une section pour chaque nœud de périphérique , étiquetée avec le numéro de la puce de périphérique et le nœud de périphérique dans la puce (par exemple, /device:GPU:0 (pid 0) ). Chaque section de nœud de périphérique contient les pistes suivantes:
    • Étape - Affiche la durée des étapes d'entraînement en cours sur l'appareil
    • TensorFlow Ops - . Affiche les opérations exécutées sur l'appareil
    • XLA Ops - Affiche les opérations XLA (ops) exécutées sur l'appareil si XLA est le compilateur utilisé (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 l'appareil).
  • Une section pour les threads exécutés sur le processeur de la machine hôte, intitulée "Host Threads" . La section contient une piste pour chaque thread CPU. Notez que vous pouvez ignorer les informations affichées à côté des étiquettes de section.
Événements

Les événements dans la chronologie sont affichés dans différentes couleurs; les couleurs elles-mêmes n'ont pas de signification particulière.

Le visualiseur de trace peut également afficher les traces des appels de fonction Python dans votre programme TensorFlow. Si vous utilisez l'API tf.profiler.experimental.start() , vous pouvez activer le traçage Python à l'aide du multiplicateur nommé ProfilerOptions lors du démarrage du profilage. Sinon, si vous utilisez le mode d'échantillonnage pour le profilage, vous pouvez sélectionner le niveau de traçage à l'aide des options de liste déroulante de la boîte de dialogue Profil de capture .

image

Statistiques du noyau GPU

Cet outil affiche les statistiques de performances et l'opération d'origine pour chaque noyau accéléré par GPU.

image

L'outil affiche les informations dans deux volets:

  • Le volet supérieur affiche un graphique à secteurs qui montre les noyaux CUDA qui ont le temps total écoulé le plus élevé

  • Le volet inférieur affiche un tableau avec les données suivantes pour chaque paire noyau-op unique:

    • Un classement par ordre décroissant de la durée totale du GPU écoulée regroupée par paire noyau-op
    • Le nom du noyau lancé
    • Le nombre de registres GPU utilisés par le noyau
    • La taille totale de la mémoire partagée (statique + dynamique partagée) utilisée en octets
    • La dimension de bloc exprimée comme blockDim.x, blockDim.y, blockDim.z
    • Les dimensions de la grille exprimées en tant que gridDim.x, gridDim.y, gridDim.z
    • Si l'op est éligible pour utiliser TensorCores
    • Si le noyau contient des instructions TensorCore
    • Le nom de l'op qui a lancé ce noyau
    • Le nombre d'occurrences de cette paire noyau-op
    • Le temps total écoulé du GPU en microsecondes
    • Le temps GPU écoulé moyen en microsecondes
    • Le temps GPU minimum écoulé en microsecondes
    • Le temps GPU écoulé maximal en microsecondes

Outil de profil de mémoire

L'outil de profil de mémoire surveille l'utilisation de la mémoire de votre appareil pendant l'intervalle de profilage. Vous pouvez utiliser cet outil pour:

  • Déboguez les problèmes de mémoire insuffisante (MOO) en identifiant l'utilisation maximale de la mémoire et l'allocation de mémoire correspondante aux opérations TensorFlow. Vous pouvez également déboguer les problèmes de MOO qui peuvent survenir lorsque vous exécutez l'inférence multiclient
  • Déboguer les problèmes de fragmentation de la mémoire

L'outil de profil de mémoire affiche les données dans trois sections:

  1. Résumé du profil de mémoire
  2. Graphique chronologique de la mémoire
  3. Tableau de répartition de la mémoire

Résumé du profil de mémoire

Cette section affiche un résumé de haut niveau du profil de mémoire de votre programme TensorFlow, comme indiqué ci-dessous:

Le résumé du profil de mémoire comporte six champs:

  1. ID de mémoire - Liste déroulante qui répertorie tous les systèmes de mémoire de périphérique disponibles. Sélectionnez le système de mémoire que vous souhaitez afficher dans la liste déroulante
  2. #Allocation - Le nombre d'allocations de mémoire effectuées pendant l'intervalle de profilage
  3. #Deallocation - Le nombre de désallocations de mémoire dans l'intervalle de profilage
  4. Capacité de mémoire - La capacité totale (en Gio) du système de mémoire que vous sélectionnez
  5. Utilisation maximale du tas - Utilisation maximale de la mémoire (en Gio) depuis le début de l'exécution du modèle
  6. Utilisation maximale de la mémoire - Utilisation maximale de la mémoire (en Gio) dans l'intervalle de profilage. Ce champ contient les sous-champs suivants:
    1. Horodatage - Horodatage du moment où l'utilisation maximale de la mémoire s'est produite sur le graphique chronologique
    2. Réservation de pile - Quantité de mémoire réservée sur la pile (en Gio)
    3. Allocation de tas - Quantité de mémoire allouée sur le tas (en Gio)
    4. Mémoire libre - Quantité de mémoire libre (en Gio). La capacité de mémoire est la somme totale de la réservation de pile, de l'allocation de tas et de la mémoire libre
    5. Fragmentation - Le pourcentage de fragmentation (plus faible est meilleur). Il est calculé en pourcentage de (1 - Taille du plus grand morceau de mémoire libre / Mémoire libre totale)

Graphique chronologique de la mémoire

Cette section affiche un graphique de l'utilisation de la mémoire (en Gio) et le pourcentage de fragmentation en fonction du temps (en ms).

image

L'axe X représente la chronologie (en ms) de l'intervalle de profilage. L'axe Y sur la gauche représente l'utilisation de la mémoire (en Gio) et l'axe Y sur la droite représente le pourcentage de fragmentation. À chaque instant sur l'axe X, la mémoire totale est décomposée en trois catégories: pile (en rouge), tas (en orange) et libre (en vert). Survolez un horodatage spécifique pour afficher les détails sur les événements d'allocation / désallocation de mémoire à ce stade, comme ci-dessous:

image

La fenêtre contextuelle affiche les informations suivantes:

  • horodatage (ms) - L'emplacement de l'événement sélectionné sur la chronologie
  • event - Le type d'événement (allocation ou désallocation)
  • required_size (Gio) - La quantité de mémoire demandée. Ce sera un nombre négatif pour les événements de désallocation
  • allocation_size (Gio) - La quantité réelle de mémoire allouée. Ce sera un nombre négatif pour les événements de désallocation
  • tf_op - L'Op TensorFlow qui demande l'allocation / la désallocation
  • step_id - L'étape d'entraînement au cours de laquelle cet événement s'est produit
  • region_type - Le type d'entité de données auquel cette mémoire allouée est destinée. Les valeurs possibles sont temp pour les temporaires, la output pour les activations et les gradients, et persist / dynamic pour les poids et les constantes
  • data_type - Le type d'élément tensoriel (par exemple, uint8 pour un entier non signé 8 bits)
  • tensor_shape - La forme du tenseur alloué / désalloué
  • memory_in_use (Gio) - La mémoire totale utilisée à ce moment

Tableau de répartition de la mémoire

Ce tableau montre les allocations de mémoire actives au point d'utilisation maximale de la mémoire dans l'intervalle de profilage.

image

Il existe une ligne pour chaque opération TensorFlow et chaque ligne contient les colonnes suivantes:

  • Nom de l'opération - Le nom de l'opération TensorFlow
  • Taille d'allocation (Gio) - La quantité totale de mémoire allouée à cette opération
  • Taille demandée (Gio) - La quantité totale de mémoire demandée pour cette opération
  • Occurrences - Le nombre d'allocations pour cette opération
  • Type de région - Le type d'entité de données auquel cette mémoire allouée est destinée. Les valeurs possibles sont temp pour les temporaires, la output pour les activations et les gradients, et persist / dynamic pour les poids et les constantes
  • Type de données - Le type d'élément tensoriel
  • Forme - La forme des tenseurs alloués

Collectez des données de performance

Le TensorFlow Profiler collecte les activités de l'hôte et les traces GPU de votre modèle TensorFlow. Vous pouvez configurer le Profiler pour collecter les données de performances via le mode programmatique ou le mode d'échantillonnage.

Profilage des API

Vous pouvez utiliser les API suivantes pour effectuer le profilage.

# Profile from batches 10 to 15
tb_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
                                             profile_batch='10, 15')

# Train the model and use the TensorBoard Keras callback to collect
# performance profiling data
model.fit(train_data,
          steps_per_epoch=20,
          epochs=5,
          callbacks=[tb_callback])
  • Mode programmatique utilisant l'API de fonction tf.profiler
tf.profiler.experimental.start('logdir')
# Train the model here
tf.profiler.experimental.stop()
  • Mode programmatique utilisant le gestionnaire de contexte
with tf.profiler.experimental.Profile('logdir'):
    # Train the model here
    pass
  • Mode d'échantillonnage - Effectuez un profilage à la demande à l'aide de tf.profiler.experimental.server.start() pour démarrer un serveur gRPC avec votre modèle TensorFlow exécuté. Après avoir démarré le serveur gRPC et exécuté votre modèle, vous pouvez capturer un profil via le bouton Capturer le profil dans le plug-in de profil TensorBoard. Utilisez le script de la section Installer le profileur ci-dessus pour lancer une instance TensorBoard si elle n'est pas déjà en cours d'exécution.

    Par exemple,

# Start a gRPC server at port 6009
tf.profiler.experimental.server.start(6009)
# ... TensorFlow program ...

Utilisez la boîte de dialogue Profil de capture pour spécifier:

  • L'URL du service de profil ou le nom du TPU
  • La durée du profilage
  • Le niveau de suivi des appels de périphérique, d'hôte et de fonction Python
  • Combien de fois vous voulez que le Profiler retente de capturer des profils en cas d'échec au début

Profilage de boucles d'entraînement personnalisées

Pour profiler des boucles d'entraînement personnalisées dans votre code TensorFlow, instrumentez la boucle d'entraînement avec l'API tf.profiler.experimental.Trace pour marquer les limites d'étape du Profiler. L'argument name est utilisé comme préfixe pour les noms d'étape, l'argument mot clé step_num est ajouté dans les noms d'étape et l'argument mot clé _r fait que cet événement de trace est traité comme un événement d'étape par le Profiler.

Par exemple,

for step in range(NUM_STEPS):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_data = next(dataset)
        train_step(train_data)

Cela activera l'analyse des performances basée sur les étapes du Profiler et fera apparaître les événements d'étape dans le visualiseur de trace.

Assurez-vous d'inclure l'itérateur de l'ensemble de données dans le contexte tf.profiler.experimental.Trace pour une analyse précise du pipeline d'entrée.

L'extrait de code ci-dessous est un anti-modèle:

for step, train_data in enumerate(dataset):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_step(train_data)

Profilage des cas d'utilisation

Le profileur couvre un certain nombre de cas d'utilisation selon quatre axes différents. Certaines des combinaisons sont actuellement prises en charge et d'autres seront ajoutées à l'avenir. Certains des cas d'utilisation sont:

  • Profilage local ou distant: il s'agit de deux méthodes courantes de configuration de votre environnement de profilage. Dans le profilage local, l'API de profilage est appelée sur la même machine que votre modèle exécute, par exemple, un poste de travail local avec des GPU. Dans le profilage à distance, l'API de profilage est appelée sur une machine différente de celle sur laquelle votre modèle s'exécute, par exemple sur un Cloud TPU.
  • Profilage de plusieurs travailleurs: vous pouvez profiler plusieurs machines lorsque vous utilisez les capacités de formation distribuées de TensorFlow.
  • Plate-forme matérielle: profils CPU, GPU et TPU.

Le tableau ci-dessous est un aperçu rapide des cas d'utilisation ci-dessus pris en charge par les différentes API de profilage dans TensorFlow 2.3:

API de profilage Local Éloigné Travailleurs multiples Plateformes matérielles
Rappel TensorBoard Keras Prise en charge Non supporté Non supporté Processeur, GPU
API de fonction tf.experimental.profiler Prise en charge Non supporté Non supporté Processeur, GPU
API du gestionnaire de contexte Prise en charge Non supporté Non supporté Processeur, GPU
API à la demande Non supporté Prise en charge Assistance limitée Processeur, GPU, TPU

Meilleures pratiques pour des performances optimales du modèle

Utilisez les recommandations suivantes en fonction de vos modèles TensorFlow pour obtenir des performances optimales.

En général, effectuez toutes les transformations sur l'appareil et assurez-vous d'utiliser la dernière version compatible de bibliothèques telles que cuDNN et Intel MKL pour votre plate-forme.

Optimiser le pipeline de données d'entrée

Un pipeline d'entrée de données efficace peut considérablement améliorer la vitesse d'exécution de votre modèle en réduisant le temps d'inactivité de l'appareil. Envisagez d'incorporer les meilleures pratiques suivantes, détaillées ici, pour rendre votre pipeline d'entrée de données plus efficace:

  • Pré-extraire les données
  • Paralléliser l'extraction de données
  • Paralléliser la transformation des données
  • Cache les données en mémoire
  • Vectoriser les fonctions définies par l'utilisateur
  • Réduisez l'utilisation de la mémoire lors de l'application des transformations

En outre, essayez d'exécuter votre modèle avec des données synthétiques pour vérifier si le pipeline d'entrée est un goulot d'étranglement des performances.

Améliorez les performances de l'appareil

  • Augmenter la taille du mini-lot d'entraînement (nombre d'échantillons d'entraînement utilisés par appareil dans une itération de la boucle d'apprentissage)
  • Utilisez TF Stats pour découvrir l'efficacité de l'exécution des opérations sur l'appareil
  • Utilisez tf.function pour effectuer des calculs et éventuellement, activez l'indicateur experimental_compile
  • Minimisez les opérations Python de l'hôte entre les étapes et réduisez les rappels. Calculez les métriques toutes les quelques étapes plutôt qu'à chaque étape
  • Gardez les unités de calcul de l'appareil occupées
  • Envoyer des données à plusieurs appareils en parallèle
  • Optimisez la mise en page des données pour préférer les canaux en premier (par exemple NCHW sur NHWC). Certains GPU comme le NVIDIA® V100 fonctionnent mieux avec une disposition de données NHWC.
  • Pensez à utiliser des représentations numériques 16 bits telles que fp16 , le format virgule flottante demi-précision spécifié par IEEE ou le format bfloat16 à virgule flottante Brain
  • Envisagez d'utiliser l' API de précision mixte Keras
  • Lorsque vous vous entraînez sur des GPU, utilisez le TensorCore. Les noyaux GPU utilisent le TensorCore lorsque la précision est fp16 et que les dimensions d'entrée / sortie sont divisibles par 8 ou 16 (pour int8)

Ressources supplémentaires