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 mendapat 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, bit per parameter (Dettmers et al., 2023), sedangkan embedding dan lapisan output tetap dalam bf16.
Aktivasi bergantung pada data. Setiap lapisan menyimpan sekitar byte untuk panjang sekuens , micro-batch , dan ukuran hidden (Korthikanti et al., 2022); FlashAttention menghapus suku matriks attention. Gradient checkpointing hanya menyimpan input setiap lapisan, , 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 bobot, gradien, state optimizer dan salinan master, aktivasi, dan logit, ditambah 1,3 GB untuk konteks CUDA dan margin 10%:
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
- Rajbhandari et al. (2020), ZeRO: Memory Optimizations Toward Training Trillion Parameter Models
- Hu et al. (2021), LoRA: Low-Rank Adaptation of Large Language Models
- Dettmers et al. (2023), QLoRA: Efficient Finetuning of Quantized LLMs
- Korthikanti et al. (2022), Reducing Activation Recomputation in Large Transformer Models
- Hugging Face Transformers: GPU memory usage in training
- Hugging Face PEFT: LoRA developer guide
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.
| Parameter | Nilai | Jika tidak diisi |
|---|---|---|
methodMetode | salah satu dari: full, lora, qlora | bawaan: qlora |
architectureModel kustom | salah satu dari: preset, custom | bawaan: preset |
modelModel | salah 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 = preset | bawaan: llama3.1-8b |
parameters_billionsParameter | angka; diizinkan 0.01–2000; dipakai saat architecture = custom | wajib |
layersLapisan | bilangan bulat; diizinkan 1–512; dipakai saat architecture = custom | wajib |
hidden_sizeUkuran hidden (hidden size) | bilangan bulat; diizinkan 64–65536; dipakai saat architecture = custom | wajib |
vocabulary_sizeUkuran kosakata | bilangan bulat; diizinkan 1–2000000; dipakai saat architecture = custom | wajib |
tied_embeddingsEmbedding bersama (tie_word_embeddings) | true atau false; dipakai saat architecture = custom | bawaan: false |
optimizerOptimizer | salah satu dari: adamw, adamw_8bit, sgd | bawaan: adamw |
master_weightsSimpan salinan master bobot dalam fp32 | true atau false; dipakai saat method = full | bawaan: true |
lora_rankRank LoRA (r) | bilangan bulat; diizinkan 1–1024; dipakai saat method = lora, qlora | bawaan: 16 |
lora_targetsModul target LoRA | salah satu dari: qv, attention, all; dipakai saat method = lora, qlora | bawaan: all |
adapter_precisionBobot adapter | salah satu dari: fp32, bf16; dipakai saat method = lora, qlora | bawaan: bf16 |
sequence_lengthPanjang sekuens (token) | bilangan bulat; diizinkan 1–1048576 | bawaan: 2048 |
batch_sizeMicro-batch per GPU | bilangan bulat; diizinkan 1–1024 | bawaan: 1 |
gradient_checkpointingGradient checkpointing | true atau false | bawaan: true |
fused_lossKernel cross-entropy gabungan (Liger, Unsloth) | true atau false | bawaan: false |
gpu_countJumlah GPU | bilangan bulat; diizinkan 1–1024 | bawaan: 1 |
zero_stageSharding (tahap ZeRO) | salah satu dari: 0, 1, 2, 3 | bawaan: 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¶meters_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"]