Accelerate documentation

Menggunakan beberapa model dengan DeepSpeed

Accelerate

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.15.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Menggunakan beberapa model dengan DeepSpeed

Panduan ini mengasumsikan bahwa Anda telah membaca dan memahami panduan penggunaan DeepSpeed.

Menjalankan beberapa model dengan Accelerate dan DeepSpeed berguna untuk:

Distilasi pengetahuan
Teknik pasca-pelatihan seperti RLHF (lihat pustaka TRL untuk lebih banyak contoh)
Melatih beberapa model sekaligus

Saat ini, Accelerate memiliki API yang sangat eksperimental untuk membantu Anda menggunakan beberapa model.

Tutorial ini akan berfokus pada dua kasus penggunaan umum:

Knowledge distillation, di mana model student yang lebih kecil dilatih untuk meniru model teacher yang lebih besar dan berkinerja lebih baik. Jika model student muat di satu GPU, kita dapat menggunakan ZeRO-2 untuk pelatihan dan ZeRO-3 untuk mem-shard model teacher saat inferensi. Ini jauh lebih cepat daripada menggunakan ZeRO-3 untuk kedua model.
Melatih beberapa model terpisah sekaligus.

Distilasi pengetahuan

Knowledge distillation adalah contoh yang baik dari penggunaan beberapa model, tetapi hanya melatih salah satunya.

Biasanya, Anda akan menggunakan satu utils.DeepSpeedPlugin untuk kedua model. Namun, dalam kasus ini, terdapat dua konfigurasi terpisah. Accelerate memungkinkan Anda membuat dan menggunakan beberapa plugin jika dan hanya jika mereka berada dalam dict sehingga Anda dapat merujuk dan mengaktifkan plugin yang tepat saat diperlukan.

from accelerate.utils import DeepSpeedPlugin

zero2_plugin = DeepSpeedPlugin(hf_ds_config="zero2_config.json")
zero3_plugin = DeepSpeedPlugin(hf_ds_config="zero3_config.json")

deepspeed_plugins = {"student": zero2_plugin, "teacher": zero3_plugin}

zero2_config.json harus dikonfigurasi untuk pelatihan penuh (jadi tentukan scheduler dan optimizer jika Anda tidak menggunakan milik Anda sendiri), sedangkan zero3_config.json hanya perlu dikonfigurasi untuk model inferensi, seperti yang ditunjukkan pada contoh di bawah.

{
    "bf16": {
        "enabled": "auto"
    },
    "zero_optimization": {
        "stage": 3,
        "overlap_comm": true,
        "reduce_bucket_size": "auto",
        "stage3_prefetch_bucket_size": "auto",
        "stage3_param_persistence_threshold": "auto",
        "stage3_max_live_parameters": "auto",
        "stage3_max_reuse_distance": "auto",
    },
    "train_micro_batch_size_per_gpu": 1
}

Contoh konfigurasi zero2_config.json ditunjukkan di bawah ini.

{
    "bf16": {
        "enabled": "auto"
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": "auto",
            "weight_decay": "auto",
            "torch_adam": true,
            "adam_w_mode": true
        }
    },
    "scheduler": {
        "type": "WarmupLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto"
        }
    },
    "zero_optimization": {
        "stage": 2,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
    },
    "gradient_accumulation_steps": 1,
    "gradient_clipping": "auto",
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
}

DeepSpeed akan menampilkan error jika train_micro_batch_size_per_gpu tidak ditentukan, bahkan jika model tertentu ini tidak dilatih.

Dari sini, buat satu Accelerator dan masukkan kedua konfigurasi tersebut.

from accelerate import Accelerator

accelerator = Accelerator(deepspeed_plugins=deepspeed_plugins)

Sekarang mari kita lihat cara menggunakannya.

Model siswa

Secara default, Accelerate menetapkan item pertama dalam dict sebagai plugin default atau yang diaktifkan (plugin "student"). Verifikasi ini dengan menggunakan fungsi utils.deepspeed.get_active_deepspeed_plugin() untuk melihat plugin mana yang diaktifkan.

active_plugin = get_active_deepspeed_plugin(accelerator.state)
assert active_plugin is deepspeed_plugins["student"]

AcceleratorState juga menyimpan plugin DeepSpeed yang aktif di state.deepspeed_plugin.

assert active_plugin is accelerator.deepspeed_plugin

Karena student adalah plugin yang aktif saat ini, mari kita lanjutkan dengan menyiapkan model, optimizer, dan scheduler.

student_model, optimizer, scheduler = ...
student_model, optimizer, scheduler, train_dataloader = accelerator.prepare(student_model, optimizer, scheduler, train_dataloader)

Sekarang saatnya menangani model guru.

Model pengajar

Pertama, Anda perlu menentukan di Accelerator bahwa konfigurasi zero3_config.json harus digunakan.

accelerator.state.select_deepspeed_plugin("teacher")

Ini menonaktifkan plugin "student" dan mengaktifkan plugin "teacher" sebagai gantinya. Konfigurasi stateful DeepSpeed di dalam Transformers diperbarui, dan ini mengubah konfigurasi plugin mana yang dipanggil saat menggunakan deepspeed.initialize(). Hal ini memungkinkan Anda menggunakan integrasi context manager deepspeed.zero.Init otomatis yang disediakan oleh Transformers.

teacher_model = AutoModel.from_pretrained(...)
teacher_model = accelerator.prepare(teacher_model)

Jika tidak, Anda harus menginisialisasi model secara manual dengan deepspeed.zero.Init.

with deepspeed.zero.Init(accelerator.deepspeed_plugin.config):
    model = MyModel(...)

Pelatihan

Dari sini, loop pelatihan Anda bisa berupa apa pun yang Anda inginkan, selama teacher_model tidak pernah dilatih.

teacher_model.eval()
student_model.train()
for batch in train_dataloader:
    with torch.no_grad():
        output_teacher = teacher_model(**batch)
    output_student = student_model(**batch)
    # Combine the losses or modify it in some way
    loss = output_teacher.loss + output_student.loss
    accelerator.backward(loss)
    optimizer.step()
    scheduler.step()
    optimizer.zero_grad()

Melatih beberapa model yang tidak saling terkait

Pelatihan beberapa model adalah skenario yang lebih rumit. Dalam kondisi saat ini, kami mengasumsikan setiap model sepenuhnya terpisah dari model lainnya selama pelatihan.

Skenario ini masih membutuhkan dua utils.DeepSpeedPlugin untuk dibuat. Namun, Anda juga memerlukan Accelerator kedua, karena mesin deepspeed yang berbeda dipanggil pada waktu yang berbeda. Satu Accelerator hanya dapat membawa satu instance pada satu waktu.

Meskipun state.AcceleratorState adalah objek stateful, ia sudah mengetahui kedua utils.DeepSpeedPlugin yang tersedia. Anda cukup membuat instans kedua Accelerator tanpa argumen tambahan.

first_accelerator = Accelerator(deepspeed_plugins=deepspeed_plugins)
second_accelerator = Accelerator()

Anda dapat memanggil first_accelerator.state.select_deepspeed_plugin() untuk mengaktifkan atau menonaktifkan plugin tertentu, lalu memanggil prepare.

# can be `accelerator_0`, `accelerator_1`, or by calling `AcceleratorState().select_deepspeed_plugin(...)`
first_accelerator.state.select_deepspeed_plugin("first_model")
first_model = AutoModel.from_pretrained(...)
# For this example, `get_training_items` is a nonexistent function that gets the setup we need for training
first_optimizer, first_scheduler, train_dl, eval_dl = get_training_items(model1)
first_model, first_optimizer, first_scheduler, train_dl, eval_dl = accelerator.prepare(
    first_model, first_optimizer, first_scheduler, train_dl, eval_dl
)

second_accelerator.state.select_deepspeed_plugin("second_model")
second_model = AutoModel.from_pretrained(...)
# For this example, `get_training_items` is a nonexistent function that gets the setup we need for training
second_optimizer, second_scheduler, _, _ = get_training_items(model2)
second_model, second_optimizer, second_scheduler = accelerator.prepare(
    second_model, second_optimizer, second_scheduler
)

Dan sekarang Anda dapat melatih:

for batch in dl:
    outputs1 = first_model(**batch)
    first_accelerator.backward(outputs1.loss)
    first_optimizer.step()
    first_scheduler.step()
    first_optimizer.zero_grad()
    
    outputs2 = model2(**batch)
    second_accelerator.backward(outputs2.loss)
    second_optimizer.step()
    second_scheduler.step()
    second_optimizer.zero_grad()

Sumber daya

Untuk melihat lebih banyak contoh, silakan periksa tes terkait yang saat ini ada di [Accelerate].

Update on GitHub

←DeepSpeed Hook Komunikasi DDP→