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á.
# Use o Depurador com contêineres de treinamento personalizados
O Amazon SageMaker Debugger está disponível para qualquer modelo de aprendizado profundo que você trouxer para a Amazon AI. SageMaker A AWS CLI`Estimator` API de SageMaker IA e o Debugger APIs permitem que você use qualquer imagem base do Docker para criar e personalizar contêineres para treinar seus modelos. Para usar o Depurador com contêineres personalizados, você precisa fazer uma alteração mínima em seu script de treinamento para implementar o retorno de chamada do hook do Depurador e recuperar tensores dos trabalhos de treinamento. As seções a seguir instruem você a usar o Depurador com Contêineres de Treinamento Personalizados.
Você precisa dos seguintes recursos para criar um contêiner personalizado com o Depurador:
+ [SDK para Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable)
+ [A biblioteca cliente de código SMDebug aberto](https://github.com/awslabs/sagemaker-debugger)
+ Uma imagem base do Docker de sua escolha
+ Seu script de treinamento com um hook do Depurador registrado: Para obter mais informações sobre como registrar um hook do Depurador no seu script de treinamento, consulte [Registre o Hook do Depurador em seu script de treinamento](#debugger-script-mode).
Para ver um end-to-end exemplo de uso do Debugger com um contêiner de treinamento personalizado, consulte o exemplo de caderno a seguir.
+ [Crie um contêiner de treinamento personalizado e depure trabalhos de treinamento com o Depurador](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/build_your_own_container_with_debugger/debugger_byoc.html)
**dica**
Esse contêiner personalizado com guia do Depurador é uma extensão do guia [Como adaptar o próprio contêiner de treinamento](adapt-training-container.md) que explica como criar e enviar seu contêiner de treinamento personalizado para o Amazon ECR.
## Prepare-se para criar um contêiner de treinamento personalizado
Para criar um contêiner do docker, a estrutura básica dos arquivos deve ter a seguinte aparência:
```
├── 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
```
## Registre o Hook do Depurador em seu script de treinamento
Para depurar seu treinamento de modelo, você precisa adicionar um hook do Depurador ao seu script de treinamento.
**nota**
Essa etapa é necessária para coletar os parâmetros do modelo (tensores de saída) para depurar o treinamento de modelos. Se você quiser apenas monitorar e criar um perfil, pode pular essa etapa de inscrição do hook e excluir o parâmetro `debugger_hook_config` ao construir um estimador.
O código de exemplo a seguir mostra a estrutura de um script de treinamento usando o modelo Keras ResNet 50 e como passar o gancho do Debugger como um retorno de chamada do Keras para depuração. Para encontrar um script de treinamento completo, consulte o script de [TensorFlow treinamento com o gancho SageMaker Debugger](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-debugger/build_your_own_container_with_debugger/docker/tf_keras_resnet_byoc.py).
```
# 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 obter mais informações sobre como registrar o gancho do Debugger para as estruturas e algoritmos compatíveis, consulte os links a seguir na biblioteca do cliente: SMDebug
+ [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)
Nos seguintes exemplos de scripts de treinamento dos cadernos, você pode encontrar mais exemplos sobre como adicionar os hooks do Depurador aos scripts de treinamento e coletar os tensores de saída em detalhes:
+ [Depurador no modo script com a estrutura 2.1 TensorFlow ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/tf2-keras-custom-container.html)
Para ver a diferença entre usar o Debugger em um contêiner de aprendizado profundo e no modo script, abra este notebook e coloque-o lado a lado com o exemplo [anterior do notebook Debugger em um contêiner de aprendizado profundo TensorFlow v2.1](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_zero_code_change/tf2-keras-default-container.html).
No modo de script, a parte de configuração do hook é removida do script no qual o estimador é definido. Em vez disso, o recurso de gancho do Debugger é mesclado ao script de treinamento, o script de treinamento [ TensorFlow Keras ResNet ](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/src/tf_keras_resnet_byoc.py) no modo script. O script de treinamento importa a `smdebug` biblioteca no ambiente TensorFlow Keras necessário para se comunicar com o algoritmo TensorFlow ResNet 50. Ele também implementa manualmente a funcionalidade do `smdebug` gancho adicionando o `callbacks=[hook]` argumento dentro da `train` função (na linha 49) e adicionando a configuração manual do gancho (na linha 89) fornecida pelo SageMaker Python SDK.
Esse exemplo de modo de script executa o trabalho de treinamento na estrutura de trabalho TF 2.1 para a comparação direta com a alteração de script zero no exemplo TF 2.1. A vantagem de configurar o Debugger no modo script é a flexibilidade de escolher versões da estrutura não cobertas pelos AWS Deep Learning Containers.
+ [Usando o Amazon SageMaker Debugger em um PyTorch contêiner no modo de script](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_custom_container)
Este notebook ativa o Debugger no modo script na estrutura v1.3.1. PyTorch PyTorchA v1.3.1 é compatível com contêineres de SageMaker IA, e este exemplo mostra detalhes de como modificar um script de treinamento.
O PyTorch estimador de SageMaker IA já está no modo script por padrão. No caderno, a linha para ativar o `script_mode` não está incluída na configuração do estimador.
Este caderno mostra etapas detalhadas para alterar [o script de PyTorch treinamento original](https://github.com/pytorch/examples/blob/master/mnist/main.py) para uma versão modificada para ativar o Debugger. Além disso, este exemplo mostra como você pode usar regras integradas do Depurador para detectar problemas de treinamento, como problema de desaparecimento de gradientes e os atributos de avaliação do Depurador para chamar e analisar os tensores salvos.
## Criar e configurar um Dockerfile
Abra sua SageMaker IA JupyterLab e crie uma nova pasta, `debugger_custom_container_test_folder` neste exemplo, para salvar seu script de treinamento `Dockerfile` e. O exemplo de código a seguir é um `Dockerfile` que inclui elogios essenciais da compilação do docker. Cole o conteúdo a seguir no arquivo de texto `Dockerfile` e salve-o. Carregue seu script de treinamento na mesma pasta.
```
# 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"]
```
Se você quiser usar uma imagem pré-criada de contêiner de aprendizado AWS profundo, consulte [Imagens de contêineres de aprendizado AWS profundo disponíveis](https://aws.amazon.com/releasenotes/available-deep-learning-containers-images/).
## Crie e envie a imagem personalizada do treinamento para o Amazon ECR
Crie um caderno de teste, `debugger_custom_container_test_notebook.ipynb`, e execute o código a seguir na célula do caderno. Isso acessará o diretório `debugger_byoc_test_docker`, criará o docker com o `algorithm_name`especificado e enviará o contêiner do docker para o 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
```
**dica**
Se você usa uma das imagens base do AWS Deep Learning Container, execute o código a seguir para fazer login no Amazon ECR e acessar o repositório de imagens do Deep Learning Container.
```
! aws ecr get-login-password --region {region} | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com
```
## Execute e depure os trabalhos de treinamento usando o contêiner de treinamento personalizado
Depois de criar e enviar seu contêiner docker para o Amazon ECR, configure um estimador de SageMaker IA com seu script de treinamento e os parâmetros específicos do Debugger. Depois de executar o `estimator.fit()`, o Depurador coletará os tensores de saída, irá monitorá-los e detectará problemas de treinamento. Usando os tensores salvos, você pode analisar melhor o trabalho de treinamento usando os principais atributos e ferramentas `smdebug`. Configurando um fluxo de trabalho do processo de monitoramento de regras do Debugger com o Amazon CloudWatch Events AWS Lambda, você pode automatizar a interrupção do processo de trabalho de treinamento sempre que as regras do Debugger detectarem problemas de treinamento.
```
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()
```