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

Pemulihan dalam proses dan pelatihan tanpa pemeriksaan

HyperPod pelatihan checkpointless menggunakan redundansi model untuk memungkinkan pelatihan toleran kesalahan. Prinsip intinya adalah bahwa status model dan pengoptimal sepenuhnya direplikasi di beberapa grup node, dengan pembaruan bobot dan perubahan status pengoptimal direplikasi secara sinkron dalam setiap grup. Ketika kegagalan terjadi, replika yang sehat menyelesaikan langkah pengoptimalnya dan mengirimkan model/optimizer status yang diperbarui ke replika pemulihan.

Pendekatan berbasis redundansi model ini memungkinkan beberapa mekanisme penanganan kesalahan:

Konfigurasi Checkpointless

Berikut adalah cuplikan inti dari pelatihan checkpointless.

from hyperpod_checkpointless_training.inprocess.train_utils import wait_rank
    wait_rank()
      
def main():
    @HPWrapper(
        health_check=CudaHealthCheck(),
        hp_api_factory=HPAgentK8sAPIFactory(),
        abort_timeout=60.0,
        checkpoint_manager=PEFTCheckpointManager(enable_offload=True),
        abort=CheckpointlessAbortManager.get_default_checkpointless_abort(),
        finalize=CheckpointlessFinalizeCleanup(),
    )
    def run_main(cfg, caller: Optional[HPCallWrapper] = None):
        ...
        trainer = Trainer(
            strategy=CheckpointlessMegatronStrategy(...,
                num_distributed_optimizer_instances=2),
            callbacks=[..., CheckpointlessCallback(...)],
            )
        trainer.fresume = resume
        trainer._checkpoint_connector = CheckpointlessCompatibleConnector(trainer)
        trainer.wrapper = caller

Lihat contoh untuk menambahkan fitur pelatihan checkpointless ke kode.

Konsep

Bagian ini memperkenalkan konsep pelatihan tanpa pemeriksaan. Pelatihan tanpa pos pemeriksaan di Amazon SageMaker HyperPod mendukung pemulihan dalam proses. Antarmuka API ini mengikuti format yang mirip dengan format NVRx APIs.

Konsep - Blok Kode yang Dapat Dieksekusi Ulang (RCB)

Ketika kegagalan terjadi, proses yang sehat tetap hidup, tetapi sebagian dari kode harus dieksekusi ulang untuk memulihkan status pelatihan dan tumpukan python. Re-executable Code Block (RCB) adalah segmen kode tertentu yang berjalan kembali selama pemulihan kegagalan. Dalam contoh berikut, RCB mencakup seluruh skrip pelatihan (yaitu, semua yang ada di bawah main ()), yang berarti bahwa setiap pemulihan kegagalan memulai ulang skrip pelatihan sambil mempertahankan model dalam memori dan status pengoptimal.

Konsep - Kontrol kesalahan

Modul pengontrol kesalahan menerima pemberitahuan ketika kegagalan terjadi selama pelatihan tanpa pemeriksaan. Pengontrol kesalahan ini mencakup komponen-komponen berikut:

Konsep - Redundansi model

Pelatihan model besar biasanya membutuhkan ukuran paralel data yang cukup besar untuk melatih model secara efisien. Dalam paralelisme data tradisional seperti PyTorch DDP dan Horovod, model ini sepenuhnya direplikasi. Teknik paralelisme data sharded yang lebih canggih seperti DeepSpeed Zero optimizer dan FSDP juga mendukung mode sharding hybrid, yang memungkinkan sharding model/optimizer status dalam grup sharding dan sepenuhnya mereplikasi di seluruh grup replikasi. NeMo juga memiliki fitur sharding hybrid ini melalui argumen num_distributed_optimizer_instances, yang memungkinkan redundansi.

Namun, menambahkan redundansi menunjukkan bahwa model tidak akan sepenuhnya dibagi di seluruh cluster, menghasilkan penggunaan memori perangkat yang lebih tinggi. Jumlah memori redundan akan bervariasi tergantung pada teknik sharding model spesifik yang diterapkan oleh pengguna. Bobot model presisi rendah, gradien, dan memori aktivasi tidak akan terpengaruh, karena mereka dipecah melalui paralelisme model. Model master presisi tinggi weights/gradients dan status pengoptimal akan terpengaruh. Menambahkan satu replika model redundan meningkatkan penggunaan memori perangkat kira-kira setara dengan satu ukuran pos pemeriksaan DCP.

Sharding hibrida memecah kolektif di seluruh kelompok DP menjadi kolektif yang relatif lebih kecil. Sebelumnya ada reduce-scatter dan all-gathering di seluruh kelompok DP. Setelah sharding hybrid, reduce-scatter hanya berjalan di dalam setiap replika model, dan akan ada all-reduce di seluruh grup replika model. All-gathering juga berjalan di dalam setiap replika model. Akibatnya, seluruh volume komunikasi tetap tidak berubah, tetapi kolektif berjalan dengan kelompok yang lebih kecil, jadi kami mengharapkan latensi yang lebih baik.

Konsep - Jenis Kegagalan dan Mulai Ulang

Tabel berikut mencatat berbagai jenis kegagalan dan mekanisme pemulihan terkait. Pelatihan tanpa pemeriksaan pertama kali mencoba pemulihan kegagalan melalui pemulihan dalam proses, diikuti dengan restart tingkat proses. Ini kembali ke restart tingkat pekerjaan hanya jika terjadi kegagalan besar (misalnya, beberapa node gagal pada saat yang sama).

Konsep - Perlindungan kunci atom untuk langkah pengoptimal

Eksekusi model dibagi menjadi tiga fase: propagasi maju, propagasi mundur, dan langkah pengoptimal. Perilaku pemulihan bervariasi berdasarkan waktu kegagalan:

Strategi ini memastikan pembaruan pengoptimal yang telah selesai tidak pernah dibuang, membantu mengurangi waktu pemulihan kesalahan.

Diagram Alur Pelatihan Tanpa Pemeriksaan

Langkah-langkah berikut menguraikan deteksi kegagalan dan proses pemulihan tanpa pemeriksaan:

Referensi API

wait_rank

hyperpod_checkpointless_training.inprocess.train_utils.wait_rank()

Menunggu dan mengambil informasi peringkat dari HyperPod, kemudian memperbarui lingkungan proses saat ini dengan variabel pelatihan terdistribusi.

Fungsi ini memperoleh penugasan peringkat dan variabel lingkungan yang benar untuk pelatihan terdistribusi. Ini memastikan bahwa setiap proses mendapatkan konfigurasi yang sesuai untuk perannya dalam pekerjaan pelatihan terdistribusi.

Parameter

Tidak ada

Pengembalian

Tidak ada

Perilaku

Variabel Lingkungan

Fungsi membaca variabel lingkungan berikut:

Menaikkan

Contoh

from hyperpod_checkpointless_training.inprocess.train_utils import wait_rank  

# Call before initializing distributed training  
wait_rank()  

# Now environment variables are properly set for this rank  
import torch.distributed as dist  
dist.init_process_group(backend='nccl')

Catatan

HPWrapper

class hyperpod_checkpointless_training.inprocess.wrap.HPWrapper(  
    *,  
    abort=Compose(HPAbortTorchDistributed()),  
    finalize=None,  
    health_check=None,  
    hp_api_factory=None,  
    abort_timeout=None,  
    enabled=True,  
    trace_file_path=None,  
    async_raise_before_abort=True,  
    early_abort_communicator=False,  
    checkpoint_manager=None,  
    check_memory_status=True)

Pembungkus fungsi Python yang memungkinkan kemampuan restart untuk Blok Kode yang Dapat Dieksekusi Ulang (RCB) dalam pelatihan tanpa pemeriksaan. HyperPod

Pembungkus ini memberikan toleransi kesalahan dan kemampuan pemulihan otomatis dengan memantau eksekusi pelatihan dan mengoordinasikan restart di seluruh proses terdistribusi ketika kegagalan terjadi. Ini menggunakan pendekatan manajer konteks daripada dekorator untuk mempertahankan sumber daya global sepanjang siklus hidup pelatihan.

Parameter

Metode

def __call__(self, fn)

Membungkus fungsi untuk mengaktifkan kemampuan restart.

Parameter:

Pengembalian:

Contoh

from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import CheckpointManager  
from hyperpod_checkpointless_training.nemo_plugins.patches import patch_megatron_optimizer  
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_connector import CheckpointlessCompatibleConnector  
from hyperpod_checkpointless_training.inprocess.train_utils import HPAgentK8sAPIFactory  
from hyperpod_checkpointless_training.inprocess.abort import CheckpointlessFinalizeCleanup, CheckpointlessAbortManager   
      
@HPWrapper(  
    health_check=CudaHealthCheck(),  
    hp_api_factory=HPAgentK8sAPIFactory(),  
    abort_timeout=60.0,  
    checkpoint_manager=CheckpointManager(enable_offload=False),  
    abort=CheckpointlessAbortManager.get_default_checkpointless_abort(),  
    finalize=CheckpointlessFinalizeCleanup(),  
)def training_function():  
    # Your training code here  
    pass

Catatan

HPCallPembungkus

class hyperpod_checkpointless_training.inprocess.wrap.HPCallWrapper(wrapper)

Memantau dan mengelola status Restart Code Block (RCB) selama eksekusi.

Kelas ini menangani siklus hidup eksekusi RCB, termasuk deteksi kegagalan, koordinasi dengan peringkat lain untuk memulai ulang, dan operasi pembersihan. Ini mengelola sinkronisasi terdistribusi dan memastikan pemulihan yang konsisten di semua proses pelatihan.

Parameter

Atribut

Metode

def initialize_barrier()

Tunggu sinkronisasi HyperPod penghalang setelah menemukan pengecualian dari RCB.

def start_hp_fault_handling_thread()

Mulai utas penanganan kesalahan untuk memantau dan mengoordinasikan kegagalan.

def handle_fn_exception(call_ex)

Proses pengecualian dari fungsi eksekusi atau RCB.

Parameter:

def restart(term_ex)

Jalankan restart handler termasuk finalisasi, pengumpulan sampah, dan pemeriksaan kesehatan.

Parameter:

def launch(fn, *a, **kw)

Jalankan RCB dengan penanganan pengecualian yang tepat.

Parameter:

def run(fn, a, kw)

Loop eksekusi utama yang menangani restart dan sinkronisasi penghalang.

Parameter:

def shutdown()

Shutdown penanganan kesalahan dan pemantauan thread.

Catatan

CudaHealthCheck

class hyperpod_checkpointless_training.inprocess.health_check.CudaHealthCheck(timeout=datetime.timedelta(seconds=30))

Memastikan bahwa konteks CUDA untuk proses saat ini dalam keadaan sehat selama pemulihan pelatihan tanpa pemeriksaan.

Pemeriksaan kesehatan ini disinkronkan dengan GPU untuk memverifikasi bahwa konteks CUDA tidak rusak setelah kegagalan pelatihan. Ini melakukan operasi sinkronisasi GPU untuk mendeteksi masalah apa pun yang mungkin mencegah dimulainya kembali pelatihan yang berhasil. Pemeriksaan kesehatan dilakukan setelah kelompok yang didistribusikan dihancurkan dan finalisasi selesai.

Parameter

Metode

__call__(state, train_ex=None)

Jalankan pemeriksaan kesehatan CUDA untuk memverifikasi integritas konteks GPU.

Parameter:

Pengembalian:

Menaikkan:

Pelestarian Negara: Mengembalikan status asli dan pengecualian tidak berubah jika semua pemeriksaan lulus

Contoh

import datetime  
from hyperpod_checkpointless_training.inprocess.health_check import CudaHealthCheck  
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
  
# Create CUDA health check with custom timeout  
cuda_health_check = CudaHealthCheck(  
    timeout=datetime.timedelta(seconds=60)  
)  
  
# Use with HPWrapper for fault-tolerant training  
@HPWrapper(  
    health_check=cuda_health_check,  
    enabled=True  
)  
def training_function():  
    # Your training code here  
    pass

Catatan

HPAgentK8s APIFactory

class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()

Kelas pabrik untuk membuat instance HPAgent K8SAPI yang berkomunikasi dengan HyperPod infrastruktur untuk koordinasi pelatihan terdistribusi.

Pabrik ini menyediakan cara standar untuk membuat dan mengkonfigurasi objek HPAgent K8SAPI yang menangani komunikasi antara proses pelatihan dan bidang kontrol. HyperPod Ini merangkum pembuatan klien soket yang mendasari dan instance API, memastikan konfigurasi yang konsisten di berbagai bagian sistem pelatihan.

Metode

__call__()

Buat dan kembalikan instance HPAgent K8SAPI yang dikonfigurasi untuk HyperPod komunikasi.

Pengembalian:

Contoh

from hyperpod_checkpointless_training.inprocess.train_utils import HPAgentK8sAPIFactory  
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
from hyperpod_checkpointless_training.inprocess.health_check import CudaHealthCheck  
  
# Create the factory  
hp_api_factory = HPAgentK8sAPIFactory()  
  
# Use with HPWrapper for fault-tolerant training  
hp_wrapper = HPWrapper(  
    hp_api_factory=hp_api_factory,  
    health_check=CudaHealthCheck(),  
    abort_timeout=60.0,  
    enabled=True  
)  
  
@hp_wrapper  
def training_function():  
    # Your distributed training code here  
    pass

Catatan

CheckpointManager

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager.CheckpointManager(  
    enable_checksum=False,  
    enable_offload=False)

Mengelola pos pemeriksaan dalam memori dan peer-to-peer pemulihan untuk toleransi kesalahan tanpa pemeriksaan dalam pelatihan terdistribusi.

Kelas ini menyediakan fungsionalitas inti untuk pelatihan HyperPod checkpointless dengan mengelola pos pemeriksaan NeMo model dalam memori, memvalidasi kelayakan pemulihan, dan mengatur transfer pos pemeriksaan antara peringkat sehat dan gagal peer-to-peer. Ini menghilangkan kebutuhan akan disk I/O selama pemulihan, secara signifikan mengurangi waktu rata-rata untuk pemulihan (MTTR).

Parameter

Atribut

Metode

save_checkpoint(trainer)

Simpan pos pemeriksaan NeMo model dalam memori untuk potensi pemulihan tanpa pos pemeriksaan.

Parameter:

Catatan:

delete_checkpoint()

Hapus pos pemeriksaan dalam memori dan lakukan operasi pembersihan.

Catatan:

try_checkpointless_load(trainer)

Mencoba pemulihan checkpointless dengan memuat status dari peringkat rekan.

Parameter:

Pengembalian:

Catatan:

checkpointless_recovery_feasible(trainer, include_checksum_verification=True)

Tentukan apakah pemulihan checkpointless dimungkinkan untuk skenario kegagalan saat ini.

Parameter:

Pengembalian:

Kriteria Validasi:

store_rng_states()

Simpan semua status generator angka acak untuk pemulihan deterministik.

Catatan:

load_rng_states()

Kembalikan semua status RNG untuk kelanjutan pemulihan deterministik.

Catatan:

maybe_offload_checkpoint()

Bongkar pos pemeriksaan dari GPU ke memori CPU jika offload diaktifkan.

Catatan:

Contoh

from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import CheckpointManager  
# Use with HPWrapper for complete fault tolerance  
@HPWrapper(  
    checkpoint_manager=CheckpointManager(),  
    enabled=True  
)  
def training_function():  
    # Training code with automatic checkpointless recovery  
    pass

Validasi: Memverifikasi integritas pos pemeriksaan menggunakan checksum (jika diaktifkan)

Catatan

PEFTCheckpointManajer

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager.PEFTCheckpointManager(  
    *args,  
    **kwargs)

Mengelola pos pemeriksaan untuk PEFT (Parameter-Efficient Fine-Tuning) dengan penanganan basis dan adaptor terpisah untuk pemulihan checkpointless yang dioptimalkan.

Manajer pos pemeriksaan khusus ini memperluas CheckpointManager untuk mengoptimalkan alur kerja PEFT dengan memisahkan bobot model dasar dari parameter adaptor.

Parameter

Mewarisi semua parameter dari CheckpointManager:

Atribut Tambahan

Metode

maybe_save_base_model(trainer)

Simpan bobot model dasar sekali, saring parameter adaptor.

Parameter:

Catatan:

save_checkpoint(trainer)

Simpan pos pemeriksaan model adaptor NeMo PEFT di memori untuk potensi pemulihan tanpa pos pemeriksaan.

Parameter:

Catatan:

try_base_model_checkpointless_load(trainer)

Mencoba pemulihan tanpa pemeriksaan bobot model dasar PEFT dengan memuat status dari peringkat sejawat.

Parameter:

Pengembalian:

Catatan:

try_checkpointless_load(trainer)

Mencoba pemberat adaptor PEFT checkpointless recovery dengan memuat status dari peringkat rekan.

Parameter:

Pengembalian:

Catatan:

is_adapter_key(key)

Periksa apakah kunci dict status milik parameter adaptor.

Parameter:

Pengembalian:

Logika Deteksi:

maybe_offload_checkpoint()

Bongkar bobot model dasar dari GPU ke memori CPU.

Catatan:

Catatan

Contoh

from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import PEFTCheckpointManager  
# Use with HPWrapper for complete fault tolerance  
@HPWrapper(  
    checkpoint_manager=PEFTCheckpointManager(),  
    enabled=True  
)  
def training_function():  
    # Training code with automatic checkpointless recovery  
    pass

CheckpointlessAbortManager

class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessAbortManager()

Kelas pabrik untuk membuat dan mengelola komposisi komponen abort untuk toleransi kesalahan tanpa pemeriksaan.

Kelas utilitas ini menyediakan metode statis untuk membuat, menyesuaikan, dan mengelola komposisi komponen abort yang digunakan selama penanganan kesalahan dalam pelatihan HyperPod checkpointless. Ini menyederhanakan konfigurasi urutan abort yang menangani pembersihan komponen pelatihan terdistribusi, pemuat data, dan sumber daya khusus kerangka kerja selama pemulihan kegagalan.

Parameter

Tidak ada (semua metode statis)

Metode Statis

get_default_checkpointless_abort()

Dapatkan instance compose abort default yang berisi semua komponen abort standar.

Pengembalian:

Komponen Default:

create_custom_abort(abort_instances)

Buat penulisan abort khusus hanya dengan instance abort yang ditentukan.

Parameter:

Pengembalian:

Menaikkan:

override_abort(abort_compose, abort_type, new_abort)

Ganti komponen abort tertentu dalam instance Compose dengan komponen baru.

Parameter:

Pengembalian:

Menaikkan:

Contoh

from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
from hyperpod_checkpointless_training.nemo_plugins.callbacks import CheckpointlessCallback  
from hyperpod_checkpointless_training.inprocess.abort import CheckpointlessFinalizeCleanup, CheckpointlessAbortManager  
  
# The strategy automatically integrates with HPWrapper  
@HPWrapper(  
    abort=CheckpointlessAbortManager.get_default_checkpointless_abort(),  
    health_check=CudaHealthCheck(),  
    finalize=CheckpointlessFinalizeCleanup(),  
    enabled=True  
)  
def training_function():  
    trainer.fit(...)

Catatan

CheckpointlessFinalizeCleanup

class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessFinalizeCleanup()

Melakukan pembersihan menyeluruh setelah deteksi kesalahan untuk mempersiapkan pemulihan dalam proses selama pelatihan tanpa pemeriksaan.

Handler finalisasi ini menjalankan operasi pembersihan khusus kerangka kerja termasuk Megatron/TransformerEngine abort, pembersihan DDP, pemuatan ulang modul, dan pembersihan memori dengan menghancurkan referensi komponen pelatihan. Ini memastikan bahwa lingkungan pelatihan diatur ulang dengan benar untuk pemulihan dalam proses yang berhasil tanpa memerlukan penghentian proses penuh.

Parameter

Tidak ada

Atribut

Metode

__call__(*a, **kw)

Jalankan operasi pembersihan komprehensif untuk persiapan pemulihan dalam proses.

Parameter:

Operasi Pembersihan:

register_attributes(trainer)

Daftarkan instance pelatih untuk digunakan selama operasi pembersihan.

Parameter:

Integrasi dengan CheckpointlessCallback

from hyperpod_checkpointless_training.nemo_plugins.callbacks import CheckpointlessCallback  
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
  
# The strategy automatically integrates with HPWrapper  
@HPWrapper(  
    ...  
    finalize=CheckpointlessFinalizeCleanup(),   
)  
def training_function():  
    trainer.fit(...)

Catatan

CheckpointlessMegatronStrategy

class hyperpod_checkpointless_training.nemo_plugins.megatron_strategy.CheckpointlessMegatronStrategy(*args, **kwargs)

NeMo Strategi Megatron dengan kemampuan pemulihan tanpa pemeriksaan terintegrasi untuk pelatihan terdistribusi yang toleran terhadap kesalahan.

Perhatikan bahwa pelatihan tanpa pemeriksaan membutuhkan num_distributed_optimizer_instances minimal 2 sehingga akan ada replikasi pengoptimal. Strategi ini juga menangani pendaftaran atribut penting dan inisialisasi grup proses.

Parameter

Mewarisi semua parameter dari MegatronStrategy:

Atribut

Metode

setup(trainer)

Inisialisasi strategi dan daftarkan komponen toleransi kesalahan dengan pelatih.

Parameter:

Operasi Pengaturan:

setup_distributed()

Inisialisasi grup proses menggunakan awalan atau koneksi tanpa akar. TCPStore

load_model_state_dict(checkpoint, strict=True)

Muat dict status model dengan kompatibilitas pemulihan tanpa pemeriksaan.

Parameter:

get_wrapper()

Dapatkan instance HPCall Wrapper untuk koordinasi toleransi kesalahan.

Pengembalian:

is_peft()

Periksa apakah PEFT (Parameter-Efficient Fine-Tuning) diaktifkan dalam konfigurasi pelatihan dengan memeriksa callback PEFT

Pengembalian:

teardown()

Ganti PyTorch pembongkaran asli Lightning untuk mendelegasikan pembersihan untuk membatalkan penangan.

Contoh

from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
  
# The strategy automatically integrates with HPWrapper  
@HPWrapper(  
    checkpoint_manager=checkpoint_manager,  
    enabled=True  
)  
def training_function():  
    trainer = pl.Trainer(strategy=CheckpointlessMegatronStrategy())  
    trainer.fit(model, datamodule)

CheckpointlessCallback

class hyperpod_checkpointless_training.nemo_plugins.callbacks.CheckpointlessCallback(  
    enable_inprocess=False,  
    enable_checkpointless=False,  
    enable_checksum=False,  
    clean_tensor_hook=False,  
    clean_lightning_module=False)

Panggilan balik kilat yang mengintegrasikan NeMo pelatihan dengan sistem toleransi kesalahan pelatihan tanpa pemeriksaan.

Callback ini mengelola pelacakan langkah, penyimpanan pos pemeriksaan, dan koordinasi pembaruan parameter untuk kemampuan pemulihan dalam proses. Ini berfungsi sebagai titik integrasi utama antara loop pelatihan PyTorch Lightning dan mekanisme pelatihan HyperPod tanpa pemeriksaan, mengoordinasikan operasi toleransi kesalahan di seluruh siklus hidup pelatihan.

Parameter

Atribut

Metode

get_wrapper_from_trainer(trainer)

Dapatkan instance HPCall Wrapper dari pelatih untuk koordinasi toleransi kesalahan.

Parameter:

Pengembalian:

on_train_batch_start(trainer, pl_module, batch, batch_idx, *args, **kwargs)

Dipanggil di awal setiap batch pelatihan untuk mengelola pelacakan dan pemulihan langkah.

Parameter:

on_train_batch_end(trainer, pl_module, outputs, batch, batch_idx)

Lepaskan kunci pembaruan parameter di akhir setiap batch pelatihan.

Parameter:

Catatan:

get_peft_callback(trainer)

Ambil callback PEFT dari daftar callback pelatih.

Parameter:

Pengembalian:

_try_adapter_checkpointless_restore(trainer, params_to_save)

Mencoba pemulihan checkpointless untuk parameter adaptor PEFT.

Parameter:

Catatan:

Contoh

from hyperpod_checkpointless_training.nemo_plugins.callbacks import CheckpointlessCallback  
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import CheckpointManager  
import pytorch_lightning as pl  
  
# Create checkpoint manager  
checkpoint_manager = CheckpointManager(  
    enable_checksum=True,  
    enable_offload=True  
)  
  
# Create checkpointless callback with full fault tolerance  
checkpointless_callback = CheckpointlessCallback(  
    enable_inprocess=True,  
    enable_checkpointless=True,  
    enable_checksum=True,  
    clean_tensor_hook=True,  
    clean_lightning_module=True  
)  
  
# Use with PyTorch Lightning trainer  
trainer = pl.Trainer(  
    callbacks=[checkpointless_callback],  
    strategy=CheckpointlessMegatronStrategy()  
)  
  
# Training with fault tolerance  
trainer.fit(model, datamodule=data_module)

Manajemen Memori

CheckpointlessCompatibleConnector

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_connector.CheckpointlessCompatibleConnector()

PyTorch Konektor pos pemeriksaan petir yang mengintegrasikan pemulihan tanpa pemeriksaan dengan pemuatan pos pemeriksaan berbasis disk tradisional.

Konektor ini memperluas PyTorch Lightning _CheckpointConnector untuk memberikan integrasi yang mulus antara pemulihan tanpa pemeriksaan dan restorasi pos pemeriksaan standar. Ini mencoba pemulihan tanpa pemeriksaan terlebih dahulu, kemudian kembali ke pemuatan pos pemeriksaan berbasis disk jika pemulihan tanpa pemeriksaan tidak layak atau gagal.

Parameter

Mewarisi semua parameter dari _ CheckpointConnector

Metode

resume_start(checkpoint_path=None)

Cobalah untuk memuat pos pemeriksaan terlebih dahulu dengan prioritas pemulihan tanpa pemeriksaan.

Parameter:

resume_end()

Selesaikan proses pemuatan pos pemeriksaan dan lakukan operasi pasca-beban.

Catatan

CheckpointlessAutoResume

class hyperpod_checkpointless_training.nemo_plugins.resume.CheckpointlessAutoResume()

Memperluas AutoResume dengan pengaturan NeMo yang tertunda untuk mengaktifkan validasi pemulihan tanpa pemeriksaan sebelum resolusi jalur pos pemeriksaan.

Kelas ini mengimplementasikan strategi inisialisasi dua fase yang memungkinkan validasi pemulihan tanpa pemeriksaan terjadi sebelum kembali ke pemuatan pos pemeriksaan berbasis disk tradisional. Ini menunda AutoResume pengaturan secara kondisional untuk mencegah resolusi jalur pos pemeriksaan prematur, memungkinkan CheckpointManager untuk memvalidasi terlebih dahulu apakah pemulihan tanpa pemeriksaan layak dilakukan. peer-to-peer

Parameter

Mewarisi semua parameter dari AutoResume

Metode

setup(trainer, model=None, force_setup=False)

Tunda AutoResume pengaturan secara kondisional untuk mengaktifkan validasi pemulihan tanpa pemeriksaan.

Parameter:

Contoh

from hyperpod_checkpointless_training.nemo_plugins.resume import CheckpointlessAutoResume  
from hyperpod_checkpointless_training.nemo_plugins.megatron_strategy import CheckpointlessMegatronStrategy  
import pytorch_lightning as pl  
  
# Create trainer with checkpointless auto-resume  
trainer = pl.Trainer(  
    strategy=CheckpointlessMegatronStrategy(),  
    resume=CheckpointlessAutoResume()  
)

Catatan