Membandingkan kinerja di antara konfigurasi terdistribusi

Mengevaluasi dan membandingkan kinerja dari berbagai konfigurasi bisa cukup rumit jika Anda tidak tahu apa yang harus diperhatikan. Sebagai contoh, Anda tidak dapat menjalankan skrip yang sama dengan ukuran batch yang sama di TPU, multi-GPU, dan single-GPU dengan Accelerate lalu mengharapkan hasil Anda selaras.

Tapi mengapa?

Ada tiga alasan untuk hal ini yang akan dibahas dalam tutorial ini:

1. Menetapkan benih yang tepat
2. Ukuran Batch yang Diamati
3. Laju Pembelajaran

Menetapkan Seed

Meskipun masalah ini tidak sering muncul, pastikan untuk menggunakan utils.set_seed() untuk sepenuhnya mengatur seed di semua kasus distribusi agar pelatihan dapat direproduksi:

from accelerate.utils import set_seed

set_seed(42)

Mengapa ini penting? Di balik layar, hal ini akan mengatur 5 pengaturan seed yang berbeda:

    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed) # or torch.xpu.manual_seed_all, etc
    # ^^ safe to call this function even if cuda is not available
    if is_torch_xla_available():
        xm.set_rng_state(seed)

Keadaan acak, keadaan numpy, torch, keadaan perangkat torch, dan jika TPU tersedia, keadaan cuda dari torch_xla.

Ukuran Batch yang Diamati

Saat melatih dengan Accelerate, ukuran batch yang diteruskan ke dataloader adalah ukuran batch per GPU. Artinya, ukuran batch 64 pada dua GPU sebenarnya adalah ukuran batch 128. Akibatnya, saat menguji pada satu GPU, hal ini perlu diperhitungkan, dan hal yang sama berlaku untuk TPU.

Tabel di bawah dapat digunakan sebagai referensi cepat untuk mencoba berbagai ukuran batch:

Pada contoh ini, terdapat dua GPU untuk “Multi-GPU” dan pod TPU dengan 8 worker

Laju Pembelajaran

Seperti yang disebutkan dalam beberapa sumber[1][2], learning rate harus diskalakan secara linear berdasarkan jumlah perangkat yang ada. Snippet di bawah ini menunjukkan cara melakukannya dengan Accelerate:

Karena pengguna dapat memiliki scheduler laju belajar mereka sendiri, kami menyerahkan keputusan kepada pengguna apakah mereka ingin menskalakan laju belajar mereka atau tidak.

learning_rate = 1e-3
accelerator = Accelerator()
learning_rate *= accelerator.num_processes

optimizer = AdamW(params=model.parameters(), lr=learning_rate)

Anda juga akan menemukan bahwa accelerate akan menaikkan learning rate berdasarkan jumlah proses yang dilatih. Hal ini disebabkan oleh ukuran batch yang diamati seperti yang disebutkan sebelumnya. Jadi, dalam kasus 2 GPU, learning rate akan dinaikkan dua kali lebih sering daripada satu GPU untuk mengakomodasi ukuran batch yang dua kali lebih besar (jika tidak ada perubahan pada ukuran batch di instance GPU tunggal).

Akselerasi Gradien dan Presisi Campuran

Saat menggunakan akumulasi gradien dan presisi campuran, karena cara kerja rata-rata gradien (akumulasi) dan kehilangan presisi (presisi campuran), beberapa penurunan kinerja diharapkan. Hal ini akan terlihat secara eksplisit saat membandingkan loss per batch antara berbagai setup komputasi. Namun, loss keseluruhan, metrik, dan kinerja umum di akhir pelatihan seharusnya sekitar sama.