Tips dan Jebakan Konfigurasi Perpustakaan Paralelisme Model SageMaker Terdistribusi

Pustaka paling efisien ketika ukuran batch ditingkatkan. Untuk kasus penggunaan di mana model cocok dalam satu perangkat, tetapi hanya dapat dilatih dengan ukuran batch kecil, ukuran batch dapat dan harus ditingkatkan setelah perpustakaan terintegrasi. Paralelisme model menghemat memori untuk model besar, memungkinkan Anda berlatih menggunakan ukuran batch yang sebelumnya tidak sesuai dengan memori.

Memilih sejumlah microbatch yang terlalu kecil atau terlalu besar dapat menurunkan kinerja. Pustaka mengeksekusi setiap microbatch secara berurutan di setiap perangkat, sehingga ukuran microbatch (ukuran batch dibagi dengan jumlah microbatch) harus cukup besar untuk sepenuhnya memanfaatkan setiap GPU. Pada saat yang sama, efisiensi pipa meningkat dengan jumlah microbatch, jadi penting untuk mencapai keseimbangan yang tepat. Biasanya, titik awal yang baik adalah mencoba 2 atau 4 microbatch, meningkatkan ukuran batch ke batas memori, dan kemudian bereksperimen dengan ukuran batch yang lebih besar dan jumlah microbatch. Karena jumlah microbatch meningkat, ukuran batch yang lebih besar mungkin menjadi layak jika pipa interleaved digunakan.

Ukuran batch Anda harus selalu habis dibagi dengan jumlah microbatch. Perhatikan bahwa tergantung pada ukuran kumpulan data, terkadang batch terakhir dari setiap epoch dapat berukuran lebih kecil daripada yang lain, dan batch yang lebih kecil ini perlu dibagi dengan jumlah microbatch juga. Jika tidak, Anda dapat mengatur drop_remainder=True tf.Dataset.batch() panggilan (in TensorFlow), atau mengatur DataLoader (drop_last=Truein PyTorch), sehingga batch kecil terakhir ini tidak digunakan. Jika Anda menggunakan API yang berbeda untuk pipeline data, Anda mungkin perlu melewati batch terakhir secara manual setiap kali tidak habis dibagi dengan jumlah microbatch.

Jika Anda menggunakan partisi manual, perhatikan parameter yang digunakan oleh beberapa operasi dan modul dalam model Anda, seperti tabel penyematan dalam arsitektur transformator. Modul yang berbagi parameter yang sama harus ditempatkan di perangkat yang sama untuk kebenaran. Saat partisi otomatis digunakan, pustaka secara otomatis memberlakukan batasan ini.

Jika model mengambil beberapa input, pastikan Anda menyemai operasi acak dalam pipeline data Anda (misalnya, pengocokan) dengan. smp.dp_rank() Jika kumpulan data sedang dipecah secara deterministik di seluruh perangkat paralel data, pastikan pecahan diindeks oleh. smp.dp_rank() Ini untuk memastikan bahwa urutan data yang terlihat pada semua peringkat yang membentuk partisi model konsisten.

Setiap tensor yang dikembalikan dari fungsi smp.DistributedModel.call (for TensorFlow) atau smp.DistributedModel.forward (for PyTorch) disiarkan ke semua peringkat lain, dari peringkat yang menghitung tensor tertentu. Akibatnya, tensor apa pun yang tidak diperlukan di luar metode panggilan dan penerusan (aktivasi menengah, misalnya) tidak boleh dikembalikan, karena ini menyebabkan komunikasi yang tidak perlu dan overhead memori dan merusak kinerja.

Jika fungsi smp.step -decorated memiliki argumen tensor yang tidak memiliki dimensi batch, nama argumen harus disediakan dalam non_split_inputs daftar saat memanggil. smp.step Ini mencegah perpustakaan mencoba membagi tensor menjadi microbatch. Untuk informasi selengkapnya lihat smp.stepdi dokumentasi API.

Jika Anda menggunakan benih untuk hasil deterministik, atur benih berdasarkan smp.dp_rank() (misalnya,torch.manual_seed(42 + smp.dp_rank())). Jika Anda tidak melakukan ini, partisi yang berbeda dari an nn.Parameter diinisialisasi dengan cara yang sama, memengaruhi konvergensi.

SageMakerperpustakaan paralelisme model menggunakan NCCL untuk mengimplementasikan kolektif yang diperlukan untuk distribusi modul. Khusus untuk model yang lebih kecil, jika terlalu banyak panggilan NCCL dijadwalkan pada GPU pada saat yang sama, penggunaan memori mungkin meningkat karena ruang tambahan yang digunakan oleh NCCL. Untuk mengatasi hal ini, smp membatasi panggilan NCCL sehingga jumlah operasi NCCL yang sedang berlangsung pada waktu tertentu kurang dari atau sama dengan batas yang diberikan. Batas default adalah 8, tetapi ini dapat disesuaikan menggunakan variabel lingkunganSMP_NCCL_THROTTLE_LIMIT. Jika Anda mengamati lebih banyak penggunaan memori daripada yang Anda harapkan saat menggunakan paralelisme tensor, Anda dapat mencoba mengurangi batas ini. Namun, memilih batas yang terlalu kecil dapat menyebabkan kerugian throughput. Untuk menonaktifkan throttling sama sekali, Anda dapat mengatur. SMP_NCCL_THROTTLE_LIMIT=-1

Identitas berikut, yang berlaku ketika derajat paralelisme tensor adalah 1, tidak berlaku ketika derajat paralelisme tensor lebih besar dari 1:. smp.mp_size() * smp.dp_size() == smp.size() Ini karena gugus paralel tensor merupakan bagian dari kelompok paralelisme model dan kelompok paralelisme data. Jika kode Anda memiliki referensi kemp_rank,mp_size,MP_GROUP, dan sebagainya, dan jika Anda ingin bekerja hanya dengan grup paralel pipeline, Anda mungkin perlu mengganti referensi dengansmp.pp_size(). Identitas berikut selalu benar:

Karena smp.DistributedModel pembungkus memodifikasi parameter model saat paralelisme tensor diaktifkan, pengoptimal harus dibuat setelah memanggilsmp.DistributedModel, dengan parameter terdistribusi. Misalnya, berikut ini tidak berfungsi:

## WRONG
model = MyModel()
optimizer = SomeOptimizer(model.parameters())
model = smp.DistributedModel(model)  # optimizer now has outdated parameters! 

Sebagai gantinya, pengoptimal harus dibuat dengan parameter smp.DistributedModel sebagai berikut:

## CORRECT
model = smp.DistributedModel(MyModel())
optimizer = SomeOptimizer(model.optimizers())

Ketika modul diganti dengan mitra terdistribusi melalui paralelisme tensor, modul terdistribusi tidak mewarisi bobotnya dari modul asli, dan menginisialisasi bobot baru. Ini berarti bahwa, misalnya, jika bobot perlu diinisialisasi dalam panggilan tertentu (misalnya, melalui load_state_dict panggilan), ini perlu terjadi setelah smp.DistributedModel panggilan, setelah distribusi modul berlangsung.

Saat mengakses parameter modul terdistribusi secara langsung, perhatikan bahwa bobotnya tidak memiliki bentuk yang sama dengan modul aslinya. Sebagai contoh, 

with smp.tensor_parallelism():
    linear = nn.Linear(60, 60)

# will pass
assert tuple(linear.weight.shape) == (60, 60)

distributed_linear = smp.DistributedModel(linear)

# will fail. the number of input channels will have been divided by smp.tp_size()
assert tuple(distributed_linear.module.weight.shape) == (60, 60)

Penggunaan sangat torch.utils.data.distributed.DistributedSampler disarankan untuk paralelisme tensor. Ini memastikan bahwa setiap peringkat paralel data menerima jumlah sampel data yang sama, yang mencegah hang yang mungkin dihasilkan dari dp_rank s yang berbeda mengambil sejumlah langkah yang berbeda.

Jika Anda menggunakan join API DistributedDataParallel kelas untuk menangani kasus di mana peringkat paralel data yang berbeda memiliki jumlah batch yang berbeda, Anda masih perlu memastikan bahwa peringkat yang sama TP_GROUP memiliki jumlah batch yang sama; jika tidak, kolektif komunikasi yang digunakan dalam eksekusi terdistribusi modul dapat hang. PyTorch Peringkat yang berada di TP_GROUP s berbeda dapat memiliki jumlah batch yang berbeda, selama join API digunakan.

Jika Anda ingin memeriksa model Anda dan menggunakan paralelisme tensor, pertimbangkan hal berikut:

Untuk informasi lebih lanjut tentang checkpointing model dengan paralelisme tensor, lihat. Checkpointing model terdistribusi