# Metode paralelisme

Konfigurasi multi-GPU efektif untuk mempercepat pelatihan dan memuat model besar ke dalam memori yang tidak akan muat di satu GPU. Pendekatan ini bergantung pada paralelisasi beban kerja di antara GPU. Terdapat beberapa jenis paralelisme, seperti paralelisme data, paralelisme tensor, paralelisme pipeline, dan paralelisme model. Setiap jenis paralelisme membagi beban kerja dengan cara yang berbeda, baik pada data maupun pada model.

Panduan ini akan membahas berbagai metode paralelisme, cara menggabungkannya, serta memilih strategi yang sesuai untuk konfigurasi Anda. Untuk detail lebih lanjut tentang pelatihan terdistribusi, silakan merujuk ke dokumentasi [Accelerate](https://hf.co/docs/accelerate/index).

Untuk panduan komprehensif tentang penskalaan model bahasa besar, lihat [Ultrascale Playbook](https://huggingface.co/spaces/nanotron/ultrascale-playbook), yang menyediakan strategi dan praktik terbaik yang terperinci untuk pelatihan berskala besar.

## Strategi skalabilitas

Gunakan [Model Memory Calculator](https://huggingface.co/spaces/hf-accelerate/model-memory-usage) untuk menghitung berapa banyak memori yang dibutuhkan oleh sebuah model. Kemudian, lihat tabel di bawah ini untuk memilih strategi berdasarkan konfigurasi Anda.

| setup | skenario | strategi |
|---|---|---|
| satu node/multi-GPU | muat di satu GPU | DistributedDataParallel atau ZeRO |
|  | tidak muat di satu GPU | PipelineParallel, ZeRO atau TensorParallel |
|  | lapisan model terbesar tidak muat | TensorParallel atau ZeRO |
| multi-node/multi-GPU | konektivitas antar-node yang cepat (NVLink atau NVSwitch) | ZeRO atau paralelisasi 3D (PipelineParallel, TensorParallel, DataParallel) |
|  | konektivitas antar-node yang lambat | ZeRO atau paralelisasi 3D (PipelineParallel, TensorParallel, DataParallel) |

## Paralelisme data

Data parallelism mendistribusikan data secara merata ke beberapa GPU. Setiap GPU menyimpan salinan model dan memproses bagian datanya secara bersamaan. Pada akhirnya, hasil dari setiap GPU disinkronkan dan digabungkan.

Data parallelism secara signifikan mengurangi waktu pelatihan dengan memproses data secara paralel, dan dapat diskalakan sesuai dengan jumlah GPU yang tersedia. Namun, sinkronisasi hasil dari setiap GPU dapat menambah overhead.

Terdapat dua jenis paralelisasi data, yaitu DataParallel (DP) dan DistributedDataParallel (DDP).

### DataParallel

[DataParallel](https://pytorch.org/docs/stable/generated/torch.nn.DataParallel.html) mendukung pelatihan terdistribusi pada *satu mesin* dengan beberapa GPU.

1. GPU default, `GPU 0`, membaca batch data dan mengirim mini batch darinya ke GPU lainnya.
2. Model yang mutakhir direplikasi dari `GPU 0` ke GPU lainnya.
3. Lewatan `forward` dilakukan pada setiap GPU dan keluarannya dikirim ke `GPU 0` untuk menghitung loss.
4. Loss didistribusikan dari `GPU 0` ke GPU lainnya untuk proses `backward`.
5. Gradien dari setiap GPU dikirim kembali ke `GPU 0` dan dirata-ratakan.

### DistributedDataParallel

[DistributedDataParallel](https://pytorch.org/docs/main/notes/ddp.html) mendukung pelatihan terdistribusi di *beberapa mesin* dengan beberapa GPU.

1. Proses utama mereplikasi model dari GPU default, `GPU 0`, ke setiap GPU.
2. Setiap GPU memproses langsung mini batch data.
3. Gradien lokal dirata-ratakan di semua GPU selama proses `backward`.

DDP direkomendasikan karena mengurangi overhead komunikasi antar-GPU, memanfaatkan setiap GPU secara efisien, dan dapat diskalakan ke lebih dari satu mesin.

### Paralelisme data ZeRO

[Zero Redundancy Optimizer](https://www.deepspeed.ai/tutorials/zero/) adalah jenis data parallelism yang lebih hemat memori. Metode ini secara signifikan meningkatkan efisiensi memori dengan mempartisi parameter, gradien, dan state optimizer di antara proses data parallel untuk mengurangi penggunaan memori. Terdapat tiga tahap ZeRO:

- Stage 1 mempartisi state optimizer
- Stage 2 membagi partisi state optimizer dan gradien
- Stage 3 membagi optimizer, gradien, dan parameter

     

## Paralelisme model

Model parallelism mendistribusikan model ke beberapa GPU. Ada beberapa cara untuk membagi model, tetapi metode yang umum mendistribusikan lapisan model ke berbagai GPU. Pada jalur `forward`, GPU pertama memproses batch data dan meneruskannya ke kelompok lapisan berikutnya di GPU berikutnya. Untuk jalur `backward`, data dikirim mundur dari lapisan terakhir ke lapisan pertama.

Model parallelism adalah strategi yang berguna untuk melatih model yang terlalu besar untuk muat ke dalam memori satu GPU. Namun, pemanfaatan GPU tidak seimbang karena hanya satu GPU yang aktif pada satu waktu. Penyerahan hasil antar GPU juga menambah overhead komunikasi dan dapat menjadi bottleneck.

## Paralelisme pipeline

Pipeline parallelism secara konseptual sangat mirip dengan model parallelism, tetapi lebih efisien karena mengurangi waktu GPU yang menganggur. Alih-alih menunggu setiap GPU menyelesaikan pemrosesan satu batch data, pipeline parallelism membuat *micro-batches* data. Begitu satu micro-batch selesai, data tersebut diteruskan ke GPU berikutnya. Dengan cara ini, setiap GPU dapat memproses sebagian data secara bersamaan tanpa menunggu GPU lain menyelesaikan pemrosesan mini batch data secara keseluruhan.

Pipeline parallelism memiliki keuntungan yang sama dengan model parallelism, tetapi mengoptimalkan pemanfaatan GPU dan mengurangi waktu idle. Namun, pipeline parallelism bisa lebih kompleks karena model mungkin perlu ditulis ulang sebagai rangkaian modul [nn.Sequential](https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html), dan juga tidak mungkin untuk sepenuhnya mengurangi waktu idle karena `forward` pass terakhir juga harus menunggu `backward` pass selesai.

## Paralelisme tensor

Tensor parallelism mendistribusikan komputasi tensor besar di antara beberapa GPU. Tensor dipotong secara horizontal atau vertikal, dan setiap potongan diproses oleh GPU yang berbeda. Setiap GPU melakukan perhitungannya pada potongan tensor miliknya, dan hasilnya disinkronkan di akhir untuk merekonstruksi hasil akhir.

Tensor parallelism efektif untuk melatih model besar yang tidak muat dalam memori satu GPU. Metode ini juga lebih cepat dan efisien karena setiap GPU dapat memproses potongan tensornya secara paralel, dan dapat dikombinasikan dengan metode paralelisasi lainnya. Namun, seperti metode paralelisasi lainnya, tensor parallelism menambah overhead komunikasi antar-GPU.

Lihat panduan [Tensor parallelism](./perf_infer_gpu_multi) untuk mempelajari cara menggunakannya untuk inferensi.

## Paralelisme hibrida

Metode paralelisme dapat dikombinasikan untuk mencapai penghematan memori yang lebih besar dan melatih model dengan miliaran parameter secara lebih efisien.

### Paralelisme data dan paralelisme pipeline

Paralelisme data dan pipeline mendistribusikan data di antara GPU dan membagi setiap mini batch data menjadi micro-batch untuk mencapai paralelisme pipeline.

Setiap rank data parallel memperlakukan proses seolah-olah hanya ada satu GPU, bukan dua, tetapi GPU 0 dan 1 dapat meng-offload micro-batch data ke GPU 2 dan 3 untuk mengurangi waktu idle.

Pendekatan ini mengoptimalkan pemrosesan data paralel dengan mengurangi utilisasi GPU yang menganggur.

     

### Paralelisme data ZeRO, paralelisme pipeline, dan paralelisme model (paralelisme 3D)

Paralelisme data, pipeline, dan model digabungkan untuk membentuk [paralelisme 3D](https://www.microsoft.com/en-us/research/blog/deepspeed-extreme-scale-model-training-for-everyone/) guna mengoptimalkan efisiensi memori dan komputasi.

Efisiensi memori dicapai dengan membagi model di antara beberapa GPU dan juga membaginya menjadi beberapa tahap untuk membuat pipeline. Hal ini memungkinkan GPU untuk bekerja secara paralel pada micro-batch data, sehingga mengurangi penggunaan memori model, optimizer, dan activations.

Efisiensi komputasi diaktifkan oleh paralelisasi data ZeRO, di mana setiap GPU hanya menyimpan sebagian dari model, optimizer, dan aktivasi. Hal ini memungkinkan bandwidth komunikasi yang lebih tinggi antar node paralelisasi data karena komunikasi dapat terjadi secara independen atau paralel dengan tahap pipeline lainnya.

Pendekatan ini dapat diskalakan untuk model yang sangat besar dengan triliunan parameter.

     

