Memperkirakan Memori GPU yang Diperlukan untuk Model Bahasa Besar - Platform For AI

Topik ini menjelaskan faktor-faktor yang memengaruhi Memori GPU yang diperlukan untuk men-deploy dan fine-tuning LLM dan cara memperkirakan Memori GPU yang diperlukan.

Estimator Memori GPU Sederhana

Catatan

Topik ini memperkirakan memori GPU yang diperlukan untuk men-deploy dan melakukan fine-tuning LLM berdasarkan metode perhitungan umum. Penggunaan memori GPU aktual dapat bervariasi karena perbedaan struktur jaringan model dan algoritma.
Untuk model Mixture-of-Experts (MoE), seperti DeepSeek-R1-671B, seluruh 671 miliar parameter model harus dimuat. Namun, hanya 37 miliar parameter yang diaktifkan selama inferensi. Oleh karena itu, saat menghitung memori GPU yang ditempati oleh nilai aktivasi, gunakan jumlah parameter sebesar 37 miliar.
Saat melakukan fine-tuning model, presisi 16-bit biasanya digunakan untuk menyimpan parameter model, nilai aktivasi, dan gradien. Pengoptimal Adam atau AdamW digunakan, dan status pengoptimal disimpan dengan presisi 32-bit.

Inferensi

<ins data-operation-index="7">Judul</ins>

Jenis Model:

Total Parameter Model: B

Konkurensi Inferensi:

Panjang Sekuens:

Skenario	Memori GPU yang Dibutuhkan (GB)
Inferensi (16-bit)	-
Inferensi (8-bit)	-
Inferensi (4-bit)	-

Fine-tuning

Jenis Model:

Total Parameter Model: B

Precision Parameter: bit

Optimizer:

batch_size Pelatihan:

Panjang Sekuens:

Skenario	Memori GPU yang Dibutuhkan (GB)
Full Fine-tuning	-
LoRA Fine-tuning	-
QLoRA (8-bit) Fine-tuning	-
QLoRA (4-bit) Fine-tuning	-

Faktor yang Mempengaruhi Kebutuhan Memori GPU untuk Inferensi Model

Memori GPU yang diperlukan untuk inferensi model terdiri dari komponen utama berikut:

Parameter model

Selama inferensi model, parameter model harus disimpan dalam memori GPU. Rumus untuk menghitung memori GPU yang diperlukan adalah: Jumlah parameter × Presisi parameter. Presisi parameter umum meliputi FP32 (4 byte), FP16 (2 byte), dan BF16 (2 byte). Untuk model bahasa besar (LLM), parameter model biasanya menggunakan presisi FP16 atau BF16. Sebagai contoh, untuk model 7B dengan presisi FP16, memori GPU yang diperlukan adalah:

$\frac{7 \times 1 0 ^{9} \times 2}{1 0 ^{9}} = 14 GB$

Nilai aktivasi

Selama inferensi LLM, nilai aktivasi dihitung untuk setiap lapisan neuron. Memori GPU yang diperlukan berbanding lurus dengan ukuran batch, panjang sekuens, dan arsitektur model (seperti jumlah lapisan dan ukuran hidden layer). Hubungan ini dapat dinyatakan sebagai: $A c t i v a t i o n M e m ory \propto b \times s \times h \times L \times p a r am_b y t es$

Dengan keterangan:

b (batch size): Ukuran batch untuk satu permintaan. Nilai ini biasanya 1 untuk layanan online tetapi bisa lebih besar untuk antarmuka pemrosesan batch.
s (panjang sekuens): Panjang total sekuens, termasuk jumlah token masukan dan keluaran.
h (hidden size): Dimensi lapisan tersembunyi model.
L: Jumlah lapisan Transformer dalam model.
param_bytes: Jumlah byte yang digunakan untuk menyimpan setiap nilai aktivasi, biasanya 2 byte.

Berdasarkan pengalaman praktis dan faktor-faktor di atas, untuk menyederhanakan estimasi dan menyertakan buffer, Anda dapat memperkirakan secara kasar bahwa untuk model 7B dengan b = 1, s = 2048, dan param_bytes = 2 byte, memori GPU untuk nilai aktivasi kira-kira 10% dari memori GPU yang digunakan oleh model: $14 GB \times 0.1 = 1.4 GB$

Cache KV

Untuk mempercepat inferensi model bahasa besar, nilai Key (K) dan Value (V) yang telah dihitung untuk setiap lapisan Transformer disimpan dalam cache. Hal ini menghindari perhitungan ulang nilai-nilai tersebut untuk semua token historis pada setiap langkah waktu. Penggunaan cache KV mengurangi kompleksitas komputasi dari $O (n^{2})$ menjadi $O (n)$ dan sangat meningkatkan kecepatan inferensi. Seperti halnya nilai aktivasi, memori GPU yang digunakan oleh cache KV juga berbanding lurus dengan ukuran batch, panjang sekuens, konkurensi, dan arsitektur model (seperti jumlah lapisan dan ukuran hidden layer). Hubungan tersebut dapat dinyatakan sebagai: $K V C a c h e GP U M e m ory \propto 2 \times b \times s \times h \times L \times C \times p a r am_b y t es$

Dengan keterangan:

2: Mewakili dua matriks yang perlu disimpan, yaitu Key (K) dan Value (V).
b (batch size): Ukuran batch untuk satu permintaan. Nilai ini biasanya 1 untuk layanan online tetapi bisa lebih besar untuk antarmuka pemrosesan batch.
s (panjang sekuens): Panjang total sekuens, termasuk jumlah token masukan dan keluaran.
h (hidden size): Dimensi lapisan tersembunyi model.
L: Jumlah lapisan Transformer dalam model.
C: Tingkat konkurensi permintaan antarmuka layanan.
param_bytes: Jumlah byte yang digunakan untuk menyimpan setiap nilai, yang biasanya 2 byte.

Berdasarkan pengalaman praktis dan faktor-faktor yang disebutkan sebelumnya, Anda dapat menyederhanakan estimasi memori GPU dan menyertakan margin. Sebagai contoh, untuk model 7B dengan C = 1, b = 1, s = 2048, dan param_bytes = 2 byte, memori GPU untuk cache KV juga dapat diperkirakan secara kasar sekitar 10% dari penggunaan memori GPU model, yaitu: $1.4 GB$

Faktor lainnya

Selain faktor-faktor di atas, data masukan untuk batch saat ini, konteks CUDA, dan kerangka kerja pembelajaran mendalam itu sendiri (seperti PyTorch atau TensorFlow) juga mengonsumsi memori GPU. Overhead ini biasanya sebesar 1 GB hingga 2 GB.

Berdasarkan analisis ini, memori GPU minimum yang diperlukan untuk men-deploy LLM 7B untuk inferensi kira-kira:

$14 GB + 1.4 GB + 1.4 GB + 2 GB = 18.8 GB$

Faktor-faktor yang memengaruhi Memori GPU untuk fine-tuning model

Memori GPU yang diperlukan untuk fine-tuning model bergantung pada komponen-komponen berikut:

Parameter model

Selama fine-tuning, parameter model harus disimpan dalam Memori GPU. Penggunaan memori dihitung dengan rumus berikut: Jumlah parameter × Presisi parameter. Presisi parameter umum meliputi FP32 (4 byte), FP16 (2 byte), dan BF16 (2 byte). Untuk LLM, parameter model biasanya menggunakan presisi FP16 atau BF16 selama fine-tuning. Sebagai contoh, model dengan 7 miliar parameter yang menggunakan presisi FP16 memerlukan jumlah Memori GPU sebagai berikut:

$\frac{7 \times 1 0 ^{9} \times 2 =}{1 0 ^{9}} 14 GB$

Parameter gradien

Selama fase propagasi mundur dalam pelatihan model, gradien dihitung untuk parameter model. Jumlah gradien sama dengan jumlah parameter yang dilatih. LLM biasanya menyimpan gradien-gradien ini dengan presisi 2 byte. Oleh karena itu, kebutuhan Memori GPU untuk model 7B bervariasi tergantung pada metode fine-tuning:

Metode fine-tuning	Mekanisme pelatihan	Skenario	Memori GPU untuk gradien dalam fine-tuning model 7B (dihitung untuk 1% parameter, penyimpanan 2 byte)
Full-parameter fine-tuning	Jumlah parameter yang dapat dilatih sama dengan jumlah total parameter model.	Kebutuhan presisi tinggi dengan daya komputasi yang mencukupi.	14 GB
LoRA (Low-Rank Adaptation)	Fine-tuning LoRA membekukan parameter model asli dan hanya melatih matriks berperingkat rendah. Jumlah parameter yang dapat dilatih bergantung pada struktur model dan ukuran matriks berperingkat rendah, biasanya sekitar 0,1% hingga 1% dari total parameter model.	Adaptasi untuk tugas tertentu dengan sumber daya terbatas.	0,14 GB
QLoRA (Kuantisasi + LoRA)	Mengompresi model pra-latih menjadi 4-bit atau 8-bit, melakukan fine-tuning model menggunakan LoRA, serta menerapkan kuantisasi ganda dan pengoptimal berhalaman untuk lebih mengurangi penggunaan Memori GPU. Jumlah parameter yang dapat dilatih biasanya sekitar 0,1% hingga 1% dari total parameter model.	Fine-tuning untuk model berskala sangat besar.	0,14 GB

Status pengoptimal

Status pengoptimal juga harus disimpan selama pelatihan. Jumlah memori yang dibutuhkan bergantung pada jumlah parameter yang dapat dilatih. Model sering menggunakan pelatihan presisi campuran. Dalam metode ini, parameter model dan gradien menggunakan penyimpanan 2 byte, sedangkan status pengoptimal menggunakan penyimpanan 4 byte. Pendekatan ini menjaga presisi tinggi selama pembaruan parameter dan mencegah ketidakstabilan numerik atau overflow yang disebabkan oleh rentang dinamis terbatas FP16 atau BF16. Karena status pengoptimal menggunakan 4 byte per nilai, komponen ini dapat memerlukan memori yang signifikan. Sebagai contoh, pengoptimal yang menyimpan satu nilai 4 byte untuk setiap parameter 2 byte memerlukan memori dua kali lipat dari parameter tersebut. Tabel berikut menjelaskan pengoptimal umum:

Jenis pengoptimal	Mekanisme pembaruan parameter	Penyimpanan tambahan yang diperlukan (per parameter yang dapat dilatih)	Skenario	Memori GPU untuk status pengoptimal dalam fine-tuning model 7B (penyimpanan 4 byte)
Jenis pengoptimal	Mekanisme pembaruan parameter		Skenario	Full-parameter fine-tuning	Fine-tuning LoRA (dihitung untuk 1% parameter)	Fine-tuning QLoRA (dihitung untuk 1% parameter)
SGD	Hanya menggunakan gradien saat ini	0 (tidak ada status tambahan)	Model kecil atau eksperimen	0	0	0
SGD + Momentum	Dengan suku momentum	1 bilangan titik mengambang (momentum)	Stabilitas lebih baik	28 GB	0,28 GB	0,28 GB
RMSProp	Tingkat pembelajaran adaptif	1 bilangan titik mengambang (momen orde kedua)	Optimisasi non-konveks	28 GB	0,28 GB	0,28 GB
Adam/AdamW	Momentum + tingkat pembelajaran adaptif	2 bilangan titik mengambang (momen orde pertama dan kedua)	Umum digunakan untuk LLM	56 GB	0,56 GB	0,56 GB

Nilai aktivasi

Selama pelatihan, nilai aktivasi antara dari proses propagasi maju harus disimpan untuk menghitung gradien selama propagasi mundur. Konsumsi Memori GPU untuk komponen ini berkorelasi positif dengan ukuran batch, panjang sekuens, dan arsitektur model, seperti jumlah lapisan dan ukuran lapisan tersembunyi. Hubungan tersebut dapat dinyatakan dengan rumus berikut: $A c t i v a t i o n M e m ory \propto b \times s \times h \times L \times p a r am_b y t es$

Di mana:

b: Ukuran batch.
s: Panjang sekuens total, yang mencakup masukan dan keluaran (jumlah token).
h: Dimensi lapisan tersembunyi model.
L: Jumlah lapisan Transformer dalam model.
param_bytes: Presisi untuk menyimpan nilai aktivasi biasanya 2 byte.

Berdasarkan pengalaman praktis dan faktor-faktor yang disebutkan di atas, Anda dapat menyederhanakan estimasi Memori GPU dan menyertakan margin. Sebagai contoh, untuk model 7B dengan b = 1, s = 2048, dan param_bytes = 2 byte, Anda dapat memperkirakan secara kasar Memori GPU untuk nilai aktivasi sebesar 10% dari Memori GPU yang digunakan oleh model: $14 GB \times 0,1 = 1,4 GB$

Faktor lainnya

Selain faktor-faktor di atas, komponen lain juga mengonsumsi Memori GPU. Komponen-komponen tersebut mencakup data masukan untuk batch saat ini, core CUDA, dan kerangka kerja pembelajaran mendalam, seperti PyTorch atau TensorFlow. Penggunaan ini biasanya mengonsumsi 1 GB hingga 2 GB Memori GPU.

Berdasarkan analisis ini, perkiraan jumlah Memori GPU yang diperlukan untuk melakukan fine-tuning LLM 7B adalah sebagai berikut:

Metode fine-tuning	Memori GPU untuk model	Memori GPU untuk gradien	Status pengoptimal Adam	Nilai aktivasi	Lainnya	Total
Full-parameter fine-tuning	14 GB	14 GB	56 GB	1,4 GB	2 GB	87,4 GB
LoRA (Low-Rank Adaptation)	14 GB	0,14 GB	0,56 GB	1,4 GB	2 GB	18,1 GB
QLoRA (kuantisasi 8-bit + LoRA)	7 GB	0,14 GB	0,56 GB	1,4 GB	2 GB	11,1 GB
QLoRA (kuantisasi 4-bit + LoRA)	3,5 GB	0,14 GB	0,56 GB	1,4 GB	2 GB	7,6 GB

Catatan

LLM biasanya menggunakan pengoptimal Adam atau AdamW.
Dalam tabel, model QLoRA disimpan dalam presisi 4-bit atau 8-bit, dan status pengoptimal disimpan dalam presisi 32-bit (4 byte). Semua parameter lain disimpan dalam presisi 16-bit (2 byte).

FAQ

T: Bagaimana cara memeriksa jumlah parameter dalam model besar?

Untuk model besar open-source, jumlah parameter biasanya ditunjukkan dalam nama model. Misalnya, Qwen-7B memiliki $7 \times 1 0^{9}$ parameter. Untuk Qwen3-235B-A22B, jumlah total parameternya adalah $235 \times 1 0^{9}$ , dan jumlah parameter aktif selama inferensi adalah $22 \times 1 0^{9}$ . Jika nama model tidak mencantumkan informasi ini, Anda dapat menemukan detail parameter tersebut di dokumentasi model.

T: Bagaimana cara memeriksa presisi parameter LLM?

Kecuali dinyatakan lain, model besar biasanya menggunakan penyimpanan 16 bit (2 byte). Model yang dikuantisasi mungkin menggunakan penyimpanan 8 bit atau 4 bit. Untuk detail lebih lanjut, lihat dokumentasi model. Sebagai contoh, jika Anda menggunakan model dari PAI Model Gallery, halaman produknya biasanya menjelaskan presisi parameternya:

Qwen2.5-7B-Instruct petunjuk pelatihan:

T: Bagaimana cara memeriksa presisi pengoptimal dan status yang digunakan untuk fine-tuning LLM?

Pelatihan LLM biasanya menggunakan pengoptimal Adam atau AdamW. Presisi parameternya adalah 32 bit (4 byte). Untuk konfigurasi yang lebih rinci, Anda dapat memeriksa perintah startup atau kode.

T: Bagaimana cara memeriksa Penggunaan memori GPU?

Anda dapat melihat Penggunaan memori GPU pada halaman pemantauan grafis PAI-DSW, PAI-EAS, atau PAI-DLC.

Atau, Anda dapat menjalankan perintah nvidia-smi di terminal kontainer untuk melihat penggunaan GPU:

T: Apa saja kesalahan umum akibat kurangnya memori GPU?

Kurangnya memori GPU NVIDIA menyebabkan kesalahan CUDA out of memory. Tried to allocate X GB. Jika kesalahan ini terjadi, Anda dapat menambah memori GPU atau mengurangi parameter seperti ukuran Batch dan panjang sekuens.