Perkirakan memori GPU untuk Large Language Models - Platform For AI

Topik ini menjelaskan faktor-faktor yang memengaruhi kebutuhan memori GPU untuk penerapan dan fine-tuning Large Language Model (LLM), serta cara memperkirakannya.

Estimator memori GPU sederhana

Catatan

Topik ini memperkirakan kebutuhan memori GPU untuk penerapan dan fine-tuning Large Language Model (LLM) berdasarkan metode perhitungan umum. Nilai perkiraan mungkin berbeda dari penggunaan memori GPU aktual karena variasi struktur jaringan dan algoritma antar model.
Untuk model mixture-of-experts (MoE), seperti DeepSeek-R1-671B, seluruh parameter model sebesar 671B harus dimuat. Namun, hanya 37B parameter yang diaktifkan selama inferensi. Oleh karena itu, saat menghitung memori GPU yang digunakan oleh nilai aktivasi, gunakan jumlah parameter yang diaktifkan, yaitu 37B.
Saat fine-tuning model, parameter, nilai aktivasi, dan gradien biasanya disimpan dalam format 16-bit. Model tersebut menggunakan pengoptimal Adam/AdamW dengan status pengoptimal disimpan dalam format 32-bit.

Inference

Jenis Model:

Total Parameter Model: B

Konkurensi Inference:

Panjang Sekuens:

Scenario	Required GPU Memory (GB)
Inference (16-bit)	-
Inference (8-bit)	-
Inference (4-bit)	-

Fine-tuning

Jenis Model:

Total Parameter Model: B

Presisi Parameter: bit

Optimizer:

Ukuran batch pelatihan:

Panjang Sekuens:

Scenario	Required GPU Memory (GB)
Full-parameter fine-tuning	-
LoRA fine-tuning	-
QLoRA (8-bit) fine-tuning	-
QLoRA (4-bit) fine-tuning	-

Faktor yang Mempengaruhi Memori GPU untuk Inferensi Model

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

Parameter model

Pertama, parameter model harus disimpan selama inferensi. Rumus penggunaan memori GPU-nya adalah: jumlah parameter × presisi parameter. Presisi parameter umum meliputi FP32 (4 byte), FP16 (2 byte), dan BF16 (2 byte). Untuk Large Language Models (LLM), parameter model biasanya disimpan dalam format FP16 atau BF16. Sebagai contoh, model 7B dengan presisi FP16 memerlukan memori GPU sebagai berikut:

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

Nilai aktivasi

Selama inferensi Large Language Model (LLM), nilai aktivasi setiap lapisan neuron harus dihitung. Penggunaan memori GPU berbanding lurus dengan ukuran batch, panjang sekuens, serta arsitektur model—seperti jumlah lapisan dan ukuran lapisan tersembunyi. Hubungan tersebut dinyatakan sebagai berikut: $Activation value GPU memory \propto b \times s \times h \times L \times p a r am_b y t es$

Di mana:

b (batch size): Ukuran batch per permintaan. Biasanya bernilai 1 untuk layanan online dan bernilai lebih dari 1 untuk antarmuka pemrosesan batch.
s (sequence length): Panjang sekuens total, mencakup jumlah token masukan dan keluaran.
h (hidden size): Dimensi lapisan tersembunyi model.
L (Layers): Jumlah lapisan Transformer dalam model.
param_bytes: Presisi penyimpanan nilai aktivasi, biasanya 2 byte.

Berdasarkan faktor-faktor ini dan pengalaman praktis, estimasi memori GPU dapat disederhanakan. Untuk memberikan ruang cadangan, pada model 7B dengan b = 1, s = 2048, dan param_bytes = 2 byte, memori GPU yang digunakan oleh nilai aktivasi diperkirakan sekitar 10% dari total memori GPU yang digunakan model. Perhitungannya sebagai berikut: $14 GB \times 0.1 = 1.4 GB$ .

KV cache

Untuk meningkatkan efisiensi inferensi Large Language Model (LLM), Key (K) dan Value (V) yang telah dihitung untuk setiap lapisan Transformer biasanya di-cache. Pendekatan ini menghindari penghitungan ulang parameter mekanisme perhatian untuk semua token historis pada setiap langkah waktu. Dengan KV cache, kompleksitas komputasi berkurang dari $O (n^{2})$ menjadi $O (n)$ , sehingga secara signifikan mempercepat inferensi. Seperti halnya nilai aktivasi, penggunaan memori GPU untuk KV cache juga berbanding lurus dengan ukuran batch, panjang sekuens, konkurensi, serta arsitektur model—seperti jumlah lapisan dan ukuran lapisan tersembunyi. Hubungan tersebut dinyatakan sebagai berikut: $K V cache GPU memory \propto 2 \times b \times s \times h \times L \times C \times p a r am_b y t es$

Di mana:

2: Menunjukkan perlunya menyimpan dua matriks, K (Key) dan V (Value).
b (batch size): Ukuran batch per permintaan. Biasanya bernilai 1 untuk layanan online dan bernilai lebih dari 1 untuk antarmuka pemrosesan batch.
s (sequence length): Panjang sekuens total, mencakup jumlah token masukan dan keluaran.
h (hidden size): Dimensi lapisan tersembunyi model.
L (Layers): Jumlah lapisan Transformer dalam model.
C (Concurrency): Tingkat konkurensi permintaan antarmuka layanan.
param_bytes: Presisi penyimpanan nilai aktivasi, biasanya 2 byte.

Berdasarkan faktor-faktor ini dan pengalaman praktis, estimasi memori GPU dapat disederhanakan. Untuk memberikan ruang cadangan, pada model 7B dengan C = 1, b = 1, s = 2048, dan param_bytes = 2 byte, memori GPU yang digunakan oleh KV cache diperkirakan sekitar 10% dari total memori GPU yang digunakan model. Perhitungannya sebagai berikut: $1.4 GB$ .

Faktor lainnya

Selain faktor-faktor tersebut, data masukan untuk batch saat ini, core CUDA, dan framework pembelajaran mendalam seperti PyTorch atau TensorFlow juga mengonsumsi sebagian memori GPU. Konsumsi ini biasanya berkisar antara 1 GB hingga 2 GB.

Berdasarkan analisis ini, memori GPU minimum yang diperlukan untuk penerapan inferensi Large Language Model (LLM) 7B kira-kira sebesar:

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

Faktor yang Mempengaruhi Memori GPU untuk Penyempurnaan Model

Memori GPU yang dibutuhkan untuk fine-tuning model terdiri dari komponen utama berikut:

Parameter model

Pertama, parameter model harus disimpan selama proses fine-tuning. Rumus penggunaan memori GPU adalah: jumlah parameter × presisi parameter. Presisi parameter umum meliputi FP32 (4 byte), FP16 (2 byte), dan BF16 (2 byte). Untuk Large Language Models (LLMs), parameter model biasanya disimpan dalam format FP16 atau BF16 selama fine-tuning. Sebagai contoh, model 7B dengan presisi parameter FP16 memerlukan memori GPU sebagai berikut:

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

Parameter gradien

Selama fase propagasi mundur (backward propagation) dalam pelatihan model, gradien dihitung untuk parameter model. Jumlah gradien sama dengan jumlah parameter yang dilatih. Large Language Models (LLMs) biasanya menyimpan gradien dengan presisi 2 byte. Oleh karena itu, model 7B memerlukan memori GPU berikut, yang bervariasi tergantung pada metode fine-tuning:

Metode fine-tuning	Mekanisme pelatihan	Skenario	Memori GPU yang dibutuhkan untuk gradien fine-tuning model 7B (dihitung dengan 1% parameter, penyimpanan 2 byte)
Full-parameter fine-tuning	Parameter yang dilatih sama dengan parameter model aslinya	Kebutuhan presisi tinggi dengan daya komputasi yang cukup	14 GB
LoRA (low-rank adaptation)	fine-tuning LoRA membekukan parameter model asli dan hanya melatih matriks low-rank. Parameter yang dilatih bergantung pada struktur model dan ukuran matriks low-rank, biasanya sekitar 0,1% hingga 1% dari total parameter model.	Adaptasi sumber daya rendah untuk tugas tertentu	0,14 GB
QLoRA (quantization + LoRA)	Menekan model pra-latih menjadi 4-bit atau 8-bit, menggunakan LoRA untuk fine-tuning model, serta memperkenalkan double quantization dan paged optimizers, sehingga lebih mengurangi penggunaan memori GPU. Parameter yang dilatih biasanya sekitar 0,1% hingga 1% dari total parameter model.	fine-tuning untuk model ultra-besar	0,14 GB

Status optimizer

Selama pelatihan, status optimizer harus disimpan. Jumlah nilai status bergantung pada jumlah parameter yang dilatih. Selain itu, model umumnya menggunakan pelatihan mixed-precision. Dalam pendekatan ini, parameter model dan gradien disimpan dalam 2 byte, sedangkan status optimizer menggunakan 4 byte. Metode ini menjaga presisi tinggi selama pembaruan parameter serta mencegah ketidakstabilan numerik atau overflow akibat rentang dinamis terbatas FP16/BF16. Jika status optimizer disimpan dalam 4 byte, memori GPU yang dibutuhkan menjadi dua kali lipat. Optimizer umum meliputi:

Jenis pengoptimal	Mekanisme pembaruan parameter	Kebutuhan Penyimpanan Tambahan (setiap parameter yang dilatih)	Skenario	Memori GPU yang dibutuhkan untuk status pengoptimal fine-tuning model 7B (penyimpanan 4 byte)
Jenis pengoptimal	Mekanisme pembaruan parameter		Skenario	Full-parameter fine-tuning	LoRA fine-tuning (dihitung dengan 1% parameter)	QLoRA fine-tuning (dihitung dengan 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 kedua)	Optimisasi non-konveks	28 GB	0,28 GB	0,28 GB
Adam/AdamW	Momentum + tingkat pembelajaran adaptif	2 bilangan titik mengambang (momen pertama + kedua)	Umum digunakan untuk Large Language Models (LLM)	56 GB	0,56 GB	0,56 GB

Nilai aktivasi

Selama pelatihan, nilai aktivasi antara yang dihasilkan dalam propagasi maju (forward propagation) harus disimpan untuk menghitung gradien selama propagasi mundur (backward propagation). Konsumsi memori GPU ini berbanding lurus dengan ukuran batch, panjang sekuens, dan arsitektur model—seperti jumlah layer dan ukuran hidden layer. Hubungan tersebut dinyatakan sebagai berikut: $Memori GPU nilai aktivasi \propto b \times s \times h \times L \times p a r am_b y t es$

Di mana:

b (batch size): Ukuran batch.
s (sequence length): Panjang sekuens total, mencakup jumlah token input dan output.
h (hidden size): Dimensi hidden layer model.
L (Layers): Jumlah layer Transformer dalam model.
param_bytes: Presisi penyimpanan nilai aktivasi, biasanya 2 byte.

Berdasarkan faktor-faktor ini dan pengalaman praktis, estimasi memori GPU dapat disederhanakan. Untuk memberikan ruang cadangan, pada model 7B dengan b = 1, s = 2.048, dan param_bytes = 2 byte, memori GPU yang digunakan oleh nilai aktivasi diperkirakan sekitar 10% dari total memori GPU model. Perhitungannya sebagai berikut: $14 GB \times 0.1 = 1.4 GB$ .

Faktor lainnya

Berdasarkan analisis ini, perkiraan memori GPU yang dibutuhkan untuk fine-tuning Large Language Model (LLM) 7B adalah sebagai berikut:

Metode fine-tuning	Memori GPU untuk model itu sendiri	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

Large Language Models (LLMs) biasanya menggunakan optimizer Adam/AdamW.
Dalam tabel, semua parameter menggunakan penyimpanan 16-bit (2 byte), kecuali model QLoRA yang menggunakan penyimpanan 4-bit atau 8-bit dan status optimizer yang menggunakan penyimpanan 32-bit (4 byte).

FAQ

T: Bagaimana cara melihat jumlah parameter Large Language Model (LLM)?

Untuk Large Language Model (LLM) sumber terbuka, jumlah parameter biasanya tercantum dalam nama model. Misalnya, Qwen-7B memiliki $7 \times 1 0^{9}$ parameter, sedangkan Qwen3-235B-A22B memiliki total $235 \times 1 0^{9}$ parameter dengan $22 \times 1 0^{9}$ parameter yang diaktifkan selama inferensi. Untuk model yang tidak mencantumkan jumlah parameter secara eksplisit dalam namanya, Anda dapat meninjau dokumentasi model tersebut untuk informasi lebih lanjut.

T: Bagaimana cara melihat presisi parameter Large Language Model (LLM)?

Kecuali dinyatakan lain, Large Language Model (LLM) umumnya menggunakan presisi 16-bit (2 byte). Model yang telah dikuantisasi mungkin menggunakan presisi 8-bit atau 4-bit. Untuk informasi lebih detail, lihat dokumentasi model tersebut. Sebagai contoh, jika Anda menggunakan model dari PAI Model Gallery, halaman produknya biasanya mencantumkan presisi parameternya:

Qwen2.5-7B-Instruct petunjuk pelatihan:

T: Bagaimana cara melihat presisi pengoptimal dan status yang digunakan untuk fine-tuning Large Language Model (LLM)?

Pelatihan Large Language Model (LLM) biasanya menggunakan pengoptimal Adam/AdamW dengan presisi 32-bit (4 byte). Untuk konfigurasi lebih rinci, Anda dapat memeriksa perintah atau kode yang digunakan saat memulai pelatihan.

T: Bagaimana cara melihat penggunaan memori GPU?

Anda dapat memantau penggunaan memori GPU melalui halaman grafis pemantauan PAI-DSW, PAI-EAS, atau PAI-DLC:

Sebagai alternatif, jalankan perintah nvidia-smi di terminal kontainer untuk melihat penggunaan GPU:

T: Apa saja error umum akibat kehabisan memori GPU?

Jika memori GPU NVIDIA tidak mencukupi, Anda akan menerima error CUDA out of memory. Tried to allocate X GB. Dalam kasus ini, Anda dapat menambah memori GPU atau mengurangi ukuran Batch, panjang urutan (sequence length), atau parameter lainnya.