12. November 2026 · VRAMfarm-Team

LLM feintunen: wie viel VRAM und wie viele GPUs für QLoRA, LoRA und volles Fine-Tuning

Die meisten Fine-Tuning-Jobs brauchen eine GPU, nicht acht. QLoRA trainiert ein 8B-Modell auf einer 16-GB-Karte, ein 32B-Modell auf einer 48-GB-Karte und ein 70B-Modell auf einer einzelnen 80-GB-Karte. LoRA in 16 Bit braucht das Zwei- bis Dreifache. Erst volles Fine-Tuning, das jedes Gewicht aktualisiert, zwingt Sie schon bei einem 8B-Modell auf mehrere 80-GB-Karten, denn es kostet vor den Aktivierungen rund 16 Bytes pro Parameter. Ein typischer QLoRA-Lauf mit einem 8B-Modell und 15 Millionen Trainings-Tokens dauert auf einer RTX 4090 2–4 Stunden und kostet 1,65 € GPU-Zeit.

Zuerst: Müssen Sie überhaupt feintunen?

Fine-Tuning bringt einem Modell ein Format, einen Ton oder eine eng umrissene Aufgabe bei: Antworten im Stil Ihres Supports, Felder in Ihr JSON-Schema extrahieren, Tickets Ihren Kategorien zuordnen. Wissen fügt man damit schlecht hinzu. Soll das Modell Ihre Produktdokumentation kennen, geben Sie ihm die Dokumente zum Zeitpunkt der Frage mit (Retrieval oder einfach ein langer Prompt) und halten Sie sie aktuell, ohne neu zu trainieren. Probieren Sie zuerst einen guten Prompt mit ein paar Beispielen auf dem Basismodell; liegt es beim Format oder Stil dann immer noch in einem von fünf Fällen daneben, lohnt sich ein Fine-Tune.

Speicher je Methode: die Rechnung

Drei Methoden, drei sehr unterschiedliche Speicherrechnungen:

• QLoRA lädt das Basismodell in 4 Bit (etwa 0,6 Bytes pro Parameter) und trainiert daneben kleine Adapter-Matrizen. Das Basismodell bleibt eingefroren, es gibt also keine Gradienten und keine Optimizer-Zustände dafür.
• LoRA macht dasselbe mit dem Basismodell in 16 Bit: 2 Bytes pro Parameter, etwas bessere Qualität, mehr Speicher.
• Volles Fine-Tuning aktualisiert jedes Gewicht. Mit dem üblichen AdamW-Optimizer in Mixed Precision kostet jeder Parameter rund 16 Bytes: Gewichte und Gradienten in 16 Bit, eine fp32-Masterkopie und zwei Optimizer-Zustände in fp32. Ein 8-Bit-Optimizer und 16-Bit-Gewichte ohne Masterkopie drücken das auf etwa 6–8 Bytes.

Dazu kommen die Aktivierungen, die mit Sequenzlänge und Batch-Größe wachsen. Die Werte unten gehen von Sequenzen mit 2.000–4.000 Tokens aus, einem kleinen Batch und Gradient Checkpointing, das Aktivierungen neu berechnet, statt sie zu speichern.

Es sind Spannen, weil sich Trainer unterscheiden: Die Kernels von Unsloth brauchen spürbar weniger als einfacher Hugging-Face-Code, und lange Sequenzen heben jede Zeile an. Der VRAM-Ratgeber erklärt die Rechnung mit Bytes pro Parameter, der Ratgeber zu CUDA out of memory die Stellschrauben, wenn ein Lauf nicht passt: Batch-Größe, Sequenzlänge, Gradient Checkpointing, 8-Bit-Optimizer.

Volles Fine-Tuning braucht eine Aufgabe nur selten. LoRA auf allen linearen Schichten mit Rang 16–64 holt bei Stil, Format und eng umrissenen Aufgaben den größten Teil des Gewinns. Seine Kosten wert ist volles Fine-Tuning beim fortgesetzten Pre-Training auf einem großen Korpus, für eine neue Sprache oder eine tiefe Verschiebung der Domäne.

Eine Karte oder mehrere

Wenn Sie Karten hinzufügen, passieren zwei verschiedene Dinge, und nur eines davon spart Speicher.

Datenparallelität (DDP): Jede Karte hält eine vollständige Kopie des Modells und verarbeitet andere Batches. Der Speicher pro Karte bleibt gleich; die Geschwindigkeit wächst, mit zwei Karten etwa auf das 1,8-Fache, mit vier auf das 3,5-Fache. Nützlich, wenn ein Lauf auf eine Karte passt, aber die ganze Nacht dauern würde.

Sharding (FSDP, DeepSpeed ZeRO-3): Gewichte, Gradienten und Optimizer-Zustände werden auf die Karten verteilt, sodass sie gemeinsam ein Modell fassen, das keine allein fassen könnte. So funktionieren volles Fine-Tuning und 16-Bit-LoRA großer Modelle. Die Karten tauschen bei jedem Schritt Daten aus, die Verbindung zählt also: Rechenzentrumsmaschinen mit NVLink, etwa 8 × H100, skalieren gut; Consumer-Karten wie die RTX 4090 und 5090 kommunizieren über PCIe und skalieren spürbar schlechter. QLoRA in Kombination mit FSDP kann sogar ein 70B-Modell auf zwei 24-GB-Karten verteilen, bei mäßigem Tempo.

Die Faustregel: Passt der Job auf eine Karte, nehmen Sie eine Karte. Das ist einfacher, und zwischen den Karten kann nichts schiefgehen. Eine einzelne H100 ist oft schneller und günstiger fertig als zwei Consumer-Karten. Mehrere Karten nehmen Sie, wenn das Modell auf keine einzelne Karte passt oder wenn ein Lauf auf einer Karte länger als einen Arbeitstag dauern würde. Maschinen mit 2, 4 und 8 Karten sind im Katalog eigens aufgeführt, und die Grundlagen des Multi-GPU-Trainings behandeln die Einrichtung; eine Maschine mit mehreren Karten kostet etwa die Zahl der Karten mal den Preis einer Karte, 4 × H100 also etwa 15,60 € pro Stunde.

Tools: Unsloth, Axolotl, TRL

Unsloth ist der schnellste Weg zu QLoRA oder LoRA auf einer Karte. Seine eigenen Kernels sparen Speicher und Zeit, es liefert fertige 4-Bit-Versionen beliebter Modelle, und es exportiert das Ergebnis als Adapter, als zusammengeführtes 16-Bit-Modell für vLLM oder als GGUF für Ollama. Die Unterstützung für mehrere GPUs ist neuer und eingeschränkter als bei den anderen beiden.

pip install unsloth

Ersetzt pip dabei das PyTorch des Images, prüfen Sie, ob der neue Build zur CUDA-Version passt, die die Maschine vor dem Start angezeigt hat; python -c "import torch; print(torch.cuda.is_available())" sollte True ausgeben.

from unsloth import FastLanguageModel
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset

model, tokenizer = FastLanguageModel.from_pretrained(
    "unsloth/Qwen3-8B", max_seq_length=2048, load_in_4bit=True)
model = FastLanguageModel.get_peft_model(model, r=16, lora_alpha=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    use_gradient_checkpointing="unsloth")

data = load_dataset("json", data_files="/workspace/data/train.jsonl", split="train")
trainer = SFTTrainer(model=model, processing_class=tokenizer, train_dataset=data,
    args=SFTConfig(output_dir="/workspace/out", per_device_train_batch_size=2,
        gradient_accumulation_steps=4, num_train_epochs=3, learning_rate=2e-4,
        logging_steps=10, save_steps=200, bf16=True))
trainer.train()
model.save_pretrained("/workspace/out/adapter")

train.jsonl enthält ein Beispiel pro Zeile, jeweils eine Liste messages im Chatformat (system, user, assistant), die der Trainer mit dem Chat-Template des Modells formatiert.

Axolotl beschreibt den ganzen Lauf in einer YAML-Datei: Modell, Datensatz, LoRA oder voll, Sequenzlänge und wie mehrere GPUs genutzt werden. Dadurch lassen sich Läufe wiederholen und leicht vergleichen. Installieren Sie es mit pip, wie in der Dokumentation beschrieben (die Extras für Flash Attention und DeepSpeed hängen von Ihrer Umgebung ab); danach lädt axolotl fetch examples fertige Konfigurationen für gängige Modelle herunter, und axolotl train your-config.yaml startet den Lauf. Für ein Modell, das nicht auf eine Karte passt, ergänzen Sie in der Konfiguration einen Abschnitt für DeepSpeed ZeRO-3 oder FSDP; hier ist Axolotl stärker als Unsloth.

TRL von Hugging Face ist die Bibliothek unter vielem davon: Trainer für Supervised Fine-Tuning, DPO und GRPO, PEFT für LoRA. Wählen Sie TRL, wenn Sie eigenen Trainingscode schreiben wollen. Ein Skript, das auf einer Karte läuft, läuft mit accelerate launch --num_processes 4 train.py auf vier.

Zeit und Kosten

Planungswerte für einen Datensatz: 10.000 Beispiele mit je etwa 500 Tokens, drei Epochen, 15 Millionen Trainings-Tokens. Der Durchsatz stammt aus der Rechenleistung und öffentlichen Berichten der Community, nicht aus eigenen Benchmarks. Die Zeit wächst mit den Tokens: doppelte Datenmenge, doppelte Stunden.

Zwei Muster fallen auf. Schnellere Rechenzentrumskarten kosten pro fertigem Lauf oft weniger, weil die Stunden schneller schrumpfen, als der Preis steigt: Vergleichen Sie die beiden Zeilen mit 70B. Und volles Fine-Tuning eines 8B-Modells ist an GPU-Zeit kurz; länger dauern die Vorbereitung der Daten und die Auswertung drumherum.

Rechnen Sie die Einrichtung dazu: 5–10 Minuten für die Installation des Trainers und den Modell-Download, der als Traffic plus Minuten berechnet wird. Nehmen Sie für QLoRA die 4-Bit-Version, wo es eine gibt; bei einem 70B-Modell sind das etwa 40 GB statt 141 GB. Der Artikel zu den Kosten pro Million Tokens rechnet mit derselben Methode für den Betrieb von Modellen nach dem Training.

Auf einem gemieteten Server trainieren, ohne Arbeit zu verlieren

1. Erst klein testen. Trainieren Sie in den ersten 15 Minuten, die Sie ohnehin bezahlen, auf 1 % der Daten. Notieren Sie die Tokens pro Sekunde, die der Trainer ausgibt, und den Speicher in nvidia-smi, und rechnen Sie hoch, bevor Sie den vollen Lauf starten.
2. Ohne Sie weiterlaufen lassen. Starten Sie das Training in tmux (apt-get install -y tmux, tmux new -s train) oder mit nohup python train.py > /workspace/train.log 2>&1 &. Dann stoppt es nicht, wenn Sie den Browser oder die SSH-Sitzung schließen.
3. Checkpoints schreiben und wegkopieren. Stellen Sie save_steps so ein, dass alle 15–30 Minuten ein Checkpoint in /workspace/out landet. Hardware fällt hin und wieder aus; geht eine Maschine verloren, endet die Abrechnung ab diesem Moment, aber ihre Festplatte ist mit ihr weg. Kopieren Sie Checkpoints laufend weg: in ein privates Hugging-Face-Repository, per rsync auf Ihren eigenen Computer oder in Ihren eigenen Bucket. Der Artikel zu Dateien nach einem Stopp erklärt, was der gespeicherte Ordner behält.
4. Den Adapter behalten, nicht das Basismodell. Ein LoRA-Adapter ist einige zehn bis wenige hundert MB groß und kostet im gespeicherten Ordner bei 0,03 € pro GB und Monat so gut wie nichts. Das öffentliche Basismodell lässt sich erneut herunterladen.
5. Stoppen, wenn Sie fertig sind. Die Abrechnung endet in der Minute, in der Sie den Server stoppen. Der Leerlaufschutz schickt Ihnen nach 2 Stunden ohne SSH, Jupyter oder GPU-Last eine E-Mail und speichert eine Stunde später den Ordner und stoppt den Server, aber diese Leerlaufstunden werden berechnet.

Um das Ergebnis zu nutzen, betreiben Sie das Basismodell mit dem Adapter in vLLM: vllm serve Qwen/Qwen3-8B --enable-lora --lora-modules support=/workspace/out/adapter, und rufen dann den Modellnamen support über die OpenAI-kompatible API auf. Oder Sie führen den Adapter mit Unsloth ins Basismodell zusammen und exportieren ein GGUF für Ollama. Der Vergleich der Laufzeitumgebungen hilft bei der Wahl.