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.
# Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker
Pour configurer un estimateur SageMaker AI avec SageMaker Debugger, utilisez le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) et spécifiez les paramètres spécifiques au Debugger. Pour utiliser pleinement la fonctionnalité de débogage, vous devez configurer trois paramètres : `debugger_hook_config`, `tensorboard_output_config` et `rules`.
**Important**
Avant de créer et d'exécuter la méthode d'ajustement de l'estimateur pour lancer une tâche d'entraînement, assurez-vous d'adapter votre script d'entraînement en suivant les instructions fournies dans [Adaptation de votre script d’entraînement pour enregistrer un hook](debugger-modify-script.md).
## Construction d'un estimateur d' SageMaker IA avec des paramètres spécifiques au débogueur
Les exemples de code présentés dans cette section montrent comment construire un estimateur d' SageMaker IA avec les paramètres spécifiques au débogueur.
**Note**
Les exemples de code suivants sont des modèles pour construire les estimateurs du framework d' SageMaker IA et ne sont pas directement exécutables. Vous devez passer aux sections suivantes et configurer les paramètres spécifiques à Debugger.
------
#### [ PyTorch ]
```
# An example of constructing a SageMaker AI PyTorch estimator
import boto3
import sagemaker
from sagemaker.pytorch import PyTorch
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
session=boto3.session.Session()
region=session.region_name
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=PyTorch(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.12.0",
py_version="py37",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_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 CollectionConfig, DebuggerHookConfig, Rule, rule_configs
session=boto3.session.Session()
region=session.region_name
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule()),
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=TensorFlow(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_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 CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=MXNet(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.7.0",
py_version="py37",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ XGBoost ]
```
# An example of constructing a SageMaker AI XGBoost estimator
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=XGBoost(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.5-1",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ 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 CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
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
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
Configurez les paramètres suivants pour activer le SageMaker débogueur :
+ `debugger_hook_config`(un objet de [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)) — Nécessaire pour activer le hook dans le script d'entraînement adapté pendant[Adaptation de votre script d’entraînement pour enregistrer un hook](debugger-modify-script.md), configurer le lanceur d' SageMaker entraînement (estimateur) pour collecter les tenseurs de sortie de votre tâche d'entraînement et enregistrer les tenseurs dans votre compartiment S3 sécurisé ou votre machine locale. Pour savoir comment configurer le paramètre `debugger_hook_config`, consultez [Configuration du SageMaker débogueur pour enregistrer les tenseurs](debugger-configure-hook.md).
+ `rules`(une liste d'[https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule)objets) — Configurez ce paramètre pour activer les règles intégrées du SageMaker Debugger que vous souhaitez exécuter en temps réel. Les règles intégrées sont des logiques qui déboguent automatiquement la progression de l'entraînement de votre modèle et détectent les problèmes d'entraînement en analysant les tenseurs de sortie enregistrés dans votre compartiment S3 sécurisé. Pour savoir comment configurer le paramètre `rules`, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md). Pour obtenir la liste complète des règles intégrées de débogage des tenseurs de sortie, consultez [Règle Debugger](debugger-built-in-rules.md#debugger-built-in-rules-Rule). Si vous souhaitez créer votre propre logique pour détecter les problèmes d'entraînement, consultez [Création de règles personnalisées à l’aide de la bibliothèque client Debugger](debugger-custom-rules.md).
**Note**
Les règles intégrées ne sont disponibles que par le biais des instances de SageMaker formation. Vous ne pouvez pas les utiliser en mode local.
+ `tensorboard_output_config`(un objet de [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig)) — Configurez SageMaker Debugger pour collecter les tenseurs de sortie au format TensorBoard compatible et les enregistrer dans le chemin de sortie S3 spécifié dans l'objet. `TensorBoardOutputConfig` Pour en savoir plus, veuillez consulter la section [Visualisez les tenseurs SageMaker de sortie d'Amazon Debugger dans TensorBoard](debugger-enable-tensorboard-summaries.md).
**Note**
L'objet `tensorboard_output_config` doit être configuré avec le paramètre `debugger_hook_config`, ce qui vous oblige également à adapter votre script d'entraînement en ajoutant le hook `sagemaker-debugger`.
**Note**
SageMaker Debugger enregistre en toute sécurité les tenseurs de sortie dans les sous-dossiers de votre compartiment S3. Par exemple, le format de l'URI du compartiment S3 par défaut dans votre compte est `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>///`. Deux sous-dossiers ont été créés par SageMaker Debugger : `debug-output` et. `rule-output` Si vous ajoutez le paramètre `tensorboard_output_config`, vous trouverez également le dossier `tensorboard-output`.
Consultez les rubriques suivantes pour obtenir des exemples supplémentaires sur la façon de configurer les paramètres spécifiques à Debugger.
**Topics**
+ [Construction d'un estimateur d' SageMaker IA avec des paramètres spécifiques au débogueur](#debugger-configuration-structure)
+ [Configuration du SageMaker débogueur pour enregistrer les tenseurs](debugger-configure-hook.md)
+ [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md)
+ [Désactivation de Debugger](debugger-turn-off.md)
+ [Méthodes de classe d'estimateur SageMaker AI utiles pour Debugger](debugger-estimator-classmethods.md)
# Configuration du SageMaker débogueur pour enregistrer les tenseurs
Les *tenseurs* sont des ensembles de données de paramètres mis à jour à partir des étapes aller-retour de chaque itération d'entraînement. SageMaker Debugger collecte les tenseurs de sortie pour analyser l'état d'une tâche de formation. SageMaker Les opérations du débogueur [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)et de [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)l'API fournissent des méthodes pour regrouper les tenseurs en *collections* et les enregistrer dans un compartiment S3 cible. Les rubriques suivantes montrent comment utiliser les opérations `CollectionConfig` et `DebuggerHookConfig` API, et sont suivies d’exemples sur l’utilisation du hook de Debugger pour accéder aux tenseurs de sortie, les visualiser et les enregistrer.
Lors de la construction d'un estimateur SageMaker AI, activez SageMaker Debugger en spécifiant le paramètre. `debugger_hook_config` Les rubriques suivantes incluent des exemples de configuration de `debugger_hook_config` à l’aide des opérations d’API `CollectionConfig` et `DebuggerHookConfig` pour extraire les tenseurs de vos tâches d’entraînement et les enregistrer.
**Note**
Une fois correctement configuré et activé, SageMaker Debugger enregistre les tenseurs de sortie dans un compartiment S3 par défaut, sauf indication contraire. Le format de l'URI du compartiment S3 par défaut est `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>//debug-output/`.
**Topics**
+ [Configurer les collections de tenseurs en utilisant l’API `CollectionConfig`](debugger-configure-tensor-collections.md)
+ [Configuration de l’API `DebuggerHookConfig` pour enregistrer les tenseurs](debugger-configure-tensor-hook.md)
+ [Exemples de blocs-notes et de code pour configurer le hook de Debugger](debugger-save-tensors.md)
# Configurer les collections de tenseurs en utilisant l’API `CollectionConfig`
Utilisez l'opération d'API `CollectionConfig` pour configurer les collections de tenseurs. Debugger fournit des collections de tenseurs précréées qui couvrent une variété d'expressions régulières (regex) de paramètres si vous utilisez des cadres de deep learning et des algorithmes de machine learning pris en charge par Debugger. Comme indiqué dans l'exemple de code suivant, ajoutez les collections de tenseurs intégrées que vous souhaitez déboguer.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(name="weights"),
CollectionConfig(name="gradients")
]
```
Les collections précédentes configurent le hook de Debugger pour enregistrer les tenseurs toutes les 500 étapes en fonction de la valeur `"save_interval"` par défaut.
Pour obtenir la liste complète des collections intégrées de Debugger, consultez [Debugger Built-in Collections](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#collection).
Si vous souhaitez personnaliser les collections intégrées, par exemple en modifiant les intervalles de sauvegarde et l'expression régulière de tenseur, utilisez le modèle `CollectionConfig` suivant pour ajuster les paramètres.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(
name="tensor_collection",
parameters={
"key_1": "value_1",
"key_2": "value_2",
...
"key_n": "value_n"
}
)
]
```
Pour plus d'informations sur les clés de paramètres disponibles, consultez [CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Par exemple, l'exemple de code suivant montre comment ajuster les intervalles de sauvegarde de la collection de tenseurs de « pertes » à différentes phases de l'entraînement : perte de sauvegarde toutes les 100 étapes de la phase d'entraînement et perte de validation toutes les 10 étapes de la phase de validation.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
```
**Astuce**
Cet objet de configuration de collection de tenseurs peut être utilisé à la fois pour [DebuggerHookConfig](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-hook.html#debugger-configure-tensor-hook)les opérations d'API [Rule](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-rules.html#debugger-built-in-rules-configuration-param-change).
# Configuration de l’API `DebuggerHookConfig` pour enregistrer les tenseurs
Utilisez l'[DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html #sagemaker.debugger.DebuggerHookConfig)API pour créer un `debugger_hook_config` objet à l'aide de l'`collection_configs`objet que vous avez créé à l'étape précédente.
```
from sagemaker.debugger import DebuggerHookConfig
debugger_hook_config=DebuggerHookConfig(
collection_configs=collection_configs
)
```
Debugger enregistre les tenseurs de sortie d'entraînement du modèle dans le compartiment S3 par défaut. Le format de l'URI du compartiment S3 par défaut est `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>//debug-output/.`
Si vous souhaitez spécifier un URI de compartiment S3 précis, utilisez l'exemple de code suivant :
```
from sagemaker.debugger import DebuggerHookConfig
debugger_hook_config=DebuggerHookConfig(
s3_output_path="specify-uri"
collection_configs=collection_configs
)
```
Pour plus d'informations, consultez [DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Exemples de blocs-notes et de code pour configurer le hook de Debugger
Les sections suivantes fournissent des exemples de blocs-notes et de code sur l'utilisation du hook de Debugger pour enregistrer, consulter et visualiser les tenseurs de sortie.
**Topics**
+ [Exemples de blocs-notes de visualisation de tenseur](#debugger-tensor-visualization-notebooks)
+ [Enregistrement des tenseurs à l’aide des collections Debugger intégrées](#debugger-save-built-in-collections)
+ [Enregistrement des tenseurs en modifiant les collections intégrées Debugger](#debugger-save-modified-built-in-collections)
+ [Enregistrement des tenseurs à l’aide de collections personnalisées Debugger](#debugger-save-custom-collections)
## Exemples de blocs-notes de visualisation de tenseur
Les deux exemples de blocs-notes suivants illustrent l'utilisation avancée d'Amazon SageMaker Debugger pour visualiser les tenseurs. Debugger offre une vue transparente de l'entraînement des modèles de deep learning.
+ [Analyse tensorielle interactive dans SageMaker Studio Notebook avec MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_analysis)
Cet exemple de bloc-notes montre comment visualiser des tenseurs enregistrés à l'aide d'Amazon SageMaker Debugger. En visualisant les tenseurs, vous pouvez voir comment les valeurs du tenseur changent pendant l'entraînement des algorithmes de deep learning. Ce bloc-notes inclut une tâche de formation avec un réseau neuronal mal configuré et utilise Amazon SageMaker Debugger pour agréger et analyser les tenseurs, notamment les gradients, les sorties d'activation et les poids. Par exemple, le diagramme suivant montre la distribution des gradients d'une couche convolutive qui souffre d'un problème de disparition gradient.
![\[Un graphique illustrant la distribution des dégradés.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-vanishing-gradient.gif)
Ce bloc-notes montre également comment un bon réglage de l'hyperparamètre initial améliore le processus d'entraînement en générant les mêmes diagrammes de distribution du tenseur.
+ [Visualisation et débogage des tenseurs à partir de l'entraînement des modèles MXNet ](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_plot)
Cet exemple de bloc-notes montre comment enregistrer et visualiser des tenseurs issus d'une tâche de formation sur un modèle MXNet Gluon à l'aide d'Amazon SageMaker Debugger. Il montre que Debugger est configuré pour enregistrer tous les tenseurs dans un compartiment Amazon S3 et récupère les résultats ReLu d'activation pour la visualisation. La figure suivante montre une visualisation en trois dimensions des sorties ReLu d'activation. En termes de couleurs, le bleu est défini pour indiquer une valeur proche de 0 et le jaune pour indiquer des valeurs proches de 1.
![\[Une visualisation des sorties d'activation ReLU\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/tensorplot.gif)
Dans ce bloc-notes, la `TensorPlot` classe importée depuis `tensor_plot.py` est conçue pour tracer des réseaux de neurones convolutifs (CNNs) qui prennent des images bidimensionnelles pour les entrées. Le script `tensor_plot.py` fourni avec le bloc-notes récupère les tenseurs en utilisant Debugger et visualise le réseau de neurones convolutif. Vous pouvez exécuter ce bloc-notes sur SageMaker Studio pour reproduire la visualisation du tenseur et implémenter votre propre modèle de réseau neuronal convolutif.
+ [Analyse tensorielle en temps réel dans un SageMaker bloc-notes avec MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_realtime_analysis)
Cet exemple vous explique comment installer les composants requis pour émettre des tenseurs dans le cadre d'une tâche de SageMaker formation Amazon et comment utiliser les opérations de l'API Debugger pour accéder à ces tenseurs pendant la formation. Un modèle de réseau de neurones convolutif gluon est entraîné sur le jeu de données Fashion MNIST. Pendant que la tâche est en cours d'exécution, vous verrez comment Debugger récupère les sorties d'activation de la première couche convolutive de chacun des 100 lots et comment il les visualise. Vous découvrirez également comment visualiser les pondérations une fois la tâche terminée.
## Enregistrement des tenseurs à l’aide des collections Debugger intégrées
Vous pouvez utiliser des collections intégrées de tenseurs à l'aide de la commande `CollectionConfig` et les enregistrer à l'aide de l'API `DebuggerHookConfig`. L'exemple suivant montre comment utiliser les paramètres par défaut des configurations de hook Debugger pour créer un estimateur SageMaker AI TensorFlow . Vous pouvez également l'utiliser pour MXNet PyTorch, et les XGBoost estimateurs.
**Note**
Dans l'exemple de code suivant, le paramètre `s3_output_path` pour `DebuggerHookConfig` est facultatif. Si vous ne le spécifiez pas, Debugger enregistre les tenseurs`s3:///debug-output/`, où il s'``agit du chemin de sortie par défaut des tâches d' SageMaker entraînement. Par exemple :
```
"s3://sagemaker-us-east-1-111122223333/sagemaker-debugger-training-YYYY-MM-DD-HH-MM-SS-123/debug-output"
```
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to call built-in collections
collection_configs=[
CollectionConfig(name="weights"),
CollectionConfig(name="gradients"),
CollectionConfig(name="losses"),
CollectionConfig(name="biases")
]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-built-in-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Pour afficher la liste des collections intégrées de Debugger, consultez [Debugger Built-in Collections](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#collection).
## Enregistrement des tenseurs en modifiant les collections intégrées Debugger
Vous pouvez modifier les collections intégrées de Debugger à l'aide de l'opération d'API `CollectionConfig`. L'exemple suivant montre comment modifier la `losses` collection intégrée et créer un TensorFlow estimateur d' SageMaker IA. Vous pouvez également l'utiliser pour MXNet PyTorch, et les XGBoost estimateurs.
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to call and modify built-in collections
collection_configs=[
CollectionConfig(
name="losses",
parameters={"save_interval": "50"})]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-modified-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Pour une liste complète des `CollectionConfig` paramètres, consultez l'API [Debugger CollectionConfig ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
## Enregistrement des tenseurs à l’aide de collections personnalisées Debugger
Vous pouvez également enregistrer un nombre réduit de tenseurs au lieu de la totalité des tenseurs (par exemple, si vous souhaitez réduire la quantité de données enregistrées dans votre compartiment Amazon S3). L'exemple suivant montre comment personnaliser la configuration du hook de Debugger pour spécifier les tenseurs cible à enregistrer. Vous pouvez l'utiliser pour TensorFlow, MXNet PyTorch, et les XGBoost estimateurs.
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to create a custom collection
collection_configs=[
CollectionConfig(
name="custom_activations_collection",
parameters={
"include_regex": "relu|tanh", # Required
"reductions": "mean,variance,max,abs_mean,abs_variance,abs_max"
})
]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-custom-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Pour une liste complète des `CollectionConfig` paramètres, voir [Debugger CollectionConfig](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
# Configuration des règles intégrées Debugger
Dans les rubriques suivantes, vous allez apprendre à utiliser les règles intégrées du SageMaker Debugger. Les règles intégrées d'Amazon SageMaker Debugger analysent les tenseurs émis lors de l'entraînement d'un modèle. SageMaker AI Debugger propose le fonctionnement de l'`Rule`API qui surveille la progression des tâches d'entraînement et les erreurs afin de garantir le succès de l'entraînement de votre modèle. Par exemple, les règles peuvent détecter si les gradients deviennent trop grands ou trop petits, si un modèle est surajusté ou surentraîné et si une tâche d'entraînement ne diminue pas la fonction de perte et ne s'améliore pas. Pour afficher la liste complète des règles intégrées disponibles, consultez [Liste des règles intégrées à Debugger](debugger-built-in-rules.md).
**Topics**
+ [Utilisation des règles intégrées Debugger avec les paramètres par défaut](debugger-built-in-rules-configuration.md)
+ [Utilisation des règles intégrées Debugger avec des valeurs de paramètres personnalisées](debugger-built-in-rules-configuration-param-change.md)
+ [Exemples de blocs-notes et de code pour configurer les règles Debugger](debugger-built-in-rules-example.md)
# Utilisation des règles intégrées Debugger avec les paramètres par défaut
Pour spécifier des règles intégrées de Debugger dans un estimateur, vous devez configurer un objet de liste . L'exemple de code suivant présente la structure de base permettant de répertorier les règles intégrées de Debugger :
```
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.built_in_rule_name_1()),
Rule.sagemaker(rule_configs.built_in_rule_name_2()),
...
Rule.sagemaker(rule_configs.built_in_rule_name_n()),
... # You can also append more profiler rules in the ProfilerRule.sagemaker(rule_configs.*()) format.
]
```
Pour plus d’informations sur les valeurs de paramètres par défaut et les descriptions de la règle intégrée, consultez [Liste des règles intégrées à Debugger](debugger-built-in-rules.md).
Pour trouver la référence de l'API SageMaker Debugger, reportez-vous [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.sagemaker.debugger.rule_configs](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.sagemaker.debugger.rule_configs)aux sections et. [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule)
Par exemple, pour inspecter les performances d'entraînement globales et la progression de votre modèle, créez un estimateur d' SageMaker IA avec la configuration de règles intégrée suivante.
```
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.loss_not_decreasing()),
Rule.sagemaker(rule_configs.overfit()),
Rule.sagemaker(rule_configs.overtraining()),
Rule.sagemaker(rule_configs.stalled_training_rule())
]
```
Lorsque vous démarrez la tâche d'entraînement, Debugger collecte les données d'utilisation des ressources système toutes les 500 millisecondes et les valeurs de perte et de précision toutes les 500 étapes par défaut. Debugger analyse l'utilisation des ressources pour identifier si votre modèle rencontre des problèmes de goulet d'étranglement. `loss_not_decreasing`, `overfit`, `overtraining` et`stalled_training_rule` contrôlent si votre modèle optimise la fonction de perte sans ces problèmes d'entraînement. 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 intégrées Debugger avec des valeurs de paramètres 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`. Vous trouverez des instructions sur l'utilisation de la classe `CollectionConfig` dans la section [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 pour le déclenchement.
+ 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 intégrées à Debugger](debugger-built-in-rules.md).
+ L'argument `collections_to_save` prend une configuration de tenseur via l'API `CollectionConfig`, qui nécessite les arguments `name` et `parameters`.
+ Pour voir les collections de tenseurs disponibles pour `name`, consultez [Debugger Built-in Tensor Collections](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections).
+ Pour une liste complète des options ajustables`parameters`, consultez l'API [Debugger CollectionConfig ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
[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=[
Rule.sagemaker(
base_config=rule_configs.built_in_rule_name(),
rule_parameters={
"key": "value"
},
collections_to_save=[
CollectionConfig(
name="tensor_collection_name",
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 intégrées à Debugger](debugger-built-in-rules.md).
# Exemples de blocs-notes et de code pour configurer les règles Debugger
Dans les sections suivantes, des blocs-notes et des exemples de code expliquant comment utiliser les règles du Debugger pour surveiller les tâches de SageMaker formation sont fournis.
**Topics**
+ [Exemples de blocs-notes de règles intégrées Debugger](#debugger-built-in-rules-notebook-example)
+ [Exemple de code pour les règles intégrées Debugger](#debugger-deploy-built-in-rules)
+ [Utilisation des règles intégrées Debugger avec modifications des paramètres](#debugger-deploy-modified-built-in-rules)
## Exemples de blocs-notes de règles intégrées Debugger
Les exemples de blocs-notes suivants montrent comment utiliser les règles intégrées du Debugger lors de l'exécution de tâches de formation avec Amazon AI : SageMaker
+ [Utilisation d'une règle intégrée du SageMaker Debugger avec TensorFlow](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_builtin_rule)
+ [Utilisation d'une règle intégrée au SageMaker débogueur avec Managed Spot Training et MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_spot_training)
+ [Utilisation d'une règle intégrée au SageMaker débogueur avec modifications de paramètres pour une analyse des tâches de formation en temps réel avec XGBoost](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/xgboost_realtime_analysis)
Lorsque vous exécutez les exemples de blocs-notes dans SageMaker Studio, vous pouvez trouver la version d'essai des tâches de formation créée dans l'onglet **Studio Experiment List**. Par exemple, comme illustré dans la capture d'écran suivante, vous pouvez rechercher et ouvrir une fenêtre **Describe Trial Component (Décrire le composant d'essai)** de votre tâche d'entraînement actuelle. Sous l'onglet Debugger, vous pouvez vérifier si les règles de Debugger, `vanishing_gradient()` et `loss_not_decreasing()`, contrôlent la séance de formation en parallèle. Pour obtenir des instructions complètes sur la façon de trouver les composants d'essai de votre projet de formation dans l'interface utilisateur de Studio, voir [SageMaker Studio - Afficher les tests, les essais et les composants d'essai](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-tasks.html#studio-tasks-experiments).
![\[Image de l'exécution d'une tâche de formation avec les règles intégrées du Debugger activées dans Studio SageMaker\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-built-in-rule-studio.png)
Il existe deux manières d'utiliser les règles intégrées du Debugger dans l'environnement d' SageMaker IA : déployez les règles intégrées au fur et à mesure de leur préparation ou ajustez leurs paramètres comme vous le souhaitez. Les rubriques suivantes vous montrent comment utiliser les règles intégrées avec des exemples de codes.
## Exemple de code pour les règles intégrées Debugger
L'exemple de code ci-après illustre comment configurer une règle intégrée Debugger à l'aide de la méthode `Rule.sagemaker`. Pour spécifier les règles intégrées que vous souhaitez exécuter, utilisez l'opération d'API `rules_configs` permettant d'appeler les règles intégrées. Pour obtenir la liste complète des règles intégrées et des valeurs de paramètres par défaut de Debugger, consultez [Liste des règles intégrées à Debugger](debugger-built-in-rules.md).
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import Rule, CollectionConfig, rule_configs
# call built-in rules that you want to use.
built_in_rules=[
Rule.sagemaker(rule_configs.vanishing_gradient())
Rule.sagemaker(rule_configs.loss_not_decreasing())
]
# construct a SageMaker AI estimator with the Debugger built-in rules
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-built-in-rules-demo',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific arguments below
rules=built_in_rules
)
sagemaker_estimator.fit()
```
**Note**
Les règles intégrées de Debugger s'exécutent en parallèle avec votre tâche d'entraînement. Le nombre maximal de conteneurs de règles intégrées pour une tâche d'entraînement est de 20.
[Pour plus d'informations sur la classe de règles, les méthodes et les paramètres du Debugger, consultez la classe [SageMaker Debugger Rule dans le SDK](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html) Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
Pour trouver un exemple d'ajustement des paramètres de règles Debugger, consultez la section [Utilisation des règles intégrées Debugger avec modifications des paramètres](#debugger-deploy-modified-built-in-rules) suivante.
## Utilisation des règles intégrées Debugger avec modifications des paramètres
L'exemple de code suivant présente la structure des règles intégrées permettant d'ajuster les paramètres. Dans cet exemple, la règle `stalled_training_rule` collecte la collection de tenseurs `losses` à partir d'une tâche d'entraînement toutes les 50 étapes et d'une étape d'évaluation toutes les 10 étapes. Si le processus d'entraînement commence à ralentir et ne collecte pas de sorties tenseurs pendant 120 secondes, la règle `stalled_training_rule` arrête la tâche d'entraînement.
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import Rule, CollectionConfig, rule_configs
# call the built-in rules and modify the CollectionConfig parameters
base_job_name_prefix= 'smdebug-stalled-demo-' + str(int(time.time()))
built_in_rules_modified=[
Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
'threshold': '120',
'training_job_name_prefix': base_job_name_prefix,
'stop_training_on_fire' : 'True'
}
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "50"
"eval.save_interval": "10"
}
)
]
)
]
# construct a SageMaker AI estimator with the modified Debugger built-in rule
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name=base_job_name_prefix,
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific arguments below
rules=built_in_rules_modified
)
sagemaker_estimator.fit()
```
Pour une configuration avancée 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).
# 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 arrêter à la fois la surveillance et 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 arrêter 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)
# Méthodes de classe d'estimateur SageMaker AI utiles pour Debugger
Les méthodes de classe d'estimateur suivantes sont utiles pour accéder aux informations relatives à votre tâche de SageMaker formation et récupérer les chemins de sortie des données de formation collectées par Debugger. Les méthodes suivantes sont exécutables après avoir lancé une tâche d'entraînement avec la méthode `estimator.fit()`.
+ Pour vérifier l'URI du compartiment S3 de base d'une tâche de SageMaker formation, procédez comme suit :
```
estimator.output_path
```
+ Pour vérifier le nom de la tâche de base d'une tâche de SageMaker formation :
```
estimator.latest_training_job.job_name
```
+ Pour voir la configuration complète du fonctionnement de `CreateTrainingJob` l'API d'une tâche de SageMaker formation, procédez comme suit :
```
estimator.latest_training_job.describe()
```
+ Pour consulter la liste complète des règles du Debugger pendant l'exécution d'une tâche de SageMaker formation, procédez comme suit :
```
estimator.latest_training_job.rule_job_summary()
```
+ Pour vérifier l'URI du compartiment S3 où les données des paramètres de modèle (tenseurs de sortie) sont enregistrées :
```
estimator.latest_job_debugger_artifacts_path()
```
+ Pour vérifier l'URI du compartiment S3 où les données de performance du modèle (métriques système et de cadre) sont enregistrées :
```
estimator.latest_job_profiler_artifacts_path()
```
+ Pour vérifier la configuration de règle Debugger pour le débogage des tenseurs de sortie :
```
estimator.debugger_rule_configs
```
+ Pour consulter la liste des règles du Debugger pour le débogage pendant l'exécution d'une tâche de SageMaker formation, procédez comme suit :
```
estimator.debugger_rules
```
+ Pour vérifier la configuration de règle Debugger pour la surveillance et le profilage des métriques système et de cadre :
```
estimator.profiler_rule_configs
```
+ Pour consulter la liste des règles du Debugger relatives à la surveillance et au profilage pendant l'exécution d'une tâche de SageMaker formation :
```
estimator.profiler_rules
```
[Pour plus d'informations sur la classe d'estimateur SageMaker AI et ses méthodes, consultez la section API [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)