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.
# Amazon SageMaker Debugger
Depure los tensores de salida de los modelos de los trabajos de formación en aprendizaje automático en tiempo real y detecte problemas no convergentes con Amazon Debugger. SageMaker
## Características de Amazon SageMaker Debugger
Es posible que un trabajo de entrenamiento sobre el machine learning (ML) presente problemas de sobreajuste, saturación de las funciones de activación y desaparición de los gradientes, lo cual podría comprometer el desempeño del modelo.
SageMaker Debugger proporciona herramientas para depurar los trabajos de entrenamiento y resolver estos problemas a fin de mejorar el rendimiento de su modelo. El depurador también ofrece herramientas capaces de enviar alertas en caso de detectar anomalías durante el entrenamiento, tomar medidas para resolver los problemas e identificar la causa raíz de los mismos mediante la visualización de las métricas y los tensores recopilados.
SageMaker Debugger es compatible con Apache MXNet, PyTorch TensorFlow, y los marcos. XGBoost Para obtener más información sobre los marcos y las versiones disponibles compatibles con SageMaker Debugger, consulte. [Marcos y algoritmos compatibles](debugger-supported-frameworks.md)
![\[Descripción general del funcionamiento de Amazon SageMaker Debugger.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-main.png)
El flujo de trabajo del depurador de alto nivel es el siguiente:
1. Modifique su script de entrenamiento con el Python SDK del `sagemaker-debugger` si es necesario.
1. Configure un trabajo SageMaker de formación con SageMaker Debugger.
+ Configure mediante la API SageMaker AI Estimator (para Python SDK).
+ Configure mediante la [`CreateTrainingJob`solicitud de SageMaker IA (para Boto3 o CLI](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html)).
+ Configure [contenedores de entrenamiento personalizados con Debugger](debugger-bring-your-own-container.md) SageMaker .
1. Inicie un trabajo de entrenamiento y supervise los problemas de entrenamiento en tiempo real.
+ [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
1. Reciba alertas y tome medidas rápidas en caso de problemas relacionados con el entrenamiento.
+ Reciba mensajes de texto y correos electrónicos y detenga los trabajos de entrenamiento en caso de que se hayan detectado problemas de entrenamiento con [Uso de las acciones integradas del depurador para reglas](debugger-built-in-actions.md).
+ Configure sus propias acciones con [Amazon CloudWatch Events y AWS Lambda](debugger-cloudwatch-lambda.md).
1. Conozca detalladamente el análisis de los problemas de entrenamiento.
+ Para depurar los tensores de salida del modelo, consulte [Visualice los tensores de salida del depurador en TensorBoard](debugger-enable-tensorboard-summaries.md).
1. Solucione los problemas, tenga en cuenta las sugerencias proporcionadas por el depurador y repita los pasos 1 a 5 hasta optimizar el modelo y lograr la precisión deseada.
La guía para desarrolladores de SageMaker Debugger explica los siguientes temas.
**Topics**
+ [Características de Amazon SageMaker Debugger](#debugger-features)
+ [Marcos y algoritmos compatibles](debugger-supported-frameworks.md)
+ [Arquitectura de Amazon SageMaker Debugger](debugger-how-it-works.md)
+ [Tutoriales del depurador](debugger-tutorial.md)
+ [Depuración de trabajos de formación con Amazon SageMaker Debugger](debugger-debug-training-jobs.md)
+ [Lista de reglas integradas del depurador](debugger-built-in-rules.md)
+ [Creación de reglas personalizadas mediante la biblioteca cliente del depurador](debugger-custom-rules.md)
+ [Uso del depurador con contenedores de entrenamiento personalizados](debugger-bring-your-own-container.md)
+ [Configurar el depurador mediante SageMaker la API](debugger-createtrainingjob-api.md)
+ [Referencias de Amazon SageMaker Debugger](debugger-reference.md)
# Marcos y algoritmos compatibles
La siguiente tabla muestra los marcos y algoritmos de aprendizaje automático de SageMaker IA compatibles con Debugger.
|
|
| **SageMaker AI-supported frameworks and algorithms** | **Debugging output tensors** |
| --- |--- |
| [TensorFlow](https://sagemaker.readthedocs.io/en/stable/using_tf.html) | [AWS TensorFlow contenedores de aprendizaje profundo](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.15.4 o versiones posteriores |
| [PyTorch](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html) | [AWS PyTorch contenedores de aprendizaje profundo 1.5.0](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) o versiones posteriores |
| [MXNet](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html) | [AWS MXNet contenedores de aprendizaje profundo](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.6.0 o versiones posteriores |
| [XGBoost](https://sagemaker.readthedocs.io/en/stable/frameworks/xgboost/using_xgboost.html) | 1.0-1, 1.2-1, 1.3-1 |
| [SageMaker Estimador genérico de IA](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) | [Contenedores de formación personalizados](debugger-bring-your-own-container.md) (disponibles para TensorFlow PyTorch MXNet, y XGBoost con registro manual de ganchos) |
+ **Depuración de tensores de salida**: rastrea y depura los parámetros del modelo, como los pesos, los gradientes, los sesgos y los valores escalares de tu trabajo de entrenamiento. Los marcos de aprendizaje profundo disponibles son Apache MXNet TensorFlow, PyTorch, y XGBoost.
**importante**
En el caso del TensorFlow marco con Keras, SageMaker Debugger desaprueba la compatibilidad con cero cambios de código para los modelos de depuración creados con los `tf.keras` módulos de la versión 2.6 y versiones posteriores. TensorFlow [Esto se debe a los cambios importantes anunciados en la nota de la versión 2.6.0. TensorFlow ](https://github.com/tensorflow/tensorflow/releases/tag/v2.6.0) Para obtener instrucciones sobre cómo actualizar el script de entrenamiento, consulte [Adapta tu guion de entrenamiento TensorFlow](debugger-modify-script-tensorflow.md).
**importante**
A partir de la PyTorch versión 1.12.0 y versiones posteriores, SageMaker Debugger deja de admitir cambios de código cero en los modelos de depuración.
Esto se debe a cambios importantes que hacen SageMaker que Debugger interfiera con la funcionalidad. `torch.jit` Para obtener instrucciones sobre cómo actualizar el script de entrenamiento, consulte [Adapte su guion PyTorch de entrenamiento](debugger-modify-script-pytorch.md).
Si el marco o algoritmo que desea entrenar y depurar no aparece en la tabla, vaya al [foro de AWS debate](https://forums.aws.amazon.com/) y deje sus comentarios sobre SageMaker Debugger.
## Regiones de AWS
Amazon SageMaker Debugger está disponible en todas las regiones en las que Amazon SageMaker AI está en servicio, excepto en las siguientes regiones.
+ Asia-Pacífico (Yakarta): `ap-southeast-3`
Para saber si Amazon SageMaker AI está en servicio en su empresa Región de AWS, consulte [Servicios AWS regionales](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).
## Utilice el depurador con contenedores de entrenamiento personalizados
Incorpore sus contenedores de formación a la SageMaker IA y obtenga información sobre sus trabajos de formación con Debugger. Maximice la eficiencia de su trabajo optimizando su modelo en las instancias de Amazon EC2 mediante las funciones de supervisión y depuración.
Para obtener más información sobre cómo crear un contenedor de entrenamiento con la biblioteca de clientes `sagemaker-debugger`, llevarlo al Amazon Elastic Container Registry (Amazon ECR), luego supervisar y depurar, consulte [Uso del depurador con contenedores de entrenamiento personalizados](debugger-bring-your-own-container.md).
## Debugger: repositorios de código abierto GitHub
APIs Los depuradores se proporcionan a través del SDK de SageMaker Python y están diseñados para crear configuraciones de reglas y enlaces del depurador para las operaciones de SageMaker IA [ CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)y [ DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html)API. La biblioteca de clientes `sagemaker-debugger` proporciona herramientas para registrar los *enlaces* y acceder a los datos de entrenamiento a través de su función de *prueba*, además de sus operaciones de API flexibles y potentes. Es compatible con los marcos de aprendizaje automático TensorFlow PyTorch MXNet, y XGBoost en Python 3.6 y versiones posteriores.
Para obtener información directa acerca de las operaciones del depurador y de la API `sagemaker-debugger`, consulte los siguientes enlaces:
+ [La documentación del SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_debugger.html)
+ [El SDK de Amazon SageMaker Python: Depurador APIs](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html)
+ [La documentación del SDK de `sagemaker-debugger` Python](https://sagemaker-debugger.readthedocs.io/en/website/index.html) para [la biblioteca cliente de código abierto Amazon SageMaker Debugger](https://github.com/awslabs/sagemaker-debugger#amazon-sagemaker-debugger)
+ [El `sagemaker-debugger` PyPI](https://pypi.org/project/smdebug/)
Si utiliza el SDK para Java para realizar trabajos de SageMaker formación y desea configurar Debugger APIs, consulte las siguientes referencias:
+ [Amazon SageMaker Debugger APIs](debugger-reference.md#debugger-apis)
+ [Configurar el depurador mediante SageMaker la API](debugger-createtrainingjob-api.md)
# Arquitectura de Amazon SageMaker Debugger
En este tema se presenta una descripción general de alto nivel del flujo de trabajo de Amazon SageMaker Debugger.
El depurador admite la funcionalidad de creación de perfiles para *optimizar el desempeño* a fin de identificar problemas de cálculo, como los cuellos de botella del sistema y la infrautilización, además de para ayudar a optimizar la utilización de los recursos de hardware a gran escala.
La funcionalidad de depuración de depurador para la *optimización de modelos* consiste en analizar los problemas de entrenamiento no convergentes que puedan surgir y, al mismo tiempo, minimizar las funciones de pérdida mediante algoritmos de optimización, como el descenso de gradientes y sus variaciones.
El siguiente diagrama muestra la arquitectura de SageMaker Debugger. Los bloques con líneas de límite en negrita son los elementos que el depurador consigue analizar en tu trabajo de entrenamiento.
![\[Descripción general del funcionamiento de Amazon SageMaker Debugger.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger_new_diagram.png)
El depurador almacena los siguientes datos de sus trabajos de entrenamiento en su bucket protegido de Amazon S3:
+ **Tensores de salida**: colecciones de escalares y parámetros del modelo que se actualizan continuamente durante las pasadas hacia adelante y hacia atrás mientras se entrenan los modelos de machine learning. Los tensores de salida incluyen valores escalares (precisión y pérdida) y matrices (pesos, gradientes, capas de entrada y capas de salida).
**nota**
De forma predeterminada, Debugger supervisa y depura los trabajos de SageMaker entrenamiento sin ningún parámetro específico de Debugger configurado en los estimadores de IA. SageMaker El depurador recopila las métricas del sistema cada 500 milisegundos y los tensores de salida básicos (resultados escalares como la pérdida y la precisión) cada 500 pasos. También ejecuta la regla `ProfilerReport` para analizar las métricas del sistema y agregar el panel de información del depurador de Studio y un informe de creación de perfiles. El depurador guarda los datos de salida en su bucket de Amazon S3 protegido.
Las reglas integradas del depurador se ejecutan en contenedores de procesamiento, que han sido diseñados para evaluar los modelos de machine learning mediante el procesamiento de los datos de entrenamiento recopilados en su bucket S3 (consulte [Procesar datos y evaluar modelos](https://docs.aws.amazon.com//sagemaker/latest/dg/processing-job.html)). El depurador gestiona completamente las reglas integradas. También puede crear sus propias reglas personalizadas para vigilar cualquier problema que tenga su modelo.
# Tutoriales del depurador
Los siguientes temas le acompañarán a través de tutoriales, desde los conceptos básicos hasta los casos de uso avanzados de monitorización, creación de perfiles y depuración de los trabajos de entrenamiento de SageMaker mediante el depurador. Explore las funciones del depurador y descubra cómo puede depurar y mejorar sus modelos de machine learning de forma eficiente mediante el uso del depurador.
**Topics**
+ [Videotutoriales sobre el depurador](debugger-videos.md)
+ [Cuadernos de ejemplo del depurador](debugger-notebooks.md)
+ [Demostraciones y visualización avanzadas del depurador](debugger-visualization.md)
# Videotutoriales sobre el depurador
En los siguientes vídeos se ofrece un recorrido por las capacidades de Amazon SageMaker Debugger mediante instancias de notebook SageMaker Studio y SageMaker AI.
**Topics**
+ [Depuración de modelos con Amazon SageMaker Debugger en Studio Classic](#debugger-video-get-started)
+ [Profundice en Amazon SageMaker Debugger y el monitor de modelos de SageMaker IA](#debugger-video-dive-deep)
## Depuración de modelos con Amazon SageMaker Debugger en Studio Classic
*Julien Simon, evangelista AWS técnico \$1 Duración: 14 minutos y 17 segundos*
En este vídeo tutorial se muestra cómo utilizar Amazon SageMaker Debugger para capturar e inspeccionar la información de depuración de un modelo de formación. El ejemplo de modelo de entrenamiento utilizado en este vídeo es una red neuronal convolucional simple (CNN) basada en Keras con el backend. TensorFlow SageMaker La IA en un TensorFlow framework y Debugger permiten crear un estimador directamente utilizando el guion de entrenamiento y depurar el trabajo de entrenamiento.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/MqPdTj0Znwg)
Encontrará el bloc de notas de ejemplo en el vídeo de [este repositorio de demostración de Studio](https://gitlab.com/juliensimon/amazon-studio-demos/-/tree/master) proporcionado por el autor. Debe clonar el archivo del `debugger.ipynb` cuaderno y el guion de `mnist_keras_tf.py` entrenamiento en su SageMaker Studio o en una instancia de SageMaker bloc de notas. Después de clonar los dos archivos, especifique la ruta de acceso `keras_script_path` al archivo `mnist_keras_tf.py` dentro del bloc de notas `debugger.ipynb`. Por ejemplo, si clona los dos archivos en el mismo directorio, establézcalo como `keras_script_path = "mnist_keras_tf.py"`.
## Profundice en Amazon SageMaker Debugger y el monitor de modelos de SageMaker IA
*Julien Simon, evangelista AWS técnico \$1 Duración: 44 minutos y 34 segundos*
Esta sesión de vídeo explora las funciones avanzadas de Debugger y SageMaker Model Monitor que ayudan a aumentar la productividad y la calidad de sus modelos. En primer lugar, este vídeo muestra cómo detectar y corregir problemas de entrenamiento, visualizar tensores y mejorar modelos con el depurador. A continuación, a las 22:41, el vídeo muestra cómo monitorizar los modelos en producción e identificar problemas de predicción, como la falta de funciones o la desviación de datos, mediante SageMaker AI Model Monitor. Por último, ofrece consejos de optimización de costos para ayudarle a sacar el máximo partido a su presupuesto de machine learning.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/0zqoeZxakOI)
Encontrará el cuaderno de ejemplo en el vídeo en [ este repositorio de AWS Dev Days 2020](https://gitlab.com/juliensimon/awsdevdays2020/-/tree/master/mls1) ofrecido por el autor.
# Cuadernos de ejemplo del depurador
SageMaker Los [cuadernos de ejemplo del depurador](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/) se proporcionan en el repositorio [amazon-sagemaker-examplesaws/](https://github.com/aws/amazon-sagemaker-examples). Los cuadernos de ejemplo del depurador muestran casos de uso básicos y avanzados de trabajos de entrenamiento sobre depuración y creación de perfiles.
Le recomendamos que ejecute los cuadernos de ejemplo en SageMaker Studio o en una instancia de SageMaker Notebook, ya que la mayoría de los ejemplos están diseñados para tareas de formación en el ecosistema de SageMaker IA, incluidos Amazon EC2, Amazon S3 y Amazon SageMaker Python SDK.
Para clonar el repositorio de ejemplo en SageMaker Studio, siga las instrucciones de [Amazon SageMaker Studio Tour](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-studio-end-to-end.html).
**importante**
Para utilizar las nuevas funciones del depurador, debe actualizar el SDK de SageMaker Python y la biblioteca `SMDebug` cliente. En su núcleo de iPython, Jupyter Notebook o JupyterLab entorno, ejecute el siguiente código para instalar las últimas versiones de las bibliotecas y reiniciar el núcleo.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Cuadernos de ejemplo del depurador para crear perfiles de trabajos de entrenamiento
La siguiente lista muestra ejemplos de cuadernos del depurador que presentan la capacidad de adaptación del depurador para monitorizar y perfilar los trabajos de entrenamiento para varios modelos, conjuntos de datos y marcos de machine learning.
| Título del cuaderno | Marcos | Modelo | Conjunto de datos | Description (Descripción) |
| --- | --- | --- | --- | --- |
| [Análisis de datos de creación de perfiles de Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/debugger_interactive_analysis_profiling/interactive_analysis_profiling_data.html) | TensorFlow | Keras 50 ResNet | Cifar-10 | Este cuaderno ofrece una introducción al análisis interactivo de los datos perfilados capturados por SageMaker Debugger. Explore todas las funciones de las herramientas de análisis interactivo `SMDebug`. |
| [Formación de perfiles sobre aprendizaje automático con Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_nlp_sentiment_analysis/sentiment-analysis-tf-distributed-training-bringyourownscript.html) | TensorFlow | Red neuronal convolucional 1-D | Conjunto de datos de IMDB | Haga un perfil de una TensorFlow CNN unidimensional para analizar las opiniones de los datos de IMDB, que consisten en reseñas de películas etiquetadas como positivas o negativas. Consulte la información del depurador de Studio y el informe de creación de perfiles del depurador. |
| [ TensorFlow ResNet Modelado de perfiles de entrenamiento con varios entornos de entrenamiento distribuidos](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_profiling) | TensorFlow | ResNet50 | Cifar-10 | Ejecute trabajos de TensorFlow entrenamiento con varios ajustes de entrenamiento distribuidos, supervise la utilización de los recursos del sistema y elabore un perfil del rendimiento del modelo mediante Debugger. |
| [Elaboración de perfiles PyTorch ResNet del modelo de entrenamiento con varios entornos de entrenamiento distribuidos](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_profiling) | PyTorch | ResNet50 | Cifar-10 | Ejecute trabajos de PyTorch entrenamiento con varios ajustes de entrenamiento distribuidos, supervise la utilización de los recursos del sistema y elabore un perfil del rendimiento del modelo mediante Debugger. |
## Cuadernos de ejemplo del depurador para analizar los parámetros del modelo
La siguiente lista muestra ejemplos de cuadernos del depurador que presentan la capacidad de adaptación del depurador para realizar tareas de entrenamiento de depuración para diversos modelos, conjuntos de datos y marcos de machine learning.
| Título del cuaderno | Marcos | Modelo | Conjunto de datos | Description (Descripción) |
| --- | --- | --- | --- | --- |
| [Amazon SageMaker Debugger: utilice una regla integrada](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_builtin_rule) | TensorFlow | Red neuronal convolucional | MNIST | Utilice las reglas integradas de Amazon SageMaker Debugger para depurar un TensorFlow modelo. |
| [Amazon SageMaker Debugger - Tensorflow 2.1](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow2) | TensorFlow | ResNet50 | Cifar-10 | Usa la configuración del enlace de Amazon SageMaker Debugger y las reglas integradas para depurar un modelo con el marco Tensorflow 2.1. |
| [Visualización de los tensores de depuración del entrenamiento MXNet](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_plot) | MXNet | Red neuronal convolucional de Gluon | Fashion MNIST | Ejecute un trabajo de entrenamiento y configure SageMaker Debugger para almacenar todos los tensores de este trabajo y, a continuación, visualice esos tensores en un cuaderno. |
| [Habilite la formación puntual con Amazon SageMaker Debugger](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_spot_training) | MXNet | Red neuronal convolucional de Gluon | Fashion MNIST | Descubra cómo el depurador recopila los datos tensoriales de un trabajo de entrenamiento en una instancia puntual y cómo utilizar las reglas integradas del depurador con el entrenamiento puntual gestionado. |
| [Explica un XGBoost modelo que predice los ingresos de una persona con Amazon Debugger SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/xgboost_census_explanations/xgboost-census-debugger-rules.html) | XGBoost | XGBoost Regresión | [Conjunto de datos del censo de adultos](https://archive.ics.uci.edu/ml/datasets/adult) | Aprenda a usar el gancho del depurador y las reglas integradas para recopilar y visualizar los datos tensoriales de un modelo de XGBoost regresión, como los valores de pérdida, las características y los valores de SHAP. |
Para encontrar visualizaciones avanzadas de los parámetros y casos de uso del modelo, consulte el siguiente tema en [Demostraciones y visualización avanzadas del depurador](debugger-visualization.md).
# Demostraciones y visualización avanzadas del depurador
Las siguientes demostraciones explican los casos de uso avanzados y los scripts de visualización con el depurador.
**Topics**
+ [Entrenar y depurar modelos con Amazon SageMaker Experiments y Debugger](#debugger-visualization-video-model-pruning)
+ [[Uso de SageMaker Debugger para supervisar el entrenamiento de un modelo de autocodificador convolucional](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/autoencoder_mnist/autoencoder_mnist.html)](#debugger-visualization-autoencoder_mnist)
+ [[Uso de SageMaker Debugger para monitorear las atenciones en el entrenamiento con modelos BERT](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/bert_attention_head_view/bert_attention_head_view.html)](#debugger-visualization-bert_attention_head_view)
+ [[Uso de SageMaker Debugger para visualizar los mapas de activación de clases en redes neuronales convolucionales () CNNs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/cnn_class_activation_maps/cnn_class_activation_maps.html)](#debugger-visualization-cnn_class_activation_maps)
## Entrenar y depurar modelos con Amazon SageMaker Experiments y Debugger
*Dra. Nathalie Rauschmayr, científica AWS aplicada \$1 Duración: 49 minutos 26 segundos*
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/Tnv6HsT1r4I)
Descubra cómo Amazon SageMaker Experiments y Debugger pueden simplificar la administración de sus trabajos de formación. Amazon SageMaker Debugger proporciona una visibilidad transparente de los trabajos de formación y guarda las métricas de formación en su bucket de Amazon S3. SageMaker Experiments le permite denominar la información de formación como *pruebas* a través de SageMaker Studio y permite visualizar el trabajo de formación. Esto le ayuda a mantener la calidad del modelo a la vez que reduce los parámetros menos importantes en función del rango de importancia.
En este vídeo se muestra una técnica de *poda de modelos* que hace que ResNet 50 AlexNet modelos previamente entrenados sean más livianos y asequibles, a la vez que se mantienen altos estándares de precisión de los modelos.
SageMaker AI Estimator entrena los algoritmos proporcionados por el zoológico de PyTorch modelos en un AWS Deep Learning Containers with PyTorch framework, y Debugger extrae las métricas de entrenamiento del proceso de entrenamiento.
El vídeo también muestra cómo configurar una regla personalizada del Debugger para comprobar la precisión de un modelo reducido, activar un CloudWatch evento de Amazon y una AWS Lambda función cuando la precisión alcanza un umbral y detener automáticamente el proceso de depuración para evitar iteraciones redundantes.
Los objetivos de aprendizaje son los siguientes:
+ Aprenda a usar la SageMaker IA para acelerar el entrenamiento de modelos de aprendizaje automático y mejorar la calidad de los modelos.
+ Aprenda a gestionar las iteraciones de entrenamiento con SageMaker Experiments capturando automáticamente los parámetros de entrada, las configuraciones y los resultados.
+ Descubrir cómo el depurador aporta transparencia al proceso de entrenamiento al capturar automáticamente datos de tensores en tiempo real de métricas como ponderaciones, gradientes y salidas de activación de redes neuronales convolucionales.
+ Se utiliza CloudWatch para activar Lambda cuando el depurador detecta problemas.
+ Domine el proceso de SageMaker formación con SageMaker Experiments y Debugger.
Puede encontrar los cuadernos y los guiones de entrenamiento utilizados en este vídeo de [SageMaker Debugger PyTorch Iterative Model Pruning](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_iterative_model_pruning).
La siguiente imagen muestra cómo el proceso de depuración del modelo iterativo reduce el tamaño al eliminar los 100 filtros menos significativos en función del rango de importancia evaluado mediante los gradientes y los resultados de activación. AlexNet
El proceso de poda redujo los 50 millones de parámetros iniciales a 18 millones. También redujo el tamaño estimado del modelo de 201 MB a 73 MB.
![\[Una imagen que contiene visualizaciones del resultado de la poda del modelo\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-model-pruning-results-alexnet.gif)
También es necesario realizar un seguimiento de la precisión del modelo, y en la siguiente imagen se muestra cómo se puede trazar el proceso de depuración del modelo para visualizar los cambios en la precisión del modelo en función del número de parámetros de Studio. SageMaker
![\[Imagen de la visualización de tensores con Debugger en Studio SageMaker\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-model-pruning-studio.png)
En SageMaker Studio, seleccione la pestaña **Experimentos**, seleccione una lista de tensores guardados por Debugger durante el proceso de depuración y, a continuación, cree un panel con una lista de componentes de **prueba**. Seleccione las diez iteraciones y elija **Agregar gráfico** para crear un **Gráfico de componentes de prueba**. Una vez que haya decidido qué modelo desea implementar, elija el componente de prueba y un menú para realizar una acción o elija **Implementar el modelo**.
**nota**
Para implementar un modelo en SageMaker Studio utilizando el siguiente ejemplo de cuaderno, añade una línea al final de la `train` función en el `train.py` script.
```
# In the train.py script, look for the train function in line 58.
def train(epochs, batch_size, learning_rate):
...
print('acc:{:.4f}'.format(correct/total))
hook.save_scalar("accuracy", correct/total, sm_metric=True)
# Add the following code to line 128 of the train.py script to save the pruned models
# under the current SageMaker Studio model directory
torch.save(model.state_dict(), os.environ['SM_MODEL_DIR'] + '/model.pt')
```
## [Uso de SageMaker Debugger para supervisar el entrenamiento de un modelo de autocodificador convolucional](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/autoencoder_mnist/autoencoder_mnist.html)
Este cuaderno muestra cómo SageMaker Debugger visualiza los tensores de un proceso de aprendizaje no supervisado (o autosupervisado) en un conjunto de datos de imágenes del MNIST de números escritos a mano.
El modelo de entrenamiento de este cuaderno es un autocodificador convolucional con el marco. MXNet El autocodificador convolucional tiene una red neuronal convolucional que consta en una parte codificadora y una parte decodificadora.
El codificador de este ejemplo tiene dos capas de convolución para producir una representación comprimida (variables latentes) de las imágenes de entrada. En este caso, el codificador produce una variable latente de tamaño (1, 20) a partir de una imagen de entrada original de tamaño (28, 28) y reduce significativamente el tamaño de los datos para el entrenamiento en 40 veces.
El decodificador tiene dos capas *deconvolucionales* y garantiza que las variables latentes preserven la información clave mediante la reconstrucción de imágenes de salida.
El codificador convolucional potencia algoritmos de agrupamiento con menor tamaño de datos de entrada, así como el rendimiento de algoritmos de agrupamiento como k-means, k-NN y t-Distributed Stochastic Neighbor Embedding (t-SNE).
Este ejemplo de cuaderno muestra cómo visualizar las variables latentes mediante el depurador, como se muestra en la siguiente animación. También muestra cómo el algoritmo t-SNE clasifica las variables latentes en diez clústeres y las proyecta en un espacio bidimensional. El esquema de color del gráfico de dispersión en el lado derecho de la imagen refleja los valores verdaderos para mostrar lo bien que el modelo BERT y el algoritmo t-SNE organizan las variables latentes en los clústeres.
![\[Una imagen conceptual del autocodificador convolucional\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-cnn-autoencoder-plot.gif)
## [Uso de SageMaker Debugger para monitorear las atenciones en el entrenamiento con modelos BERT](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/bert_attention_head_view/bert_attention_head_view.html)
Las Representaciones de codificador bidireccional de transformadores (BERT) constituyen un modelo de representación del lenguaje. Como refleja el nombre del modelo, BERT se basa en la *transferencia del aprendizaje* y el *modelo de transformadores* para el procesamiento de lenguaje natural (NLP).
El modelo BERT está preentrenado en tareas no supervisadas como predicción de palabras ausentes en una oración o predicción de la siguiente oración que seguiría naturalmente a una oración anterior. Los datos de entrenamiento contienen 3300 millones de palabras (tokens) de texto en inglés, como Wikipedia y libros electrónicos. Para un ejemplo sencillo, el modelo BERT puede prestar gran *atención* a los tokens de verbo o tokens de pronombre apropiados de un token de sujeto.
El modelo BERT previamente entrenado se puede ajustar con una capa de salida adicional para capacitarlo en tareas de PNL, como las respuestas automatizadas a las preguntas, la clasificación de textos y muchas otras. state-of-the-art
El depurador recopila los tensores del proceso de ajuste. En el contexto de NLP, el peso de las neuronas se denomina *atención*.
Este cuaderno muestra cómo utilizar el [modelo BERT previamente entrenado del zoológico de modelos GluonNLP en el](https://gluon-nlp.mxnet.io/model_zoo/bert/index.html) conjunto de datos de preguntas y respuestas de Stanford y cómo SageMaker configurar Debugger para monitorear el trabajo de capacitación.
La representación de *puntuaciones de atención* y neuronas individuales en la consulta y vectores clave puede ayudar a identificar las causas de predicciones de modelos incorrectas. Con SageMaker AI Debugger, puedes recuperar los tensores y trazar la vista desde el punto de *vista del cabezal de atención en tiempo real a medida* que avanza el entrenamiento, así como comprender lo que aprende el modelo.
La siguiente animación muestra las puntuaciones de atención de los primeros 20 tokens de entrada para diez iteraciones en el trabajo de entrenamiento proporcionado en el ejemplo del bloc de notas.
![\[Una animación de las puntuaciones de atención\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-attention_scores.gif)
## [Uso de SageMaker Debugger para visualizar los mapas de activación de clases en redes neuronales convolucionales () CNNs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/cnn_class_activation_maps/cnn_class_activation_maps.html)
Este cuaderno muestra cómo usar SageMaker Debugger para trazar mapas de activación de clases para la detección y clasificación de imágenes en redes neuronales convolucionales (). CNNs En el aprendizaje profundo, una *red neuronal convolucional (CNN o ConvNet)* es una clase de redes neuronales profundas que se suele aplicar al análisis de imágenes visuales. Una de las aplicaciones que adopta los mapas de activación de clases son los vehículos sin conductor, que requieren detección y clasificación de imágenes instantánea como señales de tráfico, carreteras y obstáculos.
En este cuaderno, el PyTorch ResNet modelo se basa en [el conjunto de datos de señales de tráfico alemán](http://benchmark.ini.rub.de/), que contiene más de 40 clases de objetos relacionados con el tráfico y más de 50 000 imágenes en total.
![\[Una animación de mapas de activación de clases en CNN\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-cnn-class-activation-maps.gif)
Durante el proceso de entrenamiento, SageMaker Debugger recopila tensores para trazar los mapas de activación de las clases en tiempo real. Como se muestra en la imagen animada, el mapa de activación de clases (también llamado *mapa de prominencia*) resalta regiones con alta activación en color rojo.
Con los tensores capturados por el depurador, puede visualizar cómo evoluciona el mapa de activación durante el entrenamiento del modelo. El modelo comienza detectando el borde en la esquina inferior izquierda al comienzo del trabajo de entrenamiento. A medida que avanza el entrenamiento, el enfoque se desplaza hacia el centro y detecta la señal de límite de velocidad y el modelo predice con éxito la imagen de entrada como Clase 3, que es una clase de señal de límite de velocidad de 60 km/h, con un nivel de confianza del 97 %.
# Depuración de trabajos de formación con Amazon SageMaker Debugger
Para preparar el guion de entrenamiento y ejecutar los trabajos de entrenamiento con SageMaker Debugger para depurar el progreso del entrenamiento del modelo, debe seguir el proceso típico de dos pasos: modificar el guion de entrenamiento con el SDK de `sagemaker-debugger` Python y crear un estimador de SageMaker IA con el SDK de Python. SageMaker Consulte los siguientes temas para aprender a utilizar SageMaker la funcionalidad de depuración de Debugger.
**Topics**
+ [Adaptación del script de entrenamiento para registrar un enlace](debugger-modify-script.md)
+ [Lance trabajos de formación con Debugger utilizando el SDK de SageMaker Python](debugger-configuration-for-debugging.md)
+ [SageMaker Informe interactivo de Debugger para XGBoost](debugger-report-xgboost.md)
+ [Reglas de Action on Amazon SageMaker Debugger](debugger-action-on-rules.md)
+ [Visualice los tensores de salida de Amazon SageMaker Debugger en TensorBoard](debugger-enable-tensorboard-summaries.md)
# Adaptación del script de entrenamiento para registrar un enlace
Amazon SageMaker Debugger incluye una biblioteca cliente llamada [`sagemaker-debugger`Python SDK](https://sagemaker-debugger.readthedocs.io/en/website). El `sagemaker-debugger` Python SDK proporciona herramientas para adaptar el script de entrenamiento antes del entrenamiento y herramientas de análisis después del entrenamiento. En esta página, aprenderá a adaptar su script de entrenamiento mediante la biblioteca cliente.
El `sagemaker-debugger` Python SDK proporciona funciones envolventes que ayudan a registrar un enlace para extraer los tensores del modelo, sin alterar el script de entrenamiento. Para empezar a recopilar los tensores de salida del modelo y depurarlos para detectar problemas de entrenamiento, realice las siguientes modificaciones en su script de entrenamiento.
**sugerencia**
Mientras siga en esta página, utilice la [`sagemaker-debugger` documentación de SDK de código abierto ](https://sagemaker-debugger.readthedocs.io/en/website/index.html) para las referencias de la API.
**Topics**
+ [Adapte su guion PyTorch de entrenamiento](debugger-modify-script-pytorch.md)
+ [Adapta tu guion de entrenamiento TensorFlow](debugger-modify-script-tensorflow.md)
# Adapte su guion PyTorch de entrenamiento
Para empezar a recopilar los tensores de salida del modelo y solucionar los problemas de entrenamiento, realiza las siguientes modificaciones en tu guion de PyTorch entrenamiento.
**nota**
SageMaker El depurador no puede recopilar los tensores de salida del modelo a partir de las operaciones de la API. [https://pytorch.org/docs/stable/nn.functional.html](https://pytorch.org/docs/stable/nn.functional.html) Al escribir un guion de PyTorch entrenamiento, se recomienda utilizar los [https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html](https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html)módulos en su lugar.
## Para la versión PyTorch 1.12.0
Si traes un guion de PyTorch entrenamiento, puedes ejecutar el trabajo de entrenamiento y extraer los tensores de salida del modelo con unas cuantas líneas de código adicionales en el guion de entrenamiento. Debes usar el [enlace APIs](https://sagemaker-debugger.readthedocs.io/en/website/hook-api.html) de la biblioteca del `sagemaker-debugger` cliente. Siga las siguientes instrucciones que desglosan los pasos con ejemplos de código.
1. Creación de un enlace.
**(Recomendado) Para trabajos de formación dentro de la SageMaker IA**
```
import smdebug.pytorch as smd
hook=smd.get_hook(create_if_not_exists=True)
```
Cuando lanzas un trabajo de formación [Lance trabajos de formación con Debugger utilizando el SDK de SageMaker Python](debugger-configuration-for-debugging.md) con alguna de las DebuggerHookConfig reglas o reglas de tu estimador, la SageMaker IA añade un archivo de configuración JSON a la instancia de entrenamiento que recoge la `get_hook` función. TensorBoardConfig Ten en cuenta que si no incluyes ninguna de las configuraciones APIs en tu estimador, el enlace no podrá encontrar ningún archivo de configuración y la función volverá a aparecer. `None`
**(Opcional) Para trabajos de formación ajenos a la IA SageMaker **
Si ejecuta tareas de formación en modo local, directamente en instancias de SageMaker Notebook, instancias de Amazon EC2 o sus propios dispositivos locales, utilice `smd.Hook` class para crear un enlace. Sin embargo, este enfoque solo puede almacenar las colecciones de tensores y utilizarlas para TensorBoard la visualización. SageMaker Las reglas integradas en Debugger no funcionan con el modo local porque requieren instancias de entrenamiento de aprendizaje automático con SageMaker IA y S3 para almacenar los resultados de las instancias remotas en tiempo real. En este caso, la API `smd.get_hook` devolverá `None`.
Si quiere crear un enlace manual para guardar los tensores en modo local, use el siguiente fragmento de código con la lógica para comprobar si la API `smd.get_hook` devuelve `None` y cree un enlace manual con la clase `smd.Hook`. Tenga en cuenta que puede especificar cualquier directorio de salida en su máquina local.
```
import smdebug.pytorch as smd
hook=smd.get_hook(create_if_not_exists=True)
if hook is None:
hook=smd.Hook(
out_dir='/path/to/your/local/output/',
export_tensorboard=True
)
```
1. Encapsule su modelo con los métodos de clase del enlace.
El método `hook.register_module()` toma el modelo y recorre cada capa en iteración, buscando tensores que coincidan con las expresiones regulares que proporcionarás a lo largo de la configuración en [Lance trabajos de formación con Debugger utilizando el SDK de SageMaker Python](debugger-configuration-for-debugging.md). Los tensores que pueden recopilarse mediante este método de enlace son ponderaciones, sesgos, activaciones, gradientes, entradas y salidas.
```
hook.register_module(model)
```
**sugerencia**
Si recopila todos los tensores de salida de un modelo de aprendizaje profundo de gran tamaño, el tamaño total de esas colecciones puede crecer exponencialmente y provocar cuellos de botella. Si desea guardar tensores específicos, también puede utilizar el método `hook.save_tensor()`. Este método le ayudará a elegir la variable para el tensor específico y guardarla en una colección personalizada con el nombre que quiera. Para obtener más información sobre este paso, consulte el [paso 7](#debugger-modify-script-pytorch-save-custom-tensor).
1. Encapsule la función de pérdida con los métodos de clase del enlace.
El método `hook.register_loss` consiste en ajustar la función de pérdida. Extrae todos los valores de pérdida cada `save_interval` que haya establecido durante la configuración [Lance trabajos de formación con Debugger utilizando el SDK de SageMaker Python](debugger-configuration-for-debugging.md), y los guarda en la colección `"losses"`.
```
hook.register_loss(loss_function)
```
1. Añada `hook.set_mode(ModeKeys.TRAIN)` al bloque de trenes. Esto indica que la colección de tensores se extrae durante la fase de entrenamiento.
```
def train():
...
hook.set_mode(ModeKeys.TRAIN)
```
1. Añada `hook.set_mode(ModeKeys.EVAL)` al bloque de validación. Esto indica que la colección de tensores se extrae durante la fase de validación.
```
def validation():
...
hook.set_mode(ModeKeys.EVAL)
```
1. Utilice [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar) para guardar escalares personalizados. Puede guardar valores escalares que no estén en el modelo. Por ejemplo, si desea registrar los valores de precisión calculados durante la evaluación, añada la siguiente línea de código debajo de la línea en la que calcula la precisión.
```
hook.save_scalar("accuracy", accuracy)
```
Tenga en cuenta que debe proporcionar una cadena como primer argumento para nombrar la colección escalar personalizada. Este es el nombre que se usará para visualizar los valores escalares y puede ser cualquier cadena que desees. TensorBoard
1. Utilice [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_tensor](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_tensor) para guardar tensores personalizados. Del mismo modo que [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar), puede guardar tensores adicionales y definir su propia colección de tensores. Por ejemplo, puede extraer los datos de imagen de entrada que se pasan al modelo y guardarlos como un tensor personalizado añadiendo la siguiente línea de código, donde `"images"` es un nombre de ejemplo del tensor personalizado, `image_inputs` es una variable de ejemplo para los datos de la imagen de entrada.
```
hook.save_tensor("images", image_inputs)
```
Tenga en cuenta que debe proporcionar una cadena al primer argumento para nombrar el tensor personalizado. `hook.save_tensor()` tiene el tercer argumento `collections_to_write` para especificar la colección de tensores para guardar el tensor personalizado. El valor predeterminado es `collections_to_write="default"`. Si no especifica explícitamente el tercer argumento, el tensor personalizado se guardará en la colección de tensores `"default"`.
Cuando haya terminado de adaptar su script de entrenamiento, continúe con [Lance trabajos de formación con Debugger utilizando el SDK de SageMaker Python](debugger-configuration-for-debugging.md).
# Adapta tu guion de entrenamiento TensorFlow
Para empezar a recopilar los tensores de salida del modelo y solucionar los problemas de entrenamiento, realiza las siguientes modificaciones en tu guion de TensorFlow entrenamiento.
**Crea un enlace para los trabajos de entrenamiento dentro de la IA SageMaker **
```
import smdebug.tensorflow as smd
hook=smd.get_hook(hook_type="keras", create_if_not_exists=True)
```
Esto crea un gancho cuando empiezas un trabajo SageMaker de formación. Cuando inicias un trabajo de formación [Lance trabajos de formación con Debugger utilizando el SDK de SageMaker Python](debugger-configuration-for-debugging.md) con alguna de las `DebuggerHookConfig``TensorBoardConfig`, o `Rules` en tu estimador, la SageMaker IA añade un archivo de configuración JSON a la instancia de formación que recoge el `smd.get_hook` método. Ten en cuenta que si no incluyes ninguna de las configuraciones APIs en tu estimador, el enlace no podrá encontrar ningún archivo de configuración y la función volverá a aparecer. `None`
**(Opcional) Crea un gancho para entrenar trabajos ajenos a la IA SageMaker **
Si ejecuta tareas de formación en modo local, directamente en instancias de SageMaker Notebook, instancias de Amazon EC2 o sus propios dispositivos locales, utilice `smd.Hook` class para crear un enlace. Sin embargo, este enfoque solo puede almacenar las colecciones de tensores y utilizarlas para TensorBoard la visualización. SageMaker Las reglas integradas del depurador no funcionan con el modo local. En este caso, el método `smd.get_hook` también devuelve `None`.
Si quiere crear un enlace manual, utilice el siguiente fragmento de código con la lógica para comprobar si el enlace devuelve `None` y cree un enlace manual con la clase `smd.Hook`.
```
import smdebug.tensorflow as smd
hook=smd.get_hook(hook_type="keras", create_if_not_exists=True)
if hook is None:
hook=smd.KerasHook(
out_dir='/path/to/your/local/output/',
export_tensorboard=True
)
```
Tras añadir el código de creación del gancho, continúa con el siguiente tema para TensorFlow Keras.
**nota**
SageMaker Actualmente, el depurador solo es compatible con TensorFlow Keras.
## Registra el gancho en tu guion de entrenamiento de TensorFlow Keras
El siguiente procedimiento le explica cómo usar el enlace y sus métodos para recopilar escalares y tensores de salida de su modelo y optimizador.
1. Incluya el modelo y el optimizador de Keras con los métodos de clase del enlace.
El método `hook.register_model()` toma el modelo e itera por cada capa, buscando tensores que coincidan con las expresiones regulares que proporcionarás a lo largo de la configuración en [Lance trabajos de formación con Debugger utilizando el SDK de SageMaker Python](debugger-configuration-for-debugging.md). Los tensores que se pueden recopilar mediante este método de enlace son las ponderaciones, los sesgos y las activaciones.
```
model=tf.keras.Model(...)
hook.register_model(model)
```
1. Encapsule el optimizador según el método `hook.wrap_optimizer()`.
```
optimizer=tf.keras.optimizers.Adam(...)
optimizer=hook.wrap_optimizer(optimizer)
```
1. Compila el modelo en modo ansioso en TensorFlow.
Para recopilar los tensores del modelo, como los tensores de entrada y salida de cada capa, debe ejecutar el entrenamiento en modo Eager. De lo contrario, SageMaker AI Debugger no podrá recolectar los tensores. Sin embargo, es posible recopilar otros tensores, como las ponderaciones del modelo, los sesgos y la pérdida, sin ejecutarlos explícitamente en modo Eager.
```
model.compile(
loss="categorical_crossentropy",
optimizer=optimizer,
metrics=["accuracy"],
# Required for collecting tensors of each layer
run_eagerly=True
)
```
1. Registre el enlace al método [https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit](https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit).
Para recopilar los tensores de los enlaces que haya registrado, agregue `callbacks=[hook]` al método de la clase `model.fit()` Keras. De este modo, el enlace `sagemaker-debugger` se transferirá como retrollamada de Keras.
```
model.fit(
X_train, Y_train,
batch_size=batch_size,
epochs=epoch,
validation_data=(X_valid, Y_valid),
shuffle=True,
callbacks=[hook]
)
```
1. TensorFlow La versión 2.x solo proporciona variables de gradiente simbólicas que no proporcionan acceso a sus valores. Para recopilar gradientes, encapsule `tf.GradientTape` con el método [https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html#tensorflow-specific-hook-api](https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html#tensorflow-specific-hook-api), que requiere que escriba su propio paso de entrenamiento de la siguiente manera.
```
def training_step(model, dataset):
with hook.wrap_tape(tf.GradientTape()) as tape:
pred=model(data)
loss_value=loss_fn(labels, pred)
grads=tape.gradient(loss_value, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
```
Al encapsular la cinta, el enlace `sagemaker-debugger` puede identificar los tensores de salida, como los gradientes, los parámetros y las pérdidas. Al agrupar la cinta, se garantiza que el `hook.wrap_tape()` método se ajuste a las funciones del objeto de la cinta `push_tape()``pop_tape()`, por ejemplo`gradient()`,, configurará los grabadores de SageMaker Debugger y guardará los tensores que se proporcionan como entrada `gradient()` (variables entrenables y pérdida) y salida (gradientes). `gradient()`
**nota**
Para recopilar información con un ciclo de entrenamiento personalizado, asegúrese de usar el modo Eager. De lo contrario, SageMaker Debugger no podrá recopilar ningún tensor.
Para ver una lista completa de las acciones que APIs ofrece el `sagemaker-debugger` gancho para construir ganchos y guardar tensores, consulta [Métodos de gancho](https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html) en la *documentación del SDK de `sagemaker-debugger` Python*.
Cuando haya terminado de adaptar su script de entrenamiento, continúe con [Lance trabajos de formación con Debugger utilizando el SDK de SageMaker Python](debugger-configuration-for-debugging.md).
# Lance trabajos de formación con Debugger utilizando el SDK de SageMaker Python
Para configurar un estimador de SageMaker IA con SageMaker Debugger, utilice el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) y especifique los parámetros específicos del Debugger. Para aprovechar al máximo la funcionalidad de depuración, debe configurar tres parámetros `debugger_hook_config`, `tensorboard_output_config` y `rules`.
**importante**
Antes de crear y ejecutar el método de ajuste del estimador para lanzar un trabajo de entrenamiento, asegúrese de adaptar el script de entrenamiento siguiendo las instrucciones que se indican en [Adaptación del script de entrenamiento para registrar un enlace](debugger-modify-script.md).
## Creación de un estimador de IA con parámetros específicos del depurador SageMaker
Los ejemplos de código de esta sección muestran cómo construir un estimador de SageMaker IA con los parámetros específicos del Debugger.
**nota**
Los siguientes ejemplos de código son plantillas para construir los estimadores del marco de SageMaker IA y no se pueden ejecutar directamente. Debe continuar con las siguientes secciones y configurar los parámetros específicos del depurador.
------
#### [ PyTorch ]
```
# An example of constructing a SageMaker AI PyTorch estimator
import boto3
import sagemaker
from sagemaker.pytorch import PyTorch
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
session=boto3.session.Session()
region=session.region_name
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=PyTorch(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.12.0",
py_version="py37",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ TensorFlow ]
```
# An example of constructing a SageMaker AI TensorFlow estimator
import boto3
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
session=boto3.session.Session()
region=session.region_name
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule()),
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=TensorFlow(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ MXNet ]
```
# An example of constructing a SageMaker AI MXNet estimator
import sagemaker
from sagemaker.mxnet import MXNet
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=MXNet(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.7.0",
py_version="py37",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ XGBoost ]
```
# An example of constructing a SageMaker AI XGBoost estimator
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=XGBoost(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.5-1",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ Generic estimator ]
```
# An example of constructing a SageMaker AI generic estimator using the XGBoost algorithm base image
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
region=boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.5-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
Configure los siguientes parámetros para activar SageMaker Debugger:
+ `debugger_hook_config`(un objeto de [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)): necesario para activar el gancho en el guion de entrenamiento adaptado durante el entrenamiento[Adaptación del script de entrenamiento para registrar un enlace](debugger-modify-script.md), configurar el lanzador de SageMaker entrenamiento (estimador) para recopilar los tensores de salida del trabajo de entrenamiento y guardar los tensores en un depósito S3 protegido o en una máquina local. Si quiere aprender a configurar el parámetro `debugger_hook_config`, consulte [Configurar SageMaker Debugger para guardar los tensores](debugger-configure-hook.md).
+ `rules`(una lista de [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule)objetos): configure este parámetro para activar las reglas integradas del SageMaker Debugger que desee ejecutar en tiempo real. Las reglas integradas son lógicas que depuran automáticamente el progreso del entrenamiento del modelo y detectan los problemas de entrenamiento mediante el análisis de los tensores de salida guardados en el depósito protegido de S3. Si quiere aprender a configurar el parámetro `rules`, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md). Para obtener una lista completa de las reglas integradas para depurar los tensores de salida, consulte [Regla de depurador](debugger-built-in-rules.md#debugger-built-in-rules-Rule). Si quiere crear su propia lógica para detectar cualquier problema de entrenamiento, consulte [Creación de reglas personalizadas mediante la biblioteca cliente del depurador](debugger-custom-rules.md).
**nota**
Las reglas integradas solo están disponibles a través de instancias SageMaker de entrenamiento. No puede utilizarlas en modo local.
+ `tensorboard_output_config`(un objeto de [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig)): configure SageMaker Debugger para que recopile los tensores de salida en un formato TensorBoard compatible y los guarde en la ruta de salida de S3 especificada en el objeto. `TensorBoardOutputConfig` Para obtener más información, consulte [Visualice los tensores de salida de Amazon SageMaker Debugger en TensorBoard](debugger-enable-tensorboard-summaries.md).
**nota**
El `tensorboard_output_config` debe configurarse con el parámetro `debugger_hook_config`, que también requiere que adapte el script de entrenamiento añadiendo el enlace `sagemaker-debugger`.
**nota**
SageMaker El depurador guarda de forma segura los tensores de salida en las subcarpetas del bucket de S3. Por ejemplo, el formato del URI del bucket de S3 predeterminado de su cuenta es `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>///`. SageMaker Debugger creó dos subcarpetas:, y. `debug-output` `rule-output` Si añade el parámetro `tensorboard_output_config`, también encontrará la carpeta `tensorboard-output`.
Consulte los siguientes temas para encontrar más ejemplos de cómo configurar en detalle los parámetros específicos del depurador.
**Topics**
+ [Creación de un estimador de IA con parámetros específicos del depurador SageMaker](#debugger-configuration-structure)
+ [Configurar SageMaker Debugger para guardar los tensores](debugger-configure-hook.md)
+ [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md)
+ [Desactivar el depurador](debugger-turn-off.md)
+ [Métodos útiles de SageMaker clases de estimadores de IA para Debugger](debugger-estimator-classmethods.md)
# Configurar SageMaker Debugger para guardar los tensores
*Los tensores* son recopilaciones de datos de parámetros actualizados de los pases hacia atrás y hacia adelante de cada iteración de entrenamiento. SageMaker El depurador recopila los tensores de salida para analizar el estado de un trabajo de entrenamiento. SageMaker Las operaciones del depurador [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)y de la [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)API proporcionan métodos para agrupar los tensores en *colecciones* y guardarlos en un depósito S3 de destino. Los siguientes temas muestran cómo usar las operaciones de `CollectionConfig` y de la API de `DebuggerHookConfig`, seguido de ejemplos sobre cómo usar el enlace del depurador para guardar, acceder y visualizar los tensores de salida.
Al crear un estimador de SageMaker IA, active SageMaker Debugger especificando el parámetro. `debugger_hook_config` Los siguientes temas incluyen ejemplos de cómo configurar `debugger_hook_config` mediante las operaciones de la API de `CollectionConfig` y `DebuggerHookConfig` para extraer tensores de los trabajos de entrenamiento y guardarlos.
**nota**
Una vez configurados y activados correctamente, SageMaker Debugger guarda los tensores de salida en un bucket S3 predeterminado, a menos que se especifique lo contrario. El formato del URI del bucket de S3 predeterminado es `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>//debug-output/`.
**Topics**
+ [Configuración de las colecciones de tensores mediante la API de `CollectionConfig`](debugger-configure-tensor-collections.md)
+ [Configuración de la API de `DebuggerHookConfig` para guardar los tensores](debugger-configure-tensor-hook.md)
+ [Ejemplos de cuadernos y de código para configurar el enlace del depurador](debugger-save-tensors.md)
# Configuración de las colecciones de tensores mediante la API de `CollectionConfig`
Utilice la operación de la API `CollectionConfig` para configurar las colecciones de tensores. El depurador proporciona colecciones de tensores prediseñadas que cubren una variedad de expresiones regulares (regex) de parámetros si se utilizan marcos de aprendizaje profundo y algoritmos de machine learning compatibles con el depurador. Añada las colecciones de tensores integradas que quiera depurar tal como se muestra en el siguiente código de ejemplo.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(name="weights"),
CollectionConfig(name="gradients")
]
```
Las colecciones anteriores configuraron el enlace del depurador para guardar los tensores cada 500 pasos en función del valor predeterminado `"save_interval"`.
Para obtener una lista completa de las colecciones integradas del depurador disponibles, consulte [Colecciones integradas del depurador](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#collection).
Si quiere personalizar las colecciones integradas, como cambiar los intervalos de guardado y tensor regex, utilice la siguiente plantilla `CollectionConfig` para ajustar los parámetros.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(
name="tensor_collection",
parameters={
"key_1": "value_1",
"key_2": "value_2",
...
"key_n": "value_n"
}
)
]
```
Para obtener más información sobre las claves de parámetros disponibles, consulte [CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Por ejemplo, el siguiente ejemplo de código muestra cómo ajustar los intervalos de almacenamiento de la colección de tensores de "pérdidas" en las distintas fases del entrenamiento: ahorrar pérdidas cada 100 pasos en la fase de entrenamiento y pérdidas de validación cada 10 pasos en la fase de validación.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
```
**sugerencia**
Este objeto de configuración de la colección de tensores se puede utilizar tanto [DebuggerHookConfig](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-hook.html#debugger-configure-tensor-hook)para las operaciones de la API [Rule como para las de Rule](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-rules.html#debugger-built-in-rules-configuration-param-change).
# Configuración de la API de `DebuggerHookConfig` para guardar los tensores
Usa la [DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html #sagemaker.debugger.DebuggerHookConfig)API para crear un `debugger_hook_config` objeto con el `collection_configs` objeto que creaste en el paso anterior.
```
from sagemaker.debugger import DebuggerHookConfig
debugger_hook_config=DebuggerHookConfig(
collection_configs=collection_configs
)
```
El depurador guarda los tensores de salida del entrenamiento del modelo en el bucket de S3 predeterminado. El formato del URI del bucket de S3 predeterminado es `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>//debug-output/.`
Si quiere especificar un URI del bucket de S3 exacto, use el siguiente ejemplo de código:
```
from sagemaker.debugger import DebuggerHookConfig
debugger_hook_config=DebuggerHookConfig(
s3_output_path="specify-uri"
collection_configs=collection_configs
)
```
Para obtener más información, consulte [DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Ejemplos de cuadernos y de código para configurar el enlace del depurador
Las siguientes secciones proporcionan cuadernos y ejemplos de código sobre cómo usar el enlace del depurador para guardar, acceder y visualizar los tensores de salida.
**Topics**
+ [Ejemplos de cuadernos de visualización de tensores](#debugger-tensor-visualization-notebooks)
+ [Guardado de tensores utilizando colecciones integradas del depurador](#debugger-save-built-in-collections)
+ [Guardado de tensores modificando colecciones integradas del depurador](#debugger-save-modified-built-in-collections)
+ [Guardado de tensores utilizando colecciones personalizadas del depurador](#debugger-save-custom-collections)
## Ejemplos de cuadernos de visualización de tensores
Los dos ejemplos de cuadernos siguientes muestran el uso avanzado de Amazon SageMaker Debugger para visualizar tensores. El depurador proporciona una visión transparente del entrenamiento de modelos de aprendizaje profundo.
+ [Análisis tensorial interactivo en Studio Notebook con SageMaker MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_analysis)
Este ejemplo de cuaderno muestra cómo visualizar los tensores guardados con Amazon SageMaker Debugger. Al visualizar los tensores, podrá ver cómo cambian los valores del tensor mientras se entrena algoritmos de aprendizaje profundo. Este cuaderno incluye un trabajo de formación con una red neuronal mal configurada y utiliza Amazon SageMaker Debugger para agregar y analizar los tensores, incluidos los gradientes, los resultados de activación y los pesos. Por ejemplo, el gráfico siguiente muestra la distribución de gradientes de una capa convolucional que sufre un problema de desaparición de gradiente.
![\[Gráfico que representa la distribución de gradientes.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-vanishing-gradient.gif)
Este cuaderno también ilustra cómo una buena configuración inicial de hiperparámetros mejora el proceso de entrenamiento al generar los mismos gráficos de distribución de tensores.
+ [Visualización y depuración de tensores a partir del entrenamiento con modelos MXNet ](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_plot)
Este ejemplo de cuaderno muestra cómo guardar y visualizar los tensores de un trabajo de entrenamiento con un modelo MXNet Gluon con Amazon SageMaker Debugger. Muestra que Debugger está configurado para guardar todos los tensores en un bucket de Amazon S3 y recupera los resultados de ReLu activación para la visualización. La siguiente figura muestra una visualización tridimensional de los resultados de activación. ReLu La combinación de colores se establece en azul para indicar valores cercanos a 0 y en amarillo para indicar valores cercanos a 1.
![\[Una visualización de las salidas de activación ReLU\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/tensorplot.gif)
En este cuaderno, la `TensorPlot` clase importada `tensor_plot.py` está diseñada para trazar redes neuronales convolucionales (CNNs) que toman imágenes bidimensionales como entradas. El script `tensor_plot.py` viene proporcionado con el cuaderno para recuperar tensores mediante el depurador y visualizar la CNN. Puede ejecutar este cuaderno en SageMaker Studio para reproducir la visualización del tensor e implementar su propio modelo de red neuronal convolucional.
+ [Análisis tensorial en tiempo real en un cuaderno con SageMaker MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_realtime_analysis)
Este ejemplo lo guía a través de la instalación de los componentes necesarios para emitir tensores en un trabajo de SageMaker entrenamiento de Amazon y el uso de las operaciones de la API Debugger para acceder a esos tensores mientras se ejecuta el entrenamiento. Un modelo CNN de gluones se entrena en el conjunto de datos Fashion MNIST. Mientras se ejecuta el trabajo, verá cómo el depurador recupera los resultados de activación de la primera capa convolucional de cada uno de los 100 lotes y los visualiza. Asimismo, esto le mostrará cómo visualizar las ponderaciones cuando haya concluido el trabajo.
## Guardado de tensores utilizando colecciones integradas del depurador
Puede usar colecciones integradas de tensores usando la API `CollectionConfig` y guardarlas usando la API `DebuggerHookConfig`. En el siguiente ejemplo, se muestra cómo utilizar los ajustes predeterminados de las configuraciones de los enlaces del depurador para crear un estimador de IA. SageMaker TensorFlow También puedes utilizarla para, y para los MXNet estimadores PyTorch. XGBoost
**nota**
En el siguiente código de ejemplo, el parámetro `s3_output_path` es opcional para `DebuggerHookConfig` es opcional. Si no lo especificas, Debugger guarda los tensores en`s3:///debug-output/`, donde `` es la ruta de salida predeterminada de los trabajos de entrenamiento. SageMaker Por ejemplo:
```
"s3://sagemaker-us-east-1-111122223333/sagemaker-debugger-training-YYYY-MM-DD-HH-MM-SS-123/debug-output"
```
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to call built-in collections
collection_configs=[
CollectionConfig(name="weights"),
CollectionConfig(name="gradients"),
CollectionConfig(name="losses"),
CollectionConfig(name="biases")
]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-built-in-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Para ver una lista de colecciones integradas en el depurador, consulte [Colecciones integradas en el depurador](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#collection).
## Guardado de tensores modificando colecciones integradas del depurador
Puede modificar las colecciones integradas del depurador mediante la operación de la API `CollectionConfig`. El siguiente ejemplo muestra cómo modificar la `losses` colección integrada y construir un SageMaker estimador de IA. TensorFlow También puedes usarlo para MXNet, PyTorch y estimadores. XGBoost
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to call and modify built-in collections
collection_configs=[
CollectionConfig(
name="losses",
parameters={"save_interval": "50"})]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-modified-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Para obtener una lista completa de `CollectionConfig` parámetros, consulta la API del [depurador CollectionConfig ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
## Guardado de tensores utilizando colecciones personalizadas del depurador
También puede guardar una cantidad reducida de tensores en lugar de un conjunto completo de tensores; por ejemplo, si desea reducir la cantidad de datos guardados en el bucket de Amazon S3. En el ejemplo siguiente se muestra cómo personalizar la configuración del enlace del depurador para especificar los tensores que quiera guardar. Puede usarla para TensorFlow, MXNet PyTorch, y XGBoost estimadores.
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to create a custom collection
collection_configs=[
CollectionConfig(
name="custom_activations_collection",
parameters={
"include_regex": "relu|tanh", # Required
"reductions": "mean,variance,max,abs_mean,abs_variance,abs_max"
})
]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-custom-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
[Para obtener una lista completa de `CollectionConfig` parámetros, consulte Debugger. CollectionConfig](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk)
# Cómo configurar reglas integradas del depurador
En los siguientes temas, aprenderá a usar las reglas integradas del SageMaker Debugger. Las reglas integradas de Amazon SageMaker Debugger analizan los tensores emitidos durante el entrenamiento de un modelo. SageMaker AI Debugger ofrece una operación de `Rule` API que monitorea el progreso y los errores del trabajo de capacitación para garantizar el éxito del entrenamiento del modelo. Por ejemplo, las reglas pueden detectar si los gradientes son demasiado grandes o demasiado pequeños, si un modelo está sobreajustado o sobreentrenado y si un trabajo de entrenamiento no reduce la pérdida de función y mejora. Para ver una lista completa de reglas integradas disponibles, consulte [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
**Topics**
+ [Uso de reglas integradas del depurador con los ajustes de parámetros predeterminados](debugger-built-in-rules-configuration.md)
+ [Uso de reglas integradas del depurador con valores de parámetros personalizados](debugger-built-in-rules-configuration-param-change.md)
+ [Ejemplos de cuadernos y ejemplos de código para configurar las reglas del depurador](debugger-built-in-rules-example.md)
# Uso de reglas integradas del depurador con los ajustes de parámetros predeterminados
Para especificar las reglas integradas del depurador en un estimador, debe configurar un objeto de la lista. El siguiente código de ejemplo muestra la estructura básica de la lista de las reglas integradas del depurador:
```
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.built_in_rule_name_1()),
Rule.sagemaker(rule_configs.built_in_rule_name_2()),
...
Rule.sagemaker(rule_configs.built_in_rule_name_n()),
... # You can also append more profiler rules in the ProfilerRule.sagemaker(rule_configs.*()) format.
]
```
Para obtener más información sobre los valores de los parámetros predeterminados y las descripciones de la regla integrada, consulte[Lista de reglas integradas del depurador](debugger-built-in-rules.md).
Para encontrar la referencia de la API SageMaker Debugger, consulta [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.sagemaker.debugger.rule_configs](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.sagemaker.debugger.rule_configs)y. [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule)
Por ejemplo, para inspeccionar el rendimiento general del entrenamiento y el progreso de su modelo, cree un estimador de SageMaker IA con la siguiente configuración de reglas integrada.
```
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.loss_not_decreasing()),
Rule.sagemaker(rule_configs.overfit()),
Rule.sagemaker(rule_configs.overtraining()),
Rule.sagemaker(rule_configs.stalled_training_rule())
]
```
Al iniciar el trabajo de entrenamiento, el depurador recopila los datos de utilización de los recursos del sistema cada 500 milisegundos y los valores de pérdida y precisión cada 500 pasos de forma predeterminada. El depurador analiza la utilización de los recursos para identificar si su modelo tiene problemas de cuellos de botella. El `loss_not_decreasing`, `overfit`, `overtraining` y `stalled_training_rule` monitoriza si su modelo está optimizando la función de pérdida sin esos problemas de entrenamiento. Si las reglas detectan anomalías en el entrenamiento, el estado de evaluación de la regla cambia a `IssueFound`. Puede configurar acciones automatizadas, como notificar problemas de formación y detener los trabajos de formación mediante Amazon CloudWatch Events y AWS Lambda. Para obtener más información, consulte [Reglas de Action on Amazon SageMaker Debugger](debugger-action-on-rules.md).
# Uso de reglas integradas del depurador con valores de parámetros personalizados
Si desea ajustar los valores de los parámetros de las reglas integradas y personalizar la expresión regular de la colección de tensores, configure los parámetros `rule_parameters` y `base_config` para los métodos de las clases `ProfilerRule.sagemaker` y `Rule.sagemaker`. En el caso de los métodos de la clase `Rule.sagemaker`, también puede personalizar las colecciones de tensores mediante el parámetro `collections_to_save`. Las instrucciones sobre cómo usar la clase `CollectionConfig` están disponibles en[Configuración de las colecciones de tensores mediante la API de `CollectionConfig`](debugger-configure-tensor-collections.md).
Utilice la siguiente plantilla de configuración para que las reglas integradas personalicen los valores de los parámetros. Al cambiar los parámetros de la regla como desee, puede ajustar la sensibilidad de las reglas que se vayan a activar.
+ El argumento `base_config` es desde donde se llaman a los métodos de reglas integrados.
+ El argumento `rule_parameters` consiste en ajustar los valores clave predeterminados de las reglas integradas que se enumeran en [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
+ El argumento `collections_to_save` adopta una configuración tensorial a través de la API `CollectionConfig`, que requiere los argumentos `name` y `parameters`.
+ Para encontrar las colecciones de tensores disponibles para `name`, consulte [Colecciones de tensores integrados del depurador](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections).
+ Para obtener una lista completa de las opciones ajustables`parameters`, consulte la API de [depuración CollectionConfig ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
Para obtener más información sobre la clase de reglas, los métodos y los parámetros del depurador, consulte la [clase de reglas del depurador de SageMaker IA](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html) en el SDK de Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs, CollectionConfig
rules=[
Rule.sagemaker(
base_config=rule_configs.built_in_rule_name(),
rule_parameters={
"key": "value"
},
collections_to_save=[
CollectionConfig(
name="tensor_collection_name",
parameters={
"key": "value"
}
)
]
)
]
```
Las descripciones de los parámetros y los ejemplos de personalización de valores vienen proporcionados para cada regla en [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
# Ejemplos de cuadernos y ejemplos de código para configurar las reglas del depurador
En las siguientes secciones, se proporcionan cuadernos y ejemplos de código sobre cómo utilizar las reglas del depurador para supervisar los trabajos de SageMaker formación.
**Topics**
+ [Cuadernos de ejemplo de reglas integradas del depurador](#debugger-built-in-rules-notebook-example)
+ [Código de ejemplo de reglas integradas del depurador](#debugger-deploy-built-in-rules)
+ [Uso de reglas integradas del depurador con modificaciones de parámetros](#debugger-deploy-modified-built-in-rules)
## Cuadernos de ejemplo de reglas integradas del depurador
Los siguientes cuadernos de ejemplo muestran cómo usar las reglas integradas del Debugger al ejecutar tareas de entrenamiento con Amazon SageMaker AI:
+ [Uso de una regla integrada en SageMaker Debugger con TensorFlow](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_builtin_rule)
+ [Uso de una regla integrada en el SageMaker depurador con Managed Spot Training y MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_spot_training)
+ [Uso de una regla integrada en el SageMaker depurador con modificaciones de parámetros para analizar el trabajo de formación en tiempo real con XGBoost](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/xgboost_realtime_analysis)
Mientras utilizas los cuadernos de ejemplo en SageMaker Studio, encontrarás la versión de prueba del trabajo de formación creada en la pestaña **Lista de experimentos de Studio**. Por ejemplo, como se muestra en la siguiente captura de pantalla, puede buscar y abrir la ventana **Describir componente de prueba** de su trabajo de entrenamiento actual. En la pestaña Depurador, puede comprobar si las reglas de depurador, `vanishing_gradient()` y `loss_not_decreasing()`, están monitorizando la sesión de entrenamiento en paralelo. Para obtener instrucciones completas sobre cómo encontrar los componentes de prueba de tu trabajo de formación en la interfaz de usuario de Studio, consulta [SageMaker Studio: View Experiments, Trials y Trial Components](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-tasks.html#studio-tasks-experiments).
![\[Imagen de la ejecución de un trabajo de formación con las reglas integradas de Debugger activadas en Studio SageMaker\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-built-in-rule-studio.png)
Hay dos formas de utilizar las reglas integradas del Debugger en el entorno de la SageMaker IA: despliega las reglas integradas a medida que están preparadas o ajusta sus parámetros como desees. En los temas siguientes se muestra cómo utilizar las reglas integradas con códigos de ejemplo.
## Código de ejemplo de reglas integradas del depurador
El siguiente ejemplo de código muestra cómo ejecutar las reglas integradas del depurador mediante el método `Rule.sagemaker`. Para especificar las reglas integradas que desea ejecutar, utilice la operación de la API `rules_configs` para llamar a las reglas integradas. Para obtener una lista completa de las reglas integradas del depurador y los valores de los parámetros predeterminados, consulte [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import Rule, CollectionConfig, rule_configs
# call built-in rules that you want to use.
built_in_rules=[
Rule.sagemaker(rule_configs.vanishing_gradient())
Rule.sagemaker(rule_configs.loss_not_decreasing())
]
# construct a SageMaker AI estimator with the Debugger built-in rules
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-built-in-rules-demo',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific arguments below
rules=built_in_rules
)
sagemaker_estimator.fit()
```
**nota**
Las reglas integradas del depurador se ejecutan en paralelo con su trabajo de entrenamiento. El número máximo de contenedores de reglas integradas para un trabajo de entrenamiento es 20.
Para obtener más información sobre la clase de reglas, los métodos y los parámetros del depurador, consulte la [clase Regla del SageMaker depurador](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html) en el SDK de Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
Para ver un ejemplo de cómo ajustar los parámetros de la regla del depurador, consulte la siguiente sección [Uso de reglas integradas del depurador con modificaciones de parámetros](#debugger-deploy-modified-built-in-rules).
## Uso de reglas integradas del depurador con modificaciones de parámetros
El siguiente ejemplo de código muestra la estructura de las reglas integradas para ajustar los parámetros. En este ejemplo, el `stalled_training_rule` recopila la colección de tensores de `losses` de un trabajo de entrenamiento cada 50 pasos y de una etapa de evaluación cada 10 pasos. Si el proceso de entrenamiento comienza a estancarse y no recopila las salidas de los tensores durante 120 segundos, `stalled_training_rule` detiene el trabajo de entrenamiento.
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import Rule, CollectionConfig, rule_configs
# call the built-in rules and modify the CollectionConfig parameters
base_job_name_prefix= 'smdebug-stalled-demo-' + str(int(time.time()))
built_in_rules_modified=[
Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
'threshold': '120',
'training_job_name_prefix': base_job_name_prefix,
'stop_training_on_fire' : 'True'
}
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "50"
"eval.save_interval": "10"
}
)
]
)
]
# construct a SageMaker AI estimator with the modified Debugger built-in rule
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name=base_job_name_prefix,
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific arguments below
rules=built_in_rules_modified
)
sagemaker_estimator.fit()
```
Para obtener una configuración avanzada de las reglas integradas del depurador mediante la API `CreateTrainingJob`, consulte [Configurar el depurador mediante SageMaker la API](debugger-createtrainingjob-api.md).
# Desactivar el depurador
Si quiere desactivar el depurador por completo, realice una de las siguientes acciones:
+ Antes de empezar un trabajo de entrenamiento, haga lo siguiente:
Para detener tanto la monitorización como la elaboración de perfiles, incluya el parámetro `disable_profiler` en su estimador y establézcalo en `True`.
**aviso**
Si lo desactiva, no podrá ver todo el panel de información del depurador de Studio ni el informe de creación de perfiles generado automáticamente.
Para detener la depuración, establezca el parámetro `debugger_hook_config` en `False`.
**aviso**
Si lo desactiva, no podrá recopilar los tensores de salida y no podrá depurar los parámetros de su modelo.
```
estimator=Estimator(
...
disable_profiler=True
debugger_hook_config=False
)
```
[Para obtener más información sobre los parámetros específicos del depurador, consulte [SageMaker AI Estimator en](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator) el SDK de Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
+ Haga lo siguiente mientras se ejecuta un trabajo de entrenamiento.
Para deshabilitar tanto la supervisión como la creación de perfiles mientras se está ejecutando el trabajo de entrenamiento, utilice el siguiente classmethod del estimador:
```
estimator.disable_profiling()
```
Para deshabilitar únicamente la creación de perfiles marco y mantener la monitorización del sistema, utilice el método `update_profiler`.
```
estimator.update_profiler(disable_framework_metrics=true)
```
[Para obtener más información sobre los métodos de extensión del estimador, consulte los métodos de clase [estimator.disable\$1profiling y [estimator.update\$1profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler)](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.disable_profiling) en la documentación del SDK de Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# Métodos útiles de SageMaker clases de estimadores de IA para Debugger
Los siguientes métodos de clases estimadoras son útiles para acceder a la información del trabajo de SageMaker entrenamiento y recuperar las rutas de salida de los datos de entrenamiento recopilados por Debugger. Los siguientes métodos se pueden ejecutar después de iniciar un trabajo de entrenamiento con el método `estimator.fit()`.
+ Para comprobar el URI del bucket base de S3 de un trabajo de formación: SageMaker
```
estimator.output_path
```
+ Para comprobar el nombre del trabajo base de un trabajo de SageMaker formación:
```
estimator.latest_training_job.job_name
```
+ Para ver la configuración completa del funcionamiento de la `CreateTrainingJob` API de un trabajo de SageMaker formación:
```
estimator.latest_training_job.describe()
```
+ Para consultar una lista completa de las reglas del depurador mientras se está ejecutando un trabajo de SageMaker formación:
```
estimator.latest_training_job.rule_job_summary()
```
+ Comprobar el URI del bucket de S3 en el que se guardan los datos de los parámetros del modelo (tensores de salida):
```
estimator.latest_job_debugger_artifacts_path()
```
+ Comprobar el URI del bucket de S3 en el que se guardan los datos de rendimiento del modelo (métricas del sistema y del marco):
```
estimator.latest_job_profiler_artifacts_path()
```
+ Comprobar la configuración de las reglas del depurador para la depuración de los tensores de salida:
```
estimator.debugger_rule_configs
```
+ Para consultar la lista de reglas del depurador para la depuración mientras se está ejecutando un trabajo de SageMaker formación:
```
estimator.debugger_rules
```
+ Para comprobar la configuración de las reglas del depurador para monitorizar y perfilar las métricas del sistema y del marco:
```
estimator.profiler_rule_configs
```
+ Para consultar la lista de reglas del depurador para la supervisión y la creación de perfiles mientras se está ejecutando un trabajo de SageMaker formación:
```
estimator.profiler_rules
```
[Para obtener más información sobre la clase de estimador de SageMaker IA y sus métodos, consulte la API [Estimator en](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator) el SDK de Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# SageMaker Informe interactivo de Debugger para XGBoost
Reciba informes de entrenamiento generados automáticamente por el depurador. Los informes del depurador proporcionan información sobre sus trabajos de entrenamiento y sugieren recomendaciones para mejorar el rendimiento de su modelo. Para los trabajos de XGBoost formación en SageMaker IA, utilice la [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) regla del depurador para recibir un informe de formación completo sobre el progreso y los resultados de la formación. Siguiendo esta guía, especifique la [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) regla al crear un XGBoost estimador, descargue el informe mediante el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) o la consola de Amazon S3 y obtenga información sobre los resultados de la formación.
**nota**
Puede descargar los informes de un depurador mientras se esté realizando su trabajo de entrenamiento o una vez finalizado el trabajo. Durante el entrenamiento, el depurador actualiza simultáneamente el informe para reflejar el estado de evaluación de las reglas actuales. Puede descargar un informe completo del depurador solo después de que se haya completado el trabajo de entrenamiento.
**importante**
En el informe, los gráficos y las recomendaciones se proporcionan con fines informativos y no son definitivos. Es responsabilidad suya realizar su propia evaluación independiente de la información.
**Topics**
+ [Cree un XGBoost estimador de SageMaker IA con la regla Debugger Report XGBoost](debugger-training-xgboost-report-estimator.md)
+ [Descarga el informe de formación de Debugger XGBoost](debugger-training-xgboost-report-download.md)
+ [Tutorial del informe de formación sobre el depurador XGBoost](debugger-training-xgboost-report-walkthrough.md)
# Cree un XGBoost estimador de SageMaker IA con la regla Debugger Report XGBoost
La regla [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) recopila los siguientes tensores de salida de su trabajo de entrenamiento:
+ `hyperparameters`: se guarda en el primer paso.
+ `metrics`: ahorra pérdidas y precisión cada 5 pasos.
+ `feature_importance`: se guarda cada 5 pasos.
+ `predictions`: se guarda cada 5 pasos.
+ `labels`: se guarda cada 5 pasos.
Los tensores de salida se guardan en un bucket S3 predeterminado. Por ejemplo, `s3://sagemaker--<12digit_account_id>//debug-output/`.
Al crear un estimador de SageMaker IA para un trabajo de XGBoost formación, especifique la regla tal y como se muestra en el siguiente código de ejemplo.
------
#### [ Using the SageMaker AI generic estimator ]
```
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.create_xgboost_report())
]
region = boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.2-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-xgboost-report-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Add the Debugger XGBoost report rule
rules=rules
)
estimator.fit(wait=False)
```
------
# Descarga el informe de formación de Debugger XGBoost
Descargue el informe de XGBoost formación de Debugger mientras se esté ejecutando el trabajo de formación o después de que el trabajo haya terminado con el [SDK y AWS Command Line Interface (CLI) de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
------
#### [ Download using the SageMaker Python SDK and AWS CLI ]
1. Compruebe el URI base de salida de S3 predeterminado del trabajo actual.
```
estimator.output_path
```
1. Compruebe el nombre del trabajo actual.
```
estimator.latest_training_job.job_name
```
1. El XGBoost informe del depurador se almacena en. `//rule-output` Configure la ruta de salida de reglas de la siguiente manera:
```
rule_output_path = estimator.output_path + "/" + estimator.latest_training_job.job_name + "/rule-output"
```
1. Para comprobar si el informe se ha generado correctamente, enumere los directorios y archivos de forma recursiva en `rule_output_path` utilizando `aws s3 ls` con la opción `--recursive`.
```
! aws s3 ls {rule_output_path} --recursive
```
Esto debería devolver una lista completa de los archivos de las carpetas generadas automáticamente con el nombre `CreateXgboostReport` y `ProfilerReport-1234567890`. El informe de XGBoost formación se guarda en la carpeta `CreateXgboostReport` y el informe de creación de perfiles se guarda en la `ProfilerReport-1234567890` carpeta. Para obtener más información sobre el informe de creación de perfiles generado de forma predeterminada con el trabajo de XGBoost formación, consulte. [SageMaker Informe interactivo sobre el depurador](debugger-profiling-report.md)
![\[Ejemplo de salida de reglas.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-ls.png)
`xgboost_report.html`Se trata de un informe de XGBoost formación generado automáticamente por Debugger. El `xgboost_report.ipynb` es un cuaderno de Jupyter que se utiliza para agregar los resultados del entrenamiento al informe. Puede descargar todos los archivos, examinar el archivo de informe HTML y modificar el informe con el cuaderno.
1. Descargue los archivos de forma recursiva utilizando `aws s3 cp`. El siguiente comando guarda todos los archivos de salida de las reglas en la carpeta `ProfilerReport-1234567890` del directorio de trabajo actual.
```
! aws s3 cp {rule_output_path} ./ --recursive
```
**sugerencia**
Si utiliza un servidor del cuaderno de Jupyter, ejecute `!pwd` para comprobar el directorio de trabajo actual.
1. En el directorio `/CreateXgboostReport`, abra `xgboost_report.html`. Si lo está utilizando JupyterLab, elija **Trust HTML** para ver el informe de formación de Debugger generado automáticamente.
![\[Ejemplo de salida de reglas.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-open-trust.png)
1. Abra el archivo `xgboost_report.ipynb` para ver cómo se genera el informe. Puede personalizar y ampliar el informe de entrenamiento mediante el archivo de cuaderno de Jupyter.
------
#### [ Download using the Amazon S3 console ]
1. Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Busque el bucket base de S3. Por ejemplo, si no ha especificado ningún nombre de trabajo base, el nombre del bucket base de S3 debe tener el siguiente formato:`sagemaker--111122223333`. Busque el bucket base de S3 en el campo **Buscar bucket por nombre**.
![\[El campo Buscar bucket por nombre en la consola de Amazon S3.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-0.png)
1. En el bucket base de S3, busque el nombre del trabajo de entrenamiento. Para ello, introduzca el prefijo del nombre del trabajo en **Buscar objetos por prefijo** y, a continuación, seleccione el nombre del trabajo de entrenamiento.
![\[Se muestra el campo Buscar objetos por prefijo en la consola de Amazon S3.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-1.png)
1. En el compartimento S3 del trabajo de entrenamiento, seleccione la subcarpeta **rule-output/**. Debe haber tres subcarpetas para los datos de entrenamiento recopilados por el depurador: **debug-output/**, **profiler-output/** y **rule-output/**.
![\[Ejemplo del URI del bucket de S3 de salida de reglas.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-2.png)
1. **En la carpeta **rule-output/, elija la carpeta/**. CreateXgboostReport** La carpeta contiene **xbgoost\$1report.html** (el informe generado automáticamente en html) y **xbgoost\$1report.ipynb** (un cuaderno de Jupyter con scripts que se utilizan para generar el informe).
1. Seleccione el archivo **xbgoost\$1report.html**, seleccione **Acciones de descarga** y, por último, seleccione **Descargar**.
![\[Ejemplo del URI del bucket de S3 de salida de reglas.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-s3-download.png)
1. Abra el archivo **xbgoost\$1report.html** descargado en un navegador web.
------
# Tutorial del informe de formación sobre el depurador XGBoost
En esta sección se explica el informe de formación sobre el depurador XGBoost . El informe se agrega automáticamente según la expresión regular del tensor de salida, reconociendo qué tipo de trabajo de entrenamiento se encuentra entre clasificación binaria, clasificación multiclase y regresión.
**importante**
En el informe, los gráficos y las recomendaciones se proporcionan con fines informativos y no son definitivos. Es responsabilidad suya realizar su propia evaluación independiente de la información.
**Topics**
+ [Distribución de las etiquetas true del conjunto de datos](#debugger-training-xgboost-report-walkthrough-dist-label)
+ [Gráfico de pérdidas versus de pasos](#debugger-training-xgboost-report-walkthrough-loss-vs-step)
+ [Importancia de las características](#debugger-training-xgboost-report-walkthrough-feature-importance)
+ [Matriz de confusión](#debugger-training-xgboost-report-walkthrough-confusion-matrix)
+ [Evaluación de la matriz de confusión](#debugger-training-xgboost-report-walkthrough-eval-conf-matrix)
+ [Tasa de precisión de cada elemento diagonal a lo largo de la iteración](#debugger-training-xgboost-report-walkthrough-accuracy-rate)
+ [Curva característica de funcionamiento del receptor](#debugger-training-xgboost-report-walkthrough-rec-op-char)
+ [Distribución de los residuos en el último paso guardado](#debugger-training-xgboost-report-walkthrough-dist-residual)
+ [Error absoluto de validación por contenedor de etiquetas durante la iteración](#debugger-training-xgboost-report-walkthrough-val-error-per-label-bin)
## Distribución de las etiquetas true del conjunto de datos
Este histograma muestra la distribución de las clases etiquetadas (para la clasificación) o los valores (para la regresión) en el conjunto de datos original. La asimetría del conjunto de datos podría provocar imprecisiones. Esta visualización está disponible para los siguientes tipos de modelos: clasificación binaria, multiclasificación y regresión.
![\[Un ejemplo de una distribución de etiquetas verdaderas del gráfico del conjunto de datos.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-dist-label.png)
## Gráfico de pérdidas versus de pasos
Se trata de un gráfico de líneas que muestra la progresión de la pérdida en los datos de entrenamiento y los datos de validación a lo largo de los pasos del entrenamiento. La pérdida es lo que definió en su función objetivo, como el error cuadrático medio. Puede evaluar si el modelo está sobreajustado o insuficientemente ajustado a partir de esta gráfica. Esta sección también proporciona información que puede utilizar para determinar cómo resolver los problemas de sobreajuste y subajuste. Esta visualización está disponible para los siguientes tipos de modelos: clasificación binaria, multiclasificación y regresión.
![\[Ejemplo de un gráfico de pérdidas versus de pasos.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-loss-vs-step.png)
## Importancia de las características
Se proporcionan tres tipos diferentes de visualizaciones de la importancia de las características: peso, ganancia y cobertura. Proporcionamos definiciones detalladas para cada uno de los tres en el informe. Las visualizaciones sobre la importancia de las funciones le ayudan a saber qué características de su conjunto de datos de entrenamiento contribuyeron a las predicciones. Las visualizaciones de importancia de las características están disponibles para los siguientes tipos de modelos: clasificación binaria, multiclasificación y regresión.
![\[Ejemplo de gráfico de importancia de características.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-feature-importance.png)
## Matriz de confusión
Esta visualización solo es aplicable a los modelos de clasificación binarios y multiclase. La precisión por sí sola puede no ser suficiente para evaluar el rendimiento de los modelos. Para algunos casos de uso, como la atención médica y la detección de fraudes, también es importante conocer la tasa de falsos positivos y la tasa de falsos negativos. Una matriz de confusión le proporciona las dimensiones adicionales para evaluar el rendimiento de su modelo.
![\[Ejemplo de matriz de confusión.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-confusion-matrix.png)
## Evaluación de la matriz de confusión
Esta sección le proporciona más información sobre las métricas microscópicas, macroeconómicas y ponderadas de precisión, recuperación y puntuación F1 de su modelo.
![\[Evaluación de la matriz de confusión.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-eval-conf-matrix.png)
## Tasa de precisión de cada elemento diagonal a lo largo de la iteración
Esta visualización solo se aplica a los modelos de clasificación binaria y multiclase. Se trata de un gráfico de líneas que traza los valores diagonales de la matriz de confusión a lo largo de los pasos de entrenamiento de cada clase. Este gráfico muestra cómo progresa la precisión de cada clase a lo largo de los pasos del entrenamiento. Puede identificar las clases con un rendimiento inferior a partir de este gráfico.
![\[Ejemplo de la tasa de precisión de cada elemento de la diagonal en un gráfico de iteración.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-accuracy-rate.gif)
## Curva característica de funcionamiento del receptor
Esta visualización solo es aplicable a los modelos de clasificación binaria. La curva de características operativas del receptor se utiliza habitualmente para evaluar el rendimiento del modelo de clasificación binaria. El eje y de la curva es True Positive Rate (TPF) o tasa de positivos verdaderos y el eje x es False Positive Rate (FPR) o tasa de positivos falsos. El gráfico también muestra el valor del Area Under the Curve (AUC) o área bajo la curva. Cuanto más alto sea el valor de AUC, más predictivo será su clasificador. También puede utilizar la curva ROC para comprender la compensación entre el TPR y el FPR e identificar el umbral de clasificación óptimo para su caso de uso. El umbral de clasificación se puede ajustar para adecuar el comportamiento del modelo y reducir más de uno u otro tipo de error (FP/FN).
![\[Un ejemplo es un gráfico de curvas características de funcionamiento del receptor.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-rec-op-char.png)
## Distribución de los residuos en el último paso guardado
Esta visualización es un gráfico de columnas que muestra las distribuciones residuales del último paso que el depurador capta. En esta visualización, puede comprobar si la distribución residual está cerca de la distribución normal centrada en cero. Si los residuos están sesgados, es posible que sus características no sean suficientes para predecir las etiquetas.
![\[Un ejemplo de una distribución de los residuos en el último gráfico de pasos guardado.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-dist-residual.png)
## Error absoluto de validación por contenedor de etiquetas durante la iteración
Esta visualización solo se aplica a los modelos de regresión. Los valores objetivo reales se dividen en 10 intervalos. Esta visualización muestra cómo progresan los errores de validación en cada intervalo a lo largo de los pasos de entrenamiento en gráficos de líneas. El error de validación absoluto es el valor absoluto de la diferencia entre la predicción y lo real durante la validación. Puede identificar los intervalos de bajo rendimiento a partir de esta visualización.
![\[Un ejemplo es un error de validación absoluto por contenedor de etiquetas en un gráfico de iteración.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-val-error-per-label-bin.png)
# Reglas de Action on Amazon SageMaker Debugger
En función del estado de evaluación de las reglas del depurador, puede configurar acciones automatizadas, como detener un trabajo de entrenamiento, y enviar notificaciones mediante el Amazon Simple Notification Service (Amazon SNS). También puedes crear tus propias acciones con Amazon CloudWatch Events y AWS Lambda. Para obtener información sobre cómo configurar acciones automatizadas en función del estado de evaluación de las reglas del depurador, consulte los siguientes temas.
**Topics**
+ [Uso de las acciones integradas del depurador para reglas](debugger-built-in-actions.md)
+ [Acciones en relación con las normas de uso de Amazon CloudWatch y AWS Lambda](debugger-cloudwatch-lambda.md)
# Uso de las acciones integradas del depurador para reglas
Utilice las acciones integradas del depurador para actuar ante los problemas encontrados por [Regla de depurador](debugger-built-in-rules.md#debugger-built-in-rules-Rule). La clase `rule_configs` del depurador proporciona herramientas para configurar una lista de acciones, como detener automáticamente los trabajos de entrenamiento y enviar notificaciones mediante el Amazon Simple Notification Service (Amazon SNS) cuando las reglas del depurador detecten problemas de entrenamiento. Los siguientes temas lo guiarán a través de los pasos necesarios para realizar estas tareas.
**Topics**
+ [Configuración de Amazon SNS, creación de un tema `SMDebugRules` y suscripción al tema](#debugger-built-in-actions-sns)
+ [Configuración del rol de IAM para asociar las políticas obligatorias](#debugger-built-in-actions-iam)
+ [Configuración de las reglas del depurador con las acciones integradas](#debugger-built-in-actions-on-rule)
+ [Consideraciones sobre el uso de las acciones integradas del depurador](#debugger-built-in-actions-considerations)
## Configuración de Amazon SNS, creación de un tema `SMDebugRules` y suscripción al tema
En esta sección, se explica cómo configurar un tema **SMDebugRules** de Amazon SNS, cómo suscribirse a él y cómo confirmar la suscripción para recibir notificaciones desde las reglas del depurador.
**nota**
[Para obtener más información sobre la facturación de Amazon SNS, consulte los precios de Amazon [SNS y Amazon SNS](https://aws.amazon.com/sns/pricing/). FAQs](https://aws.amazon.com/sns/faqs/)
**Para crear un tema sobre reglas SMDebug**
1. [Inicie sesión en la consola Amazon SNS en la v3/home Consola de administración de AWS y ábrala. https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/v3/home)
1. En el panel de navegación izquierdo, elija **Topics (Temas)**.
1. En la página **Temas**, elija **Crear tema**.
1. En la página **Crear tema**, en la sección **Detalles**, haga lo siguiente:
1. En **Tipo**, elija **Estándar** como tipo de tema.
1. En **Name (Nombre)**, escriba **SMDebugRules**.
1. Omita todos los demás ajustes opcionales y seleccione **Crear un tema**. Si desea obtener más información sobre la configuración opcional, consulte [Creación de un tema de Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html).
**Para suscribirse al tema Reglas SMDebug**
1. [Abra la consola Amazon SNS en https://console.aws.amazon.com/sns/ la versión 3/home.](https://console.aws.amazon.com/sns/v3/home)
1. En el panel de navegación izquierdo, elija **Suscripciones**.
1. En la página **Subscriptions (Suscripciones)**, elija **Create subscription (Crear suscripción)**.
1. En la página **Crear suscripción**, en la sección **Detalles**, haga lo siguiente:
1. Para **el tema ARN**, elija el tema de **SMDebugreglas ARN**. El ARN debe tener el formato `arn:aws:sns::111122223333:SMDebugRules`.
1. En **Protocol (Protocolo)**, elija **Email (Correo electrónico)** o **SMS**.
1. En **Punto de conexión**, introduzca el valor del punto de conexión, como una dirección de correo electrónico o un número de teléfono para recibir notificaciones.
**nota**
Asegúrese de escribir correctamente la dirección de correo electrónico y el número de teléfono. Los números de teléfono deben estar compuestos por `+`, un código de país y un número de teléfono, sin caracteres especiales ni espacios. Por ejemplo, el número de teléfono \$11 (222) 333-4444 tendría el formato **\$112223334444**.
1. Omita todos los demás ajustes opcionales y seleccione **Crear suscripción**. Si desea obtener más información sobre la configuración opcional, consulte [Suscripción a un tema de Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html).
Tras suscribirse al tema de las **SMDebugreglas**, recibirá el siguiente mensaje de confirmación por correo electrónico o por teléfono:
![\[Un mensaje de correo electrónico de confirmación de suscripción para el tema SMDebugReglas de Amazon SNS.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-built-in-action-subscription-confirmation.png)
Para obtener más información sobre Amazon SNS, consulte [Mensajería de texto móvil (SMS)](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html) y [Notificaciones por correo electrónico](https://docs.aws.amazon.com/sns/latest/dg/sns-email-notifications.html) en la *Guía para desarrolladores de Amazon SNS*.
## Configuración del rol de IAM para asociar las políticas obligatorias
En este paso, agregará las políticas obligatorias en su rol de IAM.
**Para agregar las políticas obligatorias a su rol de IAM**
1. Inicie sesión en la consola de IAM Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. En el panel de navegación de la izquierda, seleccione **Políticas** y **Crear política**.
1. En la página **Crear política**, haga lo siguiente para crear una nueva política de acceso SNS:
1. Seleccione la pestaña **JSON**.
1. Pegue las cadenas JSON formateadas en negrita del siguiente código en el`"Statement"`, sustituyendo el ID de AWS cuenta de 12 dígitos por el suyo. AWS
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sns:Publish",
"sns:CreateTopic",
"sns:Subscribe"
],
"Resource": "arn:aws:sns:*:111122223333:SMDebugRules"
}
]
}
```
------
1. En la parte inferior de la página, seleccione **Revisar la política**.
1. En la página **Crear política**, en **Nombre**, ingrese **sns-access**.
1. En la parte superior de la página, seleccione **Crear política**.
1. Vuelva a la consola de IAM y seleccione **Roles** en el panel de navegación de la izquierda.
1. Busca el rol de IAM que utilizas para la formación de modelos de SageMaker IA y elige ese rol de IAM.
1. En la pestaña **Permisos** de la página **Resumen**, seleccione **Adjuntar políticas**.
1. Busque la política de **acceso SNS**, seleccione la casilla situada junto a la política y, a continuación, elija **Adjuntar política**.
Para ver más ejemplos de configuración de políticas de IAM para Amazon SNS, consulte [Ejemplos de casos de control de acceso con Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-access-policy-use-cases.html).
## Configuración de las reglas del depurador con las acciones integradas
Tras completar correctamente los ajustes necesarios en los pasos anteriores, puede configurar las acciones integradas del depurador para las reglas de depuración, tal y como se muestra en el siguiente script de ejemplo. Puede elegir qué acciones integradas utilizar al crear el objeto de la lista de `actions`. El `rule_configs` es un módulo auxiliar que proporciona herramientas de alto nivel para configurar las reglas y acciones integradas en el depurador. Lo que sigue es una lista de acciones integradas disponibles para el depurador.
+ `rule_configs.StopTraining()`: detiene un trabajo de entrenamiento cuando la regla del depurador detecta un problema.
+ `rule_configs.Email("abc@abc.com")`: envía una notificación por correo electrónico cuando la regla del depurador detecta un problema. Use la dirección de correo electrónico que utilizó al configurar su suscripción a un tema de SNS.
+ `rule_configs.SMS("+1234567890")`: envía una notificación por mensaje de texto cuando la regla del depurador detecta un problema. Use el número de teléfono que utilizó al configurar su suscripción a un tema de SNS.
**nota**
Asegúrese de escribir correctamente la dirección de correo electrónico y el número de teléfono. Los números de teléfono deben estar compuestos por `+`, un código de país y un número de teléfono, sin caracteres especiales ni espacios. Por ejemplo, el número de teléfono \$11 (222) 333-4444 tendría el formato **\$112223334444**.
Puede utilizar todas las acciones integradas o un subconjunto de acciones. Para ello, utilice el método `rule_configs.ActionList()`, que toma las acciones integradas y configura una lista de acciones.
**Para añadir las tres acciones integradas a una sola regla**
Si desea asignar las tres acciones integradas a una sola regla, configure una lista de acciones integradas en el depurador mientras crea un estimador. Utilice la siguiente plantilla para construir el estimador; el depurador interrumpirá los trabajos de entrenamiento y enviará notificaciones por correo electrónico y mensaje de texto para cualquier regla que utilice a fin de supervisar el progreso de los trabajos de entrenamiento.
```
from sagemaker.debugger import Rule, rule_configs
# Configure an action list object for Debugger rules
actions = rule_configs.ActionList(
rule_configs.StopTraining(),
rule_configs.Email("abc@abc.com"),
rule_configs.SMS("+1234567890")
)
# Configure rules for debugging with the actions parameter
rules = [
Rule.sagemaker(
base_config=rule_configs.built_in_rule(), # Required
rule_parameters={"paramter_key": value }, # Optional
actions=actions
)
]
estimator = Estimator(
...
rules = rules
)
estimator.fit(wait=False)
```
**Para crear varios objetos de acción integrados a fin de asignar diferentes acciones a una sola regla**
Si desea asignar las acciones integradas para que se activen con diferentes valores de umbral de una sola regla, puede crear varios objetos de acción integrados, como se muestra en el siguiente script. Para evitar un error de conflicto al ejecutar la misma regla, debe enviar nombres de trabajo de regla diferentes (especifique cadenas diferentes para el atributo `name` de las reglas), como se muestra en el siguiente ejemplo de plantilla de script. Este ejemplo muestra cómo configurar [StalledTrainingRule](debugger-built-in-rules.md#stalled-training) para llevar a cabo dos acciones diferentes: enviar un correo electrónico a `abc@abc.com` cuando un trabajo de entrenamiento se para durante 60 segundos y detener el trabajo de entrenamiento si se detiene durante 120 segundos.
```
from sagemaker.debugger import Rule, rule_configs
import time
base_job_name_prefix= 'smdebug-stalled-demo-' + str(int(time.time()))
# Configure an action object for StopTraining
action_stop_training = rule_configs.ActionList(
rule_configs.StopTraining()
)
# Configure an action object for Email
action_email = rule_configs.ActionList(
rule_configs.Email("abc@abc.com")
)
# Configure a rule with the Email built-in action to trigger if a training job stalls for 60 seconds
stalled_training_job_rule_email = Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "60",
"training_job_name_prefix": base_job_name_prefix
},
actions=action_email
)
stalled_training_job_rule_text.name="StalledTrainingJobRuleEmail"
# Configure a rule with the StopTraining built-in action to trigger if a training job stalls for 120 seconds
stalled_training_job_rule = Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "120",
"training_job_name_prefix": base_job_name_prefix
},
actions=action_stop_training
)
stalled_training_job_rule.name="StalledTrainingJobRuleStopTraining"
estimator = Estimator(
...
rules = [stalled_training_job_rule_email, stalled_training_job_rule]
)
estimator.fit(wait=False)
```
Mientras se ejecuta el trabajo de entrenamiento, la acción integrada del depurador envía notificaciones por correo electrónico y mensajes de texto cuando la regla detecta problemas en el trabajo de entrenamiento. La siguiente captura de pantalla muestra un ejemplo de notificación por correo electrónico para un trabajo de entrenamiento detenido.
![\[Un ejemplo de notificación por correo electrónico que Debugger envía cuando detecta un problema. StalledTraining\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-built-in-action-email.png)
La siguiente captura de pantalla muestra un ejemplo de notificación de texto que Debugger envía cuando la regla detecta un StalledTraining problema.
![\[Un ejemplo de notificación de texto que Debugger envía cuando detecta un StalledTraining problema.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-built-in-action-text.png)
## Consideraciones sobre el uso de las acciones integradas del depurador
+ Para utilizar las acciones integradas del depurador, se necesita una conexión a Internet. Esta función no se admite en el modo de aislamiento de red que proporcionan Amazon SageMaker AI o Amazon VPC.
+ Las acciones integradas no se pueden utilizar para [Reglas del generador de perfiles](debugger-built-in-profiler-rules.md#debugger-built-in-profiler-rules-ProfilerRule).
+ Las acciones integradas no se pueden utilizar en trabajos de entrenamiento con interrupciones puntuales.
+ En las notificaciones por correo electrónico o mensaje de texto, al final de los mensajes aparece `None`. Esto no significa nada, por lo que puede ignorar el `None`.
# Acciones en relación con las normas de uso de Amazon CloudWatch y AWS Lambda
Amazon CloudWatch recopila registros de trabajos de entrenamiento de modelos de Amazon SageMaker AI y registros de trabajos de procesamiento de reglas de Amazon SageMaker Debugger. Configure el depurador con Amazon CloudWatch Events y AWS Lambda tome medidas en función del estado de evaluación de las reglas del depurador.
## Cuadernos de ejemplo
Puede ejecutar los siguientes cuadernos de ejemplo, que están preparados para experimentar con la interrupción de un trabajo de formación mediante acciones de las reglas integradas de Debugger mediante Amazon y. CloudWatch AWS Lambda
+ [Amazon SageMaker Debugger: Cómo reaccionar ante los CloudWatch acontecimientos a partir de las reglas](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_action_on_rule/tf-mnist-stop-training-job.html)
En este ejemplo de cuaderno, se ejecuta un trabajo de entrenamiento que tiene un problema de desaparición de gradiente. La regla [VanishingGradient](debugger-built-in-rules.md#vanishing-gradient) integrada del depurador se utiliza al construir el estimador de SageMaker IA TensorFlow . Cuando la regla del depurador detecta el problema, finaliza el trabajo de entrenamiento.
+ [Detecta el entrenamiento estancado e invoca acciones mediante la regla del depurador SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_action_on_rule/detect_stalled_training_job_and_actions.html)
Este cuaderno de ejemplo ejecuta un script de entrenamiento con una línea de código que fuerza el modo suspensión durante diez minutos. La regla [StalledTrainingRule](debugger-built-in-rules.md#stalled-training) integrada del depurador invoca los problemas y detiene el trabajo de entrenamiento.
**Topics**
+ [Cuadernos de ejemplo](#debugger-test-stop-training)
+ [Acceda a CloudWatch los registros para conocer las reglas del depurador y los trabajos de formación](debugger-cloudwatch-metric.md)
+ [Configure Debugger para la finalización automática de tareas de formación mediante CloudWatch Lambda](debugger-stop-training.md)
+ [Desactive la regla de CloudWatch eventos para dejar de utilizar la terminación automática de tareas de formación](debugger-disable-cw.md)
# Acceda a CloudWatch los registros para conocer las reglas del depurador y los trabajos de formación
Puede utilizar el estado de las tareas de la regla de formación y del depurador en los CloudWatch registros para tomar medidas adicionales cuando surjan problemas con la formación. El siguiente procedimiento muestra cómo acceder a los CloudWatch registros relacionados. Para obtener más información sobre la supervisión de los trabajos de formación mediante el uso CloudWatch, consulte [Supervisar Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html).
**Acceso a registros de trabajos de entrenamiento y registros de trabajos de reglas del depurador**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación de la izquierda, en el nodo **Registro**, seleccione **Grupos de registros**.
1. En la lista de grupos de registros, haga lo siguiente:
+ Seleccione**/aws/sagemaker/TrainingJobs**para los registros de trabajos de formación.
+ Elija**/aws/sagemaker/ProcessingJobs**para los registros de trabajos de la regla Debugger.
# Configure Debugger para la finalización automática de tareas de formación mediante CloudWatch Lambda
Las reglas del Depurador controlan el estado de las tareas de formación, y la regla de CloudWatch Eventos supervisa el estado de evaluación de las tareas de formación con la regla del Depurador. En las siguientes secciones se describe el proceso necesario para automatizar la finalización de un trabajo de formación mediante CloudWatch Lambda.
**Topics**
+ [Paso 1: Crear una función de Lambda](#debugger-lambda-function-create)
+ [Paso 2: configurar la función de Lambda](#debugger-lambda-function-configure)
+ [Paso 3: Crear una regla de CloudWatch eventos y vincularla a la función Lambda para Debugger](#debugger-cloudwatch-events)
## Paso 1: Crear una función de Lambda
**Cómo crear una función de Lambda**
1. Abra la AWS Lambda consola en. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. En el panel de navegación de la izquierda, seleccione **Funciones** y **Crear una función**.
1. En la página **Crear una función**, seleccione la opción **Crear desde cero**.
1. En la sección **Información básica**, introduzca un **nombre de función** (por ejemplo, **debugger-rule-stop-training-job**).
1. En **Runtime** (Tiempo de ejecución), elija **Python 3.7**.
1. En **Permisos**, expanda la opción desplegable y seleccione **Cambiar el rol de ejecución predeterminado**.
1. En **Función de ejecución**, selecciona **Usar una función existente** y elige la función de IAM que utilizarás para formar trabajos sobre SageMaker IA.
**nota**
Debe utilizar el rol de ejecución con `AmazonSageMakerFullAccess` y `AWSLambdaBasicExecutionRole` asociados. De lo contrario, la función de Lambda no reaccionará correctamente a los cambios del estado de la regla del depurador en el trabajo de entrenamiento. Si no está seguro de qué función de ejecución se está utilizando, ejecute el siguiente código en un cuaderno de Jupyter para recuperar el resultado del rol de ejecución:
```
import sagemaker
sagemaker.get_execution_role()
```
1. En la parte inferior de la página, elija **Create function**.
En la siguiente imagen se ve un ejemplo de la página **Crear una función**, con los campos de entrada y las selecciones completadas.
![\[Página Crear una función.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-lambda-create.png)
## Paso 2: configurar la función de Lambda
**Para configurar la función de Lambda**
1. En la sección **Código de la función** de la página de configuración, pegue el siguiente script de Python en el panel del editor de código Lambda. La `lambda_handler` función monitorea el estado de evaluación de las reglas del depurador recopilado por la `StopTrainingJob` API CloudWatch y activa la operación. La AWS SDK para Python (Boto3) `client` opción para SageMaker IA proporciona un método de alto nivel que activa la operación de la `StopTrainingJob` API. `stop_training_job`
```
import json
import boto3
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def lambda_handler(event, context):
training_job_name = event.get("detail").get("TrainingJobName")
logging.info(f'Evaluating Debugger rules for training job: {training_job_name}')
eval_statuses = event.get("detail").get("DebugRuleEvaluationStatuses", None)
if eval_statuses is None or len(eval_statuses) == 0:
logging.info("Couldn't find any debug rule statuses, skipping...")
return {
'statusCode': 200,
'body': json.dumps('Nothing to do')
}
# should only attempt stopping jobs with InProgress status
training_job_status = event.get("detail").get("TrainingJobStatus", None)
if training_job_status != 'InProgress':
logging.debug(f"Current Training job status({training_job_status}) is not 'InProgress'. Exiting")
return {
'statusCode': 200,
'body': json.dumps('Nothing to do')
}
client = boto3.client('sagemaker')
for status in eval_statuses:
logging.info(status.get("RuleEvaluationStatus") + ', RuleEvaluationStatus=' + str(status))
if status.get("RuleEvaluationStatus") == "IssuesFound":
secondary_status = event.get("detail").get("SecondaryStatus", None)
logging.info(
f'About to stop training job, since evaluation of rule configuration {status.get("RuleConfigurationName")} resulted in "IssuesFound". ' +
f'\ntraining job "{training_job_name}" status is "{training_job_status}", secondary status is "{secondary_status}"' +
f'\nAttempting to stop training job "{training_job_name}"'
)
try:
client.stop_training_job(
TrainingJobName=training_job_name
)
except Exception as e:
logging.error(
"Encountered error while trying to "
"stop training job {}: {}".format(
training_job_name, str(e)
)
)
raise e
return None
```
Para obtener más información sobre la interfaz del editor de código Lambda, consulte [Creación de funciones mediante el editor de consola AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/code-editor.html).
1. Omita todos los demás ajustes y seleccione **Guardar**, en la parte superior de la página de configuración.
## Paso 3: Crear una regla de CloudWatch eventos y vincularla a la función Lambda para Debugger
**Para crear una regla de CloudWatch eventos y vincularla a la función Lambda para Debugger**
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación de la izquierda, seleccione **Reglas** en el nodo **Eventos**.
1. Seleccione **Creación de regla**.
1. En la sección **Fuente del evento** de la página **Paso 1: Crear regla**, elija **SageMaker AI** para el **nombre del servicio** y elija **SageMaker AI Training Job State Change para el** **tipo de evento**. La vista previa del patrón de eventos tendrá un aspecto similar al de las siguientes cadenas JSON de ejemplo:
```
{
"source": [
"aws.sagemaker"
],
"detail-type": [
"SageMaker Training Job State Change"
]
}
```
1. En la sección **Objetivos**, elija **Agregar objetivo\$1** y elija la función **debugger-rule-stop-trainingLambda -job** que creó. Este paso vincula la regla de CloudWatch eventos con la función Lambda.
1. Seleccione **Configurar los detalles** y vaya a la página **Paso 2: configurar detalles de la regla**.
1. Especifique el nombre de la definición de la CloudWatch regla. Por ejemplo, **debugger-cw-event-rule**.
1. Para terminar, elija **Crear una regla**.
1. Vuelva a la página de configuración de la función de Lambda y actualice la página. Confirme que está configurada correctamente en el panel **Diseño**. La regla CloudWatch Events debe registrarse como activador de la función Lambda. El diseño de la configuración debe ser similar al siguiente ejemplo:
![\[Panel de diseño para la CloudWatch configuración.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-lambda-designer.png)
# Desactive la regla de CloudWatch eventos para dejar de utilizar la terminación automática de tareas de formación
Si desea deshabilitar la finalización automática de los trabajos de formación, debe deshabilitar la regla de CloudWatch eventos. En el panel Lambda **Designer**, elija el bloque **EventBridge (CloudWatch Eventos)** vinculado a la función Lambda. Aquí se muestra un **EventBridge**panel debajo del panel **Diseñador** (por ejemplo, consulte la captura de pantalla anterior). Seleccione la casilla de verificación situada junto a **EventBridge (CloudWatch Eventos):** y debugger-cw-event-rule, a continuación, seleccione **Desactivar**. Si desea utilizar la funcionalidad de rescisión automática más adelante, puede volver a activar la regla de CloudWatch eventos.
# Visualice los tensores de salida de Amazon SageMaker Debugger en TensorBoard
**importante**
Esta página está en desuso en favor de Amazon SageMaker AI with TensoBoard, que proporciona una TensorBoard experiencia integral integrada con la SageMaker formación y las funcionalidades de control de acceso del dominio SageMaker AI. Para obtener más información, consulte [TensorBoard en Amazon SageMaker AI](tensorboard-on-sagemaker.md).
Utilice SageMaker Debugger para crear archivos tensoriales de salida que sean compatibles con. TensorBoard Cargue los archivos para visualizar TensorBoard y analizar sus trabajos de SageMaker entrenamiento. Debugger genera automáticamente archivos tensoriales de salida compatibles con. TensorBoard Para cualquier configuración de gancho que personalice para guardar los tensores de salida, Debugger tiene la flexibilidad de crear resúmenes escalares, distribuciones e histogramas a los que puede importar. TensorBoard
![\[Un diagrama de arquitectura del mecanismo de almacenamiento del tensor de salida del depurador.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-tensorboard-concept.png)
Puede habilitar esto pasando los objetos `DebuggerHookConfig` y `TensorBoardOutputConfig` a un `estimator`.
El siguiente procedimiento explica cómo guardar los escalares, los pesos y los sesgos como tensores, histogramas y distribuciones completos con los que se pueden visualizar. TensorBoard El depurador los guarda en la ruta local del contenedor de entrenamiento (la ruta predeterminada es `/opt/ml/output/tensors`) y los sincroniza con las ubicaciones de Amazon S3 transferidas a través de los objetos de configuración de salida del depurador.
**Para guardar archivos de tensores de salida compatibles mediante Debugger TensorBoard**
1. Configure un objeto `tensorboard_output_config` de configuración para guardar la TensorBoard salida mediante la clase `TensorBoardOutputConfig` Debugger. Para el `s3_output_path` parámetro, especifique el depósito de S3 predeterminado de la sesión de SageMaker IA actual o el depósito de S3 preferido. Este ejemplo no se añade el parámetro `container_local_output_path`, sino que se establece en la ruta local `/opt/ml/output/tensors` predeterminada.
```
import sagemaker
from sagemaker.debugger import TensorBoardOutputConfig
bucket = sagemaker.Session().default_bucket()
tensorboard_output_config = TensorBoardOutputConfig(
s3_output_path='s3://{}'.format(bucket)
)
```
Para obtener información adicional, consulte la `[TensorBoardOutputConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig)` API Debugger en el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
1. Configure el enlace del depurador y personalice los valores de los parámetros del enlace. Por ejemplo, el siguiente código configura un enlace de depuración para guardar todas las salidas escalares cada 100 pasos en las fases de entrenamiento y 10 pasos en las fases de validación, los parámetros `weights` cada 500 pasos (el valor `save_interval` predeterminado para guardar las colecciones de tensores es 500) y los parámetros `bias` cada 10 pasos globales hasta que el paso global llegue a 500.
```
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig
hook_config = DebuggerHookConfig(
hook_parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
},
collection_configs=[
CollectionConfig("weights"),
CollectionConfig(
name="biases",
parameters={
"save_interval": "10",
"end_step": "500",
"save_histogram": "True"
}
),
]
)
```
Para obtener más información sobre la configuración del depurador APIs, consulte el Depurador `[CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)` y `[DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)` APIs el SDK de Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
1. Cree un estimador de SageMaker IA con los parámetros del depurador pasando por los objetos de configuración. La siguiente plantilla de ejemplo muestra cómo crear un estimador de IA genérico SageMaker . Puede sustituir `estimator` y por `Estimator` las clases principales y estimadoras de otros marcos de SageMaker IA. Los estimadores del marco de SageMaker IA disponibles para esta funcionalidad son, y. `[TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html#create-an-estimator)` `[PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#create-an-estimator)` `[MXNet](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#create-an-estimator)`
```
from sagemaker.estimator import Estimator
estimator = Estimator(
...
# Debugger parameters
debugger_hook_config=hook_config,
tensorboard_output_config=tensorboard_output_config
)
estimator.fit()
```
El `estimator.fit()` método inicia un trabajo de entrenamiento y Debugger escribe los archivos tensoriales de salida en tiempo real en la ruta de salida del Debugger S3 y en la ruta de salida S3. TensorBoard Para recuperar las rutas de salida, utilice los siguientes métodos de estimador:
+ Para la ruta de salida del depurador S3, utilice `estimator.latest_job_debugger_artifacts_path()`.
+ Para la ruta de salida de TensorBoard S3, utilice. `estimator.latest_job_tensorboard_artifacts_path()`
1. Una vez finalizado el entrenamiento, compruebe los nombres de los tensores de salida guardados:
```
from smdebug.trials import create_trial
trial = create_trial(estimator.latest_job_debugger_artifacts_path())
trial.tensor_names()
```
1. Compruebe los datos TensorBoard de salida en Amazon S3:
```
tensorboard_output_path=estimator.latest_job_tensorboard_artifacts_path()
print(tensorboard_output_path)
!aws s3 ls {tensorboard_output_path}/
```
1. Descargue los datos TensorBoard de salida a la instancia de su notebook. Por ejemplo, el siguiente AWS CLI comando descarga los TensorBoard archivos `/logs/fit` en el directorio de trabajo actual de su instancia de notebook.
```
!aws s3 cp --recursive {tensorboard_output_path} ./logs/fit
```
1. Comprima el directorio de archivos en un archivo TAR para descargarlo en su máquina local.
```
!tar -cf logs.tar logs
```
1. Descarga y extrae el archivo TAR de Tensorboard en un directorio de tu dispositivo, inicia un servidor de cuadernos de Jupyter, abre un cuaderno nuevo y ejecuta la aplicación. TensorBoard
```
!tar -xf logs.tar
%load_ext tensorboard
%tensorboard --logdir logs/fit
```
La siguiente captura de pantalla animada ilustra los pasos 5 a 8. Muestra cómo descargar el archivo TensorBoard TAR del Debugger y cómo cargarlo en un bloc de notas de Jupyter en tu dispositivo local.
![\[Animación sobre cómo descargar y cargar el TensorBoard archivo del depurador en su máquina local.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-tensorboard.gif)
# Lista de reglas integradas del depurador
Puede utilizar las reglas integradas del depurador proporcionado por el depurador de Amazon SageMaker para analizar las métricas y los tensores recopilados durante el entrenamiento de los modelos. A continuación, se enumeran las reglas del depurador, incluida información y un ejemplo sobre cómo configurar e implementar cada regla integrada.
Las reglas integradas del depurador monitorizan diversas condiciones comunes que son fundamentales para el éxito de un trabajo de entrenamiento. Puede llamar a las reglas integradas mediante el [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) o las operaciones de la API de SageMaker de bajo nivel.
El uso de reglas integradas no conlleva ningún costo adicional. Para obtener más información acerca de la facturación, consulte la página [Precios de Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/).
**nota**
El número máximo de reglas integradas que se pueden vincularse a un trabajo de entrenamiento es de 20. El depurador de SageMaker gestiona completamente las reglas integradas y analiza su trabajo de entrenamiento de forma sincrónica.
**importante**
Para utilizar las nuevas características del depurador, debe actualizar el SageMaker Python SDK y la biblioteca cliente SMDebug. En su kernel de iPython, cuaderno de Jupyter o entorno de JupyterLab, ejecute el siguiente código para instalar las últimas versiones de las bibliotecas y reiniciar el kernel.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Regla de depurador
Las siguientes reglas son las reglas integradas del depurador que pueden llamarse mediante el classmethod `Rule.sagemaker`.
Depurador: reglas integradas para generar informes de entrenamiento
| Ámbito de validez | Reglas integradas |
| --- | --- |
| Informe de entrenamiento para el trabajo de entrenamiento de SageMaker AI XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/debugger-built-in-rules.html) |
Reglas integradas en el depurador para depurar los datos de entrenamiento del modelo (tensores de salida)
| Ámbito de validez | Reglas integradas |
| --- | --- |
| Marcos de aprendizaje profundo (TensorFlow, Apache MXNet y PyTorch) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Marcos de aprendizaje profundo (TensorFlow, MXNet y PyTorch) y el algoritmo XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Aplicaciones de aprendizaje profundo | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Algoritmo XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/debugger-built-in-rules.html) |
**Para usar las reglas integradas con los valores de los parámetros predeterminados**, utilice el siguiente formato de configuración:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
Rule.sagemaker(rule_configs.built_in_rule_name_1()),
Rule.sagemaker(rule_configs.built_in_rule_name_2()),
...
Rule.sagemaker(rule_configs.built_in_rule_name_n())
]
```
**Para usar las reglas integradas con la personalización de los valores de los parámetros**, utilice el siguiente formato de configuración:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
Rule.sagemaker(
base_config=rule_configs.built_in_rule_name(),
rule_parameters={
"key": "value"
}
collections_to_save=[
CollectionConfig(
name="tensor_collection_name",
parameters={
"key": "value"
}
)
]
)
]
```
Para encontrar las claves disponibles del parámetro `rule_parameters`, consulte las tablas de descripción de los parámetros.
Se proporcionan ejemplos de códigos de configuración de reglas para cada regla integrada a continuación de las tablas de descripción de parámetros.
+ Para obtener instrucciones completas y ejemplos del uso de las reglas integradas del depurador, consulte [Código de ejemplo de reglas integradas del depurador](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Para obtener instrucciones completas sobre el uso de las reglas integradas con las operaciones de la API de SageMaker de bajo nivel, consulte [Configurar el depurador mediante SageMaker la API](debugger-createtrainingjob-api.md).
## CreateXgboostReport
La regla CreateXGBoostReport recopila los tensores de salida de un trabajo de entrenamiento de XGBoost y genera automáticamente un informe de entrenamiento completo. Puede descargar un informe completo de creación de perfiles mientras se esté realizando un trabajo de entrenamiento o una vez finalizado el trabajo de entrenamiento, y comprobar el progreso del entrenamiento o el resultado final de la misma. La regla CreateXGBoostReport recopila los siguientes tensores de salida de forma predeterminada:
+ `hyperparameters`: se guarda en el primer paso
+ `metrics`: ahorra pérdidas y precisión cada 5 pasos
+ `feature_importance`: se guarda cada 5 pasos
+ `predictions`: se guarda cada 5 pasos
+ `labels`: se guarda cada 5 pasos
Descripciones de parámetros para la regla CreateXgboostReport
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
```
rules=[
Rule.sagemaker(
rule_configs.create_xgboost_report()
)
]
```
## DeadRelu
Esta regla detecta cuando el porcentaje de funciones de activación de unidad lineal rectificada (ReLU) en una prueba se considera muerto porque su actividad de activación ha caído por debajo de un determinado umbral. Si el porcentaje de ReLU inactivas en una capa es mayor que el valor `threshold_layer` de ReLU inactivas, la regla devuelve `True`.
Descripciones de parámetros para la regla DeadRelu
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| tensor\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: `".*relu_output"` |
| threshold\$1inactivity | Define un nivel de actividad por debajo del cual se considera que una ReLU está muerta. Una ReLU podría estar activo al comienzo de una prueba y luego morir lentamente durante el proceso de entrenamiento. Si la ReLU está activa menos de `threshold_inactivity`, se considera que está muerta. **Opcional** Valores válidos: número flotante Valores predeterminados: `1.0` (en porcentaje) |
| threshold\$1layer | Devuelve `True` si el porcentaje de ReLU inactivas en una capa es mayor que `threshold_layer`. Devuelve `False` si el porcentaje de ReLU inactivas en una capa es menor que `threshold_layer`. **Opcional** Valores válidos: número flotante Valores predeterminados: `50.0` (en porcentaje) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.dead_relu(),
rule_parameters={
"tensor_regex": ".*relu_output|.*ReLU_output",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex: ".*relu_output|.*ReLU_output",
"save_interval": "500"
}
)
]
)
]
```
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
**nota**
Esta regla no está disponible para el algoritmo XGBoost.
## ExplodingTensor
Esta regla detecta si los tensores emitidos durante el entrenamiento tienen valores no finitos, infinitos o NaN (no un número). Si se detecta un valor no finito, la regla devuelve `True`.
Descripciones de parámetros para la regla ExplodingTensor
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| collection\$1names | Lista de nombres de colección cuyos tensores inspecciona la regla. **Opcional** Valores válidos: string Valor predeterminado: `None` |
| tensor\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: string Valor predeterminado: `None` |
| only\$1nan | `True` para monitorizar los tensores `base_trial` solo para valores `NaN` y no para infinito. `False` para tratar tanto `NaN` como infinito como valores de explosión y para monitorizar ambos. **Opcional** Valor predeterminado: `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.exploding_tensor(),
rule_parameters={
"tensor_regex": ".*gradient",
"only_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
**nota**
Esta regla no está disponible para el algoritmo XGBoost.
## PoorWeightInitialization
Esta regla detecta si los parámetros del modelo se han inicializado mal.
Una buena inicialización rompe la simetría de los pesos y gradientes en una red neuronal y mantiene variaciones de activación proporcionales a través de las capas. De lo contrario, la red neuronal no aprende eficazmente. Inicializadores como Xavier pretenden mantener la varianza constante a través de las activaciones, lo cual es especialmente relevante para entrenar redes neuronales muy profundas. Una inicialización demasiado pequeña puede dar lugar a la desaparición de gradientes. Una inicialización demasiado grande puede dar lugar a la explosión de gradientes. Esta regla comprueba la variación de las entradas de activación a través de las capas, la distribución de gradientes y la convergencia de pérdidas para los pasos iniciales para determinar si una red neuronal se ha inicializado mal.
Descripciones de parámetros para la regla PoorWeightInitialization
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| activation\$1inputs\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: string Valor predeterminado: `".*relu_input"` |
| threshold | Si la relación entre la varianza mínima y máxima de pesos por capa supera `threshold` en un paso, la regla vuelve `True`. **Opcional** Valores válidos: número flotante Valor predeterminado: `10.0` |
| distribution\$1range | Si la diferencia mínima entre los percentiles 5.º y 95.º de la distribución de gradiente es menor que la `distribution_range`, la regla devuelve `True`. **Opcional** Valores válidos: número flotante Valor predeterminado: `0.001` |
| patience | El número de pasos que esperar hasta que se considere que la pérdida ya no está disminuyendo. **Opcional** Valores válidos: número entero Valor predeterminado: `5` |
| steps | El número de pasos que analiza esta regla. Por lo general, solo tiene que verificar las primeras iteraciones. **Opcional** Valores válidos: número flotante Valor predeterminado: `10` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.poor_weight_initialization(),
rule_parameters={
"activation_inputs_regex": ".*relu_input|.*ReLU_input",
"threshold": "10.0",
"distribution_range": "0.001",
"patience": "5",
"steps": "10"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex": ".*relu_input|.*ReLU_input",
"save_interval": "500"
}
)
]
)
]
```
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
**nota**
Esta regla no está disponible para el algoritmo XGBoost.
## SaturatedActivation
Esta regla detecta si las capas de activación tanh y sigmoide se están saturando. Una capa de activación se satura cuando la entrada de la capa está cerca del máximo o mínimo de la función de activación. El mínimo y máximo de las funciones de activación tanh y sigmoide se definen por sus respectivos valores `min_threshold` y `max_thresholds`. Si la actividad de un nodo cae por debajo del porcentaje `threshold_inactivity`, se considera saturado. Si más de un porcentaje `threshold_layer` de los nodos están saturados, la regla devuelve `True`.
Descripciones de parámetros para la regla SaturatedActivation
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| collection\$1names | Lista de nombres de colección cuyos tensores inspecciona la regla. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: none |
| tensor\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: string Valor predeterminado: `".*tanh_input\|.*sigmoid_input".` |
| threshold\$1tanh\$1min | Los umbrales mínimo y máximo que definen los extremos de la entrada para una función de activación tanh, definidos como: `(min_threshold, max_threshold)`. Los valores predeterminados se determinan en función de un umbral de gradiente de desvanecimiento de 0,0000001. **Opcional** Valores válidos: número flotante Valores predeterminados: `-9.4999` |
| threshold\$1tanh\$1max | Los umbrales mínimo y máximo que definen los extremos de la entrada para una función de activación tanh, definidos como: `(min_threshold, max_threshold)`. Los valores predeterminados se determinan en función de un umbral de gradiente de desvanecimiento de 0,0000001. **Opcional** Valores válidos: número flotante Valores predeterminados: `9.4999` |
| threshold\$1sigmoid\$1min | Los umbrales mínimo y máximo que definen los extremos de la entrada para una función de activación sigmoide, definidos como: `(min_threshold, max_threshold)`. Los valores predeterminados se determinan en función de un umbral de gradiente de desvanecimiento de 0,0000001. **Opcional** Valores válidos: número flotante Valores predeterminados: `-23` |
| threshold\$1sigmoid\$1max | Los umbrales mínimo y máximo que definen los extremos de la entrada para una función de activación sigmoide, definidos como: `(min_threshold, max_threshold)`. Los valores predeterminados se determinan en función de un umbral de gradiente de desvanecimiento de 0,0000001. **Opcional** Valores válidos: número flotante Valores predeterminados: `16.99999` |
| threshold\$1inactivity | Porcentaje de inactividad por debajo del cual se considera que la capa de activación está saturada. La activación podría estar activa al comienzo de una prueba y luego volverse lentamente menos activa durante el proceso de entrenamiento. **Opcional** Valores válidos: número flotante Valores predeterminados: `1.0` |
| threshold\$1layer | Devuelve `True` si el número de activaciones saturadas en una capa es mayor que el porcentaje `threshold_layer`. Devuelve `False` si el número de activaciones saturadas en una capa es menor que el porcentaje `threshold_layer`. **Opcional** Valores válidos: número flotante Valores predeterminados: `50.0` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.saturated_activation(),
rule_parameters={
"tensor_regex": ".*tanh_input|.*sigmoid_input",
"threshold_tanh_min": "-9.4999",
"threshold_tanh_max": "9.4999",
"threshold_sigmoid_min": "-23",
"threshold_sigmoid_max": "16.99999",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_activations_collection",
parameters={
"include_regex": ".*tanh_input|.*sigmoid_input"
"save_interval": "500"
}
)
]
)
]
```
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
**nota**
Esta regla no está disponible para el algoritmo XGBoost.
## VanishingGradient
Esta regla detecta si los gradientes de una prueba se vuelven extremadamente pequeños o caen a una magnitud cero. Si la media de los valores absolutos de los gradientes cae por debajo de un `threshold` especificado, la regla devuelve `True`.
Descripciones de parámetros para la regla VanishingGradient
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| threshold | Valor en el que se determina que el gradiente está desapareciendo.**Opcional**Valores válidos: número flotanteValor predeterminado: `0.0000001`. |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.vanishing_gradient(),
rule_parameters={
"threshold": "0.0000001"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
**nota**
Esta regla no está disponible para el algoritmo XGBoost.
## WeightUpdateRatio
Esta regla hace un seguimiento de la proporción de actualizaciones a ponderaciones durante el entrenamiento y detecta si esa proporción es demasiado grande o demasiado pequeña. Si la proporción de actualizaciones a ponderaciones es mayor que `large_threshold value` o si esta proporción es menor que `small_threshold`, la regla devuelve `True`.
Las condiciones para el entrenamiento son mejores cuando las actualizaciones son proporcionales a los gradientes. Las actualizaciones excesivamente grandes pueden alejar las ponderaciones de los valores óptimos y las actualizaciones muy pequeñas dan lugar a una convergencia muy lenta. Esta regla requiere que haya pesos disponibles para dos pasos de entrenamiento y `train.save_interval` debe establecerse en `num_steps`.
Descripciones de parámetros para la regla WeightUpdateRatio
| Nombre del parámetro, | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| num\$1steps | El número de pasos en los que comprueba la regla para determinar si el tensor ha cambiado. El número de pasos a través de los cuales desea comparar las relaciones de ponderación. Si no transfiere ningún valor, la regla se ejecuta de forma predeterminada frente al paso actual y al paso guardado inmediatamente anterior. Si anula el valor predeterminado transfiriendo un valor para este parámetro, la comparación se realiza entre las ponderaciones en el paso `s` y en un paso que es `>= s - num_steps`. **Opcional** Valores válidos: número entero Valor predeterminado: `None` |
| large\$1threshold | El valor máximo que puede tomar la proporción de actualizaciones a ponderaciones antes de la regla devuelve `True`. **Opcional** Valores válidos: número flotante Valor predeterminado: `10.0` |
| small\$1threshold | El valor mínimo que puede tomar la proporción de actualizaciones a ponderaciones, por debajo del cual la regla devuelve `True`. **Opcional** Valores válidos: número flotante Valor predeterminado: `0.00000001` |
| epsilon | Una pequeña constante utilizada para garantizar que el depurador no se divide por cero al calcular la proporción de actualizaciones a ponderaciones. **Opcional** Valores válidos: número flotante Valor predeterminado: `0.000000001` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.weight_update_ratio(),
rule_parameters={
"num_steps": "100",
"large_threshold": "10.0",
"small_threshold": "0.00000001",
"epsilon": "0.000000001"
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"train.save_interval": "100"
}
)
]
)
]
```
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
**nota**
Esta regla no está disponible para el algoritmo XGBoost.
## AllZero
Esta regla detecta si todos o un porcentaje especificado de los valores del tensor son cero.
Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo admitidos (TensorFlow, MXNet y PyTorch) o al algoritmo XGBoost. Debe especificar el parámetro `collection_names` o `tensor_regex`. Si se especifican ambos parámetros, la regla inspecciona la unión de tensores de ambos conjuntos.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de parámetros para la regla AllZero
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| collection\$1names | Lista de nombres de colección cuyos tensores inspecciona la regla. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: `None` |
| tensor\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: `None` |
| threshold | Especifica el porcentaje de valores en el tensor que debe ser cero para que se invoque esta regla. **Opcional** Valores válidos: número flotante Valor predeterminado: 100 (en porcentaje) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.all_zero(),
rule_parameters={
"tensor_regex": ".*",
"threshold": "100"
},
collections_to_save=[
CollectionConfig(
name="all",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## ClassImbalance
Esta regla mide los desequilibrios de muestreo entre clases y devuelve errores si el desequilibrio supera un umbral o si se producen demasiados errores para clases subrepresentadas como resultado del desequilibrio.
Los modelos de clasificación requieren clases bien equilibradas en el conjunto de datos de entrenamiento o una ponderación/muestreo adecuada de las clases durante el entrenamiento. La regla realiza las siguientes comprobaciones:
+ Cuenta las incidencias por clase. Si la relación entre el número de muestras entre la clase menor y la mayor es mayor que `threshold_imbalance`, se produce un error.
+ Comprueba la precisión de la predicción por clase. Si el remuestreo o la ponderación no se han aplicado correctamente, el modelo puede alcanzar una alta precisión para la clase con muchas muestras de entrenamiento, pero baja precisión para las clases con pocas muestras de entrenamiento. Si una fracción de las predicciones erróneas para una determinada clase supera `threshold_misprediction`, se produce un error.
Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo admitidos (TensorFlow, MXNet y PyTorch) o al algoritmo XGBoost.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de parámetros para la regla ClassImbalance
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| threshold\$1imbalance | El desequilibrio aceptable entre el número de muestras en la clase menor y en la clase mayor. Si se supera este valor de umbral se genera un error. **Opcional** Valores válidos: número flotante Valor predeterminado: `10` |
| threshold\$1misprediction | Un límite en la fracción de predicciones erróneas permitidas para cada clase. Si se supera este umbral se genera un error. Las clases insuficientemente representadas corren el mayor riesgo de superar este umbral. **Opcional** Valores válidos: número flotante Valor predeterminado: `0.7` |
| samples | El número de etiquetas que se deben procesar antes de evaluar un desequilibrio. Es posible que la regla no se active hasta que haya visto suficientes muestras en varios pasos. Cuantas más clases contenga el conjunto de datos, mayor será este número `sample`. **Opcional** Valores válidos: número entero Valor predeterminado: `500` (suponiendo un conjunto de datos como MNIST con 10 clases) |
| argmax | Si es `True`, [np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) se aplica al tensor de predicción. Necesario cuando tiene un vector de probabilidades para cada clase. Se utiliza para determinar qué clase tiene la probabilidad más alta. **Condicional** Valores válidos: booleano Valor predeterminado: `False` |
| labels\$1regex | El nombre del tensor que contiene las etiquetas. **Opcional** Valores válidos: string Valor predeterminado: `".*labels"` |
| predictions\$1regex | El nombre del tensor que contiene las predicciones. **Opcional** Valores válidos: string Valor predeterminado: `".*predictions"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.class_imbalance(),
rule_parameters={
"threshold_imbalance": "10",
"threshold_misprediction": "0.7",
"samples": "500",
"argmax": "False",
"labels_regex": ".*labels",
"predictions_regex": ".*predictions"
},
collections_to_save=[
CollectionConfig(
name="custom_output_collection",
parameters={
"include_regex": ".*labels|.*predictions",
"save_interval": "500"
}
)
]
)
]
```
## LossNotDecreasing
Esta regla detecta cuando la pérdida no está disminuyendo de valor a un ritmo suficiente. Estas pérdidas deben ser escalares.
Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo admitidos (TensorFlow, MXNet y PyTorch) o al algoritmo XGBoost. Debe especificar el parámetro `collection_names` o `tensor_regex`. Si se especifican ambos parámetros, la regla inspecciona la unión de tensores de ambos conjuntos.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de parámetros para la regla LossNotDecreasing
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| collection\$1names | Lista de nombres de colección cuyos tensores inspecciona la regla. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: `None` |
| tensor\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: `None` |
| use\$1losses\$1collection | Si se establece en `True`, busca pérdidas en la colección denominada "pérdidas" cuando la colección está presente. **Opcional** Valores válidos: booleano Valor predeterminado: `True` |
| num\$1steps | El número mínimo de pasos después de los cuales la regla comprueba si la pérdida ha disminuido. La evaluación de reglas sucede cada `num_steps`. La regla compara la pérdida de este paso con la pérdida de un paso que está por lo menos `num_steps` por detrás del paso actual. Por ejemplo, supongamos que la pérdida se guarda cada tres pasos, pero `num_steps` se establece en 10. En el paso 21, la pérdida del paso 21 se compara con la pérdida del paso 9. El siguiente paso en el que se comprueba la pérdida es el paso 33, porque diez pasos desde el paso 21 es el paso 31 y en los pasos 31 y 32 la pérdida no se guarda. **Opcional** Valores válidos: número entero Valor predeterminado: `10` |
| diff\$1percent | La diferencia porcentual mínima que debe disminuir la pérdida entre `num_steps`. **Opcional** Valores válidos: `0.0` < número flotante < `100` Valor predeterminado: `0.1` (en porcentaje) |
| increase\$1threshold\$1percent | El porcentaje límite máximo que se permite que aumente la pérdida en caso de pérdida ha ido aumentando **Opcional** Valores válidos: `0` < número flotante < `100` Valor predeterminado: `5` (en porcentaje) |
| mode | El nombre del modo de depurador para consultar los valores de tensor para la comprobación de reglas. Si no se supera, la regla comprueba en orden de forma predeterminada `mode.EVAL`, `mode.TRAIN` y `mode.GLOBAL`. **Opcional** Valores válidos: string (`EVAL`, `TRAIN` o `GLOBAL`) Valor predeterminado: `GLOBAL` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.loss_not_decreasing(),
rule_parameters={
"tensor_regex": ".*",
"use_losses_collection": "True",
"num_steps": "10",
"diff_percent": "0.1",
"increase_threshold_percent": "5",
"mode": "GLOBAL"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## Overfit
Esta regla detecta si el modelo está sobreajustado a los datos de entrenamiento comparando la validación y las pérdidas de entrenamiento.
Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo admitidos (TensorFlow, MXNet y PyTorch) o al algoritmo XGBoost.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
**nota**
Una forma estándar de evitar el sobreajuste consiste en regularizar el modelo.
Descripciones de parámetros para la regla Overfit
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| tensor\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: none |
| start\$1step | El paso a partir del cual empezar a comparar la validación y la pérdida de entrenamiento. **Opcional** Valores válidos: número entero Valor predeterminado: `0` |
| patience | El número de pasos para los que se permite que `ratio_threshold` supere el valor establecido antes de que el modelo se considere sobreajuste. **Opcional** Valores válidos: número entero Valor predeterminado: `1` |
| ratio\$1threshold | La proporción máxima de la diferencia entre la pérdida media de validación y la pérdida media de entrenamiento respecto de la pérdida media de entrenamiento. Si se supera este umbral en un número de pasos `patience`, el modelo está sobreajustando y la regla devuelve `True`. **Opcional** Valores válidos: número flotante Valor predeterminado: `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overfit(),
rule_parameters={
"tensor_regex": ".*",
"start_step": "0",
"patience": "1",
"ratio_threshold": "0.1"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
)
]
```
## Overtraining
Esta regla detecta si un modelo se está sobreentrenando. Tras varias iteraciones de entrenamiento en un modelo que se comporta bien (disminuyen tanto las pérdidas de entrenamiento como las de validación), el modelo se acerca al mínimo de la función de pérdida y ya no mejora. Si el modelo sigue entrenándose, puede ocurrir que la pérdida de validación comience a aumentar, ya que el modelo empezará a sobreajustarse. Esta regla establece umbrales y condiciones para determinar si el modelo no mejora y evita problemas de sobreajuste debidos al sobreentrenamiento.
Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo admitidos (TensorFlow, MXNet y PyTorch) o al algoritmo XGBoost.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
**nota**
El sobreentrenamiento puede evitarse mediante una detención temprana. Para obtener información sobre la parada temprana, consulte [Detener trabajos de entrenamiento pronto](automatic-model-tuning-early-stopping.md). Para ver un ejemplo que muestre cómo usar el entrenamiento de spot con el depurador, consulte [Habilitar el entrenamiento de spot con el depurador de Amazon SageMaker](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html).
Descripciones de parámetros para la regla Overtraining
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| patience\$1train | El número de pasos a esperar antes de que se considere que la pérdida de entrenamiento que ya no mejora. **Opcional** Valores válidos: número entero Valor predeterminado: `5` |
| patience\$1validation | Se considera que el número de pasos a esperar antes de la pérdida de validación ya no mejora.**Opcional**Valores válidos: número enteroValor predeterminado: `10` |
| delta | El umbral mínimo que debe mejorar el error antes de que se considere como un nuevo óptimo. **Opcional** Valores válidos: número flotante Valor predeterminado: `0.01` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overtraining(),
rule_parameters={
"patience_train": "5",
"patience_validation": "10",
"delta": "0.01"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## SimilarAcrossRuns
Esta regla compara los tensores recopilados de una prueba base con los tensores de otra prueba.
Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo admitidos (TensorFlow, MXNet y PyTorch) o al algoritmo XGBoost.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de parámetros para la regla SimilarAcrossRuns
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| other\$1trials | El nombre de un trabajo de entrenamiento completado cuyos tensores desea comparar con los tensores obtenidos del actual `base_trial`. **Obligatorio** Valores válidos: string |
| collection\$1names | Lista de nombres de colección cuyos tensores inspecciona la regla. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: none |
| tensor\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: none |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.similar_across_runs(),
rule_parameters={
"other_trials": "",
"collection_names": "losses",
"tensor_regex": ".*"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## StalledTrainingRule
StalledTrainingRule detecta si no se ha realizado ningún progreso en el trabajo de entrenamiento y detiene el trabajo de entrenamiento si se activa la regla. Esta regla requiere que los tensores se guarden periódicamente en un intervalo de tiempo definido por su parámetro `threshold`. Esta regla sigue monitoreando la presencia de nuevos tensores y, si no se ha emitido ningún tensor nuevo para el intervalo umbral, se activa la regla.
Descripciones de los parámetros de la regla StalledTrainingRule
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| threshold | Un umbral que define el tiempo en segundos que la regla espera a que se produzca una salida tensorial hasta que se desencadene un problema de entrenamiento estancado. El valor predeterminado es de 1800 segundos. **Opcional** Valores válidos: número entero Valor predeterminado: `1800` |
| stop\$1training\$1on\$1fire | Si se establece en `True`, compruebe si el trabajo de entrenamiento base genera tensores en "`threshold`" segundos. **Opcional** Valores válidos: booleano Valor predeterminado: `False` |
| training\$1job\$1name\$1prefix | El prefijo del nombre de trabajo de entrenamiento base. Si `stop_training_on_fire` es true, la regla busca trabajos de entrenamiento de SageMaker con este prefijo en la misma cuenta. Si se detecta una inactividad, la regla realiza una acción `StopTrainingJob`. Tenga en cuenta que si se encuentran varios trabajos con el mismo prefijo, la regla omite la terminación. Es importante que el prefijo sea único para cada trabajo de entrenamiento. **Opcional** Valores válidos: string |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "1800",
"stop_training_on_fire": "True",
"training_job_name_prefix": ""
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TensorVariance
Esta regla detecta si tiene tensores con variaciones muy altas o bajas. Variaciones muy altas o bajas en un tensor podrían dar lugar a la saturación neuronal, lo que reduce la capacidad de aprendizaje de la red neuronal. Una variación muy alta en los tensores también puede dar lugar finalmente a la explosión de tensores. Utilice esta regla para detectar estos problemas con antelación.
Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo admitidos (TensorFlow, MXNet y PyTorch) o al algoritmo XGBoost. Debe especificar el parámetro `collection_names` o `tensor_regex`. Si se especifican ambos parámetros, la regla inspecciona la unión de tensores de ambos conjuntos.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de parámetros para la regla TensorVariance
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| collection\$1names | Lista de nombres de colección cuyos tensores inspecciona la regla. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: none |
| tensor\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: none |
| max\$1threshold | Umbral para el límite superior de la variación de tensor. **Opcional** Valores válidos: número flotante Valor predeterminado: none |
| min\$1threshold | Umbral para el límite inferior de la variación de tensor. **Opcional** Valores válidos: número flotante Valor predeterminado: none |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tensor_variance(),
rule_parameters={
"collection_names": "weights",
"max_threshold": "10",
"min_threshold": "0.00001",
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## UnchangedTensor
Esta regla detecta si un tensor ya no cambia en los pasos.
Esta regla ejecuta el método [numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html) para comprobar si el tensor no está cambiando.
Esta regla se puede aplicar a uno de los marcos de aprendizaje profundo admitidos (TensorFlow, MXNet y PyTorch) o al algoritmo XGBoost. Debe especificar el parámetro `collection_names` o `tensor_regex`. Si se especifican ambos parámetros, la regla inspecciona la unión de tensores de ambos conjuntos.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de parámetros para la regla UnchangedTensor
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| collection\$1names | Lista de nombres de colección cuyos tensores inspecciona la regla. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: none |
| tensor\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: none |
| num\$1steps | El número de pasos en los que comprueba la regla para determinar si el tensor ha cambiado. Esto comprueba los últimos `num_steps` que están disponibles. No tienen que ser consecutivos. Si `num_steps` es 2, en el paso s no verifica necesariamente s-1 y s. Si s-1 no está disponible, comprueba el último paso disponible junto con s. En ese caso, comprueba el último paso disponible con el paso actual. **Opcional** Valores válidos: número entero Valor predeterminado: `3` |
| rtol | El parámetro de tolerancia relativa que se va a transferir al método `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Opcional** Valores válidos: número flotante Valor predeterminado: `1e-05` |
| atol | El parámetro de tolerancia absoluta que se va a transferir al método `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Opcional** Valores válidos: número flotante Valor predeterminado: `1e-08` |
| equal\$1nan | Si comparar los NaNs como iguales. Si es `True`, los NaNs en la matriz de entrada a se consideran iguales a los NaNs en la matriz de entrada b en la matriz de salida. Este parámetro se transfiere al método `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Opcional** Valores válidos: booleano Valor predeterminado: `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.unchanged_tensor(),
rule_parameters={
"collection_names": "losses",
"tensor_regex": "",
"num_steps": "3",
"rtol": "1e-05",
"atol": "1e-08",
"equal_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## CheckInputImages
Esta regla comprueba si las imágenes de entrada se han normalizado correctamente. Específicamente, detecta si la media de los datos de muestra difiere de cero en más de un valor umbral. Muchos modelos de visión artificial requieren que los datos de entrada tengan una media cero y varianza unitaria.
Esta regla es aplicable a aplicaciones de aprendizaje profundo.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de parámetros para la regla CheckInputImages
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| threshold\$1mean | Un umbral que define en qué medida la media de los datos de entrada puede diferir de 0. **Opcional** Valores válidos: número flotante Valor predeterminado: `0.2` |
| threshold\$1samples | El número de imágenes que se deben muestrear antes de que se pueda lanzar un error. Si el valor es demasiado bajo, la estimación de la media del conjunto de datos será inexacta. **Opcional** Valores válidos: número entero Valor predeterminado: `500` |
| regex | El nombre del tensor de datos de entrada. **Opcional** Valores válidos: string Valor predeterminado: `".*hybridsequential0_input_0"` (el nombre del tensor de entrada para los modelos de Apache MXNet usando HybridSequential) |
| channel | La posición del canal de color en la matriz de forma del tensor de entrada. **Opcional** Valores válidos: número entero Valor predeterminado: `1` (por ejemplo, MXNet espera datos de entrada en forma de (batch\$1size, channel, height, width)) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.check_input_images(),
rule_parameters={
"threshold_mean": "0.2",
"threshold_samples": "500",
"regex": ".*hybridsequential0_input_0",
"channel": "1"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*hybridsequential0_input_0",
"save_interval": "500"
}
)
]
)
]
```
## NLPSequenceRatio
Esta regla calcula la proporción de tokens específicos dado el resto de la secuencia de entrada que es útil para optimizar el rendimiento. Por ejemplo, puede calcular el porcentaje de relleno de tokens de fin de oración (EOS) en la secuencia de entrada. Si el número de tokens EOS es demasiado alto, se debe realizar una estrategia de asignación de buckets alternativa. También puede calcular el porcentaje de tokens desconocidos en su secuencia de entrada. Si el número de palabras desconocidas es demasiado alto, podría utilizarse un vocabulario alternativo.
Esta regla es aplicable a aplicaciones de aprendizaje profundo.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de parámetros para la regla NLPSequenceRatio
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| tensor\$1regex | Una lista de patrones de expresiones regulares que se utiliza para restringir esta comparación a tensores de valores escalares específicos. La regla inspecciona solo los tensores que coinciden con los patrones de expresiones regulares especificados en la lista. Si no se aprueba ningún patrón, la regla compara todos los tensores recopilados en las pruebas de forma predeterminada. Solo pueden coincidir los tensores de valor escalar. **Opcional** Valores válidos: lista de cadenas o una cadena separada por comas Valor predeterminado: `".*embedding0_input_0"` (suponiendo una integración como capa inicial de la red) |
| token\$1values | Una cadena de una lista de los valores numéricos de los tokens. Por ejemplo, "3, 0". **Opcional** Valores válidos: string de valores numéricos separados por comas Valor predeterminado: `0` |
| token\$1thresholds\$1percent | Una cadena de una lista de umbrales (en porcentajes) que corresponden a cada uno de los `token_values`. Por ejemplo, "50.0, 50.0". **Opcional** Valores válidos: string de números flotantes separada por comas Valor predeterminado: `"50"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.nlp_sequence_ratio(),
rule_parameters={
"tensor_regex": ".*embedding0_input_0",
"token_values": "0",
"token_thresholds_percent": "50"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*embedding0_input_0"
}
)
]
)
]
```
## Confusion
Esta regla evalúa lo buena que es una matriz de confusión para un problema de clasificación.
Crea una matriz de tamaño `category_no*category_no` y la rellena con datos procedentes de pares (`labels`, `predictions`). Para cada par (`labels`, `predictions`), el recuento `confusion[labels][predictions]` se incrementa en 1. Cuando la matriz está completamente llena, la proporción de los valores de los datos en diagonal y fuera de diagonal se evalúa de la siguiente manera:
+ Para elementos en la diagonal: `confusion[i][i]/sum_j(confusion[j][j])>=min_diag`
+ Para elementos fuera de la diagonal: `confusion[j][i])/sum_j(confusion[j][i])<=max_off_diag`
Esta regla se puede aplicar al algoritmo XGBoost.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de parámetros para la regla Confusion
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| category\$1no | El número de categorías. **Opcional** Valores válidos: número entero ≥2 Valor predeterminado: `"None"` |
| labels | La colección de tensores `labels` o un vector unidimensional de etiquetas true. **Opcional** Valores válidos: string Valor predeterminado: `"labels"` |
| predictions | La colección de tensores `predictions` o un vector unidimensional de etiquetas estimadas. **Opcional** Valores válidos: string Valor predeterminado: `"predictions"` |
| labels\$1collection | La regla inspecciona los tensores de esta colección para `labels`. **Opcional** Valores válidos: string Valor predeterminado: `"labels"` |
| predictions\$1collection | La regla inspecciona los tensores de esta colección para `predictions`. **Opcional** Valores válidos: string Valor predeterminado: `"predictions"` |
| min\$1diag | El umbral mínimo para la relación de datos en la diagonal. **Opcional** Valores válidos: `0`≤número flotante≤`1` Valor predeterminado: `0.9` |
| max\$1off\$1diag | El umbral máximo para la relación de datos fuera de la diagonal. **Opcional** Valores válidos: `0`≤número flotante≤`1` Valor predeterminado: `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.confusion(),
rule_parameters={
"category_no": "10",
"labels": "labels",
"predictions": "predictions",
"labels_collection": "labels",
"predictions_collection": "predictions",
"min_diag": "0.9",
"max_off_diag": "0.1"
},
collections_to_save=[
CollectionConfig(
name="labels",
parameters={
"save_interval": "500"
}
),
CollectionConfig(
name="predictions",
parameters={
"include_regex": "500"
}
)
]
)
]
```
**nota**
Esta regla infiere los valores predeterminados de los parámetros opcionales si no se especifican sus valores.
## FeatureImportanceOverweight
Esta regla acumula las ponderaciones de los valores n de mayor importancia de las características por paso y se asegura de que no superen el umbral. Por ejemplo, puede establecer el umbral para que las tres características principales no retengan más del 80 por ciento de los pesos totales del modelo.
Esta regla es válida solo para el algoritmo XGBoost.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de los parámetros de la regla FeatureImportanceOverweight.
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| threshold | Define el umbral de la proporción de la suma acumulada de las características `n` más grandes. El número `n` viene definido por el parámetro `nfeatures`. **Opcional** Valores válidos: número flotante Valor predeterminado: `0.8` |
| nfeatures | El número de características más grandes. **Opcional** Valores válidos: número entero Valor predeterminado: `3` |
| tensor\$1regex | La expresión regular (regex) del tensor nombra la regla que se va a analizar. **Opcional** Valores válidos: string Valor predeterminado: `".*feature_importance/weight"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.feature_importance_overweight(),
rule_parameters={
"threshold": "0.8",
"nfeatures": "3",
"tensor_regex": ".*feature_importance/weight"
},
collections_to_save=[
CollectionConfig(
name="feature_importance",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TreeDepth
Esta regla mide la profundidad de los árboles en un modelo XGBoost. XGBoost rechaza las divisiones si no mejoran la pérdida. Esto regulariza el entrenamiento. Como resultado, es posible que el árbol no crezca con tanta profundidad como se define en parámetro `depth`.
Esta regla es válida solo para el algoritmo XGBoost.
Para ver un ejemplo de cómo configurar e implementar una regla integrada, consulte [Cómo configurar reglas integradas del depurador](use-debugger-built-in-rules.md).
Descripciones de parámetros para la regla TreeDepth
| Nombre del parámetro | Descripción |
| --- | --- |
| base\$1trial | El nombre del trabajo de entrenamiento de prueba base. El depurador de Amazon SageMaker establece automáticamente este parámetro en el trabajo de entrenamiento actual. **Obligatorio** Valores válidos: string |
| depth | La profundidad del árbol. La profundidad del árbol se obtiene calculando el logaritmo base 2 del ID de nodo mayor. **Opcional** Valores válidos: número flotante Valor predeterminado: `4` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tree_depth(),
rule_parameters={
"depth": "4"
},
collections_to_save=[
CollectionConfig(
name="tree",
parameters={
"save_interval": "500"
}
)
]
)
]
```
# Creación de reglas personalizadas mediante la biblioteca cliente del depurador
Puede crear reglas personalizadas para supervisar su trabajo de entrenamiento mediante la regla Debugger APIs y la [biblioteca `smdebug` Python](https://github.com/awslabs/sagemaker-debugger/) de código abierto que proporciona herramientas para crear sus propios contenedores de reglas.
## Requisitos previos para crear una regla personalizada
Para crear reglas personalizadas del depurador, necesita cumplir con los siguientes requisitos previos.
+ [SageMaker Regla de depuración. API personalizada](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule.custom)
+ [La biblioteca de Python de código abierto smdebug](https://github.com/awslabs/sagemaker-debugger/)
+ Su propio script de Python con reglas personalizadas
+ [Imagen de Amazon SageMaker Debugger URIs para evaluadores de reglas personalizados](debugger-reference.md#debuger-custom-rule-registry-ids)
**Topics**
+ [Requisitos previos para crear una regla personalizada](#debugger-custom-rules-prerequisite)
+ [Uso de la biblioteca cliente `smdebug` para crear una regla personalizada como script de Python](debugger-custom-rules-python-script.md)
+ [Usa el depurador APIs para ejecutar tus propias reglas personalizadas](debugger-custom-rules-python-sdk.md)
# Uso de la biblioteca cliente `smdebug` para crear una regla personalizada como script de Python
La API de reglas `smdebug` proporciona una interfaz para configurar sus propias reglas personalizadas. El siguiente script de Python es un ejemplo de cómo construir una regla personalizada, `CustomGradientRule`. Esta regla personalizada del tutorial comprueba si los gradientes se están haciendo demasiado grandes y establece el umbral predeterminado en 10. La regla personalizada utiliza una prueba base creada por un estimador de SageMaker IA cuando inicia el trabajo de entrenamiento.
```
from smdebug.rules.rule import Rule
class CustomGradientRule(Rule):
def __init__(self, base_trial, threshold=10.0):
super().__init__(base_trial)
self.threshold = float(threshold)
def invoke_at_step(self, step):
for tname in self.base_trial.tensor_names(collection="gradients"):
t = self.base_trial.tensor(tname)
abs_mean = t.reduction_value(step, "mean", abs=True)
if abs_mean > self.threshold:
return True
return False
```
Puede añadir varias clases de reglas personalizadas tantas como desee en el mismo script de Python e implementarlas en cualquier prueba de trabajo de entrenamiento mediante la creación de objetos de reglas personalizadas en la siguiente sección.
# Usa el depurador APIs para ejecutar tus propias reglas personalizadas
El siguiente ejemplo de código muestra cómo configurar una regla personalizada con el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). En este ejemplo se supone que el script de reglas personalizadas que creó en el paso anterior se encuentra en '*path/to/my\$1custom\$1rule.py*'.
```
from sagemaker.debugger import Rule, CollectionConfig
custom_rule = Rule.custom(
name='MyCustomRule',
image_uri='759209512951.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rule-evaluator:latest',
instance_type='ml.t3.medium',
source='path/to/my_custom_rule.py',
rule_to_invoke='CustomGradientRule',
collections_to_save=[CollectionConfig("gradients")],
rule_parameters={"threshold": "20.0"}
)
```
En la siguiente lista se explican los argumentos de la API `Rule.custom` del depurador.
+ `name` (str): especifique el nombre de las reglas personalizadas que desee.
+ `image_uri` (str): esta es la imagen del contenedor que tiene la lógica de entender su regla personalizada. Obtiene y evalúa las colecciones de tensores especificadas que haya guardado en el trabajo de entrenamiento. Puede encontrar la lista de imágenes de código abierto de los evaluadores de reglas de SageMaker [Imagen de Amazon SageMaker Debugger URIs para evaluadores de reglas personalizados](debugger-reference.md#debuger-custom-rule-registry-ids) IA en.
+ `instance_type` (str): debe especificar una instancia para crear un contenedor de Docker de reglas. Esto hace girar la instancia en paralelo con un contenedor de entrenamiento.
+ `source` (str): esta es la ruta local o el URI de Amazon S3 a su script de reglas personalizadas.
+ `rule_to_invoke`(str): Especifica la implementación de la clase Rule concreta en tu script de reglas personalizado. SageMaker La IA solo admite la evaluación de una regla a la vez en un trabajo de reglas.
+ `collections_to_save` (str): especifique qué colecciones de tensores guardará para que se ejecute la regla.
+ `rule_parameters` (diccionario): acepta entradas de parámetros en formato diccionario. Puede ajustar los parámetros que haya configurado en el script de reglas personalizadas.
Después de configurar el `custom_rule` objeto, puedes usarlo para crear un estimador de SageMaker IA para cualquier trabajo de formación. Especifique el `entry_point` en su script de entrenamiento. No necesita hacer ningún cambio en su script de entrenamiento.
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
role=sagemaker.get_execution_role(),
base_job_name='smdebug-custom-rule-demo-tf-keras',
entry_point='path/to/your_training_script.py'
train_instance_type='ml.p2.xlarge'
...
# debugger-specific arguments below
rules = [custom_rule]
)
estimator.fit()
```
Para ver más variantes y ejemplos avanzados del uso de las reglas personalizadas del depurador, consulte los siguientes cuadernos de ejemplo.
+ [Supervise su trabajo de formación con las reglas personalizadas de Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_keras_custom_rule/tf-keras-custom-rule.html)
+ [PyTorch modelo iterativo: poda de y ResNet AlexNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_iterative_model_pruning)
+ [Activa CloudWatch eventos de Amazon mediante las reglas del depurador para realizar una acción en función del estado del entrenamiento con TensorFlow](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_action_on_rule)
# 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()
```
# Configurar el depurador mediante SageMaker la API
Los temas anteriores se centran en el uso del depurador a través del SDK de Amazon SageMaker Python, que es un contenedor de operaciones AWS SDK para Python (Boto3) de SageMaker API. Esto ofrece una experiencia de alto nivel de acceso a las operaciones de la SageMaker API de Amazon. En caso de que necesite configurar manualmente las operaciones de la SageMaker API mediante AWS Boto3 o ( AWS Command Line Interface CLI) para otras SDKs, como Java, Go y C\$1\$1, en esta sección se explica cómo configurar las siguientes operaciones de API de bajo nivel.
**Topics**
+ [JSON (AWS CLI)](debugger-built-in-rules-api.CLI.md)
+ [SDK para Python (Boto3)](debugger-built-in-rules-api.Boto3.md)
# JSON (AWS CLI)
Las reglas integradas de Amazon SageMaker Debugger se pueden configurar para un trabajo de formación mediante los [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)objetos [DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html), [DebugRuleConfiguration[ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html), y mediante la operación de la [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API de SageMaker IA. Debe especificar el URI de imagen correcto en el `RuleEvaluatorImage` parámetro y, en los siguientes ejemplos, se explica cómo configurar las cadenas JSON que se van a solicitar [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html).
El siguiente código muestra una plantilla JSON completa para ejecutar un trabajo de entrenamiento con los ajustes necesarios y las configuraciones del depurador. Guarde la plantilla como un archivo JSON en su directorio de trabajo y ejecute el trabajo de formación mediante AWS CLI. Por ejemplo, guarde el siguiente código como `debugger-training-job-cli.json`.
**nota**
Asegúrese de utilizar las imágenes del contenedor de Docker correctas. Para encontrar imágenes de AWS Deep Learning Container, consulte Imágenes de [Deep Learning Containers disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Para ver una lista completa de las imágenes de Docker disponibles para usar las reglas del depurador, consulte [Imágenes de Docker para reglas del depurador](debugger-reference.md#debugger-docker-images-rules).
```
{
"TrainingJobName": "debugger-aws-cli-test",
"RoleArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-YYYYMMDDT123456",
"AlgorithmSpecification": {
// Specify a training Docker container image URI (Deep Learning Container or your own training container) to TrainingImage.
"TrainingImage": "763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.4.1-gpu-py37-cu110-ubuntu18.04",
"TrainingInputMode": "File",
"EnableSageMakerMetricsTimeSeries": false
},
"HyperParameters": {
"sagemaker_program": "entry_point/tf-hvd-train.py",
"sagemaker_submit_directory": "s3://sagemaker-us-west-2-111122223333/debugger-boto3-profiling-test/source.tar.gz"
},
"OutputDataConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/output"
},
"DebugHookConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/debug-output",
"CollectionConfigurations": [
{
"CollectionName": "losses",
"CollectionParameters" : {
"train.save_interval": "50"
}
}
]
},
"DebugRuleConfigurations": [
{
"RuleConfigurationName": "LossNotDecreasing",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {"rule_to_invoke": "LossNotDecreasing"}
}
],
"ProfilerConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/profiler-output",
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, \"MetricsRegex\": \".*\", }",
"DetailedProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, }",
"PythonProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, \"ProfilerName\": \"cprofile\", \"cProfileTimer\": \"total_time\"}",
"LocalPath": "/opt/ml/output/profiler/"
}
},
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {"rule_to_invoke": "ProfilerReport"}
}
],
"ResourceConfig": {
"InstanceType": "ml.p3.8xlarge",
"InstanceCount": 1,
"VolumeSizeInGB": 30
},
"StoppingCondition": {
"MaxRuntimeInSeconds": 86400
}
}
```
Después de guardar el archivo JSON, ejecute el siguiente comando en su terminal. (Utilice `!` al principio de la línea si usa un cuaderno de Jupyter).
```
aws sagemaker create-training-job --cli-input-json file://debugger-training-job-cli.json
```
## Configurar una regla del depurador para depurar los parámetros del modelo
Los siguientes ejemplos de código muestran cómo configurar una `VanishingGradient` regla integrada mediante esta SageMaker API.
**Permitir que el depurador recopile los tensores de salida**
Especifique la configuración del enlace del depurador de la siguiente manera:
```
"DebugHookConfig": {
"S3OutputPath": "s3:////debug-output",
"CollectionConfigurations": [
{
"CollectionName": "gradients",
"CollectionParameters" : {
"save_interval": "500"
}
}
]
}
```
Esto hará que el trabajo de entrenamiento guarde la colección de tensores, `gradients`, cada `save_interval` de 500 pasos. Para encontrar `CollectionName` los valores disponibles, consulta las [colecciones integradas de Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections) en la *documentación de la biblioteca del SMDebug cliente*. Para encontrar las claves y valores de los `CollectionParameters` parámetros disponibles, consulta la [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)clase en la *documentación del SDK de SageMaker Python*.
**Activar las reglas del depurador para depurar los tensores de salida**
El siguiente ejemplo de API `DebugRuleConfigurations` muestra cómo ejecutar la regla `VanishingGradient`integrada en la colección `gradients` guardada.
```
"DebugRuleConfigurations": [
{
"RuleConfigurationName": "VanishingGradient",
"RuleEvaluatorImage": "503895931360.dkr.ecr.us-east-1.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "VanishingGradient",
"threshold": "20.0"
}
}
]
```
Con una configuración como la de este ejemplo, el depurador inicia un trabajo de evaluación de reglas para el trabajo de entrenamiento mediante la regla `gradients` de la colección de tensores `VanishingGradient`. Para ver una lista completa de las imágenes de Docker disponibles para usar las reglas del depurador, consulte [Imágenes de Docker para reglas del depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar los pares clave-valor de `RuleParameters`, consulte [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
## Configurar una regla integrada en el depurador para perfilar las métricas del sistema y del marco
El siguiente código de ejemplo muestra cómo especificar la operación de la ProfilerConfig API para permitir la recopilación de métricas del sistema y del marco.
**Habilitar la creación de perfiles del depurador para recopilar métricas del sistema y del marco**
------
#### [ Target Step ]
```
"ProfilerConfig": {
// Optional. Path to an S3 bucket to save profiling outputs
"S3OutputPath": "s3:////profiler-output",
// Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3, \"MetricsRegex\": \".*\" }",
"DetailedProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3 }",
// For PythonProfilingConfig,
// available ProfilerName options: cProfile, Pyinstrument
// available cProfileTimer options only when using cProfile: cpu, off_cpu, total_time
"PythonProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3, \"ProfilerName\": \"cProfile\", \"cProfileTimer\": \"total_time\" }",
// Optional. Local path for profiling outputs
"LocalPath": "/opt/ml/output/profiler/"
}
}
```
------
#### [ Target Time Duration ]
```
"ProfilerConfig": {
// Optional. Path to an S3 bucket to save profiling outputs
"S3OutputPath": "s3:////profiler-output",
// Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10, \"MetricsRegex\": \".*\" }",
"DetailedProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10 }",
// For PythonProfilingConfig,
// available ProfilerName options: cProfile, Pyinstrument
// available cProfileTimer options only when using cProfile: cpu, off_cpu, total_time
"PythonProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10, \"ProfilerName\": \"cProfile\", \"cProfileTimer\": \"total_time\" }",
// Optional. Local path for profiling outputs
"LocalPath": "/opt/ml/output/profiler/"
}
}
```
------
**Habilitar las reglas del depurador para perfilar las métricas**
En el siguiente ejemplo de código se muestra cómo configurar la regla `ProfilerReport`.
```
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "ProfilerReport",
"CPUBottleneck_cpu_threshold": "90",
"IOBottleneck_threshold": "90"
}
}
]
```
Para ver una lista completa de las imágenes de Docker disponibles para usar las reglas del depurador, consulte [Imágenes de Docker para reglas del depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar los pares clave-valor de `RuleParameters`, consulte [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
## Actualización de la configuración de creación de perfiles del depurador mediante la API de `UpdateTrainingJob`
La configuración de creación de perfiles del depurador se puede actualizar mientras se ejecuta el trabajo de formación mediante la operación de [UpdateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html)API. Configure los nuevos [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)objetos [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)y especifique el nombre del trabajo de formación en el `TrainingJobName` parámetro.
```
{
"ProfilerConfig": {
"DisableProfiler": boolean,
"ProfilingIntervalInMilliseconds": number,
"ProfilingParameters": {
"string" : "string"
}
},
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "string",
"RuleEvaluatorImage": "string",
"RuleParameters": {
"string" : "string"
}
}
],
"TrainingJobName": "your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS"
}
```
## Agregación de la configuración de reglas personalizadas del depurador a la API de `CreateTrainingJob`
Se puede configurar una regla personalizada para un trabajo de formación utilizando los [ DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)objetos [ DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)y de la operación de la [ CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API. En el siguiente ejemplo de código, se muestra cómo configurar una `ImproperActivation` regla personalizada escrita con la biblioteca *smdebug* mediante esta operación de SageMaker API. En este ejemplo se supone que ha escrito la regla personalizada en el archivo *custom\$1rules.py* y la ha cargado en un bucket de Amazon S3. El ejemplo proporciona imágenes de Docker prediseñadas que puede usar para ejecutar sus reglas personalizadas. Se enumeran en [Imagen de Amazon SageMaker Debugger URIs para evaluadores de reglas personalizados](debugger-reference.md#debuger-custom-rule-registry-ids). Especifique la dirección URL del registro para la imagen de Docker prediseñada en el parámetro `RuleEvaluatorImage`.
```
"DebugHookConfig": {
"S3OutputPath": "s3:////debug-output",
"CollectionConfigurations": [
{
"CollectionName": "relu_activations",
"CollectionParameters": {
"include_regex": "relu",
"save_interval": "500",
"end_step": "5000"
}
}
]
},
"DebugRulesConfigurations": [
{
"RuleConfigurationName": "improper_activation_job",
"RuleEvaluatorImage": "552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest",
"InstanceType": "ml.c4.xlarge",
"VolumeSizeInGB": 400,
"RuleParameters": {
"source_s3_uri": "s3://bucket/custom_rules.py",
"rule_to_invoke": "ImproperActivation",
"collection_names": "relu_activations"
}
}
]
```
Para ver una lista completa de las imágenes de Docker disponibles para usar las reglas del depurador, consulte [Imágenes de Docker para reglas del depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar los pares clave-valor de `RuleParameters`, consulte [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
# SDK para Python (Boto3)
Las reglas integradas de Amazon SageMaker Debugger se pueden configurar para un trabajo de formación mediante la [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job)función del cliente AWS Boto3 AI SageMaker . Debe especificar el URI de la imagen correcta en el parámetro `RuleEvaluatorImage`; los siguientes ejemplos explican cómo configurar el cuerpo de la solicitud de la función [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job).
En el siguiente código se muestra un ejemplo completo de cómo configurar Debugger para el cuerpo de la `create_training_job()` solicitud e iniciar un trabajo de formación en él`us-west-2`, suponiendo que se prepare un guion `entry_point/train.py` de formación utilizando. TensorFlow Para encontrar un end-to-end ejemplo de bloc de notas, consulte Creación de [perfiles de TensorFlow múltiples nodos y GPU para tareas de formación con Amazon SageMaker Debugger (Boto3](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_profiling/tf-resnet-profiling-multi-gpu-multi-node-boto3.html)).
**nota**
Asegúrese de utilizar las imágenes del contenedor de Docker correctas. Para encontrar las imágenes de AWS Deep Learning Containers [disponibles, consulte Imágenes de Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) disponibles. Para ver una lista completa de las imágenes de Docker disponibles para usar las reglas del depurador, consulte [Imágenes de Docker para reglas del depurador](debugger-reference.md#debugger-docker-images-rules).
```
import sagemaker, boto3
import datetime, tarfile
# Start setting up a SageMaker session and a Boto3 SageMaker client
session = sagemaker.Session()
region = session.boto_region_name
bucket = session.default_bucket()
# Upload a training script to a default Amazon S3 bucket of the current SageMaker session
source = 'source.tar.gz'
project = 'debugger-boto3-test'
tar = tarfile.open(source, 'w:gz')
tar.add ('entry_point/train.py') # Specify the directory and name of your training script
tar.close()
s3 = boto3.client('s3')
s3.upload_file(source, bucket, project+'/'+source)
# Set up a Boto3 session client for SageMaker
sm = boto3.Session(region_name=region).client("sagemaker")
# Start a training job
sm.create_training_job(
TrainingJobName='debugger-boto3-'+datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S'),
HyperParameters={
'sagemaker_submit_directory': 's3://'+bucket+'/'+project+'/'+source,
'sagemaker_program': '/entry_point/train.py' # training scrip file location and name under the sagemaker_submit_directory
},
AlgorithmSpecification={
# Specify a training Docker container image URI (Deep Learning Container or your own training container) to TrainingImage.
'TrainingImage': '763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.4.1-gpu-py37-cu110-ubuntu18.04',
'TrainingInputMode': 'File',
'EnableSageMakerMetricsTimeSeries': False
},
RoleArn='arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20201014T161125',
OutputDataConfig={'S3OutputPath': 's3://'+bucket+'/'+project+'/output'},
ResourceConfig={
'InstanceType': 'ml.p3.8xlarge',
'InstanceCount': 1,
'VolumeSizeInGB': 30
},
StoppingCondition={
'MaxRuntimeInSeconds': 86400
},
DebugHookConfig={
'S3OutputPath': 's3://'+bucket+'/'+project+'/debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'losses',
'CollectionParameters' : {
'train.save_interval': '500',
'eval.save_interval': '50'
}
}
]
},
DebugRuleConfigurations=[
{
'RuleConfigurationName': 'LossNotDecreasing',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {'rule_to_invoke': 'LossNotDecreasing'}
}
],
ProfilerConfig={
'S3OutputPath': 's3://'+bucket+'/'+project+'/profiler-output',
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{"StartStep": 5, "NumSteps": 3, "MetricsRegex": ".*", }',
'DetailedProfilingConfig': '{"StartStep": 5, "NumSteps": 3, }',
'PythonProfilingConfig': '{"StartStep": 5, "NumSteps": 3, "ProfilerName": "cprofile", "cProfileTimer": "total_time"}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
},
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {'rule_to_invoke': 'ProfilerReport'}
}
]
)
```
## Configurar una regla del depurador para depurar los parámetros del modelo
Los siguientes ejemplos de código muestran cómo configurar una `VanishingGradient` regla integrada mediante esta SageMaker API.
**Permitir que el depurador recopile los tensores de salida**
Especifique la configuración del enlace del depurador de la siguiente manera:
```
DebugHookConfig={
'S3OutputPath': 's3:////debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'gradients',
'CollectionParameters' : {
'train.save_interval': '500',
'eval.save_interval': '50'
}
}
]
}
```
Esto hará que el trabajo de entrenamiento guarde una colección de tensores, `gradients`, cada `save_interval` de 500 pasos. Para encontrar `CollectionName` los valores disponibles, consulta las [colecciones integradas de Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections) en la *documentación de la biblioteca del SMDebug cliente*. Para encontrar las claves y valores de los `CollectionParameters` parámetros disponibles, consulta la [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)clase en la *documentación del SDK de SageMaker Python*.
**Activar las reglas del depurador para depurar los tensores de salida**
El siguiente ejemplo de API `DebugRuleConfigurations` muestra cómo ejecutar la regla `VanishingGradient`integrada en la colección `gradients` guardada.
```
DebugRuleConfigurations=[
{
'RuleConfigurationName': 'VanishingGradient',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'VanishingGradient',
'threshold': '20.0'
}
}
]
```
Con una configuración como la de este ejemplo, el depurador inicia un trabajo de evaluación de reglas para el trabajo de entrenamiento mediante la regla `gradients` de la colección de tensores `VanishingGradient`. Para ver una lista completa de las imágenes de Docker disponibles para usar las reglas del depurador, consulte [Imágenes de Docker para reglas del depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar los pares clave-valor de `RuleParameters`, consulte [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
## Configurar una regla integrada en el depurador para perfilar las métricas del sistema y del marco
El siguiente código de ejemplo muestra cómo especificar la operación de la ProfilerConfig API para permitir la recopilación de métricas del sistema y del marco.
**Habilitar la creación de perfiles del depurador para recopilar métricas del sistema y del marco**
------
#### [ Target Step ]
```
ProfilerConfig={
'S3OutputPath': 's3:////profiler-output', # Optional. Path to an S3 bucket to save profiling outputs
# Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3,
"MetricsRegex": ".*"
}',
'DetailedProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3
}',
'PythonProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3,
"ProfilerName": "cprofile", # Available options: cprofile, pyinstrument
"cProfileTimer": "total_time" # Include only when using cprofile. Available options: cpu, off_cpu, total_time
}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
}
```
------
#### [ Target Time Duration ]
```
ProfilerConfig={
'S3OutputPath': 's3:////profiler-output', # Optional. Path to an S3 bucket to save profiling outputs
# Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10,
"MetricsRegex": ".*"
}',
'DetailedProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10
}',
'PythonProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10,
"ProfilerName": "cprofile", # Available options: cprofile, pyinstrument
"cProfileTimer": "total_time" # Include only when using cprofile. Available options: cpu, off_cpu, total_time
}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
}
```
------
**Habilitar las reglas del depurador para perfilar las métricas**
En el siguiente ejemplo de código se muestra cómo configurar la regla `ProfilerReport`.
```
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'ProfilerReport',
'CPUBottleneck_cpu_threshold': '90',
'IOBottleneck_threshold': '90'
}
}
]
```
Para ver una lista completa de las imágenes de Docker disponibles para usar las reglas del depurador, consulte [Imágenes de Docker para reglas del depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar los pares clave-valor de `RuleParameters`, consulte [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
## Actualice la configuración de creación de perfiles del depurador mediante la operación de la API `UpdateTrainingJob`.
La configuración de los perfiles del depurador se puede actualizar mientras se ejecuta el trabajo de entrenamiento mediante la [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_training_job)función del cliente AWS SageMaker Boto3 AI. Configure los nuevos [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)objetos [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)y especifique el nombre del trabajo de entrenamiento en el parámetro. `TrainingJobName`
```
ProfilerConfig={
'DisableProfiler': boolean,
'ProfilingIntervalInMilliseconds': number,
'ProfilingParameters': {
'string' : 'string'
}
},
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'string',
'RuleEvaluatorImage': 'string',
'RuleParameters': {
'string' : 'string'
}
}
],
TrainingJobName='your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS'
```
## Agregue la configuración de reglas personalizadas del depurador a la operación de la CreateTrainingJob API
Se puede configurar una regla personalizada para un trabajo de entrenamiento utilizando los [ DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)objetos [ DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)y mediante la función del cliente AWS Boto3 SageMaker AI. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job) El siguiente ejemplo de código muestra cómo configurar una `ImproperActivation` regla personalizada escrita con la biblioteca *smdebug* mediante esta operación de API. SageMaker En este ejemplo se supone que ha escrito la regla personalizada en el archivo *custom\$1rules.py* y la ha cargado en un bucket de Amazon S3. El ejemplo proporciona imágenes de Docker prediseñadas que puede usar para ejecutar sus reglas personalizadas. Se enumeran en [Imagen de Amazon SageMaker Debugger URIs para evaluadores de reglas personalizados](debugger-reference.md#debuger-custom-rule-registry-ids). Especifique la dirección URL del registro para la imagen de Docker prediseñada en el parámetro `RuleEvaluatorImage`.
```
DebugHookConfig={
'S3OutputPath': 's3:////debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'relu_activations',
'CollectionParameters': {
'include_regex': 'relu',
'save_interval': '500',
'end_step': '5000'
}
}
]
},
DebugRulesConfigurations=[
{
'RuleConfigurationName': 'improper_activation_job',
'RuleEvaluatorImage': '552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest',
'InstanceType': 'ml.c4.xlarge',
'VolumeSizeInGB': 400,
'RuleParameters': {
'source_s3_uri': 's3://bucket/custom_rules.py',
'rule_to_invoke': 'ImproperActivation',
'collection_names': 'relu_activations'
}
}
]
```
Para ver una lista completa de las imágenes de Docker disponibles para usar las reglas del depurador, consulte [Imágenes de Docker para reglas del depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar los pares clave-valor de `RuleParameters`, consulte [Lista de reglas integradas del depurador](debugger-built-in-rules.md).
# Referencias de Amazon SageMaker Debugger
Encontrará más información y referencias sobre el uso de Amazon SageMaker Debugger en los siguientes temas.
**Topics**
+ [Amazon SageMaker Debugger APIs](#debugger-apis)
+ [Imágenes de Docker para reglas del depurador](#debugger-docker-images-rules)
+ [Excepciones de Amazon SageMaker Debugger](#debugger-exceptions)
+ [Capacitación distribuida respaldada por Amazon SageMaker Debugger](#debugger-considerations)
## Amazon SageMaker Debugger APIs
Amazon SageMaker Debugger tiene operaciones de API en varias ubicaciones que se utilizan para implementar su supervisión y análisis del entrenamiento de modelos.
Amazon SageMaker Debugger también proporciona el [SDK de `sagemaker-debugger` Python](https://github.com/awslabs/sagemaker-debugger/tree/master/smdebug) de código abierto que se utiliza para configurar reglas integradas, definir reglas personalizadas y registrar enlaces para recopilar datos de tensores de salida de los trabajos de entrenamiento.
El [Amazon SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/) es un SDK de alto nivel centrado en la experimentación con aprendizaje automático. El SDK se puede usar para implementar reglas integradas o personalizadas definidas con la biblioteca de `SMDebug` Python para monitorear y analizar estos tensores mediante estimadores de SageMaker IA.
Debugger ha agregado operaciones y tipos a la SageMaker API de Amazon que permiten a la plataforma usar Debugger al entrenar un modelo y administrar la configuración de entradas y salidas.
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)y [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html)utilice el siguiente depurador APIs para configurar las colecciones de tensores, las reglas, las imágenes de reglas y las opciones de creación de perfiles:
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CollectionConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CollectionConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TensorBoardOutputConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TensorBoardOutputConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html) proporciona una descripción completa de un trabajo de entrenamiento, que incluye las siguientes configuraciones del depurador y los estados de evaluación de las reglas:
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleEvaluationStatus.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleEvaluationStatus.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleEvaluationStatus.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleEvaluationStatus.html)
Las operaciones de la API de configuración de reglas utilizan la funcionalidad de SageMaker procesamiento al analizar el entrenamiento de un modelo. Para obtener más información sobre SageMaker el procesamiento, consulte[Cargas de trabajo de transformación de datos con procesamiento SageMaker](processing-job.md).
## Imágenes de Docker para reglas del depurador
Amazon SageMaker AI proporciona dos conjuntos de imágenes de Docker para las reglas: un conjunto para evaluar las reglas proporcionadas por la SageMaker IA (reglas integradas) y otro conjunto para evaluar las reglas personalizadas proporcionadas en los archivos fuente de Python.
Si usa el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), simplemente puede usar las operaciones de la API Debugger de alto nivel de SageMaker IA con las operaciones de la API SageMaker AI Estimator, sin tener que recuperar manualmente las imágenes de Docker del Debugger y configurar la API. `ConfigureTrainingJob`
Si no está utilizando el SDK de SageMaker Python, debe recuperar una imagen base de contenedor prediseñada relevante para las reglas del depurador. Amazon SageMaker Debugger proporciona imágenes de Docker prediseñadas para reglas integradas y personalizadas, y las imágenes se almacenan en Amazon Elastic Container Registry (Amazon ECR). Para extraer una imagen de un repositorio de Amazon ECR (o para insertar una imagen en uno), utilice la URL de registro del nombre completo de la imagen mediante la `CreateTrainingJob` API. SageMaker AI utiliza los siguientes patrones de URL para la dirección de registro de imágenes del contenedor de reglas del depurador.
```
.dkr.ecr..amazonaws.com/:
```
Para conocer el ID de cuenta de cada AWS región, el nombre del repositorio de Amazon ECR y el valor de la etiqueta, consulte los siguientes temas.
**Topics**
+ [Imagen de Amazon SageMaker Debugger URIs para evaluadores de reglas integrados](#debuger-built-in-registry-ids)
+ [Imagen de Amazon SageMaker Debugger URIs para evaluadores de reglas personalizados](#debuger-custom-rule-registry-ids)
### Imagen de Amazon SageMaker Debugger URIs para evaluadores de reglas integrados
Utilice los siguientes valores para los componentes del registro URLs de las imágenes que proporcionan reglas integradas para Amazon SageMaker Debugger. Para obtener información sobre la cuenta IDs, consulte la siguiente tabla.
**Nombre del repositorio de ECR**: sagemaker-debugger-rules
**Etiqueta**: última
**Ejemplo de una dirección URL completa del registro**:
`904829902805.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rules:latest`
Tenga en cuenta IDs las imágenes del contenedor de reglas integradas por región AWS
| Region | account\$1id |
| --- | --- |
| af-south-1 | 314341159256 |
| ap-east-1 | 199566480951 |
| ap-northeast-1 | 430734990657 |
| ap-northeast-2 | 578805364391 |
| ap-south-1 | 904829902805 |
| ap-southeast-1 | 972752614525 |
| ap-southeast-2 | 184798709955 |
| ca-central-1 | 519511493484 |
| cn-north-1 | 618459771430 |
| cn-northwest-1 | 658757709296 |
| eu-central-1 | 482524230118 |
| eu-north-1 | 314864569078 |
| eu-south-1 | 563282790590 |
| eu-west-1 | 929884845733 |
| eu-west-2 | 250201462417 |
| eu-west-3 | 447278800020 |
| me-south-1 | 986000313247 |
| sa-east-1 | 818342061345 |
| us-east-1 | 503895931360 |
| us-east-2 | 915447279597 |
| us-west-1 | 685455198987 |
| us-west-2 | 895741380848 |
| us-gov-west-1 | 515509971035 |
### Imagen de Amazon SageMaker Debugger URIs para evaluadores de reglas personalizados
Utilice los siguientes valores para los componentes de la URL del registro para las imágenes que proporcionan evaluadores de reglas personalizados para Amazon SageMaker Debugger. Para obtener información sobre IDs la cuenta, consulte la siguiente tabla.
**Nombre del repositorio de ECR**: sagemaker-debugger-rule-evaluator
**Etiqueta**: última
**Ejemplo de una dirección URL completa del registro**:
`552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest`
Tenga en cuenta IDs las imágenes del contenedor de reglas personalizadas por región AWS
| Region | account\$1id |
| --- | --- |
| af-south-1 | 515950693465 |
| ap-east-1 | 645844755771 |
| ap-northeast-1 | 670969264625 |
| ap-northeast-2 | 326368420253 |
| ap-south-1 | 552407032007 |
| ap-southeast-1 | 631532610101 |
| ap-southeast-2 | 445670767460 |
| ca-central-1 | 105842248657 |
| cn-north-1 | 617202126805 |
| cn-northwest-1 | 658559488188 |
| eu-central-1 | 691764027602 |
| eu-north-1 | 091235270104 |
| eu-south-1 | 335033873580 |
| eu-west-1 | 606966180310 |
| eu-west-2 | 074613877050 |
| eu-west-3 | 224335253976 |
| me-south-1 | 050406412588 |
| sa-east-1 | 466516958431 |
| us-east-1 | 864354269164 |
| us-east-2 | 840043622174 |
| us-west-1 | 952348334681 |
| us-west-2 | 759209512951 |
| us-gov-west-1 | 515361955729 |
## Excepciones de Amazon SageMaker Debugger
Amazon SageMaker Debugger está diseñado para tener en cuenta que es posible que los tensores necesarios para ejecutar una regla no estén disponibles en todos los pasos. Como resultado, plantea algunas excepciones que le permiten controlar lo que sucede cuando falta un tensor. Estas excepciones están disponibles en el [módulo smdebug.exceptions](https://github.com/awslabs/sagemaker-debugger/blob/master/smdebug/exceptions.py). Puede importarlos de la siguiente manera:
```
from smdebug.exceptions import *
```
Están disponibles las siguientes excepciones:
+ `TensorUnavailableForStep`: el tensor solicitado no está disponible para el paso. Esto podría significar que el enlace podría no guardar este paso o que este paso podría haber guardado algunos tensores pero el tensor solicitado no forma parte de ellos. Tenga en cuenta que cuando vea esta excepción, significa que este tensor nunca podrá estar disponible para este paso en el futuro. Si el tensor tiene reducciones guardadas para el paso, le notifica que se pueden consultar.
+ `TensorUnavailable`: este tensor no se está guardando o no lo ha guardado la API `smdebug`. Esto significa que este tensor nunca se verá para ningún paso en `smdebug`.
+ `StepUnavailable`: el paso no se guardó y el depurador no tiene datos del paso.
+ `StepNotYetAvailable`: `smdebug` aún no ha visto el paso. Es posible que esté disponible en el futuro si el entrenamiento aún continúa. El depurador carga automáticamente los datos nuevos en cuanto están disponibles.
+ `NoMoreData`: se planteó cuando termina el entrenamiento. Una vez que vea esto, sabe que no hay más pasos y no hay más tensores que guardar.
+ `IndexReaderException`: el lector de índices no es válido.
+ `InvalidWorker`: se invocó un trabajador que no era válido.
+ `RuleEvaluationConditionMet`: la evaluación de la regla en el paso dio lugar a que se cumpliera la condición.
+ `InsufficientInformationForRuleInvocation`: no se proporcionó suficiente información para invocar la regla.
## Capacitación distribuida respaldada por Amazon SageMaker Debugger
La siguiente lista muestra el alcance de la validez y las consideraciones a la hora de utilizar el depurador en trabajos de entrenamiento con marcos de aprendizaje profundo y diversas opciones de entrenamiento distribuido.
+ **Horovod**
Ámbito de validez del uso del depurador para trabajos de entrenamiento con Horovod
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/debugger-reference.html)
+ **SageMaker Datos distribuidos de IA en paralelo**
Ámbito de validez del uso de Debugger para trabajos de formación con SageMaker IA distribuida de datos en paralelo
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/debugger-reference.html)
\$1 El depurador no admite la creación de perfiles de framework para la versión 2.x. TensorFlow
\$1\$1 Los datos distribuidos paralelos de SageMaker IA no admiten la versión TensorFlow 2.x con la implementación de Keras.
+ **SageMaker Modelo distribuido de IA en paralelo**: el depurador no admite el entrenamiento en paralelo de modelos distribuidos de SageMaker IA.
+ **Entrenamiento distribuido con puntos de control de SageMaker IA**: el depurador no está disponible para trabajos de formación cuando están habilitados tanto la opción de entrenamiento distribuido como los puntos de control de SageMaker IA. Es posible que aparezca un error como el siguiente:
```
SMDebug Does Not Currently Support Distributed Training Jobs With Checkpointing Enabled
```
Para utilizar Debugger para tareas de formación con opciones de formación distribuidas, debes desactivar los puntos de control de SageMaker IA y añadir funciones de puntos de control manuales a tu guion de entrenamiento. Para obtener más información sobre el uso del depurador con opciones de entrenamiento y puntos de control distribuidos, consulte [Uso de datos distribuidos de SageMaker IA en paralelo con Amazon SageMaker Debugger y puntos de control](distributed-troubleshooting-data-parallel.md#distributed-ts-data-parallel-debugger) y [Guardar puntos de control](distributed-troubleshooting-model-parallel.md#distributed-ts-model-parallel-checkpoints).
+ **Servidor de parámetros**: el depurador no admite el entrenamiento distribuido basado en un servidor de parámetros.
+ La creación de perfiles de las operaciones del marco de entrenamiento distribuido, como la `AllReduced` operación de datos distribuidos de SageMaker IA en paralelo y [las operaciones de Horovod](https://horovod.readthedocs.io/en/stable/timeline_include.html), no está disponible.