Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Surveillance de l’utilisation des ressources de calcul AWS dans Amazon SageMaker Studio Classic
Pour suivre l'utilisation des ressources de calcul dans le cadre de votre tâche d'entraînement, utilisez les outils de surveillance proposés par Amazon SageMaker Debugger.
Pour chaque tâche d’entraînement que vous exécutez dans SageMaker AI à l’aide du kit SageMaker Python SDK, Debugger collecte des métriques d’utilisation des ressources de base, telles que l’utilisation du CPU, l’utilisation du GPU, l’utilisation de la mémoire de GPU, le réseau et le temps d’attente des E/S toutes les 500 millisecondes. Pour consulter le tableau de bord des métriques d'utilisation des ressources liés à votre tâche d'entraînement, il vous suffit d'utiliser l'[interface utilisateur de SageMaker Debugger dans SageMaker Studio Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html).
Les opérations et étapes de deep learning peuvent s'exécuter à des intervalles de quelques millisecondes. Par rapport aux métriques Amazon CloudWatch, qui collectent des métriques à intervalles d'une seconde, Debugger fournit une granularité plus fine dans les métriques d'utilisation des ressources, jusqu'à des intervalles de 100 millisecondes (0,1 seconde) afin que vous puissiez explorer les métriques au niveau d'une opération ou d'une étape.
Si vous souhaitez modifier l'intervalle de collecte des métriques, vous pouvez ajouter un paramètre de configuration du profilage à votre lanceur de tâches d'entraînement. Par exemple, si vous utilisez le kit SageMaker AI Python SDK, vous devez transmettre le paramètre `profiler_config` lorsque vous créez un objet estimateur. Pour découvrir comment ajuster l'intervalle de collecte des métriques d'utilisation des ressources, consultez [Modèle de code pour configurer un objet estimateur SageMaker AI avec les modules SageMaker Debugger Python dans le SageMaker SDK AI Python](debugger-configuration-for-profiling.md#debugger-configuration-structure-profiler), puis [Configuration des paramètres pour le profilage de base de l'utilisation des ressources du système](debugger-configure-system-monitoring.md).
En outre, vous pouvez ajouter des outils de détection de problèmes appelés *règles de profilage intégrées* fournies par SageMaker Debugger. Les règles de profilage intégrées exécutent une analyse par rapport aux métriques d'utilisation des ressources et détectent les problèmes de performances de calcul. Pour plus d’informations, consultez [Utilisez des règles de profilage intégrées gérées par Amazon Debugger SageMaker](use-debugger-built-in-profiler-rules.md). Vous pouvez recevoir les résultats de l'analyse des règles via l'[interface utilisateur de SageMaker Debugger dans SageMaker Studio Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html) ou via le [rapport de profilage de SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). Vous pouvez également créer des règles de profilage personnalisées à l'aide du kit SageMaker Python SDK.
Pour en savoir plus sur les fonctionnalités de surveillance fournies par SageMaker Debugger, consultez les rubriques suivantes.
**Topics**
+ [Configuration de l'estimateur avec paramètres pour le profilage de base à l'aide des modules Python d'Amazon SageMaker Debugger](debugger-configuration-for-profiling.md)
+ [Utilisez des règles de profilage intégrées gérées par Amazon Debugger SageMaker](use-debugger-built-in-profiler-rules.md)
+ [Liste des règles de profilage intégrées à Debugger](debugger-built-in-profiler-rules.md)
+ [Interface utilisateur Amazon SageMaker Debugger dans Amazon SageMaker Studio Classic Experiments](debugger-on-studio.md)
+ [SageMaker Rapport interactif du débogueur](debugger-profiling-report.md)
+ [Analyse des données à l'aide de la bibliothèque client Debugger Python](debugger-analyze-data.md)
# Configuration de l'estimateur avec paramètres pour le profilage de base à l'aide des modules Python d'Amazon SageMaker Debugger
Par défaut, le profilage de base du SageMaker Debugger est activé par défaut et surveille les indicateurs d'utilisation des ressources, tels que l'utilisation du processeur, l'utilisation du processeur graphique, l'utilisation de la mémoire du processeur graphique, le temps d'attente du réseau et les temps d'attente des E/S, de toutes les tâches de SageMaker formation soumises à l'aide du SDK Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable). SageMaker Debugger collecte ces mesures d'utilisation des ressources toutes les 500 millisecondes. Vous n'avez pas besoin d'apporter de modifications supplémentaires à votre code, à votre script d'entraînement ou au lanceur de tâches pour suivre l'utilisation des ressources de base. Si vous souhaitez modifier l'intervalle de collecte des métriques pour le profilage de base, vous pouvez spécifier des paramètres spécifiques au débogueur lors de la création d'un lanceur de tâches d' SageMaker entraînement à l'aide du SDK SageMaker Python, AWS SDK pour Python (Boto3) ou (CLI). AWS Command Line Interface Dans ce guide, nous nous concentrons sur la façon de modifier les options de profilage à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Cette page fournit des modèles de référence pour configurer cet objet estimateur.
Si vous souhaitez accéder au tableau de bord des indicateurs d'utilisation des ressources de votre tâche de formation dans SageMaker Studio, vous pouvez accéder au[Interface utilisateur Amazon SageMaker Debugger dans Amazon SageMaker Studio Classic Experiments](debugger-on-studio.md).
Si vous souhaitez activer les règles qui détectent automatiquement les problèmes d'utilisation des ressources du système, vous pouvez ajouter le paramètre `rules` dans l'objet estimateur pour activer les règles.
**Important**
Pour utiliser les dernières fonctionnalités du SageMaker Debugger, vous devez mettre à niveau le SDK SageMaker Python et la `SMDebug` bibliothèque cliente. Dans votre noyau IPython, Jupyter Notebook JupyterLab ou votre environnement, exécutez le code suivant pour installer les dernières versions des bibliothèques et redémarrer le noyau.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Modèle de code pour configurer un objet estimateur SageMaker AI avec les modules SageMaker Debugger Python dans le SageMaker SDK AI Python
Pour ajuster la configuration de profilage de base (`profiler_config`) ou ajouter les règles du profileur (`rules`), choisissez l'un des onglets pour obtenir le modèle de configuration d'un estimateur SageMaker AI. Dans les pages suivantes, vous pouvez trouver plus d'informations sur la configuration des deux paramètres.
**Note**
Les exemples de codes suivants ne sont pas directement exécutables. Passez aux sections suivantes pour découvrir comment configurer chaque paramètre.
------
#### [ PyTorch ]
```
# An example of constructing a SageMaker AI PyTorch estimator
import boto3
import sagemaker
from sagemaker.pytorch import PyTorch
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
session=boto3.session.Session()
region=session.region_name
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=PyTorch(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.12.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ TensorFlow ]
```
# An example of constructing a SageMaker AI TensorFlow estimator
import boto3
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
session=boto3.session.Session()
region=session.region_name
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=TensorFlow(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.8.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ MXNet ]
```
# An example of constructing a SageMaker AI MXNet estimator
import sagemaker
from sagemaker.mxnet import MXNet
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=MXNet(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.7.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
**Note**
En effet MXNet, lors de la configuration du `profiler_config` paramètre, vous ne pouvez le configurer que pour la surveillance du système. Les métriques du framework de profilage ne sont pas prises en charge pour MXNet.
------
#### [ XGBoost ]
```
# An example of constructing a SageMaker AI XGBoost estimator
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=XGBoost(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.5-1",
# Debugger-specific parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
**Note**
En effet XGBoost, lors de la configuration du `profiler_config` paramètre, vous ne pouvez le configurer que pour la surveillance du système. Les métriques du framework de profilage ne sont pas prises en charge pour XGBoost.
------
#### [ Generic estimator ]
```
# An example of constructing a SageMaker AI generic estimator using the XGBoost algorithm base image
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import ProfilerConfig, DebuggerHookConfig, Rule, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
region=boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.5-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Debugger-specific parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
Vous trouverez ci-dessous de brèves descriptions des paramètres.
+ `profiler_config` : configurez Debugger pour collecter les métriques système et les métriques de framework de votre tâche d'entraînement et les enregistrer dans votre URI de compartiment S3 sécurisé ou votre machine locale. Vous pouvez définir la fréquence ou le degré de collecte des métriques du système. Pour en savoir plus sur la configuration du paramètre `profiler_config`, consultez [Configuration des paramètres pour le profilage de base de l'utilisation des ressources du système](debugger-configure-system-monitoring.md) et [Configuration de l’estimateur pour le profilage du cadre](debugger-configure-framework-profiling.md).
+ `rules`— Configurez ce paramètre pour activer les règles intégrées du SageMaker Debugger que vous souhaitez exécuter en parallèle. Assurez-vous que votre tâche d'entraînement a accès à ce compartiment S3. Les règles s'appliquent au traitement des conteneurs et analysent automatiquement votre tâche d'entraînement pour détecter les problèmes de performance de calcul et opérationnelle. La règle [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) est la règle la plus intégrée qui exécute toutes les règles de profilage intégrées et enregistre les résultats du profilage sous forme de rapport dans votre compartiment S3 sécurisé. Pour savoir comment configurer le paramètre `rules`, consultez [Utilisez des règles de profilage intégrées gérées par Amazon Debugger SageMaker](use-debugger-built-in-profiler-rules.md).
**Note**
Debugger enregistre en toute sécurité les données de sortie dans les sous-dossiers de votre compartiment S3 par défaut. Par exemple, le format de l'URI du compartiment S3 par défaut est `s3://sagemaker--<12digit_account_id>///`. Il y a trois sous-dossiers créés par Debugger : `debug-output`, `profiler-output` et `rule-output`. Vous pouvez également récupérer le compartiment S3 par défaut à URIs l'aide des méthodes de [SageMaker classe AI estimator](debugger-estimator-classmethods.md).
Consultez les rubriques suivantes pour savoir comment configurer en détail les paramètres spécifiques à Debugger.
**Topics**
+ [Modèle de code pour configurer un objet estimateur SageMaker AI avec les modules SageMaker Debugger Python dans le SageMaker SDK AI Python](#debugger-configuration-structure-profiler)
+ [Configuration des paramètres pour le profilage de base de l'utilisation des ressources du système](debugger-configure-system-monitoring.md)
+ [Configuration de l’estimateur pour le profilage du cadre](debugger-configure-framework-profiling.md)
+ [Mise à jour de la configuration de la surveillance système et du profilage de framework de Debugger pendant l'exécution d'une tâche d'entraînement](debugger-update-monitoring-profiling.md)
+ [Désactivation de Debugger](debugger-turn-off-profiling.md)
# Configuration des paramètres pour le profilage de base de l'utilisation des ressources du système
Pour ajuster l'intervalle de temps nécessaire à la collecte des métriques d'utilisation, utilisez l'opération d'`ProfilerConfig`API pour créer un objet de paramètres tout en construisant un framework d' SageMaker IA ou un estimateur générique selon vos préférences.
**Note**
Par défaut, pour toutes les tâches de SageMaker formation, Debugger collecte les métriques d'utilisation des ressources à partir des instances Amazon EC2 toutes les 500 millisecondes pour la surveillance du système, sans aucun paramètre spécifique au Debugger spécifié dans les estimateurs d'IA. SageMaker
Debugger enregistre les métriques système dans un compartiment S3 par défaut. Le format de l'URI du compartiment S3 par défaut est `s3://sagemaker--<12digit_account_id>//profiler-output/`.
Le code suivant illustre la configuration du paramètre `profiler_config` avec un intervalle de temps de surveillance système de 1 000 millisecondes.
```
from sagemaker.debugger import ProfilerConfig
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000
)
```
+ `system_monitor_interval_millis` (int) : spécifiez les intervalles de surveillance en millisecondes pour enregistrer les métriques système. Les valeurs disponibles sont 100, 200, 500, 1 000 (1 seconde), 5 000 (5 secondes) et 60 000 (1 minute) millisecondes. La valeur par défaut est de 500 millisecondes.
Pour voir la progression de la surveillance système, consultez [Ouvrez le tableau de bord Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md).
# Configuration de l’estimateur pour le profilage du cadre
**Avertissement**
En faveur d'[Amazon SageMaker Profiler](train-use-sagemaker-profiler.md), SageMaker AI Debugger déconseille la fonctionnalité de profilage du framework à partir des versions 2.11 et 2.0. TensorFlow PyTorch Vous pouvez toujours utiliser cette fonctionnalité dans les versions précédentes des frameworks et SDKs comme suit.
SageMaker SDK Python <= v2.130.0
PyTorch >= v1.6.0, < v2.0
TensorFlow >= v2.3.1, < v2.11
Consultez également [16 mars 2023](debugger-release-notes.md#debugger-release-notes-20230315).
Pour activer le profilage du cadre Debugger, configurez le paramètre `framework_profile_params` lorsque vous créez un estimateur. Le profilage du cadre Debugger recueille des métriques du cadre, telles que les données de l'étape d'initialisation, les processus de chargement de données, les opérateurs Python des cadres de deep learning et des scripts d'entraînement, le profilage détaillé dans et entre les étapes, avec les options cProfile ou Pyinstrument. À l'aide de la classe `FrameworkProfile`, vous pouvez configurer des options de profilage de cadre personnalisées.
**Note**
Avant de commencer avec le profilage du cadre Debugger, vérifiez que le cadre utilisé pour créer votre modèle est pris en charge par Debugger pour le profilage du cadre. Pour de plus amples informations, veuillez consulter [Cadres et algorithmes pris en charge](debugger-supported-frameworks.md).
Debugger enregistre les métriques du cadre dans un compartiment S3 par défaut. Le format de l'URI du compartiment S3 par défaut est `s3://sagemaker--<12digit_account_id>//profiler-output/`.
**Topics**
+ [Profilage du cadre par défaut](debugger-configure-framework-profiling-basic.md)
+ [Surveillance système par défaut et profilage de cadre personnalisé pour les étapes cible ou une plage de temps cible](debugger-configure-framework-profiling-range.md)
+ [Surveillance système par défaut et profilage de cadre personnalisé avec différentes options de profilage](debugger-configure-framework-profiling-options.md)
# Profilage du cadre par défaut
Le profilage du cadre Debugger inclut les options suivantes : profilage détaillé, profilage du chargeur de données et profilage Python. L'exemple de code suivant est la configuration la plus simple du paramètre `profiler_config` pour démarrer la surveillance système et le profilage de cadre par défaut. La classe `FrameworkProfile` de l'exemple de code suivant lance le profilage de cadre par défaut lorsqu'une tâche d'entraînement démarre.
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile()
)
```
Avec cette configuration du paramètre `profiler_config`, Debugger appelle les paramètres par défaut de surveillance et de profilage. Debugger contrôle les métriques système toutes les 500 millisecondes. Il profile la cinquième étape avec l'option de profilage détaillé ; la septième étape avec l'option de profilage du chargeur de données ; et les neuvième, dixième et onzième étapes avec l'option de profilage Python.
Pour connaître les options de configuration de profilage disponibles, les paramètres par défaut et des exemples de configuration, consultez [Surveillance système par défaut et profilage de cadre personnalisé avec différentes options de profilage](debugger-configure-framework-profiling-options.md) et [SageMaker Debugger APIs — FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) dans le SDK Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
Si vous souhaitez modifier l'intervalle de surveillance système et activer le profilage de cadre par défaut, vous pouvez spécifier le paramètre `system_monitor_interval_millis` explicitement avec le paramètre `framework_profile_params`. Par exemple, pour contrôler toutes les 1 000 millisecondes et activer le profilage de cadre par défaut, utilisez l'exemple de code suivant.
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile()
)
```
Pour plus d'informations sur cette `FrameworkProfile` classe, consultez [SageMaker Debugger APIs — FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) dans le SDK Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Surveillance système par défaut et profilage de cadre personnalisé pour les étapes cible ou une plage de temps cible
Si vous souhaitez spécifier des étapes cible ou des intervalles de temps cible pour établir le profil de votre tâche d'entraînement, vous devez spécifier des paramètres pour la classe `FrameworkProfile`. Les exemples de code suivants montrent comment spécifier les plages cible pour le profilage et la surveillance système.
+ **Pour une plage d'étapes cible**
Avec l'exemple de configuration suivant, Debugger surveille l'ensemble de la tâche d'entraînement toutes les 500 millisecondes (surveillance par défaut) et profile une plage d'étapes cible allant de l'étape 5 à l'étape 15 (pour 10 étapes).
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile(start_step=5, num_steps=10)
)
```
Avec l'exemple de configuration suivant, Debugger contrôle l'ensemble de la tâche d'entraînement toutes les 1 000 millisecondes et profile une plage d'étapes cible allant de l'étape 5 à l'étape 15 (pour 10 étapes).
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile(start_step=5, num_steps=10)
)
```
+ **Pour une plage de temps cible**
Avec l'exemple de configuration suivant, Debugger contrôle l'ensemble de la tâche d'entraînement toutes les 500 millisecondes (surveillance par défaut) et profile une plage de temps cible à partir de l'heure actuelle Unix pendant 600 secondes.
```
import time
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile(start_unix_time=int(time.time()), duration=600)
)
```
Avec l'exemple de configuration suivant, Debugger contrôle l'ensemble de la tâche d'entraînement toutes les 1 000 millisecondes et profile une plage de temps cible à partir de l'heure actuelle Unix pendant 600 secondes.
```
import time
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile(start_unix_time=int(time.time()), duration=600)
)
```
Le profilage du cadre est effectué pour toutes les options de profilage à l'étape cible ou à la plage de temps.
Pour en savoir plus sur les options de profilage disponibles, consultez [SageMaker Debugger APIs — FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) dans le SDK Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
La section suivante vous montre comment écrire les options de profilage disponibles.
# Surveillance système par défaut et profilage de cadre personnalisé avec différentes options de profilage
Cette section fournit des informations sur les classes de configuration de profilage prises en charge, ainsi qu’un exemple de configuration. Vous pouvez utiliser les classes de configuration de profilage suivantes pour gérer les options de profilage de cadre :
+ [DetailedProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DetailedProfilingConfig)— Spécifiez une étape ou une plage de temps cible pour profiler les opérations du framework à l'aide des profileurs de framework natifs (TensorFlow profileur et PyTorch profileur). Par exemple, en cas d'utilisation TensorFlow, les hooks Debugger permettent au TensorFlow profileur de collecter des métriques spécifiques au framework TensorFlow. Le profilage détaillé vous permet de profiler tous les opérateurs de cadre à une étape préalable (avant la première étape), dans et entre les étapes d'une tâche d'entraînement.
**Note**
Le profilage détaillé peut augmenter considérablement la consommation de mémoire GPU. Nous déconseillons d'activer le profilage détaillé pour plus de deux étapes.
+ [DataloaderProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DataloaderProfilingConfig)— Spécifiez une étape ou une plage de temps cible pour profiler les processus du chargeur de données du framework d'apprentissage profond. Debugger collecte chaque événement de chargeur de données des cadres.
**Note**
Le profilage du chargeur de données peut réduire les performances d'entraînement lors de la collecte d'informations auprès des chargeurs de données. Nous déconseillons d'activer le profilage du chargeur de données pendant plus de deux étapes.
Debugger est préconfiguré pour annoter les processus du chargeur de données uniquement pour les conteneurs AWS Deep Learning Containers. Debugger ne peut pas profiler les processus du chargeur de données à partir d'autres conteneurs d'entraînement personnalisés ou externes.
+ [PythonProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.PythonProfilingConfig)— Spécifiez une étape ou une plage de temps cible pour profiler les fonctions Python. Vous avez également le choix entre deux profileurs Python : cProfile et Pyinstrument.
+ *cProfile* : profileur Python standard. cProfile collecte des informations pour chaque opérateur Python appelé pendant l'entraînement. Avec cProfile, Debugger économise du temps cumulé et des annotations pour chaque appel de fonction, fournissant des détails complets sur les fonctions Python. Dans le deep learning, par exemple, les fonctions les plus fréquemment appelées peuvent être les filtres convolutifs et les opérateurs de transmission vers l'arrière. cProfile profile chacun d'entre elles. Pour l'option cProfile, vous pouvez sélectionner une option de minuterie : temps total, temps CPU et temps hors CPU. Bien que vous puissiez profiler chaque appel de fonction exécuté sur les processeurs (CPU et GPU) en fonction du temps processeur, vous pouvez également identifier les goulots I/O d'étranglement du réseau grâce à l'option Hors-CPU. La valeur par défaut est le temps total, et Debugger profile à la fois le temps CPU et le temps hors CPU. Avec cProfile, vous pouvez explorer en détail toutes les fonctions lors de l'analyse des données de profil.
+ *Pyinstrument* : Pyinstrument est un profileur Python à faible charge qui fonctionne sur la base de l'échantillonnage. Avec l'option Pyinstrument, Debugger échantillonne les événements de profilage toutes les millisecondes. Étant donné que Pyinstrument mesure le temps écoulé au lieu du temps CPU, l'option Pyinstrument peut être plus appropriée par rapport à l'option cProfile pour réduire le bruit de profilage (filtrage des appels de fonction non pertinents qui s'accumulent rapidement) et capturer les opérateurs qui sont en fait exigeants en calcul (s'accumulent lentement) pour l'entraînement de votre modèle. Avec Pyinstrument, vous pouvez voir une arborescence d'appels de fonctions et mieux comprendre la structure et la cause racine de la lenteur.
**Note**
L'activation du profilage Python peut ralentir le temps global d'entraînement. cProfile profile les opérateurs Python les plus fréquemment appelés à chaque appel, de sorte que le temps de traitement du profilage augmente par rapport au nombre d'appels. Dans le cas de Pyinstrument, le temps de profilage cumulé augmente par rapport au temps en raison de son mécanisme d'échantillonnage.
L'exemple de configuration suivant montre la structure complète lorsque vous utilisez les différentes options de profilage avec des valeurs spécifiées.
```
import time
from sagemaker.debugger import (ProfilerConfig,
FrameworkProfile,
DetailedProfilingConfig,
DataloaderProfilingConfig,
PythonProfilingConfig,
PythonProfiler, cProfileTimer)
profiler_config=ProfilerConfig(
system_monitor_interval_millis=500,
framework_profile_params=FrameworkProfile(
detailed_profiling_config=DetailedProfilingConfig(
start_step=5,
num_steps=1
),
dataloader_profiling_config=DataloaderProfilingConfig(
start_step=7,
num_steps=1
),
python_profiling_config=PythonProfilingConfig(
start_step=9,
num_steps=1,
python_profiler=PythonProfiler.CPROFILE,
cprofile_timer=cProfileTimer.TOTAL_TIME
)
)
)
```
Pour plus d'informations sur les options de profilage disponibles [DetailedProfilingConfig[DataloaderProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DataloaderProfilingConfig)](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DetailedProfilingConfig), consultez, et [PythonProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.PythonProfilingConfig)dans le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Mise à jour de la configuration de la surveillance système et du profilage de framework de Debugger pendant l'exécution d'une tâche d'entraînement
Si vous souhaitez activer ou mettre à jour la configuration de surveillance du débogueur pour une tâche de formation en cours d'exécution, utilisez les méthodes d'extension SageMaker AI estimator suivantes :
+ Pour activer la surveillance système de Debugger pour une tâche d'entraînement en cours d'exécution et recevoir un rapport de profilage de Debugger, procédez comme suit :
```
estimator.enable_default_profiling()
```
Lorsque vous utilisez la méthode `enable_default_profiling`, Debugger lance la surveillance système par défaut et la méthode `ProfileReport` intégrée, qui génère un rapport de profilage complet à la fin de la tâche d'entraînement. Cette méthode ne peut être appelée que si la tâche d'entraînement actuelle est en cours d'exécution sans la surveillance et le profilage de Debugger.
[Pour plus d'informations, consultez [estimator.enable\$1default\$1profiling](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.enable_default_profiling) dans le SDK Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
+ Pour mettre à jour la configuration de surveillance du système, utilisez ce qui suit :
```
estimator.update_profiler(
system_monitor_interval_millis=500
)
```
[Pour plus d'informations, consultez [estimator.update\$1profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler) dans le SDK Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# Désactivation de Debugger
Pour désactiver complètement Debugger, effectuez l'une des actions suivantes :
+ Avant de démarrer une tâche d'entraînement, procédez comme suit :
Pour désactiver le profilage, insérez le paramètre `disable_profiler` dans votre estimateur et définissez-le sur `True`.
**Avertissement**
Si vous le désactivez, vous ne pourrez pas afficher le tableau de bord complet des informations de Studio Debugger et le rapport de profilage généré automatiquement.
Pour désactiver le débogage, définissez le paramètre `debugger_hook_config` sur `False`.
**Avertissement**
Si vous le désactivez, vous ne pourrez pas collecter les tenseurs de sortie ni déboguer vos paramètres de modèle.
```
estimator=Estimator(
...
disable_profiler=True
debugger_hook_config=False
)
```
[Pour plus d'informations sur les paramètres spécifiques au débogueur, consultez [SageMaker AI Estimator dans le SDK](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator) Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
+ Lorsqu'une tâche d'entraînement est en cours d'exécution, procédez comme suit :
Pour désactiver la surveillance et le profilage pendant que votre tâche d'entraînement est en cours d'exécution, utilisez la méthode de classe d'estimateur suivante :
```
estimator.disable_profiling()
```
Pour désactiver le profilage de cadre uniquement et conserver la surveillance système, utilisez la méthode `update_profiler` :
```
estimator.update_profiler(disable_framework_metrics=true)
```
[https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler)
# Utilisez des règles de profilage intégrées gérées par Amazon Debugger SageMaker
Les règles de profilage intégrées d'Amazon SageMaker Debugger analysent les métriques du système et les opérations de framework collectées lors de la formation d'un modèle. Debugger propose l'opération d'API `ProfilerRule` qui aide à configurer les règles pour surveiller les ressources et les opérations de calcul d'entraînement et détecter les anomalies. Par exemple, les règles de profilage peuvent vous aider à détecter les problèmes de calcul tels que des goulots d'étranglement du processeur, des temps d' I/O attente excessifs, un déséquilibre de la charge de travail entre les opérateurs du GPU et une sous-utilisation des ressources de calcul. Pour afficher la liste complète des règles de profilage intégrées disponibles, consultez [Liste des règles de profilage intégrées à Debugger](debugger-built-in-profiler-rules.md). Les rubriques suivantes montrent comment utiliser les règles Debugger intégrées avec des réglages de paramètre par défaut et des valeurs de paramètre personnalisées.
**Note**
Les règles intégrées sont fournies par le biais de conteneurs de SageMaker traitement Amazon et sont entièrement gérées par SageMaker Debugger sans frais supplémentaires. Pour plus d'informations sur la facturation, consultez la page de [ SageMaker tarification d'Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Topics**
+ [Utiliser les règles du SageMaker profileur intégré à Debugger avec leurs paramètres par défaut](#debugger-built-in-profiler-rules-configuration)
+ [Utilisation des règles de profilage intégrées de Debugger avec les valeurs de paramètre personnalisées](#debugger-built-in-profiler-rules-configuration-param-change)
## Utiliser les règles du SageMaker profileur intégré à Debugger avec leurs paramètres par défaut
Pour ajouter des règles intégrées au SageMaker Debugger dans votre estimateur, vous devez configurer un objet de liste. `rules` L'exemple de code suivant montre la structure de base de la liste des règles intégrées du SageMaker Debugger.
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_1()),
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_2()),
...
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_n()),
... # You can also append more debugging rules in the Rule.sagemaker(rule_configs.*()) format.
]
estimator=Estimator(
...
rules=rules
)
```
Pour obtenir la liste complète des règles intégrées disponibles, consultez [Liste des règles de profilage intégrées à Debugger](debugger-built-in-profiler-rules.md).
Pour utiliser les règles de profilage et inspecter les performances informatiques et la progression de votre tâche de formation, ajoutez la [https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#profiler-report](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#profiler-report)règle SageMaker Debugger. Cette règle active toutes les règles intégrées de la famille [Debugger ProfilerRule](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#debugger-built-in-profiler-rules-ProfilerRule)`ProfilerRule`. En outre, cette règle génère un rapport de profilage agrégé. Pour plus d'informations, voir [Rapport de profilage généré à l'aide du SageMaker débogueur](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). Vous pouvez utiliser le code suivant pour ajouter la règle du rapport de profilage à votre estimateur d'entraînement.
```
from sagemaker.debugger import Rule, rule_configs
rules=[
ProfilerRule.sagemaker(rule_configs.ProfilerReport())
]
```
Lorsque vous démarrez la tâche d'entraînement avec la règle `ProfilerReport`, Debugger collecte les données d'utilisation des ressources toutes les 500 millisecondes. Debugger analyse l'utilisation des ressources pour identifier si votre modèle rencontre des problèmes de goulet d'étranglement. Si les règles détectent des anomalies d'entraînement, le statut d'évaluation de la règle passe à `IssueFound`. Vous pouvez configurer des actions automatisées, telles que la notification des problèmes de formation et l'arrêt des tâches de formation à l'aide d'Amazon CloudWatch Events et AWS Lambda. Pour de plus amples informations, veuillez consulter [Action sur les règles d'Amazon SageMaker Debugger](debugger-action-on-rules.md).
## Utilisation des règles de profilage intégrées de Debugger avec les valeurs de paramètre personnalisées
Si vous souhaitez ajuster les valeurs des paramètres des règles intégrées et personnaliser l'expression regex de la collection de tenseurs, configurez les paramètres `base_config` et `rule_parameters` pour les méthodes de classe `ProfilerRule.sagemaker` et `Rule.sagemaker`. Dans le cas des méthodes de classe `Rule.sagemaker`, vous pouvez également personnaliser les collections de tenseurs via le paramètre `collections_to_save`. Pour des instructions sur l'utilisation de la classe `CollectionConfig`, consultez [Configurer les collections de tenseurs en utilisant l’API `CollectionConfig`](debugger-configure-tensor-collections.md).
Utilisez le modèle de configuration suivant pour personnaliser les valeurs des paramètres des règles intégrées. En modifiant les paramètres de règle comme vous le souhaitez, vous pouvez ajuster la sensibilité des règles à initier.
+ L'argument `base_config` sert à appeler les méthodes de règles intégrées.
+ L'argument `rule_parameters` sert à ajuster les valeurs de clé par défaut des règles intégrées répertoriées dans [Liste des règles de profilage intégrées à Debugger](debugger-built-in-profiler-rules.md).
[Pour plus d'informations sur la classe de règles, les méthodes et les paramètres du Debugger, consultez la section Classe [SageMaker AI Debugger Rule dans le SDK](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html) Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs, CollectionConfig
rules=[
ProfilerRule.sagemaker(
base_config=rule_configs.BuiltInProfilerRuleName(),
rule_parameters={
"key": "value"
}
)
]
```
Les descriptions de paramètres et des exemples de personnalisation de valeur sont fournis pour chaque règle dans [Liste des règles de profilage intégrées à Debugger](debugger-built-in-profiler-rules.md).
Pour une configuration JSON de bas niveau des règles intégrées de Debugger à l'aide de l'API `CreateTrainingJob`, consultez [Configurer le débogueur à l'aide de l'API SageMaker](debugger-createtrainingjob-api.md).
# Liste des règles de profilage intégrées à Debugger
Utilisez les règles de profilage intégrées au Debugger fournies par Amazon SageMaker Debugger et analysez les métriques collectées lors de l'entraînement de vos modèles. Les règles intégrées à Debugger contrôlent diverses conditions communes qui sont essentielles à l'exécution réussie d'une tâche d'entraînement performante. Vous pouvez appeler les règles de profilage intégrées à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) ou des opérations d'API de bas niveau SageMaker . L'utilisation des règles intégrées n'entraîne aucun coût supplémentaire. Pour plus d'informations sur la facturation, consultez la page de [ SageMaker tarification d'Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Note**
Le nombre maximum de règles de profilage intégrées que vous pouvez associer à une tâche de formation est de 20. SageMaker Debugger gère entièrement les règles intégrées et analyse votre tâche d'entraînement de manière synchrone.
**Important**
Pour utiliser les nouvelles fonctionnalités du Debugger, vous devez mettre à niveau le SDK SageMaker Python et la SMDebug bibliothèque cliente. Dans votre noyau IPython, votre bloc-notes Jupyter JupyterLab ou votre environnement, exécutez le code suivant pour installer les dernières versions des bibliothèques et redémarrer le noyau.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Règles du profileur
Les règles suivantes sont les règles intégrées de Debugger qui peuvent être appelées à l'aide de la méthode de classe `ProfilerRule.sagemaker`.
Règles intégrées à Debugger pour la génération de rapports de profilage
| Domaine de validité | Règles intégrées |
| --- | --- |
| Rapport de profilage pour n'importe quel poste SageMaker de formation | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
Règles intégrées à Debugger pour le profilage de l'utilisation des ressources matérielles du système (métriques système)
| Domaine de validité | Règles intégrées |
| --- | --- |
| Règles génériques de surveillance du système pour tout SageMaker type de formation | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
Règles intégrées à Debugger pour le profilage des métriques de framework
| Domaine de validité | Règles intégrées |
| --- | --- |
| Règles de profilage pour les frameworks d'apprentissage profond (TensorFlow et PyTorch) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
**Avertissement**
En faveur d'[Amazon SageMaker Profiler](train-use-sagemaker-profiler.md), SageMaker AI Debugger déconseille la fonctionnalité de profilage du framework à partir des versions 2.11 et 2.0. TensorFlow PyTorch Vous pouvez toujours utiliser cette fonctionnalité dans les versions précédentes des frameworks et SDKs comme suit.
SageMaker SDK Python <= v2.130.0
PyTorch >= v1.6.0, < v2.0
TensorFlow >= v2.3.1, < v2.11
Consultez également [16 mars 2023](debugger-release-notes.md#debugger-release-notes-20230315).
**Pour utiliser les règles intégrées avec les valeurs de paramètre par défaut**, utilisez le format de configuration suivant :
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_1()),
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_2()),
...
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_n())
]
```
**Pour utiliser les règles intégrées avec la personnalisation des valeurs des paramètres,** utilisez le format de configuration suivant :
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
ProfilerRule.sagemaker(
base_config=rule_configs.BuiltInRuleName(),
rule_parameters={
"key": "value"
}
)
]
```
Pour voir les clés disponibles pour le paramètre `rule_parameters`, consultez les tables de description des paramètres.
Des exemples de codes de configuration de règle sont fournis pour chaque règle intégrée sous les tables de description des paramètres.
+ Pour obtenir des instructions complètes et des exemples d’utilisation des règles intégrées Debugger, consultez [Exemple de code pour les règles intégrées Debugger](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Pour obtenir des instructions complètes sur l'utilisation des règles intégrées avec les opérations d' SageMaker API de bas niveau, consultez[Configurer le débogueur à l'aide de l'API SageMaker](debugger-createtrainingjob-api.md).
## ProfilerReport
La ProfilerReport règle invoque toutes les règles intégrées de surveillance et de profilage. Elle crée un rapport de profilage et le met à jour lorsque les règles individuelles sont déclenchées. Vous pouvez télécharger un rapport de profilage complet pendant qu'une tâche d'entraînement est en cours d'exécution ou une fois la tâche d'entraînement finie. Vous pouvez ajuster les valeurs des paramètres de règle pour personnaliser la sensibilité des règles intégrées de surveillance et de profilage. L'exemple de code suivant montre le format de base permettant d'ajuster les paramètres de règle intégrés par le biais de la ProfilerReport règle.
```
rules=[
ProfilerRule.sagemaker(
rule_configs.ProfilerReport(
_ = value
)
)
]
```
Si vous déclenchez cette ProfilerReport règle sans aucun paramètre personnalisé, comme indiqué dans l'exemple de code suivant, la ProfilerReport règle déclenche toutes les règles intégrées de surveillance et de profilage avec leurs valeurs de paramètres par défaut.
```
rules=[ProfilerRule.sagemaker(rule_configs.ProfilerReport())]
```
L'exemple de code suivant montre comment spécifier et ajuster le `cpu_threshold` paramètre de la CPUBottleneck règle et le `threshold` paramètre de la IOBottleneck règle.
```
rules=[
ProfilerRule.sagemaker(
rule_configs.ProfilerReport(
CPUBottleneck_cpu_threshold = 90,
IOBottleneck_threshold = 90
)
)
]
```
Pour découvrir le contenu du rapport du profileur, consultez le rapport de profilage du [SageMaker débogueur](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). De plus, comme cette règle active toutes les règles de profilage, vous pouvez également vérifier l'état de l'analyse des règles à l'aide de l'[interface utilisateur du SageMaker débogueur dans SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html) Experiments.
Descriptions des paramètres de la OverallSystemUsage règle
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| \$1 | Paramètre personnalisable pour ajuster les seuils d'autres règles de surveillance et de profilage intégrées. **Facultatif** Valeur par défaut : `None` |
## BatchSize
La BatchSize règle permet de détecter si le GPU est sous-utilisé en raison d'une petite taille de lot. Pour détecter ce problème, cette règle surveille l'utilisation moyenne du CPU, l'utilisation du GPU et l'utilisation de la mémoire GPU. Si l'utilisation du CPU, du GPU et de la mémoire GPU est faible en moyenne, cela peut indiquer que la tâche d'entraînement peut soit s'exécuter sur un type d'instance plus petit, soit s'exécuter avec une taille de lot plus grande. Cette analyse ne fonctionne pas pour les cadres qui surallouent fortement la mémoire. Toutefois, l'augmentation de la taille du lot peut entraîner des goulets d'étranglement dans le traitement ou le chargement des données, car le prétraitement des données est plus long à chaque itération.
Descriptions des paramètres de la BatchSize règle
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| cpu\$1threshold\$1p95 | Définit le seuil du 95e quantile d'utilisation du CPU en pourcentage. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `70` (en pourcentage) |
| gpu\$1threshold\$1p95 | Définit le seuil du 95e quantile d'utilisation du GPU en pourcentage. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `70` (en pourcentage) |
| gpu\$1memory\$1threshold\$1p95 | Définit le seuil du 95e quantile d'utilisation de la mémoire GPU en pourcentage. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `70` (en pourcentage) |
| patience | Définit le nombre de points de données à ignorer jusqu'à ce que la règle lance l'évaluation. Les premières étapes des tâches d'entraînement affichent généralement un volume élevé de processus de données, c'est pourquoi vous devez faire patienter la règle et l'empêcher d'être invoquée trop tôt en spécifiant un nombre de données de profilage avec ce paramètre. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `100` |
| window | Taille de la fenêtre pour le calcul des quantiles. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `500` |
| scan\$1interval\$1us | Intervalle de temps pendant lequel les fichiers de chronologie sont analysés. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `60000000` (en microsecondes) |
## CPUBottleneck
La CPUBottleneck règle permet de détecter si le GPU est sous-utilisé en raison d'un engorgement du processeur. La règle renvoie la valeur True si le nombre de goulets d'étranglement du CPU dépasse un seuil prédéfini.
Descriptions des paramètres de la CPUBottleneck règle
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| threshold | Définit le seuil de la proportion de temps limité par rapport au temps d'entraînement total. Si la proportion dépasse le pourcentage spécifié pour le paramètre de seuil, le statut de la règle passe à True. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `50` (en pourcentage) |
| gpu\$1threshold | Seuil qui définit une faible utilisation du GPU. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `10` (en pourcentage) |
| cpu\$1threshold | Seuil qui définit une utilisation élevée du CPU. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `90` (en pourcentage) |
| patience | Définit le nombre de points de données à ignorer jusqu'à ce que la règle lance l'évaluation. Les premières étapes des tâches d'entraînement affichent généralement un volume élevé de processus de données, c'est pourquoi vous devez faire patienter la règle et l'empêcher d'être invoquée trop tôt en spécifiant un nombre de données de profilage avec ce paramètre. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `100` |
| scan\$1interval\$1us | Intervalle de temps pendant lequel les fichiers de chronologie sont analysés. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `60000000` (en microsecondes) |
## GPUMemoryAugmenter
La règle GPUMemory d'augmentation permet de détecter une augmentation importante de l'utilisation de la mémoire sur GPUs.
Descriptions des paramètres de la règle GPUMemory d'augmentation
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| increase | Définit le seuil pour l'augmentation absolue de la mémoire. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `10` (en pourcentage) |
| patience | Définit le nombre de points de données à ignorer jusqu'à ce que la règle lance l'évaluation. Les premières étapes des tâches d'entraînement affichent généralement un volume élevé de processus de données, c'est pourquoi vous devez faire patienter la règle et l'empêcher d'être invoquée trop tôt en spécifiant un nombre de données de profilage avec ce paramètre. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `100` |
| window | Taille de la fenêtre pour le calcul des quantiles. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `500` |
| scan\$1interval\$1us | Intervalle de temps pendant lequel les fichiers de chronologie sont analysés. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `60000000` (en microsecondes) |
## IOBottleneck
Cette règle permet de détecter si le GPU est sous-utilisé en raison de goulets d'étranglement des I/O de données. La règle renvoie la valeur True si le nombre de goulets d'étranglement d'I/O dépasse un seuil prédéfini.
Descriptions des paramètres de la IOBottleneck règle
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| threshold | Définit le seuil pour que la règle renvoie True.**Facultatif**Valeurs valides : nombre entierValeur par défaut : `50` (en pourcentage) |
| gpu\$1threshold | Seuil qui définit quand le GPU est considéré comme sous-utilisé. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `70` (en pourcentage) |
| io\$1threshold | Seuil qui définit un temps d'attente d'I/O élevé.**Facultatif**Valeurs valides : nombre entierValeurs par défaut : `50` (en pourcentage) |
| patience | Définit le nombre de points de données à ignorer jusqu'à ce que la règle lance l'évaluation. Les premières étapes des tâches d'entraînement affichent généralement un volume élevé de processus de données, c'est pourquoi vous devez faire patienter la règle et l'empêcher d'être invoquée trop tôt en spécifiant un nombre de données de profilage avec ce paramètre.**Facultatif**Valeurs valides : nombre entierValeurs par défaut : `1000` |
| scan\$1interval\$1us | Intervalle de temps pendant lequel les fichiers de chronologie sont analysés. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `60000000` (en microsecondes) |
## LoadBalancing
La LoadBalancing règle permet de détecter les problèmes d'équilibrage de la charge de travail entre plusieurs GPUs.
Descriptions des paramètres de la LoadBalancing règle
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| threshold | Définit le pourcentage d'application. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `0.5` (proportion sans unité) |
| patience | Définit le nombre de points de données à ignorer jusqu'à ce que la règle lance l'évaluation. Les premières étapes des tâches d'entraînement affichent généralement un volume élevé de processus de données, c'est pourquoi vous devez faire patienter la règle et l'empêcher d'être invoquée trop tôt en spécifiant un nombre de données de profilage avec ce paramètre. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `10` |
| scan\$1interval\$1us | Intervalle de temps pendant lequel les fichiers de chronologie sont analysés. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `60000000` (en microsecondes) |
## Faible GPUUtilization
La GPUUtilization règle Low permet de détecter si le taux d'utilisation du GPU est faible ou s'il est soumis à des fluctuations. Ceci est vérifié pour chaque GPU sur chaque composant. La règle renvoie True si le 95e quantile est inférieur à threshold\$1p95, ce qui indique une sous-utilisation. La règle renvoie True si le 95e quantile est supérieur à threshold\$1p95 et le 5e quantile est inférieur à threshold\$1p5, ce qui indique des fluctuations.
Descriptions des paramètres de la GPUUtilization règle inférieure
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| threshold\$1p95 | Seuil pour le 95e quantile au-dessous duquel le GPU est considéré comme sous-utilisé. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `70` (en pourcentage) |
| threshold\$1p5 | Seuil pour le 5e quantile. La valeur par défaut est 10 %.**Facultatif**Valeurs valides : nombre entierValeurs par défaut : `10` (en pourcentage) |
| patience | Définit le nombre de points de données à ignorer jusqu'à ce que la règle lance l'évaluation. Les premières étapes des tâches d'entraînement affichent généralement un volume élevé de processus de données, c'est pourquoi vous devez faire patienter la règle et l'empêcher d'être invoquée trop tôt en spécifiant un nombre de données de profilage avec ce paramètre. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `1000` |
| window | Taille de la fenêtre pour le calcul des quantiles. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `500` |
| scan\$1interval\$1us | Intervalle de temps pendant lequel les fichiers de chronologie sont analysés. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `60000000` (en microsecondes) |
## OverallSystemUsage
La OverallSystemUsage règle mesure l'utilisation globale du système par nœud de travail. Actuellement, la règle agrège uniquement les valeurs par nœud et calcule leurs percentiles.
Descriptions des paramètres de la OverallSystemUsage règle
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| scan\$1interval\$1us | Intervalle de temps pendant lequel les fichiers de chronologie sont analysés. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `60000000` (en microsecondes) |
## MaxInitializationTime
La MaxInitializationTime règle permet de détecter si l'initialisation de l'entraînement prend trop de temps. La règle attend que la première étape soit disponible.
Descriptions des paramètres de la MaxInitializationTime règle
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| threshold | Définit le seuil en minutes à attendre pour que la première étape devienne disponible. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `20` (en minutes) |
| scan\$1interval\$1us | Intervalle de temps pendant lequel les fichiers de chronologie sont analysés. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `60000000` (en microsecondes) |
## OverallFrameworkMetrics
La OverallFrameworkMetrics règle résume le temps consacré aux métriques du framework, telles que les passes en avant et en arrière, et le chargement des données.
Descriptions des paramètres de la OverallFrameworkMetrics règle
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| scan\$1interval\$1us | Intervalle de temps pendant lequel les fichiers de chronologie sont analysés. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `60000000` (en microsecondes) |
## StepOutlier
La StepOutlier règle permet de détecter les valeurs aberrantes dans la durée des étapes. Cette règle renvoie `True` s'il y a des valeurs aberrantes avec des durées d'étape supérieures à `stddev` sigmas de l'ensemble des durées d'étape dans une plage de temps.
Descriptions des paramètres de la StepOutlier règle
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche de formation en cours par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| stddev | Définit un facteur par lequel multiplier l'écart standard. Par exemple, la règle est invoquée par défaut lorsqu'une durée d'étape est supérieure ou inférieure à 5 fois l'écart standard. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `5` (en minutes) |
| mode | Mode sous lequel les étapes ont été enregistrées et sur lequel la règle doit s'exécuter. La règle par défaut s'exécute sur les étapes de la phase EVAL et TRAIN**Facultatif**Valeurs valides : nombre entierValeur par défaut : `5` (en minutes) |
| n\$1outliers | Nombre de valeurs aberrantes à ignorer avant que la règle ne renvoie True**Facultatif**Valeurs valides : nombre entierValeur par défaut : `10` |
| scan\$1interval\$1us | Intervalle de temps pendant lequel les fichiers de chronologie sont analysés. **Facultatif** Valeurs valides : nombre entier Valeurs par défaut : `60000000` (en microsecondes) |
# Interface utilisateur Amazon SageMaker Debugger dans Amazon SageMaker Studio Classic Experiments
Utilisez le tableau de bord Amazon SageMaker Debugger Insights dans Amazon SageMaker Studio Classic Experiments pour analyser les performances de votre modèle et les goulots d'étranglement du système lors de l'exécution de tâches de formation sur des instances Amazon Elastic Compute Cloud (Amazon EC2). Obtenez des informations sur vos tâches d'entraînement et améliorez les performances et la précision de votre entraînement du modèle grâce aux tableaux de bord Debugger. Par défaut, Debugger surveille les métriques système (CPU, GPU, mémoire GPU, réseau et E/S de données) toutes les 500 millisecondes et les tenseurs de sortie de base (perte et précision) toutes les 500 itérations pour les tâches d'entraînement. Vous pouvez également personnaliser davantage les valeurs des paramètres de configuration du Debugger et ajuster les intervalles de sauvegarde via l'interface utilisateur de Studio Classic ou à l'aide du SDK Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
**Important**
Si vous utilisez une application Studio Classic existante, supprimez-la et redémarrez-la pour utiliser les nouvelles caractéristiques Studio Classic. Pour savoir comment redémarrer et mettre à jour votre environnement Studio Classic, consultez [Mettre à jour Amazon SageMaker AI Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-tasks-update.html).
**Topics**
+ [Ouvrez le tableau de bord Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md)
+ [Contrôleur de SageMaker tableau de bord Amazon Debugger Insights](debugger-on-studio-insights-controllers.md)
+ [Explorez le tableau de bord Amazon SageMaker Debugger Insights](debugger-on-studio-insights-walkthrough.md)
+ [Arrêtez l'instance Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md)
# Ouvrez le tableau de bord Amazon SageMaker Debugger Insights
Dans le tableau de bord SageMaker Debugger Insights de Studio Classic, vous pouvez consulter les informations relatives à l'utilisation des ressources informatiques, à l'utilisation des ressources et aux goulots d'étranglement du système liés à votre tâche de formation exécutée sur des instances Amazon EC2 en temps réel et après les formations
**Note**
Le tableau de bord SageMaker Debugger Insights exécute une application Studio Classic sur une `ml.m5.4xlarge` instance pour traiter et afficher les visualisations. Chaque onglet SageMaker Debugger Insights exécute une session de noyau Studio Classic. Plusieurs sessions de noyau pour plusieurs onglets de SageMaker Debugger Insights s'exécutent sur une seule instance. Lorsque vous fermez un onglet SageMaker Debugger Insights, la session de noyau correspondante est également fermée. L’application Studio Classic reste active et accumule des frais pour l’utilisation de l’instance `ml.m5.4xlarge`. Pour plus d'informations sur les tarifs, consultez la page de [ SageMaker tarification d'Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Important**
Lorsque vous avez terminé d'utiliser le tableau de bord SageMaker Debugger Insights, vous devez arrêter l'`ml.m5.4xlarge`instance pour éviter d'accumuler des frais. Pour plus d'informations sur la façon d'arrêter une instance, consultez [Arrêtez l'instance Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
**Pour ouvrir le tableau de bord SageMaker Debugger Insights**
1. Sur la page **Accueil** de Studio Classic, choisissez **Expériences** dans le panneau de navigation de gauche.
1. Recherchez votre tâche d'entraînement sur la page **Experiments** (Expériences). Si votre tâche d'entraînement a été configurée avec une exécution Expériences, la tâche doit apparaître dans l'onglet **Expériences** ; si vous n'avez pas configuré d'exécution Expériences, la tâche doit apparaître dans l'onglet **Exécutions non attribuées**.
1. Cliquez sur le lien du nom de la tâche d'entraînement pour voir les détails de la tâche.
1. Dans le menu **APERÇU**, choisissez **Débogueur**. Cela devrait afficher les deux sections suivantes.
+ Dans la section **Règles du débogueur**, vous pouvez parcourir le statut des règles intégrées à Debugger associées à la tâche d'entraînement.
+ Dans la section **Debugger Insights**, vous trouverez des liens permettant d'ouvrir SageMaker Debugger Insights sur le tableau de bord.
1. Dans la section **SageMaker Debugger Insights, cliquez sur** le lien du nom du poste de formation pour ouvrir le tableau de bord SageMaker Debugger Insights. Cela ouvre une fenêtre **Debug [your-training-job-name]**. Dans cette fenêtre, Debugger présente les performances de calcul de votre tâche d'entraînement sur les instances Amazon EC2 et vous aide à identifier les problèmes d'utilisation des ressources de calcul.
Vous pouvez également télécharger un rapport de profilage agrégé en ajoutant la [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)règle intégrée de SageMaker Debugger. Pour plus d'informations, voir [Configurer les règles de profilage intégrées](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html) et le [rapport de profilage généré à l'aide du SageMaker débogueur](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html).
# Contrôleur de SageMaker tableau de bord Amazon Debugger Insights
Il existe différents composants du contrôleur Debugger pour la surveillance et le profilage. Dans ce guide, vous allez découvrir les composants du contrôleur Debugger.
**Note**
Le tableau de bord SageMaker Debugger Insights exécute une application Studio Classic sur une `ml.m5.4xlarge` instance pour traiter et afficher les visualisations. Chaque onglet SageMaker Debugger Insights exécute une session de noyau Studio Classic. Plusieurs sessions de noyau pour plusieurs onglets de SageMaker Debugger Insights s'exécutent sur une seule instance. Lorsque vous fermez un onglet SageMaker Debugger Insights, la session de noyau correspondante est également fermée. L’application Studio Classic reste active et accumule des frais pour l’utilisation de l’instance `ml.m5.4xlarge`. Pour plus d'informations sur les tarifs, consultez la page de [ SageMaker tarification d'Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Important**
Lorsque vous avez terminé d'utiliser le tableau de bord SageMaker Debugger Insights, arrêtez l'`ml.m5.4xlarge`instance pour éviter d'accumuler des frais. Pour plus d'informations sur la façon d'arrêter une instance, consultez [Arrêtez l'instance Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
## SageMaker Interface utilisateur du contrôleur Debugger Insights
À l'aide du contrôleur Debugger situé en haut à gauche du tableau de bord Insights, vous pouvez actualiser le tableau de bord, configurer ou mettre à jour les paramètres Debugger pour surveiller les métriques système, arrêter la tâche d'entraînement et télécharger le rapport de profilage Debugger.
![\[SageMaker Contrôleurs de tableau de bord Debugger Insights\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-studio-insights-refresh.png)
+ Si vous souhaitez actualiser manuellement le tableau de bord, choisissez le bouton d'actualisation (la flèche arrondie en haut à gauche) comme indiqué dans la capture d'écran précédente.
+ Le bouton **Monitoring** est activé par défaut pour toute tâche de SageMaker formation initiée à l'aide du SDK SageMaker Python. S'il n'est pas activé, vous pouvez utiliser le bouton à bascule pour démarrer la surveillance. Pendant la surveillance, Debugger collecte uniquement les métriques d'utilisation des ressources pour détecter les problèmes de calcul, tels que les goulets d'étranglement du CPU et la sous-utilisation du GPU. Pour obtenir la liste complète des problèmes d’utilisation des ressources que Debugger surveille, consultez [Règles intégrées à Debugger pour le profilage de l’utilisation des ressources matérielles du système (métriques système)](debugger-built-in-profiler-rules.md#built-in-rules-monitoring).
+ Le bouton **Configurer la surveillance** ouvre une fenêtre contextuelle que vous pouvez utiliser pour définir ou mettre à jour la fréquence de collecte des données et le chemin S3 pour enregistrer les données.
![\[La fenêtre contextuelle permettant de configurer les paramètres de surveillance de Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-studio-enable-profiling-2.png)
Vous pouvez spécifier des valeurs pour les champs suivants.
+ **S3 bucket URI** (URI du compartiment S3) : spécifiez l'URI du compartiment S3 de base.
+ **Collect monitoring data every** (Collecter les données de surveillance toutes les) : sélectionnez un intervalle de temps pour la collecte des métriques système. Vous pouvez choisir un intervalle de surveillance dans la liste déroulante. Les intervalles disponibles sont 100 millisecondes, 200 millisecondes, 500 millisecondes (par défaut), 1 seconde, 5 secondes et 1 minute.
**Note**
Si vous choisissez l'un des intervalles les plus courts, vous augmentez la granularité des métriques d'utilisation des ressources, ce qui vous permet de capturer les pics et les anomalies avec une résolution temporelle plus élevée. Toutefois, plus la résolution est élevée, plus la taille des métriques système à traiter est importante. Cela peut entraîner des frais supplémentaires et avoir un impact sur le temps global d'entraînement et de traitement.
+ À l'aide du bouton **Arrêter l'entraînement**, vous pouvez arrêter la tâche d'entraînement lorsque vous constatez des anomalies dans l'utilisation des ressources.
+ À l'aide du bouton **Télécharger le rapport**, vous pouvez télécharger un rapport de profilage agrégé en utilisant la [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)règle intégrée de SageMaker Debugger. Le bouton est activé lorsque vous ajoutez la [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)règle intégrée à l'estimateur. Pour plus d'informations, voir [Configurer les règles de profilage intégrées](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html) et le [rapport de profilage généré à l'aide du SageMaker débogueur](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html).
# Explorez le tableau de bord Amazon SageMaker Debugger Insights
Lorsque vous lancez une tâche de SageMaker formation, SageMaker Debugger commence à surveiller l'utilisation des ressources des instances Amazon EC2 par défaut. Vous pouvez suivre les taux d'utilisation du système, l'aperçu des statistiques et l'analyse des règles intégrée via le tableau de bord Insights. **Ce guide vous présente le contenu du tableau de bord SageMaker Debugger Insights sous les onglets suivants : **System Metrics** and Rules.**
**Note**
Le tableau de bord SageMaker Debugger Insights exécute une application Studio Classic sur une `ml.m5.4xlarge` instance pour traiter et afficher les visualisations. Chaque onglet SageMaker Debugger Insights exécute une session de noyau Studio Classic. Plusieurs sessions de noyau pour plusieurs onglets de SageMaker Debugger Insights s'exécutent sur une seule instance. Lorsque vous fermez un onglet SageMaker Debugger Insights, la session de noyau correspondante est également fermée. L’application Studio Classic reste active et accumule des frais pour l’utilisation de l’instance `ml.m5.4xlarge`. Pour plus d'informations sur les tarifs, consultez la page de [ SageMaker tarification d'Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Important**
Lorsque vous avez terminé d'utiliser le tableau de bord SageMaker Debugger Insights, arrêtez l'`ml.m5.4xlarge`instance pour éviter d'accumuler des frais. Pour plus d'informations sur la façon d'arrêter une instance, consultez [Arrêtez l'instance Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
**Important**
Dans les rapports, les diagrammes et les recommandations sont fournis à titre informatif et ne sont pas définitifs. Vous êtes tenu de réaliser votre propre évaluation indépendante des informations.
**Topics**
+ [Métriques du système](#debugger-insights-system-metrics-tab)
+ [Rules](#debugger-on-studio-insights-rules)
## Métriques du système
Dans l'onglet **Métriques du système**, vous pouvez utiliser le tableau récapitulatif et les diagrammes de séries chronologiques pour comprendre l'utilisation des ressources.
### Synthèse d'utilisation des ressources
Ce tableau récapitulatif présente les statistiques des métriques d'utilisation des ressources de calcul de tous les nœuds (appelées algo-*n*). Les mesures d'utilisation des ressources incluent l'utilisation totale du processeur, l'utilisation totale du processeur graphique, l'utilisation totale de la mémoire du processeur, l'utilisation totale de la mémoire du processeur graphique, le temps d' I/O attente total et le réseau total en octets. Le tableau affiche les valeurs minimales et maximales, ainsi que les percentiles p99, p90 et p50.
![\[Un tableau récapitulatif de l'utilisation des ressources\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-studio-insights-resource-util-summary.png)
### Graphiques chronologiques de l'utilisation des ressources
Utilisez les graphiques chronologiques pour obtenir plus de détails sur l'utilisation des ressources et identifier à quel intervalle de temps chaque instance affiche un taux d'utilisation indésirable, tel qu'une faible utilisation des GPU et les goulots d'étranglement des CPU susceptibles de provoquer le gaspillage d'une instance coûteuse.
**L'interface utilisateur du contrôleur de graphiques chronologiques**
La capture d'écran suivante montre le contrôleur de l'interface utilisateur pour ajuster les graphiques chronologiques.
![\[\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-insights-graph-controller.png)
+ **algo-1** : utilisez ce menu déroulant pour choisir le nœud que vous souhaitez examiner.
+ **Zoom avant** : utilisez ce bouton pour effectuer un zoom avant sur les graphiques chronologiques et afficher des intervalles de temps plus courts.
+ **Zoom arrière** : utilisez ce bouton pour effectuer un zoom arrière sur les graphiques chronologiques et afficher des intervalles de temps plus longs.
+ **Panoramique vers la gauche** : déplacez les graphiques chronologiques vers un intervalle de temps antérieur.
+ **Panoramique vers la droite** : déplacez les graphiques chronologiques vers un intervalle de temps futur.
+ **Corriger le calendrier** : utilisez cette case à cocher pour corriger ou rétablir les graphiques chronologiques afin d'afficher la vue complète, du premier point de données au dernier point de données.
**Utilisation du processeur et temps I/O d'attente**
Les deux premiers graphiques montrent l'utilisation du processeur et le temps I/O d'attente au fil du temps. Par défaut, les graphiques indiquent la moyenne du taux d'utilisation du processeur et du temps d' I/O attente consacré aux cœurs du processeur. Vous pouvez sélectionner un ou plusieurs cœurs CPU, en sélectionnant les étiquettes, pour les représenter graphiquement sur un seul graphique et comparer l'utilisation entre les cœurs. Vous pouvez parcourir et faire un zoom avant et arrière pour voir de plus près des intervalles de temps spécifiques.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-insights-node-cpu.png)
**Utilisation de GPU et de la mémoire GPU**
Les graphiques suivants montrent l'utilisation du GPU et l'utilisation de la mémoire GPU au fil du temps. Par défaut, les graphiques indiquent le taux d'utilisation moyen dans le temps. Vous pouvez sélectionner les étiquettes des cœurs GPU pour voir leur taux d'utilisation. Si vous prenez la moyenne du taux d'utilisation sur le nombre total de cœurs GPU, vous avez l'utilisation moyenne de l'ensemble des ressources matérielles du système. En examinant le taux d'utilisation moyen, vous pouvez vérifier l'utilisation globale des ressources système d'une instance Amazon EC2. La figure suivante illustre un exemple de tâche d'entraînement sur une instance `ml.p3.16xlarge` avec 8 cœurs de GPU. Vous pouvez vérifier si les tâches de formation sont bien réparties, en les utilisant pleinement GPUs.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-studio-insights-node-gpu.gif)
**Utilisation globale du système au fil du temps**
La carte thermique suivante montre un exemple de l'utilisation totale du système d'une instance `ml.p3.16xlarge` dans le temps, projetée sur le diagramme bidimensionnel. Tous les cœurs de CPU et de GPU sont répertoriés dans l'axe vertical et l'utilisation est enregistrée au fil du temps avec une palette de couleurs, où les couleurs vives représentent une utilisation faible et les couleurs plus sombres une utilisation élevée. Consultez la barre de couleurs étiquetée sur le côté droit du graphique pour savoir quel niveau de couleur correspond à quel taux d'utilisation.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-studio-insights-node-heatmap.png)
## Rules
Utilisez l'onglet **Règles** pour trouver un résumé de l'analyse des règles de profilage sur votre tâche d'entraînement. Si la règle de profilage est activée avec la tâche d'entraînement, le texte apparaît surligné par un texte blanc uni. Les règles inactives sont grisées. Pour activer ces règles, suivez les instructions dans [Utilisez des règles de profilage intégrées gérées par Amazon Debugger SageMaker](use-debugger-built-in-profiler-rules.md).
![\[L'onglet Règles du tableau de bord SageMaker Debugger Insights\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-insights-rules.png)
# Arrêtez l'instance Amazon SageMaker Debugger Insights
Lorsque vous n'utilisez pas le tableau de bord SageMaker Debugger Insights, vous devez fermer l'instance de l'application pour éviter d'encourir des frais supplémentaires.
**Pour arrêter l'instance de l'application SageMaker Debugger Insights dans Studio Classic**
![\[Capture d'écran animée qui montre comment arrêter une instance de tableau de bord SageMaker Debugger Insights.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-studio-insights-shut-down.png)
1. Dans Studio Classic, sélectionnez l’icône **Instances et noyaux en cours d’exécution** (![\[Square icon with a white outline of a cloud on a dark blue background.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/icons/Running_squid.png)).
1. Sous la liste **RUNNING APPS (APPLICATIONS EN COURS D'EXÉCUTION)**, recherchez la valeur **sagemaker-debugger-1.0**. Sélectionnez l’icône d’arrêt (![\[Power button icon with a circular shape and vertical line symbol.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/icons/Shutdown_light.png)) située près de l’application. Les tableaux de bord SageMaker Debugger Insights s'exécutent sur une instance. `ml.m5.4xlarge` Cette instance disparaît également de **RUNNING INSTANCES (INSTANCES EN COURS D'EXÉCUTION)** lorsque vous arrêtez l'appli **sagemaker-debugger-1.0**.
# SageMaker Rapport interactif du débogueur
Recevez des rapports de profilage générés automatiquement par Debugger. Le rapport Debugger fournit des informations sur vos tâches d'entraînement et suggère des recommandations pour améliorer les performances de votre modèle. La capture d'écran suivante montre un collage du rapport de profilage Debugger. Pour en savoir plus, consultez [SageMaker Rapport interactif du débogueur](#debugger-profiling-report).
**Note**
Vous pouvez télécharger un rapport Debugger pendant que votre tâche d'entraînement est en cours d'exécution ou une fois la tâche terminée. Pendant l'entraînement, Debugger met à jour le rapport reflétant le statut d'évaluation des règles actuelles. Vous ne pouvez télécharger un rapport Debugger complet qu'une fois la tâche d'entraînement terminée.
**Important**
Dans les rapports, les diagrammes et les recommandations sont fournis à titre informatif et ne sont pas définitifs. Vous êtes tenu de réaliser votre propre évaluation indépendante des informations.
![\[Exemple de rapport récapitulatif de tâche d'entraînement Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profile-report.jpg)
Pour tous les travaux de SageMaker formation, la [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) règle SageMaker Debugger invoque toutes les règles de [surveillance et de profilage et regroupe l'analyse des règles](debugger-built-in-profiler-rules.md#built-in-rules-monitoring) dans un rapport complet. En suivant ce guide, téléchargez le rapport à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) ou de la console S3, et découvrez ce que vous pouvez interpréter à partir des résultats du profilage.
**Important**
Dans le rapport, les diagrammes et les recommandations sont fournis à titre informatif et ne sont pas définitifs. Vous êtes tenu de réaliser votre propre évaluation indépendante des informations.
# Téléchargez le rapport de SageMaker profilage du Debugger
Téléchargez le rapport de profilage du SageMaker Debugger pendant que votre tâche de formation est en cours d'exécution ou une fois la tâche terminée à l'aide du [SDK et ( AWS Command Line Interface CLI) Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
**Note**
Pour obtenir le rapport de profilage généré par SageMaker Debugger, vous devez utiliser la [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)règle intégrée proposée par SageMaker Debugger. Pour activer la règle avec votre tâche d'entraînement, consultez [Configuration des règles de profilage intégrées](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html).
**Astuce**
Vous pouvez également télécharger le rapport en un seul clic dans le tableau de bord SageMaker Studio Debugger Insights. Cela ne nécessite aucun script supplémentaire pour télécharger le rapport. Pour savoir comment télécharger le rapport depuis Studio, consultez [Ouvrez le tableau de bord Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md).
------
#### [ Download using SageMaker Python SDK and AWS CLI ]
1. Vérifiez l'URI de base de sortie S3 par défaut de la tâche en cours.
```
estimator.output_path
```
1. Vérifiez le nom de la tâche en cours.
```
estimator.latest_training_job.job_name
```
1. Le rapport de profilage Debugger est stocké sous `//rule-output`. Configurez le chemin de sortie de la règle comme suit :
```
rule_output_path = estimator.output_path + estimator.latest_training_job.job_name + "/rule-output"
```
1. Pour vérifier si le rapport est généré, listez les répertoires et les fichiers de façon récursive sous `rule_output_path` en utilisant `aws s3 ls` avec l'option `--recursive`.
```
! aws s3 ls {rule_output_path} --recursive
```
Cela devrait renvoyer une liste complète des fichiers sous un dossier généré automatiquement et nommé `ProfilerReport-1234567890`. Le nom du dossier est une combinaison de chaînes `ProfilerReport` et d'une balise unique à 10 chiffres basée sur l'horodatage Unix lorsque la ProfilerReport règle est initiée.
![\[Exemple de sortie de règle\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-rule-output-ls-example.png)
`profiler-report.html` est un rapport de profilage généré automatiquement par Debugger. Les fichiers restants sont les composants d'analyse des règles intégrées stockés dans JSON et un bloc-notes Jupyter, qui sont utilisés pour être agrégés dans le rapport.
1. Téléchargez les fichiers de façon récursive en utilisant `aws s3 cp`. La commande suivante enregistre tous les fichiers de sortie de règle dans le dossier `ProfilerReport-1234567890` sous le répertoire de travail actuel.
```
! aws s3 cp {rule_output_path} ./ --recursive
```
**Astuce**
Si vous utilisez un serveur de bloc-notes Jupyter, exécutez `!pwd` pour vérifier le répertoire de travail actuel.
1. Sous le répertoire `/ProfilerReport-1234567890/profiler-output`, ouvrez `profiler-report.html`. Si c'est JupyterLab le cas, choisissez **Trust HTML** pour voir le rapport de profilage du Debugger généré automatiquement.
![\[Exemple de sortie de règle\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-rule-output-open-html.png)
1. Ouvrez le fichier `profiler-report.ipynb` pour voir comment le rapport est généré. Vous pouvez également personnaliser et étendre le rapport de profilage à l'aide du fichier de bloc-notes Jupyter.
------
#### [ Download using Amazon S3 Console ]
1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Recherchez le compartiment S3 de base. Par exemple, si vous n'avez pas spécifié de nom de tâche de base, le nom du compartiment S3 de base doit être au format suivant : `sagemaker--111122223333`. Recherchez le compartiment S3 de base à l'aide du champ *Find bucket by name (Rechercher des compartiments par nom)*.
![\[Exemple d'utilisation de l'URI du compartiment S3 de sortie de règle\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-0.png)
1. Dans le compartiment S3 de base, recherchez le nom de la tâche d'entraînement en spécifiant votre préfixe de nom de tâche dans le champ de saisie *Find objects by prefix (Rechercher des objets par préfixe)*. Choisissez le nom de la tâche d'entraînement.
![\[Exemple d'utilisation de l'URI du compartiment S3 de sortie de règle\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-1.png)
1. Le compartiment S3 de la tâche d'entraînement doit contenir trois sous-dossiers pour les données d'entraînement collectées par Debugger : **debug-output/**, **profiler-output/** et **rule-output/**. Choisissez **rule-output/**.
![\[Exemple d'utilisation de l'URI du compartiment S3 de sortie de règle\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-2.png)
1. **Dans le dossier **rule-output/, choisissez ProfilerReport -1234567890****, puis choisissez le dossier profiler-output/**.** Le dossier **profiler-output/** contient **profiler-report.html** (le rapport de profilage généré automatiquement en html), **profiler-report.ipynb** (un bloc-notes Jupyter avec des scripts qui sont utilisés pour générer le rapport) et **profiler-report/** (contient les fichiers JSON d'analyse de règle qui sont utilisés comme composants du rapport).
1. Sélectionnez le fichier **profiler-report.html** et choisissez **Actions**, puis **Download (Télécharger)**.
![\[Exemple d'utilisation de l'URI du compartiment S3 de sortie de règle\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-3.png)
1. Ouvrez le fichier téléchargé **profiler-report.html** dans un navigateur web.
------
**Note**
Si vous avez démarré votre tâche d'entraînement sans configurer les paramètres spécifiques à Debugger, Debugger génère le rapport uniquement en fonction des règles de surveillance du système, car les paramètres Debugger ne sont pas configurés pour enregistrer les métriques de cadre. Pour activer le profilage des métriques du framework et recevoir un rapport de profilage étendu du Debugger, configurez le `profiler_config` paramètre lors de la construction ou de la mise à jour des estimateurs d' SageMaker IA.
Pour découvrir comment configurer le paramètre `profiler_config` avant de démarrer une tâche d'entraînement, consultez [Configuration de l’estimateur pour le profilage du cadre](debugger-configure-framework-profiling.md).
Pour mettre à jour la tâche d'entraînement actuelle et activer le profilage des métriques de cadre, consultez [Update Debugger Framework Profiling Configuration](debugger-update-monitoring-profiling.md).
# Démonstration du rapport de profilage Debugger
Cette section présente le rapport de profilage de Debugger section par section. Le rapport de profilage est généré sur la base des règles intégrées de surveillance et de profilage. Le rapport affiche des résultats uniquement pour les règles qui ont détecté des problèmes.
**Important**
Dans le rapport, les diagrammes et les recommandations sont fournis à titre informatif et ne sont pas définitifs. Vous êtes tenu de réaliser votre propre évaluation indépendante des informations.
**Topics**
+ [Résumé des tâches d'entraînement](#debugger-profiling-report-walkthrough-summary)
+ [Statistiques d'utilisation du système](#debugger-profiling-report-walkthrough-system-usage)
+ [Résumé des métriques de cadre](#debugger-profiling-report-walkthrough-framework-metrics)
+ [Résumé des règles](#debugger-profiling-report-walkthrough-rules-summary)
+ [Analyse de la boucle d'entraînement : durée des étapes](#debugger-profiling-report-walkthrough-step-durations)
+ [Analyse d'utilisation du GPU](#debugger-profiling-report-walkthrough-gpu-utilization)
+ [Taille de lot](#debugger-profiling-report-walkthrough-batch-size)
+ [Goulets d'étranglement de CPU](#debugger-profiling-report-walkthrough-cpu-bottlenecks)
+ [Goulets d'étranglement des E/S](#debugger-profiling-report-walkthrough-io-bottlenecks)
+ [Équilibrage de charge dans un entraînement multi-GPU](#debugger-profiling-report-walkthrough-workload-balancing)
+ [Analyse de mémoire GPU](#debugger-profiling-report-walkthrough-gpu-memory)
## Résumé des tâches d'entraînement
Le début du rapport présente un résumé de votre tâche d'entraînement. Dans cette section, vous pouvez voir les durées et les horodatages aux différentes phases d'entraînement.
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-summary.gif)
Le tableau récapitulatif comprend les informations suivantes :
+ **start\$1time** : heure exacte à laquelle la tâche d'entraînement a démarré.
+ **end\$1time** : heure exacte à laquelle la tâche d'entraînement s'est terminée.
+ **job\$1duration\$1in\$1seconds** : durée totale d'entraînement de l'heure de début (**start\$1time**) à l'heure de fin (**end\$1time**).
+ **training\$1loop\$1start** : heure exacte à laquelle la première étape de la première époque a démarré.
+ **training\$1loop\$1end** : heure exacte à laquelle la dernière étape de la dernière époque s'est terminée.
+ **training\$1loop\$1duration\$1in\$1seconds** : durée totale entre l'heure de début de la boucle d'entraînement et l'heure de fin de la boucle d'entraînement.
+ **initialization\$1in\$1seconds** : temps consacré à l'initialisation de la tâche d'entraînement. La phase d'initialisation couvre la période de l'heure de début (**start\$1time**) à l'heure de début de la bouche d'entraînement (**training\$1loop\$1start**). Le temps d'initialisation concerne la compilation du script d'entraînement, le démarrage du script d'entraînement, la création et l'initialisation du modèle, l'initialisation des instances EC2 et le téléchargement des données d'entraînement.
+ **finalization\$1in\$1seconds** : temps consacré à la finalisation de la tâche d'entraînement, par exemple pour la fin de l'entraînement du modèle, la mise à jour des artefacts du modèle et la fermeture des instances EC2. La phase de finalisation couvre la période allant de l'heure de fin de la boucle d'entraînement (**training\$1loop\$1end**) à l'heure de fin (**end\$1time**).
+ **initialisation (%)** : pourcentage de temps passé sur l'**initialisation** par rapport à la **durée totale de la tâche en secondes**.
+ **training loop (%)** : pourcentage de temps passé sur la **boucle d'entraînement** par rapport à la **durée totale de la tâche en secondes**.
+ **finalization (%)** : pourcentage de temps passé sur la **finalisation** par rapport à la **durée totale de la tâche en secondes**.
## Statistiques d'utilisation du système
Dans cette section, vous pouvez voir une présentation des statistiques d'utilisation du système.
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-system-usage.png)
Le rapport de profilage Debugger inclut les informations suivantes :
+ **node** : répertorie le nom des nœuds. Si vous utilisez un entraînement distribué sur plusieurs nœuds (plusieurs instances EC2), les noms de nœuds sont au format `algo-n`.
+ **metric** : métriques système collectées par Debugger : CPU, GPU, mémoire CPU, mémoire GPU, I/O et métriques réseau.
+ **unit** : unité des métriques système.
+ **max** : valeur maximale de chaque métrique système.
+ **p99** : 99e percentile de chaque utilisation du système.
+ **p95** : 95e percentile de chaque utilisation du système.
+ **p50** : 50e percentile (médian) de chaque utilisation du système.
+ **min** : valeur minimale de chaque métrique système.
## Résumé des métriques de cadre
Dans cette section, les diagrammes à secteurs suivants montrent la répartition des opérations du cadre sur CPUs et GPUs.
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-metrics-summary.gif)
Chacun des diagrammes à secteurs analyse les métriques de cadre collectés sur différents aspects, comme suit :
+ **Rapport entre les TRAIN/EVAL phases et les autres** — Indique le rapport entre les durées consacrées aux différentes phases d'entraînement.
+ **Ratio between forward and backward pass (Rapport entre la transmission vers l'avant et la transmission vers l'arrière)** : affiche le rapport entre les durées passées sur la transmission vers l'avant et vers l'arrière dans la boucle d'entraînement.
+ **Rapport entre CPU/GPU les opérateurs** : indique le rapport entre le temps passé sur les opérateurs fonctionnant sur un processeur ou un processeur graphique, tels que les opérateurs convolutifs.
+ **Métriques générales enregistrées dans le cadre** : affiche le rapport entre le temps passé sur les principales métriques de cadre, telles que le chargement des données, la transmission vers l'avant et la transmission vers l'arrière.
### Présentation : opérateurs CPU
Cette section fournit des informations détaillées sur les opérateurs de CPU. Le tableau indique le pourcentage de temps et le temps cumulé absolu passé sur les opérateurs de CPU les plus fréquemment appelés.
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-cpu-operators.gif)
### Présentation : opérateurs GPU
Cette section fournit des informations détaillées sur les opérateurs GPU. Le tableau indique le pourcentage de temps et le temps cumulé absolu passé sur les opérateurs GPU les plus fréquemment appelés.
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-gpu-operators.gif)
## Résumé des règles
Dans cette section, Debugger regroupe les résultats d'évaluation des règles, les analyses, les descriptions de règles et les suggestions.
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-rules-summary.png)
## Analyse de la boucle d'entraînement : durée des étapes
Dans cette section, vous trouverez des statistiques détaillées sur les durées d'étapes sur chaque cœur de GPU de chaque nœud. Debugger évalue les valeurs moyennes, maximales, p99, p95, p50 et minimales des durées d'étape, ainsi que les valeurs aberrantes d'étape. L'histogramme suivant montre les durées des étapes capturées sur les différents nœuds de travail et. GPUs Vous pouvez activer ou désactiver l'histogramme de chaque composant en choisissant les légendes sur le côté droit. Vous pouvez vérifier si un GPU particulier est à l'origine des valeurs aberrantes de durée d'étape.
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-step-duration.gif)
## Analyse d'utilisation du GPU
Cette section présente les statistiques détaillées sur l'utilisation du cœur du processeur graphique selon la GPUUtilization règle Low. Il résume également les statistiques d'utilisation du GPU (moyenne, p95 et p5) afin de déterminer si la tâche de formation est sous-utilisée. GPUs
## Taille de lot
Cette section présente les statistiques détaillées de l'utilisation totale des CPU, de l'utilisation des GPU individuels et des empreintes de mémoire GPU. La BatchSize règle détermine si vous devez modifier la taille du lot pour mieux utiliser le GPUs. Vous pouvez vérifier si la taille du lot est trop petite, ce qui entraîne une sous-utilisation, ou trop grande, ce qui entraîne une surutilisation et des problèmes de mémoire insuffisante. Dans le diagramme, les cases montrent les intervalles de percentiles p25 et p75 (remplis respectivement en violet foncé et en jaune vif) à partir de la médiane (p50). Les barres d'erreur indiquent le 5e percentile pour la limite inférieure et le 95e percentile pour la limite supérieure.
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-batch-size.png)
## Goulets d'étranglement de CPU
Dans cette section, vous pouvez examiner en détail les goulots d'étranglement du processeur détectés par la CPUBottleneck règle lors de votre formation. La règle vérifie si l'utilisation du CPU est supérieure à `cpu_threshold` (90 % par défaut) et si l'utilisation du GPU est inférieure à `gpu_threshold` (10 % par défaut).
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-cpu-bottlenecks.png)
Les graphiques à secteurs affichent les informations suivantes :
+ **Low GPU usage caused by CPU bottlenecks (Faible utilisation du GPU causée par des goulets d'étranglement du CPU** : affiche le rapport des points de données entre ceux dont l'utilisation du GPU est supérieure et inférieure au seuil et ceux qui correspondent aux critères de goulet d'étranglement du CPU.
+ **Rapport entre les TRAIN/EVAL phases et les autres** — Indique le rapport entre les durées consacrées aux différentes phases d'entraînement.
+ **Ratio between forward and backward pass (Rapport entre la transmission vers l'avant et la transmission vers l'arrière)** : affiche le rapport entre les durées passées sur la transmission vers l'avant et vers l'arrière dans la boucle d'entraînement.
+ **Rapport entre CPU/GPU les opérateurs** : indique le rapport entre les durées consacrées à GPUs et CPUs par les opérateurs Python, tels que les processus de chargement de données et les opérateurs de passes avant et arrière.
+ **General metrics recorded in framework (Métriques générales enregistrées dans le cadre)** : affiche les principales métriques de cadre et le rapport entre les durées passées sur les métriques.
## Goulets d'étranglement des E/S
Dans cette section, vous trouverez un résumé des I/O goulets d'étranglement. La règle évalue le temps d' I/O attente et les taux d'utilisation du GPU et surveille le temps passé sur les points d'I/O requests exceeds a threshold percent of the total training time. It might indicate I/Oétranglement liés à l'attente GPUs des données en provenance du stockage.
## Équilibrage de charge dans un entraînement multi-GPU
Dans cette section, vous pouvez identifier les problèmes d'équilibrage de la charge de travail entre les deux GPUs.
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-workload-balancing.gif)
## Analyse de mémoire GPU
Dans cette section, vous pouvez analyser l'utilisation de la mémoire du GPU collectée par la règle GPUMemory d'augmentation. Dans le diagramme, les cases montrent les intervalles de percentiles p25 et p75 (remplis respectivement en violet foncé et en jaune vif) à partir de la médiane (p50). Les barres d'erreur indiquent le 5e percentile pour la limite inférieure et le 95e percentile pour la limite supérieure.
![\[Exemple de rapport de profilage Debugger\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-profiling-report-gpu-memory-utilization.png)
# Désactiver la collecte des statistiques d'utilisation d'Amazon SageMaker Debugger
Pour toutes les tâches de SageMaker formation, Amazon SageMaker Debugger exécute la [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) règle et génère automatiquement un. [SageMaker Rapport interactif du débogueur](debugger-profiling-report.md) La règle `ProfilerReport` fournit un fichier de bloc-notes Jupyter (`profiler-report.ipynb`) qui génère un fichier HTML correspondant (`profiler-report.html`).
Debugger collecte les statistiques d'utilisation des rapports de profilage en incluant du code dans le bloc-notes Jupyter qui collecte les données `ProfilerReport` uniques de l'ARN de la tâche de traitement de la règle si l'utilisateur ouvre le fichier final `profiler-report.html`.
Debugger collecte uniquement des informations indiquant si un utilisateur ouvre le rapport HTML final. Il **NE COLLECTE PAS** des informations provenant des tâches d'entraînement, des données d'entraînement, des scripts d'entraînement, des tâches de traitement, des journaux ou du contenu du rapport de profilage lui-même.
Vous pouvez désactiver la collecte des statistiques d’utilisation à l’aide de l’une des options suivantes.
## (Recommandé) Option 1 : Désactiver la collecte avant d’exécuter une tâche d’entraînement
Pour désactiver la collecte, vous devez ajouter la règle Debugger `ProfilerReport` suivante à votre requête de tâche d'entraînement.
------
#### [ SageMaker Python SDK ]
```
estimator=sagemaker.estimator.Estimator(
...
rules=ProfilerRule.sagemaker(
base_config=rule_configs.ProfilerReport()
rule_parameters={"opt_out_telemetry": "True"}
)
)
```
------
#### [ AWS CLI ]
```
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport-1234567890",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "ProfilerReport",
"opt_out_telemetry": "True"
}
}
]
```
------
#### [ AWS SDK pour Python (Boto3) ]
```
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport-1234567890',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'ProfilerReport',
'opt_out_telemetry': 'True'
}
}
]
```
------
## Option 2 : Désactiver la collecte une fois la tâche d’entraînement terminée
Pour désactiver la collecte une fois l'entraînement terminé, vous devez modifier le fichier `profiler-report.ipynb`.
**Note**
Les rapports HTML générés automatiquement avant que vous ajoutiez l'**option 1** à votre requête de tâche d'entraînement contiennent toujours les statistiques d'utilisation, même une fois que vous avez désactivé la collecte à l'aide de l'**option 2**.
1. Suivez les instructions sur le téléchargement des fichiers de rapport de profilage Debugger sur la page [Téléchargez le rapport de SageMaker profilage du Debugger](debugger-profiling-report-download.md).
1. Dans le répertoire `/ProfilerReport-1234567890/profiler-output`, ouvrez `profiler-report.ipynb`.
1. Ajoutez **opt\$1out=True** à la fonction `setup_profiler_report()` dans la cinquième cellule de code, comme illustré dans l'exemple de code suivant :
```
setup_profiler_report(processing_job_arn, opt_out=True)
```
1. Exécutez la cellule de code pour terminer la désactivation.
# Analyse des données à l'aide de la bibliothèque client Debugger Python
[Pendant que votre tâche de formation est en cours ou une fois celle-ci terminée, vous pouvez accéder aux données de formation collectées par Debugger à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) et de la SMDebug bibliothèque cliente.](https://github.com/awslabs/sagemaker-debugger/) La bibliothèque client Debugger Python fournit des outils d'analyse et de visualisation qui vous permettent d'explorer les données de votre tâche d'entraînement.
**Pour installer la bibliothèque et utiliser ses outils d'analyse (dans un JupyterLab bloc-notes ou un noyau IPython)**
```
! pip install -U smdebug
```
Les rubriques suivantes vous expliquent comment utiliser les outils Debugger Python pour visualiser et analyser les données d'entraînement collectées par Debugger.
**Analyse des métriques système et de framework**
+ [Accès aux données du profil](debugger-analyze-data-profiling.md)
+ [Tracé des données des métriques système et de framework](debugger-access-data-profiling-default-plot.md)
+ [Accès aux données de profilage à l'aide de l'outil d'analyse de données Pandas](debugger-access-data-profiling-pandas-frame.md)
+ [Accès aux données de statistiques de profilage Python](debugger-access-data-python-profiling.md)
+ [Fusion des chronologies de plusieurs fichiers de trace de profil](debugger-merge-timeline.md)
+ [Profilage des chargeurs de données](debugger-data-loading-time.md)
# Accès aux données du profil
La SMDebug `TrainingJob` classe lit les données du compartiment S3 dans lequel les métriques du système et du framework sont enregistrées.
**Pour configurer un objet `TrainingJob` et récupérer les fichiers d'événements de profilage d'une tâche d'entraînement**
```
from smdebug.profiler.analysis.notebook_utils.training_job import TrainingJob
tj = TrainingJob(training_job_name, region)
```
**Astuce**
Vous devez spécifier les paramètres `training_job_name` et `region` pour vous connecter à une tâche d'entraînement. Il existe deux façons de spécifier les informations sur les tâches d'entraînement :
Utilisez le SDK SageMaker Python alors que l'estimateur est toujours associé à la tâche de formation.
```
import sagemaker
training_job_name=estimator.latest_training_job.job_name
region=sagemaker.Session().boto_region_name
```
Passez les chaînes directement.
```
training_job_name="your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS"
region="us-west-2"
```
**Note**
Par défaut, SageMaker Debugger collecte les métriques du système pour surveiller l'utilisation des ressources matérielles et les goulots d'étranglement du système. En exécutant les fonctions suivantes, vous pouvez recevoir des messages d'erreur concernant l'indisponibilité des métriques du framework. Pour récupérer les données de profilage du cadre et obtenir des informations sur les opérations du cadre, vous devez en activer le profilage.
Si vous utilisez le SDK SageMaker Python pour manipuler votre demande de tâche de formation, transmettez le `framework_profile_params` à l'`profiler_config`argument de votre estimateur. Pour en savoir plus, voir [Configurer le profilage du framework SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-framework-profiling.html).
Si vous utilisez Studio Classic, activez le profilage à l’aide du bouton **Profilage** dans le tableau de bord Debugger Insights. Pour en savoir plus, consultez [SageMaker Debugger Insights Dashboard Controller](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio-insights-controllers.html).
**Pour récupérer une description de la tâche d'entraînement et de l'URI du compartiment S3 où les données de métriques sont enregistrées**
```
tj.describe_training_job()
tj.get_config_and_profiler_s3_output_path()
```
**Pour vérifier si les métriques système et de framework sont disponibles à partir de l'URI S3**
```
tj.wait_for_sys_profiling_data_to_be_available()
tj.wait_for_framework_profiling_data_to_be_available()
```
**Pour créer des objets de lecteur de système et de framework une fois que les données de métriques sont disponibles**
```
system_metrics_reader = tj.get_systems_metrics_reader()
framework_metrics_reader = tj.get_framework_metrics_reader()
```
**Pour actualiser et récupérer les derniers fichiers d'événements d'entraînement**
Les objets du lecteur ont une méthode étendue, `refresh_event_file_list()`, afin de récupérer les fichiers les plus récents des événements d'entraînement.
```
system_metrics_reader.refresh_event_file_list()
framework_metrics_reader.refresh_event_file_list()
```
# Tracé des données des métriques système et de framework
Vous pouvez utiliser les objets de mesure système et d'algorithme pour les classes de visualisation suivantes afin de tracer des graphiques de chronologie et des histogrammes.
**Note**
Pour visualiser les données avec des métriques restreintes dans les méthodes de traçage d'objet de visualisation suivantes, spécifiez les paramètres `select_dimensions` et `select_events`. Par exemple, si vous spécifiez `select_dimensions=["GPU"]`, les méthodes de tracé filtrent les métriques qui incluent le mot-clé « GPU ». Si vous spécifiez `select_events=["total"]`, les méthodes de tracé filtrent les métriques qui incluent les identifications d'événement « total » à la fin des noms de métriques. Si vous activez ces paramètres et indiquez les chaînes de mots-clés, les classes de visualisation renvoient les graphiques avec des métriques filtrées.
+ La classe `MetricsHistogram`
```
from smdebug.profiler.analysis.notebook_utils.metrics_histogram import MetricsHistogram
metrics_histogram = MetricsHistogram(system_metrics_reader)
metrics_histogram.plot(
starttime=0,
endtime=system_metrics_reader.get_timestamp_of_latest_available_file(),
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"] # optional
)
```
+ La classe `StepTimelineChart`
```
from smdebug.profiler.analysis.notebook_utils.step_timeline_chart import StepTimelineChart
view_step_timeline_chart = StepTimelineChart(framework_metrics_reader)
```
+ La classe `StepHistogram`
```
from smdebug.profiler.analysis.notebook_utils.step_histogram import StepHistogram
step_histogram = StepHistogram(framework_metrics_reader)
step_histogram.plot(
starttime=step_histogram.last_timestamp - 5 * 1000 * 1000,
endtime=step_histogram.last_timestamp,
show_workers=True
)
```
+ La classe `TimelineCharts`
```
from smdebug.profiler.analysis.notebook_utils.timeline_charts import TimelineCharts
view_timeline_charts = TimelineCharts(
system_metrics_reader,
framework_metrics_reader,
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"] # optional
)
view_timeline_charts.plot_detailed_profiler_data([700,710])
```
+ La classe `Heatmap`
```
from smdebug.profiler.analysis.notebook_utils.heatmap import Heatmap
view_heatmap = Heatmap(
system_metrics_reader,
framework_metrics_reader,
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"], # optional
plot_height=450
)
```
# Accès aux données de profilage à l'aide de l'outil d'analyse de données Pandas
La classe `PandasFrame` suivante fournit des outils pour convertir les données de profilage collectées en cadre de données Pandas.
```
from smdebug.profiler.analysis.utils.profiler_data_to_pandas import PandasFrame
```
La classe `PandasFrame` prend le chemin de sortie du compartiment S3 de l'objet `tj`, et ses méthodes `get_all_system_metrics()` `get_all_framework_metrics()` renvoient les métriques système et les métriques de cadre au format de données Pandas.
```
pf = PandasFrame(tj.profiler_s3_output_path)
system_metrics_df = pf.get_all_system_metrics()
framework_metrics_df = pf.get_all_framework_metrics(
selected_framework_metrics=[
'Step:ModeKeys.TRAIN',
'Step:ModeKeys.GLOBAL'
]
)
```
# Accès aux données de statistiques de profilage Python
Le profilage Python fournit des métriques de framework relatives aux fonctions et aux opérateurs Python dans vos scripts d'entraînement et dans les frameworks d'apprentissage en profondeur de l' SageMaker IA.
**Modes et phases d'entraînement pour le profilage Python**
Afin de profiler des intervalles spécifiques au cours de l'entraînement pour partitionner les statistiques pour chacun de ces intervalles, Debugger fournit des outils permettant de définir les modes et les phases.
Pour les modes d'entraînement, vous utilisez la classe `PythonProfileModes` suivante :
```
from smdebug.profiler.python_profile_utils import PythonProfileModes
```
Cette classe fournit les options suivantes :
+ `PythonProfileModes.TRAIN` : utilisez cette option si vous souhaitez profiler les étapes cible de la phase d'entraînement. Cette option de mode n'est disponible que pour TensorFlow.
+ `PythonProfileModes.EVAL` : utilisez cette option si vous souhaitez profiler les étapes cible de la phase d'évaluation. Cette option de mode n'est disponible que pour TensorFlow.
+ `PythonProfileModes.PREDICT` : utilisez cette option si vous souhaitez profiler les étapes cible de la phase de prédiction. Cette option de mode n'est disponible que pour TensorFlow.
+ `PythonProfileModes.GLOBAL` : utilisez cette option si vous souhaitez profiler les étapes cible de la phase globale, qui comprend les trois phases précédentes. Cette option de mode n'est disponible que pour PyTorch.
+ `PythonProfileModes.PRE_STEP_ZERO` : utilisez cette option si vous souhaitez profiler les étapes cible de l'étape d'initialisation avant le début de la première étape d'entraînement de la première époque. Cette phase comprend la soumission de la tâche, le chargement des scripts d'entraînement vers les instances EC2, la préparation des instances EC2 et le téléchargement des données d'entrée. Cette option de mode est disponible à la fois pour TensorFlow et PyTorch.
+ `PythonProfileModes.POST_HOOK_CLOSE` : utilisez cette option si vous souhaitez profiler les étapes cible de l'étape de finalisation une fois la tâche d'entraînement terminée et le hook Debugger fermé. Cette phase comprend le profilage des données lorsque les tâches d'entraînement sont finalisées et terminées. Cette option de mode est disponible à la fois pour TensorFlow et PyTorch.
Pour les phases d'entraînement, utilisez la classe `StepPhase` suivante :
```
from smdebug.profiler.analysis.utils.python_profile_analysis_utils import StepPhase
```
Cette classe fournit les options suivantes :
+ `StepPhase.START` : permet de spécifier le point de départ de la phase d'initialisation.
+ `StepPhase.STEP_START` : permet de spécifier l'étape de début de la phase d'entraînement.
+ `StepPhase.FORWARD_PASS_END` : permet de spécifier les étapes où se termine la transmission vers l'avant. Cette option n'est disponible que pour PyTorch.
+ `StepPhase.STEP_END` : permet de spécifier les étapes finales de la phase d'entraînement. Cette option n'est disponible que pour TensorFlow.
+ `StepPhase.END`— À utiliser pour spécifier le point final de la phase de finalisation (post-hook-close). Si le hook de rappel n'est pas fermé, le profilage de la phase de finalisation ne se produit pas.
**Outils d'analyse de profilage Python**
Debugger prend en charge le profilage Python avec deux outils de profilage :
+ cProfile : profileur python standard. cProfile collecte les métriques de cadre sur le temps CPU pour chaque fonction appelée lorsque le profilage a été activé.
+ Pyinstrument : profileur Python sans frais généraux importants, qui échantillonne les événements de profilage toutes les millisecondes.
Pour en savoir plus sur les options de profilage Python et sur ce qui est collecté, consultez [Surveillance système par défaut et profilage de cadre personnalisé avec différentes options de profilage](debugger-configure-framework-profiling-options.md).
Les méthodes suivantes des classes `PythonProfileAnalysis`, `cProfileAnalysis` et `PyinstrumentAnalysis` sont fournies pour extraire et analyser les données de profilage Python. Chaque fonction charge les données les plus récentes depuis l'URI S3 par défaut.
```
from smdebug.profiler.analysis.python_profile_analysis import PythonProfileAnalysis, cProfileAnalysis, PyinstrumentAnalysis
```
Pour définir des objets de profilage Python à des fins d'analyse, utilisez les PyinstrumentAnalysis classes cProfileAnalysis or comme indiqué dans l'exemple de code suivant. Celui-ci montre comment définir un objet `cProfileAnalysis`. Si vous voulez utiliser `PyinstrumentAnalysis`, remplacez le nom de la classe.
```
python_analysis = cProfileAnalysis(
local_profile_dir=tf_python_stats_dir,
s3_path=tj.profiler_s3_output_path
)
```
Les méthodes suivantes sont disponibles pour les classes `cProfileAnalysis` et `PyinstrumentAnalysis`pour récupérer les données de statistiques de profilage Python :
+ `python_analysis.fetch_python_profile_stats_by_time(start_time_since_epoch_in_secs, end_time_since_epoch_in_secs)` : prend une heure de début et une heure de fin, et renvoie les statistiques de fonction des statistiques d'étape dont les heures de début ou de fin se chevauchent avec l'intervalle fourni.
+ `python_analysis.fetch_python_profile_stats_by_step(start_step, end_step, mode, start_phase, end_phase)` : prend une étape de départ et une étape de fin et renvoie les statistiques de fonction de toutes les statistiques d'étape dont l'étape `step` profilée correspond à `start_step <= step < end_step`.
+ `start_step` et `end_step` (str) : spécifiez l'étape de début et l'étape de fin pour récupérer les données de statistiques de profilage Python.
+ `mode` (str) : spécifiez le mode de la tâche d'entraînement à l'aide de la classe d'énumérateur `PythonProfileModes`. La valeur par défaut est `PythonProfileModes.TRAIN`. Les options disponibles sont fournies dans la section [Modes et phases d'entraînement pour le profilage Python](#debugger-access-data-python-profiling-modes).
+ `start_phase` (str) : spécifiez la phase de démarrage dans la ou les étape(s) cible à l'aide de la classe d'énumérateur `StepPhase`. Ce paramètre permet le profilage entre différentes phases de l'entraînement. La valeur par défaut est `StepPhase.STEP_START`. Les options disponibles sont fournies dans la section [Modes et phases d'entraînement pour le profilage Python](#debugger-access-data-python-profiling-phases).
+ `end_phase` (str) : spécifiez la phase de fin dans la ou les étape(s) cible à l'aide de la classe d'énumérateur `StepPhase`. Ce paramètre définit la phase finale de l'entraînement. Les options disponibles sont les mêmes que celles du paramètre `start_phase`. La valeur par défaut est `StepPhase.STEP_END`. Les options disponibles sont fournies dans la section [Modes et phases d'entraînement pour le profilage Python](#debugger-access-data-python-profiling-phases).
+ `python_analysis.fetch_profile_stats_between_modes(start_mode, end_mode)` : extrait les statistiques de profilage Python entre les modes de début et de fin.
+ `python_analysis.fetch_pre_step_zero_profile_stats()` : extrait les statistiques de profilage Python jusqu'à l'étape 0.
+ `python_analysis.fetch_post_hook_close_profile_stats()` : extrait les statistiques de profilage Python une fois le hook fermé.
+ `python_analysis.list_profile_stats()`— Renvoie une DataFrame des statistiques de profilage de Python. Chaque ligne contient les métadonnées de chaque instance de profilage et le fichier de statistiques correspondant (un par étape).
+ `python_analysis.list_available_node_ids()`— Renvoie une liste des nœuds disponibles IDs pour les statistiques de profilage Python.
Les méthodes spécifiques à la classe `cProfileAnalysis` :
+ `fetch_profile_stats_by_training_phase()` : extrait et agrège les statistiques de profilage Python pour chaque combinaison possible de modes de début et de fin. Par exemple, si un entraînement et des phases de validation sont effectués alors que le profilage détaillé est activé, les combinaisons sont `(PRE_STEP_ZERO, TRAIN)`, `(TRAIN, TRAIN)`, `(TRAIN, EVAL)`, `(EVAL, EVAL)` et `(EVAL, POST_HOOK_CLOSE)`. Tous les fichiers de statistiques de chacune de ces combinaisons sont agrégés.
+ `fetch_profile_stats_by_job_phase()` : extrait et agrège les statistiques de profilage Python par phase de tâche. Les phases de tâche sont `initialization` (profilage jusqu'à l'étape 0), `training_loop`(entraînement et validation) et `finalization` (profilage une fois le hook fermé).
# Fusion des chronologies de plusieurs fichiers de trace de profil
La bibliothèque SMDebug cliente fournit des outils d'analyse et de visualisation du profilage pour fusionner les chronologies des métriques du système, des métriques du framework et des données de profilage Python collectées par Debugger.
**Astuce**
Avant de continuer, vous devez définir un TrainingJob objet qui sera utilisé dans les exemples de cette page. Pour plus d'informations sur la configuration d'un TrainingJob objet, consultez[Accès aux données du profil](debugger-analyze-data-profiling.md).
La classe `MergedTimeline` fournit des outils permettant d'intégrer et de mettre en corrélation différentes informations de profilage dans une seule chronologie. Après que Debugger capture les données de profilage et les annotations de différentes phases d'une tâche d'entraînement, les fichiers JSON des événements de suivi sont enregistrés dans un répertoire `tracefolder` par défaut.
+ Pour les annotations dans les couches Python, les fichiers de suivi sont enregistrés dans `*pythontimeline.json`.
+ Pour les annotations dans les couches TensorFlow C\$1\$1, les fichiers de trace sont enregistrés dans`*model_timeline.json`.
+ Le profileur Tensorflow enregistre les événements dans un fichier `*trace.json.gz`.
**Astuce**
Si vous souhaitez répertorier tous les fichiers de suivi JSON, utilisez la commande AWS CLI suivante :
```
! aws s3 ls {tj.profiler_s3_output_path} --recursive | grep '\.json$'
```
Comme le montre la capture d'écran animée suivante, placer et aligner les événements de suivi capturés à partir des différentes sources de profilage dans un seul graphique peut fournir un aperçu de l'ensemble des événements se produisant dans les différentes phases de la tâche d'entraînement.
![\[Exemple de chronologie fusionnée\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-merged-timeline.gif)
**Astuce**
Pour interagir avec la chronologie fusionnée de l'appli de suivi à l'aide d'un clavier, utilisez la touche `W` pour zoomer, la touche `A` pour aller vers la gauche, la touche `S` pour dézoomer et la touche `D` pour aller vers la droite.
Les fichiers JSON de suivi d'événements multiples peuvent être fusionnés dans un fichier JSON d'événement de suivi à l'aide de l'opération d'API `MergedTimeline` suivante et de la méthode de classe du module `smdebug.profiler.analysis.utils.merge_timelines`.
```
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
combined_timeline = MergedTimeline(path, file_suffix_filter, output_directory)
combined_timeline.merge_timeline(start, end, unit)
```
L'opération d'API `MergedTimeline` transmet les paramètres suivants :
+ `path` (str) : spécifie un dossier racine (`/profiler-output`) qui contient des fichiers de suivi de profilage système et de cadre. Vous pouvez les localiser à l'`profiler-output`aide de la méthode de classe SageMaker AI estimator ou de l'objet. TrainingJob Par exemple, `estimator.latest_job_profiler_artifacts_path()` ou `tj.profiler_s3_output_path`.
+ `file_suffix_filter` (liste) : spécifiez une liste de filtres de suffixe de fichier pour fusionner les chronologies. Les filtres de suffixe disponibles sont `["model_timeline.json", "pythontimeline.json", "trace.json.gz"].` Si ce paramètre n'est pas spécifié manuellement, tous les fichiers de suivi sont fusionnés par défaut.
+ `output_directory` (str) : spécifiez un chemin d'accès pour enregistrer le fichier JSON de chronologie fusionné. La valeur par défaut est le répertoire spécifié pour le paramètre `path`.
La méthode de classe `merge_timeline()` transmet les paramètres suivants pour exécuter le processus de fusion :
+ `start` (ent) : spécifiez l'heure de début (en microsecondes et au format Unix) ou l'étape de démarrage pour fusionner les chronologies.
+ `end` (ent) : spécifiez l'heure de fin (en microsecondes et au format Unix) ou l'étape de fin pour fusionner les chronologies.
+ `unit` (str) : choisissez entre `"time"` et `"step"`. La valeur par défaut est `"time"`.
À l'aide des exemples de codes suivants, exécutez la méthode `merge_timeline()` et téléchargez le fichier JSON fusionné.
+ Fusionnez la chronologie avec l'option d'unité `"time"`. L'exemple de code suivant fusionne tous les fichiers de suivi disponibles entre l'heure de début Unix (heure Unix absolue zéro) et l'heure Unix actuelle, ce qui signifie que vous pouvez fusionner les chronologies pour toute la durée de l'entraînement.
```
import time
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
from smdebug.profiler.profiler_constants import CONVERT_TO_MICROSECS
combined_timeline = MergedTimeline(tj.profiler_s3_output_path, output_directory="./")
combined_timeline.merge_timeline(0, int(time.time() * CONVERT_TO_MICROSECS))
```
+ Fusionnez la chronologie avec l'option d'unité `"step"`. L'exemple de code suivant fusionne toutes les chronologies disponibles entre l'étape 3 et l'étape 9.
```
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
combined_timeline = MergedTimeline(tj.profiler_s3_output_path, output_directory="./")
combined_timeline.merge_timeline(3, 9, unit="step")
```
Ouvrez l'appli de suivi Chrome à l'adresse `chrome://tracing` sur un navigateur Chrome et ouvrez le fichier JSON. Vous pouvez explorer la sortie pour tracer la chronologie fusionnée.
# Profilage des chargeurs de données
Dans PyTorch, les itérateurs du chargeur de données, tels que `SingleProcessingDataLoaderIter` et`MultiProcessingDataLoaderIter`, sont lancés au début de chaque itération sur un ensemble de données. Pendant la phase d'initialisation, PyTorch active les processus de travail en fonction du nombre de travailleurs configuré, établit une file d'attente de données pour récupérer les données et `pin_memory` les threads.
Pour utiliser l'outil d'analyse de profilage du chargeur de PyTorch données, importez la `PT_dataloader_analysis` classe suivante :
```
from smdebug.profiler.analysis.utils.pytorch_dataloader_analysis import PT_dataloader_analysis
```
Transmettez les données de profilage récupérées en tant qu'objet de données de cadre Pandas dans la section [Accès aux données de profilage à l'aide de l'outil d'analyse de données Pandas](debugger-access-data-profiling-pandas-frame.md) :
```
pt_analysis = PT_dataloader_analysis(pf)
```
Les fonctions suivantes peuvent être utilisées pour l'objet `pt_analysis` :
La SMDebug `S3SystemMetricsReader` classe lit les métriques du système à partir du compartiment S3 spécifié dans le `s3_trial_path` paramètre.
+ `pt_analysis.analyze_dataloaderIter_initialization()`
L'analyse génère la durée médiane et maximale de ces initialisations. En cas de valeurs aberrantes (c'est-à-dire que la durée est supérieure à 2 fois la valeur médiane), la fonction affiche les heures de début et de fin pour ces durées. Celles-ci peuvent être utilisées pour inspecter les métriques système pendant ces intervalles de temps.
La liste suivante indique l'analyse disponible à partir de cette méthode de classe :
+ Type d'itérateurs de chargeur de données initialisés.
+ Nombre de composants par itérateur.
+ Vérifiez si l'itérateur a été initialisé avec ou sans pin\$1memory.
+ Nombre de fois où les itérateurs ont été initialisés pendant l'entraînement.
+ `pt_analysis.analyze_dataloaderWorkers()`
La liste suivante indique l'analyse disponible à partir de cette méthode de classe :
+ Nombre de processus de composant qui ont été détachés pendant toute la durée de l'entraînement.
+ Durée médiane et maximale pour les processus de composant.
+ Heure de début et de fin pour les processus de composant qui sont des anomalies.
+ `pt_analysis.analyze_dataloader_getnext()`
La liste suivante indique l'analyse disponible à partir de cette méthode de classe :
+ Nombre d' GetNext appels passés pendant la formation.
+ Durée médiane et maximale en microsecondes pour les GetNext appels.
+ Heure de début, heure de fin, durée et identifiant du travailleur pour la durée exceptionnelle de l' GetNextappel.
+ `pt_analysis.analyze_batchtime(start_timestamp, end_timestamp, select_events=[".*"], select_dimensions=[".*"])`
Debugger collecte les heures de début et de fin de tous les GetNext appels. Vous pouvez trouver le temps passé par le script d'entraînement sur un lot de données. Dans la fenêtre de la période spécifiée, vous pouvez identifier les appels qui ne contribuent pas directement à l'entraînement. Ces appels peuvent provenir des opérations suivantes : calcul de la précision, ajout des pertes à des fins de débogage ou de journalisation, et impression des informations de débogage. Des opérations comme celles-ci peuvent être exigeantes en calcul ou en temps. Nous pouvons identifier de telles opérations en corrélant le profileur Python, les métriques système et les métriques de cadre.
La liste suivante indique l'analyse disponible à partir de cette méthode de classe :
+ Profilez le temps passé sur chaque lot de données en déterminant la différence entre l'heure de début des appels en cours et celle des GetNext appels suivants. `BatchTime_in_seconds`
+ Recherchez les valeurs aberrantes dans `BatchTime_in_seconds` ainsi que l'heure de début et de fin pour ces valeurs aberrantes.
+ Obtenez les métriques système et de cadre au cours de ces horodatages `BatchTime_in_seconds`. Cela indique à quoi le temps a été consacré.
+ `pt_analysis.plot_the_window()`
Trace un graphique chronologique entre un horodatage de début et l'horodatage de fin.