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.

# Utilisation de Debugger avec des conteneurs d’entraînement personnalisés
<a name="debugger-bring-your-own-container"></a>

**Note**  
Amazon SageMaker Debugger n'est plus ouvert aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. AWS continue d'investir dans l'amélioration de la sécurité et de la disponibilité de Debugger, mais nous ne prévoyons pas d'introduire de nouvelles fonctionnalités. Pour de plus amples informations, veuillez consulter [Modification de la disponibilité du débogueur](debugger-availability-change.md). 

Amazon SageMaker Debugger est disponible pour tous les modèles de deep learning que vous apportez à Amazon SageMaker AI. Les AWS CLI`ModelTrainer` API SageMaker AI et Debugger vous 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 client open source SMDebug](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 obtenir un exemple de bout en bout d’utilisation de Debugger avec un conteneur d’entraînement 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é
<a name="debugger-bring-your-own-container-1"></a>

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
<a name="debugger-script-mode"></a>

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 callback Keras pour le débogage. Pour trouver un script de formation complet, voir script de [ TensorFlow formation 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 cadres et l'algorithme pris en charge, consultez les liens suivants dans la bibliothèque client SMDebug :
+ [Crochet SMDebug TensorFlow ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/tensorflow.md)
+ [Crochet SMDebug PyTorch ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/pytorch.md)
+ [Hook MxNet SMDebug](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/mxnet.md)
+ [Hook XGBoost SMDebug](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 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 conteneur Deep Learning 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 du hook est supprimée du script dans lequel vous définissez le ModelTrainer. 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'entraînement 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é de `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 hook (à 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 les 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 version v1.3.1 est prise en charge par les conteneurs SageMaker AI, et cet exemple explique en détail comment modifier un script d'entraînement. 

  L' SageMaker IA PyTorch ModelTrainer est déjà en mode script par défaut. Dans le bloc-notes, la ligne à activer n'`script_mode`est pas incluse dans la ModelTrainer configuration.

  Ce bloc-notes décrit les étapes détaillées à suivre pour remplacer [ le script ](https://github.com/pytorch/examples/blob/master/mnist/main.py) de PyTorch formation d'origine 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
<a name="debugger-bring-your-own-container-2"></a>

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 la section Images [ de conteneurs AWS Deep Learning ](https://aws.amazon.com/releasenotes/available-deep-learning-containers-images/) disponibles.

## Création et transmission du conteneur d’entraînement personnalisé à Amazon ECR
<a name="debugger-bring-your-own-container-3"></a>

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é
<a name="debugger-bring-your-own-container-4"></a>

Après avoir créé et envoyé votre conteneur Docker vers Amazon ECR, configurez une SageMaker IA à l' ModelTraineraide de votre script d'entraînement et de ses Debugger-specific paramètres. Après avoir exécuté `model_trainer.train()`, 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 du processus de surveillance des règles du débogueur avec Amazon CloudWatch Events AWS Lambda, vous pouvez automatiser un processus d'arrêt des tâches de formation chaque fois que les règles du débogueur détectent des problèmes de formation.

```
import sagemaker
from sagemaker.train import ModelTrainer
from sagemaker.core.debugger import Rule, DebuggerHookConfig, CollectionConfig, rule_configs
from sagemaker.core.helper.session_helper import get_execution_role

profiler_config={{ProfilerConfig(...)}}
debugger_hook_config={{DebuggerHookConfig(...)}}
rules=[
    {{Rule.sagemaker(rule_configs.built_in_rule())}},
    {{ProfilerRule.sagemaker(rule_configs.BuiltInRule())}}
]

from sagemaker.train.configs import SourceCode, Compute

model_trainer=ModelTrainer(
    training_image=byoc_image_uri,
    source_code=SourceCode(entry_script="./debugger_custom_container_test_folder/your-training-script.py"),
    role=get_execution_role(),
    base_job_name='debugger-custom-container-test',
    compute=Compute(instance_type='ml.p3.2xlarge', instance_count=1),
    
    # Debugger-specific parameters
    profiler_config=profiler_config,
    debugger_hook_config=debugger_hook_config,
    rules=rules
)

# start training
model_trainer.train()
```