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.
# SageMaker Débogueur Amazon
Déboguez les tenseurs de sortie des modèles issus de tâches de formation au machine learning en temps réel et détectez les problèmes non convergents à l'aide d'Amazon Debugger. SageMaker
## Fonctionnalités d'Amazon SageMaker Debugger
Une tâche d'entraînement de machine learning (ML) peut présenter des problèmes tels que des surajustements, la saturation des fonctions d'activation et la disparition des gradients, qui peuvent compromettre les performances du modèle.
SageMaker Debugger fournit des outils pour déboguer les tâches d'entraînement et résoudre ces problèmes afin d'améliorer les performances de votre modèle. Debugger propose également des outils permettant d'envoyer des alertes lorsque des anomalies d'entraînement sont détectées, de prendre des mesures contre les problèmes et d'en identifier la cause racine en visualisant les métriques et les tenseurs collectés.
SageMaker Debugger prend en charge les frameworks Apache MXNet PyTorch, TensorFlow, et XGBoost . Pour plus d'informations sur les frameworks disponibles et les versions prises en charge par SageMaker Debugger, consultez. [Cadres et algorithmes pris en charge](debugger-supported-frameworks.md)
![\[Présentation du fonctionnement d'Amazon SageMaker Debugger.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-main.png)
Voici le flux de travail à haut niveau de Debugger :
1. Modifiez votre script d'entraînement à l'aide du kit SDK Python pour `sagemaker-debugger`, si nécessaire.
1. Configurez une tâche SageMaker de formation avec SageMaker Debugger.
+ Configurez à l'aide de l'API SageMaker AI Estimator (pour le SDK Python).
+ Configurez à l'aide de la [`CreateTrainingJob`requête SageMaker AI (pour Boto3 ou CLI](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html)).
+ Configurez [des conteneurs de formation personnalisés](debugger-bring-your-own-container.md) avec SageMaker Debugger.
1. Démarrez une tâche d'entraînement et contrôlez les problèmes d'entraînement en temps réel.
+ [Liste des règles intégrées à Debugger](debugger-built-in-rules.md).
1. Recevez des alertes et prenez des mesures rapides contre les problèmes d'entraînement.
+ Recevez des textes et des e-mails et arrêtez les tâches d'entraînement lorsque des problèmes d'entraînement sont détectés à l'aide des [Utilisation des actions intégrées Debugger pour les règles](debugger-built-in-actions.md).
+ Configurez vos propres actions à l'aide d'[Amazon CloudWatch Events et AWS Lambda](debugger-cloudwatch-lambda.md).
1. Examinez l'analyse approfondie des problèmes d'entraînement.
+ Pour le débogage des tenseurs de sortie de modèle, consultez [Visualisez les tenseurs de sortie du débogueur dans TensorBoard](debugger-enable-tensorboard-summaries.md).
1. Corrigez les problèmes en tenant compte des suggestions fournies par Debugger et répétez les étapes 1 à 5 pour optimiser votre modèle jusqu'à atteindre la précision souhaitée.
Le guide du développeur SageMaker Debugger aborde les sujets suivants.
**Topics**
+ [Fonctionnalités d'Amazon SageMaker Debugger](#debugger-features)
+ [Cadres et algorithmes pris en charge](debugger-supported-frameworks.md)
+ [Architecture d'Amazon SageMaker Debugger](debugger-how-it-works.md)
+ [Didacticiels Debugger](debugger-tutorial.md)
+ [Débogage de tâches de formation à l'aide d'Amazon SageMaker Debugger](debugger-debug-training-jobs.md)
+ [Liste des règles intégrées à Debugger](debugger-built-in-rules.md)
+ [Création de règles personnalisées à l’aide de la bibliothèque client Debugger](debugger-custom-rules.md)
+ [Utilisation de Debugger avec des conteneurs d’entraînement personnalisés](debugger-bring-your-own-container.md)
+ [Configurer le débogueur à l'aide de l'API SageMaker](debugger-createtrainingjob-api.md)
+ [Références Amazon SageMaker Debugger](debugger-reference.md)
# Cadres et algorithmes pris en charge
Le tableau suivant présente les frameworks et algorithmes d'apprentissage automatique basés sur l' SageMaker IA pris en charge par Debugger.
|
|
| **SageMaker AI-supported frameworks and algorithms** | **Debugging output tensors** |
| --- |--- |
| [TensorFlow](https://sagemaker.readthedocs.io/en/stable/using_tf.html) | [AWS TensorFlow conteneurs de deep learning](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.15.4 ou version ultérieure |
| [PyTorch](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html) | [AWS PyTorch conteneurs de deep learning](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.5.0 ou version ultérieure |
| [MXNet](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html) | [AWS MXNet conteneurs de deep learning](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.6.0 ou version ultérieure |
| [XGBoost](https://sagemaker.readthedocs.io/en/stable/frameworks/xgboost/using_xgboost.html) | 1.0-1, 1.2-1, 1.3-1 |
| [SageMaker Estimateur générique d'IA](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) | [Conteneurs de formation personnalisés](debugger-bring-your-own-container.md) (disponibles pour TensorFlow PyTorch, MXNet, et XGBoost avec enregistrement manuel des crochets) |
+ **Débogage des tenseurs de sortie** : suivez et déboguez les paramètres du modèle, tels que les pondérations, les gradients, les biais et les valeurs scalaires de votre tâche d'entraînement. Les frameworks de deep learning disponibles sont Apache MXNet TensorFlow, PyTorch, et XGBoost.
**Important**
Pour le TensorFlow framework avec Keras, SageMaker Debugger déconseille la prise en charge du zéro changement de code pour les modèles de débogage créés à l'aide des modules de 2.6 et versions ultérieures. `tf.keras` TensorFlow Cela est dû aux modifications majeures annoncées dans la [note de publication de la TensorFlow version 2.6.0](https://github.com/tensorflow/tensorflow/releases/tag/v2.6.0). Pour obtenir des instructions de mise à jour de votre script d'entraînement, consultez [Adaptez votre script TensorFlow d'entraînement](debugger-modify-script-tensorflow.md).
**Important**
À partir de la PyTorch version v1.12.0 et des versions ultérieures, SageMaker Debugger déconseille la prise en charge du zéro changement de code pour les modèles de débogage.
Cela est dû à des modifications importantes qui font en sorte que SageMaker Debugger interfère avec les `torch.jit` fonctionnalités. Pour obtenir des instructions de mise à jour de votre script d'entraînement, consultez [Adaptez votre script PyTorch d'entraînement](debugger-modify-script-pytorch.md).
Si le framework ou l'algorithme que vous souhaitez entraîner et déboguer ne figure pas dans le tableau, rendez-vous sur le [forum de AWS discussion](https://forums.aws.amazon.com/) et laissez des commentaires sur SageMaker Debugger.
## Régions AWS
Amazon SageMaker Debugger est disponible dans toutes les régions où Amazon SageMaker AI est en service, à l'exception de la région suivante.
+ Asie-Pacifique (Jakarta) : `ap-southeast-3`
Pour savoir si Amazon SageMaker AI est en service dans votre région Région AWS, consultez la section [Services AWS régionaux](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).
## Utilisation de Debugger avec des conteneurs d’entraînement personnalisés
Intégrez vos conteneurs de formation à l' SageMaker IA et obtenez des informations sur vos tâches de formation à l'aide de Debugger. Améliorez votre efficacité en optimisant votre modèle sur les instances Amazon EC2 à l'aide des fonctions de surveillance et de débogage.
Pour savoir comment créer votre conteneur d'entraînement avec la bibliothèque client `sagemaker-debugger`, le transmettre à Amazon Elastic Container Registry (Amazon ECR) et le contrôler et le déboguer, consultez [Utilisation de Debugger avec des conteneurs d’entraînement personnalisés](debugger-bring-your-own-container.md).
## Référentiels open source Debugger GitHub
APIs Les débogueurs sont fournis via le SDK SageMaker Python et conçus pour créer des configurations de crochets et de règles de débogage pour les opérations d'IA et d'API. SageMaker [ CreateTrainingJob[ DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) La bibliothèque client `sagemaker-debugger` fournit des outils pour enregistrer des *hooks* et accéder aux données d'entraînement via sa fonction d'*essai*, le tout grâce à ses opérations d'API flexibles et puissantes. Il prend en charge les frameworks d'apprentissage automatique TensorFlow PyTorch, MXNet, et XGBoost sur Python 3.6 et versions ultérieures.
Pour obtenir des ressources directes sur Debugger et les opérations d'API `sagemaker-debugger`, consultez les liens suivants :
+ [La documentation du SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_debugger.html)
+ [Le SDK Amazon SageMaker Python - Débogueur APIs](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html)
+ [La documentation du SDK `sagemaker-debugger` Python](https://sagemaker-debugger.readthedocs.io/en/website/index.html) pour [la bibliothèque client open SageMaker source Amazon Debugger](https://github.com/awslabs/sagemaker-debugger#amazon-sagemaker-debugger)
+ [Le `sagemaker-debugger`PyPl](https://pypi.org/project/smdebug/)
Si vous utilisez le SDK for Java pour SageMaker effectuer des tâches de formation et souhaitez configurer APIs Debugger, consultez les références suivantes :
+ [SageMaker Débogueur Amazon APIs](debugger-reference.md#debugger-apis)
+ [Configurer le débogueur à l'aide de l'API SageMaker](debugger-createtrainingjob-api.md)
# Architecture d'Amazon SageMaker Debugger
Cette rubrique présente une présentation détaillée du flux de travail Amazon SageMaker Debugger.
Debugger prend en charge la fonctionnalité de profilage pour *optimiser les performances* afin d'identifier les problèmes de calcul, tels que les goulets d'étranglement et la sous-utilisation du système, et pour aider à optimiser l'utilisation des ressources matérielles à grande échelle.
La fonctionnalité de débogage de Debugger, qui vise à *optimiser les modèles*, consiste à analyser les problèmes d'entraînement non convergents pouvant survenir, tout en minimisant les fonctions de perte à l'aide d'algorithmes d'optimisation, tels que la descente de gradient et ses variations.
Le schéma suivant montre l'architecture de SageMaker Debugger. Les encadrements avec des lignes en gras illustrent ce que fait Debugger pour analyser votre tâche d'entraînement.
![\[Présentation du fonctionnement d'Amazon SageMaker Debugger.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger_new_diagram.png)
Debugger stocke les données suivantes de vos tâches d'entraînement dans votre compartiment Amazon S3 sécurisé :
+ **Output tensors (Tenseurs de sortie)** – Ensembles de paramètres scalaires et de modèle qui sont constamment mis à jour pendant les passes en avant et en arrière lors de l'entraînement des modèles de ML. Les tenseurs de sortie comprennent des valeurs scalaires (précision et perte) et des matrices (pondérations, gradients, couches en entrée et couches en sortie).
**Note**
Par défaut, Debugger surveille et débogue les tâches d' SageMaker entraînement sans qu'aucun paramètre spécifique au Debugger ne soit configuré dans les estimateurs d'IA. SageMaker Debugger collecte des métriques système toutes les 500 millisecondes et des tenseurs de sortie de base (sorties scalaires telles que la perte et la précision) toutes les 500 étapes. Il exécute également la règle `ProfilerReport` pour analyser les métriques système et agréger le tableau de bord Studio Debugger Insights ainsi qu'un rapport de profilage. Debugger enregistre les données de sortie dans votre compartiment Amazon S3 sécurisé.
Les règles intégrées de Debugger s'exécutent sur les conteneurs de traitement, qui sont conçus pour évaluer les modèles de machine learning en traitant les données d'entraînement collectées dans votre compartiment S3 (voir [Traitement des données et évaluation des modèles](https://docs.aws.amazon.com//sagemaker/latest/dg/processing-job.html)). Les règles intégrées sont entièrement gérées par Debugger. Vous pouvez également créer vos propres règles personnalisées pour votre modèle afin de contrôler les problèmes que vous souhaitez contrôler.
# Didacticiels Debugger
Les rubriques suivantes vous présentent des didacticiels couvrant aussi bien des sujets basiques que des cas d'utilisation avancés sur la surveillance, le profilage et le débogage des tâches d'entraînement SageMaker à l'aide de Debugger. Explorez les fonctions de Debugger et découvrez comment déboguer et améliorer efficacement vos modèles de machine learning à l'aide de Debugger.
**Topics**
+ [Didacticiels vidéo Debugger](debugger-videos.md)
+ [Exemples de blocs-notes Debugger](debugger-notebooks.md)
+ [Démonstrations et visualisation avancées de Debugger](debugger-visualization.md)
# Didacticiels vidéo Debugger
Les vidéos suivantes présentent les fonctionnalités d'Amazon SageMaker Debugger à l'aide de SageMaker Studio et d'instances de bloc-notes SageMaker AI.
**Topics**
+ [Débogage de modèles avec Amazon SageMaker Debugger dans Studio Classic](#debugger-video-get-started)
+ [Présentation approfondie d'Amazon SageMaker Debugger et du moniteur de modèles SageMaker AI](#debugger-video-dive-deep)
## Débogage de modèles avec Amazon SageMaker Debugger dans Studio Classic
*Julien Simon, AWS Technical Evangelist \$1 Durée : 14 minutes 17 secondes*
Ce didacticiel vidéo explique comment utiliser Amazon SageMaker Debugger pour capturer et inspecter les informations de débogage à partir d'un modèle de formation. L'exemple de modèle d'entraînement utilisé dans cette vidéo est un réseau neuronal convolutionnel (CNN) simple basé sur Keras avec le backend. TensorFlow SageMaker AI in a TensorFlow framework et Debugger vous permettent de créer un estimateur directement à l'aide du script de formation et de déboguer la tâche de formation.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/MqPdTj0Znwg)
Vous pouvez trouver l'exemple de bloc-notes dans la vidéo dans [ce référentiel Studio Demo](https://gitlab.com/juliensimon/amazon-studio-demos/-/tree/master) fourni par l'auteur. Vous devez cloner le fichier du `debugger.ipynb` bloc-notes et le script d'`mnist_keras_tf.py`entraînement dans votre SageMaker studio ou sur une instance de SageMaker bloc-notes. Après avoir cloné les deux fichiers, spécifiez le chemin d'accès `mnist_keras_tf.py` au fichier `keras_script_path` à l'intérieur du bloc-notes `debugger.ipynb`. Par exemple, si vous avez cloné les deux fichiers dans le même répertoire, définissez-le comme suit : `keras_script_path = "mnist_keras_tf.py"`.
## Présentation approfondie d'Amazon SageMaker Debugger et du moniteur de modèles SageMaker AI
*Julien Simon, AWS Technical Evangelist \$1 Durée : 44 minutes 34 secondes*
Cette session vidéo explore les fonctionnalités avancées du Debugger et du SageMaker Model Monitor qui contribuent à améliorer la productivité et la qualité de vos modèles. Tout d'abord, cette vidéo montre comment détecter et résoudre les problèmes d'entraînement, visualiser des tenseurs et améliorer les modèles avec Debugger. Ensuite, à 22h41, la vidéo montre comment surveiller les modèles en production et identifier les problèmes de prédiction tels que les fonctionnalités manquantes ou la dérive des données à l'aide d' SageMaker AI Model Monitor. Enfin, la vidéo vous offre des conseils d'optimisation des coûts pour vous aider à tirer le meilleur parti de votre budget de machine learning.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/0zqoeZxakOI)
Vous trouverez l'exemple de bloc-notes de la vidéo dans [ce référentiel AWS Dev Days 2020](https://gitlab.com/juliensimon/awsdevdays2020/-/tree/master/mls1) offert par l'auteur.
# Exemples de blocs-notes Debugger
SageMaker [Des [exemples de blocs-notes de débogage](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/) sont fournis dans le référentiel aws/. amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) Les exemples de blocs-notes Debugger vous présentent des cas d'utilisation de niveau basique à avancé de tâches d'entraînement de débogage et de profilage.
Nous vous recommandons d'exécuter les exemples de blocs-notes sur SageMaker Studio ou sur une instance de SageMaker Notebook, car la plupart des exemples sont conçus pour les tâches de formation dans l'écosystème de l' SageMaker IA, notamment Amazon EC2, Amazon S3 et le SDK Amazon SageMaker Python.
Pour cloner l'exemple de référentiel dans SageMaker Studio, suivez les instructions d'[Amazon SageMaker Studio Tour](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-studio-end-to-end.html).
**Important**
Pour utiliser les nouvelles fonctionnalités du Debugger, vous devez mettre à niveau le SDK SageMaker Python et la `SMDebug` bibliothèque cliente. Dans votre noyau IPython, Jupyter Notebook JupyterLab ou votre environnement, exécutez le code suivant pour installer les dernières versions des bibliothèques et redémarrer le noyau.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Exemple de blocs-notes Debugger pour le profilage des tâches d’entraînement
La liste suivante contient des exemples de blocs-notes Debugger présentant l'adaptabilité de Debugger au contrôle et au profilage des tâches d'entraînement pour divers modèles de machine learning, jeux de données et cadres.
| Titre du bloc-notes | Cadre | Modèle | Jeu de données | Description |
| --- | --- | --- | --- | --- |
| [Analyse des données de profilage Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/debugger_interactive_analysis_profiling/interactive_analysis_profiling_data.html) | TensorFlow | Keras 50 ResNet | Cifar-10 | Ce carnet fournit une introduction à l'analyse interactive des données profilées capturées par SageMaker Debugger. Explorez toutes les fonctionnalités des outils d'analyse interactifs `SMDebug`. |
| [Formation à l'apprentissage automatique des profils avec Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_nlp_sentiment_analysis/sentiment-analysis-tf-distributed-training-bringyourownscript.html) | TensorFlow | Réseau neuronal convolutif 1-D | Jeu de données IMDB | Profilez un CNN en TensorFlow 1 D pour analyser les sentiments des données IMDB, qui consistent en des critiques de films étiquetées comme ayant un sentiment positif ou négatif. Explorez les informations de Studio Debugger et le rapport de profilage de Debugger. |
| [Profilage TensorFlow ResNet du modèle d'entraînement avec différents paramètres d'entraînement distribués](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_profiling) | TensorFlow | ResNet50 | Cifar-10 | Exécutez des tâches de TensorFlow formation avec différents paramètres d'entraînement distribués, surveillez l'utilisation des ressources du système et profilez les performances du modèle à l'aide de Debugger. |
| [Profilage PyTorch ResNet du modèle d'entraînement avec différents paramètres d'entraînement distribués](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_profiling) | PyTorch | ResNet50 | Cifar-10 | Exécutez des tâches de PyTorch formation avec différents paramètres d'entraînement distribués, surveillez l'utilisation des ressources du système et profilez les performances du modèle à l'aide de Debugger. |
## Exemple de blocs-notes Debugger pour l’analyse des paramètres de modèle
La liste suivante contient des exemples de blocs-notes Debugger présentant l'adaptabilité de Debugger au débogage des tâches d'entraînement pour divers modèles de machine learning, jeux de données et cadres.
| Titre du bloc-notes | Cadre | Modèle | Jeu de données | Description |
| --- | --- | --- | --- | --- |
| [Amazon SageMaker Debugger - Utiliser une règle intégrée](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_builtin_rule) | TensorFlow | Réseau neuronal convolutif | MNIST | Utilisez les règles intégrées d'Amazon SageMaker Debugger pour déboguer un modèle. TensorFlow |
| [ SageMaker Débogueur Amazon - Tensorflow 2.1](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow2) | TensorFlow | ResNet50 | Cifar-10 | Utilisez la configuration du hook Amazon SageMaker Debugger et les règles intégrées pour déboguer un modèle avec le framework Tensorflow 2.1. |
| [Visualisation des tenseurs de débogage de l'entraînement MXNet](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_plot) | MXNet | Réseau neuronal convolutif Gluon | Fashion MNIST | Exécutez une tâche de formation et configurez SageMaker Debugger pour stocker tous les tenseurs de cette tâche, puis visualisez ces tenseurs dans un bloc-notes. |
| [Activez la formation ponctuelle avec Amazon SageMaker Debugger](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_spot_training) | MXNet | Réseau neuronal convolutif Gluon | Fashion MNIST | Découvrez comment Debugger collecte des données de tenseurs à partir d'une tâche d'entraînement sur une instance Spot, et comment utiliser les règles intégrées de Debugger avec un entraînement Spot géré. |
| [Expliquer un XGBoost modèle qui prédit le revenu d'un individu avec Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/xgboost_census_explanations/xgboost-census-debugger-rules.html) | XGBoost | XGBoost Régression | [Jeu de données du recensement des adultes](https://archive.ics.uci.edu/ml/datasets/adult) | Apprenez à utiliser le hook Debugger et les règles intégrées pour collecter et visualiser les données tensorielles d'un modèle de XGBoost régression, telles que les valeurs de perte, les fonctionnalités et les valeurs SHAP. |
Pour trouver des visualisations avancées des paramètres de modèle et des cas d'utilisation, consultez la rubrique suivante : [Démonstrations et visualisation avancées de Debugger](debugger-visualization.md).
# Démonstrations et visualisation avancées de Debugger
Les démonstrations suivantes vous guident dans les cas d'utilisation et les scripts de visualisation avancés à l'aide de Debugger.
**Topics**
+ [Modèles d'entraînement et d'élagage avec Amazon SageMaker Experiments et Debugger](#debugger-visualization-video-model-pruning)
+ [[Utilisation du SageMaker Debugger pour surveiller l'entraînement d'un modèle d'autoencodeur convolutif](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/autoencoder_mnist/autoencoder_mnist.html)](#debugger-visualization-autoencoder_mnist)
+ [[Utilisation du SageMaker Debugger pour surveiller les attentions lors de l'entraînement du modèle BERT](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/bert_attention_head_view/bert_attention_head_view.html)](#debugger-visualization-bert_attention_head_view)
+ [[Utiliser SageMaker Debugger pour visualiser des cartes d'activation de classes dans des réseaux neuronaux convolutifs () CNNs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/cnn_class_activation_maps/cnn_class_activation_maps.html)](#debugger-visualization-cnn_class_activation_maps)
## Modèles d'entraînement et d'élagage avec Amazon SageMaker Experiments et Debugger
*Dr. Nathalie Rauschmayr, chercheuse AWS appliquée \$1 Durée : 49 minutes 26 secondes*
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/Tnv6HsT1r4I)
Découvrez comment Amazon SageMaker Experiments et Debugger peuvent simplifier la gestion de vos tâches de formation. Amazon SageMaker Debugger fournit une visibilité transparente sur les tâches de formation et enregistre les indicateurs de formation dans votre compartiment Amazon S3. SageMaker Experiments vous permet d'appeler les informations de formation sous forme d'*essais* via SageMaker Studio et permet de visualiser le travail de formation. Cela contribue à préserver la qualité élevée du modèle tout en réduisant les paramètres moins importants en fonction du niveau d'importance.
Cette vidéo présente une technique d'*élagage de modèles* qui rend les modèles ResNet 50 et AlexNet modèles préentraînés plus légers et abordables tout en respectant des normes élevées en matière de précision des modèles.
SageMaker AI Estimator entraîne les algorithmes fournis par le zoo de PyTorch modèles dans un PyTorch framework AWS Deep Learning Containers, et Debugger extrait les métriques d'entraînement du processus d'entraînement.
La vidéo montre également comment configurer une règle personnalisée du Debugger pour vérifier la précision d'un modèle élagué, pour déclencher un CloudWatch événement Amazon et une AWS Lambda fonction lorsque la précision atteint un seuil, et pour arrêter automatiquement le processus d'élagage afin d'éviter les itérations redondantes.
Les objectifs d'apprentissage sont les suivants :
+ Découvrez comment utiliser l' SageMaker IA pour accélérer la formation des modèles de machine learning et améliorer la qualité des modèles.
+ Découvrez comment gérer les itérations d'entraînement avec SageMaker Experiments en capturant automatiquement les paramètres d'entrée, les configurations et les résultats.
+ Découvrir comment Debugger rend le processus d'entraînement transparent en capturant automatiquement les données des tenseurs en temps réel à partir de métriques telles que les pondérations, les gradients et les sorties d'activation des réseaux de neurones convolutifs.
+ CloudWatch À utiliser pour déclencher Lambda lorsque Debugger détecte des problèmes.
+ Maîtrisez le processus de SageMaker formation à l'aide d' SageMaker Experiments et de Debugger.
Vous trouverez les blocs-notes et les scripts de formation utilisés dans cette vidéo de [SageMaker Debugger PyTorch Iterative](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_iterative_model_pruning) Model Pruning.
L'image suivante montre comment le processus d'élagage itératif du modèle réduit la taille de AlexNet en supprimant les 100 filtres les moins significatifs en fonction du rang d'importance évalué par les résultats d'activation et les dégradés.
Le processus de réduction a réduit le nombre initial de 50 millions de paramètres à 18 millions. Il a également réduit la taille estimée du modèle de 201 Mo à 73 Mo.
![\[Image contenant des visualisations du résultat de la réduction du modèle\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-model-pruning-results-alexnet.gif)
Vous devez également suivre la précision du modèle. L'image suivante montre comment tracer le processus d'élagage du modèle pour visualiser les modifications de la précision du modèle en fonction du nombre de paramètres dans SageMaker Studio.
![\[Une image de visualisation des tenseurs à l'aide du débogueur dans Studio SageMaker\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-model-pruning-studio.png)
Dans SageMaker Studio, choisissez l'onglet **Experiments**, sélectionnez une liste de tenseurs enregistrés par Debugger lors du processus d'élagage, puis composez un panneau de liste des composants d'**essai**. Sélectionnez les dix itérations et choisissez **Add chart (Ajouter un graphique)** pour créer un **Trial Component Chart** (Graphique de composants d'essai). Une fois que vous avez choisi le modèle à déployer, choisissez le composant d'essai et un menu permettant d'effectuer une action ou choisissez **Deploy model** (Déployer le modèle).
**Note**
Pour déployer un modèle via SageMaker Studio à l'aide de l'exemple de bloc-notes suivant, ajoutez une ligne à la fin de la `train` fonction dans le `train.py` script.
```
# In the train.py script, look for the train function in line 58.
def train(epochs, batch_size, learning_rate):
...
print('acc:{:.4f}'.format(correct/total))
hook.save_scalar("accuracy", correct/total, sm_metric=True)
# Add the following code to line 128 of the train.py script to save the pruned models
# under the current SageMaker Studio model directory
torch.save(model.state_dict(), os.environ['SM_MODEL_DIR'] + '/model.pt')
```
## [Utilisation du SageMaker Debugger pour surveiller l'entraînement d'un modèle d'autoencodeur convolutif](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/autoencoder_mnist/autoencoder_mnist.html)
Ce bloc-notes montre comment SageMaker Debugger visualise les tenseurs issus d'un processus d'apprentissage non supervisé (ou autosupervisé) sur un jeu de données d'images MNIST contenant des nombres écrits à la main.
Le modèle d'entraînement de ce bloc-notes est un autoencodeur convolutif avec le framework. MXNet L’auto-encodeur convolutif a un réseau neuronal convolutif en forme de goulet d’étranglement qui se compose d’une partie encodeur et d’une partie décodeur.
L'encodeur de cet exemple comporte deux couches de convolution pour produire une représentation compressée (variables latentes) des images en entrée. Dans ce cas, l'encodeur produit une variable latente de taille (1, 20) à partir d'une image d'entrée d'origine de taille (28, 28) et réduit considérablement la taille des données pour l'entraînement, de l'ordre de 40 fois.
Le décodeur dispose de deux couches *déconvolutives* et garantit que les variables latentes conservent les informations clés en reconstruisant les images de sortie.
L'encodeur convolutif alimente les algorithmes de clustering avec une taille de données d'entrée plus petite, ainsi que les performances des algorithmes de clustering tels que k-moyennes (k-means), k-nn et T-SNE (Stochastic Neighbor Embedding) distribuée.
Cet exemple de bloc-notes montre comment visualiser les variables latentes à l'aide de Debugger, comme illustré dans l'animation suivante. Il montre également comment l'algorithme T-SNE classe les variables latentes en dix groupes et les projette dans un espace à deux dimensions. Le diagramme de points en couleur situé sur la droite de l'image reflète les vraies valeurs pour montrer l'efficacité de l'organisation des variables latentes dans les clusters par le modèle BERT et l'algorithme T-SNE.
![\[Image conceptuelle de l'auto-encodeur convolutif\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-cnn-autoencoder-plot.gif)
## [Utilisation du SageMaker Debugger pour surveiller les attentions lors de l'entraînement du modèle BERT](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/bert_attention_head_view/bert_attention_head_view.html)
Le modèle BERT (Bidirectional Encode Representations from Transformers) est un modèle de représentation linguistique. Comme le reflète son nom, le modèle BERT s'appuie sur l'*apprentissage par transfert* et sur le *modèle de transformateur* pour le traitement du langage naturel.
Le modèle BERT est préentraîné pour des tâches non supervisées, comme la prédiction des mots manquants dans une phrase ou la prédiction de la phrase qui suit naturellement une phrase. Les données d'entraînement contiennent 3,3 milliards de mots (jetons) de texte anglais, provenant de sources telles que Wikipédia et des livres électroniques. Pour vous donner un exemple simple, le modèle BERT peut accorder une grande *attention* aux jetons de verbe appropriés ou aux jetons de pronom d'un jeton sujet.
Le modèle BERT préentraîné peut être affiné avec une couche de sortie supplémentaire pour permettre l'entraînement du state-of-the-art modèle dans les tâches NLP, telles que les réponses automatisées aux questions, la classification de texte, etc.
Debugger collecte les tenseurs du processus de réglage précis. Dans le contexte du traitement du langage naturel, la pondération des neurones est appelée *attention*.
Ce carnet explique comment utiliser le [modèle BERT préentraîné du zoo de modèles GluonNLP sur l'ensemble](https://gluon-nlp.mxnet.io/model_zoo/bert/index.html) de données de questions et réponses de Stanford et comment SageMaker configurer Debugger pour surveiller le travail de formation.
Le tracé des *scores d'attention* et des neurones individuels dans la requête et les vecteurs clés peut aider à identifier les causes de prédictions erronées du modèle. Avec SageMaker AI Debugger, vous pouvez récupérer les tenseurs et tracer la *vue attention-tête* en temps réel au fur et à mesure de la progression de l'entraînement et comprendre ce que le modèle apprend.
L'animation suivante montre les scores d'attention des 20 premiers jetons d'entrée pour dix itérations dans la tâche d'entraînement fournie dans l'exemple de bloc-notes.
![\[Animation des scores d'attention\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-attention_scores.gif)
## [Utiliser SageMaker Debugger pour visualiser des cartes d'activation de classes dans des réseaux neuronaux convolutifs () CNNs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/cnn_class_activation_maps/cnn_class_activation_maps.html)
Ce bloc-notes explique comment utiliser SageMaker Debugger pour tracer des cartes d'activation de classes pour la détection et la classification d'images dans des réseaux neuronaux convolutifs (). CNNs En apprentissage profond, un *réseau neuronal convolutif (CNN ou ConvNet)* est une classe de réseaux neuronaux profonds, le plus souvent utilisés pour analyser des images visuelles. Les voitures autonomes illustrent une application qui adopte les cartes d'activation de classes. En effet, elles nécessitent la détection instantanée et la classification des images telles que les panneaux de signalisation, les routes et les obstacles.
Dans ce bloc-notes, le PyTorch ResNet modèle est entraîné sur [le jeu de données allemand sur les panneaux de signalisation](http://benchmark.ini.rub.de/), qui contient plus de 40 catégories d'objets liés au trafic et plus de 50 000 images au total.
![\[Animation de carte d'activation des classes dans les réseaux de neurones convolutifs\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-cnn-class-activation-maps.gif)
Au cours du processus de formation, SageMaker Debugger collecte des tenseurs pour tracer les cartes d'activation des classes en temps réel. Comme illustré dans l'image animée, la carte d'activation des classes (également appelée *carte de saillance*) met en évidence les régions à forte activation en rouge.
À l'aide des tenseurs capturés par Debugger, vous pouvez visualiser l'évolution de la carte d'activation au cours de l'entraînement du modèle. Le modèle commence par détecter le bord dans le coin inférieur gauche au début de la tâche d'entraînement. Au fur et à mesure de la progression de l'entraînement, l'attention se déplace vers le centre et détecte le panneau de limite de vitesse. Le modèle prédit à juste titre que la classe de l'image d'entrée est la classe 3, à savoir une classe pour les panneaux de limite de vitesse de 60 km/h, avec un niveau de confiance de 97 %.
# 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)
# Liste des règles intégrées à Debugger
Vous pouvez utiliser les règles intégrées à Debugger fournies par Amazon SageMaker Debugger pour analyser les métriques et les tenseurs collectés lors de l’entraînement de vos modèles. Vous trouverez ci-dessous la liste des règles du débogueur, notamment des informations et un exemple de configuration et de déploiement de chaque règle intégrée.
Les règles intégrées de Debugger contrôlent diverses conditions communes qui sont essentielles à la réussite d'une tâche d'entraînement. Vous pouvez appeler les règles intégrées à l'aide du [kit SDK Python Amazon SageMaker](https://sagemaker.readthedocs.io/en/stable) ou des opérations d'API SageMaker de bas niveau.
L'utilisation des règles intégrées n'entraîne aucun coût supplémentaire. Pour plus d'informations sur la facturation, consultez la page [Tarification d'Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/).
**Note**
Le nombre maximal de règles intégrées que vous pouvez associer à une tâche d'entraînement est de 20. SageMaker Debugger gère entièrement les règles intégrées et analyse votre tâche d'entraînement de façon synchrone.
**Important**
Pour utiliser les nouvelles fonctions de Debugger, vous devez mettre à niveau le kit SDK Python SageMaker et la bibliothèque cliente SMDebug. Dans votre noyau iPython, bloc-notes Jupyter ou environnement JupyterLab, exécutez le code suivant pour installer les dernières versions des bibliothèques et redémarrer le noyau.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Règle Debugger
Les règles suivantes sont les règles intégrées Debugger qui peuvent être appelées à l'aide de la méthode de classe `Rule.sagemaker`.
Règles intégrées à Debugger pour la génération de rapports d'entraînement
| Domaine de validité | Règles intégrées |
| --- | --- |
| Rapport d’entraînement pour les tâches d’entraînement SageMaker AI XGboost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-rules.html) |
Règles intégrées à Debugger pour le débogage des données d'entraînement de modèle (tenseurs de sortie)
| Domaine de validité | Règles intégrées |
| --- | --- |
| Cadres de deep learning (TensorFlow, Apache MXNet et PyTorch) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Cadres de deep learning (TensorFlow, MXNet et PyTorch) et algorithme XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Applications de deep learning | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Algorithme XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-rules.html) |
**Pour utiliser les règles intégrées avec les valeurs de paramètre par défaut**, utilisez le format de configuration suivant :
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
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())
]
```
**Pour utiliser les règles intégrées avec la personnalisation des valeurs des paramètres,** utilisez le format de configuration suivant :
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
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"
}
)
]
)
]
```
Pour voir les clés disponibles pour le paramètre `rule_parameters`, consultez les tables de description des paramètres.
Des exemples de codes de configuration de règle sont fournis pour chaque règle intégrée sous les tables de description des paramètres.
+ Pour obtenir des instructions complètes et des exemples d’utilisation des règles intégrées Debugger, consultez [Exemple de code pour les règles intégrées Debugger](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Pour obtenir des instructions complètes sur l'utilisation des règles intégrées avec les opérations d'API SageMaker de bas niveau, consultez [Configurer le débogueur à l'aide de l'API SageMaker](debugger-createtrainingjob-api.md).
## CreateXgboostReport
La règle CreateXgBoostReport collecte les tenseurs de sortie à partir d'une tâche d'entraînement XGBoost et génère automatiquement un rapport d'entraînement complet. Vous pouvez télécharger un rapport de profilage complet pendant qu'une tâche d'entraînement est en cours d'exécution ou une fois la tâche d'entraînement terminée, et vérifier l'avancement de l'entraînement ou le résultat final de la tâche d'entraînement. La règle CreateXgboostReport collecte par défaut les tenseurs de sortie suivants :
+ `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
Description des paramètres de la règle CreateXgboostReport
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
```
rules=[
Rule.sagemaker(
rule_configs.create_xgboost_report()
)
]
```
## DeadRelu
Cette règle détecte les cas où le pourcentage de fonctions d'activation d'unité ReLU (unité linéaire rectifiée) dans un essai est considéré comme mort parce que leur activité d'activation est descendue sous un seuil. Si le pourcentage d'unités ReLU inactives dans une couche est supérieur à la valeur `threshold_layer` d'unités ReLU inactives, la règle renvoie `True`.
Description des paramètres de la règle DeadRelu
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| tensor\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : `".*relu_output"` |
| threshold\$1inactivity | Définit un niveau d'activité sous lequel une unité ReLU est considérée morte. Une unité ReLU peut être active au début d'un essai, puis peut mourir lentement au cours du processus d'entraînement. Si l'unité ReLU est active au-dessous de `threshold_inactivity`, elle est considérée comme morte. **Facultatif** Valeurs valides : valeur flottante Valeurs par défaut : `1.0` (en pourcentage) |
| threshold\$1layer | Renvoie `True` si le pourcentage d'unités ReLU inactives dans une couche est supérieur à `threshold_layer`. Renvoie `False` si le pourcentage d'unités ReLU inactives dans une couche est inférieur à `threshold_layer`. **Facultatif** Valeurs valides : valeur flottante Valeurs par défaut : `50.0` (en pourcentage) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.dead_relu(),
rule_parameters={
"tensor_regex": ".*relu_output|.*ReLU_output",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex: ".*relu_output|.*ReLU_output",
"save_interval": "500"
}
)
]
)
]
```
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
**Note**
Cette règle n'est pas disponible pour l'algorithme XGBoost.
## ExplodingTensor
Cette règle détecte si les tenseurs émis pendant l'entraînement ont des valeurs non finies, infinies ou non numériques (NaN, Not a Number). Si une valeur non finie est détectée, la règle renvoie `True`.
Description des paramètres de la règle ExplodingTensor
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| collection\$1names | Liste des noms de collection dont la règle inspecte les tenseurs. **Facultatif** Valeurs valides : string Valeur par défaut : `None` |
| tensor\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : string Valeur par défaut : `None` |
| only\$1nan | `True` pour contrôler les tenseurs `base_trial` uniquement pour les valeurs `NaN` et non pour l'infini. `False` pour traiter les valeurs `NaN` et l'infini comme des valeurs explosives, et pour les contrôler. **Facultatif** Valeur par défaut : `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.exploding_tensor(),
rule_parameters={
"tensor_regex": ".*gradient",
"only_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
**Note**
Cette règle n'est pas disponible pour l'algorithme XGBoost.
## PoorWeightInitialization
Cette règle détecte si les paramètres de votre modèle ont été mal initialisés.
Une bonne initialisation rompt la symétrie des pondérations et des gradients dans un réseau neuronal, et maintient des variances d'activation proportionnelles entre les couches. Sinon, le réseau neuronal n'apprend pas efficacement. Des initialiseurs comme Xavier visent à maintenir une variance constante entre les activations, ce qui est particulièrement pertinent dans le cadre de l'entraînement de réseaux neuronaux très profonds. Une trop petite initialisation peut conduire à des gradients disparaissant. Une trop grande initialisation peut conduire à des gradients explosifs. Cette règle vérifie la variance des entrées d'activation entre les couches, la distribution des gradients et la convergence des pertes pour les étapes initiales afin de déterminer si un réseau neuronal a été mal initialisé.
Description des paramètres de la règle PoorWeightInitialization
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| activation\$1inputs\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : string Valeur par défaut : `".*relu_input"` |
| threshold | Si le rapport entre les variances minimale et maximale des pondérations par couche dépasse `threshold` à une étape, la règle renvoie `True`. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `10.0` |
| distribution\$1range | Si la différence minimale entre le 5e et le 95e centiles de la distribution des gradients est inférieure à `distribution_range`, la règle renvoie `True`. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `0.001` |
| patience | Nombre d'étapes qu'il convient d'attendre jusqu'à ce que la perte ne soit plus considérée comme décroissante. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `5` |
| steps | Nombre d'étapes analysées par cette règle. En général, vous n'avez besoin de vérifier que les premières itérations. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `10` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.poor_weight_initialization(),
rule_parameters={
"activation_inputs_regex": ".*relu_input|.*ReLU_input",
"threshold": "10.0",
"distribution_range": "0.001",
"patience": "5",
"steps": "10"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex": ".*relu_input|.*ReLU_input",
"save_interval": "500"
}
)
]
)
]
```
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
**Note**
Cette règle n'est pas disponible pour l'algorithme XGBoost.
## SaturatedActivation
Cette règle détecte si les couches d'activation tanh et sigmoïde deviennent saturées. Une couche d'activation est saturée lorsque l'entrée de la couche est proche du maximum ou du minimum de la fonction d'activation. Le minimum et le maximum des fonctions d'activation tanh et sigmoïde sont définis par leurs valeurs `min_threshold` et `max_thresholds` respectives. Si l'activité d'un nœud descend en dessous du pourcentage `threshold_inactivity`, il est considéré saturé. Si un pourcentage supérieur à `threshold_layer` des nœuds sont saturés, la règle renvoie `True`.
Description des paramètres de la règle SaturatedActivation
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| collection\$1names | Liste des noms de collection dont la règle inspecte les tenseurs. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : aucune. |
| tensor\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : string Valeur par défaut : `".*tanh_input\|.*sigmoid_input".` |
| threshold\$1tanh\$1min | Seuils minimum et maximum qui définissent les extrêmes d'entrée d'une fonction d'activation tanh, définis comme : `(min_threshold, max_threshold)`. Les valeurs par défaut sont déterminées en fonction d'un seuil de gradient disparaissant de 0,0000001. **Facultatif** Valeurs valides : valeur flottante Valeurs par défaut : `-9.4999` |
| threshold\$1tanh\$1max | Seuils minimum et maximum qui définissent les extrêmes d'entrée d'une fonction d'activation tanh, définis comme : `(min_threshold, max_threshold)`. Les valeurs par défaut sont déterminées en fonction d'un seuil de gradient disparaissant de 0,0000001. **Facultatif** Valeurs valides : valeur flottante Valeurs par défaut : `9.4999` |
| threshold\$1sigmoid\$1min | Seuils minimum et maximum qui définissent les extrêmes d'entrée d'une fonction d'activation sigmoïde, définis comme : `(min_threshold, max_threshold)`. Les valeurs par défaut sont déterminées en fonction d'un seuil de gradient disparaissant de 0,0000001. **Facultatif** Valeurs valides : valeur flottante Valeurs par défaut : `-23` |
| threshold\$1sigmoid\$1max | Seuils minimum et maximum qui définissent les extrêmes d'entrée d'une fonction d'activation sigmoïde, définis comme : `(min_threshold, max_threshold)`. Les valeurs par défaut sont déterminées en fonction d'un seuil de gradient disparaissant de 0,0000001. **Facultatif** Valeurs valides : valeur flottante Valeurs par défaut : `16.99999` |
| threshold\$1inactivity | Pourcentage d'inactivité sous lequel la couche d'activation est considérée comme saturée. L'activation peut être active au début d'un essai, puis devenir lentement moins active au cours du processus d'entraînement. **Facultatif** Valeurs valides : valeur flottante Valeurs par défaut : `1.0` |
| threshold\$1layer | Renvoie `True` si le nombre d'activations saturées dans une couche est supérieur au pourcentage `threshold_layer`. Renvoie `False` si le nombre d'activations saturées dans une couche est inférieur au pourcentage `threshold_layer`. **Facultatif** Valeurs valides : valeur flottante Valeurs par défaut : `50.0` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.saturated_activation(),
rule_parameters={
"tensor_regex": ".*tanh_input|.*sigmoid_input",
"threshold_tanh_min": "-9.4999",
"threshold_tanh_max": "9.4999",
"threshold_sigmoid_min": "-23",
"threshold_sigmoid_max": "16.99999",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_activations_collection",
parameters={
"include_regex": ".*tanh_input|.*sigmoid_input"
"save_interval": "500"
}
)
]
)
]
```
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
**Note**
Cette règle n'est pas disponible pour l'algorithme XGBoost.
## VanishingGradient
Cette règle détecte si les gradients d'un essai deviennent extrêmement faibles ou atteignent une grandeur nulle. Si la moyenne des valeurs absolues des gradients descend en dessous d'un `threshold` spécifié, la règle renvoie `True`.
Description des paramètres de la règle VanishingGradient
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| threshold | Valeur à laquelle le gradient est considéré comme disparaissant.**Facultatif**Valeurs valides : valeur flottanteValeur par défaut : `0.0000001`. |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.vanishing_gradient(),
rule_parameters={
"threshold": "0.0000001"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
**Note**
Cette règle n'est pas disponible pour l'algorithme XGBoost.
## WeightUpdateRatio
Cette règle assure le suivi du rapport entre les mises à jour et les pondérations pendant l'entraînement et détecte si ce rapport devient trop grand ou trop petit. Si le rapport entre les mises à jour et les pondérations est supérieur à `large_threshold value` ou s'il est inférieur à `small_threshold`, la règle renvoie `True`.
Les conditions d'entraînement sont les meilleures lorsque les mises à jour sont proportionnelles aux gradients. Des mises à jour excessivement grandes peuvent éloigner les pondérations des valeurs optimales, et des mises à jour très petites entraînent une convergence très lente. Cette règle exige que les pondérations soient disponibles pour deux étapes d'entraînement. Le paramètre `train.save_interval` doit donc être égal à `num_steps`.
Description des paramètres de la règle WeightUpdateRatio
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| num\$1steps | Nombre d'étapes dans lesquelles la règle vérifie si le tenseur a changé. Nombre d'étapes dans lesquelles vous souhaitez comparer les rapports de pondération. Si vous ne transmettez aucune valeur, la règle s'exécute par défaut sur l'étape actuelle et l'étape enregistrée immédiatement avant. Si vous remplacez la valeur par défaut en passant une valeur pour ce paramètre, la comparaison est effectuée entre les pondérations à l'étape `s` et à une étape `>= s - num_steps`. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `None` |
| large\$1threshold | Valeur maximale que le rapport entre les mises à jour et la pondération peut prendre avant que la règle renvoie `True`. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `10.0` |
| small\$1threshold | Valeur minimale que le rapport entre les mises à jour et la pondération peut prendre sous laquelle la règle renvoie `True`. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `0.00000001` |
| epsilon | Petite constante utilisée pour s'assurer que Debugger ne divise pas par zéro lors du calcul du rapport entre les mises à jour et la pondération. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `0.000000001` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.weight_update_ratio(),
rule_parameters={
"num_steps": "100",
"large_threshold": "10.0",
"small_threshold": "0.00000001",
"epsilon": "0.000000001"
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"train.save_interval": "100"
}
)
]
)
]
```
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
**Note**
Cette règle n'est pas disponible pour l'algorithme XGBoost.
## AllZero
Cette règle détecte si la totalité ou un pourcentage spécifié des valeurs dans les tenseurs sont nulles.
Cette règle peut être appliquée à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost. Vous devez spécifier le paramètre `collection_names` ou `tensor_regex`. Si les deux paramètres sont spécifiés, la règle inspecte l'union des tenseurs à partir des deux ensembles.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle AllZero
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| collection\$1names | Liste des noms de collection dont la règle inspecte les tenseurs. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : `None` |
| tensor\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : `None` |
| threshold | Spécifie le pourcentage des valeurs du tenseur qui doivent être nulles pour que cette règle soit invoquée. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : 100 (en pourcentage) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.all_zero(),
rule_parameters={
"tensor_regex": ".*",
"threshold": "100"
},
collections_to_save=[
CollectionConfig(
name="all",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## ClassImbalance
Cette règle mesure les déséquilibres d'échantillonnage entre les classes et génère des erreurs si le déséquilibre dépasse un seuil ou si trop d'erreurs de prédiction pour les classes sous-représentées se produisent en raison du déséquilibre.
Les modèles de classification exigent des classes bien équilibrées dans le jeu de données d'entraînement ou une pondération/un échantillonnage correct des classes pendant l'entraînement. La règle effectue les vérifications suivantes :
+ Elle compte les occurrences par classe. Si le rapport des nombres d'échantillons entre la plus petite classe et la plus grande classe est supérieur à `threshold_imbalance`, une erreur est levée.
+ Elle vérifie la précision des prédictions par classe. Si le rééchantillonnage ou la pondération n'ont pas été appliqués correctement, le modèle peut atteindre une grande précision pour la classe avec de nombreux échantillons d'entraînement mais une faible précision pour les classes avec peu d'échantillons d'entraînement. Si une fraction de fausses prédictions pour une certaine classe dépasse `threshold_misprediction`, une erreur est générée.
Cette règle peut être appliquée à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle ClassImbalance
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| threshold\$1imbalance | Déséquilibre acceptable entre le nombre d'échantillons dans la catégorie la plus petite et dans la catégorie la plus grande. Le dépassement de cette valeur de seuil génère une erreur. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `10` |
| threshold\$1misprediction | Limite de la fraction de fausses prédictions permise pour chaque classe. Le dépassement de ce seuil génère une erreur. Les classes sous-représentées risquent le plus de franchir ce seuil. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `0.7` |
| samples | Nombre d'étiquettes à traiter avant qu'un déséquilibre soit évalué. La règle peut ne pas être déclenchée tant qu'elle n'a pas vu suffisamment d'échantillons dans plusieurs étapes. Plus votre jeu de données contient de classes, plus le nombre `sample` doit être grand. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `500` (dans l'hypothèse d'un jeu de données comme MNIST avec 10 classes) |
| argmax | Si `True`, [np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) est appliqué au tenseur de prédiction. Obligatoire lorsque vous avez un vecteur de probabilités pour chaque classe. Il est utilisé pour déterminer quelle classe a la probabilité la plus élevée. **Conditionnel** Valeurs valides : booléen Valeur par défaut : `False` |
| labels\$1regex | Nom du tenseur qui contient les étiquettes. **Facultatif** Valeurs valides : string Valeur par défaut : `".*labels"` |
| predictions\$1regex | Nom du tenseur qui contient les prédictions. **Facultatif** Valeurs valides : string Valeur par défaut : `".*predictions"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.class_imbalance(),
rule_parameters={
"threshold_imbalance": "10",
"threshold_misprediction": "0.7",
"samples": "500",
"argmax": "False",
"labels_regex": ".*labels",
"predictions_regex": ".*predictions"
},
collections_to_save=[
CollectionConfig(
name="custom_output_collection",
parameters={
"include_regex": ".*labels|.*predictions",
"save_interval": "500"
}
)
]
)
]
```
## LossNotDecreasing
Cette règle détecte lorsque la perte ne diminue pas en valeur à un taux adéquat. Ces pertes doivent être des scalaires.
Cette règle peut être appliquée à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost. Vous devez spécifier le paramètre `collection_names` ou `tensor_regex`. Si les deux paramètres sont spécifiés, la règle inspecte l'union des tenseurs à partir des deux ensembles.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle LossNotDecreasing
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| collection\$1names | Liste des noms de collection dont la règle inspecte les tenseurs. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : `None` |
| tensor\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : `None` |
| use\$1losses\$1collection | Si ce paramètre a pour valeur `True`, il recherche les pertes dans la collection nommée « pertes » lorsque cette collection est présente. **Facultatif** Valeurs valides : booléen Valeur par défaut : `True` |
| num\$1steps | Nombre minimal d'étapes après lesquelles la règle vérifie si la perte a diminué. L'évaluation de la règle se produit toutes les `num_steps` étapes. La règle compare la perte pour cette étape avec la perte à une étape qui se trouve au moins `num_steps` étapes derrière l'étape actuelle. Par exemple, supposons que la perte soit enregistrée toutes les trois étapes, mais que le paramètre `num_steps` soit défini sur 10. À l'étape 21, la perte pour l'étape 21 est comparée à la perte pour l'étape 9. L'étape suivante à laquelle la perte est vérifiée est l'étape 33, car dix étapes après l'étape 21, il y a l'étape 31, et aux étapes 31 et 32, la perte n'est pas enregistrée. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `10` |
| diff\$1percent | Différence minimale en pourcentage par laquelle la perte devrait diminuer entre `num_steps`. **Facultatif** Valeurs valides : `0.0` < valeur flottante < `100` Valeur par défaut : `0.1` (en pourcentage) |
| increase\$1threshold\$1percent | Pourcentage maximal de perte autorisé en cas d'augmentation de la perte **Facultatif** Valeurs valides : `0` < valeur flottante < `100` Valeur par défaut : `5` (en pourcentage) |
| mode | Nom du mode Debugger d'interrogation des valeurs de tenseur pour la vérification des règles. Si la vérification n'a pas abouti, la règle vérifie par défaut et dans cet ordre les valeurs `mode.EVAL`, puis `mode.TRAIN`, puis `mode.GLOBAL`. **Facultatif** Valeurs valides : Chaîne (`EVAL`, `TRAIN` ou `GLOBAL`) Valeur par défaut : `GLOBAL` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.loss_not_decreasing(),
rule_parameters={
"tensor_regex": ".*",
"use_losses_collection": "True",
"num_steps": "10",
"diff_percent": "0.1",
"increase_threshold_percent": "5",
"mode": "GLOBAL"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## Overfit
Cette règle détecte si votre modèle est surajusté aux données d'entraînement en comparant les pertes de validation et d'entraînement.
Cette règle peut être appliquée à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
**Note**
Une façon standard d'éviter le surajustement est de régulariser votre modèle.
Description des paramètres de la règle Overfit
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| tensor\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : aucune. |
| start\$1step | Étape à partir de laquelle commencer à comparer la perte de validation et d'entraînement. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `0` |
| patience | Nombre d'étapes pour lesquelles `ratio_threshold` est autorisé à dépasser la valeur définie avant que le modèle ne soit considéré comme surajusté. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `1` |
| ratio\$1threshold | Rapport maximal entre la différence entre la perte moyenne de validation et la perte moyenne d'entraînement, et la perte moyenne d'entraînement. Si ce seuil est dépassé pour un nombre d'étapes égal à `patience`, le modèle est surajusté et la règle renvoie `True`. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overfit(),
rule_parameters={
"tensor_regex": ".*",
"start_step": "0",
"patience": "1",
"ratio_threshold": "0.1"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
)
]
```
## Overtraining
Cette règle détecte si un modèle est surentraîné. Après un certain nombre d'itérations d'entraînement sur un modèle performant (les pertes d'entraînement et de validation diminuent), le modèle s'approche d'un minimum de la fonction de perte et ne s'améliore plus. Si le modèle poursuit l'entraînement, il peut arriver que la perte de validation commence à augmenter, car le modèle commence à se surajuster. Cette règle définit des seuils et des conditions pour déterminer si le modèle ne s'améliore pas, et empêche les problèmes de surajustement dus à un surentraînement.
Cette règle peut être appliquée à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
**Note**
Le surentraînement peut être évité par un arrêt anticipé. Pour plus d’informations sur l’arrêt anticipé, consultez [Arrêter de manière précoce des tâches d'entraînement](automatic-model-tuning-early-stopping.md). Pour obtenir un exemple décrivant l’utilisation de l’entraînement Spot avec Debugger, consultez [Enable Spot Training with Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html).
Description des paramètres de la règle Overtraining
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| patience\$1train | Nombre d'étapes à attendre avant que la perte d'entraînement soit considérée comme ne s'améliorant plus. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `5` |
| patience\$1validation | Nombre d'étapes à attendre avant que la perte de validation soit considérée comme ne s'améliorant plus.**Facultatif**Valeurs valides : nombre entierValeur par défaut : `10` |
| delta | Seuil minimal correspondant à l'ampleur par laquelle l'erreur devrait s'améliorer avant qu'elle soit considérée comme une erreur optimale. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `0.01` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overtraining(),
rule_parameters={
"patience_train": "5",
"patience_validation": "10",
"delta": "0.01"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## SimilarAcrossRuns
Cette règle compare les tenseurs collectés à partir d'un essai de base à ceux issus d'un autre essai.
Cette règle peut être appliquée à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle SimilarAcrossRuns
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| other\$1trials | Nom de tâche d'entraînement terminée dont vous souhaitez comparer les tenseurs à ceux collectés à partir de l'essai `base_trial` actuel. **Obligatoire** Valeurs valides : string |
| collection\$1names | Liste des noms de collection dont la règle inspecte les tenseurs. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : aucune. |
| tensor\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : aucune. |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.similar_across_runs(),
rule_parameters={
"other_trials": "",
"collection_names": "losses",
"tensor_regex": ".*"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## StalledTrainingRrule
StalledTrainingRule détecte si la tâche d'entraînement ne présente pas de progrès. Cette dernière s'arrête si la règle se déclenche. Cette règle exige que les tenseurs soient enregistrés périodiquement dans un intervalle de temps défini par son paramètre `threshold`. Elle continue de contrôler les nouveaux tenseurs, et si aucun nouveau tenseur n'a été émis pour la règle d'intervalle de seuil, elle est déclenchée.
Description des paramètres de la règle StalledTrainingRule
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| threshold | Seuil qui définit le temps en secondes pendant lequel la règle attend une sortie de tenseur avant de déclencher un problème de blocage d'entraînement. La valeur par défaut est 1 800 secondes. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `1800` |
| stop\$1training\$1on\$1fire | Si la règle est définie sur `True`, elle surveille si la tâche d'entraînement de base génère des tenseurs en « `threshold` » secondes. **Facultatif** Valeurs valides : booléen Valeur par défaut : `False` |
| training\$1job\$1name\$1prefix | Préfixe du nom de la tâche d'entraînement de base. Si la valeur de `stop_training_on_fire` est true, la règle recherche les tâches d'entraînement SageMaker avec ce préfixe dans le même compte. Si une inactivité est détectée, la règle prend une action `StopTrainingJob`. Notez que si plusieurs tâches ont été trouvées avec le même préfixe, la règle ignore l'arrêt. Il est important que chaque tâche d'entraînement ait un préfixe unique. **Facultatif** Valeurs valides : string |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "1800",
"stop_training_on_fire": "True",
"training_job_name_prefix": ""
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TensorVariance
Cette règle détecte si vous avez des tenseurs avec des variances très élevées ou très faibles. Des variances très élevées ou faibles dans un tenseur peuvent conduire à une saturation neuronale et réduire la capacité d'apprentissage du réseau neuronal. Une variance très élevée dans les tenseurs peut aussi éventuellement conduire à l'explosion des tenseurs. Utilisez cette règle pour détecter rapidement ces problèmes.
Cette règle peut être appliquée à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost. Vous devez spécifier le paramètre `collection_names` ou `tensor_regex`. Si les deux paramètres sont spécifiés, la règle inspecte l'union des tenseurs à partir des deux ensembles.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle TensorVariance
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| collection\$1names | Liste des noms de collection dont la règle inspecte les tenseurs. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : aucune. |
| tensor\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : aucune. |
| max\$1threshold | Seuil pour la limite supérieure de la variance des tenseurs. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : aucune. |
| min\$1threshold | Seuil pour la limite inférieure de la variance des tenseurs. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : aucune. |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tensor_variance(),
rule_parameters={
"collection_names": "weights",
"max_threshold": "10",
"min_threshold": "0.00001",
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## UnchangedTensor
Cette règle détecte si un tenseur ne change plus d'une étape à l'autre.
Cette règle exécute la méthode [numpsy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html) pour vérifier si le tenseur ne change pas.
Cette règle peut être appliquée à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost. Vous devez spécifier le paramètre `collection_names` ou `tensor_regex`. Si les deux paramètres sont spécifiés, la règle inspecte l'union des tenseurs à partir des deux ensembles.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle UnchangedTensor
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| collection\$1names | Liste des noms de collection dont la règle inspecte les tenseurs. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : aucune. |
| tensor\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : aucune. |
| num\$1steps | Nombre d'étapes dans lesquelles la règle vérifie si le tenseur a changé. Les `num_steps` dernières étapes disponibles sont vérifiées. Elles n'ont pas besoin d'être consécutives. Si `num_steps` a pour valeur 2, à l'étape s, la règle ne vérifie pas nécessairement s-1 ni s. Si s-1 n'est pas disponible, la règle vérifie la dernière étape disponible ainsi que s. Dans ce cas, elle vérifie la dernière étape disponible avec l'étape actuelle. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `3` |
| rtol | Paramètre de tolérance relative à transmettre à la méthode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `1e-05` |
| atol | Paramètre de tolérance absolue à transmettre à la méthode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `1e-08` |
| equal\$1nan | S'il convient de comparer les valeurs NaN en tant qu'égales. Si `True`, les valeurs NaN du tableau d'entrée a sont considérées comme égales aux valeurs NaN du tableau d'entrée b dans le tableau de sortie. Ce paramètre est transmis à la méthode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Facultatif** Valeurs valides : booléen Valeur par défaut : `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.unchanged_tensor(),
rule_parameters={
"collection_names": "losses",
"tensor_regex": "",
"num_steps": "3",
"rtol": "1e-05",
"atol": "1e-08",
"equal_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## CheckInputImages
Cette règle vérifie si les images d'entrée ont été correctement normalisées. Plus précisément, elle détecte si la moyenne des données d'échantillonnage diffère de plus d'une valeur seuil par rapport à zéro. De nombreux modèles de vision par ordinateur exigent que les données d'entrée aient une variance unitaire et moyenne nulle.
Cette règle s'applique aux applications de deep learning.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle CheckInputImages
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| threshold\$1mean | Seuil qui définit la marge selon laquelle la moyenne des données en entrée peut différer de 0. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `0.2` |
| threshold\$1samples | Nombre d'images qui doivent être échantillonnées avant qu'une erreur puisse être générée. Si la valeur est trop faible, l'estimation de la moyenne du jeu de données est inexacte. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `500` |
| regex | Nom du tenseur de données en entrée. **Facultatif** Valeurs valides : string Valeur par défaut : `".*hybridsequential0_input_0"` (nom du tenseur d'entrée pour les modèles Apache MXNet utilisant HybridSequential) |
| channel | Position du canal de couleur dans le tableau de forme du tenseur d'entrée. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `1` (par exemple, MXNet attend des données d'entrée sous la forme (batch\$1size, channel, height, width)) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.check_input_images(),
rule_parameters={
"threshold_mean": "0.2",
"threshold_samples": "500",
"regex": ".*hybridsequential0_input_0",
"channel": "1"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*hybridsequential0_input_0",
"save_interval": "500"
}
)
]
)
]
```
## NLPSequenceRatio
Cette règle calcule le rapport de jetons spécifiques compte tenu du reste de la séquence d'entrée qui est utile pour optimiser les performances. Par exemple, vous pouvez calculer le pourcentage de jetons de fin de phrase (EOS) de remplissage dans votre séquence d'entrée. Si le nombre de jetons EOS est trop élevé, une autre politique de compartimentage doit être appliquée. Vous pouvez également calculer le pourcentage de jetons inconnus dans votre séquence d'entrée. Si le nombre de mots inconnus est trop élevé, un autre vocabulaire peut être utilisé.
Cette règle s'applique aux applications de deep learning.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle NLPSequenceRatio
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| tensor\$1regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance. **Facultatif** Valeurs valides : liste de chaînes ou chaîne séparée par des virgules Valeur par défaut : `".*embedding0_input_0"` (en supposant une intégration en tant que couche initiale du réseau) |
| token\$1values | Chaîne d'une liste des valeurs numériques des jetons. Par exemple, « 3, 0 ». **Facultatif** Valeurs valides : chaîne de valeurs numériques séparées par des virgules Valeur par défaut : `0` |
| token\$1thresholds\$1percent | Chaîne d'une liste de seuils (pourcentages) correspondant à chaque valeur `token_values`. Par exemple, "50.0, 50.0". **Facultatif** Valeurs valides : chaîne de valeurs flottantes séparées par des virgules Valeur par défaut : `"50"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.nlp_sequence_ratio(),
rule_parameters={
"tensor_regex": ".*embedding0_input_0",
"token_values": "0",
"token_thresholds_percent": "50"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*embedding0_input_0"
}
)
]
)
]
```
## Confusion
Cette règle évalue la validité d'une matrice de confusion pour un problème de classification.
Elle crée une matrice de taille `category_no*category_no` et la remplit avec des données provenant de paires (`labels`, `predictions`). Pour chaque paire (`labels`, `predictions`), le nombre dans `confusion[labels][predictions]` est incrémenté de 1. Lorsque la matrice est entièrement remplie, le rapport entre les valeurs sur la diagonale et les valeurs hors diagonale est évalué comme suit :
+ Pour les éléments sur la diagonale : `confusion[i][i]/sum_j(confusion[j][j])>=min_diag`
+ Pour les éléments hors diagonale : `confusion[j][i])/sum_j(confusion[j][i])<=max_off_diag`
Cette règle peut être appliquée à l'algorithme XGBoost.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle Confusion
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| category\$1no | Nombre de catégories. **Facultatif** Valeurs valides : nombre entier ≥2 Valeur par défaut : `"None"` |
| labels | Collection de tenseurs `labels` ou un vecteur 1-d des étiquettes true. **Facultatif** Valeurs valides : string Valeur par défaut : `"labels"` |
| predictions | Collection de tenseurs `predictions` ou un vecteur 1-d des étiquettes estimées. **Facultatif** Valeurs valides : string Valeur par défaut : `"predictions"` |
| labels\$1collection | La règle inspecte les tenseurs de cette collection pour `labels`. **Facultatif** Valeurs valides : string Valeur par défaut : `"labels"` |
| predictions\$1collection | La règle inspecte les tenseurs de cette collection pour `predictions`. **Facultatif** Valeurs valides : string Valeur par défaut : `"predictions"` |
| min\$1diag | Seuil minimal du rapport des données sur la diagonale. **Facultatif** Valeurs valides : `0`≤valeur flottante≤`1` Valeur par défaut : `0.9` |
| max\$1off\$1diag | Seuil maximal du rapport des données hors diagonale. **Facultatif** Valeurs valides : `0`≤valeur flottante≤`1` Valeur par défaut : `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.confusion(),
rule_parameters={
"category_no": "10",
"labels": "labels",
"predictions": "predictions",
"labels_collection": "labels",
"predictions_collection": "predictions",
"min_diag": "0.9",
"max_off_diag": "0.1"
},
collections_to_save=[
CollectionConfig(
name="labels",
parameters={
"save_interval": "500"
}
),
CollectionConfig(
name="predictions",
parameters={
"include_regex": "500"
}
)
]
)
]
```
**Note**
Cette règle déduit des valeurs par défaut pour les paramètres facultatifs si leurs valeurs ne sont pas spécifiées.
## FeatureImportanceOverweight
Cette règle accumule les pondérations des n valeurs les plus élevées d'importance de la fonction par étape et garantit qu'elles ne dépassent pas le seuil. Par exemple, vous pouvez définir le seuil pour les trois premières fonctions de manière à ce qu'elles ne contiennent pas plus de 80 % des pondérations totales du modèle.
Cette règle n'est valide que pour l'algorithme XGBoost.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle FeatureImportanceOverweight
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| threshold | Définit le seuil de la proportion de la somme cumulée des `n` fonctions les plus grandes. Le nombre `n` est défini par le paramètre `nfeatures`. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `0.8` |
| nfeatures | Nombre de fonctions les plus grandes. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : `3` |
| tensor\$1regex | L'expression régulière (regex) du tenseur nomme la règle à analyser. **Facultatif** Valeurs valides : string Valeur par défaut : `".*feature_importance/weight"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.feature_importance_overweight(),
rule_parameters={
"threshold": "0.8",
"nfeatures": "3",
"tensor_regex": ".*feature_importance/weight"
},
collections_to_save=[
CollectionConfig(
name="feature_importance",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TreeDepth
Cette règle mesure la profondeur des arbres dans un modèle XGBoost. XGBoost rejette les fractionnements s'ils n'améliorent pas la perte. Cela régularise l'entraînement. Par conséquent, l'arbre peut ne pas pousser aussi profondément que cela est défini par le paramètre `depth`.
Cette règle n'est valide que pour l'algorithme XGBoost.
Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).
Description des paramètres de la règle TreeDepth
| Nom du paramètre | Description |
| --- | --- |
| base\$1trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. **Obligatoire** Valeurs valides : string |
| depth | Profondeur de l'arbre. La profondeur de l'arbre est obtenue en calculant le logarithme en base 2 du plus grand ID de nœud. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : `4` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tree_depth(),
rule_parameters={
"depth": "4"
},
collections_to_save=[
CollectionConfig(
name="tree",
parameters={
"save_interval": "500"
}
)
]
)
]
```
# Création de règles personnalisées à l’aide de la bibliothèque client Debugger
Vous pouvez créer des règles personnalisées pour surveiller votre travail de formation à l'aide de la règle Debugger APIs et de la [bibliothèque `smdebug` Python](https://github.com/awslabs/sagemaker-debugger/) open source qui fournit des outils pour créer vos propres conteneurs de règles.
## Prérequis pour créer une règle personnalisée
Pour créer des règles personnalisées Debugger, vous avez besoin des prérequis suivants.
+ [SageMaker Règle du débogueur. API personnalisée](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule.custom)
+ [La bibliothèque Python smdebug open source](https://github.com/awslabs/sagemaker-debugger/)
+ Votre propre script python de règle personnalisée
+ [Image Amazon SageMaker Debugger pour les évaluateurs URIs de règles personnalisés](debugger-reference.md#debuger-custom-rule-registry-ids)
**Topics**
+ [Prérequis pour créer une règle personnalisée](#debugger-custom-rules-prerequisite)
+ [Utilisation de la bibliothèque client `smdebug` pour créer une règle personnalisée sous forme de script Python](debugger-custom-rules-python-script.md)
+ [Utilisez le Debugger APIs pour exécuter vos propres règles personnalisées](debugger-custom-rules-python-sdk.md)
# Utilisation de la bibliothèque client `smdebug` pour créer une règle personnalisée sous forme de script Python
L'API de règle `smdebug` fournit une interface pour configurer vos propres règles personnalisées. Le script python suivant montre comment vous pouvez créer une règle personnalisée, `CustomGradientRule`. La règle personnalisée de ce didacticiel contrôle si les gradients deviennent trop grands. Le seuil par défaut est 10. La règle personnalisée utilise un essai de base créé par un estimateur basé sur l' SageMaker IA lorsqu'il lance une tâche de formation.
```
from smdebug.rules.rule import Rule
class CustomGradientRule(Rule):
def __init__(self, base_trial, threshold=10.0):
super().__init__(base_trial)
self.threshold = float(threshold)
def invoke_at_step(self, step):
for tname in self.base_trial.tensor_names(collection="gradients"):
t = self.base_trial.tensor(tname)
abs_mean = t.reduction_value(step, "mean", abs=True)
if abs_mean > self.threshold:
return True
return False
```
Vous pouvez ajouter autant de classes de règles personnalisées que vous le souhaitez dans le même script python et les déployer dans n'importe quel essai de tâche d'entraînement en créant des objets de règle personnalisée dans la section suivante.
# Utilisez le Debugger APIs pour exécuter vos propres règles personnalisées
L'exemple de code suivant montre comment configurer une règle personnalisée avec le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Cet exemple suppose que le script de règles personnalisées que vous avez créé à l'étape précédente se trouve dans « *path/to/my\$1custom\$1rule.py* ».
```
from sagemaker.debugger import Rule, CollectionConfig
custom_rule = Rule.custom(
name='MyCustomRule',
image_uri='759209512951.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rule-evaluator:latest',
instance_type='ml.t3.medium',
source='path/to/my_custom_rule.py',
rule_to_invoke='CustomGradientRule',
collections_to_save=[CollectionConfig("gradients")],
rule_parameters={"threshold": "20.0"}
)
```
La liste suivante explique les arguments de l'API `Rule.custom` Debugger.
+ `name` (str) : spécifiez un nom de règle personnalisé à votre guise.
+ `image_uri` (str) : il s'agit de l'image du conteneur dont la logique est de comprendre votre règle personnalisée. Celle-ci approvisionne et évalue les collections de tenseurs spécifiées que vous enregistrez dans la tâche d'entraînement. Vous pouvez trouver la liste des images de l'évaluateur de règles d' SageMaker IA open source sur. [Image Amazon SageMaker Debugger pour les évaluateurs URIs de règles personnalisés](debugger-reference.md#debuger-custom-rule-registry-ids)
+ `instance_type` (str) : vous devez spécifier une instance pour créer un conteneur Docker de règles afin d'activer l'instance en parallèle avec un conteneur d'entraînement.
+ `source` (str) : il s'agit du chemin local ou de l'URI Amazon S3 vers votre script de règle personnalisée.
+ `rule_to_invoke`(str) : Ceci spécifie l'implémentation de la classe Rule particulière dans votre script de règles personnalisé. SageMaker L'IA ne prend en charge qu'une seule règle à évaluer à la fois dans une tâche de règles.
+ `collections_to_save` (str) : spécifie les collections de tenseurs que vous allez enregistrer pour l'exécution de la règle.
+ `rule_parameters` (dictionnaire) : accepte les entrées de paramètres dans un format de dictionnaire. Vous pouvez ajuster les paramètres que vous avez configurés dans le script de règle personnalisée.
Après avoir configuré l'`custom_rule`objet, vous pouvez l'utiliser pour créer un estimateur basé sur l' SageMaker IA pour tous les travaux de formation. Spécifiez le point `entry_point` à votre script d'entraînement. Vous n'avez pas besoin de modifier votre script d'entraînement.
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
role=sagemaker.get_execution_role(),
base_job_name='smdebug-custom-rule-demo-tf-keras',
entry_point='path/to/your_training_script.py'
train_instance_type='ml.p2.xlarge'
...
# debugger-specific arguments below
rules = [custom_rule]
)
estimator.fit()
```
Pour plus de variantes et des exemples avancés d'utilisation des règles personnalisées Debugger, consultez les exemples de blocs-notes suivants.
+ [Surveillez votre travail de formation grâce aux règles personnalisées d'Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_keras_custom_rule/tf-keras-custom-rule.html)
+ [PyTorch élagage itératif du modèle de et ResNet AlexNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_iterative_model_pruning)
+ [Déclenchez Amazon CloudWatch Events à l'aide des règles du débogueur pour effectuer une action en fonction de l'état de la formation avec TensorFlow](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_action_on_rule)
# Utilisation de Debugger avec des conteneurs d’entraînement personnalisés
Amazon SageMaker Debugger est disponible pour tous les modèles d'apprentissage profond que vous apportez à Amazon SageMaker AI. L' AWS CLI`Estimator`API SageMaker AI et le Debugger vous APIs permettent d'utiliser n'importe quelle image de base Docker pour créer et personnaliser des conteneurs afin d'entraîner vos modèles. Pour utiliser Debugger avec des conteneurs personnalisés, vous devez apporter un minimum de modifications à votre script d'entraînement afin d'implémenter le rappel de hook Debugger et de récupérer les tenseurs des tâches d'entraînement. Les sections suivantes vous expliqueront comment utiliser Debugger avec des conteneurs d’entraînement personnalisés.
Vous avez besoin des ressources suivantes pour créer un conteneur personnalisé avec Debugger.
+ [Kit de développement logiciel Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable)
+ [La bibliothèque cliente SMDebug open source](https://github.com/awslabs/sagemaker-debugger)
+ Une image de base Docker de votre choix
+ Votre script d'entraînement avec un hook Debugger enregistré (pour en savoir plus sur l'enregistrement d'un hook Debugger à votre script d'entraînement, consultez [Enregistrement du hook Debugger à votre script d’entraînement](#debugger-script-mode)).
Pour un end-to-end exemple d'utilisation de Debugger avec un conteneur de formation personnalisé, consultez l'exemple de bloc-notes suivant.
+ [Création d'un conteneur d'entraînement personnalisé et de tâches d'entraînement de débogage avec Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/build_your_own_container_with_debugger/debugger_byoc.html) (langue française non garantie)
**Astuce**
Ce conteneur personnalisé avec le guide Debugger est une extension du guide [Adaptation de votre propre conteneur d’entraînement](adapt-training-container.md), qui vous explique comment créer et transmettre votre conteneur d'entraînement personnalisé à Amazon ECR.
## Préparation à la création d’un conteneur d’entraînement personnalisé
Pour créer un conteneur docker, la structure de base des fichiers doit ressembler à ce qui suit :
```
├── debugger_custom_container_test_notebook.ipynb # a notebook to run python snippet codes
└── debugger_custom_container_test_folder # this is a docker folder
├── your-training-script.py # your training script with Debugger hook
└── Dockerfile # a Dockerfile to build your own container
```
## Enregistrement du hook Debugger à votre script d’entraînement
Pour déboguer l'entraînement de votre modèle, vous devez ajouter un hook Debugger à votre script d'entraînement.
**Note**
Cette étape est nécessaire pour collecter les paramètres de modèle (tenseurs de sortie) afin de déboguer l'entraînement de votre modèle. Si vous souhaitez uniquement contrôler et profiler, vous pouvez ignorer cette étape d'enregistrement de hook et exclure le paramètre `debugger_hook_config` lorsque vous créez un estimateur.
L'exemple de code suivant montre la structure d'un script d'entraînement utilisant le modèle Keras ResNet 50 et explique comment transmettre le hook Debugger en tant que rappel Keras pour le débogage. Pour trouver un script d'entraînement complet, voir [Script TensorFlow d'entraînement avec crochet SageMaker Debugger](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-debugger/build_your_own_container_with_debugger/docker/tf_keras_resnet_byoc.py).
```
# An example of training script (your-training-script.py)
import tensorflow.compat.v2 as tf
from tensorflow.keras.applications.resnet50 import ResNet50
import smdebug.tensorflow as smd
def train(batch_size, epoch, model, hook):
...
model.fit(X_train, Y_train,
batch_size=batch_size,
epochs=epoch,
validation_data=(X_valid, Y_valid),
shuffle=True,
# smdebug modification: Pass the Debugger hook in the main() as a Keras callback
callbacks=[hook])
def main():
parser=argparse.ArgumentParser(description="Train resnet50 cifar10")
# hyperparameter settings
parser.add_argument(...)
args = parser.parse_args()
model=ResNet50(weights=None, input_shape=(32,32,3), classes=10)
# Add the following line to register the Debugger hook for Keras.
hook=smd.KerasHook.create_from_json_file()
# Start the training.
train(args.batch_size, args.epoch, model, hook)
if __name__ == "__main__":
main()
```
Pour plus d'informations sur l'enregistrement du hook Debugger pour les frameworks et algorithmes pris en charge, consultez les liens suivants dans la bibliothèque SMDebug cliente :
+ [SMDebug TensorFlow crochet](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/tensorflow.md)
+ [SMDebug PyTorch crochet](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/pytorch.md)
+ [SMDebug MXNet crochet](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/mxnet.md)
+ [SMDebug XGBoost crochet](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/xgboost.md)
Dans les exemples de scripts d'entraînement des blocs-notes suivants, vous trouverez d'autres exemples sur la façon d'ajouter les hooks Debugger aux scripts d'entraînement et de collecter les tenseurs de sortie en détail :
+ [Débogueur en mode script avec le framework 2.1 TensorFlow ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/tf2-keras-custom-container.html)
Pour voir la différence entre l'utilisation du débogueur dans un conteneur de Deep Learning et en mode script, ouvrez ce bloc-notes et placez-le côte à côte avec [le débogueur précédent dans un exemple de bloc-notes Deep Learning Container TensorFlow v2.1](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_zero_code_change/tf2-keras-default-container.html).
En mode script, la partie de configuration de hook est supprimée du script dans lequel vous définissez l'estimateur. Au lieu de cela, la fonction Debugger hook est fusionnée dans le script d'entraînement, le script d'[ ResNet entraînement TensorFlow Keras en mode script](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/src/tf_keras_resnet_byoc.py). Le script d'apprentissage importe la `smdebug` bibliothèque dans l'environnement TensorFlow Keras requis pour communiquer avec l'algorithme TensorFlow ResNet 50. Il implémente également manuellement la fonctionnalité du `smdebug` crochet en ajoutant l'`callbacks=[hook]`argument à l'intérieur de la `train` fonction (à la ligne 49) et en ajoutant la configuration manuelle du crochet (à la ligne 89) fournie par le SDK SageMaker Python.
Cet exemple de mode script exécute la tâche d'entraînement dans le framework TF 2.1 pour une comparaison directe avec l'absence de modification de script dans l'exemple TF 2.1. L'avantage de configurer Debugger en mode script est la possibilité de choisir des versions de framework non couvertes par AWS Deep Learning Containers.
+ [Utilisation d'Amazon SageMaker Debugger dans un PyTorch conteneur en mode script](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_custom_container)
Ce bloc-notes active Debugger en mode script dans le framework PyTorch v1.3.1. PyTorchLa v1.3.1 est prise en charge par des conteneurs d' SageMaker IA, et cet exemple montre comment modifier un script d'entraînement.
L' PyTorch estimateur SageMaker AI est déjà en mode script par défaut. Dans le bloc-notes, la ligne permettant d'activer `script_mode` n'est pas incluse dans la configuration de l'estimateur.
Ce bloc-notes indique les étapes détaillées à suivre pour remplacer [le script d' PyTorch entraînement d'origine](https://github.com/pytorch/examples/blob/master/mnist/main.py) par une version modifiée afin d'activer Debugger. En outre, cet exemple montre comment utiliser les règles intégrées du débogueur pour détecter les problèmes d'entraînement tels que la disparition des gradients, et les fonctionnalités d'évaluation du débogueur pour appeler et analyser les tenseurs enregistrés.
## Création et configuration d’un Dockerfile
Ouvrez votre SageMaker IA JupyterLab et créez un nouveau dossier, `debugger_custom_container_test_folder` dans cet exemple, pour enregistrer votre script d'entraînement et`Dockerfile`. L'exemple de code suivant est un `Dockerfile` qui inclut les commandes de création docker essentielles. Collez le code suivant dans le fichier texte `Dockerfile` et enregistrez-le. Téléchargez votre script d'entraînement dans le même dossier.
```
# Specify a docker base image
FROM tensorflow/tensorflow:2.2.0rc2-gpu-py3
RUN /usr/bin/python3 -m pip install --upgrade pip
RUN pip install --upgrade protobuf
# Install required packages to enable the SageMaker Python SDK and the smdebug library
RUN pip install sagemaker-training
RUN pip install smdebug
CMD ["bin/bash"]
```
Si vous souhaitez utiliser une image de conteneur AWS Deep Learning prédéfinie, consultez [Available AWS Deep Learning Containers Images](https://aws.amazon.com/releasenotes/available-deep-learning-containers-images/).
## Création et transmission du conteneur d’entraînement personnalisé à Amazon ECR
Créez un bloc-notes de test, `debugger_custom_container_test_notebook.ipynb`, puis exécutez le code suivant dans la cellule du bloc-notes. Cela permet d'accéder au répertoire `debugger_byoc_test_docker`, de créer le docker avec le nom `algorithm_name` spécifié et de transmettre le conteneur docker à votre Amazon ECR.
```
import boto3
account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = 'sagemaker-debugger-mnist-byoc-tf2'
tag = ':latest'
region = boto3.session.Session().region_name
uri_suffix = 'amazonaws.com'
if region in ['cn-north-1', 'cn-northwest-1']:
uri_suffix = 'amazonaws.com.cn'
byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(account_id, region, uri_suffix, ecr_repository + tag)
!docker build -t $ecr_repository docker
!$(aws ecr get-login --region $region --registry-ids $account_id --no-include-email)
!aws ecr create-repository --repository-name $ecr_repository
!docker tag {ecr_repository + tag} $byoc_image_uri
!docker push $byoc_image_uri
```
**Astuce**
Si vous utilisez l'une des images de base du AWS Deep Learning Container, exécutez le code suivant pour vous connecter à Amazon ECR et accéder au référentiel d'images du Deep Learning Container.
```
! aws ecr get-login-password --region {region} | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com
```
## Exécution et débogage des tâches d’entraînement à l’aide du conteneur d’entraînement personnalisé
Après avoir créé et transféré votre conteneur docker vers Amazon ECR, configurez un estimateur SageMaker AI avec votre script d'entraînement et les paramètres spécifiques au débogueur. Après avoir exécuté `estimator.fit()`, Debugger collecte les tenseurs de sortie, les contrôle et détecte les problèmes d'entraînement. Avec les tenseurs enregistrés, vous pouvez effectuer une analyse plus poussée de la tâche d'entraînement à l'aide des fonctions et outils `smdebug` de base. En configurant un flux de travail de surveillance des règles du débogueur avec Amazon CloudWatch Events AWS Lambda, vous pouvez automatiser un processus d'arrêt de la formation chaque fois que les règles du débogueur détectent des problèmes de formation.
```
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker.debugger import Rule, DebuggerHookConfig, CollectionConfig, rule_configs
profiler_config=ProfilerConfig(...)
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule()),
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=Estimator(
image_uri=byoc_image_uri,
entry_point="./debugger_custom_container_test_folder/your-training-script.py"
role=sagemaker.get_execution_role(),
base_job_name='debugger-custom-container-test',
instance_count=1,
instance_type='ml.p3.2xlarge',
# Debugger-specific parameters
profiler_config=profiler_config,
debugger_hook_config=debugger_hook_config,
rules=rules
)
# start training
estimator.fit()
```
# Configurer le débogueur à l'aide de l'API SageMaker
Les rubriques précédentes se concentrent sur l'utilisation de Debugger via le SDK Amazon SageMaker Python, qui est un wrapper et les opérations d'API. AWS SDK pour Python (Boto3) SageMaker Cela offre une expérience de haut niveau en matière d'accès aux opérations de SageMaker l'API Amazon. Si vous devez configurer manuellement les opérations d' SageMaker API à l'aide de AWS Boto3 ou ( AWS Command Line Interface CLI) pour d'autres SDKs applications, telles que Java, Go et C\$1\$1, cette section explique comment configurer les opérations d'API de bas niveau suivantes.
**Topics**
+ [JSON (AWS CLI)](debugger-built-in-rules-api.CLI.md)
+ [Kit SDK for Python (Boto3)](debugger-built-in-rules-api.Boto3.md)
# JSON (AWS CLI)
Les règles intégrées d'Amazon SageMaker Debugger peuvent être configurées pour une tâche de formation à l'aide des [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)objets [DebugHookConfig[DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html), [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html), et via l'opération de l'[CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API SageMaker AI. Vous devez spécifier le bon URI d'image dans le `RuleEvaluatorImage` paramètre, et les exemples suivants vous expliquent comment configurer les chaînes JSON à demander [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html).
Le code suivant affiche un modèle JSON complet pour exécuter une tâche d'entraînement avec les paramètres requis et les configurations de Debugger. Enregistrez le modèle sous forme de fichier JSON dans votre répertoire de travail et exécutez la tâche de formation à l'aide de la AWS CLI. Par exemple, enregistrez le code suivant sous `debugger-training-job-cli.json`.
**Note**
Assurez-vous d'utiliser les images de conteneur Docker appropriées. Pour trouver des images de AWS Deep Learning Containers, consultez la section Images de [Deep Learning Containers disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Pour obtenir une liste complète des images Docker disponibles pour l'utilisation des règles Debugger, consultez [Images Docker pour les règles Debugger](debugger-reference.md#debugger-docker-images-rules).
```
{
"TrainingJobName": "debugger-aws-cli-test",
"RoleArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-YYYYMMDDT123456",
"AlgorithmSpecification": {
// Specify a training Docker container image URI (Deep Learning Container or your own training container) to TrainingImage.
"TrainingImage": "763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.4.1-gpu-py37-cu110-ubuntu18.04",
"TrainingInputMode": "File",
"EnableSageMakerMetricsTimeSeries": false
},
"HyperParameters": {
"sagemaker_program": "entry_point/tf-hvd-train.py",
"sagemaker_submit_directory": "s3://sagemaker-us-west-2-111122223333/debugger-boto3-profiling-test/source.tar.gz"
},
"OutputDataConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/output"
},
"DebugHookConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/debug-output",
"CollectionConfigurations": [
{
"CollectionName": "losses",
"CollectionParameters" : {
"train.save_interval": "50"
}
}
]
},
"DebugRuleConfigurations": [
{
"RuleConfigurationName": "LossNotDecreasing",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {"rule_to_invoke": "LossNotDecreasing"}
}
],
"ProfilerConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/profiler-output",
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, \"MetricsRegex\": \".*\", }",
"DetailedProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, }",
"PythonProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, \"ProfilerName\": \"cprofile\", \"cProfileTimer\": \"total_time\"}",
"LocalPath": "/opt/ml/output/profiler/"
}
},
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {"rule_to_invoke": "ProfilerReport"}
}
],
"ResourceConfig": {
"InstanceType": "ml.p3.8xlarge",
"InstanceCount": 1,
"VolumeSizeInGB": 30
},
"StoppingCondition": {
"MaxRuntimeInSeconds": 86400
}
}
```
Après avoir enregistré le fichier JSON, exécutez la commande suivante dans votre terminal. (Utilisez `!` au début de la ligne si vous utilisez un bloc-notes Jupyter.)
```
aws sagemaker create-training-job --cli-input-json file://debugger-training-job-cli.json
```
## Pour configurer une règle Debugger pour le débogage des paramètres de modèle
Les exemples de code suivants montrent comment configurer une `VanishingGradient` règle intégrée à l'aide de cette SageMaker API.
**Pour activer Debugger afin de collecter les tenseurs de sortie**
Spécifiez la configuration du hook Debugger comme suit :
```
"DebugHookConfig": {
"S3OutputPath": "s3:////debug-output",
"CollectionConfigurations": [
{
"CollectionName": "gradients",
"CollectionParameters" : {
"save_interval": "500"
}
}
]
}
```
Ainsi, la tâche d'entraînement enregistre la collection de tenseurs, `gradients`, chaque `save_interval` sur 500 étapes. Pour trouver les `CollectionName` valeurs disponibles, consultez la section [Collections intégrées au Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections) dans la documentation de la *bibliothèque SMDebug cliente*. Pour trouver les clés et les valeurs de `CollectionParameters` paramètres disponibles, consultez la [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)classe dans la *documentation du SDK SageMaker Python*.
**Pour activer les règles Debugger pour le débogage des tenseurs de sortie**
L'exemple d'API `DebugRuleConfigurations` suivant montre comment exécuter la règle `VanishingGradient` intégrée sur la collection `gradients` enregistrée.
```
"DebugRuleConfigurations": [
{
"RuleConfigurationName": "VanishingGradient",
"RuleEvaluatorImage": "503895931360.dkr.ecr.us-east-1.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "VanishingGradient",
"threshold": "20.0"
}
}
]
```
Avec une configuration telle que celle de cet exemple, Debugger lance une tâche d'évaluation des règles pour votre tâche d'entraînement à l'aide de la règle `VanishingGradient` sur la collection de tenseurs `gradients`. Pour obtenir une liste complète des images Docker disponibles pour l'utilisation des règles Debugger, consultez [Images Docker pour les règles Debugger](debugger-reference.md#debugger-docker-images-rules). Pour voir les paires clé-valeur pour `RuleParameters`, consultez [Liste des règles intégrées à Debugger](debugger-built-in-rules.md).
## Pour configurer une règle intégrée Debugger pour le profilage des métriques système et de cadre
L'exemple de code suivant montre comment spécifier le fonctionnement de l' ProfilerConfig API pour permettre la collecte des métriques du système et du framework.
**Pour activer le profilage Debugger pour collecter les métriques du système et du framework**
------
#### [ Target Step ]
```
"ProfilerConfig": {
// Optional. Path to an S3 bucket to save profiling outputs
"S3OutputPath": "s3:////profiler-output",
// Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3, \"MetricsRegex\": \".*\" }",
"DetailedProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3 }",
// For PythonProfilingConfig,
// available ProfilerName options: cProfile, Pyinstrument
// available cProfileTimer options only when using cProfile: cpu, off_cpu, total_time
"PythonProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3, \"ProfilerName\": \"cProfile\", \"cProfileTimer\": \"total_time\" }",
// Optional. Local path for profiling outputs
"LocalPath": "/opt/ml/output/profiler/"
}
}
```
------
#### [ Target Time Duration ]
```
"ProfilerConfig": {
// Optional. Path to an S3 bucket to save profiling outputs
"S3OutputPath": "s3:////profiler-output",
// Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10, \"MetricsRegex\": \".*\" }",
"DetailedProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10 }",
// For PythonProfilingConfig,
// available ProfilerName options: cProfile, Pyinstrument
// available cProfileTimer options only when using cProfile: cpu, off_cpu, total_time
"PythonProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10, \"ProfilerName\": \"cProfile\", \"cProfileTimer\": \"total_time\" }",
// Optional. Local path for profiling outputs
"LocalPath": "/opt/ml/output/profiler/"
}
}
```
------
**Pour activer les règles Debugger pour le profilage des métriques**
L'exemple de code suivant montre comment configurer la règle `ProfilerReport`.
```
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "ProfilerReport",
"CPUBottleneck_cpu_threshold": "90",
"IOBottleneck_threshold": "90"
}
}
]
```
Pour obtenir une liste complète des images Docker disponibles pour l'utilisation des règles Debugger, consultez [Images Docker pour les règles Debugger](debugger-reference.md#debugger-docker-images-rules). Pour voir les paires clé-valeur pour `RuleParameters`, consultez [Liste des règles intégrées à Debugger](debugger-built-in-rules.md).
## Mise à jour de la configuration du profilage Debugger à l’aide de l’API `UpdateTrainingJob`
La configuration du profilage du débogueur peut être mise à jour pendant que votre tâche de formation est en cours d'exécution à l'aide de l'opération [UpdateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html)API. Configurez [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)les nouveaux [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)objets et spécifiez le nom de la tâche d'entraînement dans le `TrainingJobName` paramètre.
```
{
"ProfilerConfig": {
"DisableProfiler": boolean,
"ProfilingIntervalInMilliseconds": number,
"ProfilingParameters": {
"string" : "string"
}
},
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "string",
"RuleEvaluatorImage": "string",
"RuleParameters": {
"string" : "string"
}
}
],
"TrainingJobName": "your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS"
}
```
## Ajout de la configuration des règles personnalisées du Debugger à l’API `CreateTrainingJob`
Une règle personnalisée peut être configurée pour une tâche de formation à l'aide [ DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)des objets [ DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)et dans le fonctionnement de l'[ CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API. L'exemple de code suivant montre comment configurer une `ImproperActivation` règle personnalisée écrite avec la bibliothèque *smdebug* à l'aide de cette opération d' SageMaker API. Cet exemple suppose que vous avez écrit la règle personnalisée dans le fichier *custom\$1rules.py* et que vous l'avez chargée dans un compartiment Amazon S3. L'exemple fournit des images Docker préconçues que vous pouvez utiliser pour exécuter vos règles personnalisées. Celles-ci sont énumérées sur la page [Image Amazon SageMaker Debugger pour les évaluateurs URIs de règles personnalisés](debugger-reference.md#debuger-custom-rule-registry-ids). Vous spécifiez l'adresse de registre d'URL pour l'image Docker préconçue dans le paramètre `RuleEvaluatorImage`.
```
"DebugHookConfig": {
"S3OutputPath": "s3:////debug-output",
"CollectionConfigurations": [
{
"CollectionName": "relu_activations",
"CollectionParameters": {
"include_regex": "relu",
"save_interval": "500",
"end_step": "5000"
}
}
]
},
"DebugRulesConfigurations": [
{
"RuleConfigurationName": "improper_activation_job",
"RuleEvaluatorImage": "552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest",
"InstanceType": "ml.c4.xlarge",
"VolumeSizeInGB": 400,
"RuleParameters": {
"source_s3_uri": "s3://bucket/custom_rules.py",
"rule_to_invoke": "ImproperActivation",
"collection_names": "relu_activations"
}
}
]
```
Pour obtenir une liste complète des images Docker disponibles pour l'utilisation des règles Debugger, consultez [Images Docker pour les règles Debugger](debugger-reference.md#debugger-docker-images-rules). Pour voir les paires clé-valeur pour `RuleParameters`, consultez [Liste des règles intégrées à Debugger](debugger-built-in-rules.md).
# Kit SDK for Python (Boto3)
Les règles intégrées d'Amazon SageMaker Debugger peuvent être configurées pour une tâche de formation à l'aide de la [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job)fonction du client AWS Boto3 AI SageMaker . Vous devez spécifier l'URI d'image approprié dans le paramètre `RuleEvaluatorImage`. Les exemples suivants vous expliquent comment configurer le corps de requête pour la fonction [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job).
Le code suivant montre un exemple complet de configuration du débogueur pour le corps de la `create_training_job()` requête et de démarrage d'une tâche de formation dans`us-west-2`, en supposant qu'un script de formation `entry_point/train.py` soit préparé à l'aide de. TensorFlow Pour trouver un end-to-end exemple de bloc-notes, consultez [Profiling TensorFlow Multi GPU Multi Node Training Job with Amazon SageMaker Debugger (Boto3](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_profiling/tf-resnet-profiling-multi-gpu-multi-node-boto3.html)).
**Note**
Assurez-vous d'utiliser les images de conteneur Docker appropriées. Pour trouver des images de AWS Deep Learning Containers [disponibles, consultez la section Images de Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) disponibles. Pour obtenir une liste complète des images Docker disponibles pour l'utilisation des règles Debugger, consultez [Images Docker pour les règles Debugger](debugger-reference.md#debugger-docker-images-rules).
```
import sagemaker, boto3
import datetime, tarfile
# Start setting up a SageMaker session and a Boto3 SageMaker client
session = sagemaker.Session()
region = session.boto_region_name
bucket = session.default_bucket()
# Upload a training script to a default Amazon S3 bucket of the current SageMaker session
source = 'source.tar.gz'
project = 'debugger-boto3-test'
tar = tarfile.open(source, 'w:gz')
tar.add ('entry_point/train.py') # Specify the directory and name of your training script
tar.close()
s3 = boto3.client('s3')
s3.upload_file(source, bucket, project+'/'+source)
# Set up a Boto3 session client for SageMaker
sm = boto3.Session(region_name=region).client("sagemaker")
# Start a training job
sm.create_training_job(
TrainingJobName='debugger-boto3-'+datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S'),
HyperParameters={
'sagemaker_submit_directory': 's3://'+bucket+'/'+project+'/'+source,
'sagemaker_program': '/entry_point/train.py' # training scrip file location and name under the sagemaker_submit_directory
},
AlgorithmSpecification={
# Specify a training Docker container image URI (Deep Learning Container or your own training container) to TrainingImage.
'TrainingImage': '763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.4.1-gpu-py37-cu110-ubuntu18.04',
'TrainingInputMode': 'File',
'EnableSageMakerMetricsTimeSeries': False
},
RoleArn='arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20201014T161125',
OutputDataConfig={'S3OutputPath': 's3://'+bucket+'/'+project+'/output'},
ResourceConfig={
'InstanceType': 'ml.p3.8xlarge',
'InstanceCount': 1,
'VolumeSizeInGB': 30
},
StoppingCondition={
'MaxRuntimeInSeconds': 86400
},
DebugHookConfig={
'S3OutputPath': 's3://'+bucket+'/'+project+'/debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'losses',
'CollectionParameters' : {
'train.save_interval': '500',
'eval.save_interval': '50'
}
}
]
},
DebugRuleConfigurations=[
{
'RuleConfigurationName': 'LossNotDecreasing',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {'rule_to_invoke': 'LossNotDecreasing'}
}
],
ProfilerConfig={
'S3OutputPath': 's3://'+bucket+'/'+project+'/profiler-output',
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{"StartStep": 5, "NumSteps": 3, "MetricsRegex": ".*", }',
'DetailedProfilingConfig': '{"StartStep": 5, "NumSteps": 3, }',
'PythonProfilingConfig': '{"StartStep": 5, "NumSteps": 3, "ProfilerName": "cprofile", "cProfileTimer": "total_time"}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
},
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {'rule_to_invoke': 'ProfilerReport'}
}
]
)
```
## Pour configurer une règle Debugger pour le débogage des paramètres de modèle
Les exemples de code suivants montrent comment configurer une `VanishingGradient` règle intégrée à l'aide de cette SageMaker API.
**Pour activer Debugger afin de collecter les tenseurs de sortie**
Spécifiez la configuration du hook Debugger comme suit :
```
DebugHookConfig={
'S3OutputPath': 's3:////debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'gradients',
'CollectionParameters' : {
'train.save_interval': '500',
'eval.save_interval': '50'
}
}
]
}
```
Ainsi, la tâche d'entraînement enregistre une collection de tenseurs, `gradients`, chaque `save_interval` sur 500 étapes. Pour trouver les `CollectionName` valeurs disponibles, consultez la section [Collections intégrées au Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections) dans la documentation de la *bibliothèque SMDebug cliente*. Pour trouver les clés et les valeurs de `CollectionParameters` paramètres disponibles, consultez la [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)classe dans la *documentation du SDK SageMaker Python*.
**Pour activer les règles Debugger pour le débogage des tenseurs de sortie**
L'exemple d'API `DebugRuleConfigurations` suivant montre comment exécuter la règle `VanishingGradient` intégrée sur la collection `gradients` enregistrée.
```
DebugRuleConfigurations=[
{
'RuleConfigurationName': 'VanishingGradient',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'VanishingGradient',
'threshold': '20.0'
}
}
]
```
Avec une configuration telle que celle de cet exemple, Debugger lance une tâche d'évaluation des règles pour votre tâche d'entraînement à l'aide de la règle `VanishingGradient` sur la collection de tenseurs `gradients`. Pour obtenir une liste complète des images Docker disponibles pour l'utilisation des règles Debugger, consultez [Images Docker pour les règles Debugger](debugger-reference.md#debugger-docker-images-rules). Pour voir les paires clé-valeur pour `RuleParameters`, consultez [Liste des règles intégrées à Debugger](debugger-built-in-rules.md).
## Pour configurer une règle intégrée Debugger pour le profilage des métriques système et de cadre
L'exemple de code suivant montre comment spécifier le fonctionnement de l' ProfilerConfig API pour permettre la collecte des métriques du système et du framework.
**Pour activer le profilage Debugger pour collecter les métriques du système et du framework**
------
#### [ Target Step ]
```
ProfilerConfig={
'S3OutputPath': 's3:////profiler-output', # Optional. Path to an S3 bucket to save profiling outputs
# Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3,
"MetricsRegex": ".*"
}',
'DetailedProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3
}',
'PythonProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3,
"ProfilerName": "cprofile", # Available options: cprofile, pyinstrument
"cProfileTimer": "total_time" # Include only when using cprofile. Available options: cpu, off_cpu, total_time
}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
}
```
------
#### [ Target Time Duration ]
```
ProfilerConfig={
'S3OutputPath': 's3:////profiler-output', # Optional. Path to an S3 bucket to save profiling outputs
# Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10,
"MetricsRegex": ".*"
}',
'DetailedProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10
}',
'PythonProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10,
"ProfilerName": "cprofile", # Available options: cprofile, pyinstrument
"cProfileTimer": "total_time" # Include only when using cprofile. Available options: cpu, off_cpu, total_time
}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
}
```
------
**Pour activer les règles Debugger pour le profilage des métriques**
L'exemple de code suivant montre comment configurer la règle `ProfilerReport`.
```
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'ProfilerReport',
'CPUBottleneck_cpu_threshold': '90',
'IOBottleneck_threshold': '90'
}
}
]
```
Pour obtenir une liste complète des images Docker disponibles pour l'utilisation des règles Debugger, consultez [Images Docker pour les règles Debugger](debugger-reference.md#debugger-docker-images-rules). Pour voir les paires clé-valeur pour `RuleParameters`, consultez [Liste des règles intégrées à Debugger](debugger-built-in-rules.md).
## Mettre à jour la configuration du profilage Debugger à l'aide de l'opération d'API `UpdateTrainingJob`
La configuration du profilage du débogueur peut être mise à jour pendant que votre tâche de formation est en cours d'exécution à l'aide de la [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_training_job)fonction du client AWS Boto3 AI SageMaker . Configurez [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)les nouveaux [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)objets et spécifiez le nom de la tâche d'entraînement dans le `TrainingJobName` paramètre.
```
ProfilerConfig={
'DisableProfiler': boolean,
'ProfilingIntervalInMilliseconds': number,
'ProfilingParameters': {
'string' : 'string'
}
},
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'string',
'RuleEvaluatorImage': 'string',
'RuleParameters': {
'string' : 'string'
}
}
],
TrainingJobName='your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS'
```
## Ajouter la configuration des règles personnalisées du débogueur à l'opération d'API CreateTrainingJob
Une règle personnalisée peut être configurée pour un travail de formation à l'aide [ DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)des objets [ DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)et à l'aide de la fonction du [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job)client AWS Boto3 SageMaker AI. L'exemple de code suivant montre comment configurer une `ImproperActivation` règle personnalisée écrite avec la bibliothèque *smdebug* à l'aide de cette opération d' SageMaker API. Cet exemple suppose que vous avez écrit la règle personnalisée dans le fichier *custom\$1rules.py* et que vous l'avez chargée dans un compartiment Amazon S3. L'exemple fournit des images Docker préconçues que vous pouvez utiliser pour exécuter vos règles personnalisées. Celles-ci sont énumérées sur la page [Image Amazon SageMaker Debugger pour les évaluateurs URIs de règles personnalisés](debugger-reference.md#debuger-custom-rule-registry-ids). Vous spécifiez l'adresse de registre d'URL pour l'image Docker préconçue dans le paramètre `RuleEvaluatorImage`.
```
DebugHookConfig={
'S3OutputPath': 's3:////debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'relu_activations',
'CollectionParameters': {
'include_regex': 'relu',
'save_interval': '500',
'end_step': '5000'
}
}
]
},
DebugRulesConfigurations=[
{
'RuleConfigurationName': 'improper_activation_job',
'RuleEvaluatorImage': '552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest',
'InstanceType': 'ml.c4.xlarge',
'VolumeSizeInGB': 400,
'RuleParameters': {
'source_s3_uri': 's3://bucket/custom_rules.py',
'rule_to_invoke': 'ImproperActivation',
'collection_names': 'relu_activations'
}
}
]
```
Pour obtenir une liste complète des images Docker disponibles pour l'utilisation des règles Debugger, consultez [Images Docker pour les règles Debugger](debugger-reference.md#debugger-docker-images-rules). Pour voir les paires clé-valeur pour `RuleParameters`, consultez [Liste des règles intégrées à Debugger](debugger-built-in-rules.md).
# Références Amazon SageMaker Debugger
Pour plus d'informations et de références sur l'utilisation d'Amazon SageMaker Debugger, consultez les rubriques suivantes.
**Topics**
+ [SageMaker Débogueur Amazon APIs](#debugger-apis)
+ [Images Docker pour les règles Debugger](#debugger-docker-images-rules)
+ [Exceptions relatives SageMaker à Amazon Debugger](#debugger-exceptions)
+ [Formation distribuée prise en charge par Amazon SageMaker Debugger](#debugger-considerations)
## SageMaker Débogueur Amazon APIs
Amazon SageMaker Debugger dispose d'opérations d'API sur plusieurs sites qui sont utilisées pour mettre en œuvre la surveillance et l'analyse de la formation des modèles.
Amazon SageMaker Debugger fournit également le [SDK `sagemaker-debugger` Python](https://github.com/awslabs/sagemaker-debugger/tree/master/smdebug) open source qui est utilisé pour configurer des règles intégrées, définir des règles personnalisées et enregistrer des hooks afin de collecter des données tensorielles de sortie à partir de tâches de formation.
Le SDK [Amazon SageMaker AI Python est un SDK](https://sagemaker.readthedocs.io/en/stable/) de haut niveau axé sur l'expérimentation de l'apprentissage automatique. Le SDK peut être utilisé pour déployer des règles intégrées ou personnalisées définies avec la bibliothèque `SMDebug` Python afin de surveiller et d'analyser ces tenseurs à l'aide d'estimateurs basés sur l' SageMaker IA.
Debugger a ajouté des opérations et des types à l' SageMaker API Amazon qui permettent à la plateforme d'utiliser Debugger lors de l'entraînement d'un modèle et de gérer la configuration des entrées et des sorties.
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)et [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html)utilisez le débogueur suivant APIs pour configurer les collections de tenseurs, les règles, les images de règles et les options de profilage :
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CollectionConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CollectionConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TensorBoardOutputConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TensorBoardOutputConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html) fournit une description complète d'une tâche d'entraînement, y compris les configurations Debugger et les statuts d'évaluation de règle suivants :
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleEvaluationStatus.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleEvaluationStatus.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleEvaluationStatus.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleEvaluationStatus.html)
Les opérations de l'API de configuration des règles utilisent la fonctionnalité SageMaker de traitement lors de l'analyse d'un modèle d'entraînement. Pour plus d'informations sur SageMaker le traitement, consultez[Charges de travail de transformation des données avec Processing SageMaker](processing-job.md).
## Images Docker pour les règles Debugger
Amazon SageMaker AI fournit deux ensembles d'images Docker pour les règles : un ensemble pour évaluer les règles fournies par l' SageMaker IA (règles intégrées) et un ensemble pour évaluer les règles personnalisées fournies dans les fichiers source Python.
Si vous utilisez le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), vous pouvez simplement utiliser les opérations de l'API Debugger de haut niveau de l' SageMaker IA avec les opérations de l'API SageMaker AI Estimator, sans avoir à récupérer manuellement les images Docker du Debugger et à configurer l'API. `ConfigureTrainingJob`
Si vous n'utilisez pas le SDK SageMaker Python, vous devez récupérer une image de base de conteneur prédéfinie pertinente pour les règles du débogueur. Amazon SageMaker Debugger fournit des images Docker prédéfinies pour les règles intégrées et personnalisées, et les images sont stockées dans Amazon Elastic Container Registry (Amazon ECR). Pour extraire une image d'un référentiel Amazon ECR (ou pour transférer une image vers un référentiel), utilisez l'URL du registre des noms complets de l'image à l'aide de l'`CreateTrainingJob`API. SageMaker AI utilise les modèles d'URL suivants pour l'adresse de registre d'images du conteneur de règles Debugger.
```
.dkr.ecr..amazonaws.com/:
```
Pour connaître l'ID de compte dans chaque AWS région, le nom du référentiel Amazon ECR et la valeur du tag, consultez les rubriques suivantes.
**Topics**
+ [Image Amazon SageMaker Debugger pour les évaluateurs URIs de règles intégrés](#debuger-built-in-registry-ids)
+ [Image Amazon SageMaker Debugger pour les évaluateurs URIs de règles personnalisés](#debuger-custom-rule-registry-ids)
### Image Amazon SageMaker Debugger pour les évaluateurs URIs de règles intégrés
Utilisez les valeurs suivantes pour les composants du registre URLs pour les images qui fournissent des règles intégrées pour Amazon SageMaker Debugger. Pour le compte IDs, consultez le tableau suivant.
**Nom du référentiel ECR** : sagemaker-debugger-rules
**Balise** : la plus récente
**Exemple d'une URL de registre complète** :
`904829902805.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rules:latest`
Tenez compte IDs des images de conteneurs de règles intégrées par AWS région
| Région | account\$1id |
| --- | --- |
| af-south-1 | 314341159256 |
| ap-east-1 | 199566480951 |
| ap-northeast-1 | 430734990657 |
| ap-northeast-2 | 578805364391 |
| ap-south-1 | 904829902805 |
| ap-southeast-1 | 972752614525 |
| ap-southeast-2 | 184798709955 |
| ca-central-1 | 519511493484 |
| cn-north-1 | 618459771430 |
| cn-northwest-1 | 658757709296 |
| eu-central-1 | 482524230118 |
| eu-north-1 | 314864569078 |
| eu-south-1 | 563282790590 |
| eu-west-1 | 929884845733 |
| eu-west-2 | 250201462417 |
| eu-west-3 | 447278800020 |
| me-south-1 | 986000313247 |
| sa-east-1 | 818342061345 |
| us-east-1 | 503895931360 |
| us-east-2 | 915447279597 |
| us-west-1 | 685455198987 |
| us-west-2 | 895741380848 |
| us-gov-west-1 | 515509971035 |
### Image Amazon SageMaker Debugger pour les évaluateurs URIs de règles personnalisés
Utilisez les valeurs suivantes pour les composants de l'URL de registre pour les images qui fournissent des évaluateurs de règles personnalisés pour Amazon SageMaker Debugger. Pour le compte IDs, consultez le tableau suivant.
**Nom du référentiel ECR** : sagemaker-debugger-rule-evaluator
**Balise** : la plus récente
**Exemple d'une URL de registre complète** :
`552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest`
Tenez compte IDs des images du conteneur de règles personnalisées par AWS région
| Région | account\$1id |
| --- | --- |
| af-south-1 | 515950693465 |
| ap-east-1 | 645844755771 |
| ap-northeast-1 | 670969264625 |
| ap-northeast-2 | 326368420253 |
| ap-south-1 | 552407032007 |
| ap-southeast-1 | 631532610101 |
| ap-southeast-2 | 445670767460 |
| ca-central-1 | 105842248657 |
| cn-north-1 | 617202126805 |
| cn-northwest-1 | 658559488188 |
| eu-central-1 | 691764027602 |
| eu-north-1 | 091235270104 |
| eu-south-1 | 335033873580 |
| eu-west-1 | 606966180310 |
| eu-west-2 | 074613877050 |
| eu-west-3 | 224335253976 |
| me-south-1 | 050406412588 |
| sa-east-1 | 466516958431 |
| us-east-1 | 864354269164 |
| us-east-2 | 840043622174 |
| us-west-1 | 952348334681 |
| us-west-2 | 759209512951 |
| us-gov-west-1 | 515361955729 |
## Exceptions relatives SageMaker à Amazon Debugger
Amazon SageMaker Debugger est conçu pour tenir compte du fait que les tenseurs requis pour exécuter une règle peuvent ne pas être disponibles à chaque étape. Par conséquent, il génère des exceptions qui vous permettent de contrôler ce qui se passe s'il manque un tenseur. Ces exceptions sont disponibles dans le [module smdebug.exceptions](https://github.com/awslabs/sagemaker-debugger/blob/master/smdebug/exceptions.py). Vous pouvez les importer comme suit :
```
from smdebug.exceptions import *
```
Les exceptions suivantes sont disponibles :
+ `TensorUnavailableForStep` – le tenseur demandé n'est pas disponible pour l'étape. Cela peut signifier que cette étape peut ne pas être enregistrée par le hook ou qu'elle peut avoir enregistré certains tenseurs mais que le tenseur requis n'en fait pas partie. Si cette exception est générée, cela signifie que ce tenseur ne pourra jamais être disponible pour cette étape à l'avenir. Si le tenseur a enregistré des réductions pour l'étape, il vous informe qu'elles peuvent être interrogées.
+ `TensorUnavailable` – ce tenseur n'est pas enregistré ou n'a pas été enregistré par l'API `smdebug`. Cela signifie que ce tenseur n'est jamais détecté pour une étape dans `smdebug`.
+ `StepUnavailable` – l'étape n'a pas été enregistrée et Debugger ne contient aucune donnée de l'étape.
+ `StepNotYetAvailable` : l'étape n'a pas encore été détectée par `smdebug`. Elle pourrait être disponible à l'avenir si l'entraînement est toujours en cours. Debugger charge automatiquement les nouvelles données au fur et à mesure qu'elles deviennent disponibles.
+ `NoMoreData` – générée à la fin de l'entraînement. Si vous voyez cette exception, cela signifie qu'il n'y a plus d'étapes ni plus aucun tenseur à enregistrer.
+ `IndexReaderException` – le lecteur d'index n'est pas valide.
+ `InvalidWorker` – un composant non valide a été invoqué.
+ `RuleEvaluationConditionMet` – l'évaluation de la règle à l'étape a abouti à la « condition remplie ».
+ `InsufficientInformationForRuleInvocation` – les informations fournies sont insuffisantes pour appeler la règle.
## Formation distribuée prise en charge par Amazon SageMaker Debugger
La liste suivante présente les domaines de validité et les considérations relatives à l'utilisation de Debugger sur les tâches d'entraînement avec des cadres de deep learning et les différentes options d'entraînement distribué.
+ **Horovod**
Domaine de validité de l'utilisation de Debugger pour les tâches d'entraînement avec Horovod
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-reference.html)
+ **SageMaker Données distribuées en parallèle grâce à l'IA**
Portée de validité de l'utilisation de Debugger pour les tâches de formation avec SageMaker AI distributed data parallel
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-reference.html)
\$1 Le débogueur ne prend pas en charge le profilage du framework pour TensorFlow 2.x.
\$1\$1 SageMaker AI distributed data parallel ne prend pas en charge la version TensorFlow 2.x avec l'implémentation de Keras.
+ **SageMaker AI distributed model parallel** — Debugger ne prend pas en charge l'apprentissage parallèle de modèles distribués par SageMaker IA.
+ **Formation distribuée avec points de contrôle SageMaker AI** — Debugger n'est pas disponible pour les tâches de formation lorsque l'option de formation distribuée et les points de contrôle SageMaker AI sont activés. Une erreur semblable à ce qui suit peut s'afficher :
```
SMDebug Does Not Currently Support Distributed Training Jobs With Checkpointing Enabled
```
Pour utiliser Debugger pour des tâches de formation avec des options de formation distribuées, vous devez désactiver le point de contrôle SageMaker AI et ajouter des fonctions de pointage manuel à votre script d'entraînement. Pour plus d’informations sur l’utilisation de Debugger avec des options d’entraînement distribué et des points de contrôle, consultez [Utilisation de données distribuées par SageMaker IA en parallèle avec Amazon SageMaker Debugger et les points de contrôle](distributed-troubleshooting-data-parallel.md#distributed-ts-data-parallel-debugger) et [Sauvegarde des points de contrôle](distributed-troubleshooting-model-parallel.md#distributed-ts-model-parallel-checkpoints).
+ **Serveur de paramètres** – Debugger ne prend pas en charge l'entraînement distribué basé sur le serveur de paramètres.
+ Le profilage des opérations du framework d'entraînement distribué, telles que le `AllReduced` fonctionnement des [opérations SageMaker AI distributed data parallel et Horovod](https://horovod.readthedocs.io/en/stable/timeline_include.html), n'est pas disponible.