Ü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 bekommt 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, 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 Byte bei Sequenzlänge , Micro-Batch und Hidden Size (Korthikanti et al., 2022); FlashAttention streicht den Term der Attention-Matrix. Gradient Checkpointing behält nur die Eingabe jeder Schicht, , 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 für die Gewichte, für die Gradienten, für Optimizer-Zustände und Masterkopie, für die Aktivierungen und für die Logits, dazu 1,3 GB für den CUDA-Kontext und 10 % Reserve:
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
- 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
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.
| Parameter | Wert | Wenn nicht angegeben |
|---|---|---|
methodMethode | einer von: full, lora, qlora | Standard: qlora |
architectureEigenes Modell | einer von: preset, custom | Standard: preset |
modelModell | einer 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 = preset | Standard: llama3.1-8b |
parameters_billionsParameter | Zahl; erlaubt 0.01–2000; verwendet bei architecture = custom | erforderlich |
layersSchichten | ganze Zahl; erlaubt 1–512; verwendet bei architecture = custom | erforderlich |
hidden_sizeHidden Size | ganze Zahl; erlaubt 64–65536; verwendet bei architecture = custom | erforderlich |
vocabulary_sizeVokabulargröße | ganze Zahl; erlaubt 1–2000000; verwendet bei architecture = custom | erforderlich |
tied_embeddingsGeteilte Embeddings (tie_word_embeddings) | true oder false; verwendet bei architecture = custom | Standard: false |
optimizerOptimizer | einer von: adamw, adamw_8bit, sgd | Standard: adamw |
master_weightsfp32-Masterkopie der Gewichte behalten | true oder false; verwendet bei method = full | Standard: true |
lora_rankLoRA-Rang (r) | ganze Zahl; erlaubt 1–1024; verwendet bei method = lora, qlora | Standard: 16 |
lora_targetsLoRA-Zielmodule | einer von: qv, attention, all; verwendet bei method = lora, qlora | Standard: all |
adapter_precisionAdapter-Gewichte | einer von: fp32, bf16; verwendet bei method = lora, qlora | Standard: bf16 |
sequence_lengthSequenzlänge (Token) | ganze Zahl; erlaubt 1–1048576 | Standard: 2048 |
batch_sizeMicro-Batch pro GPU | ganze Zahl; erlaubt 1–1024 | Standard: 1 |
gradient_checkpointingGradient Checkpointing | true oder false | Standard: true |
fused_lossFusionierter Cross-Entropy-Kernel (Liger, Unsloth) | true oder false | Standard: false |
gpu_countAnzahl GPUs | ganze Zahl; erlaubt 1–1024 | Standard: 1 |
zero_stageSharding (ZeRO-Stufe) | einer von: 0, 1, 2, 3 | Standard: 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¶meters_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"]