Kann ich LLMs mit FrameTrain fine-tunen?

Ja. FrameTrain unterstützt das Fine-Tuning von Large Language Models (LLMs) via LoRA und QLoRA. Du kannst Modelle wie Llama, Mistral oder Phi direkt aus HuggingFace importieren und auf eigene Datensätze anpassen.

Welche GPUs werden unterstützt?

FrameTrain läuft auf allen NVIDIA-GPUs mit CUDA-Unterstützung (ab GTX 10-Serie) sowie auf Apple Silicon (M1/M2/M3/M4) über Metal Performance Shaders. Auch rein CPU-basiertes Training ist möglich.

Was ist der Unterschied zu Google Colab oder AWS SageMaker?

FrameTrain läuft vollständig lokal auf deinem Rechner. Es entstehen keine laufenden Cloud-Kosten, deine Daten werden nicht hochgeladen und du bist nicht auf Internetverbindung angewiesen. Ideal für sensible oder proprietäre Datensätze.

Brauche ich Programmierkenntnisse?

Nein. FrameTrain ist als grafische Anwendung konzipiert. Du konfigurierst Trainingsparameter über eine intuitive Oberfläche, ohne Code schreiben zu müssen. Für Fortgeschrittene gibt es zusätzlich Konfigurationsdateien.

Unterstützt FrameTrain LoRA-Training?

Ja, LoRA (Low-Rank Adaptation) ist vollständig integriert. Du kannst LoRA-Rank, Alpha und Target-Module direkt in der App konfigurieren, was das Fine-Tuning auch auf GPUs mit wenig VRAM ermöglicht.

Warum kostet FrameTrain nur 4,99 €/Monat?

FrameTrain befindet sich im Early Access. Der Preis ist bewusst niedrig, damit möglichst viele Entwickler und Forscher früh Zugang bekommen. Der Preis steigt auf 9,99 € nach den ersten 100 Nutzern – wer jetzt einsteigt, ist dauerhaft günstiger.

Läuft FrameTrain auf Apple M1/M2/M3/M4?

Ja. FrameTrain unterstützt Apple Silicon nativ über Metal Performance Shaders (MPS). Modelle werden auf der GPU des M-Chips beschleunigt, ohne CUDA zu benötigen.

Welche Modellformate werden unterstützt?

FrameTrain unterstützt PyTorch-Modelle (.pt, .bin), SafeTensors sowie GGUF-Format. Modelle können direkt von HuggingFace Hub importiert oder lokal geladen werden.

Kann ich meine eigenen Datensätze verwenden?

Ja. Du kannst eigene Datensätze im CSV-, JSON- oder JSONL-Format laden. FrameTrain unterstützt auch Datensätze direkt vom HuggingFace Datasets Hub.

Unterstützt FrameTrain Mixed Precision und Gradient Checkpointing?

Ja. FP16 und BF16 Mixed Precision Training sind vollständig unterstützt, ebenso Gradient Checkpointing für speichereffizientes Training auf GPUs mit wenig VRAM.

Docs KI-Training Coach🔧 Fine-Tuning Methoden

Full Fine-Tuning

Alle Modell-Parameter anpassen – maximale Kontrolle

Beim Full Fine-Tuning werden alle Parameter des Basismodells trainiert und angepasst. Maximale Ausdrucksstärke, aber maximaler Speicherbedarf.

Vor- und Nachteile

✓ Vorteile

Maximale Anpassungsfähigkeit
Beste mögliche Performance
Kein Extra-Overhead durch Adapter
Gut für fundamentale Domain-Shifts

✗ Nachteile

Riesiger VRAM-Bedarf (~28GB für 7B)
Catastrophic Forgetting möglich
Viel mehr Daten nötig
Jeder Checkpoint = volle Modellgröße

Catastrophic Forgetting – das Hauptrisiko

Beim Full Fine-Tuning kann das Modell sein allgemeines Vorwissen "vergessen", wenn es zu aggressiv auf neue Daten trainiert wird. Das passiert, wenn das neue Wissen die alten Gewichte überschreibt.

Gegenmassnahmen gegen Catastrophic Forgetting:

  1. Niedrige Learning Rate (1e-5 oder niedriger)
     → Kleine Updates erhalten vorhandenes Wissen

  2. Wenige Epochen (1–3)
     → Modell nicht zu lange auf neuen Daten "einschleifen"

  3. Elastic Weight Consolidation (EWC)
     → Bestraft starke Änderungen wichtiger Parameter
     → Komplexer, aber effektiv

  4. Replay (gemischtes Training)
     → Mix aus alten (generellen) und neuen (spezifischen) Daten
     → z.B. 80% neue Aufgabe + 20% allgemeine Texte

Full Fine-Tuning vs. LoRA: Wann was?

VRAM < 24 GBLoRA / QLoRAFull FT passt nicht in Speicher

VRAM 24–40 GB, maximale Performance gewünschtFull Fine-Tuning (bf16)Bestes Ergebnis wenn Speicher reicht

Wenig Trainingsdaten (< 1.000 Beispiele)LoRA (kleiner Rank)Weniger trainierbare Parameter = weniger Overfitting

Schnelle Iteration, viele ExperimenteLoRAKleinere Checkpoints, schneller Training

Mehrere Task-spezifische Versionen eines ModellsLoRA AdapterBasis-Modell einmal laden, Adapter tauschen

Modell soll fundamental neues Wissen lernenFull Fine-TuningAlle Schichten anpassen für tiefgreifende Änderungen

Full Fine-Tuning Checkliste

Bevor du Full Fine-Tuning startest: ✓ VRAM ≥ 24 GB, ✓ bf16 aktiviert, ✓ LR maximal 5e-5, ✓ maximal 3 Epochen geplant, ✓ Early Stopping aktiviert, ✓ Best Checkpoint Speicherung an.

LoRA im Detail

Low-Rank Adaptation – der Schlüssel zu effizientem Fine-Tuning

LoRA (Low-Rank Adaptation), eingeführt 2022 von Hu et al. (Microsoft), ist die wichtigste Technik für effizientes LLM Fine-Tuning. Es reduziert trainierbare Parameter um 99%+ bei minimalem Performance-Verlust.

Die mathematische Grundidee

Statt die gesamte Gewichtsmatrix W (d×d) zu verändern, friert LoRA W ein und fügt zwei kleine Matrizen A (d×r) und B (r×d) hinzu, deren Produkt die Änderung darstellt:

Standard Fine-Tuning:
  W_neu = W + ΔW    (ΔW hat selbe Größe wie W!)
  7B Modell: ΔW ≈ 7 Milliarden Parameter zu trainieren

LoRA:
  W_neu = W + B·A   (W bleibt eingefroren)
  A: d×r  (Downprojection)
  B: r×d  (Upprojection)

Beispiel (d=4096, r=16):
  Ursprüngliche Matrix:  4096 × 4096 = 16.7M Parameter
  LoRA Matrizen:         4096×16 + 16×4096 = 131K Parameter
  Reduktion:             99.2% weniger trainierbare Parameter!

  Beim Fine-Tuning:  Nur A und B werden trainiert
  B wird mit 0 initialisiert → zu Beginn: BA = 0 → kein Einfluss

LoRA-Architektur: eingefrorenes Basismodell + trainierbare Adapter

LoRA Hyperparameter erklärt

rank (r)

4, 8, 16, 32, 64

Bestimmt die "Kapazität" der LoRA-Adapter. Höherer Rank = mehr trainierbare Parameter = mehr Ausdrucksstärke, aber mehr Speicher und Overfitting-Risiko.

💡 r=8 für einfache Aufgaben/wenig Daten. r=16 für Standard. r=32–64 für komplexe Aufgaben mit viel Daten.

Speicher: r=8: ~2× weniger Parameter als r=16

alpha (α)

Typisch: gleich r oder 2×r (z.B. 16 oder 32)

Skalierungsfaktor für den LoRA-Update: tatsächlicher Update = (α/r) × B·A·x. Alpha/r bestimmt die "Lernstärke" der Adapter.

💡 α = r (Update-Stärke = 1) oder α = 2r (stärkere Updates). Starte mit α=16 (bei r=16).

Speicher: Kein Speicher-Effekt (nur Skalierungskonstante)

dropout

0.0 bis 0.1

Dropout innerhalb der LoRA-Adapter-Matrizen. Verhindert Overfitting der Adapter, besonders bei kleinen Datasets.

💡 0.05 Standard. Bei < 500 Beispielen: 0.1. Bei > 5.000 Beispielen: 0.0

Speicher: Kein Speicher-Effekt

target_modules

q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj

Welche Schichten des Transformers mit LoRA erweitert werden. Mehr Module = mehr trainierbare Parameter = bessere Performance, aber mehr Speicher.

💡 Minimum: q_proj + v_proj. Standard: alle Attention-Layer. Maximum: alle linear layers inklusive FFN.

Speicher: Jedes target_module fügt ~2×r Parameter pro Schicht hinzu

bias

"none" (Standard), "all", "lora_only"

Ob Bias-Parameter mittrainiert werden. "none" = nur LoRA-Matrizen. "all" = auch alle Biases.

💡 "none" ist Standard und reicht fast immer.

Speicher: "all" fügt minimal extra Parameter hinzu

LoRA für verschiedene Modelltypen

BERT / RoBERTaquery, value (attention)r=8–16LR: 2e-5

GPT-2c_attn, c_projr=8–16LR: 5e-5

LLaMA 2/3q_proj,k_proj,v_proj,o_projr=16–32LR: 2e-4

Mistral 7Bq_proj,k_proj,v_proj,o_projr=16LR: 2e-4

Phi-3 / Gemmaq_proj,v_projr=8–16LR: 1e-4

QLoRA (4-bit Fine-Tuning)

Noch effizienter: Quantisierung + LoRA kombiniert

QLoRA (Dettmers et al., 2023) kombiniert 4-bit Quantisierung des Basismodells mit LoRA-Adaptern in voller Präzision. Ergebnis: Ein 7B Modell in ~4 GB VRAM fine-tunen!

Wie QLoRA funktioniert

QLoRA = Quantisiertes Basismodell + LoRA

Schritt 1: Basismodell in 4-bit laden (NF4 Quantisierung)
  → 7B Modell: 28 GB (fp32) → ~4 GB (NF4)

Schritt 2: LoRA-Adapter in bf16/fp16 hinzufügen
  → Adapter bleiben in voller Präzision für Qualität

Schritt 3: Beim Training:
  → Forward Pass: 4-bit Gewichte on-the-fly auf bf16 "dequantisiert"
  → Gradienten nur für LoRA-Adapter (bf16)
  → Basismodell bleibt eingefroren und 4-bit

Gesamtspeicher 7B:
  Basismodell (NF4):    ~4 GB
  LoRA-Adapter (bf16):  ~0.3 GB
  Aktivierungen:        ~1 GB
  Optimizer States:     ~0.6 GB
  Total:                ~6 GB → RTX 3070 reicht!

NF4 Quantisierung – die Innovation hinter QLoRA

Standard int4-Quantisierung quantisiert Gewichte gleichmäßig. NF4 (4-bit NormalFloat) berücksichtigt, dass Transformer-Gewichte normalverteilt sind – es weist Bit-Werten die Grenzen zu, die die Normalverteilung optimal aufteilen:

Int4 (gleichmäßige Abstufungen):
  Bit-Werte: -8, -7, -6, ..., 7, 8  (16 Stufen)
  Problem: Die meisten Gewichte liegen nahe 0, 
           Extremwerte selten → schlechte Auflösung

NF4 (normalverteilte Abstufungen):
  Bit-Werte: -1, -0.69, -0.52, ..., 0.52, 0.69, 1
  (Quantile der Normalverteilung)
  Vorteil: Bessere Auflösung dort wo die meisten Gewichte liegen
  Ergebnis: Deutlich bessere Qualität als int4

QLoRA vs. LoRA vs. Full FT im Vergleich

Methode	VRAM (7B)	Qualität (rel.)	Geschw.	Empfehlung
Full FT (fp32)	~60 GB	100%	⭐⭐⭐	A100/H100 Cluster
Full FT (bf16)	~40 GB	99%	⭐⭐⭐	A100 40GB
Full FT (8-bit)	~30 GB	97%	⭐⭐	A100/RTX 3090×2
LoRA (bf16)	~16 GB	97%	⭐⭐⭐⭐	RTX 3090 / A6000
QLoRA (4-bit) ⭐	~6 GB	93–96%	⭐⭐⭐	RTX 3070/4060 Ti
QLoRA (4-bit, GC)	~4–5 GB	92–95%	⭐⭐	GTX 1660 Ti oder besser

GC = Gradient Checkpointing aktiv. Qualität bezogen auf Full FT fp32.

QLoRA: Die Demokratisierung des LLM-Trainings

Vor QLoRA benötigte 7B Fine-Tuning 28 GB+ VRAM (nur High-End-Server). Mit QLoRA funktioniert es auf einer RTX 3070 (8 GB VRAM). 13B Modelle sind mit 16 GB möglich. Das macht LLM Fine-Tuning für alle zugänglich.

Wann welche Fine-Tuning Methode?

Der vollständige Entscheidungsbaum

Die Wahl der Fine-Tuning-Methode hängt von VRAM, Datenmenge, Qualitätsanforderungen und Trainingsgeschwindigkeit ab. Dieser Entscheidungsbaum führt dich zur optimalen Wahl.

Schritt-für-Schritt Entscheidungsbaum

1. VRAM ermitteln

Wie viel GPU-VRAM hast du?

< 6 GB→ QLoRA mit Gradient CheckpointingEinzige realistische Option. RTX 3060 6GB: 7B mit QLoRA gerade so möglich.

6–10 GB→ QLoRA oder LoRA (kleines Modell)RTX 3070/4060 Ti: QLoRA für 7B, LoRA für 1B–3B Modelle.

12–16 GB→ LoRA (fp16/bf16) für 7BRTX 3080/4070: Standard LoRA sehr komfortabel. QLoRA für 13B.

24+ GB→ Full FT oder LoRARTX 3090/4090: Full FT für kleine Modelle, LoRA für 7B sehr effizient.

2. Datenmenge prüfen

Wie viele Trainingsbeispiele hast du?

< 200 Beispiele→ LoRA rank=4–8, hoher DropoutWenige Parameter trainieren = weniger Overfitting-Risiko.

200–2.000 Beispiele→ LoRA rank=8–16Standard Setup. Early Stopping aktivieren.

> 2.000 Beispiele→ LoRA rank=16–32 oder Full FT (wenn VRAM)Genug Daten für mehr Modellkapazität.

3. Use Case bewerten

Was soll das Modell lernen?

Stil/Ton anpassen→ LoRA rank=4–8 reichtEinfache Aufgabe – wenig LoRA-Kapazität nötig.

Neue Domäne lernen→ LoRA rank=16–32Mehr Kapazität für neues Domänenwissen.

Fundamental neu trainieren→ Full Fine-TuningWenn Modell sein Kernverhalten ändern soll.

Mehrere Tasks, ein Modell→ LoRA Adapter pro TaskBasis-Modell einmal, Adapter für jeden Task separat.

Quick-Reference Tabelle

Szenario	Methode	Rank	LR	Epochen
7B LoRA, RTX 3070	QLoRA	16	2e-4	3–5
7B LoRA, RTX 3090	LoRA (bf16)	16	2e-4	3–5
1B Full FT, RTX 3080	Full FT (bf16)	—	5e-5	2–3
BERT Klassifikation	Full FT oder LoRA	8	2e-5	3
Wenig Daten (< 300)	QLoRA rank=4	4	1e-4	5–10
Viel Daten (> 10K)	LoRA rank=32	32	2e-4	1–3

FrameTrain Empfehlung für 90% der Fälle

LoRA (rank=16) + QLoRA wenn VRAM knapp + Early Stopping + Cosine LR Decay + weight_decay=0.01 + warmup=5% der Steps. Damit funktioniert nahezu jedes Fine-Tuning-Projekt.

Zurück

⚙️ Hyperparameter

Weiter

📦 Dataset-Mastery