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.
# Débogage de tâches de formation à l'aide d'Amazon SageMaker Debugger
Pour préparer votre script d'entraînement et exécuter des tâches d'entraînement avec SageMaker Debugger afin de déboguer la progression de l'entraînement du modèle, vous devez suivre le processus typique en deux étapes : modifier votre script d'entraînement à l'aide du SDK `sagemaker-debugger` Python et créer un SageMaker estimateur d'IA à l'aide du SDK Python. SageMaker Parcourez les rubriques suivantes pour savoir comment utiliser la fonctionnalité de débogage de SageMaker Debugger.
**Topics**
+ [Adaptation de votre script d’entraînement pour enregistrer un hook](debugger-modify-script.md)
+ [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md)
+ [SageMaker Rapport interactif du débogueur pour XGBoost](debugger-report-xgboost.md)
+ [Action sur les règles d'Amazon SageMaker Debugger](debugger-action-on-rules.md)
+ [Visualisez les tenseurs SageMaker de sortie d'Amazon Debugger dans TensorBoard](debugger-enable-tensorboard-summaries.md)
# Adaptation de votre script d’entraînement pour enregistrer un hook
Amazon SageMaker Debugger est fourni avec une bibliothèque cliente appelée SDK [`sagemaker-debugger`Python](https://sagemaker-debugger.readthedocs.io/en/website). Le kit SDK Python pour `sagemaker-debugger` fournit des outils pour adapter votre script d'entraînement avant l'entraînement et des outils d'analyse après entraînement. Sur cette page, vous allez apprendre à adapter votre script d'entraînement à l'aide de la bibliothèque client.
Le kit SDK Python pour `sagemaker-debugger` fournit des fonctions de wrapper qui aident à enregistrer un hook pour extraire les tenseurs du modèle, sans altérer votre script d'entraînement. Pour commencer à collecter les tenseurs de sortie du modèle et à les déboguer pour trouver les problèmes d'entraînement, apportez les modifications suivantes à votre script d'entraînement.
**Astuce**
Pendant que vous suivez cette page, utilisez la [documentation sur le kit SDK open source pour `sagemaker-debugger`](https://sagemaker-debugger.readthedocs.io/en/website/index.html) pour accéder aux références d'API.
**Topics**
+ [Adaptez votre script PyTorch d'entraînement](debugger-modify-script-pytorch.md)
+ [Adaptez votre script TensorFlow d'entraînement](debugger-modify-script-tensorflow.md)
# Adaptez votre script PyTorch d'entraînement
Pour commencer à collecter les tenseurs de sortie du modèle et résoudre les problèmes d'entraînement, apportez les modifications suivantes à votre script d' PyTorch entraînement.
**Note**
SageMaker Le débogueur ne peut pas collecter les tenseurs de sortie du modèle à partir des opérations de l'API [https://pytorch.org/docs/stable/nn.functional.html](https://pytorch.org/docs/stable/nn.functional.html). Lorsque vous rédigez un script de PyTorch formation, il est recommandé d'utiliser les [https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html](https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html)modules à la place.
## Pour PyTorch 1.12.0
Si vous apportez un script d' PyTorch entraînement, vous pouvez exécuter la tâche d'entraînement et extraire les tenseurs de sortie du modèle à l'aide de quelques lignes de code supplémentaires dans votre script d'entraînement. Vous devez utiliser le [hook APIs](https://sagemaker-debugger.readthedocs.io/en/website/hook-api.html) dans la bibliothèque `sagemaker-debugger` cliente. Suivez les instructions suivantes qui décomposent les étapes à l'aide d'exemples de code.
1. Créez un hook.
**(Recommandé) Pour les emplois de formation au sein de l' SageMaker IA**
```
import smdebug.pytorch as smd
hook=smd.get_hook(create_if_not_exists=True)
```
Lorsque vous lancez une tâche de formation [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md) avec l'une des règles ou l' DebuggerHookConfigune des règles de votre estimateur, SageMaker AI ajoute un fichier de configuration JSON à votre instance d'entraînement qui est récupéré par la `get_hook` fonction. TensorBoardConfig Notez que si vous n'incluez aucune configuration APIs dans votre estimateur, il n'y aura aucun fichier de configuration à trouver pour le hook et la fonction retournera. `None`
**(Facultatif) Pour les emplois de formation en dehors de l' SageMaker IA**
Si vous exécutez des tâches de formation en mode local, directement sur des instances SageMaker Notebook, des instances Amazon EC2 ou sur vos propres appareils locaux, utilisez `smd.Hook` class pour créer un hook. Cependant, cette approche ne permet de stocker que les collections de tenseurs et de les utiliser pour la TensorBoard visualisation. SageMaker Les règles intégrées du débogueur ne fonctionnent pas avec le mode local car elles nécessitent des instances d'entraînement SageMaker AI ML et S3 pour stocker les sorties des instances distantes en temps réel. L'API `smd.get_hook` renvoie `None` dans ce cas.
Si vous souhaitez créer un hook manuel pour enregistrer les tenseurs en mode local, utilisez l'extrait de code suivant avec la logique permettant de vérifier si l'API `smd.get_hook` renvoie `None` et créez un hook manuel à l'aide de la classe `smd.Hook`. Notez que vous pouvez spécifier n'importe quel répertoire de sortie sur votre machine locale.
```
import smdebug.pytorch as smd
hook=smd.get_hook(create_if_not_exists=True)
if hook is None:
hook=smd.Hook(
out_dir='/path/to/your/local/output/',
export_tensorboard=True
)
```
1. Enveloppez votre modèle avec les méthodes de classe du hook.
La méthode `hook.register_module()` prend votre modèle et itère sur chaque couche, recherchant tous les tenseurs qui correspondent aux expressions régulières que vous fournirez via la configuration dans [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md). Les tenseurs collectables via cette méthode de hook sont des poids, des biais, des activations, des gradients, des entrées et des sorties.
```
hook.register_module(model)
```
**Astuce**
Si vous collectez l'intégralité des tenseurs de sortie à partir d'un grand modèle de deep learning, la taille totale de ces collections peut augmenter de façon exponentielle et provoquer des goulots d'étranglement. Si vous souhaitez enregistrer des tenseurs spécifiques, vous pouvez également utiliser la méthode `hook.save_tensor()`. Cette méthode vous permet de sélectionner la variable pour le tenseur spécifique et de l'enregistrer dans une collection personnalisée nommée comme vous le souhaitez. Pour plus d'informations, consultez l'[étape 7](#debugger-modify-script-pytorch-save-custom-tensor) de cette instruction.
1. Enveloppez la fonction de perte avec les méthodes de classe du hook.
La méthode `hook.register_loss` consiste à envelopper la fonction de perte. Elle extrait les valeurs de perte à chaque intervalle `save_interval` que vous définirez lors de la configuration dans [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md), et les enregistre dans la collection `"losses"`.
```
hook.register_loss(loss_function)
```
1. Ajoutez `hook.set_mode(ModeKeys.TRAIN)` dans le bloc d'entraînement. Cela indique que la collection de tenseurs est extraite pendant la phase d'entraînement.
```
def train():
...
hook.set_mode(ModeKeys.TRAIN)
```
1. Ajoutez `hook.set_mode(ModeKeys.EVAL)` dans le bloc de validation. Cela indique que la collection de tenseurs est extraite pendant la phase de validation.
```
def validation():
...
hook.set_mode(ModeKeys.EVAL)
```
1. Utilisez [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar) pour enregistrer des scalaires personnalisés. Vous pouvez enregistrer des valeurs scalaires qui ne figurent pas dans votre modèle. Par exemple, si vous souhaitez enregistrer les valeurs de précision calculées lors de l'évaluation, ajoutez la ligne de code suivante sous la ligne où vous calculez la précision.
```
hook.save_scalar("accuracy", accuracy)
```
Notez que vous devez fournir une chaîne comme premier argument pour nommer la collection scalaire personnalisée. Il s'agit du nom qui sera utilisé pour visualiser les valeurs scalaires. Il peut s'agir de TensorBoard n'importe quelle chaîne de votre choix.
1. Utilisez [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_tensor](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_tensor) pour enregistrer des tenseurs personnalisés. Comme pour [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar), vous pouvez enregistrer des tenseurs supplémentaires en définissant votre propre collection de tenseurs. Par exemple, vous pouvez extraire les données d'image d'entrée qui sont transmises au modèle et les enregistrer sous forme de tenseur personnalisé en ajoutant la ligne de code suivante, où `"images"` est un exemple de nom de tenseur personnalisé et `image_inputs` est un exemple de variable pour les données d'image d'entrée.
```
hook.save_tensor("images", image_inputs)
```
Notez que vous devez fournir une chaîne au premier argument pour nommer le tenseur personnalisé. `hook.save_tensor()` contient le troisième argument `collections_to_write` pour spécifier la collection de tenseurs dans laquelle enregistrer le tenseur personnalisé. La valeur par défaut est `collections_to_write="default"`. Si vous ne spécifiez pas explicitement le troisième argument, le tenseur personnalisé est enregistré dans la collection de tenseurs `"default"`.
Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md).
# Adaptez votre script TensorFlow d'entraînement
Pour commencer à collecter les tenseurs de sortie du modèle et résoudre les problèmes d'entraînement, apportez les modifications suivantes à votre script d' TensorFlow entraînement.
**Créez une opportunité pour les emplois de formation dans le domaine de l' SageMaker IA**
```
import smdebug.tensorflow as smd
hook=smd.get_hook(hook_type="keras", create_if_not_exists=True)
```
Cela crée un crochet lorsque vous commencez un travail SageMaker de formation. Lorsque vous lancez une tâche de formation [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md) avec l'un des `DebuggerHookConfig``TensorBoardConfig`, ou `Rules` dans votre estimateur, SageMaker AI ajoute un fichier de configuration JSON à votre instance de formation qui est récupéré par la `smd.get_hook` méthode. Notez que si vous n'incluez aucune configuration APIs dans votre estimateur, il n'y aura aucun fichier de configuration à trouver pour le hook et la fonction retournera. `None`
**(Facultatif) Créez un crochet pour les emplois de formation en dehors de l' SageMaker IA**
Si vous exécutez des tâches de formation en mode local, directement sur des instances SageMaker Notebook, des instances Amazon EC2 ou sur vos propres appareils locaux, utilisez `smd.Hook` class pour créer un hook. Cependant, cette approche ne permet de stocker que les collections de tenseurs et de les utiliser pour la TensorBoard visualisation. SageMaker Les règles intégrées du débogueur ne fonctionnent pas avec le mode local. La méthode `smd.get_hook` renvoie également `None` dans ce cas.
Si vous souhaitez créer un hook manuel, utilisez l'extrait de code suivant avec la logique permettant de vérifier si le hook renvoie `None`, et créez un hook manuel à l'aide de la classe `smd.Hook`.
```
import smdebug.tensorflow as smd
hook=smd.get_hook(hook_type="keras", create_if_not_exists=True)
if hook is None:
hook=smd.KerasHook(
out_dir='/path/to/your/local/output/',
export_tensorboard=True
)
```
Après avoir ajouté le code de création du hook, passez à la rubrique suivante pour TensorFlow Keras.
**Note**
SageMaker Le débogueur ne prend actuellement en charge que TensorFlow Keras.
## Enregistrez le hook dans votre script d'entraînement TensorFlow Keras
La procédure suivante explique comment utiliser le hook et ses méthodes pour collecter des scalaires et des tenseurs de sortie à partir de votre modèle et de votre optimiseur.
1. Enveloppez votre modèle Keras et votre optimiseur avec les méthodes de classe du hook.
La méthode `hook.register_model()` prend votre modèle et itère sur chaque couche, recherchant tous les tenseurs qui correspondent aux expressions régulières que vous fournirez via la configuration dans [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md). Les tenseurs collectables via cette méthode de hook sont des poids, des biais et des activations.
```
model=tf.keras.Model(...)
hook.register_model(model)
```
1. Enveloppez l'optimiseur avec la méthode `hook.wrap_optimizer()`.
```
optimizer=tf.keras.optimizers.Adam(...)
optimizer=hook.wrap_optimizer(optimizer)
```
1. Compilez le modèle en mode rapide dans TensorFlow.
Pour collecter des tenseurs à partir du modèle, tels que les tenseurs d'entrée et de sortie de chaque couche, vous devez exécuter l'entraînement en mode Eager. Sinon, SageMaker AI Debugger ne pourra pas collecter les tenseurs. Cependant, d'autres tenseurs, tels que les poids, les biais et les pertes du modèle, peuvent être collectés sans exécuter explicitement le mode Eager.
```
model.compile(
loss="categorical_crossentropy",
optimizer=optimizer,
metrics=["accuracy"],
# Required for collecting tensors of each layer
run_eagerly=True
)
```
1. Enregistrez le hook avec la méthode [https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit](https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit).
Pour collecter les tenseurs des hooks que vous avez enregistrés, ajoutez `callbacks=[hook]` à la méthode de classe `model.fit()` Keras. Le hook `sagemaker-debugger` sera alors transmis en tant que rappel Keras.
```
model.fit(
X_train, Y_train,
batch_size=batch_size,
epochs=epoch,
validation_data=(X_valid, Y_valid),
shuffle=True,
callbacks=[hook]
)
```
1. TensorFlow 2.x fournit uniquement des variables de gradient symboliques qui ne donnent pas accès à leurs valeurs. Pour collecter des gradients, enveloppez `tf.GradientTape` avec la méthode [https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html#tensorflow-specific-hook-api](https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html#tensorflow-specific-hook-api), ce qui vous oblige à écrire votre propre étape d'entraînement comme suit.
```
def training_step(model, dataset):
with hook.wrap_tape(tf.GradientTape()) as tape:
pred=model(data)
loss_value=loss_fn(labels, pred)
grads=tape.gradient(loss_value, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
```
En enveloppant la bande, le hook `sagemaker-debugger` peut identifier les tenseurs de sortie tels que les gradients, les paramètres et les pertes. L'enroulement de la bande garantit que la `hook.wrap_tape()` méthode utilisée pour définir les fonctions de l'objet de la bande `push_tape()` `pop_tape()``gradient()`, telles que,,, configurera les rédacteurs de SageMaker Debugger et enregistrera les tenseurs fournis en entrée `gradient()` (variables entraînables et pertes) et en sortie (dégradés). `gradient()`
**Note**
Pour collecter avec une boucle d'entraînement personnalisée, assurez-vous d'utiliser le mode Eager. Sinon, SageMaker Debugger n'est pas en mesure de collecter des tenseurs.
Pour une liste complète des actions APIs proposées par le `sagemaker-debugger` hook pour créer des hooks et enregistrer des tenseurs, consultez [Hook Methods](https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html) dans la documentation du *SDK `sagemaker-debugger` Python*.
Une fois que vous avez terminé d'adapter votre scénario d'entraînement, passez à [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md).
# 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)
# SageMaker Rapport interactif du débogueur pour XGBoost
Recevez des rapports d'entraînement générés automatiquement par Debugger. Les rapports Debugger fournissent des informations sur vos tâches d'entraînement et suggèrent des recommandations pour améliorer les performances de votre modèle. Pour les tâches de XGBoost formation liées à l' SageMaker IA, utilisez la [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) règle Debugger pour recevoir un rapport de formation complet sur la progression et les résultats de la formation. En suivant ce guide, spécifiez la [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) règle lors de la création d'un XGBoost estimateur, téléchargez le rapport à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) ou de la console Amazon S3, et obtenez un aperçu des résultats de la formation.
**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 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**
+ [Construisez un XGBoost estimateur SageMaker AI avec la règle XGBoost Debugger Report](debugger-training-xgboost-report-estimator.md)
+ [Téléchargez le rapport de formation du Debugger XGBoost](debugger-training-xgboost-report-download.md)
+ [Présentation du rapport de XGBoost formation du débogueur](debugger-training-xgboost-report-walkthrough.md)
# Construisez un XGBoost estimateur SageMaker AI avec la règle XGBoost Debugger Report
La règle [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) collecte les tenseurs de sortie suivants à partir de votre tâche d'entraînement :
+ `hyperparameters` : enregistre à la première étape.
+ `metrics` : enregistre la perte et la précision toutes les 5 étapes.
+ `feature_importance` : enregistre toutes les 5 étapes.
+ `predictions` : enregistre toutes les 5 étapes.
+ `labels` : enregistre toutes les 5 étapes.
Les tenseurs de sortie sont enregistrés dans un compartiment S3 par défaut. Par exemple, `s3://sagemaker--<12digit_account_id>//debug-output/`.
Lorsque vous créez un estimateur d' SageMaker IA pour un poste de XGBoost formation, spécifiez la règle comme indiqué dans l'exemple de code suivant.
------
#### [ Using the SageMaker AI generic estimator ]
```
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.create_xgboost_report())
]
region = boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.2-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-xgboost-report-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Add the Debugger XGBoost report rule
rules=rules
)
estimator.fit(wait=False)
```
------
# Téléchargez le rapport de formation du Debugger XGBoost
Téléchargez le rapport de XGBoost formation Debugger pendant que votre tâche de formation est en cours ou une fois celle-ci terminée à l'aide du [SDK et ( AWS Command Line Interface CLI) Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
------
#### [ Download using the 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 XGBoost rapport du débogueur 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 des dossiers générés automatiquement et nommés `CreateXgboostReport` et `ProfilerReport-1234567890`. Le rapport de XGBoost formation est stocké dans le`CreateXgboostReport`, et le rapport de profilage est stocké dans le `ProfilerReport-1234567890` dossier. Pour en savoir plus sur le rapport de profilage généré par défaut avec la tâche de XGBoost formation, consultez[SageMaker Rapport interactif du débogueur](debugger-profiling-report.md).
![\[Exemple de sortie de règle.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-ls.png)
`xgboost_report.html`Il s'agit d'un rapport d' XGBoost entraînement généré automatiquement par Debugger. `xgboost_report.ipynb` est un bloc-notes Jupyter utilisé pour regrouper les résultats d'entraînement dans le rapport. Vous pouvez télécharger tous les fichiers, parcourir le fichier de rapport HTML et modifier le rapport à l'aide du bloc-notes.
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 `/CreateXgboostReport`, ouvrez `xgboost_report.html`. Si vous en utilisez JupyterLab, choisissez **Trust HTML** pour voir le rapport de formation généré automatiquement par Debugger.
![\[Exemple de sortie de règle.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-open-trust.png)
1. Ouvrez le fichier `xgboost_report.ipynb` pour voir comment le rapport est généré. Vous pouvez personnaliser et étendre le rapport d'entraînement à l'aide du fichier de bloc-notes Jupyter.
------
#### [ Download using the 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)**.
![\[Champ Find bucket by name (Rechercher des compartiments par nom) dans la console Amazon S3.\]](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 saisissant le préfixe du nom de votre tâche dans **Find objects by prefix (Rechercher des objets par préfixe) **, puis en choisissant le nom de la tâche d'entraînement.
![\[Champ Find objects by prefix (Rechercher des objets par préfixe) dans la console Amazon S3.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-1.png)
1. Dans le compartiment S3 de la tâche d'entraînement, choisissez le sous-dossier **rule-output/**. Celui-ci doit contenir trois sous-dossiers pour les données d'entraînement collectées par Debugger : **debug-output/**, **profiler-output/** et **rule-output/**.
![\[Exemple d'utilisation de l'URI du compartiment S3 de la 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 le dossier /.** CreateXgboostReport** Le dossier contient **xbgoost\$1report.html** (le rapport généré automatiquement en html) et **xbgoost\$1report.ipynb** (un bloc-notes Jupyter avec les scripts utilisés pour générer le rapport).
1. Choisissez le fichier **xbgoost\$1report.html**, puis **Download actions (Télécharger les actions)** et **Download (Télécharger)**.
![\[Exemple d'utilisation de l'URI du compartiment S3 de la sortie de règle.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-s3-download.png)
1. Ouvrez le fichier **xbgoost\$1report.html** téléchargé dans un navigateur web.
------
# Présentation du rapport de XGBoost formation du débogueur
Cette section présente le rapport de XGBoost formation du Debugger. Le rapport est automatiquement agrégé en fonction de l'expression régulière du tenseur de sortie. Il reconnait le type de votre tâche d'entraînement parmi la classification binaire, la classification multiclasse et la régression.
**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**
+ [Distribution des étiquettes True du jeu de données](#debugger-training-xgboost-report-walkthrough-dist-label)
+ [Diagramme Perte contre Étape](#debugger-training-xgboost-report-walkthrough-loss-vs-step)
+ [Importance des caractéristiques](#debugger-training-xgboost-report-walkthrough-feature-importance)
+ [Matrice Confusion](#debugger-training-xgboost-report-walkthrough-confusion-matrix)
+ [Évaluation de la matrice de confusion](#debugger-training-xgboost-report-walkthrough-eval-conf-matrix)
+ [Taux de précision de chaque élément diagonal par rapport à l’itération](#debugger-training-xgboost-report-walkthrough-accuracy-rate)
+ [Courbe caractéristique de fonctionnement du récepteur](#debugger-training-xgboost-report-walkthrough-rec-op-char)
+ [Distribution des résidus à la dernière étape enregistrée](#debugger-training-xgboost-report-walkthrough-dist-residual)
+ [Erreur de validation absolue par groupe d’étiquettes sur itération](#debugger-training-xgboost-report-walkthrough-val-error-per-label-bin)
## Distribution des étiquettes True du jeu de données
Cet histogramme montre la distribution des classes étiquetées (pour la classification) ou des valeurs (pour la régression) dans votre jeu de données d'origine. L'asymétrie de votre jeu de données peut contribuer à des inexactitudes. Cette visualisation est disponible pour les types de modèles suivants : classification binaire, multiclassification et régression.
![\[Exemple de distribution d'étiquettes True du diagramme du jeu de données.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-dist-label.png)
## Diagramme Perte contre Étape
Il s'agit d'un graphique linéaire qui montre la progression de la perte sur les données d'entraînement et les données de validation tout au long des étapes d'entraînement. La perte est ce que vous avez défini dans votre fonction objective, comme une erreur quadratique moyenne. Vous pouvez évaluer si le modèle est trop ajusté ou inadapté à partir de ce diagramme. Cette section fournit également des informations que vous pouvez utiliser pour déterminer comment résoudre les problèmes de surajustement et de sous-ajustement. Cette visualisation est disponible pour les types de modèles suivants : classification binaire, multiclassification et régression.
![\[Exemple de diagramme Perte contre Étape.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-loss-vs-step.png)
## Importance des caractéristiques
Il existe trois différents types de visualisations de l'importance des fonctions : Weight (Pondération), Gain et Coverage (Couverture). Le rapport contient des définitions détaillées pour chacune des trois fonctions. Les visualisations de l'importance des fonctions vous aident à déterminer quelles fonctions de votre jeu de données d'entraînement ont contribué aux prédictions. Les visualisations de l'importance des fonctions sont disponibles pour les types de modèles suivants : classification binaire, multiclassification et régression.
![\[Exemple de graphique d'importance des fonctions.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-feature-importance.png)
## Matrice Confusion
Cette visualisation s'applique uniquement aux modèles de classification binaires et multiclasses. La précision à elle seule peut ne pas suffire à évaluer les performances du modèle. Pour certains cas d'utilisation, comme les soins de santé et la détection de fraude, il est également important de connaître le taux de faux positifs et le taux de faux négatifs. Une matrice Confusion vous donne les dimensions supplémentaires pour évaluer les performances de votre modèle.
![\[Exemple de matrice Confusion.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-confusion-matrix.png)
## Évaluation de la matrice de confusion
Cette section vous fournit plus d'informations sur les métriques micro, macro et pondérées en matière de précision, de rappel et de score F1 pour votre modèle.
![\[Évaluation de la matrice de confusion.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-eval-conf-matrix.png)
## Taux de précision de chaque élément diagonal par rapport à l’itération
Cette visualisation s'applique uniquement aux modèles de classification binaires et multiclasses. Il s'agit d'un graphique linéaire qui trace les valeurs diagonales de la matrice Confusion tout au long des étapes d'entraînement pour chaque classe. Ce graphique vous montre comment la précision de chaque classe progresse tout au long des étapes d'entraînement. Vous pouvez identifier les classes sous-performantes à partir de ce diagramme.
![\[Exemple de taux de précision de chaque élément diagonal par rapport au graphique d'itération.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-accuracy-rate.gif)
## Courbe caractéristique de fonctionnement du récepteur
Cette visualisation s'applique uniquement aux modèles de classification binaire. La courbe de caractéristique de fonctionnement du récepteur est communément utilisée pour évaluer les performances du modèle de classification binaire. L'axe des y de la courbe représente le taux de vrais positifs et l'axe des x représente le taux de faux positif. Le graphique affiche également la valeur de la zone sous la courbe. Plus la valeur de la zone sous la courbe est élevée, plus votre classificateur est prédictif. Vous pouvez également utiliser la courbe de caractéristique de fonctionnement du récepteur pour comprendre le compromis entre le taux de vrais positifs et le taux de faux positifs et identifier le seuil de classification optimal pour votre cas d'utilisation. Le seuil de classification peut être modifié pour ajuster le comportement du modèle et ainsi réduire plus d'un ou un autre type d'erreur (FP/FN).
![\[Exemple de graphique de courbe de caractéristique de fonctionnement du récepteur.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-rec-op-char.png)
## Distribution des résidus à la dernière étape enregistrée
Cette visualisation est un graphique en colonnes qui montre les distributions résiduelles dans la dernière étape capturée par Debugger. Dans cette visualisation, vous pouvez vérifier si la distribution résiduelle est proche de la distribution normale, centrée sur zéro. Si les valeurs résiduelles sont biaisées, il se peut que vos fonctions ne soient pas suffisantes pour prédire les étiquettes.
![\[Exemple de distribution de valeurs résiduelles au dernier graphique d'étape enregistré.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-dist-residual.png)
## Erreur de validation absolue par groupe d’étiquettes sur itération
Cette visualisation s'applique uniquement aux modèles de régression. Les valeurs cibles réelles sont divisées en 10 intervalles. Cette visualisation montre comment les erreurs de validation progressent pour chaque intervalle tout au long des étapes d'entraînement à travers un tracé linéaire. L'erreur de validation absolue est la valeur absolue de la différence entre la prédiction et la valeur réelle pendant la validation. Vous pouvez identifier les intervalles sous-performants à partir de cette visualisation.
![\[Exemple d'erreur de validation absolue par groupe d'étiquettes sur graphique d'itération.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-val-error-per-label-bin.png)
# Action sur les règles d'Amazon SageMaker Debugger
En fonction du statut d'évaluation des règles Debugger, vous pouvez configurer des actions automatisées telles que l'arrêt d'une tâche d'entraînement et l'envoi de notifications à l'aide d'Amazon Simple Notification Service (Amazon SNS). Vous pouvez également créer vos propres actions à l'aide d'Amazon CloudWatch Events et AWS Lambda. Pour savoir comment configurer des actions automatisées basées sur le statut d’évaluation des règles Debugger, consultez les rubriques suivantes.
**Topics**
+ [Utilisation des actions intégrées Debugger pour les règles](debugger-built-in-actions.md)
+ [Actions relatives aux règles à l'aide d'Amazon CloudWatch et AWS Lambda](debugger-cloudwatch-lambda.md)
# Utilisation des actions intégrées Debugger pour les règles
Utilisez les actions intégrées Debugger pour réagir aux problèmes détectés par [Règle Debugger](debugger-built-in-rules.md#debugger-built-in-rules-Rule). La classe `rule_configs` Debugger fournit des outils pour configurer une liste d'actions, y compris l'arrêt automatique des tâches d'entraînement et l'envoi de notifications à l'aide d'Amazon Simple Notification Service (Amazon SNS) lorsque les règles Debugger détectent des problèmes d'entraînement. Les rubriques suivantes détaillent les étapes à suivre pour effectuer ces tâches.
**Topics**
+ [Configuration d’Amazon SNS, création d’une rubrique `SMDebugRules` et abonnement à la rubrique](#debugger-built-in-actions-sns)
+ [Configuration de votre rôle IAM pour attacher les stratégies requises](#debugger-built-in-actions-iam)
+ [Configuration des règles Debugger avec les actions intégrées](#debugger-built-in-actions-on-rule)
+ [Considérations relatives à l’utilisation des actions intégrées Debugger](#debugger-built-in-actions-considerations)
## Configuration d’Amazon SNS, création d’une rubrique `SMDebugRules` et abonnement à la rubrique
Cette section explique comment configurer une rubrique **SMDebugRules** Amazon SNS, vous abonner à celle-ci et confirmer l'abonnement pour recevoir les notifications des règles Debugger.
**Note**
[Pour plus d'informations sur la facturation d'Amazon SNS, consultez les sections Tarification Amazon [SNS et Amazon SNS](https://aws.amazon.com/sns/pricing/). FAQs](https://aws.amazon.com/sns/faqs/)
**Pour créer une rubrique sur SMDebug les règles**
1. [Connectez-vous à la console Amazon SNS AWS Management Console et ouvrez-la sur v3/home. https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/v3/home)
1. Dans le panneau de navigation de gauche, choisissez **Rubriques**.
1. Sur la page **Topics (Rubriques)**, choisissez **Create new topic (Créer une rubrique)**.
1. Sur la page **Create ropic (Créer une rubrique)**, dans la section **Details (Détails)**, procédez comme suit :
1. Pour **Type**, choisissez **Standard** pour le type de rubrique.
1. Pour **Name (Nom)**, entrez **SMDebugRules**.
1. Ignorez tous les autres paramètres facultatifs et choisissez **Create topic (Créer une rubrique)**. Pour en savoir plus sur les paramètres facultatifs, consultez [Création d'une rubrique Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html).
**Pour vous abonner à la rubrique SMDebug Règles**
1. [Ouvrez la console Amazon SNS à l'adresse v3/home. https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/v3/home)
1. Dans le volet de navigation de gauche, choisissez **Abonnements**.
1. Sur la page **Abonnements**, choisissez **Créer un abonnement**.
1. Sur la page **Créer un abonnement**, dans la section **Détails**, procédez comme suit :
1. Pour l'**ARN de la rubrique**, choisissez l'ARN de la rubrique **SMDebugRègles**. L'ARN doit avoir le format `arn:aws:sns::111122223333:SMDebugRules`.
1. Pour **Protocol (Protocole)**, choisissez **Email (E-mail)** ou **SMS**.
1. Pour **Endpoint (Point de terminaison)**, saisissez la valeur du point de terminaison, telle qu'une adresse e-mail ou un numéro de téléphone, qui recevra les notifications.
**Note**
Assurez-vous de saisir l'adresse e-mail et le numéro de téléphone appropriés. Les numéros de téléphone doivent inclure `+`, un code pays et un numéro de téléphone, et ne doivent pas contenir de caractères spéciaux ni d'espaces. Par exemple, le numéro de téléphone \$11 (222) 333-4444 est mis en forme comme suit : **\$112223334444**.
1. Ignorez tous les autres paramètres facultatifs et choisissez **Create subscription (Créer un abonnement)**. Pour en savoir plus sur les paramètres facultatifs, consultez [Abonnement à une rubrique Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html).
Après vous être inscrit à la rubrique **SMDebugRègles**, vous recevez le message de confirmation suivant par e-mail ou par téléphone :
![\[Un e-mail de confirmation d'abonnement pour la rubrique Amazon SNS SMDebugRules.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-built-in-action-subscription-confirmation.png)
Pour plus d’informations sur Amazon SNS, consultez [Messagerie texte mobile (SMS)](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html) et [Notifications par e-mail](https://docs.aws.amazon.com/sns/latest/dg/sns-email-notifications.html) dans le *Guide du développeur Amazon SNS*.
## Configuration de votre rôle IAM pour attacher les stratégies requises
Dans cette étape, vous ajoutez les stratégies requises à votre rôle IAM.
**Pour ajouter les stratégies requises à votre rôle IAM**
1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.
1. Dans le panneau de navigation de gauche, choisissez **Policies (Stratégies)**, puis **Create policy (Créer une stratégie)**.
1. Sur la page **Create policy (Créer une stratégie)**, procédez comme suit pour créer une stratégie sns-access :
1. Choisissez l’onglet **JSON**.
1. Collez les chaînes JSON mises en forme en gras dans le code suivant dans le`"Statement"`, en remplaçant l'identifiant de AWS compte à 12 chiffres par votre identifiant de AWS compte.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sns:Publish",
"sns:CreateTopic",
"sns:Subscribe"
],
"Resource": "arn:aws:sns:*:111122223333:SMDebugRules"
}
]
}
```
------
1. En bas de la page, choisissez **Review policy (Vérifier la stratégie)**.
1. Sur la page **Review policy (Vérifier la stratégie)**, pour **Name (Nom)**, saisissez **sns-access**.
1. En bas de la page, choisissez **Create policy (Créer la stratégie)**.
1. Accédez à la console IAM et choisissez **Roles (Rôles)** dans le panneau de navigation de gauche.
1. Recherchez le rôle IAM que vous utilisez pour la formation des modèles d' SageMaker IA et choisissez-le.
1. Sous l'onglet **Permissions (Autorisations)** de la page **Summary (Récapitulatif)**, choisissez **Attach policies (Attacher des stratégies)**.
1. Recherchez la stratégie **sns-access**, cochez la case en regard de la stratégie, puis choisissez **Attach Policy (Attacher la stratégie)**.
Pour voir d'autres exemples de configuration de stratégies IAM pour Amazon SNS, consultez [Exemples de cas pour le contrôle d'accès Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-access-policy-use-cases.html).
## Configuration des règles Debugger avec les actions intégrées
Après avoir terminé avec succès les paramètres requis dans les étapes précédentes, vous pouvez configurer les actions intégrées Debugger pour les règles de débogage, comme indiqué dans l'exemple de script suivant. Vous pouvez choisir les actions intégrées à utiliser lors de la création de l'objet de liste `actions`. `rule_configs` est un module d'assistance qui fournit des outils de haut niveau pour configurer les règles et actions intégrées Debugger. Les actions intégrées suivantes sont disponibles pour Debugger :
+ `rule_configs.StopTraining()` : arrête une tâche d'entraînement lorsque la règle Debugger détecte un problème.
+ `rule_configs.Email("abc@abc.com")` : envoie une notification par e-mail lorsque la règle Debugger détecte un problème. Utilisez l'adresse e-mail que vous avez utilisée lors de la configuration de votre abonnement à rubrique SNS.
+ `rule_configs.SMS("+1234567890")` : envoie une notification par message texte lorsque la règle Debugger détecte un problème. Utilisez le numéro de téléphone que vous avez utilisé lors de la configuration de votre abonnement à la rubrique SNS.
**Note**
Assurez-vous de saisir l'adresse e-mail et le numéro de téléphone appropriés. Les numéros de téléphone doivent inclure `+`, un code pays et un numéro de téléphone, et ne doivent pas comporter de caractères spéciaux ni d'espaces. Par exemple, le numéro de téléphone \$11 (222) 333-4444 est mis en forme comme suit : **\$112223334444**.
Vous pouvez utiliser toutes les actions intégrées ou un sous-ensemble d'actions en les finalisant à l'aide de la méthode `rule_configs.ActionList()`, qui prend les actions intégrées et configure une liste d'actions.
**Pour ajouter les trois actions intégrées à une seule règle**
Si vous souhaitez affecter les trois actions intégrées à une seule règle, configurez une liste d'actions intégrées Debugger lorsque vous créez un estimateur. Utilisez le modèle suivant pour créer l'estimateur, et Debugger arrêtera les tâches d'entraînement et enverra des notifications par e-mail et SMS pour toutes les règles que vous utilisez afin de contrôler la progression de votre tâche d'entraînement.
```
from sagemaker.debugger import Rule, rule_configs
# Configure an action list object for Debugger rules
actions = rule_configs.ActionList(
rule_configs.StopTraining(),
rule_configs.Email("abc@abc.com"),
rule_configs.SMS("+1234567890")
)
# Configure rules for debugging with the actions parameter
rules = [
Rule.sagemaker(
base_config=rule_configs.built_in_rule(), # Required
rule_parameters={"paramter_key": value }, # Optional
actions=actions
)
]
estimator = Estimator(
...
rules = rules
)
estimator.fit(wait=False)
```
**Pour créer plusieurs objets d'action intégrée et affecter différentes actions à une seule règle**
Si vous souhaitez affecter les actions intégrées à déclencher à différentes valeurs de seuil d'une seule règle, vous pouvez créer plusieurs objets d'action intégrée comme indiqué dans le script suivant. Pour éviter une erreur de conflit en exécutant la même règle, vous devez envoyer des noms de tâche de règle différents (spécifiez des chaînes différentes pour l'attribut `name` des règles) comme illustré dans l'exemple de modèle de script suivant. Cet exemple vous montre comment configurer [StalledTrainingRrule](debugger-built-in-rules.md#stalled-training) pour effectuer deux actions différentes : envoyer un e-mail à `abc@abc.com` lorsqu'une tâche d'entraînement se bloque pendant 60 secondes, et arrêter la tâche d'entraînement en cas de blocage pendant 120 secondes.
```
from sagemaker.debugger import Rule, rule_configs
import time
base_job_name_prefix= 'smdebug-stalled-demo-' + str(int(time.time()))
# Configure an action object for StopTraining
action_stop_training = rule_configs.ActionList(
rule_configs.StopTraining()
)
# Configure an action object for Email
action_email = rule_configs.ActionList(
rule_configs.Email("abc@abc.com")
)
# Configure a rule with the Email built-in action to trigger if a training job stalls for 60 seconds
stalled_training_job_rule_email = Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "60",
"training_job_name_prefix": base_job_name_prefix
},
actions=action_email
)
stalled_training_job_rule_text.name="StalledTrainingJobRuleEmail"
# Configure a rule with the StopTraining built-in action to trigger if a training job stalls for 120 seconds
stalled_training_job_rule = Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "120",
"training_job_name_prefix": base_job_name_prefix
},
actions=action_stop_training
)
stalled_training_job_rule.name="StalledTrainingJobRuleStopTraining"
estimator = Estimator(
...
rules = [stalled_training_job_rule_email, stalled_training_job_rule]
)
estimator.fit(wait=False)
```
Lorsque la tâche d'entraînement est en cours d'exécution, l'action intégrée Debugger envoie des notifications par e-mail et SMS chaque fois que la règle détecte des problèmes avec votre tâche d'entraînement. La capture d'écran suivante montre un exemple de notification par e-mail pour une tâche d'entraînement qui présente un problème de blocage de tâche d'entraînement.
![\[Exemple de notification par e-mail envoyée par Debugger lorsqu'il détecte un StalledTraining problème.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-built-in-action-email.png)
La capture d'écran suivante montre un exemple de notification texte que Debugger envoie lorsque la règle détecte un StalledTraining problème.
![\[Exemple de notification texte envoyée par Debugger lorsqu'il détecte un StalledTraining problème.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-built-in-action-text.png)
## Considérations relatives à l’utilisation des actions intégrées Debugger
+ Pour utiliser les actions intégrées Debugger, une connexion Internet est requise. Cette fonctionnalité n'est pas prise en charge dans le mode d'isolation réseau fourni par Amazon SageMaker AI ou Amazon VPC.
+ Les actions intégrées ne peuvent pas être utilisées pour [Règles du profileur](debugger-built-in-profiler-rules.md#debugger-built-in-profiler-rules-ProfilerRule).
+ Les actions intégrées ne peuvent pas être utilisées sur les tâches d'entraînement avec des interruptions d'entraînement ponctuelles.
+ Dans les notifications par e-mail ou par SMS, `None` apparaît à la fin des messages. Cela n'a aucune signification, vous pouvez donc ignorer le texte `None`.
# Actions relatives aux règles à l'aide d'Amazon CloudWatch et AWS Lambda
Amazon CloudWatch collecte les journaux des tâches de formation des modèles Amazon SageMaker AI et les journaux des tâches de traitement des règles Amazon SageMaker Debugger. Configurez Debugger avec Amazon CloudWatch Events et prenez des mesures en fonction AWS Lambda de l'état d'évaluation des règles du Debugger.
## Exemples de blocs-notes
Vous pouvez exécuter les exemples de blocs-notes suivants, qui sont préparés pour expérimenter l'arrêt d'une tâche de formation à l'aide d'actions sur les règles intégrées de Debugger à l'aide d'Amazon et. CloudWatch AWS Lambda
+ [Amazon SageMaker Debugger - Réagir aux CloudWatch événements à partir de règles](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_action_on_rule/tf-mnist-stop-training-job.html)
Cet exemple de bloc-notes exécute une tâche d'entraînement qui présente un problème de disparition de gradient. La règle [VanishingGradient](debugger-built-in-rules.md#vanishing-gradient) intégrée du Debugger est utilisée lors de la construction de l'estimateur SageMaker AI TensorFlow . Lorsque la règle Debugger détecte le problème, la tâche d'entraînement est interrompue.
+ [Détectez les entraînements bloqués et invoquez des actions à l'aide de la règle du SageMaker débogueur](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_action_on_rule/detect_stalled_training_job_and_actions.html)
Cet exemple de bloc-notes exécute un script d'entraînement avec une ligne de code qui le force à rester en veille pendant 10 minutes. La règle intégrée [StalledTrainingRrule](debugger-built-in-rules.md#stalled-training) de Debugger invoque des problèmes et arrête la tâche d'entraînement.
**Topics**
+ [Exemples de blocs-notes](#debugger-test-stop-training)
+ [CloudWatch Journaux d'accès aux règles du débogueur et aux tâches de formation](debugger-cloudwatch-metric.md)
+ [Configurer Debugger pour la fin automatique des tâches de formation à l'aide CloudWatch de Lambda](debugger-stop-training.md)
+ [Désactivez la règle CloudWatch des événements pour arrêter d'utiliser la fin automatique des tâches de formation](debugger-disable-cw.md)
# CloudWatch Journaux d'accès aux règles du débogueur et aux tâches de formation
Vous pouvez utiliser le statut des tâches relatives à la formation et à la règle du débogueur figurant dans les CloudWatch journaux pour prendre des mesures supplémentaires en cas de problème de formation. La procédure suivante indique comment accéder aux CloudWatch journaux associés. Pour plus d'informations sur le suivi des tâches de formation à l'aide de l'outil CloudWatch, consultez [Monitor Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html).
**Pour rechercher les journaux des tâches d’entraînement et ceux des tâches de règles Debugger**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation de gauche, sous le nœud **Log (Journal)**, choisissez **Log Groupes (Groups de journaux)**.
1. Dans la liste des groupes de journaux, procédez comme suit :
+ Choisissez**/aws/sagemaker/TrainingJobs**pour les journaux des tâches de formation.
+ Choisissez**/aws/sagemaker/ProcessingJobs**pour les journaux des tâches liées aux règles du débogueur.
# Configurer Debugger pour la fin automatique des tâches de formation à l'aide CloudWatch de Lambda
Les règles du Debugger surveillent l'état des tâches de formation, tandis qu'une règle d' CloudWatch événements surveille l'état d'évaluation des tâches de formation des règles Debugger. Les sections suivantes décrivent le processus nécessaire pour automatiser la fin des tâches de formation à l'aide de Lambda CloudWatch et de Lambda.
**Topics**
+ [Étape 1 : créer une fonction Lambda](#debugger-lambda-function-create)
+ [Étape 2 : Configurer la fonction Lambda](#debugger-lambda-function-configure)
+ [Étape 3 : créer une règle d' CloudWatch événements et un lien vers la fonction Lambda pour Debugger](#debugger-cloudwatch-events)
## Étape 1 : créer une fonction Lambda
**Pour créer une fonction Lambda**
1. Ouvrez la AWS Lambda console à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Dans le panneau de navigation, choisissez **Functions (Fonctions)**, puis **Create function (Créer une fonction)**.
1. Sur la page **Create function (Créer une fonction)**, choisissez l'option **Author from scratch (Créer à partir de zéro)**.
1. Dans la section **Informations de base**, entrez le **nom d'une fonction** (par exemple, **debugger-rule-stop-training-job**).
1. Pour **Runtime**, sélectionnez **Python 3.7**.
1. Pour **Permissions (Autorisations)**, développez la liste d'options déroulante et choisissez **Change default execution role (Modifier le rôle d'exécution par défaut)**.
1. Pour **le rôle d'exécution**, choisissez **Utiliser un rôle existant** et choisissez le rôle IAM que vous utilisez pour les tâches de formation sur l' SageMaker IA.
**Note**
Assurez-vous d'utiliser le rôle d'exécution avec `AmazonSageMakerFullAccess` et `AWSLambdaBasicExecutionRole` attachées. Sinon, la fonction Lambda ne réagira pas correctement aux changements de statut de la règle Debugger de la tâche d'entraînement. Si vous ne savez pas quel rôle d'exécution est utilisé, exécutez le code suivant dans une cellule de bloc-notes Jupyter pour récupérer la sortie du rôle d'exécution :
```
import sagemaker
sagemaker.get_execution_role()
```
1. Dans le bas de la page, choisissez **Create function**.
La figure suivante illustre un exemple de page **Create function (Créer une fonction)** avec les champs de saisie et les sélections remplis.
![\[Page Create function (Créer une fonction).\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-lambda-create.png)
## Étape 2 : Configurer la fonction Lambda
**Pour configurer la fonction Lambda**
1. Dans la section **Function code (Code de fonction)** de la page de configuration, collez le script Python suivant dans le volet de l'éditeur de code Lambda. La `lambda_handler` fonction surveille l'état d'évaluation des règles du débogueur collecté par l'`StopTrainingJob`API CloudWatch et déclenche l'opération. Le AWS SDK pour Python (Boto3) `client` for SageMaker AI fournit une méthode de haut niveau`stop_training_job`, qui déclenche le fonctionnement de l'`StopTrainingJob`API.
```
import json
import boto3
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def lambda_handler(event, context):
training_job_name = event.get("detail").get("TrainingJobName")
logging.info(f'Evaluating Debugger rules for training job: {training_job_name}')
eval_statuses = event.get("detail").get("DebugRuleEvaluationStatuses", None)
if eval_statuses is None or len(eval_statuses) == 0:
logging.info("Couldn't find any debug rule statuses, skipping...")
return {
'statusCode': 200,
'body': json.dumps('Nothing to do')
}
# should only attempt stopping jobs with InProgress status
training_job_status = event.get("detail").get("TrainingJobStatus", None)
if training_job_status != 'InProgress':
logging.debug(f"Current Training job status({training_job_status}) is not 'InProgress'. Exiting")
return {
'statusCode': 200,
'body': json.dumps('Nothing to do')
}
client = boto3.client('sagemaker')
for status in eval_statuses:
logging.info(status.get("RuleEvaluationStatus") + ', RuleEvaluationStatus=' + str(status))
if status.get("RuleEvaluationStatus") == "IssuesFound":
secondary_status = event.get("detail").get("SecondaryStatus", None)
logging.info(
f'About to stop training job, since evaluation of rule configuration {status.get("RuleConfigurationName")} resulted in "IssuesFound". ' +
f'\ntraining job "{training_job_name}" status is "{training_job_status}", secondary status is "{secondary_status}"' +
f'\nAttempting to stop training job "{training_job_name}"'
)
try:
client.stop_training_job(
TrainingJobName=training_job_name
)
except Exception as e:
logging.error(
"Encountered error while trying to "
"stop training job {}: {}".format(
training_job_name, str(e)
)
)
raise e
return None
```
Pour plus d'informations sur l'interface de l'éditeur de code Lambda, voir [Création de fonctions à l'aide de l'éditeur de console AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/code-editor.html).
1. Ignorez tous les autres paramètres et choisissez **Save (Enregistrer)** en haut de la page de configuration.
## Étape 3 : créer une règle d' CloudWatch événements et un lien vers la fonction Lambda pour Debugger
**Pour créer une règle d' CloudWatch événements et créer un lien vers la fonction Lambda pour Debugger**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation de gauche, choisissez **Rules (Règles)** sous le nœud **Events (Événements)**.
1. Choisissez **Créer une règle**.
1. Dans la section **Source de l'événement** de la page **Étape 1 : Créer une règle**, choisissez **SageMaker AI** pour le **nom du service**, puis choisissez **SageMaker AI Training Job State Change** pour le **type d'événement**. La prévisualisation du modèle d'événement doit ressembler à l'exemple de chaînes JSON suivant :
```
{
"source": [
"aws.sagemaker"
],
"detail-type": [
"SageMaker Training Job State Change"
]
}
```
1. Dans la section **Targets**, choisissez **Add target\$1, puis** choisissez la **debugger-rule-stop-trainingfonction Lambda -job** que vous avez créée. Cette étape lie la règle CloudWatch Events à la fonction Lambda.
1. Choisissez **Configure details (Configurer les détails)** et accédez à la page **Step 2: Configure rule details (Étape 2 : Configurer les détails de la règle)**.
1. Spécifiez le nom de la définition de CloudWatch règle. Par exemple, **debugger-cw-event-rule**.
1. Choisissez **Create rule (Créer la règle)** pour terminer.
1. Revenez dans la page de configuration de la fonction Lambda et actualisez la page. Vérifiez qu'elle est correctement configurée dans le panneau **Designer (Concepteur)**. La règle CloudWatch Events doit être enregistrée comme déclencheur pour la fonction Lambda. La conception de configuration doit ressembler à l'exemple suivant :
![\[Panneau de conception pour la CloudWatch configuration.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-lambda-designer.png)
# Désactivez la règle CloudWatch des événements pour arrêter d'utiliser la fin automatique des tâches de formation
Si vous souhaitez désactiver l'arrêt automatique des tâches de formation, vous devez désactiver la règle CloudWatch des événements. Dans le panneau Lambda **Designer**, choisissez le bloc **EventBridge (CloudWatch Events)** lié à la fonction Lambda. Cela montre un **EventBridge**panneau situé sous le panneau **Designer** (par exemple, voir la capture d'écran précédente). Cochez la case à côté de **EventBridge (CloudWatch Événements) : debugger-cw-event-rule**, puis choisissez **Désactiver**. Si vous souhaitez utiliser la fonctionnalité de résiliation automatique ultérieurement, vous pouvez réactiver la règle CloudWatch Événements.
# Visualisez les tenseurs SageMaker de sortie d'Amazon Debugger dans TensorBoard
**Important**
Cette page est obsolète au profit d'Amazon SageMaker AI with TensoBoard, qui fournit une TensorBoard expérience complète intégrée aux fonctionnalités de SageMaker formation et de contrôle d'accès du domaine SageMaker AI. Pour en savoir plus, veuillez consulter la section [TensorBoard dans Amazon SageMaker AI](tensorboard-on-sagemaker.md).
Utilisez SageMaker Debugger pour créer des fichiers tenseurs de sortie compatibles avec. TensorBoard Chargez les fichiers pour visualiser TensorBoard et analyser vos tâches SageMaker de formation. Le débogueur génère automatiquement des fichiers tenseurs de sortie compatibles avec. TensorBoard Quelle que soit la configuration de hook que vous personnalisez pour enregistrer des tenseurs de sortie, Debugger a la flexibilité de créer des résumés scalaires, des distributions et des histogrammes dans lesquels vous pouvez les importer. TensorBoard
![\[Diagramme d'architecture du mécanisme de sauvegarde du tenseur de sortie Debugger.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-tensorboard-concept.png)
Vous pouvez activer cela en transmettant les objets `DebuggerHookConfig` et `TensorBoardOutputConfig` à un objet `estimator`.
La procédure suivante explique comment enregistrer des scalaires, des poids et des biais sous forme de tenseurs complets, d'histogrammes et de distributions pouvant être visualisés avec. TensorBoard Debugger les enregistre dans le chemin local du conteneur d'entraînement (le chemin par défaut est `/opt/ml/output/tensors`) et se synchronise avec les emplacements Amazon S3 transmis via les objets de configuration de sortie Debugger.
**Pour enregistrer des fichiers tenseurs de sortie TensorBoard compatibles à l'aide du débogueur**
1. Configurez un objet `tensorboard_output_config` de configuration pour enregistrer la TensorBoard sortie à l'aide de la classe Debugger`TensorBoardOutputConfig`. Pour le `s3_output_path` paramètre, spécifiez le compartiment S3 par défaut de la session SageMaker AI en cours ou un compartiment S3 préféré. Cet exemple n'ajoute pas le paramètre `container_local_output_path` ; à la place, il est défini sur le chemin local par défaut `/opt/ml/output/tensors`.
```
import sagemaker
from sagemaker.debugger import TensorBoardOutputConfig
bucket = sagemaker.Session().default_bucket()
tensorboard_output_config = TensorBoardOutputConfig(
s3_output_path='s3://{}'.format(bucket)
)
```
Pour plus d'informations, consultez l'`[TensorBoardOutputConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig)`API Debugger dans le SDK Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
1. Configurez le hook Debugger et personnalisez les valeurs des paramètres du hook. Par exemple, le code suivant configure un hook Debugger pour enregistrer toutes les sorties scalaires toutes les 100 étapes dans les phases d'entraînement et toutes les 10 étapes dans les phases de validation, les paramètres `weights` toutes les 500 étapes (la valeur par défaut `save_interval` pour enregistrer les collections de tenseurs est 500), et les paramètres `bias` toutes les 10 étapes globales jusqu'à ce que l'étape globale atteigne 500.
```
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig
hook_config = DebuggerHookConfig(
hook_parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
},
collection_configs=[
CollectionConfig("weights"),
CollectionConfig(
name="biases",
parameters={
"save_interval": "10",
"end_step": "500",
"save_histogram": "True"
}
),
]
)
```
[Pour plus d'informations sur la configuration du débogueur APIs, consultez le débogueur `[CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)` et le SDK `[DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)` APIs Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
1. Construisez un estimateur SageMaker AI avec les paramètres du Debugger en transmettant les objets de configuration. L'exemple de modèle suivant montre comment créer un estimateur SageMaker IA générique. Vous pouvez remplacer `estimator` et par les classes `Estimator` parentes d'estimateurs et les classes d'estimateurs d'autres frameworks d' SageMaker IA. Les estimateurs du framework d' SageMaker IA disponibles pour cette fonctionnalité sont `[TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html#create-an-estimator)``[PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#create-an-estimator)`, et. `[MXNet](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#create-an-estimator)`
```
from sagemaker.estimator import Estimator
estimator = Estimator(
...
# Debugger parameters
debugger_hook_config=hook_config,
tensorboard_output_config=tensorboard_output_config
)
estimator.fit()
```
La `estimator.fit()` méthode lance une tâche d'entraînement et Debugger écrit les fichiers tenseurs de sortie en temps réel sur le chemin de sortie du Debugger S3 et sur le chemin de sortie S3. TensorBoard Pour récupérer les chemins de sortie, utilisez les méthodes d'estimateur suivantes :
+ Pour le chemin de sortie Debugger S3, utilisez `estimator.latest_job_debugger_artifacts_path()`.
+ Pour le chemin de sortie TensorBoard S3, utilisez`estimator.latest_job_tensorboard_artifacts_path()`.
1. Une fois l'entraînement terminé, vérifiez les noms des tenseurs de sortie enregistrés :
```
from smdebug.trials import create_trial
trial = create_trial(estimator.latest_job_debugger_artifacts_path())
trial.tensor_names()
```
1. Vérifiez les données TensorBoard de sortie dans Amazon S3 :
```
tensorboard_output_path=estimator.latest_job_tensorboard_artifacts_path()
print(tensorboard_output_path)
!aws s3 ls {tensorboard_output_path}/
```
1. Téléchargez les données TensorBoard de sortie sur votre instance de bloc-notes. Par exemple, la AWS CLI commande suivante télécharge les TensorBoard fichiers `/logs/fit` dans le répertoire de travail actuel de votre instance de bloc-notes.
```
!aws s3 cp --recursive {tensorboard_output_path} ./logs/fit
```
1. Compressez le répertoire de fichiers dans un fichier TAR à télécharger sur votre ordinateur local.
```
!tar -cf logs.tar logs
```
1. Téléchargez et extrayez le fichier TAR Tensorboard dans un répertoire de votre appareil, lancez un serveur de bloc-notes Jupyter, ouvrez un nouveau bloc-notes et exécutez l'application. TensorBoard
```
!tar -xf logs.tar
%load_ext tensorboard
%tensorboard --logdir logs/fit
```
La capture d'écran animée suivante illustre les étapes 5 à 8. Il montre comment télécharger le fichier TensorBoard TAR du débogueur et le charger dans un bloc-notes Jupyter sur votre appareil local.
![\[Animation expliquant comment télécharger et charger le TensorBoard fichier Debugger sur votre machine locale.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-tensorboard.gif)