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