Memantau goodput dengan library Pengukuran Goodput ML

Library Pengukuran Goodput ML (ml-goodput-measurement) adalah paket Python yang membantu Anda mengukur efisiensi workload pelatihan ML yang berjalan di VM Cloud TPU. Library ini menyediakan metrik yang mengukur goodput workload, yaitu proporsi waktu penggunaan TPU yang dihabiskan untuk membuat progres pelatihan yang produktif dan terjaga. Sebaliknya, badput adalah proporsi total waktu yang dihabiskan untuk aktivitas yang tidak produktif seperti overhead startup, penundaan I/O, dan pemulihan gangguan.

Anda dapat memvisualisasikan metrik goodput secara real-time dengan Cloud Monitoring dasbor dan TensorBoard, sehingga Anda dapat menentukan bottleneck, mengoptimalkan penggunaan resource, dan pada akhirnya mengurangi biaya pelatihan.

Untuk mengetahui informasi selengkapnya, lihat repositori GitHub Pengukuran Goodput ML.

Metrik goodput

Library Pengukuran Goodput ML menyediakan metrik berikut, yang juga dapat dilihat di Cloud Monitoring dan TensorBoard. Metrik dalam tabel ini harus diawali dengan compute.googleapis.com/workload/. Misalnya, nama metrik lengkap untuk goodput_time adalah compute.googleapis.com/workload/goodput_time.

  • goodput_time: Total waktu pelatihan produktif dalam hitungan detik. Hal ini dapat diartikan sebagai goodput kumulatif.

  • badput_time: Total waktu pelatihan yang tidak produktif dalam hitungan detik (startup, penundaan, pemulihan). Hal ini dapat diartikan sebagai badput kumulatif.

  • total_elapsed_time: Total waktu berlalu (durasi jam dinding) workload dalam hitungan detik. Waktu berlalu diukur dari waktu aplikasi dimulai hingga waktu saat ini atau waktu penyelesaian tugas.

  • interval_goodput: Tingkat goodput selama periode waktu tertentu (misalnya, 24 jam terakhir). Metrik ini menyediakan jendela bergulir untuk goodput.

  • interval_badput: Tingkat badput selama periode waktu tertentu. Metrik ini menyediakan jendela bergulir untuk badput, dan berguna untuk mengidentifikasi masalah sementara seperti lonjakan dalam operasi I/O.

  • disruptions: Jumlah kumulatif gangguan tugas. Gangguan adalah peristiwa yang menyebabkan proses pelatihan berhenti secara tidak terduga, sehingga memerlukan restart. Misalnya, kegagalan hardware dan peristiwa pemeliharaan.

  • step_time_deviation: Jumlah waktu yang tidak produktif karena variasi dalam waktu langkah pelatihan. Hal ini juga dikenal sebagai "jitter". Metrik ini mengukur stabilitas yang sensitif terhadap lonjakan, yaitu penyimpangan langkah "kasus terburuk" terbaru terhadap dasar pengukuran historis dalam hitungan detik. Langkah adalah satu iterasi dari loop pelatihan.

  • performance: Perkiraan waktu langkah stabil tercepat (dasar pengukuran) dalam hitungan detik. Waktu langkah ideal adalah waktu tercepat yang dapat dilakukan satu langkah pelatihan dalam kondisi optimal, tanpa gangguan sementara atau jitter.

  • max_productive_steps: Jumlah langkah tertinggi yang berhasil dipertahankan.

Penginstalan

Gunakan langkah-langkah berikut untuk menyiapkan library Pengukuran Goodput ML dengan workload TPU Anda:

  1. Aktifkan Cloud Logging API dan Cloud Monitoring API.
  2. Jika men-deploy di Google Kubernetes Engine (GKE), konfigurasi semua node pool dengan cakupan akses cloud-platform.

Instal paket ml-goodput-measurement di host pelatihan dan mesin analisis Anda:

pip install ml-goodput-measurement

Memantau dengan library Goodput

Untuk menggunakan library Pengukuran Goodput ML, lakukan inisialisasi instance GoodputRecorder, instrumentasikan kode pelatihan Anda dengan menggabungkan bagian utama dengan pengelola konteks record_event, dan pantau metrik secara real-time dengan GoodputMonitor. Monitor menjalankan proses latar belakang untuk menghitung metrik goodput secara berkala dari peristiwa yang direkam, dan menguploadnya ke Cloud Monitoring dan TensorBoard untuk analisis dan visualisasi real-time.

Menginisialisasi perekam Goodput

Lakukan inisialisasi GoodputRecorder, yang merupakan komponen inti dari library Pengukuran Goodput ML.

import datetime
import jax
from ml_goodput_measurement import measurement

# Define a unique logger name for this specific run
logger_name = f'goodput_{config.run_name}'

# Instantiate the recorder
goodput_recorder = measurement.GoodputRecorder(
    job_name=config.run_name,
    logger_name=logger_name,
    logging_enabled=(jax.process_index() == 0)
)

Merekam peristiwa

Gunakan pengelola konteks record_event untuk menggabungkan kode pelatihan Anda.

def train_loop(config):

  # 1. Wrap the entire Job (Start/End)
  with goodput_recorder.record_event(measurement.Event.JOB):

    # 2. Record Hardware Initialization
    with goodput_recorder.record_event(measurement.Event.ACCELERATOR_INIT):
      # ... perform device mesh setup ...
      initialize_tpu(config)

    # 3. Record Training Prep
    with goodput_recorder.record_event(measurement.Event.TRAINING_PREP):
      # ... create checkpoint managers, setup model ...
      model = training_prep(config)

    # 4. Main Training Loop
    for step in range(config.steps):

      # Record Data Loading
      with goodput_recorder.record_event(measurement.Event.DATA_LOADING):
        batch = get_next_batch()

      # Record Step Start (CRITICAL: Pass the step number!)
      with goodput_recorder.record_event(measurement.Event.STEP, step):
        output = train_step(model, batch)

      # 5. Record Custom Events (e.g., Evaluation)
      if step % eval_interval == 0:
        with goodput_recorder.record_event(measurement.Event.CUSTOM, "eval_step"):
          run_evaluation()

Untuk contoh cara mengintegrasikan kode pelatihan dengan library Goodput menggunakan MaxText, lihat goodput.py.

Memantau peristiwa

Pantau metrik dengan GoodputMonitor, yang memulai proses latar belakang untuk menghitung dan mengupload metrik saat tugas berjalan. Gabungkan logika dalam pengelola konteks untuk memastikan proses uploader dimulai dan berhenti sesuai keinginan.

Tentukan pengelola konteks helper untuk menangani konfigurasi dan pengelolaan siklus proses.

import contextlib
from ml_goodput_measurement import monitoring

@contextlib.contextmanager
def maybe_monitor_goodput(config):
  """Monitor goodput if enabled and on the main process."""
  if not config.monitor_goodput or jax.process_index() != 0:
    yield
    return

  goodput_monitor = None
  try:
    # Configure GCPOptions for Cloud Monitoring
    gcp_options = monitoring.GCPOptions(
      enable_gcp_goodput_metrics=config.enable_gcp_goodput_metrics
    )

    # Instantiate the monitor
    goodput_monitor = monitoring.GoodputMonitor(
      job_name=config.run_name,
      logger_name=f"goodput_{config.run_name}",
      tensorboard_dir=config.tensorboard_dir,
      upload_interval=config.goodput_upload_interval_seconds,
      monitoring_enabled=True,
      pathway_enabled=config.enable_pathways_goodput,
      include_badput_breakdown=True,
      gcp_options=gcp_options,
    )

    # Start the background upload process
    goodput_monitor.start_goodput_uploader()
    print("Started Goodput upload to Tensorboard & GCM in the background!")
    yield

  finally:
    # Ensure clean shutdown of the background process
    if goodput_monitor:
      goodput_monitor.stop_goodput_uploader()
      print("Flushed final metrics and safe exited from Goodput monitoring.")

Untuk mengukur performa jendela bergulir, konfigurasi monitor untuk menggunakan start_rolling_window_goodput_uploader dan stop_rolling_window_goodput_uploader.

try:
    self._rolling_window_monitor.start_rolling_window_goodput_uploader(
        self.config.rolling_window_size
    )
finally:
    if self._rolling_window_monitor:
        self._rolling_window_monitor.stop_rolling_window_goodput_uploader()

Gabungkan titik entri pelatihan utama Anda dengan pengelola konteks. Hal ini memastikan pemantauan dimulai sebelum pelatihan dimulai, dan metrik akhir dihapus saat pelatihan berakhir.

def main():
  # ... Load configuration ...

  # Wrap the entire execution
  with maybe_monitor_goodput(config):
    # Run the training loop (which contains the GoodputRecorder events)
    train_loop(config)

Pasca-pemrosesan dan analisis

Anda dapat menghitung metrik goodput untuk tugas yang telah selesai dari mesin mana pun, seperti VM CPU standar atau laptop Anda. Anda tidak perlu menggunakan TPU untuk pasca-pemrosesan dan analisis.

Kode berikut menampilkan total goodput tugas:

from ml_goodput_measurement import goodput

calculator = goodput.GoodputCalculator(
    job_name="my-run-name",
    logger_name="goodput_my-run-name"
)

goodput, badput, last_step = calculator.get_job_goodput(
    include_badput_breakdown=True
)

print(f"Goodput: {goodput}%")
print(f"Badput (Infra Recovery): {badput[goodput.BadputType.INFRASTRUCTURE_RECOVERY_FROM_DISRUPTION]}%")

Untuk mengetahui informasi tentang jenis badput (BadputType), lihat Perincian badput detail.

Untuk menentukan jangka waktu tertentu, gunakan get_job_goodput_interval:

goodput_pct, badput, _, _, _ = calculator.get_job_goodput_interval(
    start_time_utc,
    end_time_utc
)

Waktu mulai (start_time_utc) dan waktu berakhir (end_time_utc) adalah objek datetime. Untuk mengetahui informasi selengkapnya, lihat goodput.py.

Memantau dengan dasbor Goodput

Untuk membantu Anda memantau dan memvisualisasikan workload pelatihan Machine Learning, Google Cloud menawarkan dua kumpulan dasbor Goodput: dasbor Goodput JobSet GKE dan dasbor Goodput Cloud ML. Gunakan dasbor JobSet GKE untuk mendiagnosis masalah infrastruktur atau penjadwalan, dan dasbor Goodput Cloud ML untuk menentukan bottleneck dalam kode pelatihan.

Google Cloud Dasbor Goodput ML

Dasbor Goodput ML mengukur efisiensi tingkat aplikasi dari skrip pelatihan Anda. Dasbor ini memberikan insight tentang waktu yang dihabiskan untuk pelatihan produktif, dan sumber badput seperti pemuatan data, inisialisasi, atau pemulihan dari gangguan.

Untuk melihat dasbor Goodput ML di Cloud Monitoring:

  1. Di Google Cloud konsol, buka halaman Cloud Monitoring.
    Buka konsol Monitoring
  2. Di panel navigasi, klik Dasbor.
  3. Di kolom Filter penelusuran, masukkan "Dasbor Goodput Cloud ML".

Dasbor Goodput ML mencakup metrik berikut (diawali dengan workload/):

  • goodput_time: Waktu kumulatif yang dihabiskan untuk langkah pelatihan produktif.
  • badput_time: Waktu kumulatif yang dihabiskan untuk aktivitas yang tidak produktif, beserta sumber badput:
    • ACCELERATOR_INITIALIZATION: Waktu untuk menyiapkan TPU.
    • TRAINING_PREP: Pemuatan checkpoint, pembuatan model dan pengoptimal.
    • PROGRAM_STARTUP: Kompilasi JIT, pelacakan grafik.
    • DATA_LOADING_SYNC: Waktu yang dihabiskan untuk memblokir input data.
    • CHECKPOINT_SAVE: Waktu untuk menyimpan status model.
    • CHECKPOINT_RESTORE: Waktu untuk memulihkan status model.
    • WASTED_PROGRESS: Waktu produktif yang hilang karena gangguan yang terjadi sebelum checkpoint.
    • INFRASTRUCTURE_RECOVERY: Waktu nonaktif selama tugas dimulai ulang.
    • CUSTOM_BADPUT_EVENTS: Peristiwa sinkron yang ditentukan pengguna seperti evaluasi.
  • step_time_deviation: Mengukur jitter dan ketidakstabilan dalam waktu langkah pelatihan.
  • interval_goodput: Goodput yang dihitung selama jendela bergulir (misalnya, jam terakhir).

Dasbor JobSet GKE

Dasbor Goodput JobSet GKE berfokus pada efisiensi lapisan orkestrasi, dan membantu Anda memahami apakah GKE menjadwalkan pod dengan cepat dan membuatnya tetap berjalan.

Untuk melihat informasi lengkap tentang kondisi dan performa JobSet, buka dasbor Pemantauan JobSet di Google Cloud konsol:

Buka dasbor pemantauan JobSet

Dasbor pemantauan JobSet mencakup metrik berikut:

  • kubernetes.io/jobset/scheduling_goodput: Bagian waktu saat semua resource (pod) yang diperlukan untuk JobSet berada dalam status siap dan tersedia untuk melakukan pekerjaan, relatif terhadap waktu pembuatan JobSet. Nilai rendah menunjukkan penundaan dalam penjadwalan pod, pengambilan image, atau alokasi resource dalam GKE.

  • kubernetes.io/jobset/proxy_runtime_goodput: Perkiraan bagian waktu saat TPU aktif digunakan, berdasarkan sinyal tingkat sistem seperti siklus tugas akselerator. Hal ini memberikan tampilan tingkat tinggi tentang produktivitas runtime tanpa instrumentasi aplikasi.

  • Metrik node pool: Informasi tentang kondisi, ketersediaan, dan gangguan yang memengaruhi node pool yang menghosting JobSet. Hal ini membantu mengorelasikan penurunan goodput dengan masalah node yang mendasarinya.

Untuk mengetahui informasi selengkapnya tentang dasbor JobSet GKE, lihat Memantau goodput JobSet.

Panduan pemecahan masalah

Bagian ini memberikan informasi pemecahan masalah untuk membantu Anda mengidentifikasi dan menyelesaikan masalah umum yang mungkin Anda alami saat menggunakan library Pengukuran Goodput ML.

Metrik Cloud Monitoring tidak ada

Jika Anda tidak menemukan metrik Cloud Monitoring:

  • Verifikasi izin IAM: Akun layanan yang dilampirkan ke workload Anda harus memiliki izin monitoring.timeSeries.create dan monitoring.metricDescriptors.create.
  • Periksa konfigurasi: Metrik goodput harus diaktifkan secara eksplisit dalam konfigurasi Anda. Misalnya, pastikan enable_gcp_goodput_metrics=True diteruskan dalam GCPOptions Anda.

Metrik umum tidak ada

Jika Anda tidak menemukan metrik umum:

  • Verifikasi status monitor: Pemantauan harus diaktifkan untuk pembuatan instance monitor Anda. Teruskan monitoring_enabled=True ke monitor.

Metrik rusak

Jika metrik Anda rusak atau menampilkan nilai yang aneh:

  • Pastikan nama operasi unik: Semua nilai run_name harus unik untuk setiap eksperimen. Menggunakan kembali nama operasi akan mencampur log dari operasi lama dan baru.

Log tidak ada

Jika Anda tidak menemukan log dari Cloud Logging:

  • Aktifkan Cloud Logging API: Cloud Logging API harus diaktifkan di Google Cloud project Anda.
  • Periksa setelan perekam: Flag logging_enabled=True harus diteruskan ke Perekam Goodput.
  • Verifikasi proses utama: Proses utama (tempat jax.process_index() == 0) harus aktif melaporkan log aplikasi.

Checkpoint badput tidak ada

Jika Anda tidak menemukan checkpoint badput:

  • Verifikasi library checkpointing Anda: Library Goodput secara otomatis melacak waktu checkpointing untuk Orbax. Namun, jika Anda menggunakan library lain (seperti checkpointing PyTorch), Anda harus menggabungkan panggilan penyimpanan dan pemulihan secara manual menggunakan record_custom_badput_event_start_time dan record_custom_badput_event_end_time.