VRAM-Rechner für Fine-Tuning (LoRA, QLoRA, Full)

Ergebnisse anzeigen · 11,9 GB

Trainings-Setup

Methode

Die eingefrorene Basis liegt in 4-Bit-NF4 mit doppelter Quantisierung; trainiert werden nur die Adapter.

LoRA-Zielmodule
Adapter-Gewichte

PEFT legt die Adapter-Gewichte in fp32 an; der SFTTrainer von TRL wandelt sie in bf16 um, wenn das Basismodell quantisiert ist (QLoRA). Wähle fp32 für reines PEFT.

Optimizer

Geschätzter GPU-Speicher

VRAM gesamt
Trainierbare Parameter
41,94 Mio. (0,52 %)
Gewichte, Gradienten, Optimizer
6,2 GB
Aktivierungen
0,8 GB

Kleinste passende GPU der Liste: RTX 3060 12GB (12 GB), mit 1,0 GB Reserve.

Ohne Gradient Checkpointing: 21,1 GB.

Modell: 8.030.261.248 Parameter, 32 Schichten, Hidden Size 4.096, Vokabular 128.256.

PEFTs prepare_model_for_kbit_training wandelt Embeddings und Ausgabeschicht in fp32 um: Rechne 2,1 GB dazu, wenn dein Skript es aufruft.

Eine Schätzung, keine Messung: Der Speicher für Aktivierungen hängt vom Framework und seinen Kernels ab. Modelldaten und GPU-Liste geprüft am 2026-10-24.

Speicher im Detail

Speicher im Detail
PostenRegelSpeicherAnteil
Eingefrorene Basisgewichte (4-Bit-NF4)0.5 B×Ψlin0.5\,\text{B} \times \Psi_{\text{lin}}3,49 GB29,3 %
Quantisierungskonstanten0.127 bit×Ψlin0.127\,\text{bit} \times \Psi_{\text{lin}}0,11 GB0,93 %
Embeddings und Ausgabeschicht (bf16)2 B×Ψemb2\,\text{B} \times \Psi_{\text{emb}}2,10 GB17,6 %
LoRA-Adaptergewichte2 B×ΨLoRA2\,\text{B} \times \Psi_{\text{LoRA}}0,08 GB0,7 %
Adapter-Gradienten2 B×ΨLoRA2\,\text{B} \times \Psi_{\text{LoRA}}0,08 GB0,7 %
Optimizer-Zustände (Adapter)8 B×ΨLoRA8\,\text{B} \times \Psi_{\text{LoRA}}0,34 GB2,8 %
Aktivierungen (mit Checkpointing)2sbhL+34sbh2sbhL + 34sbh0,82 GB6,9 %
Ausgabe-Logits für den Loss10 B×sbV10\,\text{B} \times sbV2,63 GB22 %
CUDA-Kontext und Kernels1.3 GB1.3\,\text{GB}1,30 GB10,9 %
Sicherheitsreserve10 %10\,\%0,97 GB8,1 %
VRAM gesamt11,92 GB100 %

Ψ\Psi ist die Zahl der Parameter, Ψlin\Psi_{\text{lin}} die in linearen Schichten, Ψemb\Psi_{\text{emb}} die der Embeddings und der Ausgabeschicht und ΨLoRA\Psi_{\text{LoRA}} die der Adapter; ss ist die Sequenzlänge, bb der Micro-Batch, hh die Hidden Size, LL die Zahl der Schichten, VV das Vokabular und NN die Zahl der GPUs. B steht für Byte; GB für eine Milliarde Byte.

Auf welche GPUs es passt

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

Nennspeicher laut Datenblättern der Hersteller. Die Hersteller rechnen in binären Gigabyte, eine 24-GB-Karte fasst also 25,8 Mrd. Byte (in Klammern); damit wird verglichen, denn der CUDA-Kontext steckt schon in der Summe. Für die MI50 gibt es kein CUDA-Build von bitsandbytes (QLoRA, 8-Bit-AdamW); V100 und Pascal-Karten (P40, P100) haben kein bf16, in fp16 ist der Speicherbedarf gleich.

Über dieses Tool

Fine-Tuning eines Sprachmodells braucht weit mehr GPU-Speicher als das Ausführen. Neben den Gewichten hält die GPU Gradienten, Optimizer-Zustände und die Aktivierungen jeder Schicht bis zum Backward Pass. Dieser Rechner addiert diese Posten für volles Fine-Tuning, LoRA und QLoRA, für ein Modell aus der Liste oder ein selbst beschriebenes, und zeigt, auf welchen gängigen GPUs das Ergebnis Platz hat.

Jeder Posten steht mit seiner Regel und Quelle da, denn Fine-Tuning-Rechner liegen oft um den Faktor zwei auseinander: Einer rechnet 18 Byte pro Parameter, ein anderer 12, einer vergisst die Logits, ein anderer setzt Checkpointing stillschweigend voraus. Hier ist jede Annahme eine Einstellung, die du sehen und ändern kannst.

So wird der Speicher geschätzt

Volles Fine-Tuning mit Mixed Precision hält pro Parameter 2 Byte bf16-Gewichte, 2 Byte Gradienten, eine 4 Byte große fp32-Masterkopie und 8 Byte AdamW-Momentum und -Varianz: 16 Byte, die Rechnung aus dem ZeRO-Paper (Rajbhandari et al., 2020). 8-Bit-AdamW speichert 2 Byte Optimizer-Zustand statt 8, SGD mit Momentum 4. Die ZeRO-Stufen 1, 2 und 3 verteilen erst die Optimizer-Zustände, dann die Gradienten, dann die Gewichte auf die GPUs.

LoRA friert das Basismodell mit 2 Byte pro Parameter ein und trainiert neben jedem angepassten Gewicht zwei kleine Matrizen: Ein Gewicht der Größe d×kd \times k bekommt r(d+k)r(d + k) Adapter-Parameter (Hu et al., 2021). Nur sie haben Gradienten und Optimizer-Zustände: PEFT legt sie in fp32 an (mit AdamW 16 Byte je Parameter), der SFTTrainer von TRL wandelt sie bei quantisierten Modellen in bf16 um (12 Byte). QLoRA speichert die eingefrorenen linearen Schichten in 4-Bit-NormalFloat mit doppelter Quantisierung, 4+8/64+32/(64⋅256)≈4,1274 + 8/64 + 32/(64 \cdot 256) \approx 4{,}127 Bit pro Parameter (Dettmers et al., 2023), während Embeddings und Ausgabeschicht in bf16 bleiben.

Die Aktivierungen hängen von den Daten ab. Jede Schicht speichert etwa 34 sbh34\,sbh Byte bei Sequenzlänge ss, Micro-Batch bb und Hidden Size hh (Korthikanti et al., 2022); FlashAttention streicht den Term der Attention-Matrix. Gradient Checkpointing behält nur die Eingabe jeder Schicht, 2 sbh2\,sbh, und berechnet jeweils eine Schicht neu. Der Loss kostet für die Logits rund 10 Byte pro Token und Vokabulareintrag, wenn kein fusionierter Kernel sie stückweise berechnet. Mit WW für die Gewichte, GG für die Gradienten, OO für Optimizer-Zustände und Masterkopie, AA für die Aktivierungen und Λ\Lambda für die Logits, dazu 1,3 GB für den CUDA-Kontext und 10 % Reserve:

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

Warum Fine-Tuning-Rechner voneinander abweichen und was fehlt

Drei Annahmen erklären den Großteil der Abweichungen, und jede ist hier eine Einstellung. Byte pro Parameter: Der Trainingsleitfaden von Hugging Face rechnet 18 für AdamW mit Mixed Precision (fp32-Gradienten und eine zweite Kopie der Gewichte), das ZeRO-Paper 16, und die „mehr als 780 GB“ aus dem QLoRA-Paper für 16-Bit-Fine-Tuning von LLaMA 65B entsprechen 12, ohne Masterkopie; schalte die Mastergewichte aus, um das nachzurechnen. Logits: Mit dem Vokabular von Llama 3 aus 128.256 Token belegen die Logits für 2.048 Token 2,6 GB, was fusionierte Cross-Entropy-Kernels vermeiden. Checkpointing: Bei Llama 3.1 8B mit 2.048 Token steigen die Aktivierungen ohne Checkpointing von 0,8 auf 9,1 GB.

Nicht modelliert: kurzlebige Puffer innerhalb einer Operation (das dequantisierte Gewicht einer Schicht bei QLoRA, die Schicht, die ZeRO-3 einsammelt), Auslagern in den CPU-Speicher und Paged Optimizer, Mixture-of-Experts-Modelle, Vision-Encoder und Präferenztraining wie DPO, das ein zweites Referenzmodell hält. Nutze das Ergebnis zur Planung und prüfe die ersten Trainingsschritte mit torch.cuda.max_memory_allocated().

Beispiel

Abgleich mit dem QLoRA-Paper. LLaMA 65B hat 65,29 Mrd. Parameter, 80 Schichten und eine Hidden Size von 8.192. Mit QLoRA, bf16-Adaptern vom Rang 64 auf allen linearen Schichten wie im Paper und Sequenzen von 512 Token: Die 4-Bit-Gewichte belegen 32,38 GB, die Quantisierungskonstanten 1,03 GB und die bf16-Embeddings 1,05 GB; die 799,5 Mio. Adapter-Parameter belegen 1,60 GB, ihre Gradienten 1,60 GB und ihre AdamW-Zustände 6,40 GB; Aktivierungen mit Checkpointing 0,81 GB und Logits 0,16 GB. Das sind 45,0 GB Tensoren, mit 1,3 GB Kontext und 10 % Reserve 50,8 GB. Eine 48-GB-Karte fasst 51,5 Mrd. Byte, die eine 48-GB-GPU aus dem Paper reicht also mit 0,7 GB Reserve; die Paged Optimizer des Papers schaffen weiteren Spielraum, indem sie die 6,4 GB Optimizer-Zustände in den CPU-Speicher auslagern, wenn der GPU der Platz ausgeht.

Abgleich mit dem ZeRO-Paper. Für ein Modell mit 7,5 Mrd. Parametern auf 64 GPUs nennt das Paper 120 GB Modellzustände pro GPU ohne Sharding, 31,4 GB bei Stufe 1, 16,6 GB bei Stufe 2 und 1,88 GB bei Stufe 3. Die Regeln dieser Seite ergeben 120; 31,41; 16,64 und 1,875 GB.

Llama 3.1 8B. LoRA mit Rang 16 auf allen linearen Schichten (41,9 Mio. Adapter-Parameter in bf16), 2.048 Token, Micro-Batch 1 und Checkpointing: 16,06 GB eingefrorene Gewichte, 0,50 GB für die Adapter samt Gradienten und Optimizer-Zuständen, 0,82 GB Aktivierungen und 2,63 GB Logits, zusammen 23,3 GB. Unsloth nennt 22 GB als Minimum für 16-Bit-LoRA bei einem 8B-Modell. Derselbe Lauf mit QLoRA braucht 11,9 GB, mit fusioniertem Loss 9,0 GB.

Häufig gestellte Fragen

Wie viel VRAM brauche ich für das Fine-Tuning eines 7B- oder 8B-Modells?

Mit QLoRA etwa 9 bis 12 GB bei 2.048 Token und Micro-Batch 1: 11,9 GB mit den Standardeinstellungen und 9,0 GB mit fusioniertem Loss. Eine 12-GB-Karte (12,9 Mrd. Byte) reicht knapp; 16 GB lassen Platz für längere Sequenzen. 16-Bit-LoRA braucht rund 23 GB, also eine 24-GB-Karte. Volles Fine-Tuning mit AdamW braucht etwa 146 GB, also mehrere GPUs mit ZeRO oder FSDP. Längere Sequenzen und größere Batches kosten zusätzlichen Speicher für Aktivierungen; der Rechner zeigt, wie viel.

Was ist beim Speicher der Unterschied zwischen LoRA und QLoRA?

Beide trainieren dieselben kleinen Adapter; der Unterschied liegt im eingefrorenen Basismodell. LoRA hält es in bf16 mit 2 Byte pro Parameter, QLoRA in 4-Bit-NF4 mit etwa 0,52 Byte. Bei Llama 3.1 8B sind das 16,1 GB gegenüber 5,7 GB, die bf16-Embeddings eingerechnet. QLoRA trainiert etwas langsamer, weil jede Schicht im Lauf dequantisiert wird.

Warum braucht volles Fine-Tuning 16 Byte pro Parameter?

Training mit Mixed Precision rechnet in bf16 (je 2 Byte Gewichte und Gradienten pro Parameter), aktualisiert aber eine fp32-Masterkopie (4 Byte), und AdamW führt pro Parameter zwei fp32-Statistiken, Momentum und Varianz (8 Byte). Ein 8B-Modell braucht deshalb schon vor den Aktivierungen etwa 128 GB. 8-Bit-AdamW senkt das auf 10 Byte pro Parameter, ZeRO oder FSDP verteilen die Summe auf die GPUs.

Spart Gradient Checkpointing Speicher?

Ja, beim Speicher für Aktivierungen. Bei Llama 3.1 8B mit 2.048 Token sinken die Aktivierungen von 9,1 auf 0,8 GB, weil nur die Eingabe jeder Schicht behalten und der Rest im Backward Pass neu berechnet wird. Der Preis ist ein zusätzlicher Forward Pass: Korthikanti et al. maßen bis zu 30 bis 40 % mehr Trainingszeit.

Wie verteile ich das Fine-Tuning auf mehrere GPUs?

Mit DeepSpeed ZeRO oder PyTorch FSDP. Stufe 1 verteilt die Optimizer-Zustände, Stufe 2 zusätzlich die Gradienten und Stufe 3 (volles Sharding in FSDP) auch die Gewichte. Volles Fine-Tuning von Llama 3.1 8B auf acht GPUs mit Stufe 3 braucht etwa 22,8 GB pro GPU. Aktivierungen werden nicht verteilt: Jede GPU verarbeitet ihren eigenen Micro-Batch. Gib die Zahl der GPUs ein, um den Speicher pro GPU zu sehen.

Quellen

Link mit deinen Werten

Hänge diese Parameter an die Adresse dieser Seite an, um sie mit bereits ausgefüllten Werten zu öffnen, etwa um eine Berechnung zu teilen oder aus einem KI-Assistenten darauf zu verlinken. Das Ergebnis wird im Browser berechnet: Das HTML der Seite zeigt ein Beispiel mit den Standardwerten, und das Tool setzt das Attribut data-url-params, sobald die Werte aus dem Link übernommen sind.

ParameterWertWenn nicht angegeben
methodMethodeeiner von: full, lora, qloraStandard: qlora
architectureEigenes Modelleiner von: preset, customStandard: preset
modelModelleiner von: 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; verwendet bei architecture = presetStandard: llama3.1-8b
parameters_billionsParameterZahl; erlaubt 0.01–2000; verwendet bei architecture = customerforderlich
layersSchichtenganze Zahl; erlaubt 1–512; verwendet bei architecture = customerforderlich
hidden_sizeHidden Sizeganze Zahl; erlaubt 64–65536; verwendet bei architecture = customerforderlich
vocabulary_sizeVokabulargrößeganze Zahl; erlaubt 1–2000000; verwendet bei architecture = customerforderlich
tied_embeddingsGeteilte Embeddings (tie_word_embeddings)true oder false; verwendet bei architecture = customStandard: false
optimizerOptimizereiner von: adamw, adamw_8bit, sgdStandard: adamw
master_weightsfp32-Masterkopie der Gewichte behaltentrue oder false; verwendet bei method = fullStandard: true
lora_rankLoRA-Rang (r)ganze Zahl; erlaubt 1–1024; verwendet bei method = lora, qloraStandard: 16
lora_targetsLoRA-Zielmoduleeiner von: qv, attention, all; verwendet bei method = lora, qloraStandard: all
adapter_precisionAdapter-Gewichteeiner von: fp32, bf16; verwendet bei method = lora, qloraStandard: bf16
sequence_lengthSequenzlänge (Token)ganze Zahl; erlaubt 1–1048576Standard: 2048
batch_sizeMicro-Batch pro GPUganze Zahl; erlaubt 1–1024Standard: 1
gradient_checkpointingGradient Checkpointingtrue oder falseStandard: true
fused_lossFusionierter Cross-Entropy-Kernel (Liger, Unsloth)true oder falseStandard: false
gpu_countAnzahl GPUsganze Zahl; erlaubt 1–1024Standard: 1
zero_stageSharding (ZeRO-Stufe)einer von: 0, 1, 2, 3Standard: 0

Beispiele

  • ?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

Schreibe Dezimalzahlen mit Punkt. Kodiere ein Leerzeichen als %20, + als %2B, # als %23 und & als %26.

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