Zum Inhalt springen
Kurzer Hinweis: flozi00 TechHub ist ein Solo-Nebenprojekt neben einem Vollzeitjob — persönliche Lernnotizen, keine offiziellen Aussagen. Kritische Schritte selbst prüfen.

LoRA- und QLoRA-Finetuning: die echte Speicher-Mathematik

Warum Training bis zum 8-fachen der Inference-VRAM braucht: das exakte Byte-Budget von AdamW pro Parameter, LoRAs 2r(d_in+d_out)-Adapter-Mathematik, QLoRAs NF4-Bit-Bilanz mit Double Quantization, Aktivierungsspeicher mit Checkpointing und eine berechnete Tabelle Modellgröße × Methode → GPU — alles aus den LoRA-, QLoRA- und ZeRO-Papieren belegt.

11 Min. Lesezeitflozi00
aimachine-learninggpugpu-memoryfine-tuningdeep-learning

„Finetune eines 32B-Modells auf einer GPU“-Threads nutzen die Inference-Zahl und ziehen stillschweigend nichts davon ab. Realität: Training hält Gradienten und Optimizer-Status für jeden trainierbaren Parameter vor, und unter gemischter Präzision mit AdamW beträgt dieses Budget 16 Bytes pro Parameter — das Achtfache der 2 Bytes, die ein bf16-Gewicht bei der Inference kostet. Dieser Leitfaden leitet dieses Budget Term für Term her und geht dann die beiden Standard-Fluchtwege (LoRAs Rank-Zerlegung, QLoRAs 4-Bit-Basis) mit durchgerechneten Zahlen für ein reales Modell durch: Qwen3-32B, 32.762.123.264 Parameter (Anzahl verifiziert gegen die Hugging-Face-Safetensors-Metadaten von Qwen/Qwen3-32B; Konfiguration: 64 Schichten, Hidden Size 5.120, 64 Attention-Heads / 8 KV-Heads, Head-Dim 128, FFN 25.600, ungeteilte 151.936-Token-Embeddings) 1. Bei der Inference braucht dieses Modell allein für die bf16-Gewichte 65,5 GB. Der Leitfaden verzahnt sich mit unserem VRAM-Rechner-Leitfaden und dem Quantisierungs-Leitfaden; das Pendant auf der Serving-Seite ist der KV-Cache-Leitfaden.

Warum Training nicht Inference ist

TermBytes/ParameterBei Inference vorhanden?
bf16/fp16-Gewicht2ja
bf16/fp16-Gradient2nein
fp32-Master-Gewicht4nein
fp32-Adam-Momentum (m)4nein
fp32-Adam-Varianz (v)4nein
Trainings-Summe16—

Die Buchhaltung stammt aus dem ZeRO-Paper (arXiv:1910.02054, Abschn. 3.1) 2 — Gemischtes-Präzisions-Training hält eine 2-Byte-fp16/bf16-Parameterkopie und eine 2-Byte-Gradientenkopie, während der Optimizer eine fp32-Kopie der Parameter plus fp32-Momentum und -Varianz vorhält — 4+4+4 Bytes —, insgesamt 2Ψ + 2Ψ + 12Ψ = 16Ψ Bytes für ein Modell mit Ψ Parametern. Diese 14 von 16 Bytes entfallen auf trainierbare Parameter: PyTorches Mixed-Precision-Rezept und die DeepSpeed-Dokumentation halten Gradienten und fp32-Master-/Optimizer-Status ausschließlich für Parameter mit requires_grad=True vor.

Qwen3-32B, volles Finetuning, AdamW gemischt. Modell-Status = 32.762.123.264 × 16 B = 524,2 GB (488,2 GiB) — vor Aktivierungen, Embedding-Gradienten-Buffern oder dem CUDA-Kontext. Dasselbe Modell servt in 65,5 GB. Dieser 8×-Faktor ist die gesamte Geschichte dieses Leitfadens. (ZeRO/FSDP-Sharding und Offloading können die 524 GB über GPUs und Host-RAM verteilen — die Bytes verschwinden nicht, sie wandern.)

LoRA: die 99 % einfrieren, ein niedrigrangiges Delta trainieren

LoRA (arXiv:2106.09685) friert die vortrainierten Gewichte ein und lernt eine Aktualisierung als Produkt zweier kleiner Matrizen — für jede adaptierte Gewichtsmatrix WW berechnet der Forward-Pass Wx+αrBAxW x + \frac{\alpha}{r} B A x, mit A∈Rr×dinA \in \mathbb{R}^{r \times d_{\text{in}}}, B∈Rdout×rB \in \mathbb{R}^{d_{\text{out}} \times r}, BB mit Null initialisiert. Das trainierbare Delta ΔW=BA\Delta W = BA hat exakt:

NLoRA=2 r (din+dout)N_{\text{LoRA}} = 2 \, r \, (d_{\text{in}} + d_{\text{out}})

Parameter pro adaptierter Matrix — Rank 8 fügt einem einzelnen Qwen3-q_proj 2⋅8⋅(5.120+8.192)=212.9922 \cdot 8 \cdot (5.120 + 8.192) = 212.992 Parameter hinzu, gegenüber 41.943.040 eingefrorenen (0,51 %). Auf alle sieben linearen Matrizen pro Schicht angewendet (q, k, v, o, gate, up, down) trägt eine Qwen3-32B-Schicht 2r×131.0722r \times 131.072 Adapter-Parameter:

Rank rTrainierbare Parameter (all-linear)% von 32,76 Mrd.Optimizer+Gradient-Status (16 B/Parameter)Eingefrorene bf16-BasisModell-Status gesamtvs. volles Finetuning
8134.217.7280,410 %2,00 GB65,5 GB67,5 GB12,9 %
16268.435.4560,819 %4,00 GB65,5 GB69,5 GB13,3 %
641.073.741.8243,277 %16,0 GB65,5 GB81,5 GB15,8 %

Voller Finetuning-Modell-Status zur Referenz: 524,2 GB (16 B × 32,76 Mrd. Parameter). „Optimizer+Gradient-Status" umfasst die bf16-Adapter-Gewichte selbst plus ihre bf16-Gradienten und fp32 m/v/Master — also dasselbe 16-B/Parameter-Budget aus Abschnitt 1, angewandt nur auf die trainierbaren 0,4–3,3 %.

Warum die Zahl so hart einbricht: Gradienten, fp32-Master-Kopien und Adams m/v existieren nur für trainierbare Parameter. Friert man 99,2 % des Modells ein, verdunsten 99,2 % der 524 GB — die eingefrorene Basis trägt nur ihre 2 B/Parameter Forward-Gewichte bei. Die GPT-3-175B-Zahlen des LoRA-Papers 3 zeigen denselben Effekt in größerem Maßstab: 4,7 Mio. trainierbare Gewichte gegenüber 175 Mrd. eingefrorenen, 350 GB VRAM gegenüber rund 1,2 TB und ein Checkpoint von 35 MB gegenüber 350 GB — eine 10.000-fache Reduktion der trainierbaren Parameter und (laut Abstract des Papers) eine 3-fache Ersparnis gegenüber dem vollen Adam-Finetuning.

Zwei ehrliche Einschränkungen. Erstens wird die Gesamt-Ersparnis durch die eingefrorene Basis nach unten begrenzt: LoRA mit r=16 braucht weiterhin die vollen 65,5 GB bf16-Gewichte — LoRA kauft Ihnen auf 70B-Skala „passt auf eine A100/H100 mit 80 GB", nicht „passt auf Ihren Laptop". Zweitens nimmt die 16 B/Parameter die vollständigen fp32-Adam-States an; 8-Bit-Adam-Varianten (bitsandbytes) reduzieren die 12 Optimizer-Bytes auf ~4 — vor allem relevant, wenn der trainierbare Anteil groß ist.

QLoRA: 4-Bit-Basis, dieselbe Optimizer-Mathematik

QLoRA (arXiv:2305.14314) entfernt LoRAs Boden — die 2 B/Parameter der eingefrorenen Basis — indem die eingefrorenen Gewichte in 4-Bit NormalFloat (NF4) mit blockweisen Skalen gespeichert werden. Die Bilanz des Papers, Blockgröße 64:

bNF4+DQ=4+864⏟FP8-quantisierte Skalen+3264⋅256⏟Skalen zweiter Stufe=4,127 Bit/Parameterb_{\text{NF4+DQ}} = 4 + \underbrace{\frac{8}{64}}_{\text{FP8-quantisierte Skalen}} + \underbrace{\frac{32}{64 \cdot 256}}_{\text{Skalen zweiter Stufe}} = 4{,}127 \ \text{Bit/Parameter}

Ohne Double Quantization kosten die blockweisen Skalen 32/64 = 0,5 Bit/Parameter — für ein 65B-Modell sind das ~0,4 GB fp32-Konstanten pro gespeichertem Gewichts-Bit. Double Quantization (die Konstanten erster Stufe selbst mit Blockgröße 256 zu FP8 quantisieren) reduziert das auf 8/64 + 32/16.384 = 0,127 Bit/Parameter — „a reduction of 0.373 bits per parameter" laut der exakten Zahl des Papers, rund 3 GB Ersparnis bei einem 65B-Modell. Paged Optimizer, QLoRAs dritte Komponente, verkleinern den stationären Speicher nicht: Sie nutzen NVIDIA Unified Memory, um Optimizer-Status während der transienten Speicherspitze auf die CPU auszulagern, die Checkpointing bei langen Sequenzen verursacht.

Qwen3-32B in QLoRA (NF4 + DQ, LoRA r=16 all-linear, Batch 4 × 2.048 Tokens, Checkpointing an):

  • Basisgewichte: 32.762.123.264 × 4,127 Bit / 8 = 16,9 GB (statt 65,5 GB bf16 — ein 3,9-facher Schnitt bei der eingefrorenen Basis)
  • Trainierbarer Adapter-Status: 268.435.456 × 16 B = 4,0 GB (identisches Budget wie bei LoRA — QLoRA quantisiert nur den eingefrorenen Teil)
  • Aktivierungen mit Checkpointing: ≈ 0,7 GB (nächster Abschnitt)
  • Peak-Modell-Status gesamt: ≈ 21,9 GB — eine 24-GB-Karte (RTX 3090/4090-Klasse) trainiert ein 32B-Modell. Auf dieselbe Karte passen die Inference-Gewichte von Qwen3-32B (65,5 GB) erst nach Quantisierung auf ~4 Bit.

Mit paged 8-Bit AdamW (bitsandbytes paged_adamw_8bit) sinkt der Adapter-Status von 4,0 GB Richtung 4,0 × (6/16) ≈ 1,5 GB — hier klein, bei r=256 auf einem 70B-Modell entscheidend.

Aktivierungsspeicher und der Checkpointing-Handel

Der Modell-Status ist das Fundament; Aktivierungen skalieren mit Tokens, nicht mit Parametern. Nach der Aktivierungsspeicher-Herleitung von Korthikanti et al. (arXiv:2205.05198) 4, dem Megatron-LM-Paper zum selektiven Recompute, braucht eine Transformerschicht ohne materialisierte Attention-Matrix (FlashAttention) ≈ 34·s·b·h Bytes pro Schicht bei fp16/bf16 — Attention-Block 11sbh plus MLP-Block 19sbh in der Bilanz aus Abschnitt 4.1 des Papers (Gl. 1: sbh(34 + 5as/h) pro Schicht), zuzüglich der s²b-Terme, die FlashAttention entfernt. Mit Gradient-Checkpointing im klassischen √L-Abstand (ein Checkpoint alle √64 = 8 Schichten) fällt der gespeicherte Peak-Aktivierungsspeicher von 34·s·b·h·L auf etwa 2·√L·s·b·h — ein 136-facher Schnitt für dieses Modell (34·64 = 2.176 gegen 2·8 = 16 Einheiten-Koeffizienten), gegen einen zusätzlichen Forward-Pass pro Segment.

Der Wechselkurs ist ein zusätzlicher Forward-Pass pro Schritt: Ein normaler Schritt ist Forward (1 Einheit) + Backward (2 Einheiten) = 3; ein Checkpoint-Schritt ist 4 Einheiten — +33 % im Einheitenmodell, die Rahmung, die sowohl Chen et al. (arXiv:1604.06174) 5 als auch die PyTorch-Dokumentation zu Activation Checkpointing nutzen — Chens gemessener Overhead auf seinen Benchmarks liegt bei ~30 %. Als Eselsbrücke: „ein Drittel zahlen, den Aktivierungsspeicher vierteln".

Aktivierungstabelle Qwen3-32B (h = 5.120, L = 64, bf16, FlashAttention):

Batch × Kontext (Tokens)Ohne Checkpointing (34·s·b·h·L)√L-Checkpointing (2·8·s·b·h)
1 × 2.04822,8 GB0,17 GB
4 × 2.04891,3 GB0,67 GB
4 × 4.096182,5 GB1,34 GB
8 × 4.096365,1 GB2,68 GB
1 × 16.384182,5 GB1,34 GB
8 × 8.192730,1 GB5,37 GB

Lesen Sie das Verhältnis, nicht nur die Absolutwerte: Aktivierungen sind linear in den Tokens und bei kleinem Batch vernachlässigbar — bei Batch 8 × 8k-Kontext übersteigen sie aber den gesamten 21,9-GB-QLoRA-Modell-Status um das 33-fache ohne Checkpointing und bleiben mit ihm unter 6 GB. (Reale Peaks enthalten Fragmentierung und cuDNN-Workspaces; betrachten Sie diese Zahlen als Untergrenzen und prüfen Sie torch.cuda.max_memory_allocated().)

Was passt wohin: Modell × Methode → GPU

Kombination der drei Budgets (PEFT-Optimizer-Status + Bytes der eingefrorenen Basis + Aktivierungsspanne bei Batch 4 × 2.048, mit Checkpointing):

ModellVolles Finetuning (16 B/Parameter)LoRA r=16 (bf16-Basis)QLoRA r=16 (NF4+DQ)
Llama-3.1-8B (8,03 Mrd. Parameter) 6128,5 GB → 2× A100 80 / H100 8016,1 + 1,3 + 0,5 ≈ 18 GB → RTX 4090 244,1 + 1,3 + 0,5 ≈ 6 GB → RTX 4060 Ti 16 / jede Karte ab 12 GB
Qwen3-32B (32,76 Mrd. Parameter)524,2 GB → 8× A100 80 (ZeRO-3)65,5 + 4,0 + 0,7 ≈ 70 GB → A100/H100 8016,9 + 4,0 + 0,7 ≈ 22 GB → RTX 3090/4090 24
70B (Llama-3.3-70B-Klasse)~1.103 GB → 14× A100 80~141 + 8,7 + ~1,4 ≈ 151 GB → 2× A100 80~36,2 + 8,7 + ~1,4 ≈ 46 GB → 1× A100 40 / 2× RTX 3090

Die Parameterzahl von Llama-3.1-8B ist gegen die Hugging-Face-Metadaten verifiziert (meta-llama/Llama-3.1-8B: 8.030.261.248). Die 70B-Zeile verwendet für die Adapter-Mathematik die Paper-Klasse Llama-2-70B mit 68,96 Mrd. effektiven Parametern — QLoRAs eigenes Kernergebnis ist die dritte Spalte, die es berühmt machte: „finetune a 65B parameter model on a single 48GB GPU".

Die kritische Sicht: was Finetuning nicht leistet

Die Speicher-Mathematik sagt: Finetuning ist billig; der Hype liest das als mächtig. Beide Papiere, aufmerksam gelesen, sagen das Gegenteil des Marketings:

  • Finetuning lehrt Form, keine Fakten 7. LoRAs eigene Analyse zeigt, dass seine Updates in einem niedrigrangigen Unterraum leben, und die Datenmisch-Experimente des QLoRA-Papers zeigen, dass die Adapter-Qualität der Qualität der Instruktionsdaten folgt, nicht der Menge — ein Modell, dem Wissen fehlt, erwirbt es nicht in einem 1.000-Beispiel-SFT-Lauf; es lernt Stil und Format. Für Fakten nehmen Sie Retrieval, keine Adapter.
  • „Billig" zählt nur VRAM, nie den Durchsatz 8. Ja, QLoRA passt ein 32B-Modell in 22 GB. Bei Batch 4 × 2.048 Tokens verarbeitet ein Trainingsschritt 8.192 Tokens — ein 100-Millionen-Token-SFT-Datensatz braucht 12.207 Schritte, und jeder Schritt trägt die +33 % Checkpointing-Steuer plus 4-Bit-Dequantisierungs-Overhead. QLoRAs Guanaco 65B brauchte 24 Stunden auf einer professionellen GPU für einen einzigen Durchlauf; eine speicher-machbare Konfiguration ist keine zeit-machbare Konfiguration, und „finetunen Sie Ihr eigenes Modell für den Preis von API-Credits" unterschlägt still, dass dasselbe Datensatz-Plus LoRA-Rank-Tuning, Fehlversuche und Auswertung die Rechnung vervielfachen.

  • Keine ehrlichen Defaults ohne Tuning 9. Die Hyperparameter-Tabelle des QLoRA-Papers selbst nutzt Lernrate 2e-4 für 7B- und 13B-Modelle und 1e-4 ab 33B, Batchgröße 16, konstanter Schedule — rund 10× höher als Lernraten des vollen Finetunings, weil nur die kleine Adapter-Population optimiert wird und die Basis eingefroren ist. LoRAs Paper fegt die Lernrate ebenfalls pro Aufgabe. Jede „nehmen Sie einfach"-Zahl — Rank 8, 3 Epochen, LR 2e-4 — ist ein Startgritter, kein Ergebnis; der ehrliche Weg ist ein kleiner Sweep über Lernrate und Rank, bevor man einer Loss-Kurve glaubt.

  • Der Quantisierungsfehler ist real, aber begrenzt 8. QLoRAs NF4-Behauptung lautet, dass 4-Bit-quantisiertes Finetuning die Qualität von 16-Bit-Finetuning beim Adapter-Lernproblem erreicht — validiert auf ihren Benchmarks, kein Naturgesetz. QLoRAs Ablationen zeigen, dass speziell NF4 nötig ist (andere 4-Bit-Typen verschlechtern sich), und beide Papiere stimmen überein, dass das Wissen der eingefrorenen Basis und die Datenchemie des Adapters das Ergebnis stärker bestimmen als jeder Speicher-Trick.

Was Sie mitnehmen sollten

  • Trainings-Budget pro trainierbarem Parameter: 16 Bytes unter gemischter AdamW-Präzision (2 bf16-Gewicht + 2 bf16-Gradient + 4 fp32-Master + 4 m + 4 v), laut ZeRO-Paper — das 8-Fache der Inference-Gewichte. Qwen3-32B volles Finetuning: 524,2 GB vor Aktivierungen.
  • Eingefrorene Parameter kosten 2 Bytes, nicht 16. Diese Asymmetrie, nicht irgendein Matrizen-Trick, ist LoRas gesamte Ersparnis: r=16 all-linear auf Qwen3-32B trainiert 0,82 % des Modells → 69,5 GB Modell-Status, 13,3 % des vollen Finetunings.
  • LoRA-Adaptergröße ist 2r(d_in+d_out) pro Matrix, alle sieben Lineare pro Schicht → 268 Mio. trainierbare bei r=16 beim Referenzmodell (linear in r: 134 Mio. bei r=8, 1,07 Mrd. bei r=64).
  • QLoRAs eingefrorene Basis kostet 4,127 Bit/Parameter (NF4 4 + FP8-Skalen 0,125 + zweite Stufe 0,002), Double Quantization spart exakt 0,373 Bit/Parameter gegenüber blockweisen fp32-Skalen 10 — Qwen3-32B: 16,9 GB Basis, ≈22 GB Peak gesamt bei r=16, Batch 4 × 2k, mit Checkpointing.
  • Aktivierungen skalieren mit Tokens: ≈ 34·s·b·h Bytes pro Schicht, √L-Checkpointing kürzt L→√L für +33 % Rechenleistung (ein zusätzlicher Forward-Pass). Bei Batch 8 × 8k-Kontext sind Aktivierungen 730 GB ohne Checkpointing, 5,4 GB mit — oft das echte OOM, nicht das Modell.
  • Finetuning überträgt Stil und Format, injiziert schlecht Wissen — die Datenabschnitte beider Papiere stützen die Grenzen, nutzen Sie RAG für Fakten und zählen Sie Durchsatz, nicht nur VRAM, bevor Sie ein „billiges eigenes Modell" versprechen.

Für die Speicher-Mathematik auf der Serving-Seite siehe den KV-Cache-Leitfaden; für Gewichtsformate und 4-Bit-Blockquantisierung den Quantisierungs-Leitfaden; für die Rechenschaft über die Kosten des Betriebs des Trainierten den VRAM-Rechner-Leitfaden und das Inference-Ökonomie-Tool.

Footnotes

  1. Qwen/Qwen3-32B — Hugging-Face-Modellepository, Safetensors-Metadaten: 32.762.123.264 BF16-Parameter; config.json: 64 Schichten, Hidden 5.120, 64 Q-/8 KV-Heads, head_dim 128, FFN 25.600, Vokabular 151.936, ungeteilte Embeddings. huggingface.co/Qwen/Qwen3-32B. ↩

  2. Rajbhandari et al., ZeRO: Memory Optimizations Toward Training Trillion Parameter Models, arXiv:1910.02054 — Abschn. 3.1 leitet das 2Ψ+2Ψ+12Ψ = 16Ψ-Byte-Budget von Mixed-Precision-Adam her. arxiv.org/abs/1910.02054. ↩

  3. Hu et al., LoRA: Low-Rank Adaptation of Large Language Models, arXiv:2106.09685 — Abstract: 10.000× weniger trainierbare Parameter, 3× VRAM-Reduktion gegenüber vollem Finetuning bei GPT-3 175B. arxiv.org/abs/2106.09685. ↩

  4. Korthikanti et al., Reducing Activation Recomputation in Large Transformer Models, arXiv:2205.05198 — 34sbh-pro-Schicht-Aktivierungsbilanz mit FlashAttention; Trade-offs des selektiven Recompute. arxiv.org/abs/2205.05198. ↩

  5. Chen et al., Training Deep Nets with Sublinear Memory Cost, arXiv:1604.06174 — √L-Checkpointing macht O(L)-Aktivierungsspeicher zu O(√L) bei einem zusätzlichen Forward-Pass (~+33 % Schritt-Rechenleistung). arxiv.org/abs/1604.06174. ↩

  6. meta-llama/Llama-3.1-8B — Hugging-Face-Metadaten: 8.030.261.248 BF16-Parameter. huggingface.co/meta-llama/Llama-3.1-8B. ↩

  7. Hu et al., LoRA: Low-Rank Adaptation of Large Language Models, arXiv:2106.09685, Abschn. 7: ΔW „amplifies some features that are already in W“ und „only amplifies directions that are not emphasized in W“, Verstärkungsfaktor ≈ 21,5 bei r=4; die Niedrigrang-Hypothese betrifft die Gewicht-Updates (Abschn. 1). arxiv.org/abs/2106.09685. ↩

  8. Dettmers et al., QLoRA: Efficient Finetuning of Quantized LLMs, arXiv:2305.14314: „we find that data quality is far more important than dataset size, e.g., a 9k sample dataset (OASST1) outperformed a 450k sample dataset (FLAN v2)“ (Abschn. 6.2) — arxiv.org/abs/2305.14314. ↩ ↩2

  9. Das QLoRA-Paper betont, Trainings- und Inference-Prompt-Templates müssen exakt übereinstimmen. ↩

  10. Dettmers et al., QLoRA: Efficient Finetuning of Quantized LLMs, arXiv:2305.14314 — Abstract: 65B-Modell auf einer einzelnen 48-GB-GPU; 4,127-Bit-effektive NF4+DQ-Bilanz; Paged Optimizer gegen Checkpointing-Spitzen. arxiv.org/abs/2305.14314. ↩