Fine-tuning — KI-Modell an Ihre Daten anpassen

Fine-Tuning ist eine fortgeschrittene Technik, die es Ihnen ermöglicht, ein vortrainiertes KI-Modell an Ihre spezifischen Daten und Bedürfnisse anzupassen. Mit dieser Methode können Sie die Modellleistung in einer bestimmten Domäne oder Aufgabe erheblich verbessern.

Was ist Fine-Tuning und warum brauchen Sie es¶

Fine-Tuning ist der Prozess des Weitertrainierens eines vortrainierten KI-Modells auf spezifischen Daten, der es Ihnen ermöglicht, ein allgemeines Modell an Ihre konkreten Anforderungen anzupassen. Anstatt ein Modell von Grund auf zu trainieren, nutzen Sie bereits erlernte Kenntnisse und erweitern diese lediglich um Ihre Domäne.

Hauptvorteile des Fine-Tunings:

• Deutlich geringere Rechenanforderungen als Training von Grund auf
• Bessere Ergebnisse bei spezifischen Aufgaben als allgemeine Modelle
• Möglichkeit, kleinere Datensätze zu nutzen (Hunderte bis Tausende Beispiele)
• Erhaltung des allgemeinen Wissens des Basismodells

Wann Fine-Tuning statt Prompt Engineering verwenden¶

Fine-Tuning ist nicht immer die beste Lösung. Der Entscheidungsprozess sollte folgendermaßen aussehen:

Verwenden Sie Prompt Engineering, wenn:

• Sie eine schnelle Lösung ohne zusätzliche Kosten benötigen
• Sie nur wenige Beispiele haben (weniger als 100)
• Die Aufgabe allgemein und gut beschreibbar ist

Verwenden Sie Fine-Tuning, wenn:

• Sie eine spezifische Domäne mit eigener Terminologie haben
• Sie ein konsistentes Antwortformat benötigen
• Sie über einen qualitativ hochwertigen Datensatz verfügen (100+ Beispiele)
• Sie Latenz und Inferenzkosten reduzieren möchten

Arten des Fine-Tunings¶

Full Fine-Tuning¶

Aktualisiert alle Modellparameter. Am effektivsten, aber auch am anspruchsvollsten hinsichtlich Rechenressourcen und Speicher.

Parameter Efficient Fine-Tuning (PEFT)¶

Moderner Ansatz, der nur einen kleinen Teil der Parameter aktualisiert. Haupttechniken:

• LoRA (Low-Rank Adaptation): Fügt kleine Adaptionsschichten hinzu
• QLoRA: LoRA mit Quantisierung für noch geringere Speicheranforderungen
• Adapter Layers: Fügt kleine Schichten zwischen bestehende Schichten ein
• Prefix Tuning: Optimiert nur spezielle Prefix-Token

Praktische Implementierung mit LoRA¶

Beispiel für Fine-Tuning mit Hugging Face Transformers und der PEFT-Bibliothek:

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model, TaskType
from datasets import Dataset
import torch

# Fine-tuning — KI-Modell an Ihre Daten anpassen
model_name = "microsoft/DialoGPT-medium"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# LoRA-Konfiguration
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,  # Rang - höher = mehr Parameter
    lora_alpha=32,
    lora_dropout=0.1,
    target_modules=["c_attn", "c_proj"]  # welche Schichten anpassen
)

# LoRA auf Modell anwenden
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

Vorbereitung der Trainingsdaten¶

def prepare_dataset(examples):
    """Daten für kausale Sprachmodellierung vorbereiten"""
    inputs = []
    for example in examples:
        # Format: "Frage: {question} Antwort: {answer}"
        text = f"Frage: {example['question']} Antwort: {example['answer']}"
        inputs.append(text)

    # Tokenisierung
    model_inputs = tokenizer(
        inputs,
        truncation=True,
        padding=True,
        max_length=512,
        return_tensors="pt"
    )

    # Für kausales LM sind Labels gleich den input_ids
    model_inputs["labels"] = model_inputs["input_ids"].clone()
    return model_inputs

# Beispieldaten
train_data = [
    {"question": "Wie funktioniert Docker?", "answer": "Docker ist eine Containerisierungsplattform..."},
    {"question": "Was ist Kubernetes?", "answer": "Kubernetes ist ein Orchestrierungssystem..."},
    # ... weitere Beispiele
]

dataset = Dataset.from_list(train_data)
tokenized_dataset = dataset.map(prepare_dataset, batched=True)

Training starten¶

from transformers import Trainer, DataCollatorForLanguageModeling

# Trainingskonfiguration
training_args = TrainingArguments(
    output_dir="./fine-tuned-model",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    warmup_steps=100,
    learning_rate=5e-5,
    logging_steps=10,
    save_steps=500,
    evaluation_strategy="steps",
    eval_steps=500,
    fp16=True,  # zur Speichereinsparung
)

# Data Collator für Sprachmodellierung
data_collator = DataCollatorForLanguageModeling(
    tokenizer=tokenizer,
    mlm=False  # kausales LM, nicht maskiertes LM
)

# Trainer initialisieren
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    data_collator=data_collator,
)

# Training starten
trainer.train()
trainer.save_model()

Monitoring und Evaluierung¶

Korrektes Monitoring des Fine-Tuning-Fortschritts ist entscheidend:

# Metriken während des Trainings verfolgen
import wandb

# Integration mit Weights & Biases
wandb.init(project="fine-tuning-experiment")

# Evaluierungsfunktion
def compute_perplexity(eval_dataset):
    """Perplexity auf dem Evaluierungsdatensatz berechnen"""
    model.eval()
    total_loss = 0
    num_batches = 0

    with torch.no_grad():
        for batch in eval_dataset:
            outputs = model(**batch)
            total_loss += outputs.loss.item()
            num_batches += 1

    avg_loss = total_loss / num_batches
    perplexity = torch.exp(torch.tensor(avg_loss))
    return perplexity.item()

# Generierte Antworten testen
def test_generation(prompt, max_length=100):
    """Textgenerierung testen"""
    inputs = tokenizer.encode(prompt, return_tensors="pt")

    with torch.no_grad():
        outputs = model.generate(
            inputs,
            max_length=max_length,
            temperature=0.7,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id
        )

    return tokenizer.decode(outputs[0], skip_special_tokens=True)

Optimierung und Best Practices¶

Auswahl der Hyperparameter¶

• Lernrate: Beginnen Sie mit 5e-5, probieren Sie 1e-4 für kleinere Modelle
• Batch-Größe: So groß wie in den Speicher passt
• LoRA-Rang (r): 16–64 für die meisten Aufgaben, höher für komplexere Domänen
• Epochen: 2–5, achten Sie auf Overfitting

Datenqualität¶

Datenqualität ist entscheidend für den Erfolg des Fine-Tunings:

# Validierung der Datensatzqualität
def validate_dataset(dataset):
    """Qualität der Trainingsdaten prüfen"""
    issues = []

    for i, example in enumerate(dataset):
        # Längenprüfung
        if len(example['question']) < 10:
            issues.append(f"Zeile {i}: Frage zu kurz")

        # Duplikatprüfung
        if example['question'] in seen_questions:
            issues.append(f"Zeile {i}: Doppelte Frage")

        # Formatprüfung
        if not example['answer'].strip():
            issues.append(f"Zeile {i}: Leere Antwort")

    return issues

# Datenbereinigung
def clean_dataset(examples):
    """Grundlegende Datensatzbereinigung"""
    cleaned = []

    for example in examples:
        # Zusätzliche Leerzeichen entfernen
        question = example['question'].strip()
        answer = example['answer'].strip()

        # Nach Länge filtern
        if 10 <= len(question) <= 500 and 20 <= len(answer) <= 1000:
            cleaned.append({
                'question': question,
                'answer': answer
            })

    return cleaned

Deployment und Inferenz¶

Nach Abschluss des Fine-Tunings muss das Modell effizient bereitgestellt werden:

from peft import PeftModel

# Fine-Tuned-Modell für Inferenz laden
base_model = AutoModelForCausalLM.from_pretrained(
    "microsoft/DialoGPT-medium",
    torch_dtype=torch.float16,
    device_map="auto"
)

# LoRA-Adapter laden
model = PeftModel.from_pretrained(base_model, "./fine-tuned-model")

# Inferenz-API
class FineTunedAPI:
    def __init__(self, model, tokenizer):
        self.model = model
        self.tokenizer = tokenizer

    def generate_response(self, question: str) -> str:
        """Antwort auf eine Frage generieren"""
        prompt = f"Frage: {question} Antwort:"

        inputs = self.tokenizer.encode(prompt, return_tensors="pt")

        with torch.no_grad():
            outputs = self.model.generate(
                inputs,
                max_new_tokens=200,
                temperature=0.7,
                do_sample=True,
                pad_token_id=self.tokenizer.eos_token_id
            )

        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
        # Nur den neuen Teil der Antwort extrahieren
        return response[len(prompt):].strip()

# Verwendung
api = FineTunedAPI(model, tokenizer)
answer = api.generate_response("Wie optimiert man eine PostgreSQL-Datenbank?")

Zusammenfassung¶

Fine-Tuning ist ein leistungsstarkes Werkzeug zur Anpassung von KI-Modellen an spezifische Bedürfnisse. Entscheidend ist die richtige Wahl zwischen Prompt Engineering und Fine-Tuning, die Verwendung hochwertiger Daten und geeigneter PEFT-Techniken wie LoRA. Mit der zunehmenden Verfügbarkeit von Werkzeugen wie Hugging Face PEFT wird Fine-Tuning auch für kleinere Teams immer zugänglicher. Denken Sie an gründliches Testen, Monitoring der Metriken und schrittweise Verbesserung der Datenqualität, um die besten Ergebnisse zu erzielen.