Wichtigste Erkenntnisse
- LoRA = Kleine trainierbare Schichten zu einem vorgefertigten Modell hinzufügen. Nur 1–5 % der Modellgewichte sind trainierbar, wodurch VRAM und Zeit drastisch sinken.
- Fine-Tuning-Anforderungen: 500–1000 hochwertige Beispiele, 8–16 GB VRAM, 1–4 Stunden Trainingszeit.
- Beste Tools: Unsloth (schnellstes), Hugging Face TRL, Axolotl (am flexibelsten).
- LoRA-Rang (r): Niedriger (r=8) ist kleiner, schneller; höher (r=64) ist ausdrucksvoller. Standard: r=16–32.
- Ab April 2026 ist LoRA produktionsreif und weitgehend über Inference Engines unterstützt.
Wie funktioniert LoRA?
LoRA fügt kleine „Adapter"-Matrizen neben den ursprünglichen Modellgewichten hinzu. Während des Trainings werden nur die Adapter aktualisiert. Ursprüngliche Gewichte bleiben eingefroren.
Beispiel: Ein 13B Modell hat 13 Milliarden Gewichte. LoRA fügt nur 50 Millionen trainierbare Parameter hinzu (~0,4 % der ursprünglichen). Training ist 100× schneller.
Bei Inferenz wird die Adapter-Ausgabe über Matrizenmultiplikation mit der Hauptmodellausgabe zusammengeführt. Minimale Geschwindigkeitseinbuße (~5 %).
Ergebnis: Ein domänenspezifisches Modell, das bei Ihren Aufgaben besser funktioniert, benötigt aber nur 8 GB VRAM statt 26 GB.
Was ist QLoRA (4-Bit quantisiertes LoRA)?
QLoRA verbindet LoRA mit 4-Bit-Quantisierung — das Basismodell lädt in 4-Bit (QLoRA), während nur der Adapter in 16-Bit trainiert wird. Dies halbiert die VRAM-Anforderungen:
Ab April 2026 ist QLoRA der Standard für Consumer-Hardware. Unsloth's `load_in_4bit=True` Flag im Code-Beispiel oben aktiviert QLoRA automatisch. Der 2 %ige Qualitätsunterschied zu vollständigem LoRA ist für die meisten Domänenanpassungsaufgaben vernachlässigbar.
Wann LoRA (16-Bit) statt QLoRA (4-Bit) verwenden:
• Aufgaben, die maximale Präzision erfordern (medizinisch, Rechtsdokument-Analyse)
• Sie haben 16+ GB VRAM verfügbar
• Fine-Tuning von 3B oder kleineren Modellen (QLoRA-Einsparungen sind bei kleinen Größen minimal)
| Methode | 7B Modell VRAM | 13B Modell VRAM | Qualität vs Vollständig |
|---|---|---|---|
| Vollständiges Fine-Tuning | 28 GB | 52 GB | 100 % (Baseline) |
| LoRA (16-Bit Basis) | 16 GB | 30 GB | ~97 % |
| QLoRA (4-Bit Basis) | 8 GB | 14 GB | ~95 % |
Fine-Tuning oder RAG?
Entscheidungsmatrix:
Stellen Sie vor einer LoRA-Feinabstimmung sicher, dass besseres Prompting das Problem nicht zuerst lösen kann — Prompt Engineering ist schneller, reversibel und modellunabhängig. Das vollständige Entscheidungs-Framework finden Sie unter Prompt Engineering vs. Fine-Tuning: Wie Sie entscheiden.
Fine-Tuning ist ein Weg, um einen Coding-Workflow auch offline produktiv zu halten. Für das umfassendere Offline-Setup — Modell, IDE, Paket-Cache, Dokumentations-Mirror — siehe Lokales Coding-LLM ohne Internet.
| Kriterium | Fine-Tuning | RAG |
|---|---|---|
| Dokumentenänderungshäufigkeit | Jährlich oder seltener | Wöchentlich oder häufiger |
| Wissenserfordernisse | Modell braucht tiefes Verständnis | Abruf genügt |
| Trainingsdaten verfügbar | Benötigt 500+ hochwertige Beispiele | Beliebige Dokumente funktionieren |
| Kosten (langfristig) | Einmalzahlung ($50–200) | Kontinuierliche Embeddings |
| Latenz | Schneller (kein Abruf) | Langsamer (Abruf + LLM) |
| Best für | Code, Kreatives Schreiben, Domain-Stil | Wissensdatenbanken, Fragen & Antworten |
Wie bereiten Sie Trainingsdaten vor?
Qualität der Trainingsdaten bestimmt Fine-Tuning-Erfolg. Schlechte Daten = schlechtes Modell.
Minimum: 500 Beispiele. Jedes Beispiel = Eingabe + erwartete Ausgabe.
Optimal: 1000–5000 Beispiele. Mehr Daten = bessere Genauigkeit.
Format: JSON oder JSONL. Jede Zeile = ein Trainingsbeispiel.
[\n {"instruction": "Ins Englische übersetzen", "input": "Bonjour le monde", "output": "Hello world"},\n {"instruction": "Zusammenfassen", "input": "Langer Text...", "output": "Zusammenfassung..."},\n {"instruction": "Code-Review", "input": "Python-Code...", "output": "Review-Kommentare..."}\n]\n\n# ODER Nur-Anleisungs-Format:\n[\n {"text": "<|user|>Ins Englische übersetzen\nBonjour<|assistant|>Hello"},\n {"text": "<|user|>Zusammenfassen\nText<|assistant|>Zusammenfassung"}\n]
Fine-Tuning-Setup mit Unsloth
Unsloth ist das schnellste LoRA-Framework (4× Geschwindigkeit vs Standard-Training):
# Unsloth installieren\npip install unsloth[colab-new] xformers bitsandbytes\n\nfrom unsloth import FastLanguageModel\nfrom datasets import load_dataset\n\n# Basismodell mit LoRA laden\nmodel, tokenizer = FastLanguageModel.from_pretrained(\n model_name="unsloth/llama-3.1-8b-bnb-4bit",\n max_seq_length=2048,\n load_in_4bit=True,\n lora_r=16, lora_alpha=32,\n lora_dropout=0.05\n)\n\n# Trainingsdaten laden\ndataset = load_dataset("json", data_files="training.jsonl")\n\n# Trainer konfigurieren\nfrom trl import SFTTrainer\ntrainer = SFTTrainer(\n model=model,\n tokenizer=tokenizer,\n train_dataset=dataset["train"],\n dataset_text_field="text",\n max_seq_length=2048,\n args=TrainingArguments(\n per_device_train_batch_size=4,\n num_train_epochs=3,\n learning_rate=2e-4,\n output_dir="output"\n )\n)\n\n# Trainieren\ntrainer.train()Wichtige Hyperparameter für LoRA Fine-Tuning
| Hyperparameter | Empfohlener Wert | Typischer Bereich | Effekt |
|---|---|---|---|
| learning_rate | 2e-4 | 1e-5 bis 1e-3 | Niedriger = stabil, langsamere Konvergenz |
| lora_r (Rang) | 16 | 4 bis 64 | Höher = ausdrucksvoller, langsamer |
| lora_alpha | 32 | 8 bis 256 | Höher = stärkerer LoRA-Effekt |
| num_train_epochs | 3 | 1 bis 10 | Mehr Epochen = Überanpassungsrisiko |
| batch_size | 4 | 1 bis 32 | Größer = schnelleres Training, mehr VRAM |
| warmup_steps | 100 | 0 bis 1000 | Graduelle LR-Erhöhung, stabilisiert Training |
Wie bewerten Sie fine-getunete Modelle?
Trainingsverlust: Sollte über Epochen abnehmen. Wenn flach, kann die Learning Rate zu niedrig sein.
Validierungsverlust: Sollte abnehmen, aber über dem Trainingsverlust bleiben (normal). Wenn steigt, Überanpassung.
Manuelles Testen: Führen Sie das fine-getunete Modell auf Test-Beispielen aus und vergleichen Sie Ausgaben mit erwarteten Ergebnissen.
Benchmark-Aufgaben: Verwenden Sie Standard-Benchmarks (MMLU, HumanEval), um Verbesserungen zu messen.
Welche sind die häufigsten Fine-Tuning-Fehler?
- Zu wenige Trainingsbeispiele. <200 Beispiele führen oft zu Überanpassung. Sammeln Sie mindestens 500.
- Zu viele Epochen trainieren. Modell merkt sich Daten, anstatt verallgemeinerbare Muster zu lernen. Maximum 3–5 Epochen.
- Nicht auf ungesehenen Daten validieren. Immer Daten in Training/Validierung (80/20) aufteilen. Häufig validieren, um Überanpassung zu erkennen.
- Gleiche Daten für Fine-Tuning und Evaluation. Gemeldete Genauigkeit ist bedeutungslos, wenn auf Trainingsdaten bewertet.
- Keine Checkpoints speichern. Training kann Stunden dauern. Speichern Sie jede Epoche, um von Abstürzen zu genesen.
Häufig gestellte Fragen zu LoRA Fine-Tuning
Wie viele Trainingsdaten werden benötigt?
Mindestens 500 Beispiele, optimal 1000–5000. Qualität ist wichtiger als Quantität. 100 hochwertige Beispiele > 1000 schlechte Beispiele.
Kann ich auf einem Laptop fine-tunen?
Ja. Verwenden Sie 4-Bit-Quantisierung und LoRA. Ein 7B Modell erfordert 8 GB VRAM; Training dauert 1–2 Stunden auf CPU (langsam) oder 10–15 Min. auf GPU.
Wie merge ich LoRA Adapter ins Basismodell?
Verwenden Sie Unsloth oder HF Transformers: `model.merge_and_unload()`. Erstellt eine einzelne Modelldatei (~3–4 GB für 7B), bereit für Inferenz.
Kann ich mehrere LoRA Adapter kombinieren?
Ja, mit Einschränkungen. Stack Adapter für sequentielle Anwendung, oder verwenden Sie Adapter-Kompositionstechniken (z. B. DoRA).
Ist die Qualität des fine-getuneeten Modells besser als RAG?
Für die meisten Aufgaben ja. Fine-getunete Modelle verstehen Domain-Konzepte tief. RAG ist besser, wenn Dokumente groß sind und häufig ändern.
Was ist der Unterschied zwischen LoRA und QLoRA?
LoRA lädt das Basismodell in 16-Bit und trainiert kleine Adapter-Schichten. QLoRA lädt das Basismodell in 4-Bit und trainiert Adapter in 16-Bit. QLoRA verbraucht ungefähr die Hälfte des VRAM: 8 GB für 7B vs 16 GB für LoRA. Qualitätsunterschied ~2 % — für die meisten Aufgaben vernachlässigbar. Unsloth aktiviert QLoRA mit `load_in_4bit=True`.
Wie verwende ich ein LoRA fine-getuneetes Modell in Ollama?
Nach dem Training merge den Adapter ins Basismodell: `model.merge_and_unload()`. Konvertieren Sie zu GGUF mit llama.cpp's `convert.py`. Erstellen Sie eine Ollama Modelldatei, die auf die GGUF-Datei zeigt: `FROM ./my-finetuned-model.gguf`. Dann: `ollama create my-model -f Modelfile` und `ollama run my-model`. Das fine-getunete Modell läuft identisch zu jedem Ollama-Modell.
Kann ich Llama 3.3 70B mit LoRA auf Consumer-Hardware fine-tunen?
Ja, mit QLoRA. Llama 3.3 70B bei 4-Bit erfordert ~40 GB VRAM — passt auf Dual RTX 4090 (2×24 GB) oder eine einzelne A100 80GB. Trainingszeit: 4–8 Stunden auf 1.000 Beispielen. Für die meisten Benutzer ist Fine-Tuning von 7B oder 13B Modellen praktischer und ergibt 90 %+ der 70B Qualitätsgewinne für Domain-Aufgaben.
Muss ich bei der Verwendung von LoRA Fine-Tuning die DSGVO beachten?
Ja. Lokal trainierte Modelle auf eigener Hardware erfüllen DSGVO Artikel 28 (Auftragsverarbeitung). Ihre Trainingsdaten verlassen nicht Ihre Infrastruktur. Dokumentieren Sie das Training und Speicherung als Teil Ihrer DSGVO-Compliance. Für Unternehmen empfohlen: Implementieren Sie Datenlöschung nach Training und Zugriffskontrolle basierend auf BSI-Grundschutz-Katalogen.
Ist LoRA Fine-Tuning für den deutschen Mittelstand geeignet?
Ja, besonders gut für KMUs (100–1000 Mitarbeiter). Hardware kostet ca. €50–150 (Kauf einer RTX 4060 oder RTX 3060), Training kostet Null danach. Unsloth läuft auf Standard-Laptops (8 GB RAM reicht). Empfohlen für Mittelstand: Verwenden Sie lokal fine-getunete Modelle für vertrauliche Kundeninformationen, um Lizenzkosten zu vermeiden und Compliance (DSGVO, BSI) zu erfüllen. Viele Mittelstands-IT-Teams haben bereits lokale GPU-Hardware für CAD oder Rendering — diese können zu LoRA-Training wiederverwendet werden.
Quellen
- Hu, E. et al. (2021). "LoRA: Low-Rank Adaptation of Large Language Models." https://arxiv.org/abs/2106.09685 — Original-LoRA-Paper demonstriert 0,4 % trainierbare Parameter, die vollständiges Fine-Tuning-Qualität erreichen.
- Dettmers, T. et al. (2023). "QLoRA: Efficient Finetuning of Quantized LLMs." https://arxiv.org/abs/2305.14314 — QLoRA-Paper: 4-Bit quantisiertes Basismodell + 16-Bit LoRA Adapter halbiert VRAM-Anforderungen.
- Unsloth. (2026). "Unsloth: 4× Faster LoRA Training." https://github.com/unslothai/unsloth — Schnellstes LoRA-Framework, unterstützt Llama 3.x, Qwen2.5, Mistral mit 4× Trainings-Speedup.
- Hugging Face. (2025). "TRL: Transformer Reinforcement Learning." https://github.com/huggingface/trl — SFTTrainer für überwachtes Fine-Tuning mit LoRA Adapter-Unterstützung.