Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Analyse des données à l'aide de la bibliothèque client Debugger Python
<a name="debugger-analyze-data"></a>

[Pendant que votre tâche de formation est en cours ou une fois celle-ci terminée, vous pouvez accéder aux données de formation collectées par Debugger à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) et de la SMDebug bibliothèque cliente.](https://github.com/awslabs/sagemaker-debugger/) La bibliothèque client Debugger Python fournit des outils d'analyse et de visualisation qui vous permettent d'explorer les données de votre tâche d'entraînement.

**Pour installer la bibliothèque et utiliser ses outils d'analyse (dans un JupyterLab bloc-notes ou un noyau IPython)**

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

Les rubriques suivantes vous expliquent comment utiliser les outils Debugger Python pour visualiser et analyser les données d'entraînement collectées par Debugger.

**Analyse des métriques système et de framework**
+ [Accès aux données du profil](debugger-analyze-data-profiling.md)
+ [Tracé des données des métriques système et de framework](debugger-access-data-profiling-default-plot.md)
+ [Accès aux données de profilage à l'aide de l'outil d'analyse de données Pandas](debugger-access-data-profiling-pandas-frame.md)
+ [Accès aux données de statistiques de profilage Python](debugger-access-data-python-profiling.md)
+ [Fusion des chronologies de plusieurs fichiers de trace de profil](debugger-merge-timeline.md)
+ [Profilage des chargeurs de données](debugger-data-loading-time.md)

# Accès aux données du profil
<a name="debugger-analyze-data-profiling"></a>

La SMDebug `TrainingJob` classe lit les données du compartiment S3 dans lequel les métriques du système et du framework sont enregistrées. 

**Pour configurer un objet `TrainingJob` et récupérer les fichiers d'événements de profilage d'une tâche d'entraînement**

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

**Astuce**  
Vous devez spécifier les paramètres `training_job_name` et `region` pour vous connecter à une tâche d'entraînement. Il existe deux façons de spécifier les informations sur les tâches d'entraînement :   
Utilisez le SDK SageMaker Python alors que l'estimateur est toujours associé à la tâche de formation.  

  ```
  import sagemaker
  training_job_name=estimator.latest_training_job.job_name
  region=sagemaker.Session().boto_region_name
  ```
Passez les chaînes directement.  

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

**Note**  
Par défaut, SageMaker Debugger collecte les métriques du système pour surveiller l'utilisation des ressources matérielles et les goulots d'étranglement du système. En exécutant les fonctions suivantes, vous pouvez recevoir des messages d'erreur concernant l'indisponibilité des métriques du framework. Pour récupérer les données de profilage du cadre et obtenir des informations sur les opérations du cadre, vous devez en activer le profilage.  
Si vous utilisez le SDK SageMaker Python pour manipuler votre demande de tâche de formation, transmettez le `framework_profile_params` à l'`profiler_config`argument de votre estimateur. Pour en savoir plus, voir [Configurer le profilage du framework SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-framework-profiling.html).
Si vous utilisez Studio Classic, activez le profilage à l’aide du bouton **Profilage** dans le tableau de bord Debugger Insights. Pour en savoir plus, consultez [SageMaker Debugger Insights Dashboard Controller](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio-insights-controllers.html).

**Pour récupérer une description de la tâche d'entraînement et de l'URI du compartiment S3 où les données de métriques sont enregistrées**

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

**Pour vérifier si les métriques système et de framework sont disponibles à partir de l'URI S3**

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

**Pour créer des objets de lecteur de système et de framework une fois que les données de métriques sont disponibles**

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

**Pour actualiser et récupérer les derniers fichiers d'événements d'entraînement**

Les objets du lecteur ont une méthode étendue, `refresh_event_file_list()`, afin de récupérer les fichiers les plus récents des événements d'entraînement.

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

# Tracé des données des métriques système et de framework
<a name="debugger-access-data-profiling-default-plot"></a>

Vous pouvez utiliser les objets de mesure système et d'algorithme pour les classes de visualisation suivantes afin de tracer des graphiques de chronologie et des histogrammes.

**Note**  
Pour visualiser les données avec des métriques restreintes dans les méthodes de traçage d'objet de visualisation suivantes, spécifiez les paramètres `select_dimensions` et `select_events`. Par exemple, si vous spécifiez `select_dimensions=["GPU"]`, les méthodes de tracé filtrent les métriques qui incluent le mot-clé « GPU ». Si vous spécifiez `select_events=["total"]`, les méthodes de tracé filtrent les métriques qui incluent les identifications d'événement « total » à la fin des noms de métriques. Si vous activez ces paramètres et indiquez les chaînes de mots-clés, les classes de visualisation renvoient les graphiques avec des métriques filtrées.
+ La 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
  )
  ```
+ La classe `StepTimelineChart`

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

# Accès aux données de profilage à l'aide de l'outil d'analyse de données Pandas
<a name="debugger-access-data-profiling-pandas-frame"></a>

La classe `PandasFrame` suivante fournit des outils pour convertir les données de profilage collectées en cadre de données Pandas. 

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

La classe `PandasFrame` prend le chemin de sortie du compartiment S3 de l'objet `tj`, et ses méthodes `get_all_system_metrics()` `get_all_framework_metrics()` renvoient les métriques système et les métriques de cadre au format de données 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'
    ]
)
```

# Accès aux données de statistiques de profilage Python
<a name="debugger-access-data-python-profiling"></a>

Le profilage Python fournit des métriques de framework relatives aux fonctions et aux opérateurs Python dans vos scripts d'entraînement et dans les frameworks d'apprentissage en profondeur de l' SageMaker IA. 

<a name="debugger-access-data-python-profiling-modes"></a>**Modes et phases d'entraînement pour le profilage Python**

Afin de profiler des intervalles spécifiques au cours de l'entraînement pour partitionner les statistiques pour chacun de ces intervalles, Debugger fournit des outils permettant de définir les modes et les phases. 

Pour les modes d'entraînement, vous utilisez la classe `PythonProfileModes` suivante :

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

Cette classe fournit les options suivantes :
+ `PythonProfileModes.TRAIN` : utilisez cette option si vous souhaitez profiler les étapes cible de la phase d'entraînement. Cette option de mode n'est disponible que pour TensorFlow.
+ `PythonProfileModes.EVAL` : utilisez cette option si vous souhaitez profiler les étapes cible de la phase d'évaluation. Cette option de mode n'est disponible que pour TensorFlow.
+ `PythonProfileModes.PREDICT` : utilisez cette option si vous souhaitez profiler les étapes cible de la phase de prédiction. Cette option de mode n'est disponible que pour TensorFlow.
+ `PythonProfileModes.GLOBAL` : utilisez cette option si vous souhaitez profiler les étapes cible de la phase globale, qui comprend les trois phases précédentes. Cette option de mode n'est disponible que pour PyTorch.
+ `PythonProfileModes.PRE_STEP_ZERO` : utilisez cette option si vous souhaitez profiler les étapes cible de l'étape d'initialisation avant le début de la première étape d'entraînement de la première époque. Cette phase comprend la soumission de la tâche, le chargement des scripts d'entraînement vers les instances EC2, la préparation des instances EC2 et le téléchargement des données d'entrée. Cette option de mode est disponible à la fois pour TensorFlow et PyTorch.
+ `PythonProfileModes.POST_HOOK_CLOSE` : utilisez cette option si vous souhaitez profiler les étapes cible de l'étape de finalisation une fois la tâche d'entraînement terminée et le hook Debugger fermé. Cette phase comprend le profilage des données lorsque les tâches d'entraînement sont finalisées et terminées. Cette option de mode est disponible à la fois pour TensorFlow et PyTorch.

<a name="debugger-access-data-python-profiling-phases"></a>Pour les phases d'entraînement, utilisez la classe `StepPhase` suivante :

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

Cette classe fournit les options suivantes :
+ `StepPhase.START` : permet de spécifier le point de départ de la phase d'initialisation.
+ `StepPhase.STEP_START` : permet de spécifier l'étape de début de la phase d'entraînement.
+ `StepPhase.FORWARD_PASS_END` : permet de spécifier les étapes où se termine la transmission vers l'avant. Cette option n'est disponible que pour PyTorch.
+ `StepPhase.STEP_END` : permet de spécifier les étapes finales de la phase d'entraînement. Cette option n'est disponible que pour TensorFlow.
+ `StepPhase.END`— À utiliser pour spécifier le point final de la phase de finalisation (post-hook-close). Si le hook de rappel n'est pas fermé, le profilage de la phase de finalisation ne se produit pas.

**Outils d'analyse de profilage Python**

Debugger prend en charge le profilage Python avec deux outils de profilage :
+ cProfile : profileur python standard. cProfile collecte les métriques de cadre sur le temps CPU pour chaque fonction appelée lorsque le profilage a été activé.
+ Pyinstrument : profileur Python sans frais généraux importants, qui échantillonne les événements de profilage toutes les millisecondes.

Pour en savoir plus sur les options de profilage Python et sur ce qui est collecté, consultez [Surveillance système par défaut et profilage de cadre personnalisé avec différentes options de profilage](debugger-configure-framework-profiling-options.md).

Les méthodes suivantes des classes `PythonProfileAnalysis`, `cProfileAnalysis` et `PyinstrumentAnalysis` sont fournies pour extraire et analyser les données de profilage Python. Chaque fonction charge les données les plus récentes depuis l'URI S3 par défaut.

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

Pour définir des objets de profilage Python à des fins d'analyse, utilisez les PyinstrumentAnalysis classes cProfileAnalysis or comme indiqué dans l'exemple de code suivant. Celui-ci montre comment définir un objet `cProfileAnalysis`. Si vous voulez utiliser `PyinstrumentAnalysis`, remplacez le nom de la classe.

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

Les méthodes suivantes sont disponibles pour les classes `cProfileAnalysis` et `PyinstrumentAnalysis`pour récupérer les données de statistiques de profilage Python :
+ `python_analysis.fetch_python_profile_stats_by_time(start_time_since_epoch_in_secs, end_time_since_epoch_in_secs)` : prend une heure de début et une heure de fin, et renvoie les statistiques de fonction des statistiques d'étape dont les heures de début ou de fin se chevauchent avec l'intervalle fourni.
+ `python_analysis.fetch_python_profile_stats_by_step(start_step, end_step, mode, start_phase, end_phase)` : prend une étape de départ et une étape de fin et renvoie les statistiques de fonction de toutes les statistiques d'étape dont l'étape `step` profilée correspond à `start_step <= step < end_step`. 
  + `start_step` et `end_step` (str) : spécifiez l'étape de début et l'étape de fin pour récupérer les données de statistiques de profilage Python.
  + `mode` (str) : spécifiez le mode de la tâche d'entraînement à l'aide de la classe d'énumérateur `PythonProfileModes`. La valeur par défaut est `PythonProfileModes.TRAIN`. Les options disponibles sont fournies dans la section [Modes et phases d'entraînement pour le profilage Python](#debugger-access-data-python-profiling-modes).
  + `start_phase` (str) : spécifiez la phase de démarrage dans la ou les étape(s) cible à l'aide de la classe d'énumérateur `StepPhase`. Ce paramètre permet le profilage entre différentes phases de l'entraînement. La valeur par défaut est `StepPhase.STEP_START`. Les options disponibles sont fournies dans la section [Modes et phases d'entraînement pour le profilage Python](#debugger-access-data-python-profiling-phases).
  + `end_phase` (str) : spécifiez la phase de fin dans la ou les étape(s) cible à l'aide de la classe d'énumérateur `StepPhase`. Ce paramètre définit la phase finale de l'entraînement. Les options disponibles sont les mêmes que celles du paramètre `start_phase`. La valeur par défaut est `StepPhase.STEP_END`. Les options disponibles sont fournies dans la section [Modes et phases d'entraînement pour le profilage Python](#debugger-access-data-python-profiling-phases).
+ `python_analysis.fetch_profile_stats_between_modes(start_mode, end_mode)` : extrait les statistiques de profilage Python entre les modes de début et de fin.
+ `python_analysis.fetch_pre_step_zero_profile_stats()` : extrait les statistiques de profilage Python jusqu'à l'étape 0.
+ `python_analysis.fetch_post_hook_close_profile_stats()` : extrait les statistiques de profilage Python une fois le hook fermé.
+ `python_analysis.list_profile_stats()`— Renvoie une DataFrame des statistiques de profilage de Python. Chaque ligne contient les métadonnées de chaque instance de profilage et le fichier de statistiques correspondant (un par étape).
+ `python_analysis.list_available_node_ids()`— Renvoie une liste des nœuds disponibles IDs pour les statistiques de profilage Python.

Les méthodes spécifiques à la classe `cProfileAnalysis` :
+  `fetch_profile_stats_by_training_phase()` : extrait et agrège les statistiques de profilage Python pour chaque combinaison possible de modes de début et de fin. Par exemple, si un entraînement et des phases de validation sont effectués alors que le profilage détaillé est activé, les combinaisons sont `(PRE_STEP_ZERO, TRAIN)`, `(TRAIN, TRAIN)`, `(TRAIN, EVAL)`, `(EVAL, EVAL)` et `(EVAL, POST_HOOK_CLOSE)`. Tous les fichiers de statistiques de chacune de ces combinaisons sont agrégés.
+  `fetch_profile_stats_by_job_phase()` : extrait et agrège les statistiques de profilage Python par phase de tâche. Les phases de tâche sont `initialization` (profilage jusqu'à l'étape 0), `training_loop`(entraînement et validation) et `finalization` (profilage une fois le hook fermé).

# Fusion des chronologies de plusieurs fichiers de trace de profil
<a name="debugger-merge-timeline"></a>

La bibliothèque SMDebug cliente fournit des outils d'analyse et de visualisation du profilage pour fusionner les chronologies des métriques du système, des métriques du framework et des données de profilage Python collectées par Debugger. 

**Astuce**  
Avant de continuer, vous devez définir un TrainingJob objet qui sera utilisé dans les exemples de cette page. Pour plus d'informations sur la configuration d'un TrainingJob objet, consultez[Accès aux données du profil](debugger-analyze-data-profiling.md).

La classe `MergedTimeline` fournit des outils permettant d'intégrer et de mettre en corrélation différentes informations de profilage dans une seule chronologie. Après que Debugger capture les données de profilage et les annotations de différentes phases d'une tâche d'entraînement, les fichiers JSON des événements de suivi sont enregistrés dans un répertoire `tracefolder` par défaut.
+ Pour les annotations dans les couches Python, les fichiers de suivi sont enregistrés dans `*pythontimeline.json`. 
+ Pour les annotations dans les couches TensorFlow C\$1\$1, les fichiers de trace sont enregistrés dans`*model_timeline.json`. 
+ Le profileur Tensorflow enregistre les événements dans un fichier `*trace.json.gz`. 

**Astuce**  
Si vous souhaitez répertorier tous les fichiers de suivi JSON, utilisez la commande AWS CLI suivante :  

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

Comme le montre la capture d'écran animée suivante, placer et aligner les événements de suivi capturés à partir des différentes sources de profilage dans un seul graphique peut fournir un aperçu de l'ensemble des événements se produisant dans les différentes phases de la tâche d'entraînement.

![\[Exemple de chronologie fusionnée\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/debugger/debugger-merged-timeline.gif)


**Astuce**  
Pour interagir avec la chronologie fusionnée de l'appli de suivi à l'aide d'un clavier, utilisez la touche `W` pour zoomer, la touche `A` pour aller vers la gauche, la touche `S` pour dézoomer et la touche `D` pour aller vers la droite.

Les fichiers JSON de suivi d'événements multiples peuvent être fusionnés dans un fichier JSON d'événement de suivi à l'aide de l'opération d'API `MergedTimeline` suivante et de la méthode de classe du module `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)
```

L'opération d'API `MergedTimeline` transmet les paramètres suivants :
+ `path` (str) : spécifie un dossier racine (`/profiler-output`) qui contient des fichiers de suivi de profilage système et de cadre. Vous pouvez les localiser à l'`profiler-output`aide de la méthode de classe SageMaker AI estimator ou de l'objet. TrainingJob Par exemple, `estimator.latest_job_profiler_artifacts_path()` ou `tj.profiler_s3_output_path`.
+ `file_suffix_filter` (liste) : spécifiez une liste de filtres de suffixe de fichier pour fusionner les chronologies. Les filtres de suffixe disponibles sont `["model_timeline.json", "pythontimeline.json", "trace.json.gz"].` Si ce paramètre n'est pas spécifié manuellement, tous les fichiers de suivi sont fusionnés par défaut.
+ `output_directory` (str) : spécifiez un chemin d'accès pour enregistrer le fichier JSON de chronologie fusionné. La valeur par défaut est le répertoire spécifié pour le paramètre `path`.

La méthode de classe `merge_timeline()` transmet les paramètres suivants pour exécuter le processus de fusion :
+ `start` (ent) : spécifiez l'heure de début (en microsecondes et au format Unix) ou l'étape de démarrage pour fusionner les chronologies.
+ `end` (ent) : spécifiez l'heure de fin (en microsecondes et au format Unix) ou l'étape de fin pour fusionner les chronologies.
+ `unit` (str) : choisissez entre `"time"` et `"step"`. La valeur par défaut est `"time"`.

À l'aide des exemples de codes suivants, exécutez la méthode `merge_timeline()` et téléchargez le fichier JSON fusionné. 
+ Fusionnez la chronologie avec l'option d'unité `"time"`. L'exemple de code suivant fusionne tous les fichiers de suivi disponibles entre l'heure de début Unix (heure Unix absolue zéro) et l'heure Unix actuelle, ce qui signifie que vous pouvez fusionner les chronologies pour toute la durée de l'entraînement.

  ```
  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))
  ```
+ Fusionnez la chronologie avec l'option d'unité `"step"`. L'exemple de code suivant fusionne toutes les chronologies disponibles entre l'étape 3 et l'étape 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")
  ```

Ouvrez l'appli de suivi Chrome à l'adresse `chrome://tracing` sur un navigateur Chrome et ouvrez le fichier JSON. Vous pouvez explorer la sortie pour tracer la chronologie fusionnée. 

# Profilage des chargeurs de données
<a name="debugger-data-loading-time"></a>

Dans PyTorch, les itérateurs du chargeur de données, tels que `SingleProcessingDataLoaderIter` et`MultiProcessingDataLoaderIter`, sont lancés au début de chaque itération sur un ensemble de données. Pendant la phase d'initialisation, PyTorch active les processus de travail en fonction du nombre de travailleurs configuré, établit une file d'attente de données pour récupérer les données et `pin_memory` les threads.

Pour utiliser l'outil d'analyse de profilage du chargeur de PyTorch données, importez la `PT_dataloader_analysis` classe suivante :

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

Transmettez les données de profilage récupérées en tant qu'objet de données de cadre Pandas dans la section [Accès aux données de profilage à l'aide de l'outil d'analyse de données Pandas](debugger-access-data-profiling-pandas-frame.md) :

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

Les fonctions suivantes peuvent être utilisées pour l'objet `pt_analysis` :

La SMDebug `S3SystemMetricsReader` classe lit les métriques du système à partir du compartiment S3 spécifié dans le `s3_trial_path` paramètre.
+ `pt_analysis.analyze_dataloaderIter_initialization()`

  L'analyse génère la durée médiane et maximale de ces initialisations. En cas de valeurs aberrantes (c'est-à-dire que la durée est supérieure à 2 fois la valeur médiane), la fonction affiche les heures de début et de fin pour ces durées. Celles-ci peuvent être utilisées pour inspecter les métriques système pendant ces intervalles de temps.

  La liste suivante indique l'analyse disponible à partir de cette méthode de classe :
  + Type d'itérateurs de chargeur de données initialisés.
  + Nombre de composants par itérateur.
  + Vérifiez si l'itérateur a été initialisé avec ou sans pin\$1memory.
  + Nombre de fois où les itérateurs ont été initialisés pendant l'entraînement.
+ `pt_analysis.analyze_dataloaderWorkers()`

  La liste suivante indique l'analyse disponible à partir de cette méthode de classe :
  + Nombre de processus de composant qui ont été détachés pendant toute la durée de l'entraînement. 
  + Durée médiane et maximale pour les processus de composant. 
  + Heure de début et de fin pour les processus de composant qui sont des anomalies. 
+ `pt_analysis.analyze_dataloader_getnext()`

  La liste suivante indique l'analyse disponible à partir de cette méthode de classe :
  + Nombre d' GetNext appels passés pendant la formation. 
  + Durée médiane et maximale en microsecondes pour les GetNext appels. 
  + Heure de début, heure de fin, durée et identifiant du travailleur pour la durée exceptionnelle de l' GetNextappel. 
+ `pt_analysis.analyze_batchtime(start_timestamp, end_timestamp, select_events=[".*"], select_dimensions=[".*"])`

  Debugger collecte les heures de début et de fin de tous les GetNext appels. Vous pouvez trouver le temps passé par le script d'entraînement sur un lot de données. Dans la fenêtre de la période spécifiée, vous pouvez identifier les appels qui ne contribuent pas directement à l'entraînement. Ces appels peuvent provenir des opérations suivantes : calcul de la précision, ajout des pertes à des fins de débogage ou de journalisation, et impression des informations de débogage. Des opérations comme celles-ci peuvent être exigeantes en calcul ou en temps. Nous pouvons identifier de telles opérations en corrélant le profileur Python, les métriques système et les métriques de cadre.

  La liste suivante indique l'analyse disponible à partir de cette méthode de classe :
  + Profilez le temps passé sur chaque lot de données en déterminant la différence entre l'heure de début des appels en cours et celle des GetNext appels suivants. `BatchTime_in_seconds` 
  + Recherchez les valeurs aberrantes dans `BatchTime_in_seconds` ainsi que l'heure de début et de fin pour ces valeurs aberrantes.
  + Obtenez les métriques système et de cadre au cours de ces horodatages `BatchTime_in_seconds`. Cela indique à quoi le temps a été consacré.
+ `pt_analysis.plot_the_window()`

  Trace un graphique chronologique entre un horodatage de début et l'horodatage de fin.