Utiliser Debugger avec des conteneurs d'entraînement personnalisés

Amazon SageMaker Debugger est disponible pour tous les modèles de deep learning que vous apportez à Amazon. SageMaker Les SageMaker Estimator API AWS CLI, API 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.

Vous avez besoin des ressources suivantes pour créer un conteneur personnalisé avec Debugger.

Pour un end-to-end exemple d'utilisation de Debugger avec un conteneur de formation personnalisé, consultez l'exemple de bloc-notes suivant.

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

Enregistrer le 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.

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.

# 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 :

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 :

Créer et configurer un Dockerfile

Ouvrez votre dossier SageMaker JupyterLab et créez-en un nouveau, debugger_custom_container_test_folder dans cet exemple, pour enregistrer votre script d'entraînement etDockerfile. 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.

Créer et transmettre le 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

! aws ecr get-login-password --region {region} | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com

Exécuter et déboguer 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 SageMaker estimateur 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()