Feinabstimmung der Embeddings für Ihre Domäne

Warum Fine-Tuning durchführen ?

Generische Embeddings funktionieren gut, aber domänenspezifisches Fine-Tuning bringt einen Genauigkeitsgewinn von 30-50 % :

Vorher (generisch) :

• Medizinische Anfrage: "MI treatment" → ❌ entspricht "Michigan"

Nachher (feinabgestimmt) :

• Medizinische Anfrage: "MI treatment" → ✅ entspricht "Myocardial Infarction protocols"

Wann Fine-Tuning durchführen

✅ Fine-Tuning durchführen, wenn :

• Fachspezifischer Jargon (juristisch, medizinisch, technisch)
• 1000+ gelabelte Anfrage-Dokument-Paare
• Das Basismodell unterdurchschnittlich abschneidet (< 70 % Recall)

❌ Fine-Tuning vermeiden, wenn :

• Allgemeine Domäne
• < 500 Trainingsbeispiele
• Das Basismodell bereits gut funktioniert

Format der Trainingsdaten

DEVELOPERpython
# Positive Paare (Anfrage → relevantes Dokument)
train_data = [
    {
        "query": "What causes diabetes?",
        "positive": "Type 2 diabetes is caused by insulin resistance...",
        "negative": "Diabetic retinopathy affects the eyes..."  # Optional
    },
    {
        "query": "How to lower blood pressure?",
        "positive": "Lifestyle changes like diet and exercise reduce BP...",
        "negative": "High blood pressure symptoms include headaches..."
    }
]

Methode 1: Sentence Transformers

DEVELOPERpython
from sentence_transformers import SentenceTransformer, InputExample, losses
from torch.utils.data import DataLoader

# Lade das Basismodell
model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')

# Trainingsdaten vorbereiten
train_examples = [
    InputExample(texts=[item['query'], item['positive']])
    for item in train_data
]

# Erstelle den DataLoader
train_dataloader = DataLoader(train_examples, shuffle=True, batch_size=16)

# Loss-Funktion (kontrastives Lernen)
train_loss = losses.MultipleNegativesRankingLoss(model)

# Fine-Tuning durchführen
model.fit(
    train_objectives=[(train_dataloader, train_loss)],
    epochs=3,
    warmup_steps=100,
    output_path='./fine-tuned-model'
)

Methode 2: Fine-Tuning mit OpenAI

Hinweis (Juli 2026): OpenAI bietet kein Fine-Tuning seiner Embedding-Modelle (text-embedding-3-*) über seine API an — nur Textgenerierungsmodelle können feinabgestimmt werden. Um Embeddings feinabzustimmen, verwenden Sie bevorzugt Open-Source-Modelle (siehe Methode 1). Das folgende Beispiel veranschaulicht lediglich den allgemeinen Ablauf eines OpenAI-Fine-Tuning-Jobs.

DEVELOPERpython
import openai

# Daten im JSONL-Format vorbereiten
with open('training_data.jsonl', 'w') as f:
    for item in train_data:
        f.write(json.dumps({
            "input": item['query'],
            "output": item['positive']
        }) + '\n')

# Trainingsdatei hochladen
file = openai.File.create(
    file=open("training_data.jsonl", "rb"),
    purpose='fine-tune'
)

# Fine-Tuning-Job erstellen
job = openai.FineTuningJob.create(
    training_file=file.id,
    model="text-embedding-3-small"
)

# Auf Abschluss warten
status = openai.FineTuningJob.retrieve(job.id)
print(status.status)  # 'succeeded'

# Das feinabgestimmte Modell verwenden
embeddings = openai.Embedding.create(
    input="your query",
    model=f"ft:{job.fine_tuned_model}"
)

Methode 3: Mining schwieriger Negative

Kontrastives Lernen mit schwierigen Negativbeispielen verbessern :

DEVELOPERpython
from sentence_transformers import losses

# Schwierige Negative generieren (ähnliche, aber irrelevante Dokumente)
def mine_hard_negatives(query, candidates, model, k=5):
    query_emb = model.encode(query)
    cand_embs = model.encode(candidates)

    # Die ähnlichsten, aber falschen Dokumente finden
    scores = cosine_similarity([query_emb], cand_embs)[0]
    hard_neg_indices = np.argsort(scores)[-k:]

    return [candidates[i] for i in hard_neg_indices]

# Training mit schwierigen Negativbeispielen
train_examples = []
for item in train_data:
    hard_negs = mine_hard_negatives(
        item['query'],
        all_documents,
        base_model
    )

    for neg in hard_negs:
        train_examples.append(
            InputExample(texts=[
                item['query'],
                item['positive'],
                neg  # Schwieriges Negativbeispiel
            ])
        )

# TripletLoss verwenden
train_loss = losses.TripletLoss(model)

Evaluierung

DEVELOPERpython
from sklearn.metrics import ndcg_score

def evaluate_model(model, test_queries, test_docs, relevance_labels):
    predictions = []

    for query in test_queries:
        query_emb = model.encode(query)
        doc_embs = model.encode(test_docs)
        scores = cosine_similarity([query_emb], doc_embs)[0]
        predictions.append(scores)

    # nDCG@10
    ndcg = ndcg_score(relevance_labels, predictions, k=10)

    return ndcg

# Basismodell mit feinabgestimmtem Modell vergleichen
base_model = SentenceTransformer('all-MiniLM-L6-v2')
fine_tuned_model = SentenceTransformer('./fine-tuned-model')

print(f"Base model nDCG@10: {evaluate_model(base_model, ...)}")
print(f"Fine-tuned nDCG@10: {evaluate_model(fine_tuned_model, ...)}")

Inkrementelles Fine-Tuning

Das Modell mit neu eintreffenden Daten aktualisieren :

DEVELOPERpython
# Das zuvor feinabgestimmte Modell laden
model = SentenceTransformer('./fine-tuned-model')

# Neue Trainingsdaten hinzufügen
new_train_examples = [...]

# Training fortsetzen (Warmstart)
model.fit(
    train_objectives=[(new_dataloader, train_loss)],
    epochs=1,
    warmup_steps=50,
    output_path='./fine-tuned-model-v2'
)

Distillation (Schnelle Inferenz)

Ein großes Modell feinabstimmen und anschließend in ein kleines destillieren :

DEVELOPERpython
from sentence_transformers import models, SentenceTransformer, losses

# Lehrer: großes feinabgestimmtes Modell
teacher = SentenceTransformer('fine-tuned-large-model')

# Schüler: kleines Basismodell
student = SentenceTransformer('all-MiniLM-L6-v2')

# Distillations-Loss
train_loss = losses.MSELoss(student, teacher)

# Den Schüler trainieren, den Lehrer nachzuahmen
student.fit(
    train_objectives=[(train_dataloader, train_loss)],
    epochs=3
)

# Jetzt ist der Schüler schnell, performt aber wie der Lehrer

Fine-Tuning von Embeddings ist die Geheimwaffe für domänenspezifisches RAG. Investieren Sie frühzeitig darin.