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á.
# Monitore a utilização de recursos computacionais da AWS no Amazon SageMaker Studio Classic
Para monitorar a utilização dos recursos computacionais do seu trabalho de treinamento, use as ferramentas de monitoramento oferecidas pelo Amazon SageMaker Debugger.
Para qualquer tarefa de treinamento executada no SageMaker AI usando o SageMaker Python SDK, o Debugger coleta métricas básicas de utilização de recursos, como utilização da CPU, utilização da GPU, utilização da memória da GPU, rede e tempo de espera de E/S a cada 500 milissegundos. Para acessar o painel com as métricas de utilização de recursos de um trabalho de treinamento, simplesmente use a [ interface do usuário do SageMaker Debugger no SageMaker Studio Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html).
As operações e etapas de aprendizado profundo podem operar em intervalos de milissegundos. Em comparação com as métricas do Amazon CloudWatch, que coletam métricas em intervalos de 1 segundo, o Debugger fornece maior granularidade nas métricas de utilização de recursos em intervalos de até 100 milissegundos (0,1 segundo), para que você possa se aprofundar nas métricas no nível de uma operação ou etapa.
Se quiser alterar o intervalo de tempo de coleta de métricas, você pode adicionar um parâmetro para a configuração de criação de perfil ao seu inicializador de tarefas de treinamento. Por exemplo, se você estiver usando o SageMaker AI Python SDK, precisará transmitir o parâmetro `profiler_config` ao criar um objeto estimador. Para saber como ajustar o intervalo de coleta da métrica de utilização de recursos, consulte [Modelo de código para configurar um objeto estimador de SageMaker IA com os módulos Debugger SageMaker Python no SDK do AI Python SageMaker](debugger-configuration-for-profiling.md#debugger-configuration-structure-profiler) e, depois, [Defina as configurações para a criação de perfil básico da utilização dos recursos do sistema](debugger-configure-system-monitoring.md).
Além disso, você pode adicionar ferramentas de detecção de problemas chamadas *regras de criação de perfis integrados fornecidos pelo SageMaker Debugger*. As regras de criação de perfis integrados executam análises em relação às métricas de utilização de recursos e detectam problemas de desempenho computacional. Para ter mais informações, consulte [Use regras de criação de perfil integradas gerenciadas pelo Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md). Você pode receber os resultados da análise de regras por meio da [interface do usuário do SageMaker Debugger no SageMaker Studio Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html) ou no [relatório de criação de perfil do SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). Também é possível criar regras personalizadas de criação de perfil usando o SageMaker Python SDK.
Para saber mais sobre as funcionalidades de monitoramento fornecidas pelo SageMaker Debugger, consulte os tópicos a seguir.
**Topics**
+ [Configuração do estimador com parâmetros para criação de perfil básica usando os módulos Amazon SageMaker Debugger Python](debugger-configuration-for-profiling.md)
+ [Use regras de criação de perfil integradas gerenciadas pelo Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md)
+ [Lista de regras integradas do perfilador do Debugger](debugger-built-in-profiler-rules.md)
+ [Interface do SageMaker usuário do Amazon Debugger no Amazon Studio Classic Experiments SageMaker](debugger-on-studio.md)
+ [SageMaker Relatório interativo do Debugger](debugger-profiling-report.md)
+ [Analise dados usando a biblioteca cliente do Debugger Python](debugger-analyze-data.md)
# Configuração do estimador com parâmetros para criação de perfil básica usando os módulos Amazon SageMaker Debugger Python
[Por padrão, o perfil básico do SageMaker Debugger está ativado por padrão e monitora as métricas de utilização de recursos, como utilização da CPU, utilização da GPU, utilização da memória da GPU, rede e tempo de espera de E/S, de todos os trabalhos de treinamento enviados usando o SDK do Amazon Python. SageMaker SageMaker ](https://sagemaker.readthedocs.io/en/stable) SageMaker O Debugger coleta essas métricas de utilização de recursos a cada 500 milissegundos. Você não precisa fazer alterações adicionais em seu código, script de treinamento ou iniciador de trabalho para rastrear a utilização de recursos básicos. Se quiser alterar o intervalo de coleta de métricas para a criação de perfil básica, você pode especificar parâmetros específicos do Debugger ao criar um iniciador de SageMaker trabalhos de treinamento usando o SDK ou (CLI) do Python SageMaker . AWS SDK para Python (Boto3) AWS Command Line Interface Neste guia, vamos nos concentrar em como alterar as opções de criação de perfil usando o SDK do [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Esta página fornece modelos de referência para configurar esse objeto estimador.
Se quiser acessar o painel de métricas de utilização de recursos do seu trabalho de treinamento no SageMaker Studio, você pode acessar o. [Interface do SageMaker usuário do Amazon Debugger no Amazon Studio Classic Experiments SageMaker](debugger-on-studio.md)
Se você quiser ativar as regras que detectam problemas de utilização de recursos do sistema automaticamente, você pode adicionar o parâmetro `rules` no objeto estimador para ativar as regras.
**Importante**
Para usar os recursos mais recentes do SageMaker 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)
```
## Modelo de código para configurar um objeto estimador de SageMaker IA com os módulos Debugger SageMaker Python no SDK do AI Python SageMaker
Para ajustar a configuração básica de criação de perfil (`profiler_config`) ou adicionar as regras do criador de perfil (`rules`), escolha uma das guias para obter o modelo para configurar um SageMaker estimador de IA. Nas páginas seguintes, você pode encontrar mais informações sobre como configurar os dois parâmetros:
**nota**
Os exemplos de código a seguir não são executáveis diretamente. Vá para as próximas seções para saber como configurar cada parâmetro.
------
#### [ PyTorch ]
```
# An example of constructing a SageMaker AI PyTorch estimator
import boto3
import sagemaker
from sagemaker.pytorch import PyTorch
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
session=boto3.session.Session()
region=session.region_name
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=PyTorch(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.12.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_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 ProfilerConfig, ProfilerRule, rule_configs
session=boto3.session.Session()
region=session.region_name
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=TensorFlow(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.8.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_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 ProfilerConfig, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=MXNet(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.7.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
**nota**
Pois MXNet, ao configurar o `profiler_config` parâmetro, você só pode configurar para monitoramento do sistema. Não há suporte para métricas da estrutura de criação de perfil. MXNet
------
#### [ XGBoost ]
```
# An example of constructing a SageMaker AI XGBoost estimator
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=XGBoost(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.5-1",
# Debugger-specific parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
**nota**
Pois XGBoost, ao configurar o `profiler_config` parâmetro, você só pode configurar para monitoramento do sistema. Não há suporte para métricas da estrutura de criação de perfil. XGBoost
------
#### [ 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 ProfilerConfig, DebuggerHookConfig, Rule, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
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
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
A seguir, são apresentadas breves descrições dos parâmetros.
+ `profiler_config`: Configure o Debugger para coletar métricas do sistema e métricas da framework de seu trabalho de treinamento e salvar em seu URI seguro do bucket S3 ou na máquina local. Você pode definir com que frequência ou de forma flexível as métricas do sistema. Para saber como configurar a o parâmetro `profiler_config`, consulte [Defina as configurações para a criação de perfil básico da utilização dos recursos do sistema](debugger-configure-system-monitoring.md) e [Configuração do estimador para criação de perfil de framework](debugger-configure-framework-profiling.md).
+ `rules`— Configure esse parâmetro para ativar as regras integradas do SageMaker Debugger que você deseja executar em paralelo. Certifique-se de que seu trabalho de treinamento tenha acesso a esse bucket do S3. As regras são executadas em contêineres de processamento e analisam automaticamente seu trabalho de treinamento para encontrar problemas de desempenho computacional e operacional. A regra [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) é a regra mais integrada que executa todas as regras de criação de perfil integradas e salva os resultados da criação de perfil como um relatório em seu bucket seguro do S3. Para saber como configurar a o parâmetro `rules`, consulte [Use regras de criação de perfil integradas gerenciadas pelo Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md).
**nota**
O Debugger salva com segurança os dados de saída em subpastas do seu bucket S3 padrão. Por exemplo, o formato do URI padrão do bucket do S3 é `s3://sagemaker--<12digit_account_id>///`. Há três subpastas criadas pelo Debugger: `debug-output`, `profiler-output` e `rule-output`. Você também pode recuperar o bucket padrão do S3 URIs usando os métodos da classe [SageMaker AI Estimator](debugger-estimator-classmethods.md).
Consulte os tópicos a seguir para descobrir como configurar detalhadamente os parâmetros específicos do Debugger.
**Topics**
+ [Modelo de código para configurar um objeto estimador de SageMaker IA com os módulos Debugger SageMaker Python no SDK do AI Python SageMaker](#debugger-configuration-structure-profiler)
+ [Defina as configurações para a criação de perfil básico da utilização dos recursos do sistema](debugger-configure-system-monitoring.md)
+ [Configuração do estimador para criação de perfil de framework](debugger-configure-framework-profiling.md)
+ [Atualizando o monitoramento do sistema do Debugger e a configuração de criação de perfil da framework enquanto um trabalho de treinamento está em execução](debugger-update-monitoring-profiling.md)
+ [Desativar o Debugger](debugger-turn-off-profiling.md)
# Defina as configurações para a criação de perfil básico da utilização dos recursos do sistema
Para ajustar o intervalo de tempo para coletar as métricas de utilização, use a operação da `ProfilerConfig` API para criar um objeto de parâmetro enquanto constrói uma estrutura de SageMaker IA ou um estimador genérico, dependendo de sua preferência.
**nota**
Por padrão, para todos os trabalhos de SageMaker treinamento, o Debugger coleta métricas de utilização de recursos das instâncias do Amazon EC2 a cada 500 milissegundos para monitoramento do sistema, sem nenhum parâmetro específico do Debugger especificado nos estimadores de IA. SageMaker
O depurador salva as métricas do sistema no bucket do padrão do S3. O formato do URI padrão do bucket do S3 é `s3://sagemaker--<12digit_account_id>//profiler-output/`.
O exemplo de código a seguir mostra como configurar o parâmetro `profiler_config` com um intervalo de tempo de monitoramento do sistema de 1000 milissegundos.
```
from sagemaker.debugger import ProfilerConfig
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000
)
```
+ `system_monitor_interval_millis` (int): Especifique os intervalos de monitoramento em milissegundos para registrar as métricas do sistema. Os valores disponíveis são 100, 200, 500, 1000 (1 segundo), 5000 (5 segundos) e 60000 (1 minuto) milissegundos. O valor padrão é 500 milissegundos.
Para ver o progresso do monitoramento do sistema, consulte [Abra o painel do Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md).
# Configuração do estimador para criação de perfil de framework
**Atenção**
Em favor do [Amazon SageMaker Profiler](train-use-sagemaker-profiler.md), o SageMaker AI Debugger desaprova o recurso de criação de perfil da estrutura a partir da versão 2.11 e 2.0. TensorFlow PyTorch Você ainda pode usar o recurso nas versões anteriores das estruturas e da SDKs seguinte forma.
SageMaker SDK para Python <= v2.130.0
PyTorch >= v1.6.0, < v2.0
TensorFlow >= v2.3.1, < v2.11
Consulte também [16 de março de 2023](debugger-release-notes.md#debugger-release-notes-20230315).
Para habilitar a criação de perfil da framework do Debugger, configure o parâmetro `framework_profile_params` ao criar um estimador. O perfil da framework do Debugger coleta métricas da framework, como dados do estágio de inicialização, processos do carregador de dados, operadores Python de frameworks de aprendizado profundo e scripts de treinamento, perfis detalhados dentro e entre as etapas, com as opções cProfile ou Pyinstrument. Usando a classe `FrameworkProfile`, você pode configurar opções de criação de perfil da framework personalizada.
**nota**
Antes de começar com a criação de perfil da framework do Debugger, verifique se a framework usada para criar seu modelo é compatível com o Debugger para a criação de perfil da framework. Para obter mais informações, consulte [Algoritmos e frameworks compatíveis](debugger-supported-frameworks.md).
O Debugger salva as métricas da framework no bucket do padrão do S3. O formato do URI padrão do bucket do S3 é `s3://sagemaker--<12digit_account_id>//profiler-output/`.
**Topics**
+ [Criação de perfil de framework padrão](debugger-configure-framework-profiling-basic.md)
+ [Monitoramento padrão do sistema e o perfil personalizado de framework para etapas específicas ou um intervalo de tempo de destino](debugger-configure-framework-profiling-range.md)
+ [Monitoramento padrão do sistema e a criação de perfil personalizado de framework com diferentes opções de criação de perfil](debugger-configure-framework-profiling-options.md)
# Criação de perfil de framework padrão
O perfil da framework do Depurador inclui as seguintes opções: perfil detalhado, perfil do carregador de dados e perfil do Python. O código de exemplo a seguir é a configuração de `profiler_config` parâmetros mais simples para iniciar o monitoramento padrão do sistema e a criação de perfil da framework padrão. A classe `FrameworkProfile` no código de exemplo a seguir inicia o perfil padrão da framework quando um trabalho de treinamento é iniciado.
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile()
)
```
Com essa configuração de `profiler_config` parâmetros, o Debugger chama as configurações padrão de monitoramento e criação de perfil. O Debugger monitora as métricas do sistema a cada 500 milissegundos; traça o perfil da quinta etapa com a opção de perfil detalhado; a sétima etapa com a opção de criação de perfil do carregador de dados; e a nona, décima e décima primeira etapas com a opção de criação de perfil do Python.
[Para encontrar as opções de configuração de perfil disponíveis, as configurações de parâmetros padrão e exemplos de como configurá-las, consulte [Monitoramento padrão do sistema e a criação de perfil personalizado de framework com diferentes opções de criação de perfil](debugger-configure-framework-profiling-options.md) o [SageMaker Debugger — APIs no SDK do FrameworkProfile Amazon Python](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile). SageMaker ](https://sagemaker.readthedocs.io/en/stable)
Se você quiser alterar o intervalo de monitoramento do sistema e ativar o perfil da framework padrão, você pode especificar o `system_monitor_interval_millis` parâmetro explicitamente com o `framework_profile_params` parâmetro. Por exemplo, para monitorar a cada 1000 milissegundos e ativar o perfil padrão da framework, use o código de exemplo a seguir.
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile()
)
```
Para obter mais informações sobre a `FrameworkProfile` classe, consulte [SageMaker Debugger APIs — FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) no SDK do Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable).
# Monitoramento padrão do sistema e o perfil personalizado de framework para etapas específicas ou um intervalo de tempo de destino
Se você quiser especificar etapas ou intervalos de tempo desejados para traçar o perfil de seu trabalho de treinamento, precisará especificar parâmetros para a classe `FrameworkProfile`. Os exemplos de código a seguir mostram como especificar os intervalos de destino para a criação de perfil junto com o monitoramento do sistema.
+ **Para um intervalo de etapas de destino**
Com o exemplo de configuração a seguir, o Debugger monitora todo o trabalho de treinamento a cada 500 milissegundos (o monitoramento padrão) e traça o perfil de um intervalo de etapas de destino da etapa 5 à etapa 15 (para 10 etapas).
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile(start_step=5, num_steps=10)
)
```
Com o exemplo de configuração a seguir, o Debugger monitora todo o trabalho de treinamento a cada 1.000 milissegundos e traça o perfil de um intervalo de etapas de destino da etapa 5 à etapa 15 (para 10 etapas).
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile(start_step=5, num_steps=10)
)
```
+ **Para um intervalo de tempo de destino**
Com o exemplo de configuração a seguir, o Debugger monitora todo o trabalho de treinamento a cada 500 milissegundos (o monitoramento padrão) e cria perfis de um intervalo de tempo alvo do horário Unix atual por 600 segundos.
```
import time
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile(start_unix_time=int(time.time()), duration=600)
)
```
Com o exemplo de configuração a seguir, o Debugger monitora todo o trabalho de treinamento a cada 1.000 milissegundos e traça o perfil de um intervalo de tempo alvo do horário Unix atual por 600 segundos.
```
import time
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile(start_unix_time=int(time.time()), duration=600)
)
```
A criação de perfil da framework é executada para todas as opções de criação de perfil na etapa ou intervalo de tempo de destino.
[Para encontrar mais informações sobre as opções de criação de perfil disponíveis, consulte [SageMaker Debugger — APIs no](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) SDK do FrameworkProfile Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
A próxima seção mostra como criar um script para as opções de criação de perfil disponíveis.
# Monitoramento padrão do sistema e a criação de perfil personalizado de framework com diferentes opções de criação de perfil
Esta seção fornece informações sobre as classes de configuração de criação de perfil compatíveis, bem como um exemplo de configuração. Você pode usar as seguintes classes de configuração de criação de perfil para gerenciar as opções de criação de perfil da framework:
+ [DetailedProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DetailedProfilingConfig)— Especifique uma etapa ou intervalo de tempo alvo para traçar o perfil das operações da estrutura usando os perfiladores nativos da estrutura (TensorFlow profiler e PyTorch profiler). Por exemplo, se estiver usando TensorFlow, os ganchos do Debugger permitem que o TensorFlow criador de perfil colete métricas de estrutura específicas. TensorFlow A criação de perfil detalhada permite traçar o perfil de todos os operadores da framework em uma etapa prévia (antes da primeira etapa), dentro das etapas e entre as etapas de um trabalho de treinamento.
**nota**
O perfil detalhado pode aumentar significativamente o consumo de memória da GPU. Não recomendamos ativar a criação de perfil detalhado por mais de algumas etapas.
+ [DataloaderProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DataloaderProfilingConfig)— Especifique uma etapa ou intervalo de tempo alvo para traçar o perfil dos processos do carregador de dados da estrutura de aprendizado profundo. O Debugger coleta todos os eventos do carregador de dados das frameworks.
**nota**
O perfil do carregador de dados pode diminuir o desempenho do treinamento ao coletar informações dos carregadores de dados. Não recomendamos ativar o perfil do carregador de dados para mais do que algumas etapas.
O depurador é pré-configurado para anotar os processos do carregador de dados somente para os contêineres de aprendizado profundo AWS . O Debugger não pode criar o perfil dos processos do carregador de dados de nenhum outro contêiner de treinamento personalizado ou externo.
+ [PythonProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.PythonProfilingConfig)— Especifique uma etapa ou intervalo de tempo alvo para criar o perfil das funções do Python. Você também pode escolher entre dois criadores de perfil do Python: cProfile e Pyinstrument.
+ *cProfile*: O criador de perfil padrão do Python. O cProfile coleta informações para cada operador do Python chamado durante o treinamento. Com o cProfile, o Debugger economiza tempo cumulativo e anotações para cada chamada de função, fornecendo detalhes completos sobre as funções do Python. No aprendizado profundo, por exemplo, as funções mais frequentemente chamadas podem ser os filtros convolucionais e os operadores de passagem inversa, e o cProfile traça o perfil de cada um deles. Para a opção cProfile, você pode selecionar ainda mais uma opção de temporizador: tempo total, tempo de CPU e tempo fora da CPU. Embora você possa traçar o perfil de cada chamada de função executada em processadores (CPU e GPU) em tempo de CPU, você também pode identificar gargalos I/O ou gargalos de rede com a opção de tempo fora da CPU. O padrão é o tempo total, e o Debugger traça o perfil do tempo da CPU e do tempo fora da CPU. Com o cProfile, você pode detalhar todas as funções ao analisar os dados do perfil.
+ *Pyinstrument*: Pyinstrument é um criador de perfil Python de baixa sobrecarga que funciona com base em amostragem. Com a opção Pyinstrument, o Debugger coleta amostras de eventos de criação de perfil a cada milissegundo. Como o Pyinstrument mede o tempo decorrido do relógio em vez do tempo da CPU, a opção Pyinstrument pode ser uma escolha melhor em relação à opção cProfile para reduzir o ruído de criação de perfil (filtrando chamadas de função irrelevantes que são cumulativamente rápidas) e capturar operadores que realmente exigem muita computação (cumulativamente lento) para treinar seu modelo. Com o Pyinstrument, você pode ver uma árvore de chamadas de função e entender melhor a estrutura e a causa raiz da lentidão.
**nota**
A ativação da criação de perfil do Python pode diminuir o tempo geral de treinamento. O cProfile traça o perfil dos operadores do Python mais frequentemente chamados em cada chamada, portanto, o tempo de processamento na criação de perfil aumenta em relação ao número de chamadas. Para Pyinstrument, o tempo cumulativo de criação de perfil aumenta em relação ao tempo devido ao seu mecanismo de amostragem.
O exemplo de configuração a seguir mostra a estrutura completa quando você usa as diferentes opções de criação de perfil com valores especificados.
```
import time
from sagemaker.debugger import (ProfilerConfig,
FrameworkProfile,
DetailedProfilingConfig,
DataloaderProfilingConfig,
PythonProfilingConfig,
PythonProfiler, cProfileTimer)
profiler_config=ProfilerConfig(
system_monitor_interval_millis=500,
framework_profile_params=FrameworkProfile(
detailed_profiling_config=DetailedProfilingConfig(
start_step=5,
num_steps=1
),
dataloader_profiling_config=DataloaderProfilingConfig(
start_step=7,
num_steps=1
),
python_profiling_config=PythonProfilingConfig(
start_step=9,
num_steps=1,
python_profiler=PythonProfiler.CPROFILE,
cprofile_timer=cProfileTimer.TOTAL_TIME
)
)
)
```
Para obter mais informações sobre as opções de criação de perfil disponíveis, consulte [DetailedProfilingConfig[DataloaderProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DataloaderProfilingConfig)](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DetailedProfilingConfig), e [PythonProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.PythonProfilingConfig)no SDK do [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Atualizando o monitoramento do sistema do Debugger e a configuração de criação de perfil da framework enquanto um trabalho de treinamento está em execução
Se você quiser ativar ou atualizar a configuração de monitoramento do Debugger para um trabalho de treinamento em execução no momento, use os seguintes métodos de extensão do estimador de SageMaker IA:
+ Para ativar o monitoramento do sistema Debugger para um trabalho de treinamento em execução e receber um relatório de criação de perfil do Debugger, use o seguinte:
```
estimator.enable_default_profiling()
```
Quando você usa o `enable_default_profiling` método, o Debugger inicia o monitoramento padrão do sistema e a regra `ProfileReport` incorporada, que gera um relatório abrangente de criação de perfil no final do trabalho de treinamento. Esse método só pode ser chamado se o trabalho de treinamento atual estiver sendo executado sem o monitoramento e a criação de perfil do Debugger.
[Para obter mais informações, consulte [estimator.enable\$1default\$1profiling](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.enable_default_profiling) no SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
+ Para atualizar a configuração de monitoramento do sistema, use o seguinte:
```
estimator.update_profiler(
system_monitor_interval_millis=500
)
```
[Para obter mais informações, consulte [estimator.update\$1profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler) no SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# 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 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)
# Use regras de criação de perfil integradas gerenciadas pelo Amazon SageMaker Debugger
As regras integradas do criador de perfil do Amazon SageMaker Debugger analisam as métricas do sistema e as operações de estrutura coletadas durante o treinamento de um modelo. O Debugger oferece a operação de API `ProfilerRule` que ajuda a configurar as regras para monitorar os recursos e operações de computação de treinamento e detectar anomalias. Por exemplo, as regras de criação de perfil podem ajudá-lo a detectar se há problemas computacionais, como gargalos na CPU, tempo de I/O espera excessivo, carga de trabalho desequilibrada entre os funcionários da GPU e subutilização de recursos computacionais. Para obter uma lista completa das regras de criação de perfil disponíveis, consulte [Lista de regras integradas do perfilador do Debugger](debugger-built-in-profiler-rules.md). Os tópicos a seguir mostram como usar as regras integradas do Depurador com configurações de parâmetros padrão e valores de parâmetros personalizados.
**nota**
As regras integradas são fornecidas por meio de contêineres SageMaker de processamento da Amazon e totalmente gerenciadas pelo SageMaker Debugger sem custo adicional. Para obter mais informações sobre faturamento, consulte a página de [ SageMaker preços da Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Topics**
+ [Use as regras de criação de perfil integradas do SageMaker Debugger com suas configurações de parâmetros padrão](#debugger-built-in-profiler-rules-configuration)
+ [Use as regras de criação de perfil integradas do Debugger com valores de parâmetros personalizados](#debugger-built-in-profiler-rules-configuration-param-change)
## Use as regras de criação de perfil integradas do SageMaker Debugger com suas configurações de parâmetros padrão
Para adicionar regras integradas do SageMaker Debugger em seu estimador, você precisa configurar um objeto de lista. `rules` O código de exemplo a seguir mostra a estrutura básica da listagem das regras integradas do SageMaker Debugger.
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_1()),
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_2()),
...
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_n()),
... # You can also append more debugging rules in the Rule.sagemaker(rule_configs.*()) format.
]
estimator=Estimator(
...
rules=rules
)
```
Para obter uma lista completa das regras integradas, consulte [Lista de regras integradas do perfilador do Debugger](debugger-built-in-profiler-rules.md).
Para usar as regras de criação de perfil e inspecionar o desempenho computacional e o progresso do seu trabalho de treinamento, adicione a [https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#profiler-report](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#profiler-report)regra do Debugger. SageMaker Essa regra ativa todas as regras integradas da família [Debugger ProfilerRule](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#debugger-built-in-profiler-rules-ProfilerRule)`ProfilerRule`. Além disso, essa regra gera um relatório agregado de criação de perfil. Para obter mais informações, consulte [Relatório de criação de perfil gerado usando o SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). Você pode usar o código a seguir para adicionar a regra do relatório de criação de perfil ao seu estimador de treinamento.
```
from sagemaker.debugger import Rule, rule_configs
rules=[
ProfilerRule.sagemaker(rule_configs.ProfilerReport())
]
```
Quando você inicia o trabalho de treinamento com a regra `ProfilerReport`, o Debugger coleta dados de utilização de recursos a cada 500 milissegundos. O Debugger analisa a utilização de recursos para identificar se seu modelo está com problemas de gargalo. Se as regras detectarem anomalias de treinamento, o status de 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 de criação de perfil integradas do Debugger com valores de parâmetros personalizados
Se você quiser ajustar os valores dos 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`. Para obter instruções sobre como usar a classe `CollectionConfig`, consulte [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 iniciadas.
+ 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 perfilador do Debugger](debugger-built-in-profiler-rules.md).
[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=[
ProfilerRule.sagemaker(
base_config=rule_configs.BuiltInProfilerRuleName(),
rule_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 perfilador do Debugger](debugger-built-in-profiler-rules.md).
Para uma configuração JSON de baixo nível das regras integradas do Debugger usando a API `CreateTrainingJob`, consulte [Configurar o Debugger usando a API SageMaker](debugger-createtrainingjob-api.md).
# Lista de regras integradas do perfilador do Debugger
Use as regras de criação de perfil integradas do Debugger fornecidas pelo Amazon SageMaker Debugger e analise as métricas coletadas durante o treinamento de seus modelos. As regras internas do Debugger monitoram várias condições comuns que são críticas para o sucesso da execução de um trabalho de treinamento de desempenho. Você pode chamar as regras integradas do criador de perfil usando o SDK do [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) ou as operações de API de baixo nível. SageMaker Não há custo adicional para usar as regras integradas. Para obter mais informações sobre faturamento, consulte a página de [ SageMaker preços da Amazon](https://aws.amazon.com/sagemaker/pricing/).
**nota**
O número máximo de regras de criação de perfil incorporadas que você pode anexar a um trabalho de treinamento é 20. SageMaker O Debugger gerencia totalmente as regras integradas e analisa seu trabalho de treinamento de forma síncrona.
**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 notebook Jupyter 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)
```
## Regras do perfilador
As regras a seguir são as regras integradas do Debugger que podem ser chamadas usando o método de classe `ProfilerRule.sagemaker`.
Regra integrada do depurador para gerar o relatório de criação de perfil
| Escopo de validade | Regras integradas |
| --- | --- |
| Relatório de perfil para qualquer trabalho SageMaker de treinamento | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
Regras integradas do depurador para definir o perfil da utilização dos recursos do sistema de hardware (métricas do sistema)
| Escopo de validade | Regras integradas |
| --- | --- |
| Regras genéricas de monitoramento do sistema para qualquer trabalho SageMaker de treinamento | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
Regras integradas do Debugger para criar perfis de métricas da framework
| Escopo de validade | Regras integradas |
| --- | --- |
| Regras de criação de perfil para estruturas de aprendizado profundo (TensorFlow e) PyTorch | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
**Atenção**
Em favor do [Amazon SageMaker Profiler](train-use-sagemaker-profiler.md), o SageMaker AI Debugger descontinua o recurso de criação de perfil da estrutura a partir da versão 2.11 e 2.0. TensorFlow PyTorch Você ainda pode usar o recurso nas versões anteriores das estruturas e da SDKs seguinte forma.
SageMaker SDK para Python <= v2.130.0
PyTorch >= v1.6.0, < v2.0
TensorFlow >= v2.3.1, < v2.11
Consulte também [16 de março de 2023](debugger-release-notes.md#debugger-release-notes-20230315).
**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 = [
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_1()),
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_2()),
...
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_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 = [
ProfilerRule.sagemaker(
base_config=rule_configs.BuiltInRuleName(),
rule_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 SageMaker API de baixo nível, consulte[Configurar o Debugger usando a API SageMaker](debugger-createtrainingjob-api.md).
## ProfilerReport
A ProfilerReport regra invoca todas as regras integradas para monitoramento e criação de perfil. Ele cria um relatório de criação de perfil e é atualizado quando as regras individuais são acionadas. Você pode baixar um relatório de criação de perfil abrangente enquanto um trabalho de treinamento está em execução ou após a conclusão do trabalho de treinamento. Você pode ajustar os valores dos parâmetros da regra para personalizar a sensibilidade das regras integradas de monitoramento e criação de perfil. O código de exemplo a seguir mostra o formato básico para ajustar os parâmetros de regra incorporados por meio da ProfilerReport regra.
```
rules=[
ProfilerRule.sagemaker(
rule_configs.ProfilerReport(
_ = value
)
)
]
```
Se você acionar essa ProfilerReport regra sem nenhum parâmetro personalizado, conforme mostrado no código de exemplo a seguir, a ProfilerReport regra acionará todas as regras integradas para monitoramento e criação de perfil com seus valores de parâmetros padrão.
```
rules=[ProfilerRule.sagemaker(rule_configs.ProfilerReport())]
```
O código de exemplo a seguir mostra como especificar e ajustar o `cpu_threshold` parâmetro da CPUBottleneck regra e o `threshold` parâmetro da IOBottleneck regra.
```
rules=[
ProfilerRule.sagemaker(
rule_configs.ProfilerReport(
CPUBottleneck_cpu_threshold = 90,
IOBottleneck_threshold = 90
)
)
]
```
Para explorar o que está no relatório do criador de perfil, consulte Relatório de criação de perfil do [SageMaker depurador](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). Além disso, como essa regra ativa todas as regras de criação de perfil, você também pode verificar o status da análise da regra usando a interface do usuário do [SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html) no Studio Experiments. SageMaker
Descrições de parâmetros para a OverallSystemUsage regra
| Nome do parâmetro | Description |
| --- | --- |
| 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 |
| \$1 | Parâmetro personalizável para ajustar os limites de outras regras integradas de monitoramento e criação de perfil. **Opcional** Valor padrão: `None` |
## BatchSize
A BatchSize regra ajuda a detectar se a GPU está subutilizada devido ao pequeno tamanho do lote. Para detectar esse problema, essa regra monitora a utilização média da CPU, a utilização da GPU e a utilização de memória da GPU. Se a utilização na memória de CPU, GPU e GPU for baixa, em média, isso pode indicar que o trabalho de treinamento pode ser executado em um tipo de instância menor ou em um lote maior. Essa análise não funciona para frameworks que superalocam muito a memória. No entanto, aumentar o tamanho do lote pode causar problemas no processamento ou no carregamento de dados, pois é necessário mais tempo de pré-processamento de dados em cada iteração.
Descrições de parâmetros para a BatchSize regra
| Nome do parâmetro | Description |
| --- | --- |
| 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 |
| cpu\$1threshold\$1p95 | Define o limite para o 95º quantil de utilização da CPU em porcentagem. **Opcional** Valores válidos: inteiro Valor padrão: `70` (em porcentagem) |
| gpu\$1threshold\$1p95 | Define o limite para o 95º quantil de utilização da GPU em porcentagem. **Opcional** Valores válidos: inteiro Valor padrão: `70` (em porcentagem) |
| gpu\$1memory\$1threshold\$1p95 | Define o limite para o 95º quantil de utilização de memória da GPU em porcentagem. **Opcional** Valores válidos: inteiro Valores padrão: `70` (em porcentagem) |
| patience | Define o número de pontos de dados a serem ignorados até que a regra inicie a avaliação. As primeiras etapas dos trabalhos de treinamento geralmente mostram um alto volume de processos de dados, portanto, mantenha a regra paciente e evite que ela seja invocada muito cedo com um determinado número de dados de perfil que você especifica com esse parâmetro. **Opcional** Valores válidos: inteiro Valores padrão: `100` |
| window | Tamanho da janela para calcular quantis. **Opcional** Valores válidos: inteiro Valores padrão: `500` |
| scan\$1interval\$1us | Intervalo de tempo em que os arquivos da linha do tempo são digitalizados. **Opcional** Valores válidos: inteiro Valores padrão: `60000000` (em microssegundos) |
## CPUBottleneck
A CPUBottleneck regra ajuda a detectar se a GPU está subutilizada devido a gargalos na CPU. A regra retornará True se o número de problemas da CPU exceder um limite predefinido.
Descrições de parâmetros para a CPUBottleneck regra
| Nome do parâmetro | Description |
| --- | --- |
| 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 do tempo problemático em relação ao tempo total de treinamento. Se a proporção exceder a porcentagem especificada para o parâmetro de limite, a regra alterna o status da regra para Verdadeiro. **Opcional** Valores válidos: inteiro Valor padrão: `50` (em porcentagem) |
| gpu\$1threshold | Um limite que define a baixa utilização da GPU. **Opcional** Valores válidos: inteiro Valor padrão: `10` (em porcentagem) |
| cpu\$1threshold | Um limite que define a alta utilização da CPU. **Opcional** Valores válidos: inteiro Valores padrão: `90` (em porcentagem) |
| patience | Define o número de pontos de dados a serem ignorados até que a regra inicie a avaliação. As primeiras etapas dos trabalhos de treinamento geralmente mostram um alto volume de processos de dados, portanto, mantenha a regra paciente e evite que ela seja invocada muito cedo com um determinado número de dados de perfil que você especifica com esse parâmetro. **Opcional** Valores válidos: inteiro Valores padrão: `100` |
| scan\$1interval\$1us | Intervalo de tempo com o qual os arquivos da linha do tempo são digitalizados. **Opcional** Valores válidos: inteiro Valores padrão: `60000000` (em microssegundos) |
## GPUMemoryAumentar
A regra GPUMemory Aumentar ajuda a detectar um grande aumento no uso de memória em GPUs.
Descrições de parâmetros para a regra de GPUMemory aumento
| Nome do parâmetro | Description |
| --- | --- |
| 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 |
| increase | Define o limite para o aumento absoluto da memória. **Opcional** Valores válidos: inteiro Valor padrão: `10` (em porcentagem) |
| patience | Define o número de pontos de dados a serem ignorados até que a regra inicie a avaliação. As primeiras etapas dos trabalhos de treinamento geralmente mostram um alto volume de processos de dados, portanto, mantenha a regra paciente e evite que ela seja invocada muito cedo com um determinado número de dados de perfil que você especifica com esse parâmetro. **Opcional** Valores válidos: inteiro Valores padrão: `100` |
| window | Tamanho da janela para calcular quantis. **Opcional** Valores válidos: inteiro Valores padrão: `500` |
| scan\$1interval\$1us | Intervalo de tempo em que os arquivos da linha do tempo são digitalizados. **Opcional** Valores válidos: inteiro Valores padrão: `60000000` (em microssegundos) |
## IOBottleneck
Essa regra ajuda a detectar se a GPU está subutilizada devido a gargalos de E/S de dados. A regra retornará True se o número de problemas de E/S exceder um limite predefinido.
Descrições de parâmetros para a IOBottleneck regra
| Nome do parâmetro | Description |
| --- | --- |
| 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 em que a regra retornará Verdadeiro.**Opcional**Valores válidos: inteiroValor padrão: `50` (em porcentagem) |
| gpu\$1threshold | Um limite que define quando a GPU é considerada subutilizada. **Opcional** Valores válidos: inteiro Valor padrão: `70` (em porcentagem) |
| io\$1threshold | Um limite que define um alto tempo de espera de E/S.**Opcional**Valores válidos: inteiroValores padrão: `50` (em porcentagem) |
| patience | Define o número de pontos de dados a serem ignorados até que a regra inicie a avaliação. As primeiras etapas dos trabalhos de treinamento geralmente mostram um alto volume de processos de dados, portanto, mantenha a regra paciente e evite que ela seja invocada muito cedo com um determinado número de dados de perfil que você especifica com esse parâmetro.**Opcional**Valores válidos: inteiroValores padrão: `1000` |
| scan\$1interval\$1us | Intervalo de tempo em que os arquivos da linha do tempo são digitalizados. **Opcional** Valores válidos: inteiro Valores padrão: `60000000` (em microssegundos) |
## LoadBalancing
A LoadBalancing regra ajuda a detectar problemas no balanceamento da carga de trabalho entre vários. GPUs
Descrições de parâmetros para a LoadBalancing regra
| Nome do parâmetro | Description |
| --- | --- |
| 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 a porcentagem da workload. **Opcional** Valores válidos: inteiro Valor padrão: `0.5` (proporção sem unidade) |
| patience | Define o número de pontos de dados a serem ignorados até que a regra inicie a avaliação. As primeiras etapas dos trabalhos de treinamento geralmente mostram um alto volume de processos de dados, portanto, mantenha a regra paciente e evite que ela seja invocada muito cedo com um determinado número de dados de perfil que você especifica com esse parâmetro. **Opcional** Valores válidos: inteiro Valores padrão: `10` |
| scan\$1interval\$1us | Intervalo de tempo em que os arquivos da linha do tempo são digitalizados. **Opcional** Valores válidos: inteiro Valores padrão: `60000000` (em microssegundos) |
## Baixo GPUUtilization
A GPUUtilization regra Baixa ajuda a detectar se a utilização da GPU é baixa ou sofre flutuações. Isso é verificado para cada GPU em cada operador. A regra retorna True se o 95º quantil estiver abaixo do threshold\$1p95, o que indica subutilização. A regra retorna verdadeira se o 95º quantil estiver acima do threshold\$1p95 e o 5º quantil estiver abaixo do threshold\$1p5, o que indica flutuações.
Descrições de parâmetros para a GPUUtilization regra baixa
| Nome do parâmetro | Description |
| --- | --- |
| 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\$1p95 | Um limite para o 95º quantil abaixo do qual a GPU é considerada subutilizada. **Opcional** Valores válidos: inteiro Valor padrão: `70` (em porcentagem) |
| threshold\$1p5 | Um limite para o 5º quantil. O valor padrão é 10%.**Opcional**Valores válidos: inteiroValores padrão: `10` (em porcentagem) |
| patience | Define o número de pontos de dados a serem ignorados até que a regra inicie a avaliação. As primeiras etapas dos trabalhos de treinamento geralmente mostram um alto volume de processos de dados, portanto, mantenha a regra paciente e evite que ela seja invocada muito cedo com um determinado número de dados de perfil que você especifica com esse parâmetro. **Opcional** Valores válidos: inteiro Valores padrão: `1000` |
| window | Tamanho da janela para calcular quantis. **Opcional** Valores válidos: inteiro Valores padrão: `500` |
| scan\$1interval\$1us | Intervalo de tempo em que os arquivos da linha do tempo são digitalizados. **Opcional** Valores válidos: inteiro Valores padrão: `60000000` (em microssegundos) |
## OverallSystemUsage
A OverallSystemUsage regra mede o uso geral do sistema por nó de trabalho. Atualmente, a regra agrega apenas valores por nó e calcula seus percentis.
Descrições de parâmetros para a OverallSystemUsage regra
| Nome do parâmetro | Description |
| --- | --- |
| 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 |
| scan\$1interval\$1us | Intervalo de tempo para verificar arquivos da linha do tempo. **Opcional** Valores válidos: inteiro Valores padrão: `60000000` (em microssegundos) |
## MaxInitializationTime
A MaxInitializationTime regra ajuda a detectar se a inicialização do treinamento está demorando muito. A regra espera até que a primeira etapa esteja disponível.
Descrições de parâmetros para a MaxInitializationTime regra
| Nome do parâmetro | Description |
| --- | --- |
| 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 em minutos para aguardar a disponibilidade da primeira etapa. **Opcional** Valores válidos: inteiro Valor padrão: `20` (em minutos) |
| scan\$1interval\$1us | Intervalo de tempo com o qual os arquivos da linha do tempo são digitalizados. **Opcional** Valores válidos: inteiro Valores padrão: `60000000` (em microssegundos) |
## OverallFrameworkMetrics
A OverallFrameworkMetrics regra resume o tempo gasto nas métricas da estrutura, como passagem para frente e para trás e carregamento de dados.
Descrições de parâmetros para a OverallFrameworkMetrics regra
| Nome do parâmetro | Description |
| --- | --- |
| 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 |
| scan\$1interval\$1us | Intervalo de tempo para verificar arquivos da linha do tempo. **Opcional** Valores válidos: inteiro Valores padrão: `60000000` (em microssegundos) |
## StepOutlier
A StepOutlier regra ajuda a detectar valores discrepantes nas durações das etapas. Essa regra retorna `True` se houver valores discrepantes com durações de etapas maiores que `stddev` sigmas de todas as durações de etapas em um intervalo de tempo.
Descrições de parâmetros para a StepOutlier regra
| Nome do parâmetro | Description |
| --- | --- |
| 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 |
| stddev | Define um fator pelo qual multiplicar o desvio padrão. Por exemplo, a regra é invocada por padrão quando a duração de uma etapa é maior ou menor que 5 vezes o desvio padrão. **Opcional** Valores válidos: inteiro Valor padrão: `5` (em minutos) |
| mode | Modo sob o qual as etapas foram salvas e em qual Regra deve ser executada. Por padrão, a regra será executada nas etapas das fases EVAL e TRAIN**Opcional**Valores válidos: inteiroValor padrão: `5` (em minutos) |
| n\$1outliers | Quantos valores discrepantes devem ser ignorados antes que a regra retorne Verdadeiro**Opcional**Valores válidos: inteiroValor padrão: `10` |
| scan\$1interval\$1us | Intervalo de tempo com o qual os arquivos da linha do tempo são digitalizados. **Opcional** Valores válidos: inteiro Valores padrão: `60000000` (em microssegundos) |
# Interface do SageMaker usuário do Amazon Debugger no Amazon Studio Classic Experiments SageMaker
Use o painel do Amazon SageMaker Debugger Insights no Amazon SageMaker Studio Classic Experiments para analisar o desempenho do seu modelo e os gargalos do sistema enquanto executa trabalhos de treinamento em instâncias do Amazon Elastic Compute Cloud (Amazon EC2). Obtenha insights sobre seus trabalhos de treinamento e melhore o desempenho e a precisão do treinamento do modelo com os painéis do Debugger. Por padrão, o Debugger monitora as métricas do sistema (CPU, GPU, memória da GPU, rede e E/S de dados) a cada 500 milissegundos e tensores de saída básicos (perda e precisão) a cada 500 iterações para trabalhos de treinamento. [Você também pode personalizar ainda mais os valores dos parâmetros de configuração do Debugger e ajustar os intervalos de salvamento por meio da interface do usuário do Studio Classic ou usando o SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
**Importante**
Se você estiver usando uma aplicação Studio Classic existente, exclua a aplicação e reinicie para usar os atributos mais recentes do Studio Classic. Para obter instruções sobre como reiniciar e atualizar seu ambiente Studio Classic, consulte [Atualizar o Amazon SageMaker AI Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-tasks-update.html).
**Topics**
+ [Abra o painel do Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md)
+ [SageMaker Controlador de painel do Amazon Debugger Insights](debugger-on-studio-insights-controllers.md)
+ [Explore o painel do Amazon SageMaker Debugger Insights](debugger-on-studio-insights-walkthrough.md)
+ [Encerre a instância do Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md)
# Abra o painel do Amazon SageMaker Debugger Insights
No painel do SageMaker Debugger Insights no Studio Classic, você pode ver as informações sobre a utilização dos recursos computacionais, a utilização dos recursos e o gargalo do sistema do seu trabalho de treinamento executado nas instâncias do Amazon EC2 em tempo real e após os treinamentos
**nota**
O painel do SageMaker Debugger Insights executa um aplicativo Studio Classic em uma `ml.m5.4xlarge` instância para processar e renderizar as visualizações. Cada guia SageMaker do Debugger Insights executa uma sessão do kernel do Studio Classic. Várias sessões do kernel para várias guias do SageMaker Debugger Insights são executadas em uma única instância. Quando você fecha uma guia do SageMaker Debugger Insights, a sessão correspondente do kernel também é fechada. A aplicação Studio Classic permanece ativo e gera cobranças pelo uso da instância `ml.m5.4xlarge`. Para obter informações sobre preços, consulte a página de [ SageMaker preços da Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Importante**
Ao terminar de usar o painel do SageMaker Debugger Insights, você deve desligar a `ml.m5.4xlarge` instância para evitar o acúmulo de cobranças. Para obter instruções sobre como encerrar a instância, consulte [Encerre a instância do Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
**Para abrir o painel do SageMaker Debugger Insights**
1. Na **página inicial** do Studio Classic, escolha **Experimentos** no painel de navegação à esquerda.
1. Pesquise seu emprego de treinamento na página **Experimentos**. Se seu trabalho de treinamento estiver configurado com uma execução de Experimentos, o trabalho deverá aparecer na guia **Experimentos**; se você não configurou uma execução de Experimentos, o trabalho deverá aparecer na guia **Execuções não atribuídas**.
1. Escolha (clique) no link do nome do trabalho de treinamento para ver os detalhes do trabalho.
1. No menu **VISÃO GERAL**, escolha **Depurador**. Isso deve mostrar as duas seções a seguir.
+ Na seção **Regras do depurador**, você pode pesquisar o status das regras internas do depurador associadas ao trabalho de treinamento.
+ Na seção **Debugger Insights**, você pode encontrar links para abrir o SageMaker Debugger Insights no painel.
1. Na seção **SageMaker Debugger Insights**, escolha o link do nome do trabalho de treinamento para abrir o painel do SageMaker Debugger Insights. Isso abre uma janela **Debug [your-training-job-name]**. Nessa janela, o Debugger fornece uma visão geral do desempenho computacional do seu trabalho de treinamento nas instâncias do Amazon EC2 e ajuda a identificar problemas na utilização de recursos computacionais.
Você também pode baixar um relatório de criação de perfil agregado adicionando a [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)regra integrada do Debugger. SageMaker Para obter mais informações, consulte [Configurar regras incorporadas do profiler](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html) e [relatório de criação de perfil gerado usando SageMaker o](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html) Debugger.
# SageMaker Controlador de painel do Amazon Debugger Insights
Existem diferentes componentes do controlador Debugger para monitoramento e criação de perfil. Neste guia, você aprende sobre os componentes do controlador Debugger.
**nota**
O painel do SageMaker Debugger Insights executa um aplicativo Studio Classic em uma `ml.m5.4xlarge` instância para processar e renderizar as visualizações. Cada guia SageMaker do Debugger Insights executa uma sessão do kernel do Studio Classic. Várias sessões do kernel para várias guias do SageMaker Debugger Insights são executadas em uma única instância. Quando você fecha uma guia do SageMaker Debugger Insights, a sessão correspondente do kernel também é fechada. A aplicação Studio Classic permanece ativo e gera cobranças pelo uso da instância `ml.m5.4xlarge`. Para obter informações sobre preços, consulte a página de [ SageMaker preços da Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Importante**
Quando você terminar de usar o painel do SageMaker Debugger Insights, encerre a `ml.m5.4xlarge` instância para evitar o acúmulo de cobranças. Para obter instruções sobre como encerrar a instância, consulte [Encerre a instância do Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
## SageMaker UI do controlador Debugger Insights
Usando o controlador do Debugger localizado no canto superior esquerdo do painel do Insights, você pode atualizar o painel, definir ou atualizar as configurações do Debugger para monitorar as métricas do sistema, interromper um trabalho de treinamento e baixar um relatório de criação de perfil do Debugger.
![\[SageMaker Controladores de painel do Debugger Insights\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-studio-insights-refresh.png)
+ Se você quiser atualizar manualmente o painel, escolha o botão de atualização (a seta redonda no canto superior esquerdo) conforme mostrado na captura de tela anterior.
+ O botão de alternância de **monitoramento** está ativado por padrão para qualquer trabalho de SageMaker treinamento iniciado usando o SDK do Python SageMaker . Se não estiver ativado, você pode usar o botão de alternância para iniciar o monitoramento. Durante o monitoramento, o Debugger coleta apenas métricas de utilização de recursos para detectar problemas computacionais, como gargalos na CPU e subutilização da GPU. Para obter uma lista completa de problemas de uso monitorados pelos recursos do Depurador, consulte [Regras integradas do depurador para definir o perfil da utilização dos recursos do sistema de hardware (métricas do sistema)](debugger-built-in-profiler-rules.md#built-in-rules-monitoring).
+ O botão **Configurar monitoramento** abre uma janela pop-up que você pode usar para definir ou atualizar a frequência da coleta de dados e o caminho do S3 para salvar os dados.
![\[A janela pop-up para definir as configurações de monitoramento do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-studio-enable-profiling-2.png)
Você pode especificar os seguintes valores: ou .
+ URI do **bucket do S3: especifique o URI** básico do bucket do S3.
+ **Colete dados de monitoramento a cada**: selecione um intervalo de tempo para coletar métricas do sistema. Você pode escolher um dos intervalos de monitoramento na lista suspensa. Os intervalos disponíveis são 100 milissegundos, 200 milissegundos, 500 milissegundos (padrão), 1 segundo, 5 segundos e 1 minuto.
**nota**
Se você escolher um dos intervalos de tempo mais baixos, aumentará a granularidade das métricas de utilização de recursos para poder capturar picos e anomalias com uma resolução de tempo maior. No entanto, quanto maior a resolução, maior o tamanho das métricas do sistema a serem processadas. Isso pode gerar sobrecarga adicional e afetar o tempo geral de treinamento e processamento.
+ Usando o botão **Parar treinamento**, você pode interromper o trabalho de treinamento quando encontrar anomalias na utilização de recursos.
+ Usando o botão **Baixar relatório**, você pode baixar um relatório de criação de perfil agregado usando a [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)regra integrada do Debugger. SageMaker O botão é ativado quando você adiciona a [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)regra incorporada ao estimador. Para obter mais informações, consulte [Configurar regras incorporadas do profiler](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html) e [relatório de criação de perfil gerado usando SageMaker o](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html) Debugger.
# Explore o painel do Amazon SageMaker Debugger Insights
Quando você inicia um trabalho de SageMaker treinamento, o SageMaker Debugger começa a monitorar a utilização de recursos das instâncias do Amazon EC2 por padrão. Você pode acompanhar as taxas de utilização do sistema, a visão geral das estatísticas e a análise de regras integradas por meio do painel do Insights. **Este guia mostra o conteúdo do painel do SageMaker Debugger Insights nas seguintes guias: Métricas e regras **do sistema**.**
**nota**
O painel do SageMaker Debugger Insights executa um aplicativo Studio Classic em uma `ml.m5.4xlarge` instância para processar e renderizar as visualizações. Cada guia SageMaker do Debugger Insights executa uma sessão do kernel do Studio Classic. Várias sessões do kernel para várias guias do SageMaker Debugger Insights são executadas em uma única instância. Quando você fecha uma guia do SageMaker Debugger Insights, a sessão correspondente do kernel também é fechada. A aplicação Studio Classic permanece ativo e gera cobranças pelo uso da instância `ml.m5.4xlarge`. Para obter informações sobre preços, consulte a página de [ SageMaker preços da Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Importante**
Quando você terminar de usar o painel do SageMaker Debugger Insights, encerre a `ml.m5.4xlarge` instância para evitar o acúmulo de cobranças. Para obter instruções sobre como encerrar a instância, consulte [Encerre a instância do Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
**Importante**
Nos relatórios, gráficos e 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**
+ [Métricas do sistema](#debugger-insights-system-metrics-tab)
+ [Regras](#debugger-on-studio-insights-rules)
## Métricas do sistema
Na guia **Métricas do sistema**, você pode usar a tabela de resumo e os gráficos de séries temporais para entender a utilização de recursos.
### Resumo da utilização de recursos
*Essa tabela de resumo mostra as estatísticas das métricas de utilização de recursos computacionais de todos os nós (indicados como algo- n).* As métricas de utilização de recursos incluem a utilização total da CPU, a utilização total da GPU, a utilização total da memória da CPU, a utilização total da memória da GPU, o tempo total de I/O espera e a rede total em bytes. A tabela mostra os valores mínimo e máximo e os percentis p99, p90 e p50.
![\[Uma tabela resumida da utilização de recursos\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-studio-insights-resource-util-summary.png)
### Gráficos de séries temporais de utilização de recursos
Use os gráficos de séries temporais para ver mais detalhes sobre a utilização de recursos e identificar em que intervalo de tempo cada instância mostra qualquer taxa de utilização indesejada, como baixa utilização de GPU e gargalos de CPU que podem causar o desperdício da instância cara.
**A interface do usuário do controlador gráfico de séries temporais**
A captura de tela a seguir mostra o controlador de interface do usuário para ajustar os gráficos de séries temporais.
![\[\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-insights-graph-controller.png)
+ **algo-1**: Use esse menu suspenso para escolher o nó que você deseja examinar.
+ **Ampliar**: Use esse botão para ampliar os gráficos de séries temporais e visualizar intervalos de tempo mais curtos.
+ **Reduzir**: use esse botão para reduzir o zoom dos gráficos de séries temporais e visualizar intervalos de tempo mais amplos.
+ **Deslocar para a esquerda**: mova os gráficos da série temporal para um intervalo de tempo anterior.
+ **Deslocar para a direita**: mova os gráficos da série temporal para um intervalo de tempo posterior.
+ **Corrigir prazo**: use essa caixa de seleção para corrigir ou trazer de volta os gráficos de séries temporais para mostrar a visualização completa do primeiro ponto de dados até o último ponto de dados.
**Utilização da CPU e I/O tempo de espera**
Os dois primeiros gráficos mostram a utilização da CPU e o tempo de I/O espera ao longo do tempo. Por padrão, os gráficos mostram a média da taxa de utilização da CPU e do tempo de I/O espera gasto nos núcleos da CPU. Você pode selecionar um ou mais núcleos de CPU selecionando os rótulos para representá-los graficamente em um único gráfico e comparar a utilização entre os núcleos. Você pode arrastar e ampliar e reduzir para ver mais de perto intervalos de tempo específicos.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-insights-node-cpu.png)
**Utilização da GPU e utilização da memória da GPU**
Os gráficos a seguir mostram a utilização da GPU e a utilização da memória da GPU ao longo do tempo. Por padrão, os gráficos mostram a taxa média de utilização ao longo do tempo. Você pode selecionar os rótulos principais da GPU para ver a taxa de utilização de cada núcleo. Tomar a média da taxa de utilização sobre o número total de núcleos de GPU mostra a utilização média de todo o recurso do sistema de hardware. Ao observar a taxa média de utilização, você pode verificar o uso geral dos recursos do sistema de uma instância do Amazon EC2. A figura a seguir mostra um exemplo de trabalho de treinamento em uma `ml.p3.16xlarge` instância com 8 núcleos de GPU. Você pode monitorar se o trabalho de treinamento está bem distribuído, utilizando totalmente tudo GPUs.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-studio-insights-node-gpu.gif)
**Utilização geral do sistema ao longo do tempo**
O mapa de calor a seguir mostra um exemplo de toda a utilização de uma `ml.p3.16xlarge` instância pelo sistema ao longo do tempo, projetada no gráfico bidimensional. Cada núcleo de CPU e GPU é listado no eixo vertical, e a utilização é registrada ao longo do tempo com um esquema de cores, em que as cores brilhantes representam baixa utilização e as cores mais escuras representam alta utilização. Consulte a barra de cores rotulada no lado direito do gráfico para descobrir qual nível de cor corresponde a qual taxa de utilização.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-studio-insights-node-heatmap.png)
## Regras
Use a guia **Regras** para encontrar um resumo da análise das regras de criação de perfil em seu trabalho de treinamento. Se a regra de criação de perfil for ativada com o trabalho de treinamento, o texto aparecerá destacado com o texto branco sólido. As regras inativas são esmaecidas em texto cinza. Para ativar essas regras, siga as instruções em[Use regras de criação de perfil integradas gerenciadas pelo Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md).
![\[A guia Regras no painel do SageMaker Debugger Insights\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-insights-rules.png)
# Encerre a instância do Amazon SageMaker Debugger Insights
Quando você não estiver usando o painel do SageMaker Debugger Insights, você deve desligar a instância do aplicativo para evitar taxas adicionais.
**Para desligar a instância do aplicativo SageMaker Debugger Insights no Studio Classic**
![\[Uma captura de tela animada que mostra como desligar uma instância do painel do SageMaker Debugger Insights.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-studio-insights-shut-down.png)
1. No Studio Classic, selecione o ícone **Instâncias e kernels em execução** (![\[Square icon with a white outline of a cloud on a dark blue background.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/icons/Running_squid.png)).
1. Na lista **APLICAÇÕES EM EXECUÇÃO**, procure a aplicação **sagemaker-debugger-1.0**. Selecione o ícone de encerramento (![\[Power button icon with a circular shape and vertical line symbol.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/icons/Shutdown_light.png)) ao lado da aplicação. Os painéis do SageMaker Debugger Insights são executados em uma instância. `ml.m5.4xlarge` Essa instância também desaparece das **INSTÂNCIAS EM EXECUÇÃO** quando você encerra a aplicação **sagemaker-debugger-1.0**.
# SageMaker Relatório interativo do Debugger
Receba relatórios de criação de perfil gerados automaticamente pelo Debugger. O relatório do Debugger fornece insights sobre seus trabalhos de treinamento e sugere recomendações para melhorar o desempenho do seu modelo. A captura de tela a seguir mostra uma colagem do relatório de criação de perfil do Debugger. Para saber mais, consulte [SageMaker Relatório interativo do Debugger](#debugger-profiling-report).
**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**
Nos relatórios, gráficos e 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.
![\[Um exemplo de relatório de resumo do trabalho de treinamento do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profile-report.jpg)
Para qualquer trabalho de SageMaker treinamento, a [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) regra do SageMaker Debugger invoca todas as regras de [monitoramento e criação de perfil e agrega a análise das regras em um relatório abrangente](debugger-built-in-profiler-rules.md#built-in-rules-monitoring). Seguindo este guia, baixe o relatório usando o [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) ou o console do S3 e saiba o que você pode interpretar a partir dos resultados da criação de perfil.
**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.
# Baixe o relatório de criação de SageMaker perfil do Debugger
Baixe o relatório de criação de perfil do SageMaker Debugger enquanto seu trabalho de treinamento estiver em execução ou após o término do trabalho usando o [SDK e (CLI) do Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). AWS Command Line Interface
**nota**
Para obter o relatório de criação de perfil gerado pelo SageMaker Debugger, você deve usar a [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)regra integrada oferecida pelo Debugger. SageMaker Para ativar a regra com seu trabalho de treinamento, consulte [Configurar regras do criador de perfil integrado](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html).
**dica**
Você também pode baixar o relatório com um único clique no painel de insights do SageMaker Studio Debugger. Isso não requer nenhum script adicional para baixar o relatório. Para saber como baixar o relatório do Studio, consulte [Abra o painel do Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md).
------
#### [ Download using 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 relatório de criação de perfil 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 uma pasta gerada automaticamente chamada `ProfilerReport-1234567890`. O nome da pasta é uma combinação de cadeias de caracteres: `ProfilerReport` e uma tag exclusiva de 10 dígitos baseada no carimbo de data/hora do Unix quando a regra é iniciada. ProfilerReport
![\[Um exemplo de saída de regra\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-rule-output-ls-example.png)
O `profiler-report.html` é um relatório de criação de perfil gerado automaticamente pelo Debugger. Os arquivos restantes são os componentes integrados de análise de regras armazenados em JSON e em um caderno Jupyter que são usados para agregá-los ao relatório.
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 estiver usando um servidor do caderno Jupyter, execute `!pwd` para verificar novamente o diretório de trabalho atual.
1. Abaixo do diretório`/ProfilerReport-1234567890/profiler-output`, abra `profiler-report.html`. Se estiver usando JupyterLab, escolha **Confiar em HTML** para ver o relatório de criação de perfil do Debugger gerado automaticamente.
![\[Um exemplo de saída de regra\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-rule-output-open-html.png)
1. Abra o arquivo `profiler-report.ipynb` para explorar como o relatório é gerado. Você também pode personalizar e estender o relatório de criação de perfil usando o arquivo do caderno Jupyter.
------
#### [ Download using 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*.
![\[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-0.png)
1. No bucket básico do S3, pesquise o nome do trabalho de treinamento especificando o prefixo do nome do trabalho no campo de entrada *Localizar objetos por prefixo*. Escolha o nome do trabalho de treinamento.
![\[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-1.png)
1. No bucket S3 do trabalho de treinamento, deve haver três subpastas para dados de treinamento coletados pelo Debugger: **debug-output/**, **profiler-output/** e **rule-output/**. Escolha **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 **ProfilerReport-1234567890 e escolha profiler-output/**** folder.** A pasta **profiler-output/** contém **profiler-report.html** (o relatório de criação de perfil gerado automaticamente em html), **profiler-report.ipynb** (um caderno Jupyter com scripts usados para gerar o relatório) e uma pasta **profiler-report/** (contém arquivos JSON de análise de regras que são usados como componentes do relatório).
1. Selecione o arquivo **profiler-report.html**, escolha **Ações** e **Fazer download**.
![\[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-3.png)
1. Abra o arquivo **profiler-report.html** baixado em um navegador da web.
------
**nota**
Se você iniciou seu trabalho de treinamento sem configurar os parâmetros específicos do Debugger, o Debugger gerará o relatório com base apenas nas regras de monitoramento do sistema porque os parâmetros do Debugger não estão configurados para salvar métricas da estrutura. Para habilitar a criação de perfis de métricas da estrutura e receber um relatório estendido de criação de perfil do Debugger, configure o `profiler_config` parâmetro ao criar ou atualizar estimadores de IA. SageMaker
Para saber como configurar o parâmetro `profiler_config` antes de iniciar um trabalho de treinamento, consulte [Configuração do estimador para criação de perfil de framework](debugger-configure-framework-profiling.md).
Para atualizar o trabalho de treinamento atual e habilitar a criação de perfil de métricas da estrutura, consulte [Atualizar configuração de perfil da framework do Debugger](debugger-update-monitoring-profiling.md).
# Passo a passo do relatório de criação de perfil do Debugger
Esta seção o orienta no relatório de criação de perfil do Depurador, seção por seção. O relatório de criação de perfil é gerado baseado nas regras integradas para monitoramento e criação de perfil. O relatório mostra gráficos de resultados somente para as regras que encontraram problemas.
**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**
+ [Resumo do trabalho de treinamento](#debugger-profiling-report-walkthrough-summary)
+ [Estatísticas de uso do sistema](#debugger-profiling-report-walkthrough-system-usage)
+ [Resumo das métricas do framework](#debugger-profiling-report-walkthrough-framework-metrics)
+ [Resumo das regras](#debugger-profiling-report-walkthrough-rules-summary)
+ [Analisando o ciclo de treinamento: durações das etapas](#debugger-profiling-report-walkthrough-step-durations)
+ [Análise de utilização da GPU](#debugger-profiling-report-walkthrough-gpu-utilization)
+ [Tamanho do lote](#debugger-profiling-report-walkthrough-batch-size)
+ [Problemas com a CPU](#debugger-profiling-report-walkthrough-cpu-bottlenecks)
+ [Problemas de E/S](#debugger-profiling-report-walkthrough-io-bottlenecks)
+ [Balanceamento de carga no treinamento com várias GPUs](#debugger-profiling-report-walkthrough-workload-balancing)
+ [Análise de memória da GPU](#debugger-profiling-report-walkthrough-gpu-memory)
## Resumo do trabalho de treinamento
No início do relatório, o Debugger fornece um resumo do seu trabalho de treinamento. Nesta seção, você pode ter uma visão geral das durações e dos registros de data e hora em diferentes fases do treinamento.
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-summary.gif)
A tabela do resumo contém as seguintes informações:
+ **start\$1time: A hora** exata em que o trabalho de treinamento começou.
+ **end\$1time: A hora** exata em que o trabalho de treinamento foi concluído.
+ **job\$1duration\$1in\$1seconds**: O tempo total de treinamento do **horário\$1inicial** até o **horário\$1final**.
+ **training\$1loop\$1start**: A hora exata em que a primeira etapa da primeira época começou.
+ **training\$1loop\$1start**: A hora exata em que a primeira etapa da primeira época começou.
+ **training\$1loop\$1duration\$1in\$1seconds**: O tempo total entre a hora de início do ciclo de treinamento e a hora de término do ciclo de treinamento.
+ **initialization\$1in\$1seconds**: Tempo gasto na inicialização do trabalho de treinamento. A fase de inicialização abrange o período entre o **start\$1time** e o **training\$1loop\$1start time**. O tempo de inicialização é gasto na compilação do script de treinamento, na inicialização do script de treinamento, na criação e na inicialização do modelo, na inicialização de instâncias do EC2 e no download dos dados de treinamento.
+ **finalization\$1in\$1seconds**: Tempo gasto na finalização do trabalho de treinamento, como finalizar o treinamento do modelo, atualizar os artefatos do modelo e fechar as instâncias do EC2. A fase de finalização abrange o período desde o momento **training\$1loop\$1end** ao **end\$1time**.
+ **inicialização (%)**: A porcentagem de tempo gasto na **inicialização** sobre o total de **job\$1duration\$1in\$1seconds**.
+ **ciclo de treinamento (%)**: A porcentagem de tempo gasto no **ciclo de treinamento** sobre o total de **job\$1duration\$1in\$1seconds.**
+ **finalização (%)**: A porcentagem de tempo gasto na **finalização** sobre o total de **job\$1duration\$1in\$1seconds.**
## Estatísticas de uso do sistema
Nesta seção, você pode ver uma visão geral das estatísticas de utilização do sistema.
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-system-usage.png)
O relatório de criação de perfil inclui as seguintes informações:
+ **nó**: Lista o nome dos nós. Se estiver usando treinamento distribuído em vários nós (várias instâncias do EC2), os nomes dos nós estão no formato de. `algo-n`
+ **métrica**: As métricas do sistema coletadas pelo Debugger: CPU, GPU, memória da CPU, memória da GPU, E/S e métricas de rede.
+ **unidade**: A unidade das métricas do sistema.
+ **max**: O valor máximo de cada métrica do sistema.
+ **p99**: O 99º percentil de cada utilização do sistema.
+ **p95**: O 95º percentil de cada utilização do sistema.
+ **p50**: O 50º percentil (médio) de cada utilização do sistema.
+ **min**: O valor mínimo de cada métrica do sistema.
## Resumo das métricas do framework
Nesta seção, os gráficos circulares a seguir mostram o detalhamento das operações da estrutura em CPUs GPUs e.
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-metrics-summary.gif)
Cada um dos gráficos circulares analisa as métricas da framework coletadas em vários aspectos, da seguinte forma:
+ **Proporção entre TRAIN/EVAL fases e outras** — Mostra a proporção entre as durações de tempo gastas em diferentes fases de treinamento.
+ **Razão entre passe para frente e para trás**: Mostra a proporção entre as durações de tempo gastas no passe para frente e para trás no ciclo de treinamento.
+ **Proporção entre CPU/GPU operadores** — Mostra a proporção entre o tempo gasto em operadores que executam em CPU ou GPU, como operadores convolucionais.
+ **Métricas gerais registradas na framework**: Mostra a proporção entre o tempo gasto nas principais métricas da framework, como carregamento de dados, avanço e retrocesso.
### Visão geral: operadores de CPU
Esta seção fornece informações detalhadas sobre os operadores da CPU. A tabela mostra a porcentagem do tempo e o tempo cumulativo absoluto gasto nos operadores de CPU mais frequentemente chamados.
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-cpu-operators.gif)
### Visão geral: operadores de GPU
Esta seção fornece informações detalhadas sobre os operadores de GPU. A tabela mostra a porcentagem de tempo e o tempo acumulado absoluto gasto nos operadores de GPU chamados com mais frequência.
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-gpu-operators.gif)
## Resumo das regras
Nesta seção, o Debugger agrega todos os resultados da avaliação de regras, análises, descrições de regras e sugestões.
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-rules-summary.png)
## Analisando o ciclo de treinamento: durações das etapas
Nesta seção, você pode encontrar estatísticas detalhadas das durações das etapas em cada núcleo da GPU de cada nó. O depurador avalia valores médios, máximos, p99, p95, p50 e mínimos das durações das etapas e avalia os valores discrepantes das etapas. O histograma a seguir mostra as durações das etapas capturadas em diferentes nós de trabalho e. GPUs Você pode ativar ou desativar o histograma de cada operador escolhendo as legendas do lado direito. Você pode verificar se há uma GPU específica que está causando valores atípicos na duração da etapa.
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-step-duration.gif)
## Análise de utilização da GPU
Esta seção mostra as estatísticas detalhadas sobre a utilização do núcleo da GPU com base na regra LowGPUUtilization . Ele também resume as estatísticas de utilização da GPU, média, p95 e p5 para determinar se o trabalho de treinamento está subutilizado. GPUs
## Tamanho do lote
Esta seção mostra as estatísticas detalhadas da utilização total da CPU, das utilizações individuais da GPU e da área ocupada pela memória da GPU. A BatchSize regra determina se você precisa alterar o tamanho do lote para melhor utilizar GPUs o. Você pode verificar se o tamanho do lote é muito pequeno, resultando em subutilização, ou muito grande, causando superutilização e problemas de falta de memória. No gráfico, as caixas mostram os intervalos percentuais p25 e p75 (preenchidos com roxo escuro e amarelo brilhante, respectivamente) da mediana (p50), e as barras de erro mostram o percentil 5 para o limite inferior e o percentil 95 para o limite superior.
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-batch-size.png)
## Problemas com a CPU
Nesta seção, você pode detalhar os gargalos de CPU que a CPUBottleneck regra detectou em seu trabalho de treinamento. A regra verifica se a utilização da CPU está acima `cpu_threshold` (90% por padrão) e também se a utilização da GPU está abaixo `gpu_threshold` (10% por padrão).
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-cpu-bottlenecks.png)
Os gráficos circulares mostram as seguintes informações:
+ **Baixo uso da GPU causado por gargalos da CPU**: Mostra a proporção de pontos de dados entre aqueles com utilização da GPU acima e abaixo do limite e aqueles que correspondem aos critérios de gargalo da CPU.
+ **Proporção entre TRAIN/EVAL fases e outras** — Mostra a proporção entre as durações de tempo gastas em diferentes fases de treinamento.
+ **Razão entre passe para frente e para trás**: Mostra a proporção entre as durações de tempo gastas no passe para frente e para trás no ciclo de treinamento.
+ **Razão entre CPU/GPU operadores** — Mostra a proporção entre as durações de tempo gastas em GPUs e CPUs pelos operadores Python, como processos de carregador de dados e operadores de passagem para frente e para trás.
+ **Métricas gerais registradas na estrutura**: Mostra as principais métricas da estrutura e a proporção entre as durações de tempo gastas nas métricas.
## Problemas de E/S
Nesta seção, você pode encontrar um resumo dos I/O gargalos. A regra avalia o tempo de I/O espera e as taxas de utilização da GPU e monitora se o tempo gasto nos I/O requests exceeds a threshold percent of the total training time. It might indicate I/O gargalos aguarda a chegada dos GPUs dados do armazenamento.
## Balanceamento de carga no treinamento com várias GPUs
Nesta seção, você pode identificar problemas de balanceamento da carga de trabalho em 1. GPUs
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-workload-balancing.gif)
## Análise de memória da GPU
Nesta seção, você pode analisar a utilização da memória da GPU coletada pela regra Increase GPUMemory. No gráfico, as caixas mostram os intervalos percentuais p25 e p75 (preenchidos com roxo escuro e amarelo brilhante, respectivamente) da mediana (p50), e as barras de erro mostram o percentil 5 para o limite inferior e o percentil 95 para o limite superior.
![\[Um exemplo do relatório de criação de perfil do Debugger\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-profiling-report-gpu-memory-utilization.png)
# Opte por não participar da coleção de estatísticas de uso do Amazon SageMaker Debugger
Para todos os trabalhos SageMaker de treinamento, o Amazon SageMaker Debugger executa a [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) regra e gera automaticamente um. [SageMaker Relatório interativo do Debugger](debugger-profiling-report.md) A regra `ProfilerReport` fornece um arquivo de caderno Jupyter (`profiler-report.ipynb`) que gera um arquivo HTML correspondente (`profiler-report.html`).
O Debugger coleta estatísticas de uso do relatório de criação de perfil incluindo código no caderno Jupyter que coleta o ARN da tarefa de processamento exclusiva da regra `ProfilerReport` se o usuário abrir o arquivo final `profiler-report.html`.
O Debugger coleta apenas informações sobre se um usuário abre o relatório HTML final. Ele **NÃO** coleta nenhuma informação de trabalhos de treinamento, dados de treinamento, scripts de treinamento, trabalhos de processamento, logs ou do conteúdo do próprio relatório de criação de perfil.
Você pode desativar a coleta de estatísticas de uso em uma das opções a seguir.
## (Recomendado) Opção 1: optar por não participar antes de executar um trabalho de treinamento
Para optar por não participar, você precisa adicionar a seguinte configuração de regra `ProfilerReport` do Debugger à sua solicitação de trabalho de treinamento:
------
#### [ SageMaker Python SDK ]
```
estimator=sagemaker.estimator.Estimator(
...
rules=ProfilerRule.sagemaker(
base_config=rule_configs.ProfilerReport()
rule_parameters={"opt_out_telemetry": "True"}
)
)
```
------
#### [ AWS CLI ]
```
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport-1234567890",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "ProfilerReport",
"opt_out_telemetry": "True"
}
}
]
```
------
#### [ AWS SDK para Python (Boto3) ]
```
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport-1234567890',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'ProfilerReport',
'opt_out_telemetry': 'True'
}
}
]
```
------
## Opção 2: Optar por não participar após a conclusão de um trabalho de treinamento
Para optar por não participar após a conclusão do treinamento, você precisa modificar o arquivo `profiler-report.ipynb`.
**nota**
Os relatórios HTML gerados automaticamente sem a **Opção 1** já adicionada à sua solicitação de trabalho de treinamento ainda relatam as estatísticas de uso mesmo depois de você optar por não usar a **Opção 2**.
1. Siga as instruções para baixar os arquivos do relatório de criação de perfil do Debugger na página [Baixe o relatório de criação de SageMaker perfil do Debugger](debugger-profiling-report-download.md).
1. Abaixo do diretório `/ProfilerReport-1234567890/profiler-output`, abra `profiler-report.ipynb`.
1. Adicione **opt\$1out=True** à função `setup_profiler_report()` na quinta célula de código, conforme mostrado no código de seguinte exemplo:
```
setup_profiler_report(processing_job_arn, opt_out=True)
```
1. Execute a célula de código para concluir a exclusão.
# Analise dados usando a biblioteca cliente do Debugger Python
[Enquanto seu trabalho de treinamento estiver em execução ou depois de concluído, você pode acessar os dados de treinamento coletados pelo Debugger usando o [SDK do Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) e a biblioteca do cliente. SMDebug ](https://github.com/awslabs/sagemaker-debugger/) A biblioteca cliente do Debugger Python fornece ferramentas de análise e visualização que permitem que você se aprofunde nos dados do seu trabalho de treinamento.
**Para instalar a biblioteca e usar suas ferramentas de análise (em um JupyterLab notebook ou kernel do IPython)**
```
! pip install -U smdebug
```
Os tópicos a seguir explicam como usar as ferramentas do Debugger Python para visualizar e analisar os dados de treinamento coletados pelo Debugger.
**Analise as métricas do sistema e da estrutura**
+ [Acesse os dados do perfil](debugger-analyze-data-profiling.md)
+ [Faça um gráfico das métricas do sistema e dos dados de métricas da estrutura](debugger-access-data-profiling-default-plot.md)
+ [Acesse os dados de criação de perfil usando a ferramenta de análise de dados pandas](debugger-access-data-profiling-pandas-frame.md)
+ [Acesse os dados de estatísticas de perfil do Python](debugger-access-data-python-profiling.md)
+ [Mesclar cronogramas de vários arquivos de rastreamento de perfil](debugger-merge-timeline.md)
+ [Criação de perfil de carregadores de dados](debugger-data-loading-time.md)
# Acesse os dados do perfil
A SMDebug `TrainingJob` classe lê dados do bucket do S3 em que as métricas do sistema e da estrutura são salvas.
**Para configurar um objeto `TrainingJob` e recuperar arquivos de eventos de criação de perfil de um trabalho de treinamento**
```
from smdebug.profiler.analysis.notebook_utils.training_job import TrainingJob
tj = TrainingJob(training_job_name, region)
```
**dica**
Você precisa especificar os parâmetros `training_job_name` e `region` para se registrar em um trabalho de treinamento. Há duas maneiras de especificar as informações do trabalho de treinamento:
Use o SDK do SageMaker Python enquanto o estimador ainda estiver vinculado ao trabalho de treinamento.
```
import sagemaker
training_job_name=estimator.latest_training_job.job_name
region=sagemaker.Session().boto_region_name
```
Passe os strings diretamente.
```
training_job_name="your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS"
region="us-west-2"
```
**nota**
Por padrão, o SageMaker Debugger coleta métricas do sistema para monitorar a utilização dos recursos de hardware e os gargalos do sistema. Executando as funções a seguir, você pode receber mensagens de erro relacionadas à indisponibilidade das métricas da estrutura. Para recuperar dados de criação de perfil da estrutura e obter informações sobre as operações da estrutura, habilite a criação de perfil da estrutura.
Se você usa o SDK do SageMaker Python para manipular sua solicitação de trabalho de treinamento, transmita o `framework_profile_params` para o `profiler_config` argumento do seu estimador. Para saber mais, consulte [Configurar o perfil do SageMaker Debugger Framework](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-framework-profiling.html).
Se você usa o Studio Classic, ative a criação de perfil usando o botão de alternância **Criação de perfil** no painel de insights do Depurador. Para saber mais, consulte [SageMaker Debugger Insights](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio-insights-controllers.html) Dashboard Controller.
**Para recuperar uma descrição da descrição do trabalho de treinamento e o URI do bucket do S3 em que os dados métricos são salvos**
```
tj.describe_training_job()
tj.get_config_and_profiler_s3_output_path()
```
**Para verificar se as métricas do sistema e da estrutura estão disponíveis no URI do S3**
```
tj.wait_for_sys_profiling_data_to_be_available()
tj.wait_for_framework_profiling_data_to_be_available()
```
**Para criar objetos de leitura do sistema e da estrutura após a disponibilização dos dados métricos**
```
system_metrics_reader = tj.get_systems_metrics_reader()
framework_metrics_reader = tj.get_framework_metrics_reader()
```
**Para atualizar e recuperar os arquivos mais recentes do evento de treinamento**
Os objetos do leitor têm um método estendido, `refresh_event_file_list()`, para recuperar os arquivos de eventos de treinamento mais recentes.
```
system_metrics_reader.refresh_event_file_list()
framework_metrics_reader.refresh_event_file_list()
```
# Faça um gráfico das métricas do sistema e dos dados de métricas da estrutura
Você pode usar os objetos de métricas do sistema e do algoritmo das seguintes classes de visualização para traçar gráficos e histogramas da linha do tempo:
**nota**
Para visualizar os dados com métricas restritas nos seguintes métodos de gráfico de objetos de visualização, especifique os parâmetros `select_dimensions` e `select_events`: Por exemplo, se você especificar `select_dimensions=["GPU"]`, os métodos de plotagem filtram as métricas que incluem a palavra-chave “GPU”. Se você especificar `select_events=["total"]`, os métodos de plotagem filtrarão as métricas que incluem as tags de eventos “totais” no final dos nomes das métricas. Se você habilitar esses parâmetros e fornecer as sequências de palavras-chave, as classes de visualização retornarão os gráficos com métricas filtradas.
+ A classe `MetricsHistogram`
```
from smdebug.profiler.analysis.notebook_utils.metrics_histogram import MetricsHistogram
metrics_histogram = MetricsHistogram(system_metrics_reader)
metrics_histogram.plot(
starttime=0,
endtime=system_metrics_reader.get_timestamp_of_latest_available_file(),
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"] # optional
)
```
+ A classe `StepTimelineChart`
```
from smdebug.profiler.analysis.notebook_utils.step_timeline_chart import StepTimelineChart
view_step_timeline_chart = StepTimelineChart(framework_metrics_reader)
```
+ A classe `StepHistogram`
```
from smdebug.profiler.analysis.notebook_utils.step_histogram import StepHistogram
step_histogram = StepHistogram(framework_metrics_reader)
step_histogram.plot(
starttime=step_histogram.last_timestamp - 5 * 1000 * 1000,
endtime=step_histogram.last_timestamp,
show_workers=True
)
```
+ A classe `TimelineCharts`
```
from smdebug.profiler.analysis.notebook_utils.timeline_charts import TimelineCharts
view_timeline_charts = TimelineCharts(
system_metrics_reader,
framework_metrics_reader,
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"] # optional
)
view_timeline_charts.plot_detailed_profiler_data([700,710])
```
+ A classe `Heatmap`
```
from smdebug.profiler.analysis.notebook_utils.heatmap import Heatmap
view_heatmap = Heatmap(
system_metrics_reader,
framework_metrics_reader,
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"], # optional
plot_height=450
)
```
# Acesse os dados de criação de perfil usando a ferramenta de análise de dados pandas
A `PandasFrame` classe a seguir fornece ferramentas para converter os dados de perfil coletados no quadro de dados Pandas.
```
from smdebug.profiler.analysis.utils.profiler_data_to_pandas import PandasFrame
```
A classe `PandasFrame` segue o caminho de saída do bucket S3 do objeto `tj` e seus métodos `get_all_system_metrics()` `get_all_framework_metrics()` retornam métricas do sistema e métricas da estrutura no formato de dados Pandas.
```
pf = PandasFrame(tj.profiler_s3_output_path)
system_metrics_df = pf.get_all_system_metrics()
framework_metrics_df = pf.get_all_framework_metrics(
selected_framework_metrics=[
'Step:ModeKeys.TRAIN',
'Step:ModeKeys.GLOBAL'
]
)
```
# Acesse os dados de estatísticas de perfil do Python
O perfil do Python fornece métricas de estrutura relacionadas às funções e operadores do Python em seus scripts de treinamento e nas estruturas de aprendizado profundo de IA. SageMaker
**Modos e fases de treinamento para criação de perfil em Python**
Para traçar o perfil de intervalos específicos durante o treinamento para particionar estatísticas para cada um desses intervalos, o Debugger fornece ferramentas para definir modos e fases.
Para modos de treinamento, use a seguinte classe `PythonProfileModes`:
```
from smdebug.profiler.python_profile_utils import PythonProfileModes
```
Essa classe fornece as seguintes opções:
+ `PythonProfileModes.TRAIN`: Use se quiser traçar o perfil das etapas desejadas na fase de treinamento. Esta opção de modo está disponível somente para TensorFlow.
+ `PythonProfileModes.EVAL`: Use se quiser traçar o perfil das etapas desejadas na fase de avaliação. Esta opção de modo está disponível somente para TensorFlow.
+ `PythonProfileModes.PREDICT`: Use se quiser traçar o perfil das etapas desejadas na fase de predição. Esta opção de modo está disponível somente para TensorFlow.
+ `PythonProfileModes.GLOBAL`: Use se quiser traçar o perfil das etapas de destino na fase global, que inclui as três fases anteriores. Esta opção de modo está disponível somente para PyTorch.
+ `PythonProfileModes.PRE_STEP_ZERO`: Use se quiser traçar o perfil das etapas de destino no estágio de inicialização antes do início da primeira etapa de treinamento da primeira época. Essa fase inclui o envio inicial do trabalho, o upload dos scripts de treinamento para as instâncias do EC2, a preparação das instâncias do EC2 e o download dos dados de entrada. Esta opção de modo está disponível para TensorFlow PyTorch e.
+ `PythonProfileModes.POST_HOOK_CLOSE`: Use se quiser traçar o perfil das etapas de destino no estágio de finalização após a conclusão do trabalho de treinamento e o hook do Debugger estiver fechado. Essa fase inclui dados de criação de perfil enquanto os trabalhos de treinamento são finalizados e concluídos. Esta opção de modo está disponível para TensorFlow PyTorch e.
Para fases de treinamento, use a classe `StepPhase` a seguir:
```
from smdebug.profiler.analysis.utils.python_profile_analysis_utils import StepPhase
```
Essa classe fornece as seguintes opções:
+ `StepPhase.START`: Use para especificar o ponto inicial da fase de inicialização.
+ `StepPhase.STEP_START`: Use para especificar o ponto inicial da fase de treinamento.
+ `StepPhase.FORWARD_PASS_END`: Use para especificar as etapas em que a passagem para frente termina. Essa opção está disponível somente para PyTorch.
+ `StepPhase.STEP_END`: Use para especificar o ponto final da fase de treinamento. Essa opção está disponível somente para TensorFlow.
+ `StepPhase.END`— Use para especificar o ponto final da fase de finalização (post-hook-close). Se o hook de retorno de chamada não estiver fechado, a criação do perfil da fase de finalização não ocorrerá.
**Ferramentas de análise de perfil do Python**
O Debugger é compatível com a criação de perfil do Python com duas ferramentas de criação de perfil:
+ cProfile: O criador de perfil padrão do Python. O cProfile coleta métricas da estrutura sobre o tempo de CPU para cada função chamada quando a criação de perfil foi ativada.
+ Pyinstrument: Este é um criador de perfil Python de baixa sobrecarga que amostra eventos de criação de perfil a cada milissegundo.
Para saber mais sobre as opções de criação de perfil do Python e o que é coletado, consulte [Monitoramento padrão do sistema e a criação de perfil personalizado de framework com diferentes opções de criação de perfil](debugger-configure-framework-profiling-options.md).
Os seguintes métodos das classes`PythonProfileAnalysis`, `cProfileAnalysis`, `PyinstrumentAnalysis` são fornecidos para buscar e analisar os dados de criação de perfil do Python: Cada função carrega os dados mais recentes do URI padrão do S3.
```
from smdebug.profiler.analysis.python_profile_analysis import PythonProfileAnalysis, cProfileAnalysis, PyinstrumentAnalysis
```
Para definir objetos de criação de perfil do Python para análise, use as PyinstrumentAnalysis classes cProfileAnalysis ou conforme mostrado no código de exemplo a seguir. Ele mostra como definir um objeto `cProfileAnalysis` e, se você quiser usar `PyinstrumentAnalysis`, tem que substituir o nome da classe.
```
python_analysis = cProfileAnalysis(
local_profile_dir=tf_python_stats_dir,
s3_path=tj.profiler_s3_output_path
)
```
Os métodos a seguir estão disponíveis para as `PyinstrumentAnalysis` classes `cProfileAnalysis` e buscarem os dados estatísticos de perfil do Python:
+ `python_analysis.fetch_python_profile_stats_by_time(start_time_since_epoch_in_secs, end_time_since_epoch_in_secs)`: Assume a hora de início e a hora de término e retorna as estatísticas de função das estatísticas da etapa cujos horários de início ou término se sobrepõem ao intervalo fornecido.
+ `python_analysis.fetch_python_profile_stats_by_step(start_step, end_step, mode, start_phase, end_phase)`: Assume uma etapa inicial e uma etapa final e retorna as estatísticas da função de todas as estatísticas da etapa em que o perfil `step` satisfaz `start_step <= step < end_step`.
+ `start_step` e `end_step` (str): Especifique a etapa inicial e a etapa final para buscar os dados de estatísticas de perfil do Python.
+ `mode` (str): Especifique o modo de trabalho de treinamento usando a classe do `PythonProfileModes` enumerador. O padrão é `PythonProfileModes.TRAIN`. As opções disponíveis são fornecidas na seção [Modos e fases de treinamento para criação de perfil em Python](#debugger-access-data-python-profiling-modes).
+ `start_phase`(str): Especifique a fase inicial nas etapas de destino usando a classe `StepPhase` do enumerador. Esse parâmetro permite a criação de perfis entre as diferentes fases do treinamento. O padrão é `StepPhase.STEP_START`. As opções disponíveis são fornecidas na seção [Modos e fases de treinamento para criação de perfil em Python](#debugger-access-data-python-profiling-phases).
+ `end_phase`(str): Especifique a fase final nas etapas de destino usando a classe `StepPhase` do enumerador. Esse parâmetro configura a fase final do treinamento. As opções disponíveis são as mesmas do parâmetro `start_phase`. O padrão é `StepPhase.STEP_END`. As opções disponíveis são fornecidas na seção [Modos e fases de treinamento para criação de perfil em Python](#debugger-access-data-python-profiling-phases).
+ `python_analysis.fetch_profile_stats_between_modes(start_mode, end_mode)`: Busca estatísticas do perfil do Python entre os modos inicial e final.
+ `python_analysis.fetch_pre_step_zero_profile_stats()`: Busca as estatísticas da criação de perfil do Python até a etapa 0.
+ `python_analysis.fetch_post_hook_close_profile_stats()`: Busca estatísticas do perfil do Python depois que o hook é fechado.
+ `python_analysis.list_profile_stats()`— Retorna uma DataFrame das estatísticas de criação de perfil do Python. Cada linha contém os metadados de cada instância de criação de perfil e o arquivo de estatísticas correspondente (um por etapa).
+ `python_analysis.list_available_node_ids()`— Retorna uma lista do nó disponível IDs para as estatísticas de criação de perfil do Python.
Os métodos específicos da classe `cProfileAnalysis`:
+ `fetch_profile_stats_by_training_phase()`: Busca e agrega as estatísticas de criação de perfil do Python para todas as combinações possíveis dos modos inicial e final. Por exemplo, se as fases de treinamento e validação forem concluídas enquanto a criação de perfil detalhada estiver ativada, as combinações serão `(PRE_STEP_ZERO, TRAIN)`, `(TRAIN, TRAIN)`, `(TRAIN, EVAL)`, `(EVAL, EVAL)` e `(EVAL, POST_HOOK_CLOSE)`, Todos os arquivos de estatísticas em cada uma dessas combinações são agregados.
+ `fetch_profile_stats_by_job_phase()`: Busca e agrega as estatísticas de criação de perfil do Python por fase do trabalho. As fases do trabalho são `initialization` (criação de perfil até a etapa 0), `training_loop` (treinamento e validação) e `finalization` (criação de perfil após o fechamento do hook).
# Mesclar cronogramas de vários arquivos de rastreamento de perfil
A biblioteca SMDebug cliente fornece ferramentas de análise e visualização de perfil para mesclar cronogramas de métricas do sistema, métricas de estrutura e dados de perfil do Python coletados pelo Debugger.
**dica**
Antes de continuar, você precisa definir um TrainingJob objeto que será utilizado nos exemplos desta página. Para obter mais informações sobre como configurar um TrainingJob objeto, consulte[Acesse os dados do perfil](debugger-analyze-data-profiling.md).
A classe `MergedTimeline` fornece ferramentas para integrar e correlacionar diferentes informações de perfil em um único cronograma. Depois que o Debugger captura dados de perfil e anotações de diferentes fases de um trabalho de treinamento, os arquivos JSON de eventos de rastreamento são salvos em um diretório padrão. `tracefolder`
+ Para anotações nas camadas do Python, os arquivos de rastreamento são salvos em `*pythontimeline.json`.
+ Para anotações nas camadas de TensorFlow C\$1\$1, os arquivos de rastreamento são salvos em. `*model_timeline.json`
+ O Tensorflow Profiler salva eventos em um arquivo. `*trace.json.gz`
**dica**
Se você quiser listar todos os arquivos de rastreamento JSON, use o comando da AWS CLI a seguir:
```
! aws s3 ls {tj.profiler_s3_output_path} --recursive | grep '\.json$'
```
Conforme mostrado na captura de tela animada a seguir, colocar e alinhar os eventos de rastreamento capturados das diferentes fontes de perfil em um único gráfico pode propiciar uma visão geral de todos os eventos que ocorrem em diferentes fases do trabalho de treinamento.
![\[Um exemplo de cronograma mesclado\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/debugger/debugger-merged-timeline.gif)
**dica**
Para interagir com a linha do tempo mesclada na aplicação de rastreamento usando um teclado, use a tecla `W` para ampliar, a tecla `A` para deslocar para a esquerda, a tecla `S` para diminuir o zoom e a tecla `D` para deslocar para a direita.
Os vários arquivos JSON de rastreamento de eventos podem ser mesclados em um arquivo JSON de eventos de rastreamento usando a seguinte operação de API `MergedTimeline` e o método de classe `smdebug.profiler.analysis.utils.merge_timelines` do módulo:
```
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
combined_timeline = MergedTimeline(path, file_suffix_filter, output_directory)
combined_timeline.merge_timeline(start, end, unit)
```
A operação da API `MergedTimeline` passa os seguintes parâmetros:
+ `path`(str): Especifique uma pasta raiz (`/profiler-output`) que contenha arquivos de rastreamento de perfil do sistema e da estrutura. Você pode localizar o `profiler-output` usando o método de classe do estimador de SageMaker IA ou o objeto. TrainingJob Por exemplo, `estimator.latest_job_profiler_artifacts_path()` ou `tj.profiler_s3_output_path`.
+ `file_suffix_filter`(lista): Especifique uma lista de filtros de sufixo de arquivo para mesclar cronogramas. Os filtros de sufixo disponíveis são `["model_timeline.json", "pythontimeline.json", "trace.json.gz"].` Se esse parâmetro não for especificado manualmente, todos os arquivos de rastreamento serão mesclados por padrão.
+ `output_directory`(str): Especifique um caminho para salvar o arquivo JSON da linha do tempo mesclada. O padrão é para o diretório especificado para o parâmetro `path`.
O classmethod `merge_timeline()` passa os seguintes parâmetros para executar o processo de mesclagem:
+ `start`(int): Especifique a hora de início (em microssegundos e no formato de hora Unix) ou a etapa inicial para mesclar cronogramas.
+ `end`(int): Especifique a hora do final (em microssegundos e no formato de hora Unix) ou a etapa inicial para mesclar cronogramas.
+ `unit`(str): Escolha entre `"time"` e `"step"`. O padrão é `"time"`.
Usando os códigos de exemplo a seguir, execute o método `merge_timeline()` e baixe o arquivo JSON mesclado.
+ Mescle a linha do tempo com a opção de unidade `"time"`. O código de exemplo a seguir mescla todos os arquivos de rastreamento disponíveis entre o horário de início do Unix (o horário Unix zero absoluto) e o horário Unix atual, o que significa que você pode mesclar os cronogramas ao longo de toda a duração do treinamento.
```
import time
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
from smdebug.profiler.profiler_constants import CONVERT_TO_MICROSECS
combined_timeline = MergedTimeline(tj.profiler_s3_output_path, output_directory="./")
combined_timeline.merge_timeline(0, int(time.time() * CONVERT_TO_MICROSECS))
```
+ Mescle a linha do tempo com a opção de unidade `"step"`. O código de exemplo a seguir mescla todos os cronogramas disponíveis entre as etapas 3 e 9.
```
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
combined_timeline = MergedTimeline(tj.profiler_s3_output_path, output_directory="./")
combined_timeline.merge_timeline(3, 9, unit="step")
```
Abra a aplicação de rastreamento do Chrome `chrome://tracing` em um navegador Chrome e abra o arquivo JSON. Você pode explorar a saída para traçar a linha do tempo mesclada.
# Criação de perfil de carregadores de dados
Em PyTorch, os iteradores do carregador de dados, como `SingleProcessingDataLoaderIter` e`MultiProcessingDataLoaderIter`, são iniciados no início de cada iteração em um conjunto de dados. Durante a fase de inicialização, PyTorch ativa os processos de trabalho, dependendo do número configurado de trabalhadores, estabelece uma fila de dados para buscar dados e threads. `pin_memory`
Para usar a ferramenta de análise de perfil do carregador de PyTorch dados, importe a seguinte classe: `PT_dataloader_analysis`
```
from smdebug.profiler.analysis.utils.pytorch_dataloader_analysis import PT_dataloader_analysis
```
Passe os dados de perfil recuperados como um objeto de dados do quadro Pandas na seção [Acesse os dados de criação de perfil usando a ferramenta de análise de dados pandas](debugger-access-data-profiling-pandas-frame.md):
```
pt_analysis = PT_dataloader_analysis(pf)
```
As seguintes funções estão disponíveis para o objeto `pt_analysis`:
A SMDebug `S3SystemMetricsReader` classe lê as métricas do sistema do bucket do S3 especificado para o `s3_trial_path` parâmetro.
+ `pt_analysis.analyze_dataloaderIter_initialization()`
A análise gera a mediana e a duração máxima dessas inicializações. Se houver valores discrepantes (ou seja, a duração for maior que a mediana 2 \$1), a função imprime os horários de início e término dessas durações. Eles podem ser usados para inspecionar as métricas do sistema durante esses intervalos de tempo.
A seguinte lista mostra quais análises estão disponíveis nesse método de classe:
+ Que tipo de iteradores do carregador de dados foram inicializados.
+ O número de operadores por iterador.
+ Inspecione se o iterador foi inicializado com ou sem pin\$1memory.
+ Número de vezes que os iteradores foram inicializados durante o treinamento.
+ `pt_analysis.analyze_dataloaderWorkers()`
A seguinte lista mostra quais análises estão disponíveis nesse método de classe:
+ O número de processos de trabalho que foram desmembrados durante todo o treinamento.
+ Duração média e máxima dos processos de trabalho.
+ Horário de início e de término dos processos de trabalho que são atípicos.
+ `pt_analysis.analyze_dataloader_getnext()`
A seguinte lista mostra quais análises estão disponíveis nesse método de classe:
+ Número de GetNext chamadas feitas durante o treinamento.
+ Duração média e máxima em microssegundos das chamadas. GetNext
+ Hora de início, hora de término, duração e ID do trabalhador para a duração da GetNext chamada atípica.
+ `pt_analysis.analyze_batchtime(start_timestamp, end_timestamp, select_events=[".*"], select_dimensions=[".*"])`
O Debugger coleta os horários de início e término de todas as chamadas. GetNext Você pode encontrar a quantidade de tempo gasto pelo script de treinamento em um lote de dados. Dentro da janela de tempo especificada, você pode identificar as chamadas que não estão contribuindo diretamente para o treinamento. Essas chamadas podem ser provenientes das seguintes operações: calcular a precisão, adicionar as perdas para fins de depuração ou registro e imprimir as informações de depuração. Operações como essas podem ser demoradas ou intensivas em termos de computação. Podemos identificar essas operações correlacionando o perfil do Python, as métricas do sistema e as métricas da estrutura.
A seguinte lista mostra quais análises estão disponíveis nesse método de classe:
+ Crie o perfil do tempo gasto em cada lote de dados`BatchTime_in_seconds`, encontrando a diferença entre os horários de início das GetNext chamadas atuais e subsequentes.
+ Encontre os valores atípicos em `BatchTime_in_seconds` e os horários de início e término desses valores discrepantes.
+ Obtenha as métricas do sistema e da estrutura durante esses registros de data e hora `BatchTime_in_seconds`. Isso indica onde o tempo foi gasto.
+ `pt_analysis.plot_the_window()`
Traça um gráfico de linha do tempo entre um carimbo de data e hora de início e fim.