Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Análisis de datos mediante la biblioteca cliente de Python del depurador
<a name="debugger-analyze-data"></a>

Mientras su trabajo de entrenamiento esté en ejecución o cuando lo haya completado, puede acceder a los datos de entrenamiento recopilados por Debugger mediante el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) y la [biblioteca SMDebug cliente](https://github.com/awslabs/sagemaker-debugger/). La biblioteca cliente de Python del depurador proporciona herramientas de análisis y visualización que le permiten profundizar en los datos de sus trabajos de entrenamiento.

**Para instalar la biblioteca y utilizar sus herramientas de análisis (en un JupyterLab cuaderno o en un núcleo de iPython)**

```
! pip install -U smdebug
```

En los siguientes temas, se explica cómo utilizar las herramientas de Python del depurador para visualizar y analizar los datos de entrenamiento recopilados por este.

**Analizar las métricas del sistema y del marco**
+ [Acceso a los datos del perfil](debugger-analyze-data-profiling.md)
+ [Representación gráfica de los datos sobre las métricas del sistema y las métricas del marco](debugger-access-data-profiling-default-plot.md)
+ [Acceso a los datos de creación de perfiles con Pandas, una herramienta de análisis de datos](debugger-access-data-profiling-pandas-frame.md)
+ [Acceso a los datos de estadísticas de creación de perfiles de Python](debugger-access-data-python-profiling.md)
+ [Fusión de cronogramas en múltiples archivos de seguimiento de perfiles](debugger-merge-timeline.md)
+ [Cargadores de datos de creación de perfiles](debugger-data-loading-time.md)

# Acceso a los datos del perfil
<a name="debugger-analyze-data-profiling"></a>

La SMDebug `TrainingJob` clase lee los datos del depósito de S3 donde se guardan las métricas del sistema y del marco. 

**Para configurar un objeto `TrainingJob` y recuperar los archivos de eventos de creación de perfiles de un trabajo de entrenamiento**

```
from smdebug.profiler.analysis.notebook_utils.training_job import TrainingJob
tj = TrainingJob(training_job_name, region)
```

**sugerencia**  
Debe especificar los parámetros `training_job_name` y `region` para iniciar sesión en un trabajo de entrenamiento. Hay dos formas de especificar la información del trabajo de entrenamiento:   
Utilice el SDK de SageMaker Python mientras el estimador aún esté adjunto al trabajo de formación.  

  ```
  import sagemaker
  training_job_name=estimator.latest_training_job.job_name
  region=sagemaker.Session().boto_region_name
  ```
Pasar las cadenas directamente.  

  ```
  training_job_name="your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS"
  region="us-west-2"
  ```

**nota**  
De forma predeterminada, SageMaker Debugger recopila las métricas del sistema para monitorear la utilización de los recursos de hardware y los cuellos de botella del sistema. Al ejecutar las siguientes funciones, es posible que reciba mensajes de error relacionados con la falta de disponibilidad de las métricas del marco. Para recuperar los datos de creación de perfiles del marco y obtener información sobre las operaciones de este, debe habilitar la creación de perfiles del marco.  
Si utilizas el SDK de SageMaker Python para manipular tu solicitud de trabajo de formación, pasa el `profiler_config` argumento `framework_profile_params` al de tu estimador. Para obtener más información, consulte [Configurar la creación de perfiles de SageMaker Debugger Framework](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-framework-profiling.html).
Si utiliza Studio Classic, active la creación de perfiles con el conmutador **Elaboración de perfiles** en el panel de información del depurador. Para obtener más información, consulte [SageMaker Debugger Insights](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio-insights-controllers.html) Dashboard Controller.

**Para recuperar una descripción del trabajo de entrenamiento y el URI del bucket de S3 en el que se guardan los datos de las métricas**

```
tj.describe_training_job()
tj.get_config_and_profiler_s3_output_path()
```

**Para comprobar si las métricas del sistema y del marco están disponibles en el URI de S3**

```
tj.wait_for_sys_profiling_data_to_be_available()
tj.wait_for_framework_profiling_data_to_be_available()
```

**Para crear objetos lectores del sistema y del marco cuando los datos de las métricas estén disponibles**

```
system_metrics_reader = tj.get_systems_metrics_reader()
framework_metrics_reader = tj.get_framework_metrics_reader()
```

**Para actualizar y recuperar los archivos de eventos de entrenamiento más recientes**

Los objetos lectores tienen un método extendido (`refresh_event_file_list()`) para recuperar los archivos de eventos de entrenamiento más recientes.

```
system_metrics_reader.refresh_event_file_list()
framework_metrics_reader.refresh_event_file_list()
```

# Representación gráfica de los datos sobre las métricas del sistema y las métricas del marco
<a name="debugger-access-data-profiling-default-plot"></a>

Puede utilizar los objetos de métricas del sistema y del algoritmo de las siguientes clases de visualización para trazar histogramas y gráficos con línea de tiempo.

**nota**  
Para visualizar los datos con métricas reducidas en los siguientes métodos de representación gráfica de objetos de visualización, especifique los parámetros `select_dimensions` y `select_events`. Por ejemplo, si especifica `select_dimensions=["GPU"]`, los métodos de representación gráfica filtrarán las métricas que incluyan la palabra clave “GPU”. Si especifica `select_events=["total"]`, los métodos de representación gráfica filtrarán las métricas que incluyan las etiquetas de eventos “totales” al final de los nombres de las métricas. Si habilita estos parámetros y proporciona las cadenas de palabras clave, las clases de visualización devuelven los gráficos con métricas filtradas.
+ La clase `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
  )
  ```
+ La clase `StepTimelineChart`

  ```
  from smdebug.profiler.analysis.notebook_utils.step_timeline_chart import StepTimelineChart
  
  view_step_timeline_chart = StepTimelineChart(framework_metrics_reader)
  ```
+ La clase `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
  )
  ```
+ La clase `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])
  ```
+ La clase `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
  )
  ```

# Acceso a los datos de creación de perfiles con Pandas, una herramienta de análisis de datos
<a name="debugger-access-data-profiling-pandas-frame"></a>

La siguiente clase `PandasFrame` proporciona herramientas para convertir los datos de creación de perfiles recopilados al marco de datos de Pandas. 

```
from smdebug.profiler.analysis.utils.profiler_data_to_pandas import PandasFrame
```

La clase `PandasFrame` toma la ruta de salida del bucket S3 del objeto `tj`, y sus métodos `get_all_system_metrics()` y `get_all_framework_metrics()` devuelven las métricas del sistema y las métricas del marco en el formato de datos de 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'
    ]
)
```

# Acceso a los datos de estadísticas de creación de perfiles de Python
<a name="debugger-access-data-python-profiling"></a>

La creación de perfiles de Python proporciona métricas del marco relacionadas con las funciones y los operadores de Python en sus scripts de entrenamiento y en los marcos de aprendizaje profundo de SageMaker IA. 

<a name="debugger-access-data-python-profiling-modes"></a>**Modos y fases de entrenamiento para la creación de perfiles en Python**

A fin de elaborar perfiles de intervalos específicos durante el entrenamiento y segmentar las estadísticas de cada uno de estos intervalos, el depurador proporciona herramientas para establecer modos y fases. 

Para los modos de entrenamiento, utilice la siguiente clase `PythonProfileModes`:

```
from smdebug.profiler.python_profile_utils import PythonProfileModes
```

Esta clase proporciona las siguientes opciones.
+ `PythonProfileModes.TRAIN`: úsela si quiere elaborar perfiles de los pasos previstos en la fase de entrenamiento. Esta opción de modo solo está disponible para TensorFlow.
+ `PythonProfileModes.EVAL`: úsela si quiere elaborar perfiles de los pasos previstos en la fase de evaluación. Esta opción de modo solo está disponible para TensorFlow.
+ `PythonProfileModes.PREDICT`: úsela si quiere elaborar perfiles de los pasos previstos en la fase de predicción. Esta opción de modo solo está disponible para TensorFlow.
+ `PythonProfileModes.GLOBAL`: úsela si desea elaborar perfiles de los pasos previstos en la fase global, lo que incluye las tres fases previas. Esta opción de modo solo está disponible para PyTorch.
+ `PythonProfileModes.PRE_STEP_ZERO`: úsela si desea elaborar perfiles de los pasos previstos en la fase de inicialización, antes de que comience el primer paso de entrenamiento del primer epoch. Esta fase incluye el envío del trabajo inicial, la carga de los scripts de entrenamiento en las instancias de EC2, la preparación de las instancias de EC2 y la descarga de los datos de entrada. Esta opción de modo está disponible tanto para como TensorFlow para PyTorch.
+ `PythonProfileModes.POST_HOOK_CLOSE`: úsela si desea elaborar perfiles de los pasos previstos en la fase de finalización, tras el trabajo de entrenamiento y tras cerrar el enlace del depurador. Esta fase incluye la elaboración de perfiles mientras se finalizan y completan los trabajos de entrenamiento. Esta opción de modo está disponible tanto para como TensorFlow para PyTorch.

<a name="debugger-access-data-python-profiling-phases"></a>Para las fases de entrenamiento, utilice la siguiente clase `StepPhase`:

```
from smdebug.profiler.analysis.utils.python_profile_analysis_utils import StepPhase
```

Esta clase proporciona las siguientes opciones.
+ `StepPhase.START`: se utiliza para especificar el punto de inicio de la fase de inicialización.
+ `StepPhase.STEP_START`: se utiliza para especificar el paso de inicio de la fase de entrenamiento.
+ `StepPhase.FORWARD_PASS_END`: se utiliza para especificar los pasos en los que termina la propagación hacia delante. Esta opción solo está disponible para PyTorch.
+ `StepPhase.STEP_END`: se utiliza para especificar los pasos finales de la fase de entrenamiento. Esta opción solo está disponible para TensorFlow.
+ `StepPhase.END`— Se utiliza para especificar el punto final de la fase de finalización (post-hook-close). Si el enlace de devolución de llamada no está cerrado, no se lleva a cabo la creación de perfiles de la fase de finalización.

**Herramientas de Python para el análisis en la elaboración de perfiles**

El depurador es compatible con la creación de perfiles de Python mediante dos herramientas de creación de perfiles:
+ cProfile: el generador de perfiles estándar de Python. cProfile recopila métricas del marco sobre el tiempo de CPU para cada función llamada cuando la creación de perfiles estaba habilitada.
+ Pyinstrument: un generador de perfiles de Python de bajo costo que muestrea eventos de creación de perfiles con una frecuencia de milisegundos.

Para obtener más información sobre las opciones de creación de perfiles de Python y lo que se recopila, consulte [Supervisión del sistema predeterminada y creación de perfiles de marco personalizada con diferentes opciones de creación de perfiles](debugger-configure-framework-profiling-options.md).

Los siguientes métodos de las clases `PythonProfileAnalysis`, `cProfileAnalysis` y `PyinstrumentAnalysis` se proporcionan para obtener y analizar los datos de creación de perfiles de Python. Cada función carga los datos más recientes del URI de S3 predeterminado.

```
from smdebug.profiler.analysis.python_profile_analysis import PythonProfileAnalysis, cProfileAnalysis, PyinstrumentAnalysis
```

Para configurar los objetos de creación de perfiles de Python para su análisis, utilice las PyinstrumentAnalysis clases cProfileAnalysis o como se muestra en el siguiente código de ejemplo. Muestra cómo configurar un objeto `cProfileAnalysis` y, si desea usar `PyinstrumentAnalysis`, cómo reemplazar el nombre de la clase.

```
python_analysis = cProfileAnalysis(
    local_profile_dir=tf_python_stats_dir, 
    s3_path=tj.profiler_s3_output_path
)
```

Hay los siguientes métodos disponibles para las clases `PyinstrumentAnalysis` y `cProfileAnalysis`, a fin de obtener los datos de las estadísticas de creación de perfiles de Python.
+ `python_analysis.fetch_python_profile_stats_by_time(start_time_since_epoch_in_secs, end_time_since_epoch_in_secs)`: toma en cuenta la hora de inicio y la hora de finalización y devuelve las estadísticas de función de los pasos cuyas horas de inicio o finalización coinciden con el intervalo proporcionado.
+ `python_analysis.fetch_python_profile_stats_by_step(start_step, end_step, mode, start_phase, end_phase)`: incluye un paso de inicio y un paso final y devuelve las estadísticas de función de todas las estadísticas de paso cuyo `step` perfilado cumpla con `start_step <= step < end_step`. 
  + `start_step` y `end_step` (str): especifique el paso de inicio y el paso final para obtener los datos de las estadísticas de creación de perfiles de Python.
  + `mode` (str): especifique el modo del trabajo de entrenamiento mediante la clase enumeradora `PythonProfileModes`. El valor predeterminado es `PythonProfileModes.TRAIN`. Las opciones disponibles se proporcionan en la sección [Training Modes and Phases for Python Profiling](#debugger-access-data-python-profiling-modes).
  + `start_phase` (str): especifique la fase de inicio en los pasos objetivo mediante la clase enumeradora `StepPhase`. Este parámetro permite crear perfiles entre las diferentes fases del entrenamiento. El valor predeterminado es `StepPhase.STEP_START`. Las opciones disponibles se proporcionan en la sección [Training Modes and Phases for Python Profiling](#debugger-access-data-python-profiling-phases).
  + `end_phase` (str): especifique la fase final en los pasos objetivo mediante la clase enumeradora `StepPhase`. Este parámetro configura la fase final del entrenamiento. Las opciones disponibles son las mismas que las del parámetro `start_phase`. El valor predeterminado es `StepPhase.STEP_END`. Las opciones disponibles se proporcionan en la sección [Training Modes and Phases for Python Profiling](#debugger-access-data-python-profiling-phases).
+ `python_analysis.fetch_profile_stats_between_modes(start_mode, end_mode)`: obtiene estadísticas de la creación de perfiles de Python entre los modos de inicio y final.
+ `python_analysis.fetch_pre_step_zero_profile_stats()`: obtiene las estadísticas de la creación de perfiles de Python hasta el paso 0.
+ `python_analysis.fetch_post_hook_close_profile_stats()`: obtiene las estadísticas de la creación de perfiles de Python después de cerrar el enlace.
+ `python_analysis.list_profile_stats()`— Devuelve una DataFrame de las estadísticas de creación de perfiles de Python. Cada fila contiene los metadatos de cada instancia de creación de perfiles y el archivo de estadísticas correspondiente (uno por paso).
+ `python_analysis.list_available_node_ids()`— Devuelve una lista de los nodos disponibles IDs para las estadísticas de creación de perfiles de Python.

Los métodos específicos de la clase `cProfileAnalysis`.
+  `fetch_profile_stats_by_training_phase()`: obtiene y agrega las estadísticas de creación de perfiles de Python para cada combinación posible de modos de inicio y finalización. Por ejemplo, si las fases de entrenamiento y validación se llevan a cabo con la creación de perfiles detallados habilitada, las combinaciones son `(PRE_STEP_ZERO, TRAIN)`, `(TRAIN, TRAIN)`, `(TRAIN, EVAL)`, `(EVAL, EVAL)` y `(EVAL, POST_HOOK_CLOSE)`. Se agregan todos los archivos de estadísticas de cada una de estas combinaciones.
+  `fetch_profile_stats_by_job_phase()`: obtiene y agrega las estadísticas de creación de perfiles de Python por fase de trabajo. Las fases del trabajo son `initialization` (creación de perfiles hasta el paso 0), `training_loop` (entrenamiento y validación) y `finalization` (creación de perfiles tras cerrar el enlace).

# Fusión de cronogramas en múltiples archivos de seguimiento de perfiles
<a name="debugger-merge-timeline"></a>

La biblioteca SMDebug cliente proporciona herramientas de análisis y visualización de perfiles para combinar los cronogramas de las métricas del sistema, las métricas del marco y los datos de creación de perfiles de Python recopilados por Debugger. 

**sugerencia**  
Antes de continuar, debe configurar un TrainingJob objeto que se utilizará en los ejemplos de esta página. Para obtener más información sobre la configuración de un TrainingJob objeto, consulte[Acceso a los datos del perfil](debugger-analyze-data-profiling.md).

La clase `MergedTimeline` proporciona herramientas para integrar y correlacionar diferentes datos de creación de perfiles en un solo cronograma. Cuando el depurador captura los datos de creación de perfiles y las anotaciones de las diferentes fases de un trabajo de entrenamiento, los archivos JSON de los eventos de seguimiento se guardan en un directorio `tracefolder` predeterminado.
+ Para las anotaciones en las capas de Python, los archivos de seguimiento se guardan en `*pythontimeline.json`. 
+ Para las anotaciones en las capas de TensorFlow C\$1\$1, los archivos de rastreo se guardan en`*model_timeline.json`. 
+ El generador de perfiles de Tensorflow guarda los eventos en un archivo `*trace.json.gz`. 

**sugerencia**  
Si quiere enumerar todos los archivos de seguimiento JSON, use el siguiente comando de la AWS CLI :  

```
! aws s3 ls {tj.profiler_s3_output_path} --recursive | grep '\.json$'
```

Como se muestra en la siguiente captura de pantalla animada, al colocar y alinear los eventos de seguimiento capturados de las diferentes fuentes de creación de perfiles en un solo gráfico, se puede obtener una visión general de todos los eventos que ocurren en las diferentes fases del trabajo de entrenamiento.

![\[Ejemplo de cronología fusionada\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/debugger/debugger-merged-timeline.gif)


**sugerencia**  
A fin de interactuar con la cronología fusionada en la aplicación de seguimiento mediante un teclado, use la tecla `W` para acercarse, la tecla `A` para ir a la izquierda, la tecla `S` para alejarse y la tecla `D` para ir a la derecha.

Los múltiples archivos JSON de seguimiento de eventos se pueden combinar en un solo archivo JSON de eventos de seguimiento utilizando la siguiente operación de API `MergedTimeline` y el método de clase del módulo `smdebug.profiler.analysis.utils.merge_timelines`.

```
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)
```

La operación de API `MergedTimeline` pasa los siguientes parámetros:
+ `path` (str): especifique una carpeta raíz (`/profiler-output`) que contenga los archivos de seguimiento de creación de perfiles del sistema y del marco. Puede localizarlos `profiler-output` mediante el método de clase SageMaker AI Estimator o el objeto. TrainingJob Por ejemplo, `estimator.latest_job_profiler_artifacts_path()` o `tj.profiler_s3_output_path`.
+ `file_suffix_filter` (lista): especifique una lista de filtros de sufijos de archivos para combinar cronogramas. Los filtros de sufijos disponibles son `["model_timeline.json", "pythontimeline.json", "trace.json.gz"].`. Si este parámetro no se especifica manualmente, todos los archivos de seguimiento se combinan de forma predeterminada.
+ `output_directory` (str): especifique una ruta para guardar el archivo JSON del cronograma fusionado. El valor predeterminado es el directorio especificado para el parámetro `path`.

El classmethod `merge_timeline()` transfiere los siguientes parámetros para ejecutar el proceso de fusión:
+ `start` (int): especifique la hora de inicio (en microsegundos y en formato de hora Unix) o el paso de inicio para combinar los cronogramas.
+ `end` (int): especifique la hora de finalización (en microsegundos y en formato de hora Unix) o el paso final para combinar los cronogramas.
+ `unit` (str): elija entre `"step"` y `"time"`. El valor predeterminado es `"time"`.

Con los siguientes códigos de ejemplo, ejecute el método `merge_timeline()` y descargue el archivo JSON combinado. 
+ Combine el cronograma con la opción de unidad `"time"`. El siguiente código de ejemplo combina todos los archivos de seguimiento disponibles entre la hora de inicio de Unix (la hora de Unix con cero absoluto) y la hora actual de Unix, lo que significa que puede combinar los cronogramas de todo el entrenamiento.

  ```
  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))
  ```
+ Combine el cronograma con la opción de unidad `"step"`. El siguiente código de ejemplo combina todos los cronogramas disponibles entre el paso 3 y el paso 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 la aplicación de seguimiento de Chrome en `chrome://tracing`, en un navegador Chrome, y abra el archivo JSON. Puede explorar el resultado para representar gráficamente el cronograma fusionado. 

# Cargadores de datos de creación de perfiles
<a name="debugger-data-loading-time"></a>

En PyTorch, los iteradores del cargador de datos, como `SingleProcessingDataLoaderIter` y`MultiProcessingDataLoaderIter`, se inician al principio de cada iteración sobre un conjunto de datos. Durante la fase de inicialización, PyTorch activa los procesos de trabajo en función del número de trabajadores configurado y establece una cola de datos para recuperar los datos y los subprocesos. `pin_memory`

Para utilizar la herramienta de análisis de perfiles del cargador de PyTorch datos, importe la siguiente clase: `PT_dataloader_analysis`

```
from smdebug.profiler.analysis.utils.pytorch_dataloader_analysis import PT_dataloader_analysis
```

Transfiera los datos de creación de perfiles recuperados como un objeto de datos del marco de Pandas en la sección [Acceso a los datos de creación de perfiles con Pandas, una herramienta de análisis de datos](debugger-access-data-profiling-pandas-frame.md):

```
pt_analysis = PT_dataloader_analysis(pf)
```

Las siguientes funciones están disponibles para el objeto `pt_analysis`:

La SMDebug `S3SystemMetricsReader` clase lee las métricas del sistema del bucket de S3 especificado para el `s3_trial_path` parámetro.
+ `pt_analysis.analyze_dataloaderIter_initialization()`

  El análisis muestra la duración media y máxima de estas inicializaciones. Si hay valores atípicos (es decir, la duración es superior al doble de la media), la función imprime las horas de inicio y finalización de esas duraciones. Se pueden usar para inspeccionar las métricas del sistema durante esos intervalos de tiempo.

  La siguiente lista muestra los análisis disponibles con este método de clase:
  + Qué tipo de iteradores del cargador de datos se inicializaron.
  + El número de procesos de trabajo por iterador.
  + Comprobación de si el iterador se inicializó con o sin pin\$1memory.
  + El número de veces que se inicializaron los iteradores durante el entrenamiento.
+ `pt_analysis.analyze_dataloaderWorkers()`

  La siguiente lista muestra los análisis disponibles con este método de clase:
  + El número de procesos de trabajo que se generaron durante todo el entrenamiento. 
  + Duración media y máxima de los procesos de trabajo. 
  + Hora de inicio y finalización en los procesos de trabajo atípicos. 
+ `pt_analysis.analyze_dataloader_getnext()`

  La siguiente lista muestra los análisis disponibles con este método de clase:
  + Número de GetNext llamadas realizadas durante la formación. 
  + Duración media y máxima en microsegundos de las GetNext llamadas. 
  + Hora de inicio, hora de finalización, duración e identificador del trabajador para la duración atípica de la GetNext llamada. 
+ `pt_analysis.analyze_batchtime(start_timestamp, end_timestamp, select_events=[".*"], select_dimensions=[".*"])`

  El depurador recopila las horas de inicio y finalización de todas las GetNext llamadas. Puede encontrar la cantidad de tiempo que emplea el script de entrenamiento en un lote de datos. Dentro del intervalo de tiempo especificado, puede identificar las llamadas que no contribuyen directamente al entrenamiento. Estas llamadas pueden proceder de las siguientes operaciones: calcular la precisión, sumar las pérdidas con fines de depuración o registro e imprimir la información de depuración. Operaciones como estas pueden requerir un uso intensivo de recursos informáticos o consumir mucho tiempo. Podemos identificar dichas operaciones correlacionando el generador de perfiles de Python, las métricas del sistema y las métricas del marco.

  La siguiente lista muestra los análisis disponibles con este método de clase:
  + Haga un perfil del tiempo dedicado a cada lote de datos`BatchTime_in_seconds`, encontrando la diferencia entre las horas de inicio de las GetNext llamadas actuales y las posteriores. 
  + Encuentre los valores atípicos en `BatchTime_in_seconds` y la hora de inicio y finalización de esos valores atípicos.
  + Obtenga las métricas del sistema y del marco durante esas marcas temporales `BatchTime_in_seconds`. Esto indica dónde se empleó el tiempo.
+ `pt_analysis.plot_the_window()`

  Traza un gráfico de cronograma entre una marca de tiempo de inicio y la marca de tiempo de finalización.