As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Adaptação do seu script de treinamento para registrar um hook
[O Amazon SageMaker Debugger vem com uma biblioteca cliente chamada Python `sagemaker-debugger` SDK.](https://sagemaker-debugger.readthedocs.io/en/website) O `sagemaker-debugger` Python SDK fornece ferramentas para adaptar seu script de treinamento antes do treinamento e ferramentas de análise após o treinamento. Nesta página, você aprenderá como adaptar seu script de treinamento usando a biblioteca de cliente.
O `sagemaker-debugger` Python SDK fornece funções de wrapper que ajudam a registrar um hook para extrair os tensores do modelo, sem alterar seu script de treinamento. Para começar a usar a coleção de tensores de saída do modelo e depurá-los para encontrar problemas de treinamento, faça as seguintes modificações em seu script de treinamento:
**dica**
Enquanto estiver acompanhando esta página, use a [documentação do SDK de código aberto do `sagemaker-debugger`](https://sagemaker-debugger.readthedocs.io/en/website/index.html) para referências de API.
**Topics**
+ [Adapte seu roteiro PyTorch de treinamento](debugger-modify-script-pytorch.md)
+ [Adapte seu roteiro TensorFlow de treinamento](debugger-modify-script-tensorflow.md)
# Adapte seu roteiro PyTorch de treinamento
Para começar a coletar tensores de saída do modelo e depurar problemas de treinamento, faça as seguintes modificações em seu script de PyTorch treinamento.
**nota**
SageMaker O depurador não pode coletar tensores de saída do modelo das operações da API. [https://pytorch.org/docs/stable/nn.functional.html](https://pytorch.org/docs/stable/nn.functional.html) Ao escrever um script PyTorch de treinamento, é recomendável usar os [https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html](https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html)módulos em vez disso.
## Para PyTorch 1.12.0
Se você trouxer um script de PyTorch treinamento, poderá executar o trabalho de treinamento e extrair os tensores de saída do modelo com algumas linhas de código adicionais em seu script de treinamento. Você precisa usar o [gancho APIs](https://sagemaker-debugger.readthedocs.io/en/website/hook-api.html) na biblioteca do `sagemaker-debugger` cliente. Siga as instruções a seguir que detalham as etapas com exemplos de código.
1. Crie um hook.
**(Recomendado) Para trabalhos de treinamento em SageMaker IA**
```
import smdebug.pytorch as smd
hook=smd.get_hook(create_if_not_exists=True)
```
Quando você inicia um trabalho de treinamento [Inicie trabalhos de treinamento com o Debugger usando o SDK do Python SageMaker](debugger-configuration-for-debugging.md) com qualquer uma das regras DebuggerHookConfig, TensorBoardConfig, ou em seu estimador, a SageMaker IA adiciona um arquivo de configuração JSON à sua instância de treinamento que é captado pela função. `get_hook` Observe que, se você não incluir nenhuma configuração APIs em seu estimador, não haverá nenhum arquivo de configuração para o gancho encontrar e a função retornará. `None`
**(Opcional) Para trabalhos de treinamento fora da SageMaker IA**
Se você executa trabalhos de treinamento no modo local, diretamente nas instâncias do SageMaker Notebook, nas instâncias do Amazon EC2 ou em seus próprios dispositivos locais, use a `smd.Hook` classe para criar um gancho. No entanto, essa abordagem só pode armazenar as coleções de tensores e pode ser usada para TensorBoard visualização. SageMaker As regras integradas do Debugger não funcionam com o modo local porque exigem que as instâncias de treinamento de SageMaker AI ML e o S3 armazenem as saídas das instâncias remotas em tempo real. A API `smd.get_hook` retorna a `None` nesse caso.
Se você quiser criar um hook manual para salvar tensores no modo local, use o seguinte trecho de código com a lógica para verificar se a API `smd.get_hook` retorna a `None` e cria um hook manual usando a classe `smd.Hook`: Observe que você pode especificar qualquer diretório de saída em sua 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. Empacote seu modelo com os métodos de classe do hook.
O método `hook.register_module()` pega seu modelo e percorre cada camada, procurando por tensores que correspondam às expressões regulares que você fornecerá por meio da configuração em [Inicie trabalhos de treinamento com o Debugger usando o SDK do Python SageMaker](debugger-configuration-for-debugging.md). Os tensores coletáveis por meio desse método de hook são pesos, tendências, ativações, gradientes, entradas e saídas.
```
hook.register_module(model)
```
**dica**
Se você coletar todos os tensores de saída de um grande modelo de aprendizado profundo, o tamanho total dessas coleções pode crescer exponencialmente e causar gargalos. Se quiser salvar tensores específicos, você também pode usar o método `hook.save_tensor()`. Esse método ajuda você a escolher a variável para o tensor específico e salvar em uma coleção personalizada com o nome desejado. Para obter mais informações, consulte a [etapa 7](#debugger-modify-script-pytorch-save-custom-tensor) desta instrução.
1. Distorça a função de perda com os métodos de classe de hook.
O método `hook.register_loss` é empacotar a função de perda. Ele extrai todos os valores de perda `save_interval` que você definirá durante a configuração em [Inicie trabalhos de treinamento com o Debugger usando o SDK do Python SageMaker](debugger-configuration-for-debugging.md) e os salva na coleção de `"losses"`.
```
hook.register_loss(loss_function)
```
1. Adicione `hook.set_mode(ModeKeys.TRAIN)` no bloco de treinamento. Isso indica que a coleção de tensores é extraída durante a fase de treinamento.
```
def train():
...
hook.set_mode(ModeKeys.TRAIN)
```
1. Adicione `hook.set_mode(ModeKeys.EVAL)` no bloco de validação. Isso indica que a coleção de tensores é extraída durante a fase de validação.
```
def validation():
...
hook.set_mode(ModeKeys.EVAL)
```
1. Use [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 salvar escalares personalizados. Você pode salvar valores escalares que não estão no modelo. Por exemplo, se você quiser registrar os valores de precisão calculados durante a avaliação, adicione a seguinte linha de código abaixo da linha em que você calcula a precisão:
```
hook.save_scalar("accuracy", accuracy)
```
Observe que você precisa fornecer uma string como primeiro argumento para nomear a coleção escalar personalizada. Esse é o nome que será usado para visualizar os valores escalares e pode ser qualquer string que você quiser. TensorBoard
1. Use [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 salvar tensores personalizados. Da mesma forma que em [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), você pode salvar tensores adicionais, definindo sua própria coleção de tensores. Por exemplo, você pode extrair dados de imagem de entrada que são passados para o modelo e salvar como um tensor personalizado adicionando a seguinte linha de código, onde `"images"` é um nome de exemplo do tensor personalizado, `image_inputs` é uma variável de exemplo para os dados da imagem de entrada:
```
hook.save_tensor("images", image_inputs)
```
Observe que você deve fornecer uma string para o primeiro argumento para nomear o tensor personalizado. O `hook.save_tensor()` tem o terceiro argumento `collections_to_write` para especificar a coleção de tensores para salvar o tensor personalizado. O padrão é `collections_to_write="default"`. Se você não especificar explicitamente o terceiro argumento, o tensor personalizado será salvo na coleção de tensores `"default"`.
Depois de concluir a adaptação do seu script de treinamento, prossiga para [Inicie trabalhos de treinamento com o Debugger usando o SDK do Python SageMaker](debugger-configuration-for-debugging.md).
# Adapte seu roteiro TensorFlow de treinamento
Para começar a coletar tensores de saída do modelo e depurar problemas de treinamento, faça as seguintes modificações em seu script de TensorFlow treinamento.
**Crie um gancho para trabalhos de treinamento em SageMaker IA**
```
import smdebug.tensorflow as smd
hook=smd.get_hook(hook_type="keras", create_if_not_exists=True)
```
Isso cria um problema quando você inicia um trabalho SageMaker de treinamento. Quando você inicia um trabalho de treinamento [Inicie trabalhos de treinamento com o Debugger usando o SDK do Python SageMaker](debugger-configuration-for-debugging.md) com qualquer um dos `DebuggerHookConfig``TensorBoardConfig`, ou `Rules` em seu estimador, a SageMaker IA adiciona um arquivo de configuração JSON à sua instância de treinamento que é captado pelo método. `smd.get_hook` Observe que, se você não incluir nenhuma configuração APIs em seu estimador, não haverá nenhum arquivo de configuração para o gancho encontrar e a função retornará. `None`
**(Opcional) Crie um gancho para treinar trabalhos fora da SageMaker IA**
Se você executa trabalhos de treinamento no modo local, diretamente nas instâncias do SageMaker Notebook, nas instâncias do Amazon EC2 ou em seus próprios dispositivos locais, use a `smd.Hook` classe para criar um gancho. No entanto, essa abordagem só pode armazenar as coleções de tensores e pode ser usada para TensorBoard visualização. SageMaker As regras integradas do Debugger não funcionam com o modo local. Neste caso, o método `smd.get_hook` também retorna a `None`.
Se você quiser criar um hook manual, use o seguinte trecho de código com a lógica para verificar se o hook retorna a `None` e cria um hook manual usando a 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
)
```
Depois de adicionar o código de criação do gancho, vá para o tópico a seguir para TensorFlow Keras.
**nota**
SageMaker Atualmente, o Debugger suporta TensorFlow apenas Keras.
## Registre o gancho em seu TensorFlow script de treinamento Keras
O procedimento a seguir mostra como usar o hook e seus métodos para coletar escalares e tensores de saída do seu modelo e otimizador.
1. Empacote seu modelo e otimizador Keras com os métodos de classe do hook.
O método `hook.register_model()` pega seu modelo e percorre cada camada, procurando por tensores que correspondam às expressões regulares que você fornecerá por meio da configuração em [Inicie trabalhos de treinamento com o Debugger usando o SDK do Python SageMaker](debugger-configuration-for-debugging.md). Os tensores coletáveis por meio desse método de hook são pesos, tendências e ativações.
```
model=tf.keras.Model(...)
hook.register_model(model)
```
1. Empacote o otimizador pelo método `hook.wrap_optimizer()`.
```
optimizer=tf.keras.optimizers.Adam(...)
optimizer=hook.wrap_optimizer(optimizer)
```
1. Compile o modelo no modo ávido em. TensorFlow
Para coletar tensores do modelo, como os tensores de entrada e saída de cada camada, você deve executar o treinamento no modo eager. Caso contrário, o SageMaker AI Debugger não conseguirá coletar os tensores. No entanto, outros tensores, como pesos, tendências e perdas do modelo, podem ser coletados sem serem executados explicitamente no modo eager.
```
model.compile(
loss="categorical_crossentropy",
optimizer=optimizer,
metrics=["accuracy"],
# Required for collecting tensors of each layer
run_eagerly=True
)
```
1. Registre o hook no 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 coletar os tensores dos hooks que você registrou, adicione `callbacks=[hook]` ao método da classe `model.fit()` do Keras. Isso fará com que o hook de `sagemaker-debugger` passe como um retorno de chamada do 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 fornece somente variáveis de gradiente simbólico que não fornecem acesso aos seus valores. Para coletar gradientes, empacote `tf.GradientTape` pelo 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 exige que você escreva sua própria etapa de treinamento da seguinte maneira:
```
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))
```
Ao empacotar a fita, o hook de `sagemaker-debugger` pode identificar tensores de saída, como gradientes, parâmetros e perdas. Empacotar a fita garante que o `hook.wrap_tape()` método em torno das funções do objeto de fita, como`push_tape()`,, `pop_tape()``gradient()`, configure os gravadores do SageMaker Debugger e salve os tensores que são fornecidos como entrada (variáveis treináveis e perda) e saída de `gradient()` (gradientes). `gradient()`
**nota**
Para coletar com um loop de treinamento personalizado, certifique-se de usar o modo eager. Caso contrário, o SageMaker Debugger não conseguirá coletar nenhum tensor.
Para ver uma lista completa das ações que o `sagemaker-debugger` gancho APIs oferece para construir ganchos e salvar tensores, consulte [Hook Methods](https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html) na documentação do SDK do *`sagemaker-debugger`Python*.
Depois de concluir a adaptação do seu script de treinamento, prossiga para [Inicie trabalhos de treinamento com o Debugger usando o SDK do Python SageMaker](debugger-configuration-for-debugging.md).