Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menganalisis data menggunakan pustaka klien Python Debugger
<a name="debugger-analyze-data"></a>

[Saat tugas pelatihan Anda berjalan atau setelah selesai, Anda dapat mengakses data pelatihan yang dikumpulkan oleh Debugger menggunakan Amazon [ SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) dan pustaka klien. SMDebug ](https://github.com/awslabs/sagemaker-debugger/) Pustaka klien Python Debugger menyediakan alat analisis dan visualisasi yang memungkinkan Anda menelusuri data pekerjaan pelatihan Anda.

**Untuk menginstal perpustakaan dan menggunakan alat analisisnya (dalam buku JupyterLab catatan atau kernel IPython)**

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

Topik berikut memandu Anda melalui cara menggunakan alat Python Debugger untuk memvisualisasikan dan menganalisis data pelatihan yang dikumpulkan oleh Debugger.

**Menganalisis metrik sistem dan kerangka kerja**
+ [Akses data profil](debugger-analyze-data-profiling.md)
+ [Plot metrik sistem dan data metrik kerangka kerja](debugger-access-data-profiling-default-plot.md)
+ [Akses data profil menggunakan alat parsing data panda](debugger-access-data-profiling-pandas-frame.md)
+ [Mengakses data statistik profil Python](debugger-access-data-python-profiling.md)
+ [Gabungkan garis waktu beberapa file jejak profil](debugger-merge-timeline.md)
+ [Membuat profil pemuat data](debugger-data-loading-time.md)

# Akses data profil
<a name="debugger-analyze-data-profiling"></a>

 SMDebug `TrainingJob`Kelas membaca data dari bucket S3 tempat metrik sistem dan kerangka kerja disimpan. 

**Untuk mengatur `TrainingJob` objek dan mengambil file acara profiling dari pekerjaan pelatihan**

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

**Tip**  
Anda perlu menentukan `training_job_name` dan `region` parameter untuk masuk ke pekerjaan pelatihan. Ada dua cara untuk menentukan informasi pekerjaan pelatihan:   
Gunakan SageMaker Python SDK saat estimator masih melekat pada pekerjaan pelatihan.  

  ```
  import sagemaker
  training_job_name=estimator.latest_training_job.job_name
  region=sagemaker.Session().boto_region_name
  ```
Lulus string secara langsung.  

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

**catatan**  
Secara default, SageMaker Debugger mengumpulkan metrik sistem untuk memantau pemanfaatan sumber daya perangkat keras dan kemacetan sistem. Menjalankan fungsi berikut, Anda mungkin menerima pesan kesalahan terkait tidak tersedianya metrik kerangka kerja. Untuk mengambil data profil kerangka kerja dan mendapatkan wawasan tentang operasi kerangka kerja, Anda harus mengaktifkan pembuatan profil kerangka kerja.  
Jika Anda menggunakan SageMaker Python SDK untuk memanipulasi permintaan pekerjaan pelatihan Anda, teruskan `framework_profile_params` ke `profiler_config` argumen estimator Anda. Untuk mempelajari selengkapnya, lihat [Mengkonfigurasi Profil Kerangka SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-framework-profiling.html).
Jika Anda menggunakan Studio Classic, aktifkan pembuatan profil menggunakan tombol toggle **Profiling** di dasbor wawasan Debugger. Untuk mempelajari lebih lanjut, lihat Pengontrol Dasbor [Wawasan SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio-insights-controllers.html).

**Untuk mengambil deskripsi deskripsi pekerjaan pelatihan dan URI bucket S3 tempat data metrik disimpan**

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

**Untuk memeriksa apakah metrik sistem dan kerangka kerja tersedia dari URI S3**

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

**Untuk membuat objek pembaca sistem dan kerangka kerja setelah data metrik tersedia**

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

**Untuk menyegarkan dan mengambil file acara pelatihan terbaru**

Objek pembaca memiliki metode yang diperluas`refresh_event_file_list()`,, untuk mengambil file acara pelatihan terbaru.

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

# Plot metrik sistem dan data metrik kerangka kerja
<a name="debugger-access-data-profiling-default-plot"></a>

Anda dapat menggunakan objek metrik sistem dan algoritma untuk kelas visualisasi berikut untuk memplot grafik garis waktu dan histogram.

**catatan**  
Untuk memvisualisasikan data dengan metrik yang dipersempit dalam metode plot objek visualisasi berikut, tentukan dan parameternya. `select_dimensions` `select_events` Misalnya, jika Anda menentukan`select_dimensions=["GPU"]`, metode plot memfilter metrik yang menyertakan kata kunci “GPU”. Jika Anda menentukan`select_events=["total"]`, metode plot memfilter metrik yang menyertakan tag peristiwa “total” di akhir nama metrik. Jika Anda mengaktifkan parameter ini dan memberikan string kata kunci, kelas visualisasi mengembalikan bagan dengan metrik yang difilter.
+ `MetricsHistogram`Kelas

  ```
  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
  )
  ```
+ `StepTimelineChart`Kelas

  ```
  from smdebug.profiler.analysis.notebook_utils.step_timeline_chart import StepTimelineChart
  
  view_step_timeline_chart = StepTimelineChart(framework_metrics_reader)
  ```
+ `StepHistogram`Kelas

  ```
  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
  )
  ```
+ `TimelineCharts`Kelas

  ```
  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])
  ```
+ `Heatmap`Kelas

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

# Akses data profil menggunakan alat parsing data panda
<a name="debugger-access-data-profiling-pandas-frame"></a>

`PandasFrame`Kelas berikut menyediakan alat untuk mengonversi data profil yang dikumpulkan ke bingkai data Pandas. 

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

`PandasFrame`Kelas mengambil jalur keluaran bucket S3 `tj` objek, dan metodenya `get_all_system_metrics()` `get_all_framework_metrics()` mengembalikan metrik sistem dan metrik kerangka kerja dalam format data 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'
    ]
)
```

# Mengakses data statistik profil Python
<a name="debugger-access-data-python-profiling"></a>

Profil Python menyediakan metrik kerangka kerja yang terkait dengan fungsi dan operator Python dalam skrip pelatihan Anda dan kerangka kerja pembelajaran mendalam AI. SageMaker 

<a name="debugger-access-data-python-profiling-modes"></a>**Mode Pelatihan dan Fase untuk Profil Python**

Untuk membuat profil interval tertentu selama pelatihan ke statistik partisi untuk masing-masing interval ini, Debugger menyediakan alat untuk mengatur mode dan fase. 

Untuk mode pelatihan, gunakan `PythonProfileModes` kelas berikut:

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

Kelas ini menyediakan opsi berikut:
+ `PythonProfileModes.TRAIN`— Gunakan jika Anda ingin membuat profil langkah-langkah target dalam fase pelatihan. Opsi mode ini hanya tersedia untuk TensorFlow.
+ `PythonProfileModes.EVAL`— Gunakan jika Anda ingin membuat profil langkah-langkah target dalam fase evaluasi. Opsi mode ini hanya tersedia untuk TensorFlow.
+ `PythonProfileModes.PREDICT`— Gunakan jika Anda ingin membuat profil langkah target dalam fase prediksi. Opsi mode ini hanya tersedia untuk TensorFlow.
+ `PythonProfileModes.GLOBAL`— Gunakan jika Anda ingin membuat profil langkah target dalam fase global, yang mencakup tiga fase sebelumnya. Opsi mode ini hanya tersedia untuk PyTorch.
+ `PythonProfileModes.PRE_STEP_ZERO`— Gunakan jika Anda ingin membuat profil langkah-langkah target dalam tahap inisialisasi sebelum langkah pelatihan pertama dari epoch pertama dimulai. Fase ini mencakup pengajuan pekerjaan awal, mengunggah skrip pelatihan ke instans EC2, menyiapkan instans EC2, dan mengunduh data input. Opsi mode ini tersedia untuk keduanya TensorFlow dan PyTorch.
+ `PythonProfileModes.POST_HOOK_CLOSE`— Gunakan jika Anda ingin membuat profil langkah target di tahap finalisasi setelah pekerjaan pelatihan selesai dan kait Debugger ditutup. Fase ini mencakup data profil sementara pekerjaan pelatihan diselesaikan dan diselesaikan. Opsi mode ini tersedia untuk keduanya TensorFlow dan PyTorch.

<a name="debugger-access-data-python-profiling-phases"></a>Untuk fase pelatihan, gunakan `StepPhase` kelas berikut:

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

Kelas ini menyediakan opsi berikut:
+ `StepPhase.START`— Gunakan untuk menentukan titik awal fase inisialisasi.
+ `StepPhase.STEP_START`— Gunakan untuk menentukan langkah awal fase pelatihan.
+ `StepPhase.FORWARD_PASS_END`— Gunakan untuk menentukan langkah-langkah di mana pass maju berakhir. Opsi ini hanya tersedia untuk PyTorch.
+ `StepPhase.STEP_END`— Gunakan untuk menentukan langkah akhir dalam fase pelatihan. Opsi ini hanya tersedia untuk TensorFlow.
+ `StepPhase.END`— Gunakan untuk menentukan titik akhir dari fase finalisasi (post-hook-close). Jika hook callback tidak ditutup, profil fase finalisasi tidak terjadi.

**Alat Analisis Profil Python**

Debugger mendukung profiling Python dengan dua alat profiling:
+ CProfile — Profiler python standar. cProfile mengumpulkan metrik kerangka kerja pada waktu CPU untuk setiap fungsi yang dipanggil saat pembuatan profil diaktifkan.
+ Pyinstrument - Ini adalah peristiwa profil pengambilan sampel profiler Python overhead rendah setiap milidetik.

Untuk mempelajari lebih lanjut tentang opsi pembuatan profil Python dan apa yang dikumpulkan, lihat. [Pemantauan sistem default dan pembuatan profil kerangka kerja yang disesuaikan dengan opsi pembuatan profil yang berbeda](debugger-configure-framework-profiling-options.md)

Metode berikut dari`PythonProfileAnalysis`,`cProfileAnalysis`, `PyinstrumentAnalysis` kelas disediakan untuk mengambil dan menganalisis data profil Python. Setiap fungsi memuat data terbaru dari URI S3 default.

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

Untuk mengatur objek profiling Python untuk analisis, gunakan cProfileAnalysis atau PyinstrumentAnalysis kelas seperti yang ditunjukkan dalam kode contoh berikut. Ini menunjukkan bagaimana mengatur `cProfileAnalysis` objek, dan jika Anda ingin menggunakan`PyinstrumentAnalysis`, ganti nama kelas.

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

Metode berikut tersedia untuk `PyinstrumentAnalysis` kelas `cProfileAnalysis` dan untuk mengambil data statistik profil Python:
+ `python_analysis.fetch_python_profile_stats_by_time(start_time_since_epoch_in_secs, end_time_since_epoch_in_secs)`— Mengambil waktu mulai dan waktu akhir, dan mengembalikan statistik fungsi statistik langkah yang waktu mulai atau berakhir tumpang tindih dengan interval yang disediakan.
+ `python_analysis.fetch_python_profile_stats_by_step(start_step, end_step, mode, start_phase, end_phase)`— Mengambil langkah awal dan langkah akhir dan mengembalikan statistik fungsi dari semua statistik langkah yang diprofilkan `step` memenuhi. `start_step <= step < end_step` 
  + `start_step`dan `end_step` (str) - Tentukan langkah awal dan langkah akhir untuk mengambil data statistik profil Python.
  + `mode`(str) — Tentukan mode pekerjaan pelatihan menggunakan kelas `PythonProfileModes` enumerator. Nilai default-nya `PythonProfileModes.TRAIN`. Opsi yang tersedia disediakan di bagian [Mode Pelatihan dan Fase untuk Profiling Python](#debugger-access-data-python-profiling-modes).
  + `start_phase`(str) - Tentukan fase awal pada langkah target menggunakan kelas `StepPhase` enumerator. Parameter ini memungkinkan pembuatan profil antara fase pelatihan yang berbeda. Nilai default-nya `StepPhase.STEP_START`. Opsi yang tersedia disediakan di bagian [Mode Pelatihan dan Fase untuk Profiling Python](#debugger-access-data-python-profiling-phases).
  + `end_phase`(str) - Tentukan fase akhir pada langkah target menggunakan kelas `StepPhase` enumerator. Parameter ini mengatur fase akhir pelatihan. Opsi yang tersedia sama dengan yang untuk `start_phase` parameter. Nilai default-nya `StepPhase.STEP_END`. Opsi yang tersedia disediakan di bagian [Mode Pelatihan dan Fase untuk Profiling Python](#debugger-access-data-python-profiling-phases).
+ `python_analysis.fetch_profile_stats_between_modes(start_mode, end_mode)`— Mengambil statistik dari profil Python antara mode awal dan akhir.
+ `python_analysis.fetch_pre_step_zero_profile_stats()`— Mengambil statistik dari profil Python hingga langkah 0.
+ `python_analysis.fetch_post_hook_close_profile_stats()`— Mengambil statistik dari profil Python setelah hook ditutup.
+ `python_analysis.list_profile_stats()`— DataFrame Mengembalikan statistik profil Python. Setiap baris menyimpan metadata untuk setiap instance profil dan file statistik yang sesuai (satu per langkah).
+ `python_analysis.list_available_node_ids()`— Mengembalikan daftar node yang tersedia IDs untuk statistik profil Python.

Metode khusus `cProfileAnalysis` kelas:
+  `fetch_profile_stats_by_training_phase()`— Mengambil dan menggabungkan statistik profil Python untuk setiap kemungkinan kombinasi mode awal dan akhir. Misalnya, jika fase pelatihan dan validasi dilakukan saat pembuatan profil terperinci diaktifkan, kombinasinya adalah,`(PRE_STEP_ZERO, TRAIN)`,, `(TRAIN, TRAIN)` `(TRAIN, EVAL)``(EVAL, EVAL)`, dan. `(EVAL, POST_HOOK_CLOSE)` Semua file statistik dalam masing-masing kombinasi ini digabungkan.
+  `fetch_profile_stats_by_job_phase()`— Mengambil dan menggabungkan statistik profil Python berdasarkan fase pekerjaan. Fase pekerjaan adalah `initialization` (pembuatan profil hingga langkah 0), `training_loop` (pelatihan dan validasi), dan `finalization` (pembuatan profil setelah kait ditutup).

# Gabungkan garis waktu beberapa file jejak profil
<a name="debugger-merge-timeline"></a>

Pustaka SMDebug klien menyediakan analisis profil dan alat visualisasi untuk menggabungkan garis waktu metrik sistem, metrik kerangka kerja, dan data profil Python yang dikumpulkan oleh Debugger. 

**Tip**  
Sebelum melanjutkan, Anda perlu mengatur TrainingJob objek yang akan digunakan di seluruh contoh di halaman ini. Untuk informasi selengkapnya tentang menyiapkan TrainingJob objek, lihat[Akses data profil](debugger-analyze-data-profiling.md).

`MergedTimeline`Kelas menyediakan alat untuk mengintegrasikan dan mengkorelasikan informasi profil yang berbeda dalam satu garis waktu. Setelah Debugger menangkap data profil dan anotasi dari berbagai fase pekerjaan pelatihan, file JSON dari peristiwa pelacakan disimpan dalam direktori default. `tracefolder`
+ Untuk anotasi di lapisan Python, file jejak disimpan di. `*pythontimeline.json` 
+ Untuk anotasi di lapisan TensorFlow C \$1\$1, file jejak disimpan di. `*model_timeline.json` 
+ Profiler Tensorflow menyimpan peristiwa dalam file. `*trace.json.gz` 

**Tip**  
Jika Anda ingin membuat daftar semua file jejak JSON, gunakan AWS CLI perintah berikut:  

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

Seperti yang ditunjukkan pada tangkapan layar animasi berikut, menempatkan dan menyelaraskan peristiwa jejak yang diambil dari sumber profil yang berbeda dalam satu plot dapat memberikan gambaran umum tentang seluruh peristiwa yang terjadi dalam fase yang berbeda dari pekerjaan pelatihan.

![\[Contoh garis waktu gabungan\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-merged-timeline.gif)


**Tip**  
Untuk berinteraksi dengan timeline gabungan pada aplikasi traicing menggunakan keyboard, gunakan `W` tombol untuk memperbesar, tombol untuk menggeser ke kiri, `A` tombol untuk memperkecil, dan `S` tombol untuk bergeser ke kanan. `D`

Beberapa file JSON jejak peristiwa dapat digabungkan menjadi satu file JSON peristiwa jejak menggunakan operasi `MergedTimeline` API berikut dan metode kelas dari modul. `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)
```

Operasi `MergedTimeline` API melewati parameter berikut:
+ `path`(str) - Tentukan folder root (`/profiler-output`) yang berisi file jejak profil sistem dan kerangka kerja. Anda dapat menemukan metode kelas estimator SageMaker AI atau objeknya TrainingJob . `profiler-output` Misalnya, `estimator.latest_job_profiler_artifacts_path()` atau `tj.profiler_s3_output_path`.
+ `file_suffix_filter`(daftar) - Tentukan daftar filter akhiran file untuk menggabungkan garis waktu. Filter akhiran yang tersedia adalah `["model_timeline.json", "pythontimeline.json", "trace.json.gz"].` Jika parameter ini tidak ditentukan secara manual, semua file jejak digabungkan secara default.
+ `output_directory`(str) - Tentukan jalur untuk menyimpan file JSON garis waktu gabungan. Defaultnya adalah ke direktori yang ditentukan untuk `path` parameter.

`merge_timeline()`Classmethod melewati parameter berikut untuk menjalankan proses penggabungan:
+ `start`(int) - Tentukan waktu mulai (dalam mikrodetik dan dalam format waktu Unix) atau mulai langkah untuk menggabungkan garis waktu.
+ `end`(int) - Tentukan waktu akhir (dalam mikrodetik dan dalam format waktu Unix) atau langkah akhir untuk menggabungkan garis waktu.
+ `unit`(str) — Pilih antara `"time"` dan`"step"`. Nilai default-nya `"time"`.

Dengan menggunakan kode contoh berikut, jalankan `merge_timeline()` metode dan unduh file JSON yang digabungkan. 
+ Gabungkan timeline dengan opsi `"time"` unit. Contoh kode berikut menggabungkan semua file jejak yang tersedia antara waktu mulai Unix (waktu Unix nol mutlak) dan waktu Unix saat ini, yang berarti Anda dapat menggabungkan garis waktu untuk seluruh durasi pelatihan.

  ```
  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))
  ```
+ Gabungkan timeline dengan opsi `"step"` unit. Kode contoh berikut menggabungkan semua garis waktu yang tersedia antara langkah 3 dan langkah 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")
  ```

Buka aplikasi penelusuran Chrome `chrome://tracing` di browser Chrome, dan buka file JSON. Anda dapat menjelajahi output untuk memplot timeline gabungan. 

# Membuat profil pemuat data
<a name="debugger-data-loading-time"></a>

Pada tahun PyTorch, iterator pemuat data, seperti `SingleProcessingDataLoaderIter` dan`MultiProcessingDataLoaderIter`, dimulai pada awal setiap iterasi melalui kumpulan data. Selama fase inisialisasi, PyTorch mengaktifkan proses pekerja tergantung pada jumlah pekerja yang dikonfigurasi, menetapkan antrian data untuk mengambil data dan utas. `pin_memory`

Untuk menggunakan alat analisis profil pemuat PyTorch data, impor `PT_dataloader_analysis` kelas berikut:

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

Lulus data profil yang diambil sebagai objek data bingkai Pandas di bagian: [Akses data profil menggunakan alat parsing data panda](debugger-access-data-profiling-pandas-frame.md)

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

Fungsi-fungsi berikut tersedia untuk `pt_analysis` objek:

 SMDebug `S3SystemMetricsReader`Kelas membaca metrik sistem dari bucket S3 yang ditentukan ke parameter. `s3_trial_path`
+ `pt_analysis.analyze_dataloaderIter_initialization()`

  Analisis menghasilkan median dan durasi maksimum untuk inisialisasi ini. Jika ada outlier, (yaitu durasi lebih besar dari 2 \$1 median), fungsi mencetak waktu mulai dan akhir untuk durasi tersebut. Ini dapat digunakan untuk memeriksa metrik sistem selama interval waktu tersebut.

  Daftar berikut menunjukkan analisis apa yang tersedia dari metode kelas ini:
  + Jenis iterator pemuat data apa yang diinisialisasi.
  + Jumlah pekerja per iterator.
  + Periksa apakah iterator diinisialisasi dengan atau tanpa pin\$1memory.
  + Berapa kali iterator diinisialisasi selama pelatihan.
+ `pt_analysis.analyze_dataloaderWorkers()`

  Daftar berikut menunjukkan analisis apa yang tersedia dari metode kelas ini:
  + Jumlah proses pekerja yang diputar selama seluruh pelatihan. 
  + Durasi rata-rata dan maksimum untuk proses pekerja. 
  + Waktu mulai dan berakhir untuk proses pekerja yang merupakan outlier. 
+ `pt_analysis.analyze_dataloader_getnext()`

  Daftar berikut menunjukkan analisis apa yang tersedia dari metode kelas ini:
  + Jumlah GetNext panggilan yang dilakukan selama pelatihan. 
  + Median dan durasi maksimum dalam mikrodetik untuk GetNext panggilan. 
  + Waktu mulai, Waktu berakhir, durasi, dan id pekerja untuk durasi GetNext panggilan outlier. 
+ `pt_analysis.analyze_batchtime(start_timestamp, end_timestamp, select_events=[".*"], select_dimensions=[".*"])`

  Debugger mengumpulkan waktu mulai dan berakhir dari semua panggilan. GetNext Anda dapat menemukan jumlah waktu yang dihabiskan oleh skrip pelatihan pada satu kumpulan data. Dalam jendela waktu yang ditentukan, Anda dapat mengidentifikasi panggilan yang tidak secara langsung berkontribusi pada pelatihan. Panggilan ini dapat berasal dari operasi berikut: menghitung akurasi, menambahkan kerugian untuk tujuan debugging atau logging, dan mencetak informasi debugging. Operasi seperti ini dapat dihitung secara intensif atau memakan waktu. Kami dapat mengidentifikasi operasi tersebut dengan menghubungkan profiler Python, metrik sistem, dan metrik kerangka kerja.

  Daftar berikut menunjukkan analisis apa yang tersedia dari metode kelas ini:
  + Waktu profil yang dihabiskan untuk setiap kumpulan data`BatchTime_in_seconds`,, dengan menemukan perbedaan antara waktu mulai GetNext panggilan saat ini dan berikutnya. 
  + Temukan outlier di dalam `BatchTime_in_seconds` dan waktu mulai dan berakhir untuk outlier tersebut.
  + Dapatkan metrik sistem dan kerangka kerja selama stempel waktu tersebut`BatchTime_in_seconds`. Ini menunjukkan di mana waktu dihabiskan.
+ `pt_analysis.plot_the_window()`

  Plot bagan garis waktu antara stempel waktu awal dan stempel waktu akhir.