Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Adaptation de votre script d’entraînement pour enregistrer un hook
Amazon SageMaker Debugger est fourni avec une bibliothèque cliente appelée SDK [`sagemaker-debugger`Python](https://sagemaker-debugger.readthedocs.io/en/website). Le kit SDK Python pour `sagemaker-debugger` fournit des outils pour adapter votre script d'entraînement avant l'entraînement et des outils d'analyse après entraînement. Sur cette page, vous allez apprendre à adapter votre script d'entraînement à l'aide de la bibliothèque client.
Le kit SDK Python pour `sagemaker-debugger` fournit des fonctions de wrapper qui aident à enregistrer un hook pour extraire les tenseurs du modèle, sans altérer votre script d'entraînement. Pour commencer à collecter les tenseurs de sortie du modèle et à les déboguer pour trouver les problèmes d'entraînement, apportez les modifications suivantes à votre script d'entraînement.
**Astuce**
Pendant que vous suivez cette page, utilisez la [documentation sur le kit SDK open source pour `sagemaker-debugger`](https://sagemaker-debugger.readthedocs.io/en/website/index.html) pour accéder aux références d'API.
**Topics**
+ [Adaptez votre script PyTorch d'entraînement](debugger-modify-script-pytorch.md)
+ [Adaptez votre script TensorFlow d'entraînement](debugger-modify-script-tensorflow.md)
# Adaptez votre script PyTorch d'entraînement
Pour commencer à collecter les tenseurs de sortie du modèle et résoudre les problèmes d'entraînement, apportez les modifications suivantes à votre script d' PyTorch entraînement.
**Note**
SageMaker Le débogueur ne peut pas collecter les tenseurs de sortie du modèle à partir des opérations de l'API [https://pytorch.org/docs/stable/nn.functional.html](https://pytorch.org/docs/stable/nn.functional.html). Lorsque vous rédigez un script de PyTorch formation, il est recommandé d'utiliser les [https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html](https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html)modules à la place.
## Pour PyTorch 1.12.0
Si vous apportez un script d' PyTorch entraînement, vous pouvez exécuter la tâche d'entraînement et extraire les tenseurs de sortie du modèle à l'aide de quelques lignes de code supplémentaires dans votre script d'entraînement. Vous devez utiliser le [hook APIs](https://sagemaker-debugger.readthedocs.io/en/website/hook-api.html) dans la bibliothèque `sagemaker-debugger` cliente. Suivez les instructions suivantes qui décomposent les étapes à l'aide d'exemples de code.
1. Créez un hook.
**(Recommandé) Pour les emplois de formation au sein de l' SageMaker IA**
```
import smdebug.pytorch as smd
hook=smd.get_hook(create_if_not_exists=True)
```
Lorsque vous lancez une tâche de formation [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md) avec l'une des règles ou l' DebuggerHookConfigune des règles de votre estimateur, SageMaker AI ajoute un fichier de configuration JSON à votre instance d'entraînement qui est récupéré par la `get_hook` fonction. TensorBoardConfig Notez que si vous n'incluez aucune configuration APIs dans votre estimateur, il n'y aura aucun fichier de configuration à trouver pour le hook et la fonction retournera. `None`
**(Facultatif) Pour les emplois de formation en dehors de l' SageMaker IA**
Si vous exécutez des tâches de formation en mode local, directement sur des instances SageMaker Notebook, des instances Amazon EC2 ou sur vos propres appareils locaux, utilisez `smd.Hook` class pour créer un hook. Cependant, cette approche ne permet de stocker que les collections de tenseurs et de les utiliser pour la TensorBoard visualisation. SageMaker Les règles intégrées du débogueur ne fonctionnent pas avec le mode local car elles nécessitent des instances d'entraînement SageMaker AI ML et S3 pour stocker les sorties des instances distantes en temps réel. L'API `smd.get_hook` renvoie `None` dans ce cas.
Si vous souhaitez créer un hook manuel pour enregistrer les tenseurs en mode local, utilisez l'extrait de code suivant avec la logique permettant de vérifier si l'API `smd.get_hook` renvoie `None` et créez un hook manuel à l'aide de la classe `smd.Hook`. Notez que vous pouvez spécifier n'importe quel répertoire de sortie sur votre machine locale.
```
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. Enveloppez votre modèle avec les méthodes de classe du hook.
La méthode `hook.register_module()` prend votre modèle et itère sur chaque couche, recherchant tous les tenseurs qui correspondent aux expressions régulières que vous fournirez via la configuration dans [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md). Les tenseurs collectables via cette méthode de hook sont des poids, des biais, des activations, des gradients, des entrées et des sorties.
```
hook.register_module(model)
```
**Astuce**
Si vous collectez l'intégralité des tenseurs de sortie à partir d'un grand modèle de deep learning, la taille totale de ces collections peut augmenter de façon exponentielle et provoquer des goulots d'étranglement. Si vous souhaitez enregistrer des tenseurs spécifiques, vous pouvez également utiliser la méthode `hook.save_tensor()`. Cette méthode vous permet de sélectionner la variable pour le tenseur spécifique et de l'enregistrer dans une collection personnalisée nommée comme vous le souhaitez. Pour plus d'informations, consultez l'[étape 7](#debugger-modify-script-pytorch-save-custom-tensor) de cette instruction.
1. Enveloppez la fonction de perte avec les méthodes de classe du hook.
La méthode `hook.register_loss` consiste à envelopper la fonction de perte. Elle extrait les valeurs de perte à chaque intervalle `save_interval` que vous définirez lors de la configuration dans [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md), et les enregistre dans la collection `"losses"`.
```
hook.register_loss(loss_function)
```
1. Ajoutez `hook.set_mode(ModeKeys.TRAIN)` dans le bloc d'entraînement. Cela indique que la collection de tenseurs est extraite pendant la phase d'entraînement.
```
def train():
...
hook.set_mode(ModeKeys.TRAIN)
```
1. Ajoutez `hook.set_mode(ModeKeys.EVAL)` dans le bloc de validation. Cela indique que la collection de tenseurs est extraite pendant la phase de validation.
```
def validation():
...
hook.set_mode(ModeKeys.EVAL)
```
1. Utilisez [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) pour enregistrer des scalaires personnalisés. Vous pouvez enregistrer des valeurs scalaires qui ne figurent pas dans votre modèle. Par exemple, si vous souhaitez enregistrer les valeurs de précision calculées lors de l'évaluation, ajoutez la ligne de code suivante sous la ligne où vous calculez la précision.
```
hook.save_scalar("accuracy", accuracy)
```
Notez que vous devez fournir une chaîne comme premier argument pour nommer la collection scalaire personnalisée. Il s'agit du nom qui sera utilisé pour visualiser les valeurs scalaires. Il peut s'agir de TensorBoard n'importe quelle chaîne de votre choix.
1. Utilisez [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) pour enregistrer des tenseurs personnalisés. Comme pour [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), vous pouvez enregistrer des tenseurs supplémentaires en définissant votre propre collection de tenseurs. Par exemple, vous pouvez extraire les données d'image d'entrée qui sont transmises au modèle et les enregistrer sous forme de tenseur personnalisé en ajoutant la ligne de code suivante, où `"images"` est un exemple de nom de tenseur personnalisé et `image_inputs` est un exemple de variable pour les données d'image d'entrée.
```
hook.save_tensor("images", image_inputs)
```
Notez que vous devez fournir une chaîne au premier argument pour nommer le tenseur personnalisé. `hook.save_tensor()` contient le troisième argument `collections_to_write` pour spécifier la collection de tenseurs dans laquelle enregistrer le tenseur personnalisé. La valeur par défaut est `collections_to_write="default"`. Si vous ne spécifiez pas explicitement le troisième argument, le tenseur personnalisé est enregistré dans la collection de tenseurs `"default"`.
Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md).
# Adaptez votre script TensorFlow d'entraînement
Pour commencer à collecter les tenseurs de sortie du modèle et résoudre les problèmes d'entraînement, apportez les modifications suivantes à votre script d' TensorFlow entraînement.
**Créez une opportunité pour les emplois de formation dans le domaine de l' SageMaker IA**
```
import smdebug.tensorflow as smd
hook=smd.get_hook(hook_type="keras", create_if_not_exists=True)
```
Cela crée un crochet lorsque vous commencez un travail SageMaker de formation. Lorsque vous lancez une tâche de formation [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md) avec l'un des `DebuggerHookConfig``TensorBoardConfig`, ou `Rules` dans votre estimateur, SageMaker AI ajoute un fichier de configuration JSON à votre instance de formation qui est récupéré par la `smd.get_hook` méthode. Notez que si vous n'incluez aucune configuration APIs dans votre estimateur, il n'y aura aucun fichier de configuration à trouver pour le hook et la fonction retournera. `None`
**(Facultatif) Créez un crochet pour les emplois de formation en dehors de l' SageMaker IA**
Si vous exécutez des tâches de formation en mode local, directement sur des instances SageMaker Notebook, des instances Amazon EC2 ou sur vos propres appareils locaux, utilisez `smd.Hook` class pour créer un hook. Cependant, cette approche ne permet de stocker que les collections de tenseurs et de les utiliser pour la TensorBoard visualisation. SageMaker Les règles intégrées du débogueur ne fonctionnent pas avec le mode local. La méthode `smd.get_hook` renvoie également `None` dans ce cas.
Si vous souhaitez créer un hook manuel, utilisez l'extrait de code suivant avec la logique permettant de vérifier si le hook renvoie `None`, et créez un hook manuel à l'aide de la classe `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
)
```
Après avoir ajouté le code de création du hook, passez à la rubrique suivante pour TensorFlow Keras.
**Note**
SageMaker Le débogueur ne prend actuellement en charge que TensorFlow Keras.
## Enregistrez le hook dans votre script d'entraînement TensorFlow Keras
La procédure suivante explique comment utiliser le hook et ses méthodes pour collecter des scalaires et des tenseurs de sortie à partir de votre modèle et de votre optimiseur.
1. Enveloppez votre modèle Keras et votre optimiseur avec les méthodes de classe du hook.
La méthode `hook.register_model()` prend votre modèle et itère sur chaque couche, recherchant tous les tenseurs qui correspondent aux expressions régulières que vous fournirez via la configuration dans [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md). Les tenseurs collectables via cette méthode de hook sont des poids, des biais et des activations.
```
model=tf.keras.Model(...)
hook.register_model(model)
```
1. Enveloppez l'optimiseur avec la méthode `hook.wrap_optimizer()`.
```
optimizer=tf.keras.optimizers.Adam(...)
optimizer=hook.wrap_optimizer(optimizer)
```
1. Compilez le modèle en mode rapide dans TensorFlow.
Pour collecter des tenseurs à partir du modèle, tels que les tenseurs d'entrée et de sortie de chaque couche, vous devez exécuter l'entraînement en mode Eager. Sinon, SageMaker AI Debugger ne pourra pas collecter les tenseurs. Cependant, d'autres tenseurs, tels que les poids, les biais et les pertes du modèle, peuvent être collectés sans exécuter explicitement le mode Eager.
```
model.compile(
loss="categorical_crossentropy",
optimizer=optimizer,
metrics=["accuracy"],
# Required for collecting tensors of each layer
run_eagerly=True
)
```
1. Enregistrez le hook avec la méthode [https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit](https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit).
Pour collecter les tenseurs des hooks que vous avez enregistrés, ajoutez `callbacks=[hook]` à la méthode de classe `model.fit()` Keras. Le hook `sagemaker-debugger` sera alors transmis en tant que rappel 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 2.x fournit uniquement des variables de gradient symboliques qui ne donnent pas accès à leurs valeurs. Pour collecter des gradients, enveloppez `tf.GradientTape` avec la méthode [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), ce qui vous oblige à écrire votre propre étape d'entraînement comme suit.
```
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))
```
En enveloppant la bande, le hook `sagemaker-debugger` peut identifier les tenseurs de sortie tels que les gradients, les paramètres et les pertes. L'enroulement de la bande garantit que la `hook.wrap_tape()` méthode utilisée pour définir les fonctions de l'objet de la bande `push_tape()` `pop_tape()``gradient()`, telles que,,, configurera les rédacteurs de SageMaker Debugger et enregistrera les tenseurs fournis en entrée `gradient()` (variables entraînables et pertes) et en sortie (dégradés). `gradient()`
**Note**
Pour collecter avec une boucle d'entraînement personnalisée, assurez-vous d'utiliser le mode Eager. Sinon, SageMaker Debugger n'est pas en mesure de collecter des tenseurs.
Pour une liste complète des actions APIs proposées par le `sagemaker-debugger` hook pour créer des hooks et enregistrer des tenseurs, consultez [Hook Methods](https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html) dans la documentation du *SDK `sagemaker-debugger` Python*.
Une fois que vous avez terminé d'adapter votre scénario d'entraînement, passez à [Lancez des tâches de formation avec Debugger à l'aide du SDK Python SageMaker](debugger-configuration-for-debugging.md).