LLM privat auf einer gemieteten GPU feintunen: Eine praktische Anleitung

Sie können ein offenes 8B-Modell mit QLoRA auf einer einzigen gemieteten 24-GB-GPU mit Ihren eigenen Daten feintunen, und ein typischer Lauf kostet unter einem Dollar. Die schwierigeren Fragen kommen vorher: ob Fine-Tuning überhaupt die richtige Lösung ist (für Fakten gewinnt meist Retrieval) und wie Ihre Daten auf einer Maschine, die jemand anderem gehört, privat bleiben.

Diese Anleitung behandelt beides, dann den VRAM-Bedarf nach Modellgröße, die aktuellen Tools, ein funktionierendes Trainingsskript, eine Beispielrechnung und die Bereitstellung des Ergebnisses. Alles wurde im September 2026 geprüft; die Quellen stehen am Ende.

Fine-Tuning, RAG oder bessere Prompts

Fine-Tuning verändert, wie sich ein Modell verhält. Um ihm Fakten beizubringen, taugt es wenig. Ovadia et al. haben beides für das Einbringen von Wissen verglichen und festgestellt, dass RAG unüberwachtes Fine-Tuning „durchweg übertrifft“, „sowohl bei vorhandenem Wissen, das im Training vorkam, als auch bei völlig neuem Wissen“. Ihr Fazit: LLMs tun sich schwer, durch Fine-Tuning neue Fakten zu lernen.

Gehen Sie also diesen Baum durch, bevor Sie irgendetwas mieten:

Gute Gründe für Fine-Tuning:

• Striktes Ausgabeformat. Bei jedem Aufruf Felder in Ihr Schema extrahieren, ohne eine Seite Anweisungen in jedem Prompt.
• Stil und Tonfall. Support-Antworten, die wie Ihr Team klingen, oder Berichte mit fester Struktur.
• Eine eng umrissene Aufgabe für ein kleines Modell. Ein angepasstes 8B-Modell kann ein großes Allzweckmodell für einen einzelnen Job ersetzen. Das zählt, wenn Sie es auf günstiger Hardware betreiben.
• Kürzere Prompts. Verhalten, das in den Gewichten steckt, muss nicht in jeder Anfrage wiederholt werden.

LoRA und QLoRA

Vollständiges Fine-Tuning aktualisiert jedes Gewicht. Die GPU muss also zusätzlich zum Modell Gradienten und Optimizer-Zustand für alle Gewichte halten. LoRA friert das Basismodell ein und trainiert kleine Matrizen mit niedrigem Rang neben seinen Schichten; das ursprüngliche Paper meldete 10.000-mal weniger trainierbare Parameter und ein Drittel des GPU-Speichers im Vergleich zum vollständigen Fine-Tuning von GPT-3 175B mit Adam.

QLoRA geht weiter: Das eingefrorene Basismodell wird in 4-Bit-NF4-Präzision geladen, nur die Adapter werden in 16 Bit trainiert. Dettmers et al. haben damit ein 65B-Modell auf einer einzigen 48-GB-GPU feingetunt, „bei voller Leistung eines 16-Bit-Fine-Tunings“. Das Paper brachte drei Bausteine mit, die die Tools bis heute nutzen: den Datentyp NF4, doppelte Quantisierung der Quantisierungskonstanten und Paged Optimizers, die Speicherspitzen abfangen.

Das Ergebnis ist in beiden Fällen ein Adapter, ein Ordner mit ein paar Tensoren, den Sie auf das unveränderte Basismodell anwenden. Sie können ihn getrennt halten oder in die Gewichte einmergen. Bildmodelle nutzen dieselbe Methode: Eine Stable-Diffusion-LoRA lässt sich auf einer einzigen gemieteten 24-GB-Karte für deutlich unter 10 $ trainieren.

Wie viel VRAM Sie brauchen

Unsloth veröffentlicht eine Tabelle mit dem minimalen VRAM für Fine-Tuning nach Modellgröße. Das sind die Zahlen von Unsloth, mit dessen Speicheroptimierungen; normales Training mit Hugging Face braucht mehr, und längere Sequenzen oder größere Batches treiben jede Zeile nach oben.

Modellgröße	QLoRA (4 Bit)	LoRA (16 Bit)	Mietkarte, auf die QLoRA bequem passt
3B	3,5 GB	8 GB	Jede Karte ab 12 GB
8B	6 GB	22 GB	RTX 3090 / 4090 (24 GB)
14B	8,5 GB	33 GB	RTX 3090 / 4090 (24 GB)
32B	26 GB	76 GB	48-GB-Karte (RTX A6000, A40, L40S)
70B	41 GB	164 GB	80-GB-Karte (A100, H100)

Mein Standard ist ein 8B- oder 14B-Modell auf einer RTX 4090. Das ist die günstigste Mietkarte, die Platz für Sequenzen mit 2.048 Tokens und eine vernünftige Batchgröße lässt, und Modelle dieser Größe lassen sich danach leicht bereitstellen. Wie Sie ein Basismodell nach dem VRAM wählen, auf dem Sie es später betreiben, steht in welche KI-Modelle in den VRAM Ihrer GPU passen.

Ein Tool wählen: TRL, Unsloth oder Axolotl

Alle drei sind Open Source, und alle beherrschen LoRA und QLoRA.

Tool	Bedienung	Stärke	Worauf achten
Hugging Face TRL + PEFT	Python (SFTTrainer)	Die Referenzimplementierung; DPO, GRPO und mehr über dieselbe API	Braucht beim selben Lauf mehr Speicher als Unsloth
Unsloth	Python oder die Web-Oberfläche Unsloth Studio	Verspricht doppelte Geschwindigkeit und 70 % weniger VRAM; exportiert direkt nach GGUF	Studio steht unter AGPL-3.0 (der Kern unter Apache 2.0)
Axolotl	Eine YAML-Datei, axolotl train config.yml	Mehrere GPUs (FSDP, DeepSpeed), viele Rezepte	Braucht Python 3.11+ und PyTorch 2.11+

Stand September 2026 ist TRL bei Version 1.14 und PEFT bei 0.21. Unsloth braucht Python 3.11 bis 3.13 und eine NVIDIA-GPU mit CUDA Compute Capability 7.0 oder neuer (V100, T4, RTX-20-Serie und neuer). Axolotl empfiehlt Python 3.12 und PyTorch 2.12.1.

Nehmen Sie TRL, wenn Sie jede Zeile verstehen wollen, Unsloth, wenn der VRAM knapp ist oder Sie den GGUF-Export mit einem Aufruf wollen, und Axolotl, wenn Sie Läufe mit anderen Einstellungen wiederholen oder auf mehrere GPUs gehen. Das Skript unten nutzt TRL, weil es der kürzeste Weg ist, der alle beweglichen Teile zeigt.

Die Daten vorbereiten

SFTTrainer von TRL liest Konversationen im selben Format wie eine Anfrage an eine Chat-API. Ein JSON-Objekt pro Zeile in train.jsonl:

{"messages": [{"role": "system", "content": "Extract the invoice fields as JSON."}, {"role": "user", "content": "Invoice 4471 from Norden AB, due 12 March, total 1,250 EUR"}, {"role": "assistant", "content": "{\"invoice_id\": \"4471\", \"supplier\": \"Norden AB\", \"due\": \"2026-03-12\", \"total\": 1250, \"currency\": \"EUR\"}"}]}

Praktische Regeln:

• Qualität vor Menge. Ein paar hundert bis ein paar tausend einheitliche, korrekte Beispiele schlagen Zehntausende verrauschte. Jeder Fehler in den Daten ist Verhalten, für dessen Training Sie bezahlen.
• Wie in Produktion. Nutzen Sie den System-Prompt und das Eingabeformat, das Ihre Anwendung tatsächlich senden wird.
• 5 bis 10 % zurückhalten. Behalten Sie Beispiele, auf denen das Modell nie trainiert, um Basismodell und angepasstes Modell direkt zu vergleichen.
• Entfernen, was Sie nicht brauchen. Namen, E-Mail-Adressen, Kontonummern und IDs helfen dem Modell selten, ein Format zu lernen. Ersetzen Sie sie durch realistische Platzhalter, bevor die Daten Ihren Computer verlassen.

Bei der letzten Regel geht es um mehr als die gemietete Maschine. Carlini et al. haben Hunderte wörtliche Trainingssequenzen aus GPT-2 extrahiert, darunter Namen, Telefonnummern und E-Mail-Adressen, von denen manche nur in einem einzigen Trainingsdokument vorkamen. Ein feingetuntes Modell kann das, worauf es trainiert wurde, jedem wiedergeben, der es später nutzt.

Die Daten auf einer gemieteten Maschine privat halten

Auf einem GPU-Marktplatz gehört der Computer jemand anderem. Vast.ai sagt es klar: „Kunden sind in Docker-Containern ohne Root-Rechte isoliert und haben nur Zugriff auf ihre eigenen Daten“, und „die Sicherheit bei den Anbietern schwankt stark“. Diese Isolation schützt Sie vor anderen Mietern. Vor der Person mit physischem Zugang und Root-Rechten auf dem Host schützt sie nicht.

Für private Daten:

1. Wählen Sie einen geprüften Rechenzentrums-Host. Die Secure-Cloud-Anbieter von Vast.ai sind „geprüfte Rechenzentren mit ISO-27001-Zertifizierung und Tier-3/4-Standard“, und Vast empfiehlt sie für sensible Arbeit. Die Secure Cloud von RunPod läuft in T3/T4-Rechenzentren; die Community Cloud verbindet Sie mit einzelnen Anbietern. Die Rechenzentrumsstufen kosten mehr pro Stunde und sind es hier wert.
2. Laden Sie nur den bereinigten Datensatz hoch, über SSH (rsync -avP oder scp). Legen Sie ihn unterwegs nicht in einem öffentlichen Bucket oder hinter einem geteilten Link ab.
3. Halten Sie das Logging lokal. In TRL 1.14 steht report_to standardmäßig auf "none", es geht also nichts an einen Experiment-Tracker, solange Sie das nicht einschalten. Rufen Sie push_to_hub nicht mit einem Adapter auf, der auf privaten Daten trainiert wurde.
4. Holen Sie die Ergebnisse heraus und löschen Sie dann die Instanz. Laden Sie Adapter und Evaluationsergebnisse herunter, melden Sie sich bei Hugging Face ab (hf auth logout), falls Sie ein Token genutzt haben, und löschen Sie Instanz und Volumes. Bei Vast.ai wird Speicher berechnet und aufbewahrt, bis die Instanz gelöscht ist, nicht nur gestoppt.

Dateien in einem Container zu löschen garantiert nicht, dass die Festplatte des Hosts gelöscht wird. Der eigentliche Schutz sind deshalb die Schritte 1 und 2: Wählen Sie, wer die Hardware hält, und schicken Sie so wenig wie möglich dorthin. Mehr dazu in einen Datensatz auf einem öffentlichen GPU-Knoten absichern. Verbietet Ihre Richtlinie jede fremde Hardware, läuft dasselbe Skript auch auf Ihrer eigenen 24-GB-Karte.

Training: ein QLoRA-Skript mit TRL

Auf einer gemieteten Linux-Maschine mit RTX 3090 oder 4090:

python -m venv venv && source venv/bin/activate
pip install torch trl peft bitsandbytes datasets

Dann train.py, nach dem QLoRA-Muster aus der PEFT-Doku von TRL. Qwen3-8B steht unter Apache 2.0 und ist frei zugänglich, ein Hugging-Face-Token ist also nicht nötig:

import torch
from datasets import load_dataset
from peft import LoraConfig
from transformers import BitsAndBytesConfig
from trl import SFTConfig, SFTTrainer

dataset = load_dataset("json", data_files="train.jsonl", split="train")

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    target_modules="all-linear",
    task_type="CAUSAL_LM",
)

args = SFTConfig(
    output_dir="out",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    lr_scheduler_type="cosine",
    warmup_steps=20,
    max_length=2048,
    bf16=True,
    logging_steps=10,
    save_strategy="epoch",
    model_init_kwargs={"dtype": torch.bfloat16},
)

trainer = SFTTrainer(
    model="Qwen/Qwen3-8B",
    args=args,
    train_dataset=dataset,
    quantization_config=bnb_config,
    peft_config=peft_config,
)
trainer.train()
trainer.save_model("out/adapter")

Die Entscheidungen, auf die es ankommt:

• learning_rate=2e-4. Die Doku von TRL empfiehlt für QLoRA etwa das Zehnfache der üblichen Fine-Tuning-Rate. Steigt der Evaluations-Loss, während der Trainings-Loss fällt, liegt Overfitting vor: Nehmen Sie weniger Epochen.
• r=16, target_modules="all-linear". Adapter auf jeder linearen Schicht, so wie in den Benchmarks von Unsloth. Rang 16 reicht für Format und Stil; für schwierigere Aufgaben erhöhen Sie ihn.
• max_length=2048. Längere Beispiele werden abgeschnitten. Prüfen Sie die Token-Längen Ihrer Daten; ein höheres Limit braucht mehr VRAM.
• Effektive Batchgröße 16 (4 × 4 Akkumulationsschritte). Geht der Speicher aus, senken Sie per_device_train_batch_size und erhöhen die Akkumulation, sodass das Produkt gleich bleibt.

Bevor Sie die Maschine herunterfahren, schicken Sie Ihre zurückgehaltenen Beispiele durch das Basismodell und das angepasste Modell und vergleichen die Ergebnisse. Nur dieser Test sagt Ihnen, ob das Geld etwas bewirkt hat.

Was es kostet

Trainingszeit ist Gesamtzahl der Tokens ÷ Durchsatz. GigaGPU, ein Hosting-Anbieter, hat für Llama 3.1 8B mit QLoRA auf einer RTX 4090 etwa 3.500 Trainings-Tokens pro Sekunde gemessen und veröffentlicht. Unter der Annahme eines ähnlichen Werts für Qwen3-8B:

Kleiner Lauf: 2.000 Beispiele × 600 Tokens × 3 Epochen = 3,6 Millionen Tokens. 3.600.000 ÷ 3.500 = 1.029 s, etwa 17 Minuten.

Schritt	Zeit
Umgebung einrichten	10 Min.
Qwen3-8B herunterladen (16,4 GB Gewichte) und Daten hochladen	10 Min.
Training	17 Min.
Basismodell und angepasstes Modell auf zurückgehaltenen Daten vergleichen	15 Min.
Mergen, exportieren, herunterladen, Instanz löschen	15 Min.
Summe	67 Min. (1,12 h)

• RTX 4090 bei Vast.ai zu 0,31 $/h: 1,12 × 0,31 $ = 0,35 $
• RTX 4090 bei RunPod zu 0,74 $/h (Listenpreis der Preisseite): 1,12 × 0,74 $ = 0,83 $

Größerer Lauf: 20.000 Beispiele × 1.000 Tokens × 2 Epochen = 40 Millionen Tokens ÷ 3.500 = 11.429 s, etwa 3,2 Stunden. Mit 50 Minuten desselben Drumherums sind es 4,0 Stunden: 1,24 $ bei Vast.ai oder 2,97 $ bei RunPod.

Für ein 32B-Modell listet RunPod im September 2026 48-GB-Karten zu 0,49 $/h (A40), 0,53 $/h (RTX A6000) und 1,09 $/h (L40S). Einen veröffentlichten Durchsatz für 32B-QLoRA auf diesen Karten habe ich nicht. Lassen Sie also 50 Schritte laufen, lesen Sie die Zeit pro Schritt aus dem Log ab und machen Sie dieselbe Multiplikation, bevor Sie sich auf einen langen Lauf festlegen.

Die Preise sind die Werte vom September 2026 von der Preisseite von RunPod und aus dem Tracker von getdeploying.com für Vast.ai. Secure- und Rechenzentrumsstufen kosten mehr als die günstigsten Community-Angebote. Das Gesamtbild steht im GPU-Preisvergleich.

Das Ergebnis bereitstellen

Sie haben zwei Möglichkeiten: den Adapter getrennt halten oder ihn ins Modell mergen.

Getrennt halten mit vLLM. vLLM lädt LoRA-Adapter neben dem Basismodell und stellt jeden unter einem eigenen Modellnamen auf seinem OpenAI-kompatiblen Server bereit:

vllm serve Qwen/Qwen3-8B --enable-lora --lora-modules invoices=./out/adapter

Clients senden dann "model": "invoices". Mehrere Adapter können sich ein Basismodell auf einer GPU teilen.

Mergen und in Ollama ausführen. Mergen Sie den Adapter in Gewichte mit voller Präzision, konvertieren Sie sie mit llama.cpp nach GGUF, quantisieren Sie und importieren Sie das Ergebnis:

import torch
from peft import AutoPeftModelForCausalLM
from transformers import AutoTokenizer

model = AutoPeftModelForCausalLM.from_pretrained("out/adapter", dtype=torch.bfloat16)
model.merge_and_unload().save_pretrained("merged")
AutoTokenizer.from_pretrained("Qwen/Qwen3-8B").save_pretrained("merged")

python llama.cpp/convert_hf_to_gguf.py merged --outfile invoices-bf16.gguf --outtype bf16
./llama.cpp/build/bin/llama-quantize invoices-bf16.gguf invoices-Q4_K_M.gguf Q4_K_M
echo "FROM ./invoices-Q4_K_M.gguf" > Modelfile
ollama create invoices -f Modelfile

Unsloth erledigt Merge und GGUF-Export in einem Aufruf (model.save_pretrained_gguf("dir", tokenizer, quantization_method="q4_k_m")). Die Doku warnt, dass die häufigste Ursache für schlechte Antworten nach dem Export das falsche Chat-Template ist: Stellen Sie das Modell mit dem Template bereit, mit dem Sie trainiert haben. Die Abwägungen zwischen Ollama, vLLM und TGI stehen in unserem Inferenz-Benchmark auf der RTX 4090.

Wo GPUFlow ins Spiel kommt

Das Training kann GPUFlow nicht übernehmen: Es vermietet eine OpenAI-kompatible API auf der GPU eines Anbieters, ohne Shell, SSH oder Dateizugriff. Ihr feingetuntes Modell kann es auch nicht bereitstellen. Mieter können keine Modelle hochladen; angeboten werden die Modelle, die der jeweilige Anbieter installiert hat (meist mit Ollama), etwa qwen2.5:7b oder llama3.1:8b.

Helfen kann es beim Schritt davor: für ein paar Cent prüfen, ob ein normales offenes Modell mit einem guten Prompt die Aufgabe schon erledigt. Das ist im Entscheidungsbaum das günstigste Ergebnis. Nutzen Sie dafür Testdaten, nicht die privaten Daten, um die es in dieser Anleitung geht: Prompts und Antworten laufen während der Miete im Klartext über den Rechner des Anbieters. Wie das funktioniert, steht im API-Schnellstart, und den API-Schlüssel in Apps nutzen zeigt, wie Sie ihn mit bestehenden Tools verbinden.

Quellen

Alle geprüft im September 2026.

• Paper: Hu et al., LoRA; Dettmers et al., QLoRA; Ovadia et al., Fine-Tuning or Retrieval?; Carlini et al., Extracting Training Data from Large Language Models
• Hugging Face TRL: SFT Trainer, PEFT-Integration und QLoRA
• Unsloth: Anforderungen und VRAM-Tabelle, Benchmarks, Speichern als GGUF, GitHub
• Axolotl auf GitHub
• Modell: Model Card von Qwen3-8B
• Trainingsdurchsatz: GigaGPU, Fine-Tuning auf der RTX 4090
• Hosts und Sicherheit: Sicherheits-FAQ von Vast.ai, Preise von Vast.ai, Überblick über Pods bei RunPod
• Preise: Preise von RunPod, getdeploying.com für Vast.ai und RTX 4090
• Bereitstellung: LoRA-Adapter in vLLM, Quantisierung mit llama.cpp, Import in Ollama
• GPUFlow: API-Schnellstart