Uso del depurador con contenedores de entrenamiento personalizados

Amazon SageMaker Debugger está disponible para todos los modelos de aprendizaje profundo que incorpore a Amazon SageMaker AI. La AWS CLIEstimator API de SageMaker IA y el depurador le APIs 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. Las siguientes secciones le guiarán a través de la utilización del depurador con contenedores de entrenamiento personalizados.

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

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

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 para el script de entrenamiento

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

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, consulte los siguientes enlaces de la biblioteca SMDebug cliente:

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:

Creación y configuración de un dockerfile

Abre tu SageMaker IA JupyterLab y crea una nueva carpeta, 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.

Creación e inserción de la imagen de entrenamiento personalizada 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

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

Ejecución y depuración de trabajos de entrenamiento con el contenedor de entrenamiento personalizado

Después de crear e insertar el contenedor de Docker en Amazon ECR, configure un estimador de SageMaker IA 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()