Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Pantau pemanfaatan sumber daya AWS komputasi di Amazon Studio Classic SageMaker
Untuk melacak pemanfaatan sumber daya komputasi dari pekerjaan pelatihan Anda, gunakan alat pemantauan yang ditawarkan oleh Amazon SageMaker Debugger.
Untuk pekerjaan pelatihan apa pun yang Anda jalankan di SageMaker AI menggunakan SageMaker Python SDK, Debugger mengumpulkan metrik pemanfaatan sumber daya dasar, seperti pemanfaatan CPU, pemanfaatan GPU, pemanfaatan memori GPU, jaringan, dan waktu tunggu setiap 500 milidetik. I/O Untuk melihat dasbor metrik pemanfaatan sumber daya dari pekerjaan pelatihan Anda, cukup gunakan UI [SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html) di Studio Experiments. SageMaker
Operasi dan langkah-langkah pembelajaran mendalam dapat beroperasi dalam interval milidetik. Dibandingkan dengan CloudWatch metrik Amazon, yang mengumpulkan metrik pada interval 1 detik, Debugger memberikan perincian yang lebih halus ke dalam metrik pemanfaatan sumber daya hingga interval 100 milidetik (0,1 detik) sehingga Anda dapat menyelam jauh ke dalam metrik pada tingkat operasi atau langkah.
Jika Anda ingin mengubah interval waktu pengumpulan metrik, Anda dapat menambahkan parameter untuk konfigurasi profil ke peluncur pekerjaan pelatihan Anda. Misalnya, jika Anda menggunakan SageMaker AI Python SDK, Anda harus meneruskan `profiler_config` parameter saat membuat objek estimator. Untuk mempelajari cara menyesuaikan interval pengumpulan metrik pemanfaatan sumber daya, lihat [Template kode untuk mengonfigurasi objek estimator SageMaker AI dengan modul SageMaker Debugger Python di AI Python SDK SageMaker](debugger-configuration-for-profiling.md#debugger-configuration-structure-profiler) dan kemudian[Konfigurasikan pengaturan untuk pembuatan profil dasar pemanfaatan sumber daya sistem](debugger-configure-system-monitoring.md).
Selain itu, Anda dapat menambahkan alat pendeteksi masalah yang disebut *aturan profil bawaan yang disediakan oleh SageMaker Debugger*. Aturan pembuatan profil bawaan menjalankan analisis terhadap metrik pemanfaatan sumber daya dan mendeteksi masalah kinerja komputasi. Untuk informasi selengkapnya, lihat [Menggunakan aturan profiler bawaan yang dikelola oleh Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md). Anda dapat menerima hasil analisis aturan melalui [UI SageMaker Debugger di SageMaker Studio Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html) atau [SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html) Profiling Report. Anda juga dapat membuat aturan pembuatan profil khusus menggunakan SageMaker Python SDK.
Untuk mempelajari selengkapnya tentang fungsi pemantauan yang disediakan oleh SageMaker Debugger, lihat topik berikut.
**Topics**
+ [Konfigurasi estimator dengan parameter untuk pembuatan profil dasar menggunakan modul Amazon SageMaker Debugger Python](debugger-configuration-for-profiling.md)
+ [Menggunakan aturan profiler bawaan yang dikelola oleh Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md)
+ [Daftar aturan profiler bawaan Debugger](debugger-built-in-profiler-rules.md)
+ [Amazon SageMaker Debugger UI di Eksperimen Klasik Amazon SageMaker Studio](debugger-on-studio.md)
+ [SageMaker Laporan interaktif debugger](debugger-profiling-report.md)
+ [Menganalisis data menggunakan pustaka klien Python Debugger](debugger-analyze-data.md)
# Konfigurasi estimator dengan parameter untuk pembuatan profil dasar menggunakan modul Amazon SageMaker Debugger Python
[Secara default, pembuatan profil dasar SageMaker Debugger aktif secara default dan memantau metrik pemanfaatan sumber daya, seperti pemanfaatan CPU, pemanfaatan GPU, pemanfaatan memori GPU, Jaringan, dan waktu tunggu I/O, dari semua pekerjaan pelatihan yang diajukan menggunakan Amazon Python SDK. SageMaker SageMaker ](https://sagemaker.readthedocs.io/en/stable) SageMaker Debugger mengumpulkan metrik pemanfaatan sumber daya ini setiap 500 milidetik. Anda tidak perlu membuat perubahan tambahan dalam kode, skrip pelatihan, atau peluncur pekerjaan untuk melacak pemanfaatan sumber daya dasar. Jika Anda ingin mengubah interval pengumpulan metrik untuk pembuatan profil dasar, Anda dapat menentukan parameter khusus Debugger saat membuat peluncur pekerjaan SageMaker pelatihan menggunakan SageMaker Python SDK,, atau (CLI). AWS SDK untuk Python (Boto3) AWS Command Line Interface Dalam panduan ini, kami fokus pada cara mengubah opsi pembuatan profil menggunakan [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable). Halaman ini memberikan template referensi untuk mengkonfigurasi objek estimator ini.
Jika Anda ingin mengakses dasbor metrik pemanfaatan sumber daya dari pekerjaan pelatihan Anda di SageMaker Studio, Anda dapat melompat ke halaman. [Amazon SageMaker Debugger UI di Eksperimen Klasik Amazon SageMaker Studio](debugger-on-studio.md)
Jika Anda ingin mengaktifkan aturan yang mendeteksi masalah pemanfaatan sumber daya sistem secara otomatis, Anda dapat menambahkan `rules` parameter di objek estimator untuk mengaktifkan aturan.
**penting**
Untuk menggunakan fitur SageMaker Debugger terbaru, Anda perlu memutakhirkan SageMaker Python SDK dan pustaka klien. `SMDebug` Di kernel IPython Anda, Jupyter Notebook, JupyterLab atau lingkungan, jalankan kode berikut untuk menginstal versi terbaru dari pustaka dan restart kernel.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Template kode untuk mengonfigurasi objek estimator SageMaker AI dengan modul SageMaker Debugger Python di AI Python SDK SageMaker
Untuk menyesuaikan konfigurasi profil dasar (`profiler_config`) atau menambahkan aturan profiler (`rules`), pilih salah satu tab untuk mendapatkan templat untuk menyiapkan estimator AI. SageMaker Di halaman berikutnya, Anda dapat menemukan informasi lebih lanjut tentang cara mengkonfigurasi dua parameter.
**catatan**
Contoh kode berikut tidak dapat dieksekusi secara langsung. Lanjutkan ke bagian berikutnya untuk mempelajari cara mengkonfigurasi setiap parameter.
------
#### [ PyTorch ]
```
# An example of constructing a SageMaker AI PyTorch estimator
import boto3
import sagemaker
from sagemaker.pytorch import PyTorch
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
session=boto3.session.Session()
region=session.region_name
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=PyTorch(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.12.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ TensorFlow ]
```
# An example of constructing a SageMaker AI TensorFlow estimator
import boto3
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
session=boto3.session.Session()
region=session.region_name
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=TensorFlow(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.8.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ MXNet ]
```
# An example of constructing a SageMaker AI MXNet estimator
import sagemaker
from sagemaker.mxnet import MXNet
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=MXNet(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.7.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
**catatan**
Untuk MXNet, saat mengkonfigurasi `profiler_config` parameter, Anda hanya dapat mengkonfigurasi untuk pemantauan sistem. Metrik kerangka kerja profil tidak didukung untuk. MXNet
------
#### [ XGBoost ]
```
# An example of constructing a SageMaker AI XGBoost estimator
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=XGBoost(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.5-1",
# Debugger-specific parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
**catatan**
Untuk XGBoost, saat mengkonfigurasi `profiler_config` parameter, Anda hanya dapat mengkonfigurasi untuk pemantauan sistem. Metrik kerangka kerja profil tidak didukung untuk. XGBoost
------
#### [ Generic estimator ]
```
# An example of constructing a SageMaker AI generic estimator using the XGBoost algorithm base image
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import ProfilerConfig, DebuggerHookConfig, Rule, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
region=boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.5-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Debugger-specific parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
Berikut ini memberikan deskripsi singkat tentang parameter.
+ `profiler_config`— Konfigurasikan Debugger untuk mengumpulkan metrik sistem dan metrik kerangka kerja dari pekerjaan pelatihan Anda dan simpan ke URI bucket S3 atau mesin lokal Anda yang aman. Anda dapat mengatur seberapa sering atau longgar mengumpulkan metrik sistem. Untuk mempelajari cara mengkonfigurasi `profiler_config` parameter, lihat [Konfigurasikan pengaturan untuk pembuatan profil dasar pemanfaatan sumber daya sistem](debugger-configure-system-monitoring.md) dan[Konfigurasi estimator untuk pembuatan profil kerangka kerja](debugger-configure-framework-profiling.md).
+ `rules`— Konfigurasikan parameter ini untuk mengaktifkan aturan bawaan SageMaker Debugger yang ingin Anda jalankan secara paralel. Pastikan bahwa pekerjaan pelatihan Anda memiliki akses ke bucket S3 ini. Aturan berjalan pada wadah pemrosesan dan secara otomatis menganalisis pekerjaan pelatihan Anda untuk menemukan masalah kinerja komputasi dan operasional. [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report)Aturan ini adalah aturan paling terintegrasi yang menjalankan semua aturan pembuatan profil bawaan dan menyimpan hasil pembuatan profil sebagai laporan ke dalam bucket S3 aman Anda. Untuk mempelajari cara mengkonfigurasi `rules` parameter, lihat[Menggunakan aturan profiler bawaan yang dikelola oleh Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md).
**catatan**
Debugger menyimpan data keluaran dengan aman di subfolder bucket S3 default Anda. Misalnya, format URI bucket S3 default adalah`s3://sagemaker--<12digit_account_id>///`. Ada tiga subfolder yang dibuat oleh Debugger:`debug-output`,, `profiler-output` dan. `rule-output` Anda juga dapat mengambil bucket S3 default URIs menggunakan classmethods [estimator SageMaker AI](debugger-estimator-classmethods.md).
Lihat topik berikut untuk mengetahui cara mengonfigurasi parameter khusus Debugger secara detail.
**Topics**
+ [Template kode untuk mengonfigurasi objek estimator SageMaker AI dengan modul SageMaker Debugger Python di AI Python SDK SageMaker](#debugger-configuration-structure-profiler)
+ [Konfigurasikan pengaturan untuk pembuatan profil dasar pemanfaatan sumber daya sistem](debugger-configure-system-monitoring.md)
+ [Konfigurasi estimator untuk pembuatan profil kerangka kerja](debugger-configure-framework-profiling.md)
+ [Memperbarui pemantauan sistem Debugger dan konfigurasi profil kerangka kerja saat pekerjaan pelatihan sedang berjalan](debugger-update-monitoring-profiling.md)
+ [Matikan Debugger](debugger-turn-off-profiling.md)
# Konfigurasikan pengaturan untuk pembuatan profil dasar pemanfaatan sumber daya sistem
Untuk menyesuaikan interval waktu pengumpulan metrik pemanfaatan, gunakan operasi `ProfilerConfig` API untuk membuat objek parameter sambil membuat kerangka kerja SageMaker AI atau estimator generik tergantung pada preferensi Anda.
**catatan**
Secara default, untuk semua pekerjaan SageMaker pelatihan, Debugger mengumpulkan metrik pemanfaatan sumber daya dari instans Amazon EC2 setiap 500 milidetik untuk pemantauan sistem, tanpa parameter khusus Debugger yang ditentukan dalam estimator AI. SageMaker
Debugger menyimpan metrik sistem di bucket S3 default. Format URI bucket S3 default adalah`s3://sagemaker--<12digit_account_id>//profiler-output/`.
Contoh kode berikut menunjukkan cara mengatur `profiler_config` parameter dengan interval waktu pemantauan sistem 1000 milidetik.
```
from sagemaker.debugger import ProfilerConfig
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000
)
```
+ `system_monitor_interval_millis`(int) — Tentukan interval pemantauan dalam milidetik untuk merekam metrik sistem. Nilai yang tersedia adalah 100, 200, 500, 1000 (1 detik), 5000 (5 detik), dan 60000 (1 menit) milidetik. Nilai defaultnya adalah 500 milidetik.
Untuk melihat kemajuan pemantauan sistem, lihat[Buka dasbor Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md).
# Konfigurasi estimator untuk pembuatan profil kerangka kerja
**Awas**
Untuk mendukung [Amazon SageMaker Profiler](train-use-sagemaker-profiler.md), SageMaker AI Debugger menghentikan fitur pembuatan profil kerangka kerja mulai dari 2.11 dan 2.0. TensorFlow PyTorch Anda masih dapat menggunakan fitur ini di versi kerangka kerja sebelumnya dan SDKs sebagai berikut.
SageMaker Python SDK <= v2.130.0
PyTorch >= v1.6.0, < v2.0
TensorFlow >= v2.3.1, < v2.11
Lihat juga [16 Maret 2023](debugger-release-notes.md#debugger-release-notes-20230315).
Untuk mengaktifkan pembuatan profil kerangka kerja Debugger, konfigurasikan `framework_profile_params` parameter saat Anda membuat estimator. Pemprofilan kerangka kerja debugger mengumpulkan metrik kerangka kerja, seperti data dari tahap inisialisasi, proses pemuat data, operator Python dari kerangka kerja pembelajaran mendalam dan skrip pelatihan, pembuatan profil terperinci di dalam dan di antara langkah-langkah, dengan opsi CProfile atau Pyinstrument. Menggunakan `FrameworkProfile` kelas, Anda dapat mengonfigurasi opsi pembuatan profil kerangka kustom.
**catatan**
Sebelum memulai dengan pembuatan profil kerangka kerja Debugger, verifikasi bahwa kerangka kerja yang digunakan untuk membangun model Anda didukung oleh Debugger untuk pembuatan profil kerangka kerja. Untuk informasi selengkapnya, lihat [Kerangka kerja dan algoritma yang didukung](debugger-supported-frameworks.md).
Debugger menyimpan metrik kerangka kerja dalam bucket S3 default. Format URI bucket S3 default adalah`s3://sagemaker--<12digit_account_id>//profiler-output/`.
**Topics**
+ [Profil kerangka kerja default](debugger-configure-framework-profiling-basic.md)
+ [Pemantauan sistem default dan pembuatan profil kerangka kerja yang disesuaikan untuk langkah target atau rentang waktu target](debugger-configure-framework-profiling-range.md)
+ [Pemantauan sistem default dan pembuatan profil kerangka kerja yang disesuaikan dengan opsi pembuatan profil yang berbeda](debugger-configure-framework-profiling-options.md)
# Profil kerangka kerja default
Pemprofilan default kerangka kerja debugger mencakup opsi berikut: pembuatan profil terperinci, profil pemuat data, dan profil Python. Kode contoh berikut adalah pengaturan `profiler_config` parameter paling sederhana untuk memulai pemantauan sistem default dan pembuatan profil kerangka kerja default. `FrameworkProfile`Kelas dalam kode contoh berikut memulai profil kerangka kerja default ketika pekerjaan pelatihan dimulai.
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile()
)
```
Dengan konfigurasi `profiler_config` parameter ini, Debugger memanggil pengaturan default pemantauan dan pembuatan profil. Debugger memantau metrik sistem setiap 500 milidetik; profil langkah kelima dengan opsi pembuatan profil terperinci; langkah ketujuh dengan opsi profil pemuat data; dan langkah kesembilan, kesepuluh, dan kesebelas dengan opsi profil Python.
Untuk menemukan opsi konfigurasi profil yang tersedia, pengaturan parameter default, dan contoh cara mengonfigurasinya, lihat [Pemantauan sistem default dan pembuatan profil kerangka kerja yang disesuaikan dengan opsi pembuatan profil yang berbeda](debugger-configure-framework-profiling-options.md) dan [SageMaker Debugger APIs — FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) di Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable) SDK.
Jika Anda ingin mengubah interval pemantauan sistem dan mengaktifkan profil kerangka kerja default, Anda dapat menentukan `system_monitor_interval_millis` parameter secara eksplisit dengan parameter. `framework_profile_params` Misalnya, untuk memantau setiap 1000 milidetik dan mengaktifkan profil kerangka kerja default, gunakan kode contoh berikut.
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile()
)
```
Untuk informasi selengkapnya tentang `FrameworkProfile` kelas, lihat [SageMaker Debugger APIs — FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) di Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable) SDK.
# Pemantauan sistem default dan pembuatan profil kerangka kerja yang disesuaikan untuk langkah target atau rentang waktu target
Jika Anda ingin menentukan langkah target atau interval waktu target untuk membuat profil pekerjaan pelatihan Anda, Anda perlu menentukan parameter untuk `FrameworkProfile` kelas. Contoh kode berikut menunjukkan cara menentukan rentang target untuk pembuatan profil bersama dengan pemantauan sistem.
+ **Untuk rentang langkah target**
Dengan konfigurasi contoh berikut, Debugger memantau seluruh pekerjaan pelatihan setiap 500 milidetik (pemantauan default) dan profil rentang langkah target dari langkah 5 hingga langkah 15 (untuk 10 langkah).
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile(start_step=5, num_steps=10)
)
```
Dengan konfigurasi contoh berikut, Debugger memantau seluruh pekerjaan pelatihan setiap 1000 milidetik dan profil rentang langkah target dari langkah 5 hingga langkah 15 (untuk 10 langkah).
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile(start_step=5, num_steps=10)
)
```
+ **Untuk rentang waktu target**
Dengan konfigurasi contoh berikut, Debugger memantau seluruh pekerjaan pelatihan setiap 500 milidetik (pemantauan default) dan profil rentang waktu target dari waktu Unix saat ini selama 600 detik.
```
import time
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile(start_unix_time=int(time.time()), duration=600)
)
```
Dengan konfigurasi contoh berikut, Debugger memantau seluruh pekerjaan pelatihan setiap 1000 milidetik dan profil rentang waktu target dari waktu Unix saat ini selama 600 detik.
```
import time
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile(start_unix_time=int(time.time()), duration=600)
)
```
Pembuatan profil kerangka kerja dilakukan untuk semua opsi pembuatan profil pada langkah target atau rentang waktu.
Untuk menemukan informasi selengkapnya tentang opsi pembuatan profil yang tersedia, lihat [SageMaker Debugger APIs — FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) di Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable) SDK.
Bagian selanjutnya menunjukkan kepada Anda cara membuat skrip opsi profil yang tersedia.
# Pemantauan sistem default dan pembuatan profil kerangka kerja yang disesuaikan dengan opsi pembuatan profil yang berbeda
Bagian ini memberikan informasi tentang kelas konfigurasi profiling yang didukung, serta konfigurasi contoh. Anda dapat menggunakan kelas konfigurasi profiling berikut untuk mengelola opsi pembuatan profil kerangka kerja:
+ [DetailedProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DetailedProfilingConfig)— Tentukan langkah target atau rentang waktu untuk operasi kerangka profil menggunakan profiler kerangka kerja asli (profiler dan TensorFlow PyTorch profiler). Misalnya, jika menggunakan TensorFlow, kait Debugger memungkinkan TensorFlow profiler untuk mengumpulkan TensorFlow metrik kerangka kerja khusus. Pembuatan profil terperinci memungkinkan Anda untuk membuat profil semua operator kerangka kerja pada tahap awal (sebelum langkah pertama), dalam beberapa langkah, dan di antara langkah-langkah pekerjaan pelatihan.
**catatan**
Profil terperinci dapat secara signifikan meningkatkan konsumsi memori GPU. Kami tidak menyarankan untuk mengaktifkan profil terperinci selama lebih dari beberapa langkah.
+ [DataloaderProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DataloaderProfilingConfig)— Tentukan langkah target atau rentang waktu untuk membuat profil proses pemuat data kerangka pembelajaran mendalam. Debugger mengumpulkan setiap peristiwa pemuat data dari kerangka kerja.
**catatan**
Pembuatan profil pemuat data dapat menurunkan kinerja pelatihan sambil mengumpulkan informasi dari pemuat data. Kami tidak menyarankan untuk mengaktifkan profil pemuat data selama lebih dari beberapa langkah.
Debugger telah dikonfigurasi sebelumnya untuk membuat anotasi proses pemuat data hanya untuk wadah pembelajaran mendalam. AWS Debugger tidak dapat memprofilkan proses pemuat data dari wadah pelatihan khusus atau eksternal lainnya.
+ [PythonProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.PythonProfilingConfig)— Tentukan langkah target atau rentang waktu untuk memprofilkan fungsi Python. Anda juga dapat memilih antara dua profiler Python: CProfile dan Pyinstrument.
+ *CProfile — Profiler* Python standar. cProfile mengumpulkan informasi untuk setiap operator Python yang dipanggil selama pelatihan. Dengan CProfile, Debugger menghemat waktu kumulatif dan anotasi untuk setiap panggilan fungsi, memberikan detail lengkap tentang fungsi Python. Dalam pembelajaran mendalam, misalnya, fungsi yang paling sering disebut mungkin adalah filter convolutional dan operator backward pass, dan profil CProfile masing-masing. Untuk opsi CProfile, Anda dapat memilih opsi timer lebih lanjut: total waktu, waktu CPU, dan waktu off-CPU. Meskipun Anda dapat membuat profil setiap panggilan fungsi yang dijalankan pada prosesor (baik CPU dan GPU) dalam waktu CPU, Anda juga dapat mengidentifikasi I/O atau kemacetan jaringan dengan opsi waktu off-CPU. Defaultnya adalah total waktu, dan Debugger memprofilkan waktu CPU dan off-CPU. Dengan CProfile, Anda dapat menelusuri setiap fungsi saat menganalisis data profil.
+ *Pyinstrument* — Pyinstrument adalah profiler Python overhead rendah yang bekerja berdasarkan pengambilan sampel. Dengan opsi Pyinstrument, Debugger mengambil sampel pembuatan profil peristiwa setiap milidetik. Karena Pyinstrument mengukur waktu jam dinding yang telah berlalu alih-alih waktu CPU, opsi Pyinstrument dapat menjadi pilihan yang lebih baik daripada opsi CProfile untuk mengurangi kebisingan profil (menyaring panggilan fungsi yang tidak relevan yang secara kumulatif cepat) dan menangkap operator yang sebenarnya komputasi intensif (secara kumulatif lambat) untuk melatih model Anda. Dengan Pyinstrument, Anda dapat melihat pohon panggilan fungsi dan lebih memahami struktur dan akar penyebab kelambatan.
**catatan**
Mengaktifkan pembuatan profil Python dapat memperlambat waktu pelatihan secara keseluruhan. cProfile memprofilkan operator Python yang paling sering disebut di setiap panggilan, sehingga waktu pemrosesan pada pembuatan profil meningkat sehubungan dengan jumlah panggilan. Untuk Pyinstrument, waktu pembuatan profil kumulatif meningkat sehubungan dengan waktu karena mekanisme pengambilan sampelnya.
Contoh konfigurasi berikut menunjukkan struktur lengkap saat Anda menggunakan opsi profil yang berbeda dengan nilai yang ditentukan.
```
import time
from sagemaker.debugger import (ProfilerConfig,
FrameworkProfile,
DetailedProfilingConfig,
DataloaderProfilingConfig,
PythonProfilingConfig,
PythonProfiler, cProfileTimer)
profiler_config=ProfilerConfig(
system_monitor_interval_millis=500,
framework_profile_params=FrameworkProfile(
detailed_profiling_config=DetailedProfilingConfig(
start_step=5,
num_steps=1
),
dataloader_profiling_config=DataloaderProfilingConfig(
start_step=7,
num_steps=1
),
python_profiling_config=PythonProfilingConfig(
start_step=9,
num_steps=1,
python_profiler=PythonProfiler.CPROFILE,
cprofile_timer=cProfileTimer.TOTAL_TIME
)
)
)
```
Untuk informasi selengkapnya tentang opsi pembuatan profil yang tersedia, lihat [DetailedProfilingConfig[DataloaderProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DataloaderProfilingConfig)](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DetailedProfilingConfig), dan [PythonProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.PythonProfilingConfig)di [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
# Memperbarui pemantauan sistem Debugger dan konfigurasi profil kerangka kerja saat pekerjaan pelatihan sedang berjalan
Jika Anda ingin mengaktifkan atau memperbarui konfigurasi pemantauan Debugger untuk pekerjaan pelatihan yang sedang berjalan, gunakan metode ekstensi estimator SageMaker AI berikut:
+ Untuk mengaktifkan pemantauan sistem Debugger untuk pekerjaan pelatihan yang sedang berjalan dan menerima laporan pembuatan profil Debugger, gunakan yang berikut ini:
```
estimator.enable_default_profiling()
```
Saat Anda menggunakan `enable_default_profiling` metode ini, Debugger memulai pemantauan sistem default dan aturan `ProfileReport` bawaan, yang menghasilkan laporan profil komprehensif di akhir pekerjaan pelatihan. Metode ini hanya dapat dipanggil jika pekerjaan pelatihan saat ini berjalan tanpa pemantauan dan pembuatan profil Debugger.
[Untuk informasi selengkapnya, lihat [estimator.enable\$1default\$1profiling](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.enable_default_profiling) di Amazon Python SDK. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
+ Untuk memperbarui konfigurasi pemantauan sistem, gunakan yang berikut ini:
```
estimator.update_profiler(
system_monitor_interval_millis=500
)
```
[Untuk informasi selengkapnya, lihat [estimator.update\$1profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler) di Amazon Python SDK. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# Matikan Debugger
Jika Anda ingin mematikan Debugger sepenuhnya, lakukan salah satu hal berikut:
+ Sebelum memulai pekerjaan pelatihan, lakukan hal berikut:
Untuk menonaktifkan pembuatan profil, sertakan `disable_profiler` parameter ke estimator Anda dan atur ke. `True`
**Awas**
Jika menonaktifkannya, Anda tidak akan dapat melihat dasbor wawasan Studio Debugger yang komprehensif dan laporan pembuatan profil yang dibuat secara otomatis.
Untuk mematikan debugging, atur `debugger_hook_config` parameter ke`False`.
**Awas**
Jika Anda menonaktifkannya, Anda tidak akan dapat mengumpulkan tensor keluaran dan tidak dapat men-debug parameter model Anda.
```
estimator=Estimator(
...
disable_profiler=True
debugger_hook_config=False
)
```
[Untuk informasi selengkapnya tentang parameter khusus Debugger, lihat [SageMaker AI Estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator) di Amazon Python SDK. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
+ Saat pekerjaan pelatihan sedang berjalan, lakukan hal berikut:
Untuk menonaktifkan pemantauan dan pembuatan profil saat tugas pelatihan Anda berjalan, gunakan metode kelas estimator berikut:
```
estimator.disable_profiling()
```
Untuk menonaktifkan profil kerangka kerja saja dan menjaga pemantauan sistem, gunakan `update_profiler` metode ini:
```
estimator.update_profiler(disable_framework_metrics=true)
```
[https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler)
# Menggunakan aturan profiler bawaan yang dikelola oleh Amazon SageMaker Debugger
Aturan SageMaker profiler bawaan Amazon Debugger menganalisis metrik sistem dan operasi kerangka kerja yang dikumpulkan selama pelatihan model. Debugger menawarkan operasi `ProfilerRule` API yang membantu mengonfigurasi aturan untuk memantau sumber daya dan operasi komputasi pelatihan dan untuk mendeteksi anomali. Misalnya, aturan pembuatan profil dapat membantu Anda mendeteksi apakah ada masalah komputasi seperti kemacetan CPU, waktu I/O tunggu yang berlebihan, beban kerja yang tidak seimbang di seluruh pekerja GPU, dan sumber daya komputasi yang kurang dimanfaatkan. Untuk melihat daftar lengkap aturan pembuatan profil bawaan yang tersedia, lihat[Daftar aturan profiler bawaan Debugger](debugger-built-in-profiler-rules.md). Topik berikut menunjukkan cara menggunakan aturan bawaan Debugger dengan pengaturan parameter default dan nilai parameter khusus.
**catatan**
Aturan bawaan disediakan melalui wadah SageMaker pemrosesan Amazon dan dikelola sepenuhnya oleh SageMaker Debugger tanpa biaya tambahan. Untuk informasi selengkapnya tentang penagihan, lihat halaman [ SageMaker Harga Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Topics**
+ [Gunakan aturan SageMaker profiler bawaan Debugger dengan pengaturan parameter defaultnya](#debugger-built-in-profiler-rules-configuration)
+ [Gunakan aturan profiler bawaan Debugger dengan nilai parameter khusus](#debugger-built-in-profiler-rules-configuration-param-change)
## Gunakan aturan SageMaker profiler bawaan Debugger dengan pengaturan parameter defaultnya
Untuk menambahkan aturan bawaan SageMaker Debugger di estimator Anda, Anda perlu mengonfigurasi objek daftar`rules`. Kode contoh berikut menunjukkan struktur dasar daftar aturan bawaan SageMaker Debugger.
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_1()),
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_2()),
...
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_n()),
... # You can also append more debugging rules in the Rule.sagemaker(rule_configs.*()) format.
]
estimator=Estimator(
...
rules=rules
)
```
Untuk daftar lengkap aturan bawaan yang tersedia, lihat[Daftar aturan profiler bawaan Debugger](debugger-built-in-profiler-rules.md).
Untuk menggunakan aturan pembuatan profil dan memeriksa kinerja komputasi dan kemajuan pekerjaan pelatihan Anda, tambahkan aturan Debugger. [https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#profiler-report](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#profiler-report) SageMaker Aturan ini mengaktifkan semua aturan bawaan di bawah keluarga [Debugger ProfilerRule](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#debugger-built-in-profiler-rules-ProfilerRule)`ProfilerRule`. Selanjutnya, aturan ini menghasilkan laporan profil agregat. Untuk informasi selengkapnya, lihat [Membuat Profil Laporan yang Dihasilkan Menggunakan SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). Anda dapat menggunakan kode berikut untuk menambahkan aturan laporan pembuatan profil ke estimator pelatihan Anda.
```
from sagemaker.debugger import Rule, rule_configs
rules=[
ProfilerRule.sagemaker(rule_configs.ProfilerReport())
]
```
Saat Anda memulai pekerjaan pelatihan dengan `ProfilerReport` aturan, Debugger mengumpulkan data pemanfaatan sumber daya setiap 500 milidetik. Debugger menganalisis pemanfaatan sumber daya untuk mengidentifikasi apakah model Anda mengalami masalah kemacetan. Jika aturan mendeteksi anomali pelatihan, status evaluasi aturan berubah menjadi. `IssueFound` Anda dapat mengatur tindakan otomatis, seperti memberi tahu masalah pelatihan dan menghentikan pekerjaan pelatihan menggunakan CloudWatch Acara Amazon dan AWS Lambda. Untuk informasi selengkapnya, lihat [Tindakan pada aturan Amazon SageMaker Debugger](debugger-action-on-rules.md).
## Gunakan aturan profiler bawaan Debugger dengan nilai parameter khusus
Jika Anda ingin menyesuaikan nilai parameter aturan bawaan dan menyesuaikan regex koleksi tensor, konfigurasikan `rule_parameters` parameter `base_config` and untuk metode `ProfilerRule.sagemaker` dan `Rule.sagemaker` class. Dalam kasus metode `Rule.sagemaker` kelas, Anda juga dapat menyesuaikan koleksi tensor melalui `collections_to_save` parameter. Untuk instruksi tentang cara menggunakan `CollectionConfig` kelas, lihat[Konfigurasikan koleksi tensor menggunakan API `CollectionConfig`](debugger-configure-tensor-collections.md).
Gunakan templat konfigurasi berikut untuk aturan bawaan untuk menyesuaikan nilai parameter. Dengan mengubah parameter aturan sesuai keinginan, Anda dapat menyesuaikan sensitivitas aturan yang akan dimulai.
+ `base_config`Argumennya adalah di mana Anda memanggil metode aturan bawaan.
+ `rule_parameters`Argumennya adalah untuk menyesuaikan nilai kunci default dari aturan bawaan yang tercantum dalam[Daftar aturan profiler bawaan Debugger](debugger-built-in-profiler-rules.md).
[Untuk informasi selengkapnya tentang kelas aturan Debugger, metode, dan parameter, lihat kelas [Aturan Debugger SageMaker AI di](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html) Amazon Python SDK. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs, CollectionConfig
rules=[
ProfilerRule.sagemaker(
base_config=rule_configs.BuiltInProfilerRuleName(),
rule_parameters={
"key": "value"
}
)
]
```
Deskripsi parameter dan contoh kustomisasi nilai disediakan untuk setiap aturan di[Daftar aturan profiler bawaan Debugger](debugger-built-in-profiler-rules.md).
Untuk konfigurasi JSON tingkat rendah dari aturan bawaan Debugger yang menggunakan API, lihat. `CreateTrainingJob` [Konfigurasikan Debugger menggunakan API SageMaker](debugger-createtrainingjob-api.md)
# Daftar aturan profiler bawaan Debugger
Gunakan aturan profiler bawaan Debugger yang disediakan oleh Amazon SageMaker Debugger dan analisis metrik yang dikumpulkan saat melatih model Anda. Aturan bawaan Debugger memantau berbagai kondisi umum yang sangat penting untuk keberhasilan menjalankan pekerjaan pelatihan yang berkinerja. Anda dapat memanggil aturan profiler bawaan menggunakan [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) SDK atau operasi API tingkat rendah. SageMaker Tidak ada biaya tambahan untuk menggunakan aturan bawaan. Untuk informasi selengkapnya tentang penagihan, lihat halaman [ SageMaker Harga Amazon](https://aws.amazon.com/sagemaker/pricing/).
**catatan**
Jumlah maksimum aturan profiler bawaan yang dapat Anda lampirkan ke pekerjaan pelatihan adalah 20. SageMaker Debugger sepenuhnya mengelola aturan bawaan dan menganalisis pekerjaan pelatihan Anda secara serempak.
**penting**
Untuk menggunakan fitur Debugger baru, Anda perlu memutakhirkan SageMaker Python SDK dan pustaka klien. SMDebug Di kernel IPython, notebook Jupyter, JupyterLab atau lingkungan Anda, jalankan kode berikut untuk menginstal versi terbaru dari pustaka dan restart kernel.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Aturan profiler
Aturan berikut adalah aturan bawaan Debugger yang dapat dipanggil menggunakan classmethod. `ProfilerRule.sagemaker`
Aturan bawaan debugger untuk membuat laporan pembuatan profil
| Lingkup Validitas | Aturan bawaan |
| --- | --- |
| Laporan Profil untuk setiap pekerjaan SageMaker pelatihan | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
Aturan bawaan debugger untuk membuat profil pemanfaatan sumber daya sistem perangkat keras (metrik sistem)
| Lingkup Validitas | Aturan bawaan |
| --- | --- |
| Aturan pemantauan sistem generik untuk pekerjaan SageMaker pelatihan apa pun | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
Aturan bawaan debugger untuk membuat profil metrik kerangka kerja
| Lingkup Validitas | Aturan bawaan |
| --- | --- |
| Aturan pembuatan profil untuk kerangka pembelajaran mendalam (TensorFlow dan) PyTorch | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
**Awas**
Untuk mendukung [Amazon SageMaker Profiler](train-use-sagemaker-profiler.md), SageMaker AI Debugger menghentikan fitur pembuatan profil kerangka kerja mulai dari 2.11 dan 2.0. TensorFlow PyTorch Anda masih dapat menggunakan fitur ini di versi kerangka kerja sebelumnya dan SDKs sebagai berikut.
SageMaker Python SDK <= v2.130.0
PyTorch >= v1.6.0, < v2.0
TensorFlow >= v2.3.1, < v2.11
Lihat juga [16 Maret 2023](debugger-release-notes.md#debugger-release-notes-20230315).
**Untuk menggunakan aturan bawaan dengan nilai parameter default** - gunakan format konfigurasi berikut:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_1()),
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_2()),
...
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_n())
]
```
**Untuk menggunakan aturan bawaan dengan menyesuaikan nilai parameter** — gunakan format konfigurasi berikut:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
ProfilerRule.sagemaker(
base_config=rule_configs.BuiltInRuleName(),
rule_parameters={
"key": "value"
}
)
]
```
Untuk menemukan kunci yang tersedia untuk `rule_parameters` parameter, lihat tabel deskripsi parameter.
Contoh kode konfigurasi aturan disediakan untuk setiap aturan bawaan di bawah tabel deskripsi parameter.
+ Untuk instruksi lengkap dan contoh penggunaan aturan bawaan Debugger, lihat. [Kode contoh aturan bawaan debugger](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules)
+ Untuk instruksi lengkap tentang penggunaan aturan bawaan dengan operasi SageMaker API tingkat rendah, lihat[Konfigurasikan Debugger menggunakan API SageMaker](debugger-createtrainingjob-api.md).
## ProfilerReport
ProfilerReport Aturan tersebut memanggil semua aturan bawaan untuk pemantauan dan pembuatan profil. Ini membuat laporan profil dan pembaruan saat aturan individual dipicu. Anda dapat mengunduh laporan pembuatan profil yang komprehensif saat pekerjaan pelatihan sedang berjalan atau setelah pekerjaan pelatihan selesai. Anda dapat menyesuaikan nilai parameter aturan untuk menyesuaikan sensitivitas aturan pemantauan dan pembuatan profil bawaan. Kode contoh berikut menunjukkan format dasar untuk menyesuaikan parameter aturan bawaan melalui ProfilerReport aturan.
```
rules=[
ProfilerRule.sagemaker(
rule_configs.ProfilerReport(
_ = value
)
)
]
```
Jika Anda memicu ProfilerReport aturan ini tanpa parameter yang disesuaikan seperti yang ditunjukkan dalam kode contoh berikut, maka aturan akan memicu semua ProfilerReport aturan bawaan untuk memantau dan membuat profil dengan nilai parameter defaultnya.
```
rules=[ProfilerRule.sagemaker(rule_configs.ProfilerReport())]
```
Kode contoh berikut menunjukkan cara menentukan dan menyesuaikan `cpu_threshold` parameter CPUBottleneck aturan dan `threshold` parameter IOBottleneck aturan.
```
rules=[
ProfilerRule.sagemaker(
rule_configs.ProfilerReport(
CPUBottleneck_cpu_threshold = 90,
IOBottleneck_threshold = 90
)
)
]
```
Untuk menjelajahi apa yang ada dalam laporan profiler, lihat Laporan Profiling [SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). Selain itu, karena aturan ini mengaktifkan semua aturan pembuatan profil, Anda juga dapat memeriksa status analisis aturan menggunakan [UI SageMaker Debugger di Eksperimen Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html). SageMaker
Deskripsi Parameter untuk Aturan OverallSystemUsage
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| \$1 | Parameter yang dapat disesuaikan untuk menyesuaikan ambang batas aturan pemantauan dan pembuatan profil bawaan lainnya. **Opsional** Nilai default: `None` |
## BatchSize
BatchSize Aturan ini membantu mendeteksi jika GPU kurang dimanfaatkan karena ukuran batch yang kecil. Untuk mendeteksi masalah ini, aturan ini memantau pemanfaatan CPU rata-rata, pemanfaatan GPU, dan pemanfaatan memori GPU. Jika pemanfaatan pada CPU, GPU, dan memori GPU rata-rata rendah, ini mungkin menunjukkan bahwa pekerjaan pelatihan dapat berjalan pada jenis instance yang lebih kecil atau dapat berjalan dengan ukuran batch yang lebih besar. Analisis ini tidak berfungsi untuk kerangka kerja yang mengalokasikan memori secara berlebihan. Namun, meningkatkan ukuran batch dapat menyebabkan kemacetan pemrosesan atau pemuatan data karena lebih banyak waktu pemrosesan data diperlukan di setiap iterasi.
Deskripsi Parameter untuk Aturan BatchSize
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| cpu\$1threshold\$1p95 | Mendefinisikan ambang batas untuk kuantil ke-95 pemanfaatan CPU dalam persentase. **Opsional** Nilai yang valid: Integer Nilai default: `70` (dalam persentase) |
| gpu\$1threshold\$1p95 | Mendefinisikan ambang batas untuk kuantil 95 pemanfaatan GPU dalam persentase. **Opsional** Nilai yang valid: Integer Nilai default: `70` (dalam persentase) |
| gpu\$1memory\$1threshold\$1p95 | Mendefinisikan ambang batas untuk kuantil ke-95 pemanfaatan memori GPU dalam persentase. **Opsional** Nilai yang valid: Integer Nilai default: `70` (dalam persentase) |
| patience | Mendefinisikan jumlah titik data yang harus dilewati sampai aturan memulai evaluasi. Beberapa langkah pertama pekerjaan pelatihan biasanya menunjukkan volume proses data yang tinggi, jadi pertahankan aturan tetap sabar dan cegah agar tidak dipanggil terlalu cepat dengan sejumlah data profil tertentu yang Anda tentukan dengan parameter ini. **Opsional** Nilai yang valid: Integer Nilai default: `100` |
| window | Ukuran jendela untuk menghitung kuantil. **Opsional** Nilai yang valid: Integer Nilai default: `500` |
| scan\$1interval\$1us | Interval waktu file timeline dipindai. **Opsional** Nilai yang valid: Integer Nilai default: `60000000` (dalam mikrodetik) |
## CPUBottleneck
CPUBottleneck Aturan ini membantu mendeteksi jika GPU kurang dimanfaatkan karena kemacetan CPU. Rule mengembalikan True jika jumlah bottleneck CPU melebihi ambang batas yang telah ditentukan.
Deskripsi Parameter untuk Aturan CPUBottleneck
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| threshold | Mendefinisikan ambang batas untuk proporsi waktu yang terhambat dengan total waktu pelatihan. Jika proporsi melebihi persentase yang ditentukan ke parameter ambang batas, aturan akan mengalihkan status aturan ke Benar. **Opsional** Nilai yang valid: Integer Nilai default: `50` (dalam persentase) |
| gpu\$1threshold | Ambang batas yang mendefinisikan pemanfaatan GPU rendah. **Opsional** Nilai yang valid: Integer Nilai default: `10` (dalam persentase) |
| cpu\$1threshold | Ambang batas yang mendefinisikan pemanfaatan CPU yang tinggi. **Opsional** Nilai yang valid: Integer Nilai default: `90` (dalam persentase) |
| patience | Mendefinisikan jumlah titik data yang harus dilewati sampai aturan memulai evaluasi. Beberapa langkah pertama pekerjaan pelatihan biasanya menunjukkan volume proses data yang tinggi, jadi pertahankan aturan tetap sabar dan cegah agar tidak dipanggil terlalu cepat dengan sejumlah data profil tertentu yang Anda tentukan dengan parameter ini. **Opsional** Nilai yang valid: Integer Nilai default: `100` |
| scan\$1interval\$1us | Interval waktu dengan mana file timeline dipindai. **Opsional** Nilai yang valid: Integer Nilai default: `60000000` (dalam mikrodetik) |
## GPUMemoryMeningkat
Aturan GPUMemory Peningkatan membantu mendeteksi peningkatan besar dalam penggunaan memori pada GPUs.
Deskripsi Parameter untuk Aturan GPUMemory Peningkatan
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| increase | Mendefinisikan ambang batas untuk peningkatan memori absolut. **Opsional** Nilai yang valid: Integer Nilai default: `10` (dalam persentase) |
| patience | Mendefinisikan jumlah titik data yang harus dilewati sampai aturan memulai evaluasi. Beberapa langkah pertama pekerjaan pelatihan biasanya menunjukkan volume proses data yang tinggi, jadi pertahankan aturan tetap sabar dan cegah agar tidak dipanggil terlalu cepat dengan sejumlah data profil tertentu yang Anda tentukan dengan parameter ini. **Opsional** Nilai yang valid: Integer Nilai default: `100` |
| window | Ukuran jendela untuk menghitung kuantil. **Opsional** Nilai yang valid: Integer Nilai default: `500` |
| scan\$1interval\$1us | Interval waktu file timeline dipindai. **Opsional** Nilai yang valid: Integer Nilai default: `60000000` (dalam mikrodetik) |
## IOBottleneck
Aturan ini membantu mendeteksi apakah GPU kurang dimanfaatkan karena kemacetan data IO. Rule mengembalikan True jika jumlah bottleneck IO melebihi ambang batas yang telah ditentukan.
Deskripsi Parameter untuk Aturan IOBottleneck
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| threshold | Mendefinisikan ambang batas ketika Aturan untuk mengembalikan Benar.**Opsional**Nilai yang valid: IntegerNilai default: `50` (dalam persentase) |
| gpu\$1threshold | Ambang batas yang menentukan kapan GPU dianggap kurang dimanfaatkan. **Opsional** Nilai yang valid: Integer Nilai default: `70` (dalam persentase) |
| io\$1threshold | Ambang batas yang menentukan waktu tunggu IO yang tinggi.**Opsional**Nilai yang valid: IntegerNilai default: `50` (dalam persentase) |
| patience | Mendefinisikan jumlah titik data yang harus dilewati sampai aturan memulai evaluasi. Beberapa langkah pertama pekerjaan pelatihan biasanya menunjukkan volume proses data yang tinggi, jadi pertahankan aturan tetap sabar dan cegah agar tidak dipanggil terlalu cepat dengan sejumlah data profil tertentu yang Anda tentukan dengan parameter ini.**Opsional**Nilai yang valid: IntegerNilai default: `1000` |
| scan\$1interval\$1us | Interval waktu file timeline dipindai. **Opsional** Nilai yang valid: Integer Nilai default: `60000000` (dalam mikrodetik) |
## LoadBalancing
LoadBalancing Aturan ini membantu mendeteksi masalah dalam penyeimbangan beban kerja di antara beberapa masalah. GPUs
Deskripsi Parameter untuk Aturan LoadBalancing
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| threshold | Mendefinisikan persentase beban kerja. **Opsional** Nilai yang valid: Integer Nilai default: `0.5` (proporsi tanpa unit) |
| patience | Mendefinisikan jumlah titik data yang harus dilewati sampai aturan memulai evaluasi. Beberapa langkah pertama pekerjaan pelatihan biasanya menunjukkan volume proses data yang tinggi, jadi pertahankan aturan tetap sabar dan cegah agar tidak dipanggil terlalu cepat dengan sejumlah data profil tertentu yang Anda tentukan dengan parameter ini. **Opsional** Nilai yang valid: Integer Nilai default: `10` |
| scan\$1interval\$1us | Interval waktu file timeline dipindai. **Opsional** Nilai yang valid: Integer Nilai default: `60000000` (dalam mikrodetik) |
## Rendah GPUUtilization
GPUUtilization Aturan Rendah membantu mendeteksi apakah pemanfaatan GPU rendah atau mengalami fluktuasi. Ini diperiksa untuk setiap GPU pada setiap pekerja. Aturan mengembalikan True jika kuantil ke-95 di bawah threshold\$1p95 yang menunjukkan kurang dimanfaatkan. Aturan mengembalikan true jika kuantil ke-95 di atas threshold\$1p95 dan kuantil ke-5 di bawah threshold\$1p5 yang menunjukkan fluktuasi.
Deskripsi Parameter untuk Aturan Rendah GPUUtilization
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| threshold\$1p95 | Ambang batas untuk kuantil ke-95 di bawah mana GPU dianggap kurang dimanfaatkan. **Opsional** Nilai yang valid: Integer Nilai default: `70` (dalam persentase) |
| threshold\$1p5 | Ambang batas untuk kuantil ke-5. Default adalah 10 persen.**Opsional**Nilai yang valid: IntegerNilai default: `10` (dalam persentase) |
| patience | Mendefinisikan jumlah titik data yang harus dilewati sampai aturan memulai evaluasi. Beberapa langkah pertama pekerjaan pelatihan biasanya menunjukkan volume proses data yang tinggi, jadi pertahankan aturan tetap sabar dan cegah agar tidak dipanggil terlalu cepat dengan sejumlah data profil tertentu yang Anda tentukan dengan parameter ini. **Opsional** Nilai yang valid: Integer Nilai default: `1000` |
| window | Ukuran jendela untuk menghitung kuantil. **Opsional** Nilai yang valid: Integer Nilai default: `500` |
| scan\$1interval\$1us | Interval waktu file timeline dipindai. **Opsional** Nilai yang valid: Integer Nilai default: `60000000` (dalam mikrodetik) |
## OverallSystemUsage
OverallSystemUsage Aturan ini mengukur penggunaan sistem secara keseluruhan per node pekerja. Aturan saat ini hanya mengumpulkan nilai per node dan menghitung persentilnya.
Deskripsi Parameter untuk Aturan OverallSystemUsage
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| scan\$1interval\$1us | Interval waktu untuk memindai file timeline. **Opsional** Nilai yang valid: Integer Nilai default: `60000000` (dalam mikrodetik) |
## MaxInitializationTime
MaxInitializationTime Aturan membantu mendeteksi jika inisialisasi pelatihan memakan terlalu banyak waktu. Aturan menunggu sampai langkah pertama tersedia.
Deskripsi Parameter untuk Aturan MaxInitializationTime
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| threshold | Mendefinisikan ambang batas dalam hitungan menit untuk menunggu langkah pertama tersedia. **Opsional** Nilai yang valid: Integer Nilai default: `20` (dalam hitungan menit) |
| scan\$1interval\$1us | Interval waktu dengan mana file timeline dipindai. **Opsional** Nilai yang valid: Integer Nilai default: `60000000` (dalam mikrodetik) |
## OverallFrameworkMetrics
OverallFrameworkMetrics Aturan ini merangkum waktu yang dihabiskan untuk metrik kerangka kerja, seperti pass maju dan mundur, dan pemuatan data.
Deskripsi Parameter untuk Aturan OverallFrameworkMetrics
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| scan\$1interval\$1us | Interval waktu untuk memindai file timeline. **Opsional** Nilai yang valid: Integer Nilai default: `60000000` (dalam mikrodetik) |
## StepOutlier
StepOutlier Aturan ini membantu mendeteksi outlier dalam durasi langkah. Aturan ini kembali `True` jika ada outlier dengan durasi langkah lebih besar dari `stddev` sigma dari seluruh durasi langkah dalam rentang waktu.
Deskripsi Parameter untuk Aturan StepOutlier
| Nama Parameter | Deskripsi |
| --- | --- |
| base\$1trial | Nama pekerjaan pelatihan uji coba dasar. Parameter ini secara otomatis diatur ke pekerjaan pelatihan saat ini oleh Amazon SageMaker Debugger. **Diperlukan** Nilai valid: String |
| stddev | Mendefinisikan faktor yang digunakan untuk mengalikan standar deviasi. Misalnya, aturan dipanggil secara default ketika durasi langkah lebih besar atau lebih kecil dari 5 kali standar deviasi. **Opsional** Nilai yang valid: Integer Nilai default: `5` (dalam hitungan menit) |
| mode | Mode di mana langkah-langkah telah disimpan dan Aturan mana yang harus dijalankan. Per aturan default akan berjalan pada langkah-langkah dari fase EVAL dan TRAIN**Opsional**Nilai yang valid: IntegerNilai default: `5` (dalam hitungan menit) |
| n\$1outliers | Berapa banyak outlier yang harus diabaikan sebelum aturan mengembalikan True**Opsional**Nilai yang valid: IntegerNilai default: `10` |
| scan\$1interval\$1us | Interval waktu dengan mana file timeline dipindai. **Opsional** Nilai yang valid: Integer Nilai default: `60000000` (dalam mikrodetik) |
# Amazon SageMaker Debugger UI di Eksperimen Klasik Amazon SageMaker Studio
Gunakan dasbor Amazon SageMaker Debugger Insights di Amazon SageMaker Studio Classic Experiments untuk menganalisis performa model dan hambatan sistem saat menjalankan tugas pelatihan di instans Amazon Elastic Compute Cloud (Amazon EC2). Dapatkan wawasan tentang pekerjaan pelatihan Anda dan tingkatkan kinerja dan akurasi pelatihan model Anda dengan dasbor Debugger. Secara default, Debugger memantau metrik sistem (CPU, GPU, memori GPU, jaringan, dan data I/O) setiap 500 milidetik dan tensor keluaran dasar (kehilangan dan akurasi) setiap 500 iterasi untuk pekerjaan pelatihan. Anda juga dapat menyesuaikan nilai parameter konfigurasi Debugger lebih lanjut dan menyesuaikan interval penyimpanan melalui UI Studio Classic atau menggunakan Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable) SDK.
**penting**
Jika Anda menggunakan aplikasi Studio Classic yang sudah ada, hapus aplikasi dan mulai ulang untuk menggunakan fitur Studio Classic terbaru. Untuk petunjuk tentang cara memulai ulang dan memperbarui lingkungan Studio Classic, lihat [Memperbarui Amazon SageMaker AI Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-tasks-update.html).
**Topics**
+ [Buka dasbor Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md)
+ [Pengontrol SageMaker dasbor Amazon Debugger Insights](debugger-on-studio-insights-controllers.md)
+ [Jelajahi dasbor Amazon SageMaker Debugger Insights](debugger-on-studio-insights-walkthrough.md)
+ [Matikan instans Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md)
# Buka dasbor Amazon SageMaker Debugger Insights
Di dasbor SageMaker Debugger Insights di Studio Classic, Anda dapat melihat informasi pemanfaatan sumber daya komputasi, pemanfaatan sumber daya, dan kemacetan sistem dari pekerjaan pelatihan Anda yang berjalan di instans Amazon EC2 secara real time dan setelah pelatihan
**catatan**
Dasbor SageMaker Debugger Insights menjalankan aplikasi Studio Classic pada `ml.m5.4xlarge` instance untuk memproses dan merender visualisasi. Setiap tab SageMaker Debugger Insights menjalankan satu sesi kernel Studio Classic. Beberapa sesi kernel untuk beberapa tab SageMaker Debugger Insights berjalan pada satu instance. Saat Anda menutup tab SageMaker Debugger Insights, sesi kernel yang sesuai juga ditutup. Aplikasi Studio Classic tetap aktif dan dikenakan biaya untuk penggunaan `ml.m5.4xlarge` instans. Untuk informasi tentang harga, lihat halaman [ SageMaker Harga Amazon](https://aws.amazon.com/sagemaker/pricing/).
**penting**
Setelah selesai menggunakan dasbor SageMaker Debugger Insights, Anda harus mematikan `ml.m5.4xlarge` instance untuk menghindari biaya yang bertambah. Untuk petunjuk tentang cara mematikan instance, lihat[Matikan instans Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
**Untuk membuka dasbor SageMaker Debugger Insights**
1. Di halaman **Beranda** Studio Classic, pilih **Eksperimen** di panel navigasi kiri.
1. Cari pekerjaan pelatihan Anda di halaman **Eksperimen**. Jika tugas latihan Anda disiapkan dengan Eksperimen yang dijalankan, pekerjaan tersebut akan muncul di tab **Eksperimen**; jika Anda tidak menyiapkan Eksperimen yang dijalankan, pekerjaan tersebut akan muncul di tab Jalankan **yang tidak ditetapkan**.
1. Pilih (klik) tautan nama pekerjaan pelatihan untuk melihat detail pekerjaan.
1. Di bawah menu **OVERVIEW**, pilih **Debuggger**. Ini harus menunjukkan dua bagian berikut.
+ Di bagian **Aturan debugger**, Anda dapat menelusuri status aturan bawaan Debugger yang terkait dengan pekerjaan pelatihan.
+ Di bagian **wawasan Debugger**, Anda dapat menemukan tautan untuk membuka Wawasan SageMaker Debugger di dasbor.
1. Di bagian **SageMaker Debugger Insights**, pilih tautan nama pekerjaan pelatihan untuk membuka dasbor SageMaker Debugger Insights. Ini membuka jendela **Debug [your-training-job-name]**. Di jendela ini, Debugger memberikan ikhtisar kinerja komputasi pekerjaan pelatihan Anda di instans Amazon EC2 dan membantu Anda mengidentifikasi masalah dalam pemanfaatan sumber daya komputasi.
Anda juga dapat mengunduh laporan profil agregat dengan menambahkan [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)aturan bawaan Debugger. SageMaker Untuk selengkapnya, lihat [Mengkonfigurasi Aturan Profiler Bawaan](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html) dan [Laporan Profil yang Dihasilkan Menggunakan SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html).
# Pengontrol SageMaker dasbor Amazon Debugger Insights
Ada berbagai komponen pengontrol Debugger untuk pemantauan dan pembuatan profil. Dalam panduan ini, Anda belajar tentang komponen pengontrol Debugger.
**catatan**
Dasbor SageMaker Debugger Insights menjalankan aplikasi Studio Classic pada `ml.m5.4xlarge` instance untuk memproses dan merender visualisasi. Setiap tab SageMaker Debugger Insights menjalankan satu sesi kernel Studio Classic. Beberapa sesi kernel untuk beberapa tab SageMaker Debugger Insights berjalan pada satu instance. Saat Anda menutup tab SageMaker Debugger Insights, sesi kernel yang sesuai juga ditutup. Aplikasi Studio Classic tetap aktif dan dikenakan biaya untuk penggunaan `ml.m5.4xlarge` instans. Untuk informasi tentang harga, lihat halaman [ SageMaker Harga Amazon](https://aws.amazon.com/sagemaker/pricing/).
**penting**
Setelah selesai menggunakan dasbor SageMaker Debugger Insights, matikan `ml.m5.4xlarge` instance untuk menghindari biaya yang bertambah. Untuk petunjuk tentang cara mematikan instance, lihat[Matikan instans Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
## SageMaker UI pengontrol Wawasan Debugger
Menggunakan pengontrol Debugger yang terletak di sudut kiri atas dasbor Insights, Anda dapat menyegarkan dasbor, mengonfigurasi, atau memperbarui pengaturan Debugger untuk memantau metrik sistem, menghentikan pekerjaan pelatihan, dan mengunduh laporan pembuatan profil Debugger.
![\[SageMaker Pengontrol Dasbor Wawasan Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-studio-insights-refresh.png)
+ Jika Anda ingin menyegarkan dasbor secara manual, pilih tombol refresh (panah bundar di sudut kiri atas) seperti yang ditunjukkan pada tangkapan layar sebelumnya.
+ Tombol sakelar **Monitoring** aktif secara default untuk setiap pekerjaan SageMaker pelatihan yang dimulai menggunakan Python SageMaker SDK. Jika tidak diaktifkan, Anda dapat menggunakan tombol sakelar untuk memulai pemantauan. Selama pemantauan, Debugger hanya mengumpulkan metrik pemanfaatan sumber daya untuk mendeteksi masalah komputasi seperti kemacetan CPU dan kurangnya pemanfaatan GPU. Untuk daftar lengkap masalah pemanfaatan sumber daya yang dipantau Debugger, lihat [Aturan bawaan Debugger untuk membuat profil pemanfaatan sumber daya sistem perangkat keras (metrik sistem](debugger-built-in-profiler-rules.md#built-in-rules-monitoring)).
+ Tombol **Configure monitoring** membuka jendela pop-up yang dapat Anda gunakan untuk mengatur atau memperbarui frekuensi pengumpulan data dan jalur S3 untuk menyimpan data.
![\[Jendela pop-up untuk mengonfigurasi pengaturan pemantauan Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-studio-enable-profiling-2.png)
Anda dapat menentukan nilai untuk bidang berikut.
+ **URI bucket S3: Tentukan URI** bucket S3 dasar.
+ **Kumpulkan data pemantauan setiap**: Pilih interval waktu untuk mengumpulkan metrik sistem. Anda dapat memilih salah satu interval pemantauan dari daftar dropdown. Interval yang tersedia adalah 100 milidetik, 200 milidetik, 500 milidetik (default), 1 detik, 5 detik, dan 1 menit.
**catatan**
Jika Anda memilih salah satu interval waktu yang lebih rendah, Anda meningkatkan perincian metrik pemanfaatan sumber daya, sehingga Anda dapat menangkap lonjakan dan anomali dengan resolusi waktu yang lebih tinggi. Namun, semakin tinggi resolusinya, semakin besar ukuran metrik sistem untuk diproses. Ini mungkin memperkenalkan overhead tambahan dan berdampak pada keseluruhan waktu pelatihan dan pemrosesan.
+ Dengan menggunakan tombol **Stop training**, Anda dapat menghentikan pekerjaan pelatihan ketika Anda menemukan anomali dalam pemanfaatan sumber daya.
+ Dengan menggunakan tombol **Unduh laporan**, Anda dapat mengunduh laporan profil agregat dengan menggunakan [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)aturan bawaan Debugger. SageMaker Tombol diaktifkan saat Anda menambahkan [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)aturan bawaan ke estimator. Untuk selengkapnya, lihat [Mengkonfigurasi Aturan Profiler Bawaan](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html) dan [Laporan Profil yang Dihasilkan Menggunakan SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html).
# Jelajahi dasbor Amazon SageMaker Debugger Insights
Saat memulai pekerjaan SageMaker pelatihan, SageMaker Debugger mulai memantau pemanfaatan sumber daya instans Amazon EC2 secara default. Anda dapat melacak tingkat pemanfaatan sistem, ikhtisar statistik, dan analisis aturan bawaan melalui dasbor Wawasan. **Panduan ini memandu Anda melalui konten dasbor SageMaker Debugger Insights di bawah tab berikut: Metrik dan Aturan **Sistem**.**
**catatan**
Dasbor SageMaker Debugger Insights menjalankan aplikasi Studio Classic pada `ml.m5.4xlarge` instance untuk memproses dan merender visualisasi. Setiap tab SageMaker Debugger Insights menjalankan satu sesi kernel Studio Classic. Beberapa sesi kernel untuk beberapa tab SageMaker Debugger Insights berjalan pada satu instance. Saat Anda menutup tab SageMaker Debugger Insights, sesi kernel yang sesuai juga ditutup. Aplikasi Studio Classic tetap aktif dan dikenakan biaya untuk penggunaan `ml.m5.4xlarge` instans. Untuk informasi tentang harga, lihat halaman [ SageMaker Harga Amazon](https://aws.amazon.com/sagemaker/pricing/).
**penting**
Setelah selesai menggunakan dasbor SageMaker Debugger Insights, matikan `ml.m5.4xlarge` instance untuk menghindari biaya yang bertambah. Untuk petunjuk tentang cara mematikan instance, lihat[Matikan instans Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
**penting**
Dalam laporan, plot dan rekomendasi disediakan untuk tujuan informasi dan tidak definitif. Anda bertanggung jawab untuk membuat penilaian independen Anda sendiri atas informasi tersebut.
**Topics**
+ [Metrik sistem](#debugger-insights-system-metrics-tab)
+ [Aturan](#debugger-on-studio-insights-rules)
## Metrik sistem
Di tab **Metrik Sistem**, Anda dapat menggunakan tabel ringkasan dan plot waktu untuk memahami pemanfaatan sumber daya.
### Ringkasan pemanfaatan sumber daya
*Tabel ringkasan ini menunjukkan statistik metrik pemanfaatan sumber daya komputasi dari semua node (dilambangkan sebagai algo- n).* Metrik pemanfaatan sumber daya meliputi pemanfaatan CPU total, pemanfaatan GPU total, pemanfaatan memori CPU total, pemanfaatan memori GPU total, total waktu I/O tunggu, dan total jaringan dalam byte. Tabel menunjukkan nilai minimum dan maksimum, dan persentil p99, p90, dan p50.
![\[Tabel ringkasan pemanfaatan sumber daya\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-studio-insights-resource-util-summary.png)
### Plot deret waktu pemanfaatan sumber daya
Gunakan grafik deret waktu untuk melihat rincian lebih lanjut tentang pemanfaatan sumber daya dan mengidentifikasi pada interval waktu berapa setiap instance menunjukkan tingkat pemanfaatan yang tidak diinginkan, seperti pemanfaatan GPU yang rendah dan kemacetan CPU yang dapat menyebabkan pemborosan instance mahal.
**UI pengontrol grafik deret waktu**
Tangkapan layar berikut menunjukkan pengontrol UI untuk menyesuaikan grafik deret waktu.
![\[\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-insights-graph-controller.png)
+ **algo-1**: Gunakan menu dropdown ini untuk memilih node yang ingin Anda lihat.
+ **Zoom In**: Gunakan tombol ini untuk memperbesar grafik deret waktu dan melihat interval waktu yang lebih pendek.
+ **Perkecil**: Gunakan tombol ini untuk memperkecil grafik deret waktu dan melihat interval waktu yang lebih luas.
+ **Pan Kiri**: Pindahkan grafik deret waktu ke interval waktu sebelumnya.
+ **Pan Kanan**: Pindahkan grafik deret waktu ke interval waktu berikutnya.
+ **Perbaiki Jangka Waktu**: Gunakan kotak centang ini untuk memperbaiki atau mengembalikan grafik deret waktu untuk menampilkan seluruh tampilan dari titik data pertama ke titik data terakhir.
**Pemanfaatan CPU dan waktu I/O tunggu**
Dua grafik pertama menunjukkan pemanfaatan CPU dan I/O menunggu waktu dari waktu ke waktu. Secara default, grafik menunjukkan rata-rata tingkat pemanfaatan CPU dan waktu I/O tunggu yang dihabiskan pada inti CPU. Anda dapat memilih satu atau lebih inti CPU dengan memilih label untuk membuat grafik pada bagan tunggal dan membandingkan pemanfaatan di seluruh inti. Anda dapat menyeret dan memperbesar dan memperkecil untuk melihat lebih dekat pada interval waktu tertentu.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-insights-node-cpu.png)
**Pemanfaatan GPU dan pemanfaatan memori GPU**
Grafik berikut menunjukkan pemanfaatan GPU dan pemanfaatan memori GPU dari waktu ke waktu. Secara default, grafik menunjukkan tingkat pemanfaatan rata-rata dari waktu ke waktu. Anda dapat memilih label inti GPU untuk melihat tingkat pemanfaatan setiap inti. Mengambil rata-rata tingkat pemanfaatan atas jumlah total inti GPU menunjukkan pemanfaatan rata-rata dari seluruh sumber daya sistem perangkat keras. Dengan melihat tingkat pemanfaatan rata-rata, Anda dapat memeriksa keseluruhan penggunaan sumber daya sistem dari instans Amazon EC2. Gambar berikut menunjukkan contoh pekerjaan pelatihan pada `ml.p3.16xlarge` instance dengan 8 core GPU. Anda dapat memantau apakah pekerjaan pelatihan didistribusikan dengan baik, sepenuhnya memanfaatkan semua GPUs.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-studio-insights-node-gpu.gif)
**Pemanfaatan sistem secara keseluruhan dari waktu ke waktu**
Peta panas berikut menunjukkan contoh seluruh pemanfaatan sistem `ml.p3.16xlarge` instance dari waktu ke waktu, diproyeksikan ke plot dua dimensi. Setiap inti CPU dan GPU tercantum dalam sumbu vertikal, dan pemanfaatannya dicatat dari waktu ke waktu dengan skema warna, di mana warna-warna cerah mewakili pemanfaatan rendah dan warna yang lebih gelap mewakili pemanfaatan tinggi. Lihat bilah warna berlabel di sisi kanan plot untuk mengetahui tingkat warna mana yang sesuai dengan tingkat pemanfaatan mana.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-studio-insights-node-heatmap.png)
## Aturan
Gunakan tab **Aturan** untuk menemukan ringkasan analisis aturan pembuatan profil pada pekerjaan pelatihan Anda. Jika aturan pembuatan profil diaktifkan dengan pekerjaan pelatihan, teks akan muncul disorot dengan teks putih solid. Aturan tidak aktif diredupkan dalam teks abu-abu. Untuk mengaktifkan aturan ini, ikuti instruksi di[Menggunakan aturan profiler bawaan yang dikelola oleh Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md).
![\[Tab Aturan di dasbor SageMaker Debugger Insights\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-insights-rules.png)
# Matikan instans Amazon SageMaker Debugger Insights
Saat Anda tidak menggunakan dasbor SageMaker Debugger Insights, Anda harus mematikan instance aplikasi untuk menghindari biaya tambahan.
**Untuk mematikan instance aplikasi SageMaker Debugger Insights di Studio Classic**
![\[Tangkapan layar animasi yang menunjukkan cara mematikan instance dasbor SageMaker Debugger Insights.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-studio-insights-shut-down.png)
1. Di Studio Classic, pilih ikon **Running Instances dan Kernels** ()![\[Square icon with a white outline of a cloud on a dark blue background.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/icons/Running_squid.png).
1. Di bawah daftar **RUNNING APPS**, cari aplikasi **sagemaker-debugger-1.0**. Pilih ikon shutdown (![\[Power button icon with a circular shape and vertical line symbol.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/icons/Shutdown_light.png)) di sebelah aplikasi. Dasbor SageMaker Debugger Insights berjalan pada sebuah instance. `ml.m5.4xlarge` Instance ini juga menghilang dari **RUNNING INSTANCES** saat Anda mematikan aplikasi **sagemaker-debugger-1.0**.
# SageMaker Laporan interaktif debugger
Terima laporan pembuatan profil yang dibuat secara otomatis oleh Debugger. Laporan Debugger memberikan wawasan tentang pekerjaan pelatihan Anda dan menyarankan rekomendasi untuk meningkatkan kinerja model Anda. Tangkapan layar berikut menunjukkan kolase laporan profil Debugger. Untuk mempelajari selengkapnya, lihat [SageMaker Laporan interaktif debugger](#debugger-profiling-report).
**catatan**
Anda dapat mengunduh laporan Debugger saat pekerjaan pelatihan Anda berjalan atau setelah pekerjaan selesai. Selama pelatihan, Debugger secara bersamaan memperbarui laporan yang mencerminkan status evaluasi aturan saat ini. Anda dapat mengunduh laporan Debugger lengkap hanya setelah pekerjaan pelatihan selesai.
**penting**
Dalam laporan, plot dan dan rekomendasi disediakan untuk tujuan informasi dan tidak definitif. Anda bertanggung jawab untuk membuat penilaian independen Anda sendiri atas informasi tersebut.
![\[Contoh laporan ringkasan pekerjaan pelatihan Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profile-report.jpg)
Untuk pekerjaan SageMaker pelatihan apa pun, aturan SageMaker Debugger memanggil semua [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) aturan [pemantauan dan pembuatan profil dan menggabungkan analisis aturan](debugger-built-in-profiler-rules.md#built-in-rules-monitoring) ke dalam laporan yang komprehensif. Mengikuti panduan ini, unduh laporan menggunakan [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) atau konsol S3, dan pelajari apa yang dapat Anda tafsirkan dari hasil pembuatan profil.
**penting**
Dalam laporan tersebut, plot dan dan rekomendasi disediakan untuk tujuan informasi dan tidak definitif. Anda bertanggung jawab untuk membuat penilaian independen Anda sendiri atas informasi tersebut.
# Unduh laporan pembuatan profil SageMaker Debugger
Unduh laporan pembuatan profil SageMaker Debugger saat tugas pelatihan Anda berjalan atau setelah pekerjaan selesai menggunakan Amazon [ SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) dan (CLI). AWS Command Line Interface
**catatan**
Untuk mendapatkan laporan profiling yang dihasilkan oleh SageMaker Debugger, Anda harus menggunakan [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)aturan bawaan yang ditawarkan oleh Debugger. SageMaker Untuk mengaktifkan aturan dengan tugas latihan Anda, lihat [Mengonfigurasi Aturan Profiler Bawaan](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html).
**Tip**
Anda juga dapat mengunduh laporan dengan satu klik di dasbor wawasan SageMaker Studio Debugger. Ini tidak memerlukan skrip tambahan untuk mengunduh laporan. Untuk mengetahui cara mengunduh laporan dari Studio, lihat[Buka dasbor Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md).
------
#### [ Download using SageMaker Python SDK and AWS CLI ]
1. Periksa URI basis output S3 default pekerjaan saat ini.
```
estimator.output_path
```
1. Periksa nama pekerjaan saat ini.
```
estimator.latest_training_job.job_name
```
1. Laporan pembuatan profil Debugger disimpan di bawah. `//rule-output` Konfigurasikan jalur keluaran aturan sebagai berikut:
```
rule_output_path = estimator.output_path + estimator.latest_training_job.job_name + "/rule-output"
```
1. Untuk memeriksa apakah laporan dibuat, daftar direktori dan file secara rekursif di bawah `rule_output_path` menggunakan `aws s3 ls` dengan opsi. `--recursive`
```
! aws s3 ls {rule_output_path} --recursive
```
Ini akan mengembalikan daftar lengkap file di bawah folder yang dibuat otomatis yang dinamai sebagai`ProfilerReport-1234567890`. Nama folder adalah kombinasi string: `ProfilerReport` dan tag 10 digit unik berdasarkan stempel waktu Unix saat aturan dimulai. ProfilerReport
![\[Contoh output aturan\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-rule-output-ls-example.png)
`profiler-report.html`Ini adalah laporan profil yang dibuat secara otomatis oleh Debugger. File yang tersisa adalah komponen analisis aturan bawaan yang disimpan di JSON dan notebook Jupyter yang digunakan untuk menggabungkannya ke dalam laporan.
1. Unduh file secara rekursif menggunakan`aws s3 cp`. Perintah berikut menyimpan semua file output aturan ke `ProfilerReport-1234567890` folder di bawah direktori kerja saat ini.
```
! aws s3 cp {rule_output_path} ./ --recursive
```
**Tip**
Jika menggunakan server notebook Jupyter, jalankan `!pwd` untuk memeriksa ulang direktori kerja saat ini.
1. Di bawah `/ProfilerReport-1234567890/profiler-output` direktori, buka`profiler-report.html`. Jika menggunakan JupyterLab, pilih **Trust HTML** untuk melihat laporan pembuatan profil Debugger yang dibuat secara otomatis.
![\[Contoh output aturan\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-rule-output-open-html.png)
1. Buka `profiler-report.ipynb` file untuk menjelajahi bagaimana laporan dibuat. Anda juga dapat menyesuaikan dan memperluas laporan pembuatan profil menggunakan file notebook Jupyter.
------
#### [ Download using Amazon S3 Console ]
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Cari ember S3 dasar. Misalnya, jika Anda belum menentukan nama pekerjaan dasar apa pun, nama bucket S3 dasar harus dalam format berikut:`sagemaker--111122223333`. Cari bucket S3 dasar melalui bidang *Find bucket by name*.
![\[Contoh untuk aturan output S3 bucket URI\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-0.png)
1. Di bucket S3 dasar, cari nama pekerjaan pelatihan dengan menentukan awalan nama pekerjaan Anda ke dalam kolom Input *Find objects by prefix*. Pilih nama pekerjaan pelatihan.
![\[Contoh untuk aturan output S3 bucket URI\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-1.png)
1. ****Dalam bucket S3 pekerjaan pelatihan, harus ada tiga subfolder untuk data pelatihan yang dikumpulkan oleh Debugger: **debug-output/, profiler-output/, dan rule-output/**.**** Pilih **aturan-output/**.
![\[Contoh untuk aturan output S3 bucket URI\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-2.png)
1. **Di folder **aturan-output/, pilih ProfilerReport -1234567890****, dan pilih folder profiler-output/**.** Folder **profiler-output/** berisi **profiler-report.html** (laporan profil yang dibuat secara otomatis dalam html), **profiler-report.ipynb** (buku catatan Jupyter dengan skrip yang digunakan untuk membuat laporan), dan folder **profiler-report/** (berisi file JSON analisis aturan yang digunakan sebagai komponen laporan).
1. Pilih file **profiler-report.html**, pilih **Actions**, dan **Download**.
![\[Contoh untuk aturan output S3 bucket URI\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-3.png)
1. Buka file **profiler-report.html** yang diunduh di browser web.
------
**catatan**
Jika Anda memulai tugas latihan tanpa mengonfigurasi parameter khusus Debugger, Debugger akan menghasilkan laporan hanya berdasarkan aturan pemantauan sistem karena parameter Debugger tidak dikonfigurasi untuk menyimpan metrik kerangka kerja. Untuk mengaktifkan profil metrik kerangka kerja dan menerima laporan profil Debugger yang diperluas, konfigurasikan `profiler_config` parameter saat membuat atau memperbarui estimator AI. SageMaker
Untuk mempelajari cara mengkonfigurasi `profiler_config` parameter sebelum memulai pekerjaan pelatihan, lihat[Konfigurasi estimator untuk pembuatan profil kerangka kerja](debugger-configure-framework-profiling.md).
Untuk memperbarui tugas pelatihan saat ini dan mengaktifkan profil metrik kerangka kerja, lihat [Memperbarui Konfigurasi Profil Kerangka Debugger](debugger-update-monitoring-profiling.md).
# Panduan laporan pembuatan profil debugger
Bagian ini memandu Anda melalui bagian laporan profiling Debugger demi bagian. Laporan pembuatan profil dibuat berdasarkan aturan bawaan untuk pemantauan dan pembuatan profil. Laporan menunjukkan plot hasil hanya untuk aturan yang menemukan masalah.
**penting**
Dalam laporan tersebut, plot dan dan rekomendasi disediakan untuk tujuan informasi dan tidak definitif. Anda bertanggung jawab untuk membuat penilaian independen Anda sendiri atas informasi tersebut.
**Topics**
+ [Ringkasan pekerjaan pelatihan](#debugger-profiling-report-walkthrough-summary)
+ [Statistik penggunaan sistem](#debugger-profiling-report-walkthrough-system-usage)
+ [Ringkasan metrik kerangka kerja](#debugger-profiling-report-walkthrough-framework-metrics)
+ [Ringkasan aturan](#debugger-profiling-report-walkthrough-rules-summary)
+ [Menganalisis loop pelatihan — durasi langkah](#debugger-profiling-report-walkthrough-step-durations)
+ [Analisis pemanfaatan GPU](#debugger-profiling-report-walkthrough-gpu-utilization)
+ [Ukuran batch](#debugger-profiling-report-walkthrough-batch-size)
+ [Kemacetan CPU](#debugger-profiling-report-walkthrough-cpu-bottlenecks)
+ [Kemacetan I/O](#debugger-profiling-report-walkthrough-io-bottlenecks)
+ [Load balancing dalam pelatihan multi-GPU](#debugger-profiling-report-walkthrough-workload-balancing)
+ [Analisis memori GPU](#debugger-profiling-report-walkthrough-gpu-memory)
## Ringkasan pekerjaan pelatihan
Di awal laporan, Debugger memberikan ringkasan pekerjaan pelatihan Anda. Di bagian ini, Anda dapat meninjau durasi waktu dan stempel waktu pada fase pelatihan yang berbeda.
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-summary.gif)
Tabel ringkasan berisi informasi berikut:
+ **start\$1time — Waktu** yang tepat ketika pekerjaan pelatihan dimulai.
+ **end\$1time** — Waktu yang tepat ketika pekerjaan pelatihan selesai.
+ **job\$1duration\$1in\$1seconds — Total waktu pelatihan dari start\$1time** ****hingga end\$1time.****
+ **training\$1loop\$1start** — Waktu yang tepat ketika langkah pertama dari zaman pertama telah dimulai.
+ **training\$1loop\$1end** — Waktu yang tepat ketika langkah terakhir dari zaman terakhir telah selesai.
+ **training\$1loop\$1duration\$1in\$1seconds** — Total waktu antara waktu mulai loop pelatihan dan waktu akhir loop pelatihan.
+ **initialization\$1in\$1seconds** - Waktu yang dihabiskan untuk menginisialisasi pekerjaan pelatihan. **Fase inisialisasi mencakup periode dari **start\$1time ke waktu training\$1loop\$1start**.** Waktu inisialisasi dihabiskan untuk menyusun skrip pelatihan, memulai skrip pelatihan, membuat dan menginisialisasi model, memulai instans EC2, dan mengunduh data pelatihan.
+ **finalization\$1in\$1seconds** — Waktu yang dihabiskan untuk menyelesaikan pekerjaan pelatihan, seperti menyelesaikan pelatihan model, memperbarui artefak model, dan menutup instans EC2. **Fase finalisasi mencakup periode dari waktu **training\$1loop\$1end hingga end\$1time**.**
+ **inisialisasi (%)** **— Persentase waktu yang dihabiskan untuk **inisialisasi** atas total job\$1duration\$1in\$1seconds.**
+ **loop pelatihan (%)** — Persentase waktu yang dihabiskan untuk **loop pelatihan** di atas total **job\$1duration\$1in\$1seconds**.
+ **finalisasi (%)** **— Persentase waktu yang dihabiskan untuk **finalisasi** atas total job\$1duration\$1in\$1seconds.**
## Statistik penggunaan sistem
Di bagian ini, Anda dapat melihat ikhtisar statistik pemanfaatan sistem.
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-system-usage.png)
Laporan pembuatan profil Debugger mencakup informasi berikut:
+ **node** — Daftar nama node. Jika menggunakan pelatihan terdistribusi pada multi node (beberapa instance EC2), nama node dalam format. `algo-n`
+ **metrik** — Metrik sistem yang dikumpulkan oleh Debugger: CPU, GPU, memori CPU, memori GPU, I/O, dan metrik Jaringan.
+ **unit** — Unit metrik sistem.
+ **max** — Nilai maksimum setiap metrik sistem.
+ **p99** — Persentil ke-99 dari setiap pemanfaatan sistem.
+ **p95** — Persentil ke-95 dari setiap pemanfaatan sistem.
+ **p50** — Persentil ke-50 (median) dari setiap pemanfaatan sistem.
+ **min** — Nilai minimum setiap metrik sistem.
## Ringkasan metrik kerangka kerja
Pada bagian ini, diagram lingkaran berikut menunjukkan rincian operasi kerangka kerja pada CPUs dan GPUs.
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-metrics-summary.gif)
Setiap diagram lingkaran menganalisis metrik kerangka kerja yang dikumpulkan dalam berbagai aspek sebagai berikut:
+ **Rasio antara TRAIN/EVAL fase dan lainnya** — Menunjukkan rasio antara durasi waktu yang dihabiskan untuk fase pelatihan yang berbeda.
+ **Rasio antara pass maju dan mundur** — Menunjukkan rasio antara durasi waktu yang dihabiskan untuk pass maju dan mundur dalam loop pelatihan.
+ **Rasio antar CPU/GPU operator** - Menunjukkan rasio antara waktu yang dihabiskan pada operator yang berjalan pada CPU atau GPU, seperti operator convolutional.
+ **Metrik umum yang direkam dalam kerangka kerja** — Menunjukkan rasio antara waktu yang dihabiskan untuk metrik kerangka kerja utama, seperti pemuatan data, pass maju dan mundur.
### Ikhtisar: Operator CPU
Bagian ini memberikan informasi tentang operator CPU secara rinci. Tabel menunjukkan persentase waktu dan waktu kumulatif absolut yang dihabiskan untuk operator CPU yang paling sering disebut.
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-cpu-operators.gif)
### Ikhtisar: Operator GPU
Bagian ini memberikan informasi tentang operator GPU secara rinci. Tabel menunjukkan persentase waktu dan waktu kumulatif absolut yang dihabiskan untuk operator GPU yang paling sering disebut.
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-gpu-operators.gif)
## Ringkasan aturan
Pada bagian ini, Debugger menggabungkan semua hasil evaluasi aturan, analisis, deskripsi aturan, dan saran.
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-rules-summary.png)
## Menganalisis loop pelatihan — durasi langkah
Di bagian ini, Anda dapat menemukan statistik rinci durasi langkah pada setiap inti GPU dari setiap node. Debugger mengevaluasi nilai rata-rata, maksimum, p99, p95, p50, dan minimum durasi langkah, dan mengevaluasi pencilan langkah. Histogram berikut menunjukkan durasi langkah yang ditangkap pada node pekerja yang berbeda dan. GPUs Anda dapat mengaktifkan atau menonaktifkan histogram setiap pekerja dengan memilih legenda di sisi kanan. Anda dapat memeriksa apakah ada GPU tertentu yang menyebabkan pencilan durasi langkah.
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-step-duration.gif)
## Analisis pemanfaatan GPU
Bagian ini menunjukkan statistik rinci tentang pemanfaatan inti GPU berdasarkan aturan RendahGPUUtilization . Ini juga merangkum statistik pemanfaatan GPU, mean, p95, dan p5 untuk menentukan apakah pekerjaan pelatihan kurang dimanfaatkan. GPUs
## Ukuran batch
Bagian ini menunjukkan statistik terperinci dari total pemanfaatan CPU, pemanfaatan GPU individu, dan jejak memori GPU. BatchSize Aturan menentukan apakah Anda perlu mengubah ukuran batch untuk memanfaatkan. GPUs Anda dapat memeriksa apakah ukuran batch terlalu kecil sehingga kurang dimanfaatkan atau terlalu besar menyebabkan pemanfaatan berlebihan dan masalah memori. Dalam plot, kotak menunjukkan rentang persentil p25 dan p75 (masing-masing diisi dengan ungu tua dan kuning cerah) dari median (p50), dan bilah kesalahan menunjukkan persentil ke-5 untuk batas bawah dan persentil ke-95 untuk batas atas.
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-batch-size.png)
## Kemacetan CPU
Di bagian ini, Anda dapat menelusuri kemacetan CPU yang terdeteksi CPUBottleneck aturan dari pekerjaan pelatihan Anda. Aturan memeriksa apakah pemanfaatan CPU di atas `cpu_threshold` (90% secara default) dan juga jika pemanfaatan GPU di bawah `gpu_threshold` (10% secara default).
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-cpu-bottlenecks.png)
Diagram lingkaran menunjukkan informasi berikut:
+ **Penggunaan GPU rendah yang disebabkan oleh kemacetan CPU** - Menunjukkan rasio titik data antara titik dengan pemanfaatan GPU di atas dan di bawah ambang batas dan yang sesuai dengan kriteria bottleneck CPU.
+ **Rasio antara TRAIN/EVAL fase dan lainnya** — Menunjukkan rasio antara durasi waktu yang dihabiskan untuk fase pelatihan yang berbeda.
+ **Rasio antara pass maju dan mundur** — Menunjukkan rasio antara durasi waktu yang dihabiskan untuk pass maju dan mundur dalam loop pelatihan.
+ **Rasio antar CPU/GPU operator** - Menunjukkan rasio antara durasi waktu yang dihabiskan untuk GPUs dan CPUs oleh operator Python, seperti proses pemuat data dan operator pass maju dan mundur.
+ **Metrik umum yang direkam dalam kerangka kerja** — Menunjukkan metrik kerangka kerja utama dan rasio antara durasi waktu yang dihabiskan untuk metrik.
## Kemacetan I/O
Di bagian ini, Anda dapat menemukan ringkasan I/O kemacetan. Aturan mengevaluasi waktu I/O tunggu dan tingkat pemanfaatan GPU dan memantau jika waktu yang dihabiskan untuk I/O requests exceeds a threshold percent of the total training time. It might indicate I/O kemacetan di mana menunggu data tiba dari GPUs penyimpanan.
## Load balancing dalam pelatihan multi-GPU
Di bagian ini, Anda dapat mengidentifikasi masalah penyeimbangan beban kerja di seluruh. GPUs
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-workload-balancing.gif)
## Analisis memori GPU
Di bagian ini, Anda dapat menganalisis pemanfaatan memori GPU yang dikumpulkan oleh aturan GPUMemory Peningkatan. Dalam plot, kotak menunjukkan rentang persentil p25 dan p75 (masing-masing diisi dengan ungu tua dan kuning cerah) dari median (p50), dan bilah kesalahan menunjukkan persentil ke-5 untuk batas bawah dan persentil ke-95 untuk batas atas.
![\[Contoh laporan pembuatan profil Debugger\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/debugger/debugger-profiling-report-gpu-memory-utilization.png)
# Menyisih dari koleksi statistik penggunaan Amazon SageMaker Debugger
Untuk semua pekerjaan SageMaker pelatihan, Amazon SageMaker Debugger menjalankan [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) aturan dan membuat otomatis a. [SageMaker Laporan interaktif debugger](debugger-profiling-report.md) `ProfilerReport`Aturan menyediakan file notebook Jupyter (`profiler-report.ipynb`) yang menghasilkan file HTML yang sesuai (`profiler-report.html`).
Debugger mengumpulkan statistik penggunaan laporan profil dengan menyertakan kode di buku catatan Jupyter yang mengumpulkan ARN tugas pemrosesan aturan unik `ProfilerReport` jika pengguna membuka file akhir. `profiler-report.html`
Debugger hanya mengumpulkan informasi tentang apakah pengguna membuka laporan HTML akhir. Itu **TIDAK** mengumpulkan informasi apa pun dari pekerjaan pelatihan, data pelatihan, skrip pelatihan, pekerjaan pemrosesan, log, atau konten laporan profil itu sendiri.
Anda dapat memilih keluar dari pengumpulan statistik penggunaan menggunakan salah satu opsi berikut.
## (Disarankan) Opsi 1: Memilih keluar sebelum menjalankan pekerjaan pelatihan
Untuk memilih keluar, Anda perlu menambahkan konfigurasi `ProfilerReport` aturan Debugger berikut ke permintaan pekerjaan pelatihan Anda.
------
#### [ SageMaker Python SDK ]
```
estimator=sagemaker.estimator.Estimator(
...
rules=ProfilerRule.sagemaker(
base_config=rule_configs.ProfilerReport()
rule_parameters={"opt_out_telemetry": "True"}
)
)
```
------
#### [ AWS CLI ]
```
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport-1234567890",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "ProfilerReport",
"opt_out_telemetry": "True"
}
}
]
```
------
#### [ AWS SDK untuk Python (Boto3) ]
```
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport-1234567890',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'ProfilerReport',
'opt_out_telemetry': 'True'
}
}
]
```
------
## Opsi 2: Memilih keluar setelah pekerjaan pelatihan selesai
Untuk memilih keluar setelah pelatihan selesai, Anda perlu memodifikasi `profiler-report.ipynb` file.
**catatan**
Laporan HTML dibuat secara otomatis tanpa **Opsi 1** yang telah ditambahkan ke permintaan pekerjaan pelatihan Anda masih melaporkan statistik penggunaan bahkan setelah Anda memilih untuk tidak menggunakan **Opsi 2**.
1. Ikuti petunjuk untuk mengunduh file laporan profil Debugger di halaman. [Unduh laporan pembuatan profil SageMaker Debugger](debugger-profiling-report-download.md)
1. Di `/ProfilerReport-1234567890/profiler-output` direktori, buka`profiler-report.ipynb`.
1. Tambahkan **opt\$1out=True** ke `setup_profiler_report()` fungsi di sel kode kelima seperti yang ditunjukkan pada kode contoh berikut:
```
setup_profiler_report(processing_job_arn, opt_out=True)
```
1. Jalankan sel kode untuk menyelesaikan opting out.
# Menganalisis data menggunakan pustaka klien Python Debugger
[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
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
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
`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
Profil Python menyediakan metrik kerangka kerja yang terkait dengan fungsi dan operator Python dalam skrip pelatihan Anda dan kerangka kerja pembelajaran mendalam AI. SageMaker
**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.
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
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
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.