Uso del depurador con contenedores de entrenamiento personalizados

Amazon SageMaker Debugger está disponible para todos los modelos de aprendizaje profundo que traiga a Amazon SageMaker. La AWS CLI API y las SageMaker Estimator API Debugger le permiten utilizar cualquier imagen base de Docker para crear y personalizar contenedores con el fin de entrenar sus modelos. Para utilizar el depurador con contenedores personalizados, debe realizar un cambio pequeño en el script de entrenamiento a fin de implementar la devolución de llamada al enlace del depurador y recuperar los tensores de los trabajos de entrenamiento.

Para crear un contenedor personalizado con el depurador, necesita los siguientes recursos.

• SDK de Amazon SageMaker Python

• La biblioteca cliente de código abierto de SMDebug

• Una imagen base de Docker que usted elija

• El Script de entrenamiento con un enlace de depuración registrado: para obtener más información sobre cómo registrar un enlace del depurador en su script de entrenamiento, consulte Registro del enlace del depurador en el script de entrenamiento.

Para ver un end-to-end ejemplo del uso de Debugger con un contenedor de entrenamiento personalizado, consulte el siguiente cuaderno de ejemplo.

• Build a Custom Training Container and Debug Training Jobs with Debugger

sugerencia

Esta guía sobre el contenedor personalizado con el depurador es una extensión de la guía Adaptación del contenedor de entrenamiento propio, en la que se explica detalladamente cómo crear e introducir un contenedor de entrenamiento personalizado en Amazon ECR.

Preparación para crear un contenedor de entrenamiento personalizado

Para construir un contenedor de Docker, la estructura básica de los archivos debería ser la siguiente:

├── 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

Registro del enlace del depurador en el script de entrenamiento

Para depurar el modelo de entrenamiento, necesita añadir un enlace de depuración al script de entrenamiento.

nota

Este paso es necesario para recopilar los parámetros del modelo (tensores de salida) a fin de depurar el entrenamiento del modelo. Si solo quiere monitorizar y elaborar un perfil, puede omitir este paso de registro de enlace y excluir el parámetro debugger_hook_config al crear un estimador.

El siguiente código de ejemplo muestra la estructura de un guion de entrenamiento que utiliza el modelo Keras ResNet 50 y cómo pasar el enlace del depurador como retrollamada de Keras para la depuración. Para encontrar un guion de entrenamiento completo, consulte el guion de entrenamiento con Debugger TensorFlow Hook. SageMaker

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

Para obtener más información sobre cómo registrar el enlace del depurador en los marcos y algoritmos compatibles, consulta los siguientes enlaces de la biblioteca cliente de SMDebug:

• Gancho SMDebug TensorFlow

• Gancho SMDebug PyTorch

• SMDebug MXNet hook

• SMDebug XGBoost hook

En los siguientes ejemplos de scripts de entrenamiento en cuadernos, puede encontrar más ejemplos sobre cómo añadir los enlaces del depurador a los scripts de entrenamiento y recopilar los tensores de salida en detalle:

• Depurador en modo script con el framework 2.1 TensorFlow

  Para ver la diferencia entre usar Debugger en un contenedor de aprendizaje profundo y en modo script, abra este cuaderno y colóquelo junto con el anterior ejemplo de Debugger en un cuaderno de Deep Learning Container TensorFlow v2.1.

  En el modo de script, la parte de configuración del enlace se elimina del script en el que se establece el estimador. En su lugar, la función Debugger Hook se fusiona con el guion de entrenamiento y el guion de entrenamiento de TensorFlow Kera en modo ResNet guion. El guion de entrenamiento importa la smdebug biblioteca al entorno de TensorFlow Keras necesario para comunicarse con el TensorFlow ResNet algoritmo 50. También implementa manualmente la funcionalidad de smdebug enlace añadiendo el callbacks=[hook] argumento dentro de la train función (en la línea 49) y añadiendo la configuración de enlace manual (en la línea 89) proporcionada a través del SDK de SageMaker Python.

  Este ejemplo de modo de script ejecuta el trabajo de entrenamiento en el marco TF 2.1 para realizar una comparación directa con el trabajo sin ningún cambio de script en el ejemplo de TF 2.1. La ventaja de configurar Debugger en modo script es la flexibilidad de elegir versiones de framework no incluidas en AWS Deep Learning Containers.

• Uso de Amazon SageMaker Debugger en un PyTorch contenedor en modo script

  Este cuaderno habilita Debugger en modo script en el marco PyTorch v1.3.1. PyTorchLa versión 1.3.1 es compatible con los SageMaker contenedores, y en este ejemplo se muestran detalles sobre cómo modificar un script de entrenamiento.

  El SageMaker PyTorch estimador ya está en modo script de forma predeterminada. En el bloc de notas verá que la línea para activar el script_mode no está incluida en la configuración del estimador.

  Este cuaderno muestra los pasos detallados para cambiar el guion de PyTorch entrenamiento original a una versión modificada para activar Debugger. Además, en este ejemplo se muestra cómo puede utilizar las reglas integradas del depurador para detectar problemas de entrenamiento, como problemas de desaparición de gradientes; también se muestran las características de prueba del depurador para llamar a los tensores guardados y analizarlos.

Crear y configurar un Dockerfile

Abre tu carpeta SageMaker JupyterLab y crea una nueva, debugger_custom_container_test_folder en este ejemplo, para guardar tu guion de entrenamiento yDockerfile. El siguiente ejemplo de código es un Dockerfile que incluye las recomendaciones esenciales de compilación de Docker. Pegue el siguiente código en el archivo de texto Dockerfile y guárdelo. Suba el script de entrenamiento a la misma carpeta.

# 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 quiere utilizar una imagen de AWS Deep Learning Container prediseñada, consulte Imágenes de AWS Deep Learning Containers disponibles.

Crear e insertar el contenedor de entrenamiento personalizado en Amazon ECR

Cree un cuaderno de prueba (debugger_custom_container_test_notebook.ipynb) y ejecute el siguiente código en la celda del cuaderno. Esto dará acceso al directorio debugger_byoc_test_docker, compilará el docker con el algorithm_name especificado y enviará el contenedor de Docker a su 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

sugerencia

Si utiliza una de las imágenes base del contenedor de aprendizaje AWS profundo, ejecute el siguiente código para iniciar sesión en Amazon ECR y acceder al repositorio de imágenes del contenedor de aprendizaje profundo.

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

Ejecutar y depurar los trabajos de entrenamiento con el contenedor de entrenamiento personalizado

Después de crear e insertar el contenedor de Docker en Amazon ECR, configure un SageMaker estimador con su script de entrenamiento y los parámetros específicos del depurador. Tras ejecutar estimator.fit(), el depurador recopilará los tensores de salida, los supervisará y detectará los problemas de entrenamiento. Con los tensores guardados, puede analizar más a fondo el trabajo de entrenamiento utilizando las funciones y herramientas principales de smdebug. Al configurar un flujo de trabajo del proceso de supervisión de las reglas del depurador con Amazon CloudWatch Events AWS Lambda, puede automatizar el proceso de detener el trabajo de formación cada vez que las reglas del depurador detecten problemas de formación.

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