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
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()
```