Fine-Tuning in der Praxis

Wann Fine-Tuning – und wann nicht?

Fine-Tuning ist mächtig, aber es ist nicht die Lösung für jedes Problem. Die häufigste Fehlannahme: „Wenn ich das Modell auf meinen Daten trainiere, kennt es mein Unternehmen besser.” Das stimmt nur bedingt.

Fine-Tuning ist gut für:

• Konsistenter Stil und Ton: Das Modell schreibt immer in deiner Markensprache
• Spezifisches Ausgabeformat: Immer valides JSON, immer dieselbe Struktur
• Domänenvokabular: Fachbegriffe korrekt verwenden, Abkürzungen verstehen
• Kürzere Prompts: Was du jetzt im System Prompt erklärst, kann das Modell „wissen”
• Latenz und Kosten: Kleineres Fine-Tuned Modell kann besser sein als großes Basismodell

Fine-Tuning ist schlecht für:

• Neues Faktenwissen einbringen: Das Modell halluziniert trotzdem – dafür ist RAG besser
• Aktuelle Daten: Fine-Tuning ist statisch, RAG ist dynamisch
• Schnelle Iteration: Fine-Tuning dauert Stunden bis Tage, Prompt-Änderungen Sekunden
• Kleine Datensätze unter 50 Beispielen: Zu wenig für stabiles Lernen

Entscheidungsbaum:
Problem → Prompt Engineering ausreichend? → Ja: fertig
         → Nein → Wissen/aktuelle Daten? → Ja: RAG
                → Nein → Stil/Format/Verhalten? → Ja: Fine-Tuning
                        → Nein → Kombination RAG + Fine-Tuning

Wie Fine-Tuning funktioniert

Beim Fine-Tuning wird ein vortrainiertes Modell auf einem kleineren, spezifischen Datensatz weitertrainiert. Die Gewichte des Modells werden angepasst – es „lernt” das neue Verhalten dauerhaft.

Vortrainiertes Modell (Milliarden Parameter, allgemeines Wissen)
         ↓
Fine-Tuning auf 500 Beispielen (dein spezifischer Use Case)
         ↓
Fine-Tuned Modell (allgemeines Wissen + spezifisches Verhalten)

Full Fine-Tuning vs. LoRA

Full Fine-Tuning aktualisiert alle Parameter des Modells – extrem rechenintensiv. Ein 7B-Modell braucht 4× A100 GPUs (ca. $10/h).

LoRA (Low-Rank Adaptation) ist die praktische Alternative: Statt alle Gewichte zu ändern, werden kleine Adapter-Matrizen trainiert die auf das Basismodell aufgesetzt werden.

Full Fine-Tuning: 7B Parameter × 4 Bytes = 28 GB VRAM (minimum)
LoRA:             ~10M trainierbare Parameter = 2-4 GB VRAM

QLoRA kombiniert LoRA mit Quantisierung (4-bit): Ein 7B-Modell passt auf eine RTX 4090 (24 GB VRAM) – Consumer-Hardware.

Daten vorbereiten

Datenqualität ist der wichtigste Faktor. Schlechte Daten → schlechtes Modell, egal wie lange du trainierst.

Format für OpenAI Fine-Tuning (JSONL)

{"messages": [{"role": "system", "content": "Du bist ein präziser technischer Redakteur."}, {"role": "user", "content": "Erkläre RAG in einem Satz."}, {"role": "assistant", "content": "RAG (Retrieval Augmented Generation) kombiniert Sprachmodelle mit einer Wissensdatenbank, um Antworten auf Basis aktueller Dokumente statt nur auf Trainingswissen zu generieren."}]}
{"messages": [{"role": "system", "content": "Du bist ein präziser technischer Redakteur."}, {"role": "user", "content": "Was ist ein Embedding?"}, {"role": "assistant", "content": "Ein Embedding ist eine numerische Vektordarstellung von Text, bei der semantisch ähnliche Texte ähnliche Vektoren haben."}]}

Qualitätskriterien für Trainingsdaten

• Konsistenz: Alle Beispiele folgen demselben Stil und Format
• Korrektheit: Keine falschen Informationen – das Modell lernt auch Fehler
• Diversität: Verschiedene Eingaben, nicht nur Variationen desselben Satzes
• Repräsentativität: Die Beispiele spiegeln echte Nutzungsszenarien wider
• Kein Bias: Keine systematischen Verzerrungen in den Ausgaben

import json

def validate_training_data(filepath: str) -> dict:
    """Prüft JSONL-Datei auf häufige Probleme."""
    issues = []
    examples = []

    with open(filepath) as f:
        for i, line in enumerate(f):
            try:
                example = json.loads(line)
                examples.append(example)

                # Pflichtfelder prüfen
                if "messages" not in example:
                    issues.append(f"Zeile {i+1}: 'messages' fehlt")
                    continue

                messages = example["messages"]
                roles = [m["role"] for m in messages]

                # Muss user und assistant enthalten
                if "user" not in roles:
                    issues.append(f"Zeile {i+1}: Kein 'user' Message")
                if "assistant" not in roles:
                    issues.append(f"Zeile {i+1}: Kein 'assistant' Message")

                # Leere Inhalte prüfen
                for msg in messages:
                    if not msg.get("content", "").strip():
                        issues.append(f"Zeile {i+1}: Leerer Content in '{msg['role']}'")

            except json.JSONDecodeError as e:
                issues.append(f"Zeile {i+1}: Ungültiges JSON – {e}")

    return {
        "total": len(examples),
        "issues": issues,
        "valid": len(examples) - len(issues)
    }

result = validate_training_data("training_data.jsonl")
print(f"Gesamt: {result['total']}, Valide: {result['valid']}")
for issue in result["issues"]:
    print(f"  ⚠️  {issue}")

Fine-Tuning mit der OpenAI API

from openai import OpenAI
import time

client = OpenAI()

# 1. Datei hochladen
with open("training_data.jsonl", "rb") as f:
    file = client.files.create(file=f, purpose="fine-tune")
print(f"File ID: {file.id}")

# 2. Fine-Tuning starten
job = client.fine_tuning.jobs.create(
    training_file=file.id,
    model="gpt-4o-mini",
    hyperparameters={
        "n_epochs": 3,           # Wie oft über die Daten iterieren
        "batch_size": "auto",    # Automatisch basierend auf Datenmenge
        "learning_rate_multiplier": "auto"
    }
)
print(f"Job ID: {job.id}")

# 3. Status überwachen
while True:
    job = client.fine_tuning.jobs.retrieve(job.id)
    print(f"Status: {job.status}")

    if job.status in ["succeeded", "failed", "cancelled"]:
        break
    time.sleep(60)

# 4. Fine-Tuned Modell nutzen
if job.status == "succeeded":
    model_id = job.fine_tuned_model
    print(f"Modell: {model_id}")

    response = client.chat.completions.create(
        model=model_id,
        messages=[{"role": "user", "content": "Erkläre Transformer in einem Satz."}]
    )
    print(response.choices[0].message.content)

Fine-Tuning mit Hugging Face und LoRA

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model, TaskType
from trl import SFTTrainer
from datasets import load_dataset

# Basismodell laden (4-bit quantisiert für weniger VRAM)
model_name = "mistralai/Ministral-3-8B-Instruct-2412"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    load_in_4bit=True,      # QLoRA: 4-bit Quantisierung
    device_map="auto"
)

# LoRA Konfiguration
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,               # Rank: höher = mehr Parameter, mehr Kapazität
    lora_alpha=32,      # Skalierungsfaktor
    lora_dropout=0.1,
    target_modules=["q_proj", "v_proj"]  # Welche Layer anpassen
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 9,437,184 || all params: 3,761,856,512 || trainable%: 0.25

# Training
dataset = load_dataset("json", data_files="training_data.jsonl")

training_args = TrainingArguments(
    output_dir="./fine-tuned-model",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    fp16=True,
    save_steps=100,
    logging_steps=10,
)

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    tokenizer=tokenizer,
    dataset_text_field="text",
    max_seq_length=512,
)

trainer.train()
trainer.save_model("./fine-tuned-model")

Evaluation: Wie gut ist das Fine-Tuned Modell?

Ohne Evaluation ist Fine-Tuning Blindflug. Definiere Erfolgskriterien vor dem Training.

Automatische Metriken

from openai import OpenAI
import json

client = OpenAI()

def evaluate_model(model_id: str, test_cases: list[dict]) -> dict:
    """Vergleicht Fine-Tuned Modell mit Baseline."""
    results = []

    for case in test_cases:
        # Fine-Tuned Modell
        ft_response = client.chat.completions.create(
            model=model_id,
            messages=[{"role": "user", "content": case["input"]}],
            temperature=0
        ).choices[0].message.content

        # Baseline
        base_response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": case["input"]}],
            temperature=0
        ).choices[0].message.content

        # Automatische Bewertung durch GPT-5
        eval_prompt = f"""Bewerte welche Antwort besser ist für folgende Aufgabe:
Aufgabe: {case['input']}
Erwartetes Verhalten: {case['expected_behavior']}

Antwort A: {ft_response}
Antwort B: {base_response}

Antworte als JSON: {{"winner": "A"|"B"|"tie", "reason": "..."}}"""

        eval = json.loads(client.chat.completions.create(
            model="gpt-5",
            messages=[{"role": "user", "content": eval_prompt}],
            response_format={"type": "json_object"}
        ).choices[0].message.content)

        results.append({**eval, "input": case["input"]})

    wins_ft = sum(1 for r in results if r["winner"] == "A")
    wins_base = sum(1 for r in results if r["winner"] == "B")

    return {
        "fine_tuned_wins": wins_ft,
        "baseline_wins": wins_base,
        "ties": len(results) - wins_ft - wins_base,
        "win_rate": wins_ft / len(results)
    }

Wann ist Fine-Tuning erfolgreich?

• Win Rate > 60% gegenüber Baseline: Fine-Tuning hat geholfen
• Konsistenz: Ausgaben folgen immer dem gewünschten Format
• Keine Regression: Das Modell ist bei allgemeinen Aufgaben nicht schlechter geworden
• Kosten: Fine-Tuned kleineres Modell ist günstiger als Baseline-Großmodell

Kosten und Infrastruktur

Ansatz	Hardware	Kosten Training	Kosten Inferenz
OpenAI Fine-Tuning	Keine eigene	$0.30/1M Tokens	$0.60/1M Tokens (Fine-Tuned gpt-4o-mini)
Hugging Face + A100	Cloud GPU	$3–5/h × 2–8h	Eigener Server
QLoRA + RTX 4090	Eigene GPU	Strom (~$0.50/h)	Eigener Server
Hugging Face AutoTrain	Keine eigene	$10–50 pro Job	Eigener Server

Faustregel: Für den Einstieg OpenAI Fine-Tuning – kein Setup, einfache API. Für Open-Source-Modelle und volle Kontrolle: Hugging Face mit QLoRA auf einer Cloud-GPU.

Häufige Fehler und wie du sie vermeidest

Problem: „Fine-Tuning hat nichts verbessert”

Ursache: Zu wenige oder zu schlechte Trainingsdaten, oder das Problem wäre besser mit Prompt Engineering oder RAG gelöst. Lösung: Zuerst prüfen ob Prompt Engineering ausreicht. Datenqualität vor Datenmenge – 100 perfekte Beispiele schlagen 1000 mittelmäßige. Evaluation-Set definieren und Win Rate messen.

Problem: „Das Fine-Tuned Modell halluziniert mehr als vorher”

Ursache: Trainingsdaten enthalten Fehler oder Inkonsistenzen – das Modell hat schlechte Muster gelernt. Lösung: Trainingsdaten manuell prüfen. Keine widersprüchlichen Beispiele. Faktenaussagen in den Trainingsdaten verifizieren. Evaluation auf allgemeinen Aufgaben: Fine-Tuning darf keine Regression erzeugen.

Problem: „Das Modell overfittet auf die Trainingsdaten”

Ursache: Zu viele Epochen, zu wenige Daten, oder zu hohe Learning Rate. Lösung: n_epochs reduzieren (1–3 statt 10+). Validation Loss überwachen – steigt er während Training Loss sinkt, ist Overfitting im Gange. Mehr diverse Trainingsdaten beschaffen.

Problem: „Fine-Tuning ist teurer als erwartet”

Ursache: Zu viele Tokens pro Beispiel, zu viele Epochen, oder falsches Modell gewählt. Lösung: Beispiele auf das Wesentliche kürzen. gpt-4o-mini statt größerer Modelle für Fine-Tuning – oft ausreichend und deutlich günstiger. Token-Kosten vor dem Start mit der OpenAI Tokenizer-API schätzen.