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