Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# 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 CLI`Estimator` 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.
+ [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable)
+ [La biblioteca de clientes de código SMDebug abierto](https://github.com/awslabs/sagemaker-debugger)
+ 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 para el script de entrenamiento](#debugger-script-mode).
Para ver un end-to-end ejemplo del uso de Debugger con un contenedor de entrenamiento personalizado, consulta el siguiente cuaderno de ejemplo.
+ [Build a Custom Training Container and Debug Training Jobs with Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/build_your_own_container_with_debugger/debugger_byoc.html)
**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](adapt-training-container.md), 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 para 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](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-debugger/build_your_own_container_with_debugger/docker/tf_keras_resnet_byoc.py). 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:
+ [SMDebug TensorFlow hook](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/tensorflow.md)
+ [SMDebug PyTorch hook](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/pytorch.md)
+ [SMDebug MXNet hook](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/mxnet.md)
+ [SMDebug XGBoost hook](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/xgboost.md)
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 marco 2.1 TensorFlow ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/tf2-keras-custom-container.html)
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](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_zero_code_change/tf2-keras-default-container.html).
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 ](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/src/tf_keras_resnet_byoc.py) 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](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_custom_container)
Este cuaderno habilita Debugger en modo script en el marco PyTorch v1.3.1. PyTorchLa versión 1.3.1 es compatible con los contenedores de SageMaker IA, y en este ejemplo se muestran detalles sobre cómo modificar un guion de entrenamiento.
El PyTorch estimador de SageMaker IA 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](https://github.com/pytorch/examples/blob/master/mnist/main.py) por 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.
## 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 y`Dockerfile`. 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](https://aws.amazon.com/releasenotes/available-deep-learning-containers-images/).
## 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
```
**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
```
## 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()
```