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

# Analise dados usando a biblioteca cliente do Debugger Python
<a name="debugger-analyze-data"></a>

[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 name="debugger-analyze-data-profiling"></a>

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
<a name="debugger-access-data-profiling-default-plot"></a>

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 name="debugger-access-data-profiling-pandas-frame"></a>

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
<a name="debugger-access-data-python-profiling"></a>

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 

<a name="debugger-access-data-python-profiling-modes"></a>**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.

<a name="debugger-access-data-python-profiling-phases"></a>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 name="debugger-merge-timeline"></a>

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
<a name="debugger-data-loading-time"></a>

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.