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