Kalkulator VRAM untuk Fine-Tuning (LoRA, QLoRA, Penuh)

Lihat hasil · 11,9 GB

Pengaturan pelatihan

Metode

Model dasar yang dibekukan disimpan dalam NF4 4-bit dengan kuantisasi ganda; yang dilatih hanya adapter.

Modul target LoRA
Bobot adapter

PEFT membuat bobot adapter dalam fp32; SFTTrainer dari TRL mengubahnya ke bf16 jika model dasar dikuantisasi (QLoRA). Pilih fp32 untuk PEFT tanpa TRL.

Optimizer

Perkiraan memori GPU

Total VRAM
Parameter yang dilatih
41,94 jt (0,52%)
Bobot, gradien, optimizer
6,2 GB
Aktivasi
0,8 GB

GPU terkecil di daftar yang muat: RTX 3060 12GB (12 GB), sisa 1,0 GB.

Tanpa gradient checkpointing: 21,1 GB.

Model: 8.030.261.248 parameter, 32 lapisan, ukuran hidden 4.096, kosakata 128.256.

prepare_model_for_kbit_training dari PEFT mengubah embedding dan lapisan output ke fp32: tambahkan 2,1 GB jika skrip Anda memanggilnya.

Ini perkiraan, bukan hasil pengukuran: memori aktivasi bergantung pada framework dan kernel-nya. Data model dan daftar GPU diperiksa pada 2026-10-24.

Rincian memori

Rincian memori
KomponenAturanMemoriPorsi
Bobot dasar beku (NF4 4-bit)0.5 B×Ψlin0.5\,\text{B} \times \Psi_{\text{lin}}3,49 GB29,3%
Konstanta kuantisasi0.127 bit×Ψlin0.127\,\text{bit} \times \Psi_{\text{lin}}0,11 GB0,93%
Embedding dan lapisan output (bf16)2 B×Ψemb2\,\text{B} \times \Psi_{\text{emb}}2,10 GB17,6%
Bobot adapter LoRA2 B×ΨLoRA2\,\text{B} \times \Psi_{\text{LoRA}}0,08 GB0,7%
Gradien adapter2 B×ΨLoRA2\,\text{B} \times \Psi_{\text{LoRA}}0,08 GB0,7%
State optimizer (adapter)8 B×ΨLoRA8\,\text{B} \times \Psi_{\text{LoRA}}0,34 GB2,8%
Aktivasi (dengan checkpointing)2sbhL+34sbh2sbhL + 34sbh0,82 GB6,9%
Logit output untuk loss10 B×sbV10\,\text{B} \times sbV2,63 GB22%
Konteks dan kernel CUDA1.3 GB1.3\,\text{GB}1,30 GB10,9%
Margin keamanan10 %10\,\%0,97 GB8,1%
Total VRAM11,92 GB100%

Ψ\Psi adalah jumlah parameter, Ψlin\Psi_{\text{lin}} parameter di lapisan linear, Ψemb\Psi_{\text{emb}} parameter embedding dan lapisan output, dan ΨLoRA\Psi_{\text{LoRA}} parameter adapter; ss adalah panjang sekuens, bb micro-batch, hh ukuran hidden, LL jumlah lapisan, VV kosakata, dan NN jumlah GPU. B berarti byte; GB berarti satu miliar byte.

GPU mana yang muat

  • RTX 3060 12GB 12 GB (12,9 GB)sisa 1,0 GB
  • RTX 4060 Ti 16GB 16 GB (17,2 GB)sisa 5,3 GB
  • RTX 4080 16 GB (17,2 GB)sisa 5,3 GB
  • Tesla P100 16GB 16 GB (17,2 GB)sisa 5,3 GB
  • RTX 3090 24 GB (25,8 GB)sisa 13,9 GB
  • RTX 4090 24 GB (25,8 GB)sisa 13,9 GB
  • Tesla P40 24 GB (25,8 GB)sisa 13,9 GB
  • MI50 32GB 32 GB (34,4 GB)sisa 22,5 GB
  • RTX 5090 32 GB (34,4 GB)sisa 22,5 GB
  • Tesla V100 32GB 32 GB (34,4 GB)sisa 22,5 GB
  • A100 40GB 40 GB (42,9 GB)sisa 31,0 GB
  • L40S 48 GB (51,5 GB)sisa 39,6 GB
  • RTX 4090 48GB 48 GB (51,5 GB)sisa 39,6 GB
  • RTX A6000 48 GB (51,5 GB)sisa 39,6 GB
  • A100 80GB 80 GB (85,9 GB)sisa 74,0 GB
  • H100 80GB 80 GB (85,9 GB)sisa 74,0 GB
  • H100 NVL 94 GB (100,9 GB)sisa 89,0 GB
  • RTX PRO 6000 96 GB (103,1 GB)sisa 91,2 GB
  • DGX Spark GB10 128 GB (137,4 GB)sisa 125,5 GB
  • H200 141 GB (151,4 GB)sisa 139,5 GB
  • B200 180 GB (193,3 GB)sisa 181,4 GB

Memori nominal menurut lembar spesifikasi produsen. Produsen menghitung dalam gigabyte biner, jadi kartu 24 GB menampung 25,8 miliar byte (dalam kurung); angka itulah yang dibandingkan, karena konteks CUDA sudah termasuk dalam total. MI50 tidak punya build CUDA untuk bitsandbytes (QLoRA, AdamW 8-bit); V100 dan kartu Pascal (P40, P100) tidak mendukung bf16, dan dalam fp16 memorinya sama.

Tentang alat ini

Fine-tuning model bahasa membutuhkan memori GPU jauh lebih besar daripada sekadar menjalankannya. Selain bobot, GPU menyimpan gradien, state optimizer, dan aktivasi setiap lapisan sampai backward pass. Kalkulator ini menjumlahkan semua komponen itu untuk fine-tuning penuh, LoRA, dan QLoRA, untuk model dari daftar atau model yang Anda gambarkan sendiri, lalu menunjukkan GPU umum mana yang cukup untuk hasilnya.

Setiap komponen ditampilkan dengan aturan dan sumbernya, karena kalkulator fine-tuning sering berbeda hingga dua kali lipat: satu menghitung 18 byte per parameter, yang lain 12, ada yang melupakan logit, ada yang diam-diam mengasumsikan checkpointing. Di sini setiap asumsi adalah pengaturan yang bisa Anda lihat dan ubah.

Cara memori diperkirakan

Fine-tuning penuh dengan mixed precision menyimpan, untuk setiap parameter, 2 byte bobot bf16, 2 byte gradien, salinan master fp32 sebesar 4 byte, serta 8 byte momentum dan varians AdamW: 16 byte, sesuai perhitungan makalah ZeRO (Rajbhandari et al., 2020). AdamW 8-bit menyimpan 2 byte state, bukan 8, dan SGD dengan momentum 4. Tahap ZeRO 1, 2, dan 3 membagi ke semua GPU state optimizer lebih dulu, lalu gradien, lalu bobot.

LoRA membekukan model dasar dengan 2 byte per parameter dan melatih dua matriks kecil di samping setiap bobot yang diadaptasi: bobot berukuran d×kd \times k mendapat r(d+k)r(d + k) parameter adapter (Hu et al., 2021). Hanya parameter ini yang punya gradien dan state optimizer: PEFT membuatnya dalam fp32 (16 byte per parameter dengan AdamW), dan SFTTrainer dari TRL mengubahnya ke bf16 untuk model terkuantisasi (12 byte). QLoRA menyimpan lapisan linear yang dibekukan dalam NormalFloat 4-bit dengan kuantisasi ganda, 4+8/64+32/(64⋅256)≈4,1274 + 8/64 + 32/(64 \cdot 256) \approx 4{,}127 bit per parameter (Dettmers et al., 2023), sedangkan embedding dan lapisan output tetap dalam bf16.

Aktivasi bergantung pada data. Setiap lapisan menyimpan sekitar 34 sbh34\,sbh byte untuk panjang sekuens ss, micro-batch bb, dan ukuran hidden hh (Korthikanti et al., 2022); FlashAttention menghapus suku matriks attention. Gradient checkpointing hanya menyimpan input setiap lapisan, 2 sbh2\,sbh, dan menghitung ulang satu lapisan sekaligus. Loss menambah sekitar 10 byte per token per entri kosakata untuk logit, kecuali kernel gabungan menghitungnya per potongan. Dengan WW bobot, GG gradien, OO state optimizer dan salinan master, AA aktivasi, dan Λ\Lambda logit, ditambah 1,3 GB untuk konteks CUDA dan margin 10%:

M=(W+G+O+A+Λ)×1,1+1,3 GBM = (W + G + O + A + \Lambda) \times 1{,}1 + 1{,}3\ \text{GB}

Mengapa kalkulator fine-tuning berbeda, dan apa yang tidak dihitung

Tiga asumsi menjelaskan sebagian besar perbedaan antarkalkulator, dan di sini masing-masing adalah pengaturan. Byte per parameter: panduan pelatihan Hugging Face menghitung 18 untuk AdamW dengan mixed precision (gradien fp32 dan salinan bobot kedua), makalah ZeRO 16, dan angka "lebih dari 780 GB" di makalah QLoRA untuk fine-tuning 16-bit LLaMA 65B sesuai dengan 12, tanpa salinan master; matikan bobot master untuk mereproduksinya. Logit: dengan kosakata Llama 3 sebanyak 128.256 token, logit untuk 2.048 token memakan 2,6 GB, yang dihindari kernel cross-entropy gabungan. Checkpointing: pada Llama 3.1 8B dengan 2.048 token, mematikannya menaikkan aktivasi dari 0,8 menjadi 9,1 GB.

Tidak dimodelkan: buffer sesaat di dalam satu operasi (bobot satu lapisan yang didekuantisasi pada QLoRA, lapisan yang dikumpulkan ZeRO-3), offloading ke CPU dan paged optimizer, model mixture-of-experts, encoder visi, serta pelatihan preferensi seperti DPO yang menyimpan model referensi kedua. Gunakan hasilnya untuk perencanaan, lalu periksa langkah pelatihan pertama dengan torch.cuda.max_memory_allocated().

Contoh

Pengecekan dengan makalah QLoRA. LLaMA 65B memiliki 65,29 miliar parameter, 80 lapisan, dan ukuran hidden 8.192. Dengan QLoRA, adapter bf16 rank 64 di semua lapisan linear seperti di makalah, dan sekuens 512 token: bobot 4-bit memakan 32,38 GB, konstanta kuantisasi 1,03 GB, dan embedding bf16 1,05 GB; 799,5 juta parameter adapter memakan 1,60 GB, gradiennya 1,60 GB, dan state AdamW-nya 6,40 GB; aktivasi dengan checkpointing 0,81 GB dan logit 0,16 GB. Totalnya 45,0 GB tensor, dan 50,8 GB dengan konteks 1,3 GB dan margin 10%. Kartu 48 GB menampung 51,5 miliar byte, jadi satu GPU 48 GB seperti di makalah cukup dengan sisa 0,7 GB; paged optimizer di makalah memberi kelonggaran tambahan dengan memindahkan 6,4 GB state optimizer ke memori CPU ketika GPU kehabisan ruang.

Pengecekan dengan makalah ZeRO. Untuk model 7,5 miliar parameter di 64 GPU, makalah tersebut menyebut 120 GB state model per GPU tanpa sharding, 31,4 GB pada tahap 1, 16,6 GB pada tahap 2, dan 1,88 GB pada tahap 3. Aturan di halaman ini menghasilkan 120; 31,41; 16,64; dan 1,875 GB.

Llama 3.1 8B. LoRA rank 16 di semua lapisan linear (41,9 juta parameter adapter dalam bf16), 2.048 token, micro-batch 1, dan checkpointing: 16,06 GB bobot beku, 0,50 GB untuk adapter beserta gradien dan state optimizer-nya, 0,82 GB aktivasi, dan 2,63 GB logit, total 23,3 GB. Unsloth mencantumkan 22 GB sebagai minimum untuk LoRA 16-bit pada model 8B. Proses yang sama dengan QLoRA butuh 11,9 GB, atau 9,0 GB dengan loss gabungan.

Pertanyaan yang sering diajukan

Berapa VRAM yang dibutuhkan untuk fine-tuning model 7B atau 8B?

Dengan QLoRA, sekitar 9 sampai 12 GB pada 2.048 token dan micro-batch 1: 11,9 GB dengan pengaturan bawaan dan 9,0 GB dengan loss gabungan. Kartu 12 GB (12,9 miliar byte) pas-pasan; 16 GB menyisakan ruang untuk sekuens yang lebih panjang. LoRA 16-bit butuh sekitar 23 GB, jadi kartu 24 GB. Fine-tuning penuh dengan AdamW butuh sekitar 146 GB, artinya beberapa GPU dengan ZeRO atau FSDP. Sekuens yang lebih panjang dan batch yang lebih besar menambah memori aktivasi; kalkulator menunjukkan berapa banyak.

Apa beda kebutuhan memori LoRA dan QLoRA?

Keduanya melatih adapter kecil yang sama; bedanya ada di model dasar yang dibekukan. LoRA menyimpannya dalam bf16 dengan 2 byte per parameter, QLoRA dalam NF4 4-bit dengan sekitar 0,52 byte. Untuk Llama 3.1 8B itu berarti 16,1 GB berbanding 5,7 GB, sudah termasuk embedding bf16. QLoRA berlatih sedikit lebih lambat karena setiap lapisan didekuantisasi saat itu juga.

Mengapa fine-tuning penuh butuh 16 byte per parameter?

Pelatihan mixed precision menghitung dalam bf16 (2 byte bobot dan 2 byte gradien per parameter), tetapi memperbarui salinan master fp32 (4 byte), dan AdamW menyimpan dua statistik fp32 per parameter, yaitu momentum dan varians (8 byte). Karena itu model 8B butuh sekitar 128 GB sebelum aktivasi. AdamW 8-bit menurunkannya menjadi 10 byte per parameter, dan ZeRO atau FSDP membagi totalnya ke semua GPU.

Apakah gradient checkpointing menghemat memori?

Ya, untuk memori aktivasi. Pada Llama 3.1 8B dengan 2.048 token, aktivasi turun dari 9,1 menjadi 0,8 GB, karena hanya input setiap lapisan yang disimpan dan sisanya dihitung ulang saat backward pass. Harganya satu forward pass tambahan: Korthikanti et al. mengukur waktu pelatihan hingga 30 sampai 40% lebih lama.

Bagaimana membagi fine-tuning ke beberapa GPU?

Dengan DeepSpeed ZeRO atau PyTorch FSDP. Tahap 1 membagi state optimizer, tahap 2 juga gradien, dan tahap 3 (full sharding di FSDP) juga bobot. Fine-tuning penuh Llama 3.1 8B di delapan GPU pada tahap 3 butuh sekitar 22,8 GB per GPU. Aktivasi tidak dibagi: setiap GPU memproses micro-batch-nya sendiri. Masukkan jumlah GPU untuk melihat memori yang dibutuhkan tiap GPU.

Sumber

Tautan dengan nilai Anda

Tambahkan parameter ini ke alamat halaman agar halaman terbuka dengan nilai yang sudah terisi, misalnya untuk membagikan perhitungan atau menautkannya dari asisten AI. Hasil dihitung di browser: HTML halaman menampilkan contoh untuk nilai bawaan, dan alat ini menetapkan atribut data-url-params setelah nilai dari tautan diterapkan.

ParameterNilaiJika tidak diisi
methodMetodesalah satu dari: full, lora, qlorabawaan: qlora
architectureModel kustomsalah satu dari: preset, custombawaan: preset
modelModelsalah satu dari: llama3.2-1b, llama3.2-3b, qwen3-4b, mistral-7b-v0.3, qwen2.5-7b, llama3.1-8b, qwen3-8b, phi-4, qwen3-14b, qwen3-32b, llama3.3-70b, llama-2-7b, llama-7b, llama-65b; dipakai saat architecture = presetbawaan: llama3.1-8b
parameters_billionsParameterangka; diizinkan 0.01–2000; dipakai saat architecture = customwajib
layersLapisanbilangan bulat; diizinkan 1–512; dipakai saat architecture = customwajib
hidden_sizeUkuran hidden (hidden size)bilangan bulat; diizinkan 64–65536; dipakai saat architecture = customwajib
vocabulary_sizeUkuran kosakatabilangan bulat; diizinkan 1–2000000; dipakai saat architecture = customwajib
tied_embeddingsEmbedding bersama (tie_word_embeddings)true atau false; dipakai saat architecture = custombawaan: false
optimizerOptimizersalah satu dari: adamw, adamw_8bit, sgdbawaan: adamw
master_weightsSimpan salinan master bobot dalam fp32true atau false; dipakai saat method = fullbawaan: true
lora_rankRank LoRA (r)bilangan bulat; diizinkan 1–1024; dipakai saat method = lora, qlorabawaan: 16
lora_targetsModul target LoRAsalah satu dari: qv, attention, all; dipakai saat method = lora, qlorabawaan: all
adapter_precisionBobot adaptersalah satu dari: fp32, bf16; dipakai saat method = lora, qlorabawaan: bf16
sequence_lengthPanjang sekuens (token)bilangan bulat; diizinkan 1–1048576bawaan: 2048
batch_sizeMicro-batch per GPUbilangan bulat; diizinkan 1–1024bawaan: 1
gradient_checkpointingGradient checkpointingtrue atau falsebawaan: true
fused_lossKernel cross-entropy gabungan (Liger, Unsloth)true atau falsebawaan: false
gpu_countJumlah GPUbilangan bulat; diizinkan 1–1024bawaan: 1
zero_stageSharding (tahap ZeRO)salah satu dari: 0, 1, 2, 3bawaan: 0

Contoh

  • ?method=qlora&model=llama-65b&lora_rank=64&adapter_precision=bf16&sequence_length=512
  • ?method=lora&model=llama3.1-8b&lora_rank=16&lora_targets=all&sequence_length=2048&batch_size=1
  • ?method=full&model=llama3.1-8b&gpu_count=8&zero_stage=3
  • ?method=qlora&architecture=custom&parameters_billions=12&layers=48&hidden_size=3840&vocabulary_size=262144&tied_embeddings=true

Tulis desimal dengan titik. Kodekan spasi sebagai %20, + sebagai %2B, # sebagai %23, dan & sebagai %26.

Elemen hasil: [data-result-block="fine-tuning-vram"]