Accelerate documentation

Tur Cepat

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Tur Cepat

Terdapat banyak cara untuk meluncurkan dan menjalankan kode Anda tergantung pada lingkungan pelatihan (torchrun, DeepSpeed, dll.) dan perangkat keras yang tersedia. Accelerate menawarkan antarmuka terpadu untuk meluncurkan dan melatih pada berbagai konfigurasi terdistribusi, sehingga Anda dapat fokus pada kode pelatihan PyTorch Anda alih-alih kerumitan dalam menyesuaikan kode Anda untuk berbagai konfigurasi tersebut. Hal ini memungkinkan Anda untuk dengan mudah menskalakan kode PyTorch Anda untuk pelatihan dan inferensi pada konfigurasi terdistribusi dengan perangkat keras seperti GPU dan TPU. Accelerate juga menyediakan Big Model Inference untuk membuat proses pemuatan dan eksekusi inferensi dengan model yang sangat besar, yang biasanya tidak muat di memori, menjadi lebih mudah diakses.

Quicktour ini memperkenalkan tiga fitur utama Accelerate:

  • antarmuka peluncuran baris perintah terpadu untuk skrip pelatihan terdistribusi
  • perpustakaan pelatihan untuk mengadaptasi kode pelatihan PyTorch agar dapat dijalankan pada berbagai konfigurasi terdistribusi
  • Inferensi Model Besar

Antarmuka peluncuran terpadu

Accelerate secara otomatis memilih nilai konfigurasi yang sesuai untuk setiap framework pelatihan terdistribusi (DeepSpeed, FSDP, dll.) melalui file konfigurasi terpadu yang dihasilkan dari perintah accelerate config. Anda juga dapat meneruskan nilai konfigurasi secara eksplisit ke command line, yang berguna dalam situasi tertentu seperti saat Anda menggunakan SLURM.

Namun dalam kebanyakan kasus, Anda sebaiknya selalu menjalankan accelerate config terlebih dahulu untuk membantu Accelerate memahami konfigurasi pelatihan Anda.

accelerate config

Perintah accelerate config membuat dan menyimpan file default_config.yaml di folder cache Accelerate. File ini menyimpan konfigurasi untuk lingkungan pelatihan Anda, yang membantu Accelerate meluncurkan skrip pelatihan Anda dengan benar berdasarkan mesin Anda.

Setelah Anda mengonfigurasi lingkungan Anda, Anda dapat menguji pengaturan Anda dengan accelerate test, yang meluncurkan skrip singkat untuk menguji lingkungan terdistribusi.

accelerate test

Tambahkan --config_file ke perintah accelerate test atau accelerate launch untuk menentukan lokasi file konfigurasi jika file tersebut disimpan di lokasi non-default seperti cache.

Setelah lingkungan Anda disiapkan, jalankan skrip pelatihan Anda dengan accelerate launch!

accelerate launch path_to_script.py --args_for_the_script

Untuk mempelajari lebih lanjut, lihat tutorial Launch distributed code untuk informasi lebih lanjut tentang cara menjalankan skrip Anda.

Kami juga memiliki zoo konfigurasi yang menampilkan sejumlah konfigurasi contoh minimal yang sudah jadi untuk berbagai setup yang dapat Anda jalankan.

Sesuaikan kode pelatihan

Fitur utama berikutnya dari Accelerate adalah kelas Accelerator yang menyesuaikan kode PyTorch Anda untuk dijalankan pada berbagai konfigurasi distribusi.

Anda hanya perlu menambahkan beberapa baris kode ke skrip pelatihan Anda untuk mengaktifkan eksekusinya di beberapa GPU atau TPU.

+ from accelerate import Accelerator
+ accelerator = Accelerator()

+ device = accelerator.device
+ model, optimizer, training_dataloader, scheduler = accelerator.prepare(
+     model, optimizer, training_dataloader, scheduler
+ )

  for batch in training_dataloader:
      optimizer.zero_grad()
      inputs, targets = batch
-     inputs = inputs.to(device)
-     targets = targets.to(device)
      outputs = model(inputs)
      loss = loss_function(outputs, targets)
+     accelerator.backward(loss)
      optimizer.step()
      scheduler.step()
  1. Impor dan instansiasi kelas Accelerator di awal skrip pelatihan Anda. Kelas Accelerator menginisialisasi semua yang diperlukan untuk pelatihan terdistribusi, dan secara otomatis mendeteksi lingkungan pelatihan Anda (satu mesin dengan GPU, mesin dengan beberapa GPU, beberapa mesin dengan banyak GPU, atau TPU, dll.) berdasarkan cara kode diluncurkan.
from accelerate import Accelerator

accelerator = Accelerator()
  1. Hapus panggilan seperti .cuda() pada model dan data input Anda. Kelas Accelerator secara otomatis menempatkan objek-objek ini pada perangkat yang sesuai untuk Anda.

Langkah ini opsional, tetapi dianggap sebagai praktik terbaik untuk membiarkan Accelerate menangani penempatan perangkat. Anda juga dapat menonaktifkan penempatan perangkat otomatis dengan meneruskan device_placement=False saat menginisialisasi Accelerator. Jika Anda ingin secara eksplisit menempatkan objek pada perangkat dengan .to(device), pastikan Anda menggunakan accelerator.device sebagai gantinya. Misalnya, jika Anda membuat optimizer sebelum menempatkan model pada accelerator.device, pelatihan akan gagal pada TPU.

Accelerate tidak menggunakan transfer non-blocking secara default untuk penempatan perangkat otomatisnya, yang dapat menyebabkan sinkronisasi CUDA yang tidak diinginkan. Anda dapat mengaktifkan transfer non-blocking dengan meneruskan DataLoaderConfiguration dengan non_blocking=True yang diset sebagai dataloader_config saat menginisialisasi Accelerator. Seperti biasa, transfer non-blocking hanya akan berfungsi jika dataloader juga memiliki pin_memory=True yang diset. Waspadai bahwa penggunaan transfer non-blocking dari GPU ke CPU dapat menyebabkan hasil yang salah jika hal itu mengakibatkan operasi CPU dilakukan pada tensor yang belum siap.

device = accelerator.device
  1. Lewatkan semua objek PyTorch yang relevan untuk pelatihan (optimizer, model, dataloader(s), learning rate scheduler) ke metode prepare() segera setelah mereka dibuat. Metode ini membungkus model dalam kontainer yang dioptimalkan untuk setup distributed Anda, menggunakan versi Accelerate dari optimizer dan scheduler, serta membuat versi sharded dari dataloader Anda untuk distribusi di antara GPU atau TPU.
model, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
    model, optimizer, train_dataloader, lr_scheduler
)
  1. Ganti loss.backward() dengan backward() untuk menggunakan metode backward() yang benar untuk setup pelatihan Anda.
accelerator.backward(loss)

Baca panduan mekanisme internal Accelerate untuk mempelajari lebih lanjut tentang bagaimana Accelerate menyesuaikan kode Anda.

Evaluasi terdistribusi

Untuk melakukan evaluasi terdistribusi, lewati dataloader validasi Anda ke metode prepare():

validation_dataloader = accelerator.prepare(validation_dataloader)

Setiap perangkat dalam konfigurasi terdistribusi Anda hanya menerima sebagian dari data evaluasi, yang berarti Anda harus menggabungkan prediksi Anda menggunakan metode gather_for_metrics(). Metode ini mensyaratkan semua tensor memiliki ukuran yang sama di setiap proses, sehingga jika tensor Anda memiliki ukuran yang berbeda di setiap proses (misalnya saat melakukan padding dinamis ke panjang maksimum dalam batch), Anda harus menggunakan metode pad_across_processes() untuk melakukan padding pada tensor Anda ke ukuran terbesar di antara proses. Perhatikan bahwa tensor harus berupa 1D dan kita menggabungkan tensor sepanjang dimensi pertama.

for inputs, targets in validation_dataloader:
    predictions = model(inputs)
    # Gather all predictions and targets
    all_predictions, all_targets = accelerator.gather_for_metrics((predictions, targets))
    # Example of use with a *Datasets.Metric*
    metric.add_batch(all_predictions, all_targets)

Untuk kasus yang lebih kompleks (misalnya tensor 2D, tidak ingin menggabungkan tensor, dict dari tensor 3D), Anda dapat meneruskan use_gather_object=True ke gather_for_metrics. Ini akan mengembalikan daftar objek setelah pengumpulan. Perhatikan bahwa penggunaannya dengan tensor GPU tidak didukung dengan baik dan tidak efisien.

Data di akhir dataset mungkin diduplikasi agar batch dapat dibagi secara merata di antara semua worker. Metode gather_for_metrics() secara otomatis menghapus data yang diduplikasi untuk menghitung metrik yang lebih akurat.

Inferensi Model Besar

Big Model Inference dari Accelerate memiliki dua fitur utama, init_empty_weights() dan load_checkpoint_and_dispatch(), untuk memuat model besar untuk inferensi yang biasanya tidak muat di memori.

Lihat panduan Handling big models for inference untuk memahami lebih baik cara kerja Big Model Inference di balik layar.

Inisialisasi bobot kosong

Context manager init_empty_weights() menginisialisasi model berukuran berapa pun dengan membuat kerangka model dan memindahkan serta menempatkan parameter setiap kali dibuat ke perangkat meta PyTorch. Dengan cara ini, tidak semua bobot dimuat secara langsung dan hanya sebagian kecil model yang dimuat ke memori pada satu waktu.

Sebagai contoh, memuat model Mixtral-8x7B kosong membutuhkan memori jauh lebih sedikit daripada memuat model dan bobot secara penuh di CPU.

from accelerate import init_empty_weights
from transformers import AutoConfig, AutoModelForCausalLM

config = AutoConfig.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
with init_empty_weights():
    model = AutoModelForCausalLM.from_config(config)

Muat dan sebar bobot

Fungsi load_checkpoint_and_dispatch() memuat checkpoint penuh atau terbagi ke dalam model kosong, dan secara otomatis mendistribusikan bobot ke semua perangkat yang tersedia.

Parameter device_map menentukan di mana setiap lapisan model ditempatkan, dan dengan menentukan "auto", lapisan tersebut akan ditempatkan di GPU terlebih dahulu, kemudian di CPU, dan akhirnya di hard drive sebagai tensor memory-mapped jika memori masih tidak mencukupi. Gunakan parameter no_split_module_classes untuk menunjukkan modul mana yang tidak boleh dipecah di antara perangkat (biasanya modul yang memiliki koneksi residual).

from accelerate import load_checkpoint_and_dispatch

model_checkpoint = "your-local-model-folder"
model = load_checkpoint_and_dispatch(
    model, checkpoint=model_checkpoint, device_map="auto", no_split_module_classes=['Block']
)

Langkah selanjutnya

Sekarang setelah Anda diperkenalkan dengan fitur utama Accelerate, langkah selanjutnya Anda bisa mencakup:

  • Lihat tutorial untuk panduan bertahap tentang Accelerate. Ini sangat berguna jika Anda baru dalam pelatihan terdistribusi dan pustaka ini.
  • Selami panduan untuk melihat cara menggunakan Accelerate untuk kasus penggunaan tertentu.
  • Perdalam pemahaman konseptual Anda tentang cara kerja internal Accelerate dengan membaca panduan konsep.
  • Lihat kelas dan perintah di referensi API untuk melihat parameter dan opsi yang tersedia.
Update on GitHub