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á.
# SageMaker Depurador Amazon
Depure os tensores de saída do modelo de trabalhos de treinamento de aprendizado de máquina em tempo real e detecte problemas não convergentes usando o Amazon Debugger. SageMaker
## Recursos do Amazon SageMaker Debugger
Um trabalho de treinamento de machine learning (ML) pode ter problemas como sobreajuste, funções de ativação com saturação e gradientes que se diminuem, o que pode comprometer o desempenho do modelo.
SageMaker O Debugger fornece ferramentas para depurar trabalhos de treinamento e resolver esses problemas para melhorar o desempenho do seu modelo. O Depurador também oferece ferramentas para enviar alertas quando anomalias de treinamento são encontradas, executar ações contra os problemas e identificar a causa raiz deles por meio da visualização ao coletar métricas e tensores.
SageMaker O Debugger é compatível com as estruturas Apache MXNet,, PyTorch, e. TensorFlow XGBoost Para obter mais informações sobre estruturas e versões disponíveis suportadas pelo SageMaker Debugger, consulte. [Algoritmos e frameworks compatíveis](debugger-supported-frameworks.md)
![\[Visão geral de como o Amazon SageMaker Debugger funciona.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-main.png)
O fluxo de trabalho de alto nível do Depurador é o seguinte:
1. Modifique seu script de treinamento com o SDK Python `sagemaker-debugger`, se necessário.
1. Configure um trabalho SageMaker de treinamento com o SageMaker Debugger.
+ Configure usando a API SageMaker AI Estimator (para Python SDK).
+ Configure usando a [`CreateTrainingJob`solicitação de SageMaker IA (para Boto3 ou CLI](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html)).
+ Configure [contêineres de treinamento personalizados](debugger-bring-your-own-container.md) com o SageMaker Debugger.
1. Inicie um trabalho de treinamento e monitore os problemas de treinamento em tempo real.
+ [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
1. Seja alertado e tome medidas imediatas contra os problemas de treinamento.
+ Receba mensagens de texto e e-mails e interrompa os trabalhos de treinamento quando forem encontrados problemas de treinamento no uso de [Usar ações integradas das regras do Depurador](debugger-built-in-actions.md).
+ Configure suas próprias ações usando [Amazon CloudWatch Events AWS Lambda e.](debugger-cloudwatch-lambda.md)
1. Explore uma análise profunda dos problemas de treinamento.
+ Para a depuração de tensores de saída do modelo, consulte [Visualize os tensores de saída do depurador em TensorBoard](debugger-enable-tensorboard-summaries.md).
1. Corrija os problemas, considere as sugestões fornecidas pelo Depurador e repita as etapas de 1 a 5 até otimizar seu modelo e atingir a precisão desejada.
O guia do desenvolvedor do SageMaker Debugger explica os tópicos a seguir.
**Topics**
+ [Recursos do Amazon SageMaker Debugger](#debugger-features)
+ [Algoritmos e frameworks compatíveis](debugger-supported-frameworks.md)
+ [SageMaker Arquitetura do Amazon Debugger](debugger-how-it-works.md)
+ [Tutoriais do Depurador](debugger-tutorial.md)
+ [Depuração de trabalhos de treinamento usando o Amazon Debugger SageMaker](debugger-debug-training-jobs.md)
+ [Lista de regras integradas do Depurador](debugger-built-in-rules.md)
+ [Criação de regras personalizadas usando a biblioteca de cliente do Depurador](debugger-custom-rules.md)
+ [Use o Depurador com contêineres de treinamento personalizados](debugger-bring-your-own-container.md)
+ [Configurar o Debugger usando a API SageMaker](debugger-createtrainingjob-api.md)
+ [Referências do Amazon SageMaker Debugger](debugger-reference.md)
# Algoritmos e frameworks compatíveis
A tabela a seguir mostra as estruturas e algoritmos de aprendizado de máquina de SageMaker IA compatíveis com o Debugger.
|
|
| **SageMaker AI-supported frameworks and algorithms** | **Debugging output tensors** |
| --- |--- |
| [TensorFlow](https://sagemaker.readthedocs.io/en/stable/using_tf.html) | [AWS TensorFlow contêineres de aprendizado profundo](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.15.4 ou posterior |
| [PyTorch](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html) | [AWS PyTorch contêineres de aprendizado profundo](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.5.0 ou posterior |
| [MXNet](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html) | [AWS MXNet contêineres de aprendizado profundo](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.6.0 ou posterior |
| [XGBoost](https://sagemaker.readthedocs.io/en/stable/frameworks/xgboost/using_xgboost.html) | 1.0-1, 1.2-1, 1.3-1 |
| [SageMaker Estimador genérico de IA](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) | [Contêineres de treinamento personalizados](debugger-bring-your-own-container.md) (disponíveis para TensorFlow PyTorch, MXNet, e XGBoost com registro manual de ganchos) |
+ **Depuração de tensores de saída**: Monitore e depure os parâmetros do modelo, como pesos, gradientes, tendenciosos e valores escalares do seu trabalho de treinamento. As estruturas de aprendizado profundo disponíveis são Apache MXNet, TensorFlow PyTorch, e. XGBoost
**Importante**
Para a TensorFlow estrutura com Keras, o SageMaker Debugger desaprova o suporte de alteração de código zero para modelos de depuração criados usando os módulos 2.6 e posteriores. `tf.keras` TensorFlow Isso se deve às mudanças significativas anunciadas na nota de [lançamento TensorFlow 2.6.0](https://github.com/tensorflow/tensorflow/releases/tag/v2.6.0). Para obter instruções sobre como atualizar seu script de treinamento, consulte [Adapte seu roteiro TensorFlow de treinamento](debugger-modify-script-tensorflow.md).
**Importante**
A partir da PyTorch versão 1.12.0 e versões posteriores, o SageMaker Debugger descontinua o suporte à alteração de código zero para modelos de depuração.
Isso ocorre devido a alterações significativas que fazem com que o SageMaker Debugger interfira na funcionalidade. `torch.jit` Para obter instruções sobre como atualizar seu script de treinamento, consulte [Adapte seu roteiro PyTorch de treinamento](debugger-modify-script-pytorch.md).
Se a estrutura ou algoritmo que você deseja treinar e depurar não estiver listado na tabela, acesse o [Fórum de AWS discussão](https://forums.aws.amazon.com/) e deixe um comentário no SageMaker Debugger.
## Regiões da AWS
O Amazon SageMaker Debugger está disponível em todas as regiões em que o Amazon SageMaker AI está em serviço, exceto na região a seguir.
+ Ásia-Pacífico (Jacarta): `ap-southeast-3`
Para descobrir se a Amazon SageMaker AI está em serviço no seu Região da AWS, consulte [Serviços AWS regionais](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).
## Use o Depurador com contêineres de treinamento personalizados
Traga seus contêineres de treinamento para a SageMaker IA e obtenha informações sobre seus trabalhos de treinamento usando o Debugger. Maximize sua eficiência de processamento otimizando seu modelo nas instâncias do Amazon EC2, usando os atributos de monitoramento e depuração.
Para obter mais informações sobre como compilar seu contêiner de treinamento com a biblioteca de cliente `sagemaker-debugger`, enviá-lo para o Amazon Elastic Container Registry (Amazon ECR), monitorar e depurar, consulte [Use o Depurador com contêineres de treinamento personalizados](debugger-bring-your-own-container.md).
## Repositórios de código aberto do Debugger GitHub
APIs Os depuradores são fornecidos por meio do SDK do SageMaker Python e projetados para criar configurações de regras e ganchos do Debugger para as operações de IA e API. SageMaker [ CreateTrainingJob[ DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) A biblioteca de clientes `sagemaker-debugger` fornece ferramentas para registrar *hooks* e acessar os dados de treinamento por meio de seu atributo de *avaliação*, por meio de suas operações de API flexíveis e avançadas. Ele é compatível com as estruturas de aprendizado de máquina TensorFlow, PyTorch MXNet, e XGBoost no Python 3.6 e versões posteriores.
Para recursos diretos sobre o Depurador e as operações de API `sagemaker-debugger`, consulte os seguintes links:
+ [A documentação do Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_debugger.html)
+ [O SDK do Amazon SageMaker Python — Debugger APIs](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html)
+ [A documentação do `sagemaker-debugger` Python SDK](https://sagemaker-debugger.readthedocs.io/en/website/index.html) para a biblioteca cliente de código [aberto Amazon SageMaker Debugger](https://github.com/awslabs/sagemaker-debugger#amazon-sagemaker-debugger)
+ [O `sagemaker-debugger` PyPI](https://pypi.org/project/smdebug/)
Se você usa o SDK for Java para SageMaker realizar trabalhos de treinamento e quiser configurar o APIs Debugger, consulte as seguintes referências:
+ [SageMaker Depurador Amazon APIs](debugger-reference.md#debugger-apis)
+ [Configurar o Debugger usando a API SageMaker](debugger-createtrainingjob-api.md)
# SageMaker Arquitetura do Amazon Debugger
Este tópico mostra uma visão geral de alto nível do fluxo de trabalho do Amazon SageMaker Debugger.
O Depurador oferece apoio à funcionalidade do perfilador para *otimização de performance* e para identificar problemas de computação, como gargalos e subutilização do sistema, além de ajudar a otimizar a utilização de recursos de hardware em escala.
A funcionalidade de depuração do Depurador para a *otimização de modelos* consiste em analisar problemas de treinamento não convergentes que podem surgir e, ao mesmo tempo, minimizar as funções de perda usando algoritmos de otimização, como gradiente descendente e suas variações.
O diagrama a seguir mostra a arquitetura do SageMaker Debugger. Os blocos com linhas de limite em negrito são o que o Depurador gerencia para analisar o seu trabalho de treinamento.
![\[Visão geral de como o Amazon SageMaker Debugger funciona.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger_new_diagram.png)
O Depurador armazena os seguintes dados de seus trabalhos de treinamento no seu bucket seguro do Amazon S3:
+ **Tensores de saída**: Coleções de escalares e parâmetros de modelo que são continuamente atualizados durante as passagens de avanço e retorno durante o treinamento de modelos de ML. Os tensores de saída incluem valores escalares (precisão e perda) e matrizes (pesos, gradientes, camadas de entrada e camadas de saída).
**nota**
Por padrão, o Debugger monitora e depura trabalhos de SageMaker treinamento sem nenhum parâmetro específico do Debugger configurado nos estimadores de IA. SageMaker O Depurador coleta métricas do sistema a cada 500 milissegundos e tensores de saída básicos (saídas escalares, como perda e precisão) a cada 500 etapas. Ele também executa a regra `ProfilerReport` para analisar as métricas do sistema e agregar insights e painéis do Depurador do Studio e um perfilador de relatório. O Depurador salva os dados de saída em seu bucket protegido do Amazon S3.
As regras integradas do Depurador são executadas em contêineres de processamento projetados para avaliar modelos de machine learning ao processar os dados de treinamento coletados em seu bucket do S3 (consulte [Dados processados avaliar modelos](https://docs.aws.amazon.com//sagemaker/latest/dg/processing-job.html)). As regras integradas são totalmente gerenciadas pelo Depurador. Você também pode criar suas próprias regras personalizadas para o seu modelo e monitorar qualquer problema que desejar.
# Tutoriais do Depurador
Os tópicos a seguir orientam você pelos tutoriais, desde os básicos até os casos de uso avançados de monitoramento, criação de perfil e depuração de trabalhos de treinamento do SageMaker usando o Debugger. Explore os atributos do Debugger e saiba como você pode depurar e melhorar seus modelos de machine learning de forma eficiente usando o Debugger.
**Topics**
+ [Vídeos tutoriais do Depurador](debugger-videos.md)
+ [cadernos de exemplos do Depurador](debugger-notebooks.md)
+ [Demonstrações e visualização avançadas do Depurador](debugger-visualization.md)
# Vídeos tutoriais do Depurador
Os vídeos a seguir fornecem um tour pelos recursos do Amazon SageMaker Debugger usando instâncias de notebook SageMaker Studio e SageMaker AI.
**Topics**
+ [Modelos de depuração com o Amazon SageMaker Debugger no Studio Classic](#debugger-video-get-started)
+ [Mergulhe profundamente no Amazon SageMaker Debugger e SageMaker no monitor de modelos de IA](#debugger-video-dive-deep)
## Modelos de depuração com o Amazon SageMaker Debugger no Studio Classic
*Julien Simon, Evangelista AWS Técnico \$1 Duração: 14 minutos 17 segundos*
Este vídeo tutorial demonstra como usar o Amazon SageMaker Debugger para capturar e inspecionar informações de depuração de um modelo de treinamento. O exemplo de modelo de treinamento usado neste vídeo é uma rede neural convolucional simples (CNN) baseada em Keras com o back-end. TensorFlow SageMaker A IA em uma TensorFlow estrutura e o Debugger permitem que você crie um estimador diretamente usando o script de treinamento e depure o trabalho de treinamento.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/MqPdTj0Znwg)
É possível encontrar o caderno de exemplo no vídeo [neste repositório de demonstrações do Studio](https://gitlab.com/juliensimon/amazon-studio-demos/-/tree/master) fornecido pelo autor. Você precisa clonar o arquivo do `debugger.ipynb` notebook e o script de `mnist_keras_tf.py` treinamento no seu SageMaker Studio ou em uma instância do SageMaker notebook. Depois de clonar os dois arquivos, especifique o caminho `keras_script_path` para o arquivo `mnist_keras_tf.py` dentro do caderno `debugger.ipynb`. Por exemplo, se você clonou os dois arquivos no mesmo diretório, defina-o como `keras_script_path = "mnist_keras_tf.py"`.
## Mergulhe profundamente no Amazon SageMaker Debugger e SageMaker no monitor de modelos de IA
*Julien Simon, Evangelista AWS Técnico \$1 Duração: 44 minutos 34 segundos*
Esta sessão de vídeo explora os recursos avançados do Debugger e do SageMaker Model Monitor que ajudam a aumentar a produtividade e a qualidade de seus modelos. Primeiro, esse vídeo mostra como detectar e corrigir problemas de treinamento, visualizar tensores e aprimorar modelos com o Debugger. A seguir, às 22:41, o vídeo mostra como monitorar modelos em produção e identificar problemas de previsão, como recursos ausentes ou desvio de dados, usando o AI Model Monitor. SageMaker Por fim, ele oferece dicas de otimização de custos para ajudá-lo a aproveitar ao máximo seu orçamento de machine learning.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/0zqoeZxakOI)
É possível encontrar o caderno de exemplo do vídeo [neste repositório do Dev Days 2020 da AWS](https://gitlab.com/juliensimon/awsdevdays2020/-/tree/master/mls1) oferecido pelo autor.
# cadernos de exemplos do Depurador
SageMaker [Os [notebooks de exemplo do Debugger](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/) são fornecidos no repositório aws/. amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) Os cadernos de exemplo do Debugger orientam você nos casos de uso básicos e avançados de trabalhos de treinamento de depuração e criação de perfil.
Recomendamos que você execute os notebooks de exemplo no SageMaker Studio ou em uma instância do SageMaker Notebook porque a maioria dos exemplos foi projetada para trabalhos de treinamento no ecossistema de SageMaker IA, incluindo Amazon EC2, Amazon S3 e Amazon SageMaker Python SDK.
Para clonar o repositório de exemplo no SageMaker Studio, siga as instruções no [Amazon SageMaker Studio Tour](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-studio-end-to-end.html).
**Importante**
Para usar os novos recursos do Debugger, você precisa atualizar o SDK do SageMaker Python e a biblioteca cliente. `SMDebug` No kernel do IPython, no Jupyter Notebook JupyterLab ou no ambiente, execute o código a seguir para instalar as versões mais recentes das bibliotecas e reiniciar o kernel.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Cadernos de exemplo do Depurador para a criação de perfis de trabalhos de treinamento
A lista a seguir mostra exemplos de cadernos do Debugger que apresentam a adaptabilidade do Debugger para monitorar e criar perfis de tarefas de treinamento para vários modelos, conjuntos de dados e estruturas de machine learning.
| Título do caderno | Framework | Modelo | Conjunto de dados | Description |
| --- | --- | --- | --- | --- |
| [Análise de dados de perfil do Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/debugger_interactive_analysis_profiling/interactive_analysis_profiling_data.html) | TensorFlow | Keras 50 ResNet | Cifar-10 | Este notebook fornece uma introdução à análise interativa de dados perfilados capturados pelo SageMaker Debugger. Explore a funcionalidade completa das ferramentas de análise interativa `SMDebug`. |
| [Treinamento de aprendizado de máquina de perfil com o Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_nlp_sentiment_analysis/sentiment-analysis-tf-distributed-training-bringyourownscript.html) | TensorFlow | Rede neural convolucional 1-D | Conjunto de dados do IMDB | Crie o perfil de uma CNN TensorFlow 1-D para análise de sentimentos dos dados do IMDB que consistem em resenhas de filmes rotuladas como tendo sentimentos positivos ou negativos. Explore os insights do Studio Debugger e o relatório de criação de perfil do Debugger. |
| [ TensorFlow ResNet Modelo de criação de perfil de treinamento com várias configurações de treinamento distribuídas](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_profiling) | TensorFlow | ResNet50 | Cifar-10 | Execute trabalhos TensorFlow de treinamento com várias configurações de treinamento distribuídas, monitore a utilização dos recursos do sistema e defina o perfil do desempenho do modelo usando o Debugger. |
| [ PyTorch ResNet Modelo de criação de perfil de treinamento com várias configurações de treinamento distribuídas](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_profiling) | PyTorch | ResNet50 | Cifar-10 | Execute trabalhos PyTorch de treinamento com várias configurações de treinamento distribuídas, monitore a utilização dos recursos do sistema e defina o perfil do desempenho do modelo usando o Debugger. |
## Cadernos de exemplo do Depurador para a análise de parâmetros do modelo
A lista a seguir mostra exemplos de cadernos do Debugger que apresentam a adaptabilidade do Debugger para depurar trabalhos de treinamento para vários modelos, conjuntos de dados e estruturas de machine learning.
| Título do caderno | Framework | Modelo | Conjunto de dados | Description |
| --- | --- | --- | --- | --- |
| [Amazon SageMaker Debugger - Use uma regra integrada](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_builtin_rule) | TensorFlow | Rede neural convolucional | MNIST | Use as regras integradas do Amazon SageMaker Debugger para depurar um modelo. TensorFlow |
| [Amazon SageMaker Debugger - Tensorflow 2.1](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow2) | TensorFlow | ResNet50 | Cifar-10 | Use a configuração de gancho do Amazon SageMaker Debugger e as regras integradas para depurar um modelo com a estrutura Tensorflow 2.1. |
| [Visualizando tensores de depuração do treinamento MXNet](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_plot) | MXNet | Rede Neural Convolucional Gluon | Modo MNIST | Execute um trabalho de treinamento e configure o SageMaker Debugger para armazenar todos os tensores desse trabalho e, em seguida, visualize esses tensores em um notebook. |
| [Habilite o treinamento pontual com o Amazon SageMaker Debugger](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_spot_training) | MXNet | Rede Neural Convolucional Gluon | Modo MNIST | Saiba como o Debugger coleta dados de tensores de um trabalho de treinamento em uma instância spot e como usar as regras integradas do Debugger com treinamento spot gerenciado. |
| [Explique um XGBoost modelo que prevê a renda de um indivíduo com o Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/xgboost_census_explanations/xgboost-census-debugger-rules.html) | XGBoost | XGBoost Regressão | [Conjunto de dados do Censo de Adultos](https://archive.ics.uci.edu/ml/datasets/adult) | Aprenda a usar o gancho do Debugger e as regras integradas para coletar e visualizar dados de tensores de um modelo de XGBoost regressão, como valores de perda, recursos e valores SHAP. |
Para encontrar visualizações avançadas dos parâmetros do modelo e dos casos de uso, consulte o próximo tópico em [Demonstrações e visualização avançadas do Depurador](debugger-visualization.md).
# Demonstrações e visualização avançadas do Depurador
As demonstrações a seguir mostram casos de uso avançados e scripts de visualização usando o Debugger.
**Topics**
+ [Modelos de treinamento e poda com Amazon SageMaker Experiments and Debugger](#debugger-visualization-video-model-pruning)
+ [[Usando o SageMaker Debugger para monitorar um treinamento de modelo de autoencoder convolucional](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/autoencoder_mnist/autoencoder_mnist.html)](#debugger-visualization-autoencoder_mnist)
+ [[Usando o SageMaker Debugger para monitorar as atenções no treinamento do modelo BERT](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/bert_attention_head_view/bert_attention_head_view.html)](#debugger-visualization-bert_attention_head_view)
+ [[Usando o SageMaker Debugger para visualizar mapas de ativação de classes em redes neurais convolucionais () CNNs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/cnn_class_activation_maps/cnn_class_activation_maps.html)](#debugger-visualization-cnn_class_activation_maps)
## Modelos de treinamento e poda com Amazon SageMaker Experiments and Debugger
*Dra. Nathalie Rauschmayr, Cientista AWS Aplicada \$1 Duração: 49 minutos 26 segundos*
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/Tnv6HsT1r4I)
Descubra como o Amazon SageMaker Experiments and Debugger pode simplificar o gerenciamento de seus trabalhos de treinamento. O Amazon SageMaker Debugger fornece visibilidade transparente das tarefas de treinamento e salva métricas de treinamento em seu bucket do Amazon S3. SageMaker O Experiments permite que você chame as informações de treinamento como *testes* por meio do SageMaker Studio e oferece suporte à visualização do trabalho de treinamento. Isso ajuda a manter uma alta qualidade do modelo enquanto reduz parâmetros menos importantes com base na classificação de importância.
Este vídeo demonstra uma técnica de *poda de modelos que torna os AlexNet modelos pré-treinados ResNet 50 e S mais leves e acessíveis, mantendo altos padrões de precisão do modelo*.
SageMaker O AI Estimator treina esses algoritmos fornecidos pelo zoológico PyTorch modelo em um AWS Deep Learning Containers com PyTorch estrutura, e o Debugger extrai métricas de treinamento do processo de treinamento.
O vídeo também demonstra como configurar uma regra personalizada do Debugger para observar a precisão de um modelo removido, acionar um CloudWatch evento e uma AWS Lambda função da Amazon quando a precisão atingir um limite e interromper automaticamente o processo de remoção para evitar iterações redundantes.
Os objetivos de aprendizado são os seguintes:
+ Saiba como usar a SageMaker IA para acelerar o treinamento do modelo de ML e melhorar a qualidade do modelo.
+ Entenda como gerenciar as iterações de treinamento com o SageMaker Experiments capturando automaticamente os parâmetros de entrada, as configurações e os resultados.
+ Descubra como o Debugger torna o processo de treinamento transparente capturando automaticamente dados de tensores em tempo real a partir de métricas como pesos, gradientes e saídas de ativação de redes neurais convolucionais.
+ Use CloudWatch para acionar o Lambda quando o Debugger detecta problemas.
+ Domine o processo SageMaker de treinamento usando o SageMaker Experiments and Debugger.
Você pode encontrar os cadernos e scripts de treinamento usados neste vídeo do [SageMaker Debugger PyTorch ](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_iterative_model_pruning) Iterative Model Pruning.
A imagem a seguir mostra como o processo de remoção iterativa do AlexNet modelo reduz o tamanho ao cortar os 100 filtros menos significativos com base na classificação de importância avaliada pelas saídas de ativação e gradientes.
O processo de redução diminuiu os 50 milhões de parâmetros iniciais para 18 milhões. Também reduziu o tamanho estimado do modelo de 201 MB para 73 MB.
![\[Uma imagem contendo visualizações de saída de resultados de redução de modelo\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-model-pruning-results-alexnet.gif)
Você também precisa monitorar a precisão do modelo, e a imagem a seguir mostra como você pode traçar o processo de poda do modelo para visualizar as alterações na precisão do modelo com base no número de parâmetros no SageMaker Studio.
![\[Uma imagem da visualização do tensor usando o Debugger no Studio SageMaker\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-model-pruning-studio.png)
**No SageMaker Studio, escolha a guia **Experimentos**, selecione uma lista de tensores salvos pelo Debugger no processo de poda e, em seguida, crie um painel Lista de componentes de teste.** Selecione todas as 10 iterações e escolha **Adicionar gráfico** para criar um **Gráfico de componentes de teste**. Depois de decidir sobre um modelo a ser implantado, escolha o componente de teste e escolha um menu para realizar uma ação ou escolha **Implantar modelo**.
**nota**
Para implantar um modelo por meio do SageMaker Studio usando o exemplo de notebook a seguir, adicione uma linha no final da `train` função no `train.py` script.
```
# In the train.py script, look for the train function in line 58.
def train(epochs, batch_size, learning_rate):
...
print('acc:{:.4f}'.format(correct/total))
hook.save_scalar("accuracy", correct/total, sm_metric=True)
# Add the following code to line 128 of the train.py script to save the pruned models
# under the current SageMaker Studio model directory
torch.save(model.state_dict(), os.environ['SM_MODEL_DIR'] + '/model.pt')
```
## [Usando o SageMaker Debugger para monitorar um treinamento de modelo de autoencoder convolucional](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/autoencoder_mnist/autoencoder_mnist.html)
Este caderno demonstra como o SageMaker Debugger visualiza tensores de um processo de aprendizado não supervisionado (ou autosupervisionado) em um conjunto de dados de imagens MNIST de números manuscritos.
O modelo de treinamento neste notebook é um codificador automático convolucional com a estrutura. MXNet O codificador automático convolucional tem uma rede neural convolucional em forma de gargalo que consiste em uma parte codificadora e uma parte decodificadora.
O codificador neste exemplo tem duas camadas de convolução para produzir uma representação compactada (variáveis latentes) das imagens de entrada. Neste caso, o codificador produz uma variável latente de tamanho (1, 20) a partir de uma imagem de entrada original de tamanho (28, 28) e reduz significativamente o tamanho dos dados para treinamento em 40 vezes.
O decodificador tem duas camadas *desconvolucionais* e garante que as variáveis latentes preservem informações importantes reconstruindo imagens de saída.
O codificador convolucional alimenta algoritmos de agrupamento com tamanho menor de dados de entrada e o desempenho de algoritmos de agrupamento, como k-means, K-NN e t-Distributed Stochastic Neighbor Embedding (t-SNE).
Este exemplo de caderno demonstra como visualizar as variáveis latentes usando o Debugger, como mostrado na animação a seguir. Ele também demonstra como o algoritmo t-SNE classifica as variáveis latentes em 10 clusters e as projeta em um espaço bidimensional. O esquema de cores do gráfico de dispersão no lado direito da imagem reflete os valores verdadeiros para mostrar a eficiência com que o modelo BERT e o algoritmo t-SNE organizam as variáveis latentes nos clusters.
![\[Uma imagem conceitual do codificador automático convolucional\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-cnn-autoencoder-plot.gif)
## [Usando o SageMaker Debugger para monitorar as atenções no treinamento do modelo BERT](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/bert_attention_head_view/bert_attention_head_view.html)
Bidirectional Encode Representations from Transformers (BERT) é um modelo de representação de linguagem. Como reflete o nome do modelo, o modelo BERT baseia-se na *aprendizado de transferência* e no *modelo tipo transformador* para processamento de linguagem natural (PLN).
O modelo BERT é pré-treinado em tarefas não supervisionadas, como prever palavras ausentes em uma frase ou prever a próxima frase que naturalmente segue uma frase anterior. Os dados de treinamento contêm 3,3 bilhões de palavras (tokens) de texto em inglês, de fontes como Wikipédia e livros eletrônicos. Para obter um exemplo simples, o modelo BERT pode dar uma grande *atenção* aos tokens de verbo apropriados ou tokens de pronome de um token de assunto.
O modelo BERT pré-treinado pode ser ajustado com uma camada de saída adicional para obter treinamento de state-of-the-art modelo em tarefas de PNL, como respostas automatizadas a perguntas, classificação de texto e muitas outras.
O Debugger coleta tensores do processo de ajuste fino. No contexto do PLN, o peso dos neurônios chama *atenção*.
Este caderno demonstra como usar o [modelo BERT pré-treinado do zoológico modelo GluonNLP](https://gluon-nlp.mxnet.io/model_zoo/bert/index.html) no conjunto de dados de perguntas e respostas de Stanford e como configurar o Debugger para monitorar o trabalho de treinamento. SageMaker
Traçar *pontuações de atenção* e neurônios individuais na consulta e vetores chave pode ajudar a identificar causas de predições incorretas do modelo. Com o SageMaker AI Debugger, você pode recuperar os tensores e traçar a *visão da cabeça de atenção* em tempo real à medida que o treinamento avança e entender o que o modelo está aprendendo.
A animação a seguir mostra as pontuações de atenção dos primeiros 20 tokens de entrada para 10 iterações no trabalho de treinamento fornecido no exemplo do caderno.
![\[Uma animação das pontuações de atenção\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-attention_scores.gif)
## [Usando o SageMaker Debugger para visualizar mapas de ativação de classes em redes neurais convolucionais () CNNs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/cnn_class_activation_maps/cnn_class_activation_maps.html)
Este notebook demonstra como usar o SageMaker Debugger para traçar mapas de ativação de classes para detecção e classificação de imagens em redes neurais convolucionais (). CNNs No aprendizado profundo, uma *rede neural convolucional (CNN ou ConvNet)* é uma classe de redes neurais profundas, mais comumente aplicada à análise de imagens visuais. Uma das aplicações que adota os mapas de ativação de classe é o caso dos veículos autônomos, que exigem detecção instantânea e classificação de imagens, como sinais de trânsito, estradas e obstáculos.
Neste notebook, o PyTorch ResNet modelo é treinado [no conjunto de dados alemão de sinais de trânsito](http://benchmark.ini.rub.de/), que contém mais de 40 classes de objetos relacionados ao trânsito e mais de 50.000 imagens no total.
![\[Uma animação de mapas de ativação da classe CNN\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-cnn-class-activation-maps.gif)
Durante o processo de treinamento, o SageMaker Debugger coleta tensores para traçar os mapas de ativação da classe em tempo real. Como mostrado na imagem animada, o mapa de ativação de classe (também chamado de *mapa de saliência*) destaca regiões com alta ativação na cor vermelha.
Ao usar os tensores capturados pelo Debugger, você pode visualizar como o mapa de ativação evolui durante o treinamento do modelo. O modelo começa detectando a borda no canto inferior esquerdo no início do trabalho de treinamento. À medida que o treinamento progride, o foco muda para o centro e detecta o sinal de limite de velocidade, e o modelo prevê com êxito a imagem de entrada como Classe 3, que é uma classe de sinais de limite de velocidade de 60 km/h, com um nível de confiança de 97%.
# Depuração de trabalhos de treinamento usando o Amazon Debugger SageMaker
Para preparar seu script de treinamento e executar trabalhos de treinamento com o SageMaker Debugger para depurar o progresso do treinamento do modelo, você segue o processo típico de duas etapas: modifique seu script de treinamento usando o SDK do Python e construa um estimador de IA usando o SDK do `sagemaker-debugger` Python. SageMaker SageMaker Leia os tópicos a seguir para saber como usar a funcionalidade de depuração do SageMaker Debugger.
**Topics**
+ [Adaptação do seu script de treinamento para registrar um hook](debugger-modify-script.md)
+ [Inicie trabalhos de treinamento com o Debugger usando o SDK do Python SageMaker](debugger-configuration-for-debugging.md)
+ [SageMaker Relatório interativo do depurador para XGBoost](debugger-report-xgboost.md)
+ [Ação sobre as regras do Amazon SageMaker Debugger](debugger-action-on-rules.md)
+ [Visualize os tensores de saída do Amazon SageMaker Debugger em TensorBoard](debugger-enable-tensorboard-summaries.md)
# 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).
# Inicie trabalhos de treinamento com o Debugger usando o SDK do Python SageMaker
Para configurar um estimador de SageMaker IA com o SageMaker Debugger, use o [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) SDK e especifique os parâmetros específicos do Debugger. Para utilizar totalmente a funcionalidade de depuração, há três parâmetros que você precisa configurar:`debugger_hook_config`, `tensorboard_output_config` e `rules`.
**Importante**
Antes de criar e executar o método de ajuste do estimador para iniciar um trabalho de treinamento, certifique-se de adaptar seu script de treinamento seguindo as instruções em [Adaptação do seu script de treinamento para registrar um hook](debugger-modify-script.md).
## Construindo um estimador de SageMaker IA com parâmetros específicos do Debugger
Os exemplos de código nesta seção mostram como criar um estimador de SageMaker IA com os parâmetros específicos do Debugger.
**nota**
Os exemplos de código a seguir são modelos para construir os estimadores da estrutura de SageMaker IA e não são diretamente executáveis. Você precisa prosseguir para as próximas seções e configurar os parâmetros específicos do Debugger.
------
#### [ 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 os seguintes parâmetros para ativar o SageMaker Debugger:
+ `debugger_hook_config`(um 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)) — Necessário para ativar o gancho no script de treinamento adaptado durante[Adaptação do seu script de treinamento para registrar um hook](debugger-modify-script.md), configurar o iniciador de SageMaker treinamento (estimador) para coletar tensores de saída de seu trabalho de treinamento e salvar os tensores em seu bucket S3 protegido ou em sua máquina local. Para saber como configurar o parâmetro `debugger_hook_config`, consulte [Configurando o SageMaker Debugger para salvar tensores](debugger-configure-hook.md).
+ `rules`(uma 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 esse parâmetro para ativar as regras internas do SageMaker Debugger que você deseja executar em tempo real. As regras integradas são lógicas que depuram automaticamente o progresso do treinamento do seu modelo e encontram problemas de treinamento analisando os tensores de saída salvos em seu bucket seguro do S3. Para saber como configurar o parâmetro `rules`, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md). Para encontrar uma lista completa de regras integradas para depuração de tensores de saída, consulte [Regra do Depurador](debugger-built-in-rules.md#debugger-built-in-rules-Rule). Se você quiser criar sua própria lógica para detectar problemas de treinamento, consulte [Criação de regras personalizadas usando a biblioteca de cliente do Depurador](debugger-custom-rules.md).
**nota**
As regras integradas estão disponíveis somente por meio de instâncias SageMaker de treinamento. Você não pode usá-los no modo local.
+ `tensorboard_output_config`(um 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 o SageMaker Debugger para coletar tensores de saída no formato TensorBoard compatível e salvar no caminho de saída do S3 especificado no objeto. `TensorBoardOutputConfig` Para saber mais, consulte [Visualize os tensores de saída do Amazon SageMaker Debugger em TensorBoard](debugger-enable-tensorboard-summaries.md).
**nota**
O `tensorboard_output_config` deve ser configurado com o `debugger_hook_config` parâmetro, o que também exige que você adapte seu script de treinamento adicionando o hook `sagemaker-debugger`.
**nota**
SageMaker O depurador salva com segurança os tensores de saída em subpastas do seu bucket do S3. Por exemplo, o formato do URI padrão do bucket do S3 em sua conta é `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>///`. Há duas subpastas criadas pelo SageMaker Debugger: e. `debug-output` `rule-output` Se você adicionar o `tensorboard_output_config` parâmetro, também encontrará a pasta `tensorboard-output`.
Consulte os tópicos a seguir para encontrar mais exemplos de como configurar os parâmetros específicos do Debugger em detalhes.
**Topics**
+ [Construindo um estimador de SageMaker IA com parâmetros específicos do Debugger](#debugger-configuration-structure)
+ [Configurando o SageMaker Debugger para salvar tensores](debugger-configure-hook.md)
+ [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md)
+ [Desativar o Debugger](debugger-turn-off.md)
+ [Métodos úteis de classes de estimadores de SageMaker IA para o Debugger](debugger-estimator-classmethods.md)
# Configurando o SageMaker Debugger para salvar tensores
Os *tensores* são coleções de dados de parâmetros atualizados da passagem para trás e para frente de cada iteração de treinamento. SageMaker O Debugger coleta os tensores de saída para analisar o estado de um trabalho de treinamento. SageMaker As operações do 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)e da [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 fornecem métodos para agrupar tensores em *coleções* e salvá-los em um bucket S3 de destino. Os tópicos a seguir mostram como usar as operações da API `CollectionConfig` e `DebuggerHookConfig`, seguidos por exemplos de como usar o hook do Depurador para salvar, acessar e visualizar tensores de saída.
Ao criar um estimador de SageMaker IA, ative o SageMaker Debugger especificando o parâmetro. `debugger_hook_config` As etapas a seguir incluem exemplos de como configurar `debugger_hook_config` usando as operações da API `CollectionConfig` e `DebuggerHookConfig` para retirar tensores de seus trabalhos de treinamento e salvá-los.
**nota**
Depois de configurado e ativado adequadamente, o SageMaker Debugger salva os tensores de saída em um bucket S3 padrão, a menos que especificado de outra forma. O formato do URI padrão do bucket do S3 é `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>//debug-output/`.
**Topics**
+ [Configurar coleções de tensores usando a API `CollectionConfig`](debugger-configure-tensor-collections.md)
+ [Configurar a API `DebuggerHookConfig` para salvar tensores](debugger-configure-tensor-hook.md)
+ [Exemplos de Cadernos e exemplos de código para configurar o Debugger Hook](debugger-save-tensors.md)
# Configurar coleções de tensores usando a API `CollectionConfig`
Use a operação `CollectionConfig` da API para configurar coleções de tensores. O Debugger fornece coleções de tensores pré-criadas que abrangem uma variedade de expressões regulares (regex) de parâmetros se estiver usando estruturas de aprendizado profundo e algoritmos de machine learning compatíveis com o Debugger. Conforme mostrado no código de exemplo a seguir, adicione as coleções de tensores integradas que você deseja depurar.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(name="weights"),
CollectionConfig(name="gradients")
]
```
As coleções anteriores configuraram o hook Debugger para salvar os tensores a cada 500 etapas com base no valor padrão `"save_interval"`.
Para obter uma lista completa das coleções integradas do Debugger disponíveis, consulte [Coleções integradas do Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#collection).
Se quiser personalizar as coleções integradas, como alterar os intervalos de salvamento e o regex do tensor, use o modelo `CollectionConfig` a seguir para ajustar os 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 obter mais informações sobre as chaves de parâmetros disponíveis, consulte o [CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)SDK do [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Por exemplo, o seguinte exemplo de código mostra como você pode ajustar os intervalos de salvamento da coleção de tensores de “perdas” em diferentes fases do treinamento: perda de salvamento a cada 100 etapas na fase de treinamento e perda de validação a cada 10 etapas na fase de validação.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
```
**dica**
Esse objeto de configuração da coleção de tensores pode ser usado tanto para operações da [Rule](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-rules.html#debugger-built-in-rules-configuration-param-change) API [DebuggerHookConfig](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-hook.html#debugger-configure-tensor-hook)quanto para operações.
# Configurar a API `DebuggerHookConfig` para salvar tensores
Use a [DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html #sagemaker.debugger.DebuggerHookConfig)API para criar um `debugger_hook_config` objeto usando o `collection_configs` objeto que você criou na etapa anterior.
```
from sagemaker.debugger import DebuggerHookConfig
debugger_hook_config=DebuggerHookConfig(
collection_configs=collection_configs
)
```
O Debugger salva os tensores de saída de treinamento do modelo no bucket S3 padrão. O formato do URI padrão do bucket do S3 é `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>//debug-output/.`
Se você quiser especificar um URI exato do bucket do S3, use o seguinte exemplo de código:
```
from sagemaker.debugger import DebuggerHookConfig
debugger_hook_config=DebuggerHookConfig(
s3_output_path="specify-uri"
collection_configs=collection_configs
)
```
Para obter mais informações, consulte o [DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)SDK do [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Exemplos de Cadernos e exemplos de código para configurar o Debugger Hook
As seções a seguir fornecem cadernos e exemplos de código de como usar o hook do Debugger para salvar, acessar e visualizar tensores de saída.
**Topics**
+ [Cadernos de exemplo da visualização do tensor](#debugger-tensor-visualization-notebooks)
+ [Salvar tensores usando coleções integradas do Depurador](#debugger-save-built-in-collections)
+ [Salvar tensores usando coleções integradas modificadas do Depurador](#debugger-save-modified-built-in-collections)
+ [Salvar tensores usando as coleções personalizadas do Depurador](#debugger-save-custom-collections)
## Cadernos de exemplo da visualização do tensor
Os dois exemplos de notebooks a seguir mostram o uso avançado do Amazon SageMaker Debugger para visualizar tensores. O Debugger fornece uma visão transparente do treinamento de modelos de aprendizado profundo.
+ [Análise interativa de tensores no SageMaker Studio Notebook com MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_analysis)
Este exemplo de notebook mostra como visualizar tensores salvos usando o Amazon SageMaker Debugger. Com a visualização dos tensores, você pode ver como os valores dos tensores mudam ao treinar algoritmos de aprendizado profundo. Esse notebook inclui um trabalho de treinamento com uma rede neural mal configurada e usa o Amazon SageMaker Debugger para agregar e analisar tensores, incluindo gradientes, saídas de ativação e pesos. Por exemplo, o gráfico a seguir mostra a distribuição de gradientes de uma camada convolucional que está sofrendo de um problema de desaparecimento de gradiente.
![\[Um gráfico que delineia a distribuição dos gradientes.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-vanishing-gradient.gif)
Esse caderno também ilustra como uma boa configuração inicial de hiperparâmetros aprimora o processo de treinamento gerando os mesmos gráficos de distribuição de tensores.
+ [Visualizando e depurando tensores a partir do treinamento de modelos MXNet ](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_plot)
Este exemplo de caderno mostra como salvar e visualizar tensores de um trabalho de treinamento do modelo MXNet Gluon usando o Amazon Debugger. SageMaker Isso ilustra que o Debugger está configurado para salvar todos os tensores em um bucket do Amazon S3 e recuperar as saídas de ativação para a visualização. ReLu A figura a seguir mostra uma visualização tridimensional das saídas de ReLu ativação. O esquema de cores está definido como azul para indicar valores próximos a 0 e amarelo para indicar valores próximos a 1.
![\[Uma visualização das saídas de ativação ReLU\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/tensorplot.gif)
Neste notebook, a `TensorPlot` classe importada do foi `tensor_plot.py` projetada para traçar redes neurais convolucionais (CNNs) que usam imagens bidimensionais como entradas. O script `tensor_plot.py` fornecido com o caderno recupera os tensores usando o Debugger e visualiza a CNN. Você pode executar esse notebook no SageMaker Studio para reproduzir a visualização do tensor e implementar seu próprio modelo de rede neural convolucional.
+ [Análise de tensores em tempo real em um SageMaker notebook com MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_realtime_analysis)
Este exemplo orienta você na instalação dos componentes necessários para a emissão de tensores em um trabalho de SageMaker treinamento da Amazon e no uso das operações da API Debugger para acessar esses tensores durante a execução do treinamento. Um modelo CNN de glúon é treinado no conjunto de dados Fashion MNIST. Enquanto a tarefa estiver em execução, você verá como o Debugger recupera as saídas de ativação da primeira camada convolucional de cada um dos 100 lotes e as visualiza. Além disso, isso mostrará como visualizar os pesos após a conclusão do trabalho.
## Salvar tensores usando coleções integradas do Depurador
Você pode usar coleções integradas de tensores usando a API `CollectionConfig` e salvá-las usando a API `DebuggerHookConfig`. O exemplo a seguir mostra como usar as configurações padrão das configurações do gancho do Debugger para criar um estimador de IA. SageMaker TensorFlow Você também pode utilizar isso para MXNet PyTorch, e XGBoost estimadores.
**nota**
No código de exemplo a seguir, o parâmetro `s3_output_path` para `DebuggerHookConfig` é opcional. Se você não especificar, o Debugger salvará os tensores`s3:///debug-output/`, onde `` é o caminho de saída padrão dos trabalhos de treinamento. SageMaker Por exemplo:
```
"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 uma lista de coleções integradas do Debugger, consulte [Coleções internas do Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#collection).
## Salvar tensores usando coleções integradas modificadas do Depurador
Você pode modificar as coleções integradas do Debugger usando a operação da API `CollectionConfig`. O exemplo a seguir mostra como ajustar a `losses` coleção integrada e construir um TensorFlow estimador de SageMaker IA. Você também pode usar isso para MXNet PyTorch, e XGBoost estimadores.
```
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 ver uma lista completa dos `CollectionConfig` parâmetros, consulte [Debugger API CollectionConfig ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
## Salvar tensores usando as coleções personalizadas do Depurador
Também é possível salvar um número reduzido de tensores em vez do conjunto completo de tensores, (por exemplo, se quiser reduzir a quantidade de dados salvos no bucket do Amazon S3). O exemplo a seguir mostra como personalizar a configuração de hook do Debugger para especificar os tensores de destino que você deseja salvar. Você pode usar isso para TensorFlow, MXNet PyTorch, e 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 obter uma lista completa dos `CollectionConfig` parâmetros, consulte [Debugger CollectionConfig](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
# Configurar regras integradas do Depurador
Nos tópicos a seguir, você aprenderá a usar as regras integradas do SageMaker Debugger. As regras integradas do Amazon SageMaker Debugger analisam os tensores emitidos durante o treinamento de um modelo. SageMaker O AI Debugger oferece a operação de `Rule` API que monitora o progresso e os erros do trabalho de treinamento para garantir o sucesso do treinamento de seu modelo. Por exemplo, as regras podem detectar se os gradientes estão ficando muito grandes ou muito pequenos, se um modelo está se ajustando demais ou treinando demais, e se um trabalho de treinamento não diminui a função de perda e melhora. Para ver uma listagem completa de regras integradas disponíveis, consulte [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
**Topics**
+ [Use as regras integradas do depurador com suas configurações de parâmetros padrão](debugger-built-in-rules-configuration.md)
+ [Use as regras integradas do depurador com valores de parâmetros personalizados](debugger-built-in-rules-configuration-param-change.md)
+ [Exemplos de Cadernos e exemplos de código para configurar as regras do Depurador](debugger-built-in-rules-example.md)
# Use as regras integradas do depurador com suas configurações de parâmetros padrão
Para especificar as regras integradas do depurador em seu estimador, você precisa configurar um objeto listado. O código de exemplo a seguir mostra a estrutura básica da listagem das regras integradas do 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 obter mais informações sobre valores de parâmetros padrão e descrições da regra integrada, consulte [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
Para encontrar a referência da API SageMaker Debugger, consulte e. [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)
Por exemplo, para inspecionar o desempenho geral do treinamento e o progresso do seu modelo, crie um estimador de SageMaker IA com a seguinte configuração de regras incorporada.
```
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())
]
```
Quando você inicia o trabalho de treinamento, o Debugger coleta dados de utilização de recursos do sistema a cada 500 milissegundos e os valores de perda e precisão a cada 500 etapas, por padrão. O depurador analisa a utilização de recursos para identificar se seu modelo está com problemas de gargalo. O `loss_not_decreasing`, `overfit`, `overtraining` e `stalled_training_rule` monitoram se seu modelo está otimizando a função de perda sem esses problemas de treinamento. Se as regras detectarem anomalias de treinamento, o status da avaliação da regra será alterado para `IssueFound`. Você pode configurar ações automatizadas, como notificar problemas de treinamento e interromper trabalhos de treinamento usando Amazon CloudWatch Events e. AWS Lambda Para obter mais informações, consulte [Ação sobre as regras do Amazon SageMaker Debugger](debugger-action-on-rules.md).
# Use as regras integradas do depurador com valores de parâmetros personalizados
Se você quiser ajustar os valores de parâmetros da regra integrada e personalizar o regex da coleção de tensores, configure os parâmetros `base_config` e `rule_parameters` para os métodos das classes `ProfilerRule.sagemaker` e `Rule.sagemaker`. No caso dos métodos de classe `Rule.sagemaker`, você também pode personalizar coleções de tensores por meio do parâmetro `collections_to_save`. As instruções de como usar a classe `CollectionConfig` são fornecidas em [Configurar coleções de tensores usando a API `CollectionConfig`](debugger-configure-tensor-collections.md).
Use o modelo de configuração a seguir para regras integradas para personalizar os valores dos parâmetros. Ao alterar os parâmetros da regra conforme desejar, você pode ajustar a sensibilidade das regras a serem acionadas.
+ O argumento `base_config` é onde você chama os métodos de regras integradas.
+ O argumento `rule_parameters` serve para ajustar os valores de chave padrão das regras integradas listadas em [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
+ O argumento `collections_to_save` recebe uma configuração de tensor por meio da API `CollectionConfig`, que requer argumentos `name` e `parameters`.
+ Para encontrar coleções de tensores disponíveis para `name`, consulte as [Coleções de Tensores Integrados do Depurador](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections).
+ Para ver uma lista completa de opções ajustáveis`parameters`, consulte [Debugger API CollectionConfig ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
[Para obter mais informações sobre a classe de regras, os métodos e os parâmetros do Debugger, consulte a classe de regra do [SageMaker AI Debugger no SDK do Amazon](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html) Python. SageMaker ](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"
}
)
]
)
]
```
As descrições dos parâmetros e os exemplos de personalização de valores são fornecidos para cada regra em [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
# Exemplos de Cadernos e exemplos de código para configurar as regras do Depurador
Nas seções a seguir, blocos de notas e exemplos de código de como usar as regras do Debugger para monitorar trabalhos de SageMaker treinamento são fornecidos.
**Topics**
+ [Cadernos de exemplo de regras integradas do Depurador](#debugger-built-in-rules-notebook-example)
+ [Código de exemplo de regras integradas do Depurador](#debugger-deploy-built-in-rules)
+ [Use regras integradas do Depurador com modificações de parâmetros](#debugger-deploy-modified-built-in-rules)
## Cadernos de exemplo de regras integradas do Depurador
Os exemplos de cadernos a seguir mostram como usar as regras integradas do Debugger ao executar trabalhos de treinamento com a Amazon AI: SageMaker
+ [Usando uma regra integrada SageMaker do Debugger com TensorFlow](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_builtin_rule)
+ [Usando uma regra integrada SageMaker do Debugger com o Managed Spot Training e MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_spot_training)
+ [Usando uma regra integrada do SageMaker Debugger com modificações de parâmetros para uma análise do trabalho de treinamento em tempo real com XGBoost](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/xgboost_realtime_analysis)
Ao executar os notebooks de exemplo no SageMaker Studio, você pode encontrar o teste de trabalho de treinamento criado na guia **Studio Experiment List**. Por exemplo, conforme mostrado na captura de tela a seguir, você pode encontrar e abrir uma janela **Descrever o Componente de Teste** do seu trabalho de treinamento atual. Na guia Depurador, você pode verificar se as regras do Depurador `vanishing_gradient()` e `loss_not_decreasing()` estão monitorando a sessão de treinamento em paralelo. Para obter instruções completas sobre como encontrar seus componentes de teste de emprego de treinamento na interface do usuário do Studio, consulte [SageMaker Studio - View Experiments, Trials and Trial Components](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-tasks.html#studio-tasks-experiments).
![\[Uma imagem da execução de um trabalho de treinamento com as regras integradas do Debugger ativadas no Studio SageMaker\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-built-in-rule-studio.png)
Há duas maneiras de usar as regras integradas do Debugger no ambiente de SageMaker IA: implantar as regras integradas conforme elas são preparadas ou ajustar seus parâmetros conforme desejar. Os tópicos a seguir mostram como usar as regras integradas com códigos de exemplo.
## Código de exemplo de regras integradas do Depurador
O exemplo de código a seguir mostra como configurar as regras integradas do Depurador usando o método `Rule.sagemaker`. Para especificar as regras integradas que você deseja executar, use a operação `rules_configs` da API para chamar as regras integradas. Para encontrar uma listagem completa das regras integradas do Depurador e dos valores de parâmetros padrão, consulte [Lista de regras integradas do 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**
As regras integradas do Depurador são executadas em paralelo ao seu trabalho de treinamento. O número máximo de contêineres de regras integradas para um trabalho de treinamento é 20.
[Para obter mais informações sobre a classe de regras, os métodos e os parâmetros do Debugger, consulte a classe [SageMaker Debugger Rule no SDK do](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html) Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
Para encontrar um exemplo de como ajustar os parâmetros da regra do Depurador, consulte a seção [Use regras integradas do Depurador com modificações de parâmetros](#debugger-deploy-modified-built-in-rules) a seguir.
## Use regras integradas do Depurador com modificações de parâmetros
O exemplo de código a seguir mostra a estrutura das regras integradas para ajustar os parâmetros. Neste exemplo, o `stalled_training_rule` coleta a coleção `losses` de tensores de um trabalho de treinamento a cada 50 etapas e um estágio de avaliação a cada 10 etapas. Se o processo de treinamento se iniciar parado e não coletar as saídas do tensor por 120 segundos, o `stalled_training_rule` interrompe o trabalho de treinamento.
```
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 uma configuração avançada das regras integradas do Depurador usando a API `CreateTrainingJob`, consulte [Configurar o Debugger usando a API SageMaker](debugger-createtrainingjob-api.md).
# Desativar o Debugger
Se quiser desativar completamente o Debugger, execute uma das seguintes ações:
+ Antes de iniciar um trabalho de treinamento, faça o seguinte:
Para interromper o monitoramento e a criação de perfil, inclua o parâmetro `disable_profiler` em seu estimador e defina-o como `True`.
**Atenção**
Se você desativá-lo, não poderá visualizar o painel abrangente de insights do Studio Debugger e o relatório de criação de perfil gerado automaticamente.
Para interromper a depuração, defina o parâmetro `debugger_hook_config` como `False`.
**Atenção**
Se desativá-lo, você não poderá coletar os tensores de saída e não poderá depurar os parâmetros do seu modelo.
```
estimator=Estimator(
...
disable_profiler=True
debugger_hook_config=False
)
```
[Para obter mais informações sobre os parâmetros específicos do Debugger, consulte AI [SageMaker Estimator no](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator) SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
+ Enquanto um trabalho de treinamento estiver em execução, faça o seguinte:
Para desativar o monitoramento e a criação de perfil durante a execução do trabalho de treinamento, use o seguinte método de classe estimador:
```
estimator.disable_profiling()
```
Para desativar somente a criação de perfil da framework e manter o monitoramento do sistema, use o método `update_profiler`:
```
estimator.update_profiler(disable_framework_metrics=true)
```
[Para obter mais informações sobre os métodos de extensão do estimador, consulte os métodos de classe [estimator.disable\$1profiling e [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) na documentação do SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# Métodos úteis de classes de estimadores de SageMaker IA para o Debugger
Os métodos da classe estimadora a seguir são úteis para acessar as informações do seu trabalho de SageMaker treinamento e recuperar os caminhos de saída dos dados de treinamento coletados pelo Debugger. Os métodos a seguir são executáveis depois que você inicia um trabalho de treinamento com o método `estimator.fit()`.
+ Para verificar o URI básico do bucket S3 de um trabalho de SageMaker treinamento:
```
estimator.output_path
```
+ Para verificar o nome do trabalho base de um trabalho de SageMaker treinamento:
```
estimator.latest_training_job.job_name
```
+ Para ver uma configuração completa `CreateTrainingJob` da operação de API de um trabalho de SageMaker treinamento:
```
estimator.latest_training_job.describe()
```
+ Para verificar uma lista completa das regras do Debugger durante a execução de um trabalho SageMaker de treinamento:
```
estimator.latest_training_job.rule_job_summary()
```
+ Para verificar o URI do bucket do S3 em que os dados dos parâmetros do modelo (tensores de saída) são salvos:
```
estimator.latest_job_debugger_artifacts_path()
```
+ Para verificar o URI do bucket do S3 em que os dados de desempenho do modelo (métricas do sistema e da estrutura) são salvos:
```
estimator.latest_job_profiler_artifacts_path()
```
+ Para verificar a configuração da regra do Debugger para depurar tensores de saída:
```
estimator.debugger_rule_configs
```
+ Para verificar a lista das regras do Debugger para depuração durante a execução de um trabalho de treinamento: SageMaker
```
estimator.debugger_rules
```
+ Para verificar a configuração da regra do Debugger para monitorar e definir o perfil das métricas do sistema e da estrutura:
```
estimator.profiler_rule_configs
```
+ Para verificar a lista das regras do Debugger para monitoramento e criação de perfil durante a execução de um trabalho de SageMaker treinamento:
```
estimator.profiler_rules
```
[Para obter mais informações sobre a classe de estimador de SageMaker IA e seus métodos, consulte a API [Estimator no](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator) SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# SageMaker Relatório interativo do depurador para XGBoost
Receba relatórios de treinamento gerados automaticamente pelo Debugger. Os relatórios do Debugger fornecem informações sobre seus trabalhos de treinamento e sugerem recomendações para melhorar o desempenho do seu modelo. Para trabalhos de XGBoost treinamento de SageMaker IA, use a [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) regra Debugger para receber um relatório de treinamento abrangente sobre o progresso e os resultados do treinamento. Seguindo este guia, especifique a [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) regra ao criar um XGBoost estimador, baixe o relatório usando o Amazon [ SageMaker Python SDK ou](https://sagemaker.readthedocs.io/en/stable) o console do Amazon S3 e obtenha informações sobre os resultados do treinamento.
**nota**
Você pode baixar os relatórios do Debugger enquanto seu trabalho de treinamento está em execução ou após a conclusão do trabalho. Durante o treinamento, o Debugger atualiza simultaneamente o relatório, refletindo o status de avaliação das regras atuais. Você só pode baixar um relatório completo do Debugger após a conclusão do trabalho de treinamento.
**Importante**
No relatório, os gráficos e as recomendações são fornecidos para fins informativos e não são definitivos. Você é responsável por fazer sua própria avaliação independente das informações.
**Topics**
+ [Crie um XGBoost estimador de SageMaker IA com a regra XGBoost Debugger Report](debugger-training-xgboost-report-estimator.md)
+ [Baixe o relatório de treinamento do Debugger XGBoost](debugger-training-xgboost-report-download.md)
+ [Passo a passo do relatório de treinamento do Debugger XGBoost](debugger-training-xgboost-report-walkthrough.md)
# Crie um XGBoost estimador de SageMaker IA com a regra XGBoost Debugger Report
A regra [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) coleta os seguintes tensores de saída do seu trabalho de treinamento:
+ `hyperparameters`: Salva na primeira etapa.
+ `metrics`: Economiza perdas e precisão a cada 5 etapas.
+ `feature_importance`: Salva a cada 5 etapas.
+ `predictions`: Salva a cada 5 etapas.
+ `labels`: Salva a cada 5 etapas.
Os tensores de saída são salvos em um bucket S3 padrão. Por exemplo, .`s3://sagemaker--<12digit_account_id>//debug-output/`
Ao criar um estimador de SageMaker IA para um trabalho de XGBoost treinamento, especifique a regra conforme mostrado no código de exemplo a seguir.
------
#### [ Using the SageMaker AI generic estimator ]
```
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.create_xgboost_report())
]
region = boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.2-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-xgboost-report-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Add the Debugger XGBoost report rule
rules=rules
)
estimator.fit(wait=False)
```
------
# Baixe o relatório de treinamento do Debugger XGBoost
Faça o download do relatório de XGBoost treinamento do Debugger enquanto seu trabalho de treinamento estiver em execução ou após a conclusão do trabalho usando o [ SageMaker SDK e (CLI) do Amazon Python](https://sagemaker.readthedocs.io/en/stable). AWS Command Line Interface
------
#### [ Download using the SageMaker Python SDK and AWS CLI ]
1. Verifique o URI base de saída S3 padrão do trabalho atual.
```
estimator.output_path
```
1. Verifique o nome do trabalho atual.
```
estimator.latest_training_job.job_name
```
1. O XGBoost relatório do Debugger é armazenado em. `//rule-output` Configure o caminho de saída da regra da seguinte forma:
```
rule_output_path = estimator.output_path + "/" + estimator.latest_training_job.job_name + "/rule-output"
```
1. Para verificar se o relatório foi gerado, liste os diretórios e arquivos recursivamente em `rule_output_path` usando `aws s3 ls` com a opção `--recursive`.
```
! aws s3 ls {rule_output_path} --recursive
```
Isso deve retornar uma lista completa de arquivos em pastas geradas automaticamente denominadas `CreateXgboostReport` e `ProfilerReport-1234567890`. O relatório de XGBoost treinamento é armazenado no`CreateXgboostReport`, e o relatório de criação de perfil é armazenado na `ProfilerReport-1234567890` pasta. Para saber mais sobre o relatório de criação de perfil gerado por padrão com o trabalho XGBoost de treinamento, consulte[SageMaker Relatório interativo do Debugger](debugger-profiling-report.md).
![\[Um exemplo de saída de regra.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-ls.png)
`xgboost_report.html`É um relatório de XGBoost treinamento gerado automaticamente pelo Debugger. O `xgboost_report.ipynb` é um caderno Jupyter usado para agregar resultados de treinamento ao relatório. Você pode baixar todos os arquivos, navegar pelo arquivo de relatório HTML e modificar o relatório usando o caderno.
1. Faça download dos arquivos recursivamente usando o `aws s3 cp`. O comando a seguir salva todos os arquivos de saída da regra na pasta `ProfilerReport-1234567890` sob o diretório de trabalho atual.
```
! aws s3 cp {rule_output_path} ./ --recursive
```
**dica**
Se você estiver usando um servidor do caderno Jupyter, execute `!pwd` para verificar o diretório de trabalho atual.
1. Abaixo do diretório`/CreateXgboostReport`, abra `xgboost_report.html`. Se você estiver usando JupyterLab, escolha **Trust HTML** para ver o relatório de treinamento do Debugger gerado automaticamente.
![\[Um exemplo de saída de regra.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-open-trust.png)
1. Abra o arquivo `xgboost_report.ipynb` para explorar como o relatório é gerado. Você pode personalizar e estender o relatório de treinamento usando o arquivo do caderno Jupyter.
------
#### [ Download using the Amazon S3 console ]
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Procure o bucket base do S3. Por exemplo, se você não especificou o nome de trabalho básico, o nome básico do bucket do S3 deve estar no seguinte formato:`sagemaker--111122223333`. Procure o bucket S3 básico por meio do campo **Localizar bucket pelo nome**.
![\[O campo Localizar bucket pelo nome no console do Amazon S3.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-0.png)
1. No bucket básico do S3, procure o nome do trabalho de treinamento inserindo o prefixo do nome do trabalho em **Localizar objetos por prefixo** e, em seguida, escolhendo o nome do trabalho de treinamento.
![\[O campo Localizar objetos por prefixo no console do Amazon S3.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-1.png)
1. No bucket S3 do trabalho de treinamento, escolha a subpasta **rule-output/**. Deve haver três subpastas para os dados de treinamento coletados pelo Debugger: **debug-output/**, **profiler-output/** e **rule-output/**.
![\[Um exemplo de saída de regra para o URI do bucket do S3.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-2.png)
1. **Na pasta **rule-output/, escolha a pasta /.** CreateXgboostReport** A pasta contém **xbgoost\$1report.html** (o relatório gerado automaticamente em html) e **xbgoost\$1report.ipynb** (um caderno Jupyter com scripts usados para gerar o relatório).
1. Escolha o arquivo **xbgoost\$1report.html**, escolha **Ações de download** e, em seguida, escolha **Baixar**.
![\[Um exemplo de saída de regra para o URI do bucket do S3.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-s3-download.png)
1. Abra o arquivo **xbgoost\$1report.html** baixado em um navegador da web.
------
# Passo a passo do relatório de treinamento do Debugger XGBoost
Esta seção mostra o relatório de treinamento do Debugger XGBoost . O relatório é agregado automaticamente, dependendo da expressão regular do tensor de saída, reconhecendo que tipo de seu trabalho de treinamento está entre classificação binária, classificação multiclasse e regressão.
**Importante**
No relatório, os gráficos e as recomendações são fornecidos para fins informativos e não são definitivos. Você é responsável por fazer sua própria avaliação independente das informações.
**Topics**
+ [Distribuição de rótulos verdadeiros do conjunto de dados](#debugger-training-xgboost-report-walkthrough-dist-label)
+ [Gráfico de perda versus etapas](#debugger-training-xgboost-report-walkthrough-loss-vs-step)
+ [importância do atributo](#debugger-training-xgboost-report-walkthrough-feature-importance)
+ [Matriz de confusão](#debugger-training-xgboost-report-walkthrough-confusion-matrix)
+ [Avaliação da matriz de confusão](#debugger-training-xgboost-report-walkthrough-eval-conf-matrix)
+ [Taxa de precisão de cada elemento diagonal durante a iteração](#debugger-training-xgboost-report-walkthrough-accuracy-rate)
+ [Curva característica de operação do receptor](#debugger-training-xgboost-report-walkthrough-rec-op-char)
+ [Distribuição de resíduos na última etapa salva](#debugger-training-xgboost-report-walkthrough-dist-residual)
+ [Erro absoluto de validação por compartimento de etiqueta durante a iteração](#debugger-training-xgboost-report-walkthrough-val-error-per-label-bin)
## Distribuição de rótulos verdadeiros do conjunto de dados
Esse histograma mostra a distribuição de classes rotuladas (para classificação) ou valores (para regressão) em seu conjunto de dados original. A distorção em seu conjunto de dados pode contribuir para imprecisões. Essa visualização está disponível para os seguintes tipos de modelo: classificação binária, multiclassificação e regressão.
![\[Um exemplo de distribuição de rótulos verdadeiros do gráfico do conjunto de dados.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-dist-label.png)
## Gráfico de perda versus etapas
Este é um gráfico de linhas que mostra a progressão da perda nos dados de treinamento e nos dados de validação ao longo das etapas do treinamento. A perda é o que você definiu em sua função objetivo, como erro quadrático médio. Você pode avaliar se o ajuste do modelo está excessivo ou insuficiente a partir desse gráfico. Esta seção também fornece informações que você pode usar para determinar como resolver os problemas de ajuste excessivo e insuficiente. Essa visualização está disponível para os seguintes tipos de modelo: classificação binária, multiclassificação e regressão.
![\[Um exemplo de gráfico de perda versus etapa.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-loss-vs-step.png)
## importância do atributo
Há três tipos diferentes de visualizações de importância de atributos fornecidos: peso, ganho e cobertura. Fornecemos definições detalhadas para cada um dos três no relatório. As visualizações de importância do atributo ajudam você a aprender quais atributos em seu conjunto de dados de treinamento contribuíram para as predições. As visualizações da importância do atributo estão disponíveis para os seguintes tipos de modelo: classificação binária, multiclassificação e regressão.
![\[Um exemplo de gráfico de importância de um atributo.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-feature-importance.png)
## Matriz de confusão
Essa visualização é aplicável somente aos modelos de classificação binária e multiclasse. A precisão por si só pode não ser suficiente para avaliar o desempenho do modelo. Para alguns casos de uso, como saúde e detecção de fraudes, também é importante conhecer a taxa de falsos positivos e a taxa de falsos negativos. Uma matriz de confusão fornece as dimensões adicionais para avaliar o desempenho do seu modelo.
![\[Um exemplo de matriz de confusão.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-confusion-matrix.png)
## Avaliação da matriz de confusão
Esta seção fornece mais informações sobre as métricas micro, macro e ponderadas sobre precisão, recall e pontuação F1 para seu modelo.
![\[Avaliação da matriz de confusão.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-eval-conf-matrix.png)
## Taxa de precisão de cada elemento diagonal durante a iteração
Essa visualização é aplicável somente aos modelos de classificação binária e classificação multiclasse. Este é um gráfico de linhas que traça os valores diagonais na matriz de confusão ao longo das etapas de treinamento de cada classe. Este gráfico mostra como a precisão de cada classe progride ao longo das etapas do treinamento. Você pode identificar as classes com baixo desempenho nesse gráfico.
![\[Um exemplo de taxa de precisão de cada elemento diagonal durante no gráfico de iteração.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-accuracy-rate.gif)
## Curva característica de operação do receptor
Essa visualização é aplicável somente aos modelos de classificação binária. A curva característica de operação do receptor é comumente usada para avaliar o desempenho do modelo de classificação binária. O eixo y da curva é a taxa de positivos verdadeiros (TPF) e o eixo x é a taxa de falsos positivos (FPR). O gráfico também exibe o valor da área sob a curva (AUC). Quanto maior o valor da AUC, mais previsível é o seu classificador. Você também pode usar a curva ROC para entender a compensação entre TPR e FPR e identificar o limite de classificação ideal para seu caso de uso. O limite de classificação pode ser ajustado para ajustar o comportamento do modelo para reduzir mais de um ou outro tipo de erro (FP/FN).
![\[Um exemplo de gráfico de curva característica de operação do receptor.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-rec-op-char.png)
## Distribuição de resíduos na última etapa salva
Essa visualização é um gráfico de colunas que mostra as distribuições residuais na última etapa que o Debugger captura. Nessa visualização, você pode verificar se a distribuição residual está próxima da distribuição normal centralizada em zero. Se os resíduos estiverem distorcidos, seus atributos podem não ser suficientes para prever os rótulos.
![\[Um exemplo de distribuição de resíduos no último gráfico de etapa salvo.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-dist-residual.png)
## Erro absoluto de validação por compartimento de etiqueta durante a iteração
Essa visualização é aplicável somente para modelos de regressão. Os valores-alvo reais são divididos em 10 intervalos. Essa visualização mostra como os erros de validação progridem em cada intervalo ao longo das etapas de treinamento nos gráficos de linha. O erro absoluto de validação é o valor absoluto da diferença entre a predição e o real durante a validação. Você pode identificar os intervalos de baixo desempenho nessa visualização.
![\[Um exemplo de erro absoluto de validação por compartimento de rótulos no gráfico de iteração.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-val-error-per-label-bin.png)
# Ação sobre as regras do Amazon SageMaker Debugger
Com base no status de avaliação da regra do Debugger, você pode configurar ações automatizadas, como interromper um trabalho de treinamento e enviar notificações por SMS usando o Amazon Simple Notification Service (Amazon SNS). Você também pode criar suas próprias ações usando Amazon CloudWatch Events AWS Lambda e. Para saber como configurar ações automatizadas com base no status de avaliação da regra do Debugger, consulte os tópicos a seguir.
**Topics**
+ [Usar ações integradas das regras do Depurador](debugger-built-in-actions.md)
+ [Ações sobre regras usando Amazon CloudWatch e AWS Lambda](debugger-cloudwatch-lambda.md)
# Usar ações integradas das regras do Depurador
Use as ações integradas do Debugger para responder aos problemas encontrados por [Regra do Depurador](debugger-built-in-rules.md#debugger-built-in-rules-Rule). A classe `rule_configs` Debugger fornece ferramentas para configurar uma lista de ações, incluindo a interrupção automática de trabalhos de treinamento e o envio de notificações usando o Amazon Simple Notification Service (Amazon SNS) quando as regras do Debugger encontram problemas de treinamento. Os tópicos a seguir orienta as etapas necessárias para realizar essas tarefas.
**Topics**
+ [Configurar o Amazon SNS, criar um tópico `SMDebugRules` e assinar o tópico](#debugger-built-in-actions-sns)
+ [Configurar o seu perfil do IAM para anexar as políticas necessárias](#debugger-built-in-actions-iam)
+ [Configuração das regras do Depurador com ações integradas](#debugger-built-in-actions-on-rule)
+ [Considerações sobre o uso das ações integradas do Depurador](#debugger-built-in-actions-considerations)
## Configurar o Amazon SNS, criar um tópico `SMDebugRules` e assinar o tópico
Esta seção explica como configurar um **SMDebugRules** tópico do Amazon SNS, inscrever-se nele e confirmar a assinatura para receber notificações das regras do Debugger.
**nota**
[Para obter mais informações sobre o faturamento do Amazon SNS, consulte os preços do Amazon SNS [e o Amazon SNS](https://aws.amazon.com/sns/pricing/). FAQs](https://aws.amazon.com/sns/faqs/)
**Para criar um tópico de SMDebug regras**
1. [Faça login no Console de gerenciamento da AWS e abra o console do Amazon SNS em https://console.aws.amazon.com/sns/ v3/home.](https://console.aws.amazon.com/sns/v3/home)
1. No painel de navegação à esquerda, selecione **Tópicos**.
1. Na página **Tópicos**, escolha **Criar tópico**.
1. Na página **Criar tópico**, na seção **Detalhes**, faça o seguinte:
1. Em **Tipo**, escolha **Padrão** para o tipo de tópico.
1. Em **Nome**, insira **SMDebugRules**.
1. Ignore todas as outras configurações opcionais e escolha **Criar tópico**. Se você quiser saber mais sobre as configurações opcionais, consulte o tópico [Criação de um Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html).
**Para se inscrever no tópico SMDebug Regras**
1. [Abra o console do Amazon SNS em https://console.aws.amazon.com/sns/ v3/home.](https://console.aws.amazon.com/sns/v3/home)
1. No painel de navegação à esquerda, selecione **Assinaturas**.
1. Na página **Assinaturas**, escolha **Criar assinatura**.
1. Na página **Criar assinatura**, na seção **Detalhes**, faça o seguinte:
1. Em **ARN do tópico, escolha o ARN** do tópico **SMDebugRegras**. O ARN deve estar no formato de `arn:aws:sns::111122223333:SMDebugRules`.
1. Em **Protocolo**, escolha **Email** ou **SMS**.
1. Em **Endpoint**, insira o valor do endpoint, como um endereço de e-mail ou um número de telefone do qual você deseja receber notificações.
**nota**
Certifique-se de digitar o endereço de e-mail e o número de telefone corretos. Os números de telefone devem incluir `+`, um código de país e um número de telefone, sem caracteres especiais ou espaços. Por exemplo, o número de telefone \$11 (222) 333-4444 está formatado como **\$112223334444**.
1. Ignore todas as outras configurações opcionais e escolha **Criar assinatura**. Se você quiser saber mais sobre as configurações opcionais, consulte o tópico [Inscrevendo-se para um Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html).
Depois de assinar o tópico **SMDebugRegras**, você receberá a seguinte mensagem de confirmação por e-mail ou telefone:
![\[Uma mensagem de e-mail de confirmação da assinatura para o tópico SMDebugRegras do Amazon SNS.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-built-in-action-subscription-confirmation.png)
Para obter mais informações sobre o Amazon SNS, consulte [Mensagens de texto móveis (SMS)](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html) e [Notificações por e-mail](https://docs.aws.amazon.com/sns/latest/dg/sns-email-notifications.html) no *Guia do desenvolvedor do Amazon SNS*.
## Configurar o seu perfil do IAM para anexar as políticas necessárias
Nesta etapa, adicione as políticas necessárias à perfil do IAM.
**Para adicionar as políticas necessárias à sua perfil do IAM**
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação à esquerda, selecione **Políticas** e **Criar política**.
1. Na página **Criar política**, faça o seguinte para criar uma nova política de acesso ao sns:
1. Selecione a guia **JSON**.
1. Cole as sequências de caracteres JSON formatadas em negrito no código a seguir no`"Statement"`, substituindo o ID da conta de 12 dígitos pelo ID da AWS sua conta. AWS
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sns:Publish",
"sns:CreateTopic",
"sns:Subscribe"
],
"Resource": "arn:aws:sns:*:111122223333:SMDebugRules"
}
]
}
```
------
1. Na parte inferior da página, escolha **Revisar política**.
1. Na página **Revisar política**, em **Nome**, insira **sns-access**.
1. Na parte inferior da página, escolha **Criar política**.
1. Volte para o console do IAM e escolha **Funções** no painel de navegação à esquerda.
1. Pesquise a função do IAM que você usa para o treinamento do modelo de SageMaker IA e escolha essa função do IAM.
1. Na guia de **Permissões** da página **Resumo**, escolha **Anexar políticas**.
1. Pesquise a política de **acesso sns**, marque a caixa de seleção ao lado da política e escolha **Anexar política**.
Para obter mais exemplos de configuração de políticas do IAM para o Amazon SNS, consulte [Exemplos de casos de controle de acesso ao Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-access-policy-use-cases.html).
## Configuração das regras do Depurador com ações integradas
Depois de concluir com êxito as configurações necessárias nas etapas anteriores, você poderá configurar as ações integradas do Debugger para regras de depuração, conforme mostrado no script de exemplo a seguir. Você pode escolher quais ações internas usar ao criar o objeto da lista `actions`. O `rule_configs` é um módulo auxiliar que fornece ferramentas de alto nível para configurar as regras e ações integradas do Debugger. As seguintes ações integradas estão disponíveis para o Debugger:
+ `rule_configs.StopTraining()`: Interrompe um trabalho de treinamento quando a regra do Debugger encontra um problema.
+ `rule_configs.Email("abc@abc.com")`: Envia uma notificação por e-mail quando a regra do Debugger encontra um problema. Use o endereço de e-mail que você usou ao configurar sua assinatura de tópicos do SNS.
+ `rule_configs.SMS("+1234567890")`: Envia uma notificação por mensagem de texto quando a regra do Debugger encontra um problema. Use o número de telefone que você usou ao configurar sua assinatura de tópico SNS.
**nota**
Certifique-se de digitar o endereço de e-mail e o número de telefone corretos. Os números de telefone devem incluir `+`, um código do país e um número de telefone, sem caracteres especiais ou espaços. Por exemplo, o número de telefone \$11 (222) 333-4444 está formatado como **\$112223334444**.
Você pode usar todas as ações integradas ou um subconjunto de ações concluindo usando o método `rule_configs.ActionList()`, que usa as ações integradas e configura uma lista de ações.
**Para adicionar todas as três ações integradas a uma única regra**
Se você quiser atribuir todas as três ações integradas a uma única regra, configure uma lista de ações integradas do Debugger ao construir um estimador. Use o modelo a seguir para construir o estimador, e o Debugger interromperá os trabalhos de treinamento e enviará notificações por email e texto para quaisquer regras que você usar para monitorar o progresso do seu trabalho de treinamento.
```
from sagemaker.debugger import Rule, rule_configs
# Configure an action list object for Debugger rules
actions = rule_configs.ActionList(
rule_configs.StopTraining(),
rule_configs.Email("abc@abc.com"),
rule_configs.SMS("+1234567890")
)
# Configure rules for debugging with the actions parameter
rules = [
Rule.sagemaker(
base_config=rule_configs.built_in_rule(), # Required
rule_parameters={"paramter_key": value }, # Optional
actions=actions
)
]
estimator = Estimator(
...
rules = rules
)
estimator.fit(wait=False)
```
**Para criar vários objetos de ação integrados para atribuir ações diferentes a uma única regra**
Se desejar atribuir ações integradas para serem acionadas em diferentes valores de limite de uma única regra, você poderá criar vários objetos de ação integrados, conforme mostrado no script a seguir. Para evitar um erro de conflito ao executar a mesma regra, você deve enviar nomes de tarefas de regras diferentes (especificar sequências diferentes para o atributo `name` das regras), conforme mostrado no modelo de script de exemplo a seguir. Este exemplo mostra como configurar [StalledTrainingRule](debugger-built-in-rules.md#stalled-training) para realizar duas ações diferentes: enviar um e-mail para `abc@abc.com` quando um trabalho de treinamento parar por 60 segundos e interromper o trabalho de treinamento se ficar parado por 120 segundos.
```
from sagemaker.debugger import Rule, rule_configs
import time
base_job_name_prefix= 'smdebug-stalled-demo-' + str(int(time.time()))
# Configure an action object for StopTraining
action_stop_training = rule_configs.ActionList(
rule_configs.StopTraining()
)
# Configure an action object for Email
action_email = rule_configs.ActionList(
rule_configs.Email("abc@abc.com")
)
# Configure a rule with the Email built-in action to trigger if a training job stalls for 60 seconds
stalled_training_job_rule_email = Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "60",
"training_job_name_prefix": base_job_name_prefix
},
actions=action_email
)
stalled_training_job_rule_text.name="StalledTrainingJobRuleEmail"
# Configure a rule with the StopTraining built-in action to trigger if a training job stalls for 120 seconds
stalled_training_job_rule = Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "120",
"training_job_name_prefix": base_job_name_prefix
},
actions=action_stop_training
)
stalled_training_job_rule.name="StalledTrainingJobRuleStopTraining"
estimator = Estimator(
...
rules = [stalled_training_job_rule_email, stalled_training_job_rule]
)
estimator.fit(wait=False)
```
Enquanto o trabalho de treinamento está em execução, a ação integrada do Debugger envia e-mails de notificação e mensagens de texto sempre que a regra encontra problemas com seu trabalho de treinamento. A captura de tela a seguir mostra um exemplo de notificação por email para um trabalho de treinamento que apresenta um problema de trabalho de treinamento paralisado.
![\[Um exemplo de notificação por e-mail enviada pelo Debugger quando ele detecta um problema. StalledTraining\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-built-in-action-email.png)
A captura de tela a seguir mostra um exemplo de notificação de texto que o Debugger envia quando a regra encontra um problema. StalledTraining
![\[Um exemplo de notificação de texto enviada pelo Debugger quando ele detecta um problema. StalledTraining\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-built-in-action-text.png)
## Considerações sobre o uso das ações integradas do Depurador
+ Para usar as ações integradas do Debugger, é necessária uma conexão com a Internet. Esse recurso não é suportado no modo de isolamento de rede fornecido pela Amazon SageMaker AI ou Amazon VPC.
+ As ações integradas não podem ser usadas para [Regras do perfilador](debugger-built-in-profiler-rules.md#debugger-built-in-profiler-rules-ProfilerRule).
+ As ações integradas não podem ser usadas em trabalhos de treinamento com interrupções pontuais no treinamento.
+ Nas notificações por e-mail ou texto, `None` aparece no final das mensagens. Isso não tem nenhum significado, então você pode ignorar o texto `None`.
# Ações sobre regras usando Amazon CloudWatch e AWS Lambda
A Amazon CloudWatch coleta registros de trabalhos de treinamento do modelo Amazon SageMaker AI e registros de trabalhos de processamento de regras do Amazon SageMaker Debugger. Configure o Debugger com o Amazon CloudWatch Events e tome medidas com base no AWS Lambda status de avaliação da regra do Debugger.
## Cadernos de exemplo
Você pode executar os seguintes exemplos de cadernos, que estão preparados para experimentar a interrupção de um trabalho de treinamento usando ações nas regras integradas do Debugger usando Amazon e. CloudWatch AWS Lambda
+ [Amazon SageMaker Debugger - Reagindo a eventos a partir de regras CloudWatch ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_action_on_rule/tf-mnist-stop-training-job.html)
Este caderno de exemplo executa um trabalho de treinamento que apresenta um problema de gradiente de desaparecimento. A regra [VanishingGradient](debugger-built-in-rules.md#vanishing-gradient) integrada do Debugger é usada durante a construção do estimador de IA. SageMaker TensorFlow Quando a regra do Debugger detecta o problema, o trabalho de treinamento é encerrado.
+ [Detecte o treinamento paralisado e invoque ações usando SageMaker a regra do depurador](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_action_on_rule/detect_stalled_training_job_and_actions.html)
Este exemplo de caderno executa um script de treinamento com uma linha de código que o força a dormir por 10 minutos. A regra [StalledTrainingRule](debugger-built-in-rules.md#stalled-training) integrada do Debugger invoca problemas e interrompe o trabalho de treinamento.
**Topics**
+ [Cadernos de exemplo](#debugger-test-stop-training)
+ [CloudWatch Registros de acesso para regras do Debugger e trabalhos de treinamento](debugger-cloudwatch-metric.md)
+ [Configure o Debugger para o término automatizado do trabalho de treinamento usando o Lambda CloudWatch](debugger-stop-training.md)
+ [Desative a regra de CloudWatch Eventos para parar de usar o encerramento automático do trabalho de treinamento](debugger-disable-cw.md)
# CloudWatch Registros de acesso para regras do Debugger e trabalhos de treinamento
Você pode usar o status do trabalho da regra de treinamento e do Debugger nos CloudWatch registros para realizar outras ações quando houver problemas de treinamento. O procedimento a seguir mostra como acessar os CloudWatch registros relacionados. Para obter mais informações sobre como monitorar trabalhos de treinamento usando CloudWatch, consulte [Monitore a Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html).
**Para encontrar logs de trabalho de treinamento e logs de trabalho da regra do Debugger**
1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação à esquerda, sob o nó **Log**, escolha **Grupos de logs**.
1. Na lista de grupos de logs, faça o seguinte:
+ Escolha**/aws/sagemaker/TrainingJobs**para registros de tarefas de treinamento.
+ Escolha**/aws/sagemaker/ProcessingJobs**para os registros de tarefas da regra do Debugger.
# Configure o Debugger para o término automatizado do trabalho de treinamento usando o Lambda CloudWatch
As regras do Debugger monitoram o status do trabalho de treinamento, e uma regra de CloudWatch Eventos observa o status da avaliação do trabalho de treinamento da regra do Debugger. As seções a seguir descrevem o processo necessário para automatizar o término do trabalho de treinamento usando o uso e o CloudWatch Lambda.
**Topics**
+ [Etapa 1: criar uma função do Lambda](#debugger-lambda-function-create)
+ [Etapa 2: configurar a função do Lambda](#debugger-lambda-function-configure)
+ [Etapa 3: criar uma regra de CloudWatch eventos e vincular à função Lambda para o Debugger](#debugger-cloudwatch-events)
## Etapa 1: criar uma função do Lambda
**Criar uma função do Lambda**
1. Abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. No painel de navegação à esquerda, selecione **Funções** e selecione **Criar função**.
1. Na página **Criar função**, escolha a opção **Criar do zero**.
1. Na seção **Informações básicas**, insira um **nome de função** (por exemplo, **debugger-rule-stop-training-job**).
1. Em **Runtime**, selecione **Python 3.7**.
1. Em **Permissões**, expanda a opção suspensa e escolha **Alterar função de execução padrão**.
1. Em **Função de execução**, escolha **Usar uma função existente** e escolha a função do IAM que você usa para treinar trabalhos em SageMaker IA.
**nota**
Certifique-se de usar a função de execução com `AmazonSageMakerFullAccess` e `AWSLambdaBasicExecutionRole` anexados. Caso contrário, a função do Lambda não reagirá adequadamente às mudanças de status da regra do Debugger do trabalho de treinamento. Se você não tiver certeza de qual função de execução está sendo usada, execute o código a seguir em uma célula do Caderno Jupyter para recuperar a saída da função de execução:
```
import sagemaker
sagemaker.get_execution_role()
```
1. Na parte inferior da página, selecione **Create function**.
A figura a seguir mostra um exemplo da página **Criar função** com os campos de entrada e as seleções concluídos.
![\[Página Criar função.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-lambda-create.png)
## Etapa 2: configurar a função do Lambda
**Para configurar a função do Lambda**
1. Na seção **Código da função** da página de configuração, cole o seguinte script Python no painel do editor de código Lambda: A `lambda_handler` função monitora o status de avaliação da regra do Debugger coletado CloudWatch e aciona a operação da API. `StopTrainingJob` O AWS SDK para Python (Boto3) `client` for SageMaker AI fornece um método de alto nível,`stop_training_job`, que aciona a operação da `StopTrainingJob` API.
```
import json
import boto3
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def lambda_handler(event, context):
training_job_name = event.get("detail").get("TrainingJobName")
logging.info(f'Evaluating Debugger rules for training job: {training_job_name}')
eval_statuses = event.get("detail").get("DebugRuleEvaluationStatuses", None)
if eval_statuses is None or len(eval_statuses) == 0:
logging.info("Couldn't find any debug rule statuses, skipping...")
return {
'statusCode': 200,
'body': json.dumps('Nothing to do')
}
# should only attempt stopping jobs with InProgress status
training_job_status = event.get("detail").get("TrainingJobStatus", None)
if training_job_status != 'InProgress':
logging.debug(f"Current Training job status({training_job_status}) is not 'InProgress'. Exiting")
return {
'statusCode': 200,
'body': json.dumps('Nothing to do')
}
client = boto3.client('sagemaker')
for status in eval_statuses:
logging.info(status.get("RuleEvaluationStatus") + ', RuleEvaluationStatus=' + str(status))
if status.get("RuleEvaluationStatus") == "IssuesFound":
secondary_status = event.get("detail").get("SecondaryStatus", None)
logging.info(
f'About to stop training job, since evaluation of rule configuration {status.get("RuleConfigurationName")} resulted in "IssuesFound". ' +
f'\ntraining job "{training_job_name}" status is "{training_job_status}", secondary status is "{secondary_status}"' +
f'\nAttempting to stop training job "{training_job_name}"'
)
try:
client.stop_training_job(
TrainingJobName=training_job_name
)
except Exception as e:
logging.error(
"Encountered error while trying to "
"stop training job {}: {}".format(
training_job_name, str(e)
)
)
raise e
return None
```
Para obter mais informações sobre a interface do editor de código Lambda, consulte [Criação de funções usando o editor do console AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/code-editor.html).
1. Ignore todas as outras configurações e escolha **Salvar** na parte superior da página de configuração.
## Etapa 3: criar uma regra de CloudWatch eventos e vincular à função Lambda para o Debugger
**Para criar uma regra de CloudWatch eventos e vincular à função Lambda para o Debugger**
1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação à esquerda, selecione **Regras** sob o nó **Eventos**.
1. Escolha **Criar regra**.
1. Na seção **Origem do evento** da página **Etapa 1: Criar regra**, escolha **SageMaker AI** para **Nome do serviço** e escolha **SageMaker AI Training Job State Change** para **Tipo de evento**. A visualização do padrão de evento deve ser semelhante aos seguintes exemplos de strings JSON:
```
{
"source": [
"aws.sagemaker"
],
"detail-type": [
"SageMaker Training Job State Change"
]
}
```
1. Na seção **Targets**, escolha **Add target\$1** e escolha a função **debugger-rule-stop-training-job Lambda** que você criou. Essa etapa vincula a regra de CloudWatch Eventos à função Lambda.
1. Escolha **Configurar detalhes** e vá para a página **Etapa 2: configurar detalhes da regra**.
1. Especifique o nome da definição da CloudWatch regra. Por exemplo, .**debugger-cw-event-rule**
1. Escolha **Criar regra** para concluir.
1. Volte para a página de configuração da função do Lambda e atualize a página. Confirme se está configurado corretamente no painel **Designer**. A regra de CloudWatch eventos deve ser registrada como um gatilho para a função Lambda. O design da configuração deve ser semelhante ao seguinte exemplo:
![\[Painel de design para a CloudWatch configuração.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-lambda-designer.png)
# Desative a regra de CloudWatch Eventos para parar de usar o encerramento automático do trabalho de treinamento
Se você quiser desativar o encerramento automático do trabalho de treinamento, precisará desativar a regra de CloudWatch Eventos. No painel Lambda **Designer**, escolha o bloco **EventBridge (CloudWatch Eventos)** vinculado à função Lambda. Isso mostra um **EventBridge**painel abaixo do painel **Designer** (por exemplo, veja a captura de tela anterior). Marque a caixa de seleção ao lado de **EventBridge (CloudWatch Eventos): debugger-cw-event-rule** e escolha **Desativar**. Se quiser usar a funcionalidade de encerramento automático posteriormente, você pode ativar a regra de CloudWatch Eventos novamente.
# Visualize os tensores de saída do Amazon SageMaker Debugger em TensorBoard
**Importante**
Esta página foi descontinuada em favor do Amazon SageMaker AI with TensoBoard, que fornece uma TensorBoard experiência abrangente integrada ao SageMaker treinamento e às funcionalidades de controle de acesso do domínio de IA. SageMaker Para saber mais, consulte [TensorBoard na Amazon SageMaker AI](tensorboard-on-sagemaker.md).
Use o SageMaker Debugger para criar arquivos tensores de saída compatíveis com o. TensorBoard Carregue os arquivos para visualizar TensorBoard e analisar seus trabalhos de SageMaker treinamento. O Debugger gera automaticamente arquivos tensores de saída compatíveis com o. TensorBoard Para qualquer configuração de gancho que você personaliza para salvar tensores de saída, o Debugger tem a flexibilidade de criar resumos, distribuições e histogramas escalares para os quais você pode importar. TensorBoard
![\[Um diagrama de arquitetura do mecanismo de salvamento do tensor de saída do Debugger.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-tensorboard-concept.png)
Você pode habilitar isso passando objetos `DebuggerHookConfig` e `TensorBoardOutputConfig` para um `estimator`.
O procedimento a seguir explica como salvar escalares, pesos e vieses como tensores completos, histogramas e distribuições que podem ser visualizados com. TensorBoard O Debugger os salva no caminho local do contêiner de treinamento (o caminho padrão é `/opt/ml/output/tensors`) e sincroniza com os locais do Amazon S3 passados pelos objetos de configuração de saída do Debugger.
**Para salvar arquivos tensores de saída TensorBoard compatíveis usando o Debugger**
1. Configure um objeto `tensorboard_output_config` de configuração para salvar a TensorBoard saída usando a classe Debugger`TensorBoardOutputConfig`. Para o `s3_output_path` parâmetro, especifique o bucket S3 padrão da sessão de SageMaker IA atual ou um bucket S3 preferencial. Este exemplo não adiciona o parâmetro `container_local_output_path`; em vez disso, ele é definido como o caminho local padrão `/opt/ml/output/tensors`.
```
import sagemaker
from sagemaker.debugger import TensorBoardOutputConfig
bucket = sagemaker.Session().default_bucket()
tensorboard_output_config = TensorBoardOutputConfig(
s3_output_path='s3://{}'.format(bucket)
)
```
Para obter informações adicionais, consulte a `[TensorBoardOutputConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig)` API Debugger no SDK do Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable).
1. Configure o hook do Debugger e personalize os valores dos parâmetros do hook. Por exemplo, o código a seguir configura um hook do Debugger para salvar todas as saídas escalares a cada 100 etapas nas fases de treinamento e 10 etapas nas fases de validação, os parâmetros `weights` a cada 500 etapas (o valor padrão `save_interval` para salvar coleções de tensores é 500) e os parâmetros `bias` a cada 10 etapas globais até que a etapa global alcance 500.
```
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig
hook_config = DebuggerHookConfig(
hook_parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
},
collection_configs=[
CollectionConfig("weights"),
CollectionConfig(
name="biases",
parameters={
"save_interval": "10",
"end_step": "500",
"save_histogram": "True"
}
),
]
)
```
[Para obter mais informações sobre a configuração do Debugger APIs, consulte o Debugger e o SDK `[DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)` APIs do Amazon `[CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)` Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
1. Construa um estimador de SageMaker IA com os parâmetros do Debugger passando pelos objetos de configuração. O modelo de exemplo a seguir mostra como criar um estimador genérico de SageMaker IA. Você pode substituir `estimator` e por classes principais `Estimator` de estimadores e classes de estimadores de outras estruturas de SageMaker IA. Os estimadores de estrutura de SageMaker IA disponíveis para essa funcionalidade são `[TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html#create-an-estimator)``[PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#create-an-estimator)`, e. `[MXNet](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#create-an-estimator)`
```
from sagemaker.estimator import Estimator
estimator = Estimator(
...
# Debugger parameters
debugger_hook_config=hook_config,
tensorboard_output_config=tensorboard_output_config
)
estimator.fit()
```
O `estimator.fit()` método inicia um trabalho de treinamento e o Debugger grava os arquivos tensores de saída em tempo real no caminho de saída do Debugger S3 e no caminho de saída do S3. TensorBoard Para recuperar os caminhos de saída, use os seguintes métodos de estimativa:
+ Para o caminho de saída do Debugger S3, use `estimator.latest_job_debugger_artifacts_path()`.
+ Para o caminho de saída do TensorBoard S3, use`estimator.latest_job_tensorboard_artifacts_path()`.
1. Após a conclusão do treinamento, verifique os nomes dos tensores de saída salvos:
```
from smdebug.trials import create_trial
trial = create_trial(estimator.latest_job_debugger_artifacts_path())
trial.tensor_names()
```
1. Verifique os dados TensorBoard de saída no Amazon S3:
```
tensorboard_output_path=estimator.latest_job_tensorboard_artifacts_path()
print(tensorboard_output_path)
!aws s3 ls {tensorboard_output_path}/
```
1. Faça o download dos dados de TensorBoard saída para a instância do seu notebook. Por exemplo, o AWS CLI comando a seguir baixa os TensorBoard arquivos para o `/logs/fit` diretório de trabalho atual da instância do seu notebook.
```
!aws s3 cp --recursive {tensorboard_output_path} ./logs/fit
```
1. Comprima o diretório do arquivo em um arquivo TAR para fazer o download em sua máquina local.
```
!tar -cf logs.tar logs
```
1. Baixe e extraia o arquivo TAR do Tensorboard em um diretório no seu dispositivo, inicie um servidor de notebook Jupyter, abra um novo notebook e execute o aplicativo. TensorBoard
```
!tar -xf logs.tar
%load_ext tensorboard
%tensorboard --logdir logs/fit
```
A captura de tela animada a seguir ilustra as etapas 5 a 8. Ele demonstra como baixar o arquivo TensorBoard TAR do Debugger e carregar o arquivo em um notebook Jupyter em seu dispositivo local.
![\[Animação sobre como baixar e carregar o TensorBoard arquivo do Debugger em sua máquina local.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-tensorboard.gif)
# Lista de regras integradas do Depurador
Você pode usar as regras integradas do Depurador fornecidas pelo Amazon SageMaker Debugger para analisar métricas e tensores coletados durante o treinamento dos modelos. A seguir estão listadas as regras do depurador, incluindo informações e um exemplo de como configurar e implantar cada regra incorporada.
Essas regras integradas do Debugger monitoram várias condições comuns que são críticas para o sucesso de um trabalho de treinamento. Você pode chamar as regras integradas usando o [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) ou as operações de API de baixo nível do SageMaker.
Não há custo adicional para usar as regras integradas. Para obter mais informações sobre faturamento, consulte a página de [Definição de preços do Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/).
**nota**
O número máximo de regras integradas que você pode anexar a um trabalho de treinamento é 20. O SageMaker Debugger gerencia totalmente as regras integradas e analisa seu trabalho de treinamento de forma síncrona.
**Importante**
Para usar os novos atributos do Debugger, você precisa atualizar o SageMaker Python SDK e a biblioteca de cliente do SMDebug. No kernel do iPython, no caderno Jupyter ou no ambiente do JupyterLab, execute o código a seguir para instalar as versões mais recentes das bibliotecas e reiniciar o kernel.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Regra do Depurador
As regras a seguir são as regras integradas do Debugger que podem ser chamadas usando o método de classe `Rule.sagemaker`.
Regras integradas do Debugger para a geração de relatórios de treinamento
| Escopo de validade | Regras integradas |
| --- | --- |
| Relatório de treinamento para a tarefa de treinamento do XGBoost do SageMaker AI | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-rules.html) |
Regras integradas do Debugger para a depuração de dados de treinamento de modelo (tensores de saída)
| Escopo de validade | Regras integradas |
| --- | --- |
| Estruturas de aprendizado profundo (TensorFlow, MXNet e PyTorch) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Estruturas de aprendizado profundo (TensorFlow, MXNet e PyTorch) e o algoritmo XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Aplicações de aprendizado profundo | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Algoritmo XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-rules.html) |
**Para usar as regras integradas com valores de parâmetros padrão**, use o seguinte formato de configuração:
```
from sagemaker.debugger import Rule, ProfilerRule, 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())
]
```
**Para usar as regras integradas com valores de parâmetros personalizados**, use o seguinte formato de configuração:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
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"
}
)
]
)
]
```
Para encontrar as chaves disponíveis para o parâmetro `rule_parameters`, consulte as tabelas de descrição de parâmetros.
Exemplos de códigos de configuração de regras são fornecidos para cada regra integrada abaixo das tabelas de descrição de parâmetros.
+ Para obter instruções completas e exemplos de uso das regras integradas do Debugger, consulte [Código de exemplo de regras integradas do Depurador](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Para obter instruções completas sobre como usar as regras integradas com as operações de API de baixo nível do SageMaker, consulte [Configurar o Debugger usando a API SageMaker](debugger-createtrainingjob-api.md).
## CreateXgboostReport
A regra CreateXGBoostReport coleta tensores de saída de um trabalho de treinamento do XGBoost e gera automaticamente um relatório de treinamento abrangente. Você pode baixar um relatório abrangente de criação de perfis enquanto um trabalho de treinamento é executado ou após a conclusão do trabalho de treinamento e verificar o progresso do treinamento ou o resultado final do trabalho de treinamento. A regra CreateXGBoostReport coleta os seguintes tensores de saída por padrão:
+ `hyperparameters`: Salva na primeira etapa
+ `metrics`: Economiza perdas e precisão a cada 5 etapas
+ `feature_importance`: Salva a cada 5 etapas
+ `predictions`: Salva a cada 5 etapas
+ `labels`: Salva a cada 5 etapas
Descrições de parâmetros para a regra CreateXGBoostReport
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
```
rules=[
Rule.sagemaker(
rule_configs.create_xgboost_report()
)
]
```
## DeadRelu
Essa regra detecta quando a porcentagem de funções de ativação de unidade linear retificada (ReLU) em um teste são consideradas inativas porque sua atividade de ativação caiu abaixo de um limite. Se o percentual de ReLUs inativas em uma camada for maior que o valor `threshold_layer` de ReLUs inativas, a regra retornará `True`.
Descrições de parâmetros para a regra DeadRelu
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| tensor\$1regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `".*relu_output"` |
| threshold\$1inactivity | Define um nível de atividade abaixo do qual uma ReLU é considerada morta. Uma ReLU pode estar ativa no início de um teste e, depois, morrer lentamente durante o processo de treinamento. Se a ReLU estiver ativa abaixo do `threshold_inactivity`, ela será considerada morta. **Opcional** Valores válidos: Flutuante Valores padrão: `1.0` (em porcentagem) |
| threshold\$1layer | Retorna `True` se a porcentagem de ReLUs inativas em uma camada for maior que `threshold_layer`. Retorna `False` se a porcentagem de ReLUs inativas em uma camada for menor que `threshold_layer`. **Opcional** Valores válidos: Flutuante Valores padrão: `50.0` (em porcentagem) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.dead_relu(),
rule_parameters={
"tensor_regex": ".*relu_output|.*ReLU_output",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex: ".*relu_output|.*ReLU_output",
"save_interval": "500"
}
)
]
)
]
```
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
**nota**
Essa regra não está disponível para o algoritmo XGBoost.
## ExplodingTensor
Essa regra detecta se os tensores emitidos durante o treinamento têm valores não finitos, infinitos ou NaN (que não é um número). Se um valor não finito for detectado, a regra retornará `True`.
Descrições de parâmetros para a regra ExplodingTensor
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: string Valor padrão: `None` |
| tensor\$1regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: string Valor padrão: `None` |
| only\$1nan | `True` para monitorar os tensores `base_trial` apenas para valores `NaN` e não para infinito. `False` para tratar ambos `NaN` e infinito como valores explosivos e para monitorar para ambos. **Opcional** Valor padrão: `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.exploding_tensor(),
rule_parameters={
"tensor_regex": ".*gradient",
"only_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
**nota**
Essa regra não está disponível para o algoritmo XGBoost.
## PoorWeightInitialization
Essa regra detecta se os parâmetros do modelo foram inicializados incorretamente.
Uma inicialização correta quebra a simetria dos pesos e dos gradientes em uma rede neural e mantém variações de ativação proporcionais nas camadas. Caso contrário, a rede neural não aprende de maneira eficaz. Inicializadores como Xavier visam manter a variação constante em todas as ativações, o que é especialmente relevante para o treinamento de redes neurais muito profundas. Uma inicialização muito pequena pode levar ao desaparecimento de gradientes. Uma inicialização muito grande pode levar à explosão de gradientes. Essa regra verifica a variação das entradas de ativação nas camadas, a distribuição de gradientes e a convergência de perda para as etapas iniciais a fim de determinar se uma rede neural foi inicializada incorretamente.
Descrições de parâmetros da regra de PoorWeightInitialization
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| activation\$1inputs\$1regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: string Valor padrão: `".*relu_input"` |
| threshold | Se a proporção entre variação mínima e máxima de pesos por camada exceder o `threshold` em uma etapa, a regra retornará `True`. **Opcional** Valores válidos: Flutuante Valor padrão: `10.0` |
| distribution\$1range | Se a diferença mínima entre os 5º e 95º percentis da distribuição de gradientes for menor que o `distribution_range`, a regra retornará `True`. **Opcional** Valores válidos: Flutuante Valor padrão: `0.001` |
| patience | O número de passos a aguardar até que a perda não seja mais decrescente. **Opcional** Valores válidos: inteiro Valor padrão: `5` |
| steps | O número de etapas que essa regra analisa. Normalmente, você precisa verificar apenas as primeiras iterações. **Opcional** Valores válidos: Flutuante Valor padrão: `10` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.poor_weight_initialization(),
rule_parameters={
"activation_inputs_regex": ".*relu_input|.*ReLU_input",
"threshold": "10.0",
"distribution_range": "0.001",
"patience": "5",
"steps": "10"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex": ".*relu_input|.*ReLU_input",
"save_interval": "500"
}
)
]
)
]
```
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
**nota**
Essa regra não está disponível para o algoritmo XGBoost.
## SaturatedActivation
Essa regra detecta se as camadas de ativação de tanh (tangente hiperbólica) e sigmoide estão ficando saturadas. Uma camada de ativação fica saturada quando a entrada da camada está próxima do máximo ou do mínimo da função de ativação. O mínimo e máximo das funções de ativação tanh e sigmoide são definidos pelos seus respectivos valores `min_threshold` e `max_thresholds`. Se a atividade de um nó cair abaixo da porcentagem de `threshold_inactivity`, ele será considerada saturado. Se mais de um percentual de `threshold_layer` dos nós estiverem saturados, a regra retornará `True`.
Descrições de parâmetros da regra SaturatedActivation
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| tensor\$1regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: string Valor padrão: `".*tanh_input\|.*sigmoid_input".` |
| threshold\$1tanh\$1min | Os limites mínimo e máximo que definem os extremos da entrada para uma função de ativação tanh, definidos como: `(min_threshold, max_threshold)`. Os valores padrão são determinados com base em um limite de gradientes desaparecendo de 0,0000001. **Opcional** Valores válidos: Flutuante Valores padrão: `-9.4999` |
| threshold\$1tanh\$1max | Os limites mínimo e máximo que definem os extremos da entrada para uma função de ativação tanh, definidos como: `(min_threshold, max_threshold)`. Os valores padrão são determinados com base em um limite de gradientes desaparecendo de 0,0000001. **Opcional** Valores válidos: Flutuante Valores padrão: `9.4999` |
| threshold\$1sigmoid\$1min | Os limites mínimo e máximo que definem os extremos da entrada para uma função de ativação sigmoide, definidos como: `(min_threshold, max_threshold)`. Os valores padrão são determinados com base em um limite de gradientes desaparecendo de 0,0000001. **Opcional** Valores válidos: Flutuante Valores padrão: `-23` |
| threshold\$1sigmoid\$1max | Os limites mínimo e máximo que definem os extremos da entrada para uma função de ativação sigmoide, definidos como: `(min_threshold, max_threshold)`. Os valores padrão são determinados com base em um limite de gradientes desaparecendo de 0,0000001. **Opcional** Valores válidos: Flutuante Valores padrão: `16.99999` |
| threshold\$1inactivity | A porcentagem de inatividade abaixo da qual a camada de ativação é considerada saturada. A ativação pode estar ativa no início de um teste e, depois, lentamente tornar-se menos ativa durante o processo de treinamento. **Opcional** Valores válidos: Flutuante Valores padrão: `1.0` |
| threshold\$1layer | Retornará `True` se o número de ativações saturadas em uma camada for maior que a porcentagem de `threshold_layer`. Retornará `False` se o número de ativações saturadas em uma camada for menor que a porcentagem de `threshold_layer`. **Opcional** Valores válidos: Flutuante Valores padrão: `50.0` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.saturated_activation(),
rule_parameters={
"tensor_regex": ".*tanh_input|.*sigmoid_input",
"threshold_tanh_min": "-9.4999",
"threshold_tanh_max": "9.4999",
"threshold_sigmoid_min": "-23",
"threshold_sigmoid_max": "16.99999",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_activations_collection",
parameters={
"include_regex": ".*tanh_input|.*sigmoid_input"
"save_interval": "500"
}
)
]
)
]
```
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
**nota**
Essa regra não está disponível para o algoritmo XGBoost.
## VanishingGradient
Essa regra detecta se os gradientes em um teste se tornam extremamente pequenos ou caem para uma magnitude zero. Se a média dos valores absolutos dos gradientes cair abaixo de um `threshold` especificado, a regra retornará `True`.
Descrições de parâmetros da regra de VanishingGradient
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| threshold | O valor no qual determina-se que o gradiente está desaparecendo.**Opcional**Valores válidos: FlutuanteValor padrão: `0.0000001`. |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.vanishing_gradient(),
rule_parameters={
"threshold": "0.0000001"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
**nota**
Essa regra não está disponível para o algoritmo XGBoost.
## WeightUpdateRatio
Essa regra mantém o controle da proporção de atualizações com relação a pesos durante o treinamento e detecta se essa proporção fica muito grande ou muito pequena. Se a proporção de atualizações com relação a pesos for maior do que o `large_threshold value` ou se essa proporção for menor que `small_threshold`, a regra retornará `True`.
As condições de treinamento são melhores quando as atualizações são proporcionais aos gradientes. As atualizações excessivamente grandes podem afastar os pesos dos valores ideais, e as atualizações muito pequenas resultam em uma convergência muito lenta. Essa regra requer que os pesos estejam disponíveis para duas etapas consecutivas, e `train.save_interval` precisa ser definido como igual a `num_steps`.
Descrições de parâmetros da regra WeightUpdateRatio
| Nome do parâmetro, | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| num\$1steps | O número de etapas que a regra verifica para determinar se o tensor foi alterado. O número de etapas com as quais você deseja comparar as proporções de peso. Se você não transmitir nenhum valor, a regra será executada por padrão em relação à etapa atual e à etapa salva imediatamente antes. Se você substituir o padrão transmitindo um valor para esse parâmetro, a comparação será feita entre pesos na etapa `s` e em uma etapa `>= s - num_steps`. **Opcional** Valores válidos: inteiro Valor padrão: `None` |
| large\$1threshold | O valor máximo que a proporção de atualizações em relação ao peso pode ter antes que a regra retorne `True`. **Opcional** Valores válidos: Flutuante Valor padrão: `10.0` |
| small\$1threshold | O valor mínimo que a proporção de atualizações com relação ao peso pode ter, abaixo do qual a regra retorna `True`. **Opcional** Valores válidos: Flutuante Valor padrão: `0.00000001` |
| epsilon | Uma pequena constante usada para garantir que o Debugger não divida por zero ao calcular as atualizações de proporção do peso. **Opcional** Valores válidos: Flutuante Valor padrão: `0.000000001` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.weight_update_ratio(),
rule_parameters={
"num_steps": "100",
"large_threshold": "10.0",
"small_threshold": "0.00000001",
"epsilon": "0.000000001"
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"train.save_interval": "100"
}
)
]
)
]
```
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
**nota**
Essa regra não está disponível para o algoritmo XGBoost.
## AllZero
Essa regra detecta se todos ou uma porcentagem especificada dos valores dos tensores são zero.
Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost. É necessário especificar o parâmetro `collection_names` ou `tensor_regex`. Se ambos os parâmetros forem especificados, a regra inspecionará a união de tensores de ambos os conjuntos.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros da regra AllZero
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `None` |
| tensor\$1regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `None` |
| threshold | Especifica a porcentagem de valores no tensor que precisa ser zero para que essa regra seja invocada. **Opcional** Valores válidos: Flutuante Valor padrão: 100 (em porcentagem) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.all_zero(),
rule_parameters={
"tensor_regex": ".*",
"threshold": "100"
},
collections_to_save=[
CollectionConfig(
name="all",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## ClassImbalance
Essa regra mede os desequilíbrios de amostragem entre classes e lança erros se o desequilíbrio exceder um limite ou se ocorrerem muitas predições erradas para classes sub-representadas como resultado do desequilíbrio.
Os modelos de classificação exigem classes bem equilibradas no conjunto de dados de treinamento ou uma ponderação/amostragem adequada das classes durante o treinamento. A regra executa as seguintes verificações:
+ Ela conta as ocorrências por classe. Se a proporção do número de amostras entre a menor e a maior classe for maior do que o `threshold_imbalance`, será lançado um erro.
+ Ela verifica a precisão de predição por classe. Se a reamostragem ou a ponderação não tiver sido aplicada corretamente, o modelo poderá atingir alta precisão para a classe com muitas amostras de treinamento, mas baixa precisão para as classes com poucas amostras de treinamento. Se uma fração de predições erradas de determinada classe estiver acima de `threshold_misprediction`, será lançado um erro.
Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros da regra ClassImbalance
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| threshold\$1imbalance | O desequilíbrio aceitável entre o número de amostras da classe menor e da classe maior. Se esse valor do limite for excedido, será lançado um erro. **Opcional** Valores válidos: Flutuante Valor padrão: `10` |
| threshold\$1misprediction | Um limite da fração de predições incorretas permitidas para cada classe. Se esse limite for excedido, será lançado um erro. As classes sub-representadas têm maior risco de ultrapassar esse limite. **Opcional** Valores válidos: Flutuante Valor padrão: `0.7` |
| samples | O número de rótulos que precisam ser processados antes de um desequilíbrio ser avaliado. A regra pode não ser acionada até que tenha visto amostras suficientes em várias etapas. Quanto mais classes o conjunto de dados tiver, maior será o número de `sample`. **Opcional** Valores válidos: inteiro Valor padrão: `500` (supondo um conjunto de dados como MNIST com 10 classes) |
| argmax | Se `True`, [np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) será aplicado ao tensor da predição. Obrigatório quando você tem um vetor de probabilidades para cada classe. Ele é usado para determinar qual classe tem a maior probabilidade. **Condicional** Valores válidos: booleano Valor padrão: `False` |
| labels\$1regex | O nome do tensor que contém os rótulos. **Opcional** Valores válidos: string Valor padrão: `".*labels"` |
| predictions\$1regex | O nome do tensor que contém as predições. **Opcional** Valores válidos: string Valor padrão: `".*predictions"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.class_imbalance(),
rule_parameters={
"threshold_imbalance": "10",
"threshold_misprediction": "0.7",
"samples": "500",
"argmax": "False",
"labels_regex": ".*labels",
"predictions_regex": ".*predictions"
},
collections_to_save=[
CollectionConfig(
name="custom_output_collection",
parameters={
"include_regex": ".*labels|.*predictions",
"save_interval": "500"
}
)
]
)
]
```
## LossNotDecreasing
Essa regra detecta quando a perda não está diminuindo em valor a uma taxa adequada. Essas perdas devem ser escalares.
Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost. É necessário especificar o parâmetro `collection_names` ou `tensor_regex`. Se ambos os parâmetros forem especificados, a regra inspecionará a união de tensores de ambos os conjuntos.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros da regra LossNotDecreasing
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `None` |
| tensor\$1regex | Uma lista de padrões regex que é usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `None` |
| use\$1losses\$1collection | Se definido como `True`, procura perdas na coleção chamada "losses" (perdas) quando a coleção está presente. **Opcional** Valores válidos: booleano Valor padrão: `True` |
| num\$1steps | O número mínimo de etapas após as quais a regra verifica se a perda diminuiu. A avaliação da regra acontece a cada `num_steps`. A regra compara a perda dessa etapa com a perda de uma etapa que está pelo menos `num_steps` atrás da etapa atual. Por exemplo, suponha que a perda está sendo salva a cada três etapas, mas `num_steps` está definido como 10. Na etapa 21, a perda dessa etapa é comparada com a perda da etapa 9. A próxima etapa em que a perda é verificada é a etapa 33, porque dez etapas após a etapa 21 é a etapa 31 e, na etapa 31 e etapa 32, a perda não é salva. **Opcional** Valores válidos: inteiro Valor padrão: `10` |
| diff\$1percent | A diferença percentual mínima pela qual a perda deve diminuir entre `num_steps`. **Opcional** Valores válidos: `0.0` < flutuante < `100` Valor padrão: `0.1` (em porcentagem) |
| increase\$1threshold\$1percent | A porcentagem do limite máximo em que a perda tem permissão para aumentar caso a perda esteja aumentando **Opcional** Valores válidos: `0` < flutuante < `100` Valor padrão: `5` (em porcentagem) |
| mode | O nome do modo do Debugger para consultar valores de tensor da verificação de regras. Se isso não for transmitido, a regra verificará em ordem por padrão para o `mode.EVAL`, depois `mode.TRAIN` e, então, `mode.GLOBAL`. **Opcional** Valores válidos: string (`EVAL`, `TRAIN` ou `GLOBAL`) Valor padrão: `GLOBAL` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.loss_not_decreasing(),
rule_parameters={
"tensor_regex": ".*",
"use_losses_collection": "True",
"num_steps": "10",
"diff_percent": "0.1",
"increase_threshold_percent": "5",
"mode": "GLOBAL"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## Overfit
Essa regra detecta se o modelo está sendo sobreajustado aos dados de treinamento comparando as perdas de validação e treinamento.
Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
**nota**
Uma maneira padrão de evitar o sobreajuste é regularizar o modelo.
Descrições de parâmetros da regra de Overfit
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| tensor\$1regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| start\$1step | A etapa a partir da qual começar a comparar a perda de validação e de treinamento. **Opcional** Valores válidos: inteiro Valor padrão: `0` |
| patience | O número de etapas para as quais o `ratio_threshold` tem permissão para exceder o valor definido antes que o modelo seja considerado sobreajuste. **Opcional** Valores válidos: inteiro Valor padrão: `1` |
| ratio\$1threshold | A proporção máxima da diferença entre a perda média de validação e a perda média de treinamento com relação à perda média de treinamento. Se esse limite for excedido para um número `patience` de etapas, o modelo estará sendo sobreajustado e a regra retornará `True`. **Opcional** Valores válidos: Flutuante Valor padrão: `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overfit(),
rule_parameters={
"tensor_regex": ".*",
"start_step": "0",
"patience": "1",
"ratio_threshold": "0.1"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
)
]
```
## Overtraining
Essa regra detecta se um modelo está sendo treinado em excesso. Depois de várias iterações de treinamento em um modelo bem-comportado (diminuição da perda de treinamento e validação), o modelo se aproxima de um mínimo da função de perda e não melhora mais. Se o modelo continuar treinando, pode acontecer que a perda de validação comece a aumentar, porque o modelo começa a apresentar sobreajuste. Essa regra define limites e condições para determinar se o modelo não está melhorando e evita problemas de sobreajuste devido ao excesso de treinamento.
Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
**nota**
O excesso de treinamento pode ser evitado pela interrupção precoce. Para obter informações sobre interrupção precoce, consulte [Interromper trabalhos de treinamento precocemente](automatic-model-tuning-early-stopping.md). Para obter um exemplo que mostra como usar o treinamento spot com o Debugger, consulte [Ativar o treinamento spot com o Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html).
Descrições de parâmetros da regra Overtraining
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| patience\$1train | O número de etapas a aguardar antes que se considere que a perda de treinamento não esteja mais melhorando. **Opcional** Valores válidos: inteiro Valor padrão: `5` |
| patience\$1validation | O número de etapas a aguardar antes que se considere que a perda de validação não esteja mais melhorando.**Opcional**Valores válidos: inteiroValor padrão: `10` |
| delta | O limite mínimo de quanto o erro deve melhorar antes de ser considerado como um novo ideal. **Opcional** Valores válidos: Flutuante Valor padrão: `0.01` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overtraining(),
rule_parameters={
"patience_train": "5",
"patience_validation": "10",
"delta": "0.01"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## SimilarAcrossRuns
Essa regra compara tensores coletados de um teste base com tensores de outro teste.
Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros da regra SimilarAcrossRuns
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| other\$1trials | Um nome de trabalho de treinamento concluído cujos tensores você deseja comparar com os tensores coletados do `base_trial` atual. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| tensor\$1regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.similar_across_runs(),
rule_parameters={
"other_trials": "",
"collection_names": "losses",
"tensor_regex": ".*"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## StalledTrainingRule
A StalledTrainingRule detecta se não há progresso no trabalho de treinamento e interrompe o trabalho de treinamento se a regra for acionada. Essa regra exige que os tensores sejam salvos periodicamente em um intervalo de tempo definido por seu parâmetro `threshold`. Essa regra continua monitorando novos tensores e, se nenhum novo tensor for emitido, a regra de intervalo de limite será acionada.
Descrições de parâmetros para a regra StalledTrainingRule
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| threshold | Um limite que define por quanto tempo em segundos a regra espera pela saída de um tensor até acionar um problema de treinamento interrompido. O valor padrão é de 1800 segundos. **Opcional** Valores válidos: inteiro Valor padrão: `1800` |
| stop\$1training\$1on\$1fire | Se definido como `True`, observa se o trabalho de treinamento básico gera tensores em “`threshold`” segundos. **Opcional** Valores válidos: booleano Valor padrão: `False` |
| training\$1job\$1name\$1prefix | O prefixo do nome do trabalho de treinamento básico. Se `stop_training_on_fire` for verdadeiro, a regra procura trabalhos de treinamento do SageMaker com esse prefixo na mesma conta. Se for encontrada uma inatividade, a regra executa uma ação `StopTrainingJob`. Observe que, se houver vários trabalhos encontrados com o mesmo prefixo, a regra ignora o encerramento. É importante que o prefixo seja definido de forma exclusiva para cada trabalho de treinamento. **Opcional** Valores válidos: string |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "1800",
"stop_training_on_fire": "True",
"training_job_name_prefix": ""
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TensorVariance
Essa regra detecta se você tem tensores com variâncias muito altas ou muito baixas. Variâncias muito altas ou muito baixas em um tensor podem levar à saturação de neurônios, o que reduz a capacidade de aprendizado da rede neural. A variância muito alta nos tensores também pode acabar resultando em tensores explosivos. Use essa regra para detectar esses problemas antecipadamente.
Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost. É necessário especificar o parâmetro `collection_names` ou `tensor_regex`. Se ambos os parâmetros forem especificados, a regra inspecionará a união de tensores de ambos os conjuntos.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros da regra TensorVariance
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| tensor\$1regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| max\$1threshold | O limite máximo da variância do tensor. **Opcional** Valores válidos: Flutuante Valor padrão: Nenhum |
| min\$1threshold | O limite mínimo da variância do tensor. **Opcional** Valores válidos: Flutuante Valor padrão: Nenhum |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tensor_variance(),
rule_parameters={
"collection_names": "weights",
"max_threshold": "10",
"min_threshold": "0.00001",
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## UnchangedTensor
Essa regra detecta se um tensor não está mais mudando ao longo das etapas.
Essa regra executa o método [numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html) para verificar se o tensor não está mudando.
Esta regra pode ser aplicada a uma das estruturas de aprendizado profundo compatíveis (TensorFlow, MXNet e PyTorch) ou ao algoritmo XGBoost. É necessário especificar o parâmetro `collection_names` ou `tensor_regex`. Se ambos os parâmetros forem especificados, a regra inspecionará a união de tensores de ambos os conjuntos.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros da regra UnchangedTensor
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| collection\$1names | A lista de nomes de coleção cujos tensores a regra inspeciona. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| tensor\$1regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: Nenhum |
| num\$1steps | O número de etapas que a regra verifica para determinar se o tensor foi alterado. Isso verifica os últimos `num_steps` que estão disponíveis. Eles não precisam ser consecutivos. Se `num_steps` for 2, na etapa s ela não necessariamente verifica s-1 e s. Se s-1 não estiver disponível, ela verifica a última etapa disponível com s. Nesse caso, ela verifica a última etapa disponível com a etapa atual. **Opcional** Valores válidos: inteiro Valor padrão: `3` |
| rtol | O parâmetro de tolerância relativa a ser transmitido para o método `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Opcional** Valores válidos: Flutuante Valor padrão: `1e-05` |
| atol | O parâmetro de tolerância absoluta a ser transmitido para o método `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Opcional** Valores válidos: Flutuante Valor padrão: `1e-08` |
| equal\$1nan | Se os NaNs devem ser comparados como iguais. Se `True`, os NaNs na matriz de entrada a são considerados iguais aos NaNs na matriz de entrada b na matriz de saída. Este parâmetro é transmitido para o método `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Opcional** Valores válidos: booleano Valor padrão: `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.unchanged_tensor(),
rule_parameters={
"collection_names": "losses",
"tensor_regex": "",
"num_steps": "3",
"rtol": "1e-05",
"atol": "1e-08",
"equal_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## CheckInputImages
Essa regra verifica se as imagens de entrada foram normalizadas corretamente. Especificamente, ela detecta se a média dos dados de amostra difere de zero em mais de um valor limite. Muitos modelos de visão computacional exigem que os dados de entrada tenham uma média zero e variação de unidade.
Esta regra é aplicável a aplicações de aprendizado profundo.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros da regra CheckInputImages
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| threshold\$1mean | Um limite que define por quanto a média dos dados de entrada pode ser diferente de 0. **Opcional** Valores válidos: Flutuante Valor padrão: `0.2` |
| threshold\$1samples | O número de imagens que precisam ser amostradas antes que um erro possa ser lançado. Se o valor for muito baixo, a estimativa da média do conjunto de dados será imprecisa. **Opcional** Valores válidos: inteiro Valor padrão: `500` |
| regex | O nome do tensor dos dados de entrada. **Opcional** Valores válidos: string Valor padrão: `".*hybridsequential0_input_0"` (o nome do tensor de entrada para modelos do Apache MXNet usando HybridSequential) |
| channel | A posição do canal de cor na matriz de forma do tensor de entrada. **Opcional** Valores válidos: inteiro Valor padrão: `1` (por exemplo, o MXNet espera dados de entrada na forma de (tamanho\$1do\$1lote, canal, altura, largura)) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.check_input_images(),
rule_parameters={
"threshold_mean": "0.2",
"threshold_samples": "500",
"regex": ".*hybridsequential0_input_0",
"channel": "1"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*hybridsequential0_input_0",
"save_interval": "500"
}
)
]
)
]
```
## NLPSequenceRatio
Essa regra calcula a proporção de tokens específicos, dado o resto da sequência de entrada que é útil para otimizar o desempenho. Por exemplo, é possível calcular a porcentagem de tokens de fim de sentença (EOS) de preenchimento na sequência de entrada. Se o número de tokens de EOS for muito alto, deverá ser executada uma estratégia de armazenamento bucketing alternativa. Também é possível calcular a porcentagem de tokens desconhecidos na sequência de entrada. Se o número de palavras desconhecidas for muito alto, poderá ser usado um vocabulário alternativo.
Esta regra é aplicável a aplicações de aprendizado profundo.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros da regra NLPSequenceRatio
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| tensor\$1regex | Uma lista de padrões regex usada para restringir essa comparação a tensores de valor escalar específicos. A regra inspeciona apenas os tensores que correspondem aos padrões regex especificados na lista. Se nenhum padrão for transmitido, a regra comparará todos os tensores reunidos nos testes por padrão. Somente tensores com valor escalar podem ser combinados. **Opcional** Valores válidos: lista de strings ou uma string separada por vírgulas Valor padrão: `".*embedding0_input_0"` (supondo uma incorporação como a camada inicial da rede) |
| token\$1values | Uma string de uma lista dos valores numéricos dos tokens. Por exemplo, "3, 0". **Opcional** Valores válidos: string de valores numéricos separados por vírgulas Valor padrão: `0` |
| token\$1thresholds\$1percent | Uma string de uma lista de limites (em porcentagens) que correspondem a cada um dos `token_values`. Por exemplo, "50,0; 50,0". **Opcional** Valores válidos: string de flutuações separadas por vírgulas Valor padrão: `"50"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.nlp_sequence_ratio(),
rule_parameters={
"tensor_regex": ".*embedding0_input_0",
"token_values": "0",
"token_thresholds_percent": "50"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*embedding0_input_0"
}
)
]
)
]
```
## Confusion
Essa regra avalia a qualidade de uma matriz de confusão para um problema de classificação.
Ela cria uma matriz de tamanho `category_no*category_no` e a preenche com dados de pares (`labels`, `predictions`). Para cada par (`labels`, `predictions`), a contagem em `confusion[labels][predictions]` é incrementada em 1. Quando a matriz é totalmente preenchida, a proporção de dados de valores na diagonal e de valores fora da diagonal são avaliados da seguinte maneira:
+ Para elementos na diagonal: `confusion[i][i]/sum_j(confusion[j][j])>=min_diag`
+ Para elementos fora da diagonal: `confusion[j][i])/sum_j(confusion[j][i])<=max_off_diag`
Essa regra pode ser aplicada ao algoritmo XGBoost.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros da regra Confusion
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| category\$1no | O número de categorias. **Opcional** Valores válidos: inteiro ≥2 Valor padrão: `"None"` |
| labels | A coleção de tensores `labels` ou um vetor 1-d de rótulos verdadeiros. **Opcional** Valores válidos: string Valor padrão: `"labels"` |
| predictions | A coleção de tensores `predictions` ou um vetor 1-d de rótulos estimados. **Opcional** Valores válidos: string Valor padrão: `"predictions"` |
| labels\$1collection | A regra inspeciona os tensores nesta coleção para `labels`. **Opcional** Valores válidos: string Valor padrão: `"labels"` |
| predictions\$1collection | A regra inspeciona os tensores nesta coleção para `predictions`. **Opcional** Valores válidos: string Valor padrão: `"predictions"` |
| min\$1diag | O limite mínimo da proporção de dados na diagonal. **Opcional** Valores válidos: `0`≤flutuante≤`1` Valor padrão: `0.9` |
| max\$1off\$1diag | O limite máximo da proporção de dados fora da diagonal. **Opcional** Valores válidos: `0`≤flutuante≤`1` Valor padrão: `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.confusion(),
rule_parameters={
"category_no": "10",
"labels": "labels",
"predictions": "predictions",
"labels_collection": "labels",
"predictions_collection": "predictions",
"min_diag": "0.9",
"max_off_diag": "0.1"
},
collections_to_save=[
CollectionConfig(
name="labels",
parameters={
"save_interval": "500"
}
),
CollectionConfig(
name="predictions",
parameters={
"include_regex": "500"
}
)
]
)
]
```
**nota**
Essa regra inferirá valores padrão para os parâmetros opcionais se seus valores não forem especificados.
## FeatureImportanceOverweight
Essa regra acumula os pesos dos n maiores valores de importância do atributo por etapa e garante que eles não excedam o limite. Por exemplo, você pode definir o limite para que os três principais atributos não suportem mais de 80% dos pesos totais do modelo.
Essa regra é válida apenas para o algoritmo XGBoost.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros para a regra FeatureImportanceOverweight
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| threshold | Define o limite para a proporção da soma cumulativa dos `n` maiores atributos. O número `n` é definido pelo parâmetro `nfeatures`. **Opcional** Valores válidos: Flutuante Valor padrão: `0.8` |
| nfeatures | O número dos maiores atributos. **Opcional** Valores válidos: inteiro Valor padrão: `3` |
| tensor\$1regex | A expressão regular (regex) do tensor nomeia a regra a ser analisada. **Opcional** Valores válidos: string Valor padrão: `".*feature_importance/weight"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.feature_importance_overweight(),
rule_parameters={
"threshold": "0.8",
"nfeatures": "3",
"tensor_regex": ".*feature_importance/weight"
},
collections_to_save=[
CollectionConfig(
name="feature_importance",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TreeDepth
Essa regra mede a profundidade das árvores em um modelo do XGBoost. O XGBoost rejeita divisões se elas não melhoram a perda. Isso regulariza o treinamento. Como resultado, a árvore pode não crescer tão profundamente como definido no parâmetro `depth`.
Essa regra é válida apenas para o algoritmo XGBoost.
Para obter um exemplo de como configurar e implantar uma regra interna, consulte [Configurar regras integradas do Depurador](use-debugger-built-in-rules.md).
Descrições de parâmetros da regra TreeDepth
| Nome do parâmetro | Descrição |
| --- | --- |
| base\$1trial | O nome do trabalho de treinamento de teste básico. Esse parâmetro é definido automaticamente para o trabalho de treinamento atual pelo Amazon SageMaker Debugger. **Obrigatório** Valores válidos: string |
| depth | A profundidade da árvore. A profundidade da árvore é obtida calculando o logaritmo base 2 do ID do maior nó. **Opcional** Valores válidos: Flutuante Valor padrão: `4` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tree_depth(),
rule_parameters={
"depth": "4"
},
collections_to_save=[
CollectionConfig(
name="tree",
parameters={
"save_interval": "500"
}
)
]
)
]
```
# Criação de regras personalizadas usando a biblioteca de cliente do Depurador
Você pode criar regras personalizadas para monitorar seu trabalho de treinamento usando a regra Debugger APIs e a [biblioteca `smdebug` Python](https://github.com/awslabs/sagemaker-debugger/) de código aberto que fornecem ferramentas para criar seus próprios contêineres de regras.
## Pré-requisitos para criação de regra personalizada
Para criar regras personalizadas do Debugger, você precisa dos seguintes pré-requisitos:
+ [SageMaker Regra do depurador. API personalizada](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule.custom)
+ [A biblioteca de cliente de código aberto smdebug](https://github.com/awslabs/sagemaker-debugger/)
+ Seu próprio script de regras personalizadas em Python
+ [Imagem do Amazon SageMaker Debugger URIs para avaliadores de regras personalizadas](debugger-reference.md#debuger-custom-rule-registry-ids)
**Topics**
+ [Pré-requisitos para criação de regra personalizada](#debugger-custom-rules-prerequisite)
+ [Use a biblioteca de cliente do `smdebug` para criar regra personalizada na forma de um script Python](debugger-custom-rules-python-script.md)
+ [Use o Debugger APIs para executar suas próprias regras personalizadas](debugger-custom-rules-python-sdk.md)
# Use a biblioteca de cliente do `smdebug` para criar regra personalizada na forma de um script Python
A API de regras `smdebug` fornece uma interface para configurar suas próprias regras personalizadas. O script Python a seguir é uma amostra de como criar uma regra personalizada,`CustomGradientRule`. Este tutorial de regra personalizada observa se os gradientes estão ficando muito grandes e define o limite padrão como 10. A regra personalizada faz um teste básico criado por um estimador de SageMaker IA quando ele inicia o trabalho de treinamento.
```
from smdebug.rules.rule import Rule
class CustomGradientRule(Rule):
def __init__(self, base_trial, threshold=10.0):
super().__init__(base_trial)
self.threshold = float(threshold)
def invoke_at_step(self, step):
for tname in self.base_trial.tensor_names(collection="gradients"):
t = self.base_trial.tensor(tname)
abs_mean = t.reduction_value(step, "mean", abs=True)
if abs_mean > self.threshold:
return True
return False
```
Você pode adicionar várias classes de regras personalizadas quantas quiser no mesmo script Python e implantá-las em qualquer teste de trabalho de treinamento criando objetos de regras personalizados na seção a seguir.
# Use o Debugger APIs para executar suas próprias regras personalizadas
O exemplo de código a seguir mostra como configurar uma regra personalizada com o SDK do [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Este exemplo pressupõe que o script de regras personalizadas que você criou na etapa anterior esteja localizado em '*path/to/my\$1custom\$1rule.py*'.
```
from sagemaker.debugger import Rule, CollectionConfig
custom_rule = Rule.custom(
name='MyCustomRule',
image_uri='759209512951.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rule-evaluator:latest',
instance_type='ml.t3.medium',
source='path/to/my_custom_rule.py',
rule_to_invoke='CustomGradientRule',
collections_to_save=[CollectionConfig("gradients")],
rule_parameters={"threshold": "20.0"}
)
```
A lista a seguir explica os argumentos da API Debugger `Rule.custom`.
+ `name` (str): especifique um nome de regra personalizado conforme desejar.
+ `image_uri` (str): essa é a imagem do contêiner que tem a lógica de entender sua regra personalizada. Ele fornece e avalia as coleções de tensores especificadas que você salva no trabalho de treinamento. Você pode encontrar a lista de imagens de avaliadores de regras de SageMaker IA de [Imagem do Amazon SageMaker Debugger URIs para avaliadores de regras personalizadas](debugger-reference.md#debuger-custom-rule-registry-ids) código aberto em.
+ `instance_type` (str): você precisa especificar uma instância para criar um contêiner docker de regras. Isso ativa a instância paralelamente a um contêiner de treinamento.
+ `source` (str): esse é o caminho local ou o URI do Amazon S3 para seu script de regras personalizado.
+ `rule_to_invoke`(str): Isso especifica a implementação específica da classe de regra em seu script de regra personalizado. SageMaker A IA suporta apenas uma regra a ser avaliada por vez em um trabalho de regra.
+ `collections_to_save` (str): isso especifica quais coleções de tensores você salvará para que a regra seja executada.
+ `rule_parameters` (dicionário): Isso aceita entradas de parâmetros em formato de dicionário. Você pode ajustar os parâmetros que você configurou no script de regra personalizada.
Depois de configurar o `custom_rule` objeto, você pode usá-lo para criar um estimador de SageMaker IA para qualquer trabalho de treinamento. Especifique o `entry_point` em seu script de treinamento. Não é necessário fazer nenhuma alteração no script de treinamento.
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
role=sagemaker.get_execution_role(),
base_job_name='smdebug-custom-rule-demo-tf-keras',
entry_point='path/to/your_training_script.py'
train_instance_type='ml.p2.xlarge'
...
# debugger-specific arguments below
rules = [custom_rule]
)
estimator.fit()
```
Para obter mais variações e exemplos avançados do uso das regras personalizadas do Debugger, consulte os seguintes exemplos de cadernos:
+ [Monitore seu trabalho de treinamento com as regras personalizadas do Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_keras_custom_rule/tf-keras-custom-rule.html)
+ [PyTorch poda de modelo iterativo de e ResNet AlexNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_iterative_model_pruning)
+ [Acione CloudWatch eventos da Amazon usando as regras do Debugger para realizar uma ação com base no status do treinamento com TensorFlow](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_action_on_rule)
# 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()
```
# Configurar o Debugger usando a API SageMaker
Os tópicos anteriores se concentram no uso do Debugger por meio do Amazon SageMaker Python SDK, que é um invólucro e operações de API. AWS SDK para Python (Boto3) SageMaker Isso oferece uma experiência de alto nível de acesso às operações de SageMaker API da Amazon. Caso você precise configurar manualmente as operações de SageMaker API usando AWS Boto3 ou ( AWS Command Line Interface CLI) para outras SDKs, como Java, Go e C\$1\$1, esta seção aborda como configurar as seguintes operações de API de baixo nível.
**Topics**
+ [JSON (AWS CLI)](debugger-built-in-rules-api.CLI.md)
+ [SDK para Python (Boto3)](debugger-built-in-rules-api.Boto3.md)
# JSON (AWS CLI)
As regras integradas do Amazon SageMaker Debugger podem ser configuradas para um trabalho de treinamento usando os [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)objetos [DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html),, [DebugRuleConfiguration[ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html), e por meio da operação da SageMaker API de IA [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). Você precisa especificar o URI correto da imagem no `RuleEvaluatorImage` parâmetro, e os exemplos a seguir explicam como configurar as cadeias de caracteres JSON a serem solicitadas. [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)
O código a seguir mostra um modelo JSON completo para executar uma tarefa de treinamento com as configurações exigidas e as configurações do Debugger. Salve o modelo como um arquivo JSON em seu diretório de trabalho e execute o trabalho de treinamento usando a AWS CLI. Por exemplo, salve o código a seguir como `debugger-training-job-cli.json`.
**nota**
Certifique-se de usar as imagens de contêiner do Docker corretas. Para encontrar imagens de contêineres de aprendizado AWS profundo, consulte Imagens de [contêineres de aprendizado profundo disponíveis](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Para encontrar uma lista completa das imagens do Docker disponíveis para usar as regras do Debugger, consulte [Imagens do Docker para regras do Depurador](debugger-reference.md#debugger-docker-images-rules).
```
{
"TrainingJobName": "debugger-aws-cli-test",
"RoleArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-YYYYMMDDT123456",
"AlgorithmSpecification": {
// Specify a training Docker container image URI (Deep Learning Container or your own training container) to TrainingImage.
"TrainingImage": "763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.4.1-gpu-py37-cu110-ubuntu18.04",
"TrainingInputMode": "File",
"EnableSageMakerMetricsTimeSeries": false
},
"HyperParameters": {
"sagemaker_program": "entry_point/tf-hvd-train.py",
"sagemaker_submit_directory": "s3://sagemaker-us-west-2-111122223333/debugger-boto3-profiling-test/source.tar.gz"
},
"OutputDataConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/output"
},
"DebugHookConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/debug-output",
"CollectionConfigurations": [
{
"CollectionName": "losses",
"CollectionParameters" : {
"train.save_interval": "50"
}
}
]
},
"DebugRuleConfigurations": [
{
"RuleConfigurationName": "LossNotDecreasing",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {"rule_to_invoke": "LossNotDecreasing"}
}
],
"ProfilerConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/profiler-output",
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, \"MetricsRegex\": \".*\", }",
"DetailedProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, }",
"PythonProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, \"ProfilerName\": \"cprofile\", \"cProfileTimer\": \"total_time\"}",
"LocalPath": "/opt/ml/output/profiler/"
}
},
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {"rule_to_invoke": "ProfilerReport"}
}
],
"ResourceConfig": {
"InstanceType": "ml.p3.8xlarge",
"InstanceCount": 1,
"VolumeSizeInGB": 30
},
"StoppingCondition": {
"MaxRuntimeInSeconds": 86400
}
}
```
Depois de salvar o arquivo JSON, execute o seguinte comando em seu terminal: (Use `!` no início da linha se você usa o caderno Jupyter.)
```
aws sagemaker create-training-job --cli-input-json file://debugger-training-job-cli.json
```
## Para configurar uma regra do Debugger para depurar os parâmetros do modelo
Os exemplos de código a seguir mostram como configurar uma `VanishingGradient` regra integrada usando essa SageMaker API.
**Para habilitar o Debugger para coletar tensores de saída**
Especifique a configuração do hook do Debugger da seguinte forma:
```
"DebugHookConfig": {
"S3OutputPath": "s3:////debug-output",
"CollectionConfigurations": [
{
"CollectionName": "gradients",
"CollectionParameters" : {
"save_interval": "500"
}
}
]
}
```
Isso fará com que a tarefa de treinamento salve a coleção de tensores, `gradients`, a cada `save_interval` de 500 etapas. Para encontrar `CollectionName` os valores disponíveis, consulte [Debugger Built-in Collections na documentação](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections) da biblioteca *SMDebug cliente*. Para encontrar as chaves e valores de `CollectionParameters` parâmetros disponíveis, consulte a [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)classe na documentação do *SDK do SageMaker Python*.
**Para habilitar as regras do Debugger para depurar os tensores de saída**
O exemplo de API `DebugRuleConfigurations` a seguir mostra como executar a regra integrada do`VanishingGradient` na coleção `gradients` salva.
```
"DebugRuleConfigurations": [
{
"RuleConfigurationName": "VanishingGradient",
"RuleEvaluatorImage": "503895931360.dkr.ecr.us-east-1.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "VanishingGradient",
"threshold": "20.0"
}
}
]
```
Com uma configuração como a desse exemplo, o Debugger inicia uma tarefa de avaliação de regra para a tarefa de treinamento usando a regra `VanishingGradient` na coleção do tensor de `gradients`. Para encontrar uma lista completa das imagens do Docker disponíveis para usar as regras do Debugger, consulte [Imagens do Docker para regras do Depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar os pares de valores-chave para `RuleParameters`, consulte [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
## Para configurar a regra integrada do Debugger para criar perfis do sistema e métricas do framework
O código de exemplo a seguir mostra como especificar a operação da ProfilerConfig API para permitir a coleta de métricas do sistema e da estrutura.
**Para habilitar a criação de perfil do Debugger para coletar métricas do sistema e da estrutura**
------
#### [ Target Step ]
```
"ProfilerConfig": {
// Optional. Path to an S3 bucket to save profiling outputs
"S3OutputPath": "s3:////profiler-output",
// Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3, \"MetricsRegex\": \".*\" }",
"DetailedProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3 }",
// For PythonProfilingConfig,
// available ProfilerName options: cProfile, Pyinstrument
// available cProfileTimer options only when using cProfile: cpu, off_cpu, total_time
"PythonProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3, \"ProfilerName\": \"cProfile\", \"cProfileTimer\": \"total_time\" }",
// Optional. Local path for profiling outputs
"LocalPath": "/opt/ml/output/profiler/"
}
}
```
------
#### [ Target Time Duration ]
```
"ProfilerConfig": {
// Optional. Path to an S3 bucket to save profiling outputs
"S3OutputPath": "s3:////profiler-output",
// Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10, \"MetricsRegex\": \".*\" }",
"DetailedProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10 }",
// For PythonProfilingConfig,
// available ProfilerName options: cProfile, Pyinstrument
// available cProfileTimer options only when using cProfile: cpu, off_cpu, total_time
"PythonProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10, \"ProfilerName\": \"cProfile\", \"cProfileTimer\": \"total_time\" }",
// Optional. Local path for profiling outputs
"LocalPath": "/opt/ml/output/profiler/"
}
}
```
------
**Para habilitar as regras do Debugger para criar perfil das métricas**
O código de exemplo a seguir mostra como configurar a regra `ProfilerReport`.
```
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "ProfilerReport",
"CPUBottleneck_cpu_threshold": "90",
"IOBottleneck_threshold": "90"
}
}
]
```
Para encontrar uma lista completa das imagens do Docker disponíveis para usar as regras do Debugger, consulte [Imagens do Docker para regras do Depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar os pares de valores-chave para `RuleParameters`, consulte [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
## Atualização da configuração de perfil do Depurador com API `UpdateTrainingJob`
A configuração do perfil do depurador pode ser atualizada enquanto seu trabalho de treinamento está em execução usando a operação da API. [UpdateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html) Configure novos [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)objetos [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)e especifique o nome do trabalho de treinamento para o `TrainingJobName` parâmetro.
```
{
"ProfilerConfig": {
"DisableProfiler": boolean,
"ProfilingIntervalInMilliseconds": number,
"ProfilingParameters": {
"string" : "string"
}
},
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "string",
"RuleEvaluatorImage": "string",
"RuleParameters": {
"string" : "string"
}
}
],
"TrainingJobName": "your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS"
}
```
## Adicione a configuração de regra personalizada do Depurador à API `CreateTrainingJob`
Uma regra personalizada pode ser configurada para um trabalho de treinamento usando os [ DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)objetos [ DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)e na operação da [ CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API. O exemplo de código a seguir mostra como configurar uma `ImproperActivation` regra personalizada escrita com a biblioteca *smdebug* usando essa operação de SageMaker API. Este exemplo pressupõe que você tenha escrito a regra personalizada no arquivo *custom\$1rules.py* e o tenha carregado em um bucket do Amazon S3. O exemplo fornece imagens pré-criadas do Docker que podem ser usadas para executar as regras personalizadas. Elas estão listadas em [Imagem do Amazon SageMaker Debugger URIs para avaliadores de regras personalizadas](debugger-reference.md#debuger-custom-rule-registry-ids). Você especifica o endereço de registro de URL para a imagem pré-criada do Docker no parâmetro `RuleEvaluatorImage`.
```
"DebugHookConfig": {
"S3OutputPath": "s3:////debug-output",
"CollectionConfigurations": [
{
"CollectionName": "relu_activations",
"CollectionParameters": {
"include_regex": "relu",
"save_interval": "500",
"end_step": "5000"
}
}
]
},
"DebugRulesConfigurations": [
{
"RuleConfigurationName": "improper_activation_job",
"RuleEvaluatorImage": "552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest",
"InstanceType": "ml.c4.xlarge",
"VolumeSizeInGB": 400,
"RuleParameters": {
"source_s3_uri": "s3://bucket/custom_rules.py",
"rule_to_invoke": "ImproperActivation",
"collection_names": "relu_activations"
}
}
]
```
Para encontrar uma lista completa das imagens do Docker disponíveis para usar as regras do Debugger, consulte [Imagens do Docker para regras do Depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar os pares de valores-chave para `RuleParameters`, consulte [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
# SDK para Python (Boto3)
As regras integradas do Amazon SageMaker Debugger podem ser configuradas para um trabalho de treinamento usando a [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job)função do cliente AWS SageMaker Boto3 AI. Você precisa especificar o URI da imagem correto no parâmetro `RuleEvaluatorImage` e os exemplos a seguir demonstram como configurar o corpo da solicitação para a função [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job).
O código a seguir mostra um exemplo completo de como configurar o Debugger para o corpo da `create_training_job()` solicitação e iniciar um trabalho de treinamento em`us-west-2`, supondo que um script `entry_point/train.py` de treinamento seja preparado usando. TensorFlow Para encontrar um end-to-end exemplo de notebook, consulte [Profiling TensorFlow Multi GPU Multi Node Training Job with Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_profiling/tf-resnet-profiling-multi-gpu-multi-node-boto3.html) (Boto3).
**nota**
Certifique-se de usar as imagens de contêiner do Docker corretas. Para encontrar imagens de contêineres de aprendizado AWS profundo [disponíveis, consulte Imagens de contêineres de aprendizado profundo disponíveis](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Para encontrar uma lista completa das imagens do Docker disponíveis para usar as regras do Debugger, consulte [Imagens do Docker para regras do Depurador](debugger-reference.md#debugger-docker-images-rules).
```
import sagemaker, boto3
import datetime, tarfile
# Start setting up a SageMaker session and a Boto3 SageMaker client
session = sagemaker.Session()
region = session.boto_region_name
bucket = session.default_bucket()
# Upload a training script to a default Amazon S3 bucket of the current SageMaker session
source = 'source.tar.gz'
project = 'debugger-boto3-test'
tar = tarfile.open(source, 'w:gz')
tar.add ('entry_point/train.py') # Specify the directory and name of your training script
tar.close()
s3 = boto3.client('s3')
s3.upload_file(source, bucket, project+'/'+source)
# Set up a Boto3 session client for SageMaker
sm = boto3.Session(region_name=region).client("sagemaker")
# Start a training job
sm.create_training_job(
TrainingJobName='debugger-boto3-'+datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S'),
HyperParameters={
'sagemaker_submit_directory': 's3://'+bucket+'/'+project+'/'+source,
'sagemaker_program': '/entry_point/train.py' # training scrip file location and name under the sagemaker_submit_directory
},
AlgorithmSpecification={
# Specify a training Docker container image URI (Deep Learning Container or your own training container) to TrainingImage.
'TrainingImage': '763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.4.1-gpu-py37-cu110-ubuntu18.04',
'TrainingInputMode': 'File',
'EnableSageMakerMetricsTimeSeries': False
},
RoleArn='arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20201014T161125',
OutputDataConfig={'S3OutputPath': 's3://'+bucket+'/'+project+'/output'},
ResourceConfig={
'InstanceType': 'ml.p3.8xlarge',
'InstanceCount': 1,
'VolumeSizeInGB': 30
},
StoppingCondition={
'MaxRuntimeInSeconds': 86400
},
DebugHookConfig={
'S3OutputPath': 's3://'+bucket+'/'+project+'/debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'losses',
'CollectionParameters' : {
'train.save_interval': '500',
'eval.save_interval': '50'
}
}
]
},
DebugRuleConfigurations=[
{
'RuleConfigurationName': 'LossNotDecreasing',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {'rule_to_invoke': 'LossNotDecreasing'}
}
],
ProfilerConfig={
'S3OutputPath': 's3://'+bucket+'/'+project+'/profiler-output',
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{"StartStep": 5, "NumSteps": 3, "MetricsRegex": ".*", }',
'DetailedProfilingConfig': '{"StartStep": 5, "NumSteps": 3, }',
'PythonProfilingConfig': '{"StartStep": 5, "NumSteps": 3, "ProfilerName": "cprofile", "cProfileTimer": "total_time"}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
},
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {'rule_to_invoke': 'ProfilerReport'}
}
]
)
```
## Para configurar uma regra do Debugger para depurar os parâmetros do modelo
Os exemplos de código a seguir mostram como configurar uma `VanishingGradient` regra integrada usando essa SageMaker API.
**Para habilitar o Debugger para coletar tensores de saída**
Especifique a configuração do hook do Debugger da seguinte forma:
```
DebugHookConfig={
'S3OutputPath': 's3:////debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'gradients',
'CollectionParameters' : {
'train.save_interval': '500',
'eval.save_interval': '50'
}
}
]
}
```
Isso fará com que a tarefa de treinamento salve uma coleção, `gradients`, a cada `save_interval` de 500 etapas. Para encontrar `CollectionName` os valores disponíveis, consulte [Debugger Built-in Collections na documentação](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections) da biblioteca *SMDebug cliente*. Para encontrar as chaves e valores de `CollectionParameters` parâmetros disponíveis, consulte a [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)classe na documentação do *SDK do SageMaker Python*.
**Para habilitar as regras do Debugger para depurar os tensores de saída**
O exemplo de API `DebugRuleConfigurations` a seguir mostra como executar a regra integrada do`VanishingGradient` na coleção `gradients` salva.
```
DebugRuleConfigurations=[
{
'RuleConfigurationName': 'VanishingGradient',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'VanishingGradient',
'threshold': '20.0'
}
}
]
```
Com uma configuração como a desse exemplo, o Debugger inicia uma tarefa de avaliação de regra para a tarefa de treinamento usando a regra `VanishingGradient` na coleção do tensor de `gradients`. Para encontrar uma lista completa das imagens do Docker disponíveis para usar as regras do Debugger, consulte [Imagens do Docker para regras do Depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar os pares de valores-chave para `RuleParameters`, consulte [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
## Para configurar a regra integrada do Debugger para criar perfis do sistema e métricas do framework
O código de exemplo a seguir mostra como especificar a operação da ProfilerConfig API para permitir a coleta de métricas do sistema e da estrutura.
**Para habilitar a criação de perfil do Debugger para coletar métricas do sistema e da estrutura**
------
#### [ Target Step ]
```
ProfilerConfig={
'S3OutputPath': 's3:////profiler-output', # Optional. Path to an S3 bucket to save profiling outputs
# Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3,
"MetricsRegex": ".*"
}',
'DetailedProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3
}',
'PythonProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3,
"ProfilerName": "cprofile", # Available options: cprofile, pyinstrument
"cProfileTimer": "total_time" # Include only when using cprofile. Available options: cpu, off_cpu, total_time
}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
}
```
------
#### [ Target Time Duration ]
```
ProfilerConfig={
'S3OutputPath': 's3:////profiler-output', # Optional. Path to an S3 bucket to save profiling outputs
# Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10,
"MetricsRegex": ".*"
}',
'DetailedProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10
}',
'PythonProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10,
"ProfilerName": "cprofile", # Available options: cprofile, pyinstrument
"cProfileTimer": "total_time" # Include only when using cprofile. Available options: cpu, off_cpu, total_time
}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
}
```
------
**Para habilitar as regras do Debugger para criar perfil das métricas**
O código de exemplo a seguir mostra como configurar a regra `ProfilerReport`.
```
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'ProfilerReport',
'CPUBottleneck_cpu_threshold': '90',
'IOBottleneck_threshold': '90'
}
}
]
```
Para encontrar uma lista completa das imagens do Docker disponíveis para usar as regras do Debugger, consulte [Imagens do Docker para regras do Depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar os pares de valores-chave para `RuleParameters`, consulte [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
## Atualizar a configuração de perfil do Debugger usando a operação de API `UpdateTrainingJob`
A configuração do perfil do depurador pode ser atualizada enquanto seu trabalho de treinamento está em execução usando a [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_training_job)função do cliente Boto3 AI. AWS SageMaker Configure novos [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)objetos [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)e especifique o nome do trabalho de treinamento para o `TrainingJobName` parâmetro.
```
ProfilerConfig={
'DisableProfiler': boolean,
'ProfilingIntervalInMilliseconds': number,
'ProfilingParameters': {
'string' : 'string'
}
},
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'string',
'RuleEvaluatorImage': 'string',
'RuleParameters': {
'string' : 'string'
}
}
],
TrainingJobName='your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS'
```
## Adicionar configuração de regra personalizada do Debugger à operação da API CreateTrainingJob
Uma regra personalizada pode ser configurada para um trabalho de treinamento usando os [ DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)objetos [ DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)e usando a função do [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job)cliente AWS Boto3 SageMaker AI. O exemplo de código a seguir mostra como configurar uma `ImproperActivation` regra personalizada escrita com a biblioteca *smdebug* usando essa operação de SageMaker API. Este exemplo pressupõe que você tenha escrito a regra personalizada no arquivo *custom\$1rules.py* e o tenha carregado em um bucket do Amazon S3. O exemplo fornece imagens pré-criadas do Docker que podem ser usadas para executar as regras personalizadas. Elas estão listadas em [Imagem do Amazon SageMaker Debugger URIs para avaliadores de regras personalizadas](debugger-reference.md#debuger-custom-rule-registry-ids). Você especifica o endereço de registro de URL para a imagem pré-criada do Docker no parâmetro `RuleEvaluatorImage`.
```
DebugHookConfig={
'S3OutputPath': 's3:////debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'relu_activations',
'CollectionParameters': {
'include_regex': 'relu',
'save_interval': '500',
'end_step': '5000'
}
}
]
},
DebugRulesConfigurations=[
{
'RuleConfigurationName': 'improper_activation_job',
'RuleEvaluatorImage': '552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest',
'InstanceType': 'ml.c4.xlarge',
'VolumeSizeInGB': 400,
'RuleParameters': {
'source_s3_uri': 's3://bucket/custom_rules.py',
'rule_to_invoke': 'ImproperActivation',
'collection_names': 'relu_activations'
}
}
]
```
Para encontrar uma lista completa das imagens do Docker disponíveis para usar as regras do Debugger, consulte [Imagens do Docker para regras do Depurador](debugger-reference.md#debugger-docker-images-rules). Para encontrar os pares de valores-chave para `RuleParameters`, consulte [Lista de regras integradas do Depurador](debugger-built-in-rules.md).
# Referências do Amazon SageMaker Debugger
Encontre mais informações e referências sobre o uso do Amazon SageMaker Debugger nos tópicos a seguir.
**Topics**
+ [SageMaker Depurador Amazon APIs](#debugger-apis)
+ [Imagens do Docker para regras do Depurador](#debugger-docker-images-rules)
+ [Exceções do Amazon SageMaker Debugger](#debugger-exceptions)
+ [Treinamento distribuído suportado pelo Amazon SageMaker Debugger](#debugger-considerations)
## SageMaker Depurador Amazon APIs
O Amazon SageMaker Debugger tem operações de API em vários locais que são usadas para implementar seu monitoramento e análise do treinamento de modelos.
O Amazon SageMaker Debugger também fornece o [SDK `sagemaker-debugger` Python](https://github.com/awslabs/sagemaker-debugger/tree/master/smdebug) de código aberto que é usado para configurar regras incorporadas, definir regras personalizadas e registrar ganchos para coletar dados de tensores de saída de trabalhos de treinamento.
O [Amazon SageMaker AI Python SDK é um SDK](https://sagemaker.readthedocs.io/en/stable/) de alto nível focado na experimentação de aprendizado de máquina. O SDK pode ser usado para implantar regras integradas ou personalizadas definidas com a biblioteca `SMDebug` Python para monitorar e analisar esses tensores SageMaker usando estimadores de IA.
O Debugger adicionou operações e tipos à SageMaker API da Amazon que permitem que a plataforma use o Debugger ao treinar um modelo e gerenciar a configuração de entradas e saídas.
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)e [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html)use o seguinte depurador APIs para configurar coleções de tensores, regras, imagens de regras e opções de criação de perfil:
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CollectionConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CollectionConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TensorBoardOutputConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TensorBoardOutputConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html) fornece uma descrição completa de um trabalho de treinamento, incluindo as seguintes configurações do Depurador e os status de avaliação de regras:
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleEvaluationStatus.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleEvaluationStatus.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleEvaluationStatus.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleEvaluationStatus.html)
As operações da API de configuração de regras usam a funcionalidade SageMaker Processing ao analisar o treinamento de um modelo. Para obter mais informações sobre SageMaker processamento, consulte[Cargas de trabalho de transformação de dados com processamento SageMaker](processing-job.md).
## Imagens do Docker para regras do Depurador
A Amazon SageMaker AI fornece dois conjuntos de imagens do Docker para regras: um conjunto para avaliar as regras fornecidas pela SageMaker IA (regras incorporadas) e um conjunto para avaliar as regras personalizadas fornecidas nos arquivos de origem do Python.
Se você usa o [SDK do Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), pode simplesmente usar as operações da API do Debugger de alto nível de SageMaker IA com as operações da API do SageMaker AI Estimator, sem precisar recuperar manualmente as imagens do Debugger Docker e configurar a API. `ConfigureTrainingJob`
Se você não estiver usando o SDK do SageMaker Python, precisará recuperar uma imagem base de contêiner pré-criada relevante para as regras do Debugger. O Amazon SageMaker Debugger fornece imagens pré-criadas do Docker para regras incorporadas e personalizadas, e as imagens são armazenadas no Amazon Elastic Container Registry (Amazon ECR). Para extrair uma imagem de um repositório Amazon ECR (ou enviar uma imagem para um), use a URL de registro do nome completo da imagem usando a `CreateTrainingJob` API. SageMaker O AI usa os seguintes padrões de URL para o endereço de registro da imagem do contêiner da regra do Debugger.
```
.dkr.ecr..amazonaws.com/:
```
Para obter o ID da conta em cada AWS região, o nome do repositório Amazon ECR e o valor da tag, consulte os tópicos a seguir.
**Topics**
+ [Imagem do Amazon SageMaker Debugger URIs para avaliadores de regras integrados](#debuger-built-in-registry-ids)
+ [Imagem do Amazon SageMaker Debugger URIs para avaliadores de regras personalizadas](#debuger-custom-rule-registry-ids)
### Imagem do Amazon SageMaker Debugger URIs para avaliadores de regras integrados
Use os seguintes valores para os componentes do registro das imagens que fornecem regras integradas URLs para o Amazon SageMaker Debugger. Para a conta IDs, consulte a tabela a seguir.
Nome do **repositório ECR**: sagemaker-debugger-rules
**Tag**: mais recente
**Exemplo de URL de registro completo**:
`904829902805.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rules:latest`
Conta IDs para imagens de contêiner de regras integradas por AWS região
| Região | account\$1id |
| --- | --- |
| af-south-1 | 314341159256 |
| ap-east-1 | 199566480951 |
| ap-northeast-1 | 430734990657 |
| ap-northeast-2 | 578805364391 |
| ap-south-1 | 904829902805 |
| ap-southeast-1 | 972752614525 |
| ap-southeast-2 | 184798709955 |
| ca-central-1 | 519511493484 |
| cn-north-1 | 618459771430 |
| cn-northwest-1 | 658757709296 |
| eu-central-1 | 482524230118 |
| eu-north-1 | 314864569078 |
| eu-south-1 | 563282790590 |
| eu-west-1 | 929884845733 |
| eu-west-2 | 250201462417 |
| eu-west-3 | 447278800020 |
| me-south-1 | 986000313247 |
| sa-east-1 | 818342061345 |
| us-east-1 | 503895931360 |
| us-east-2 | 915447279597 |
| us-west-1 | 685455198987 |
| us-west-2 | 895741380848 |
| us-gov-west-1 | 515509971035 |
### Imagem do Amazon SageMaker Debugger URIs para avaliadores de regras personalizadas
Use os valores a seguir para os componentes da URL de registro das imagens que fornecem avaliadores de regras personalizados para o Amazon SageMaker Debugger. Para a conta IDs, consulte a tabela a seguir.
Nome do **repositório ECR**: sagemaker-debugger-rule-evaluator
**Tag**: mais recente
**Exemplo de URL de registro completo**:
`552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest`
Conta IDs para imagens de contêiner de regras personalizadas por AWS região
| Região | account\$1id |
| --- | --- |
| af-south-1 | 515950693465 |
| ap-east-1 | 645844755771 |
| ap-northeast-1 | 670969264625 |
| ap-northeast-2 | 326368420253 |
| ap-south-1 | 552407032007 |
| ap-southeast-1 | 631532610101 |
| ap-southeast-2 | 445670767460 |
| ca-central-1 | 105842248657 |
| cn-north-1 | 617202126805 |
| cn-northwest-1 | 658559488188 |
| eu-central-1 | 691764027602 |
| eu-north-1 | 091235270104 |
| eu-south-1 | 335033873580 |
| eu-west-1 | 606966180310 |
| eu-west-2 | 074613877050 |
| eu-west-3 | 224335253976 |
| me-south-1 | 050406412588 |
| sa-east-1 | 466516958431 |
| us-east-1 | 864354269164 |
| us-east-2 | 840043622174 |
| us-west-1 | 952348334681 |
| us-west-2 | 759209512951 |
| us-gov-west-1 | 515361955729 |
## Exceções do Amazon SageMaker Debugger
O Amazon SageMaker Debugger foi projetado para estar ciente de que os tensores necessários para executar uma regra podem não estar disponíveis em todas as etapas. Como resultado, ele abre algumas exceções que permitem que você controle o que acontece quando um tensor está ausente. Essas exceções estão disponíveis no [módulo smdebug.exceptions](https://github.com/awslabs/sagemaker-debugger/blob/master/smdebug/exceptions.py). É possível importá-los da seguinte maneira:
```
from smdebug.exceptions import *
```
As seguintes exceções estão disponíveis:
+ `TensorUnavailableForStep`: O tensor solicitado não está disponível para a etapa. Isso pode significar que essa etapa pode não ser salva pelo hook, ou que essa etapa pode ter salvo alguns tensores, mas o tensor solicitado não faz parte deles. Observe que quando você vê essa exceção, isso significa que esse tensor pode nunca ficar disponível para essa etapa no futuro. Se o tensor tiver reduções salvas para a etapa, ele notificará que elas podem ser consultadas.
+ `TensorUnavailable`: Este tensor não está sendo salvo ou não foi salvo pela API de `smdebug`. Isso significa que esse tensor nunca é visto para nenhuma etapa na `smdebug`.
+ `StepUnavailable`: A etapa não foi salva e o Depurador não tem os dados da etapa.
+ `StepNotYetAvailable`: A etapa ainda não foi vista por `smdebug`. Pode estar disponível no futuro se o treinamento ainda estiver em andamento. O Depurador carrega automaticamente novos dados assim que se tornam disponíveis.
+ `NoMoreData`: Gerado quando o treinamento termina. Ao ver isso, você saberá que não há mais etapas e nem tensores a serem salvos.
+ `IndexReaderException`: O leitor de índice não é válido.
+ `InvalidWorker`: Um operador que não era válido foi invocado.
+ `RuleEvaluationConditionMet`: A avaliação da regra na etapa resultou no cumprimento da condição.
+ `InsufficientInformationForRuleInvocation`: Informações insuficientes foram fornecidas para invocar a regra.
## Treinamento distribuído suportado pelo Amazon SageMaker Debugger
A listagem a seguir mostra o escopo de validade e as considerações sobre o uso do Depurador em trabalhos de treinamento com frameworks de aprendizado profundo e várias opções de treinamento distribuído.
+ **Horovod**
Escopo de validade do uso do Depurador para trabalhos de treinamento com Horovod
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-reference.html)
+ **SageMaker Dados distribuídos paralelamente com IA**
Escopo de validade do uso do Debugger para trabalhos de treinamento com SageMaker IA Distributed Data Parallel
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-reference.html)
\$1 O depurador não oferece suporte à criação de perfis de estrutura para 2.x. TensorFlow
\$1\$1 O SageMaker AI Distributed Data Parallel não suporta TensorFlow 2.x com a implementação do Keras.
+ **SageMaker AI Distributed Model Parallel** — O Debugger não oferece suporte ao treinamento paralelo de modelos distribuídos de SageMaker IA.
+ **Treinamento distribuído com pontos de verificação de SageMaker IA** — O Debugger não está disponível para trabalhos de treinamento quando a opção de treinamento distribuído e os pontos de verificação de SageMaker IA estão habilitados. Você verá um erro parecido com o seguinte:
```
SMDebug Does Not Currently Support Distributed Training Jobs With Checkpointing Enabled
```
Para usar o Debugger para trabalhos de treinamento com opções de treinamento distribuídas, você precisa desativar o ponto de verificação de SageMaker IA e adicionar funções de ponto de verificação manual ao seu script de treinamento. Para obter mais informações sobre como usar o Depurador com opções de treinamento e pontos de verificação distribuídos, consulte [Usando dados distribuídos de SageMaker IA paralelamente com o Amazon SageMaker Debugger e os pontos de verificação](distributed-troubleshooting-data-parallel.md#distributed-ts-data-parallel-debugger) e [Salvando pontos de verificação](distributed-troubleshooting-model-parallel.md#distributed-ts-model-parallel-checkpoints).
+ **Servidor de parâmetros**: O depurador não oferece apoio ao treinamento distribuído baseado em servidor de parâmetros.
+ A criação de perfis de operações de estrutura de treinamento distribuída, como a `AllReduced` operação paralela de dados distribuídos de SageMaker IA e [as operações Horovod](https://horovod.readthedocs.io/en/stable/timeline_include.html), não está disponível.