Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Fine-tuning van embeddings

Les 21 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. Wanneer fine-tunen?
  3. Benadering 1: Lineaire adapter (Matryoshka)
  4. Benadering 2: Fine-tuning met Sentence Transformers
  5. Een kwaliteitsdataset voorbereiden
  6. Fine-tuning evalueren
  7. Belangrijkste punten

Doelstellingen

  • Begrijpen wanneer fine-tuning van embeddings noodzakelijk is
  • Een paar-dataset voorbereiden voor training
  • Fine-tuning implementeren met lichtgewicht adapters

Wanneer fine-tunen?

Laten we beginnen met het slechte nieuws, dat eigenlijk goed nieuws is: in de meeste gevallen werken vooraf getrainde embedding-modellen prima en is fine-tuning zonde van de moeite. Slechts drie situaties rechtvaardigen dit echt. De eerste is een domein met zeer gespecialiseerd vocabulaire—geneeskunde, recht, industrie—waar het generieke model niet weet dat “MI” en “myocardinfarct” naar hetzelfde verwijzen. De tweede is het bereiken van een plateau: u heeft chunking geoptimaliseerd, hybride zoekopdrachten en herordening toegevoegd, maar de metrics bewegen niet. De derde is simpelweg het hebben van geannoteerde tekstparen bij de hand, gelijksoortig of ongelijksoortig, die werkloos in uw zoeklogboeken zitten.

Sla fine-tuning daarentegen over als u minder dan duizend geannoteerde paren heeft: training zal uw voorbeelden van buiten leren zonder te generaliseren. Sla het ook over als de prestaties al bevredigend zijn—een winst van twee punten in recall is het onderhouden van een extra model niet waard. En bovenal: verifieer dat betere chunking of een betere prompt het probleem niet oplost: dat is bijna altijd goedkoper en sneller.

Benadering 1: Lineaire adapter (Matryoshka)

De zuinigste benadering laat het embedding-model ongemoeid. U laat het zijn vectoren produceren en traint vervolgens een kleine projectielaag erbovenop die de ruimte vervormt om dichter bij elkaar te brengen wat in uw domein dicht bij elkaar moet zijn. Het model van OpenAI blijft een black box die via API wordt aangeroepen; er worden slechts een paar honderdduizend parameters getraind, op CPU, in minuten.

Training vertrouwt op triplets: een query, een document dat deze beantwoordt, en een document dat over hetzelfde onderwerp gaat maar niet antwoordt. Kijk naar de medische voorbeelden hieronder—de negatieve voor “bijwerkingen paracetamol” is geen tekst over voetbal, maar een tekst over paracetamol dat in apotheken wordt verkocht. Dit wordt een hard negative genoemd en dit is wat het model iets leert: een voor de hand liggende negatieve corrigeert niets, aangezien het generieke model deze al correct heeft geclassificeerd.

import numpy as np
from openai import OpenAI
from sklearn.model_selection import train_test_split

client = OpenAI()

# Dataset of pairs (query, positive_document, negative_document)
triplets = [
    {
        "query": "paracetamol side effects",
        "positive": "Paracetamol can cause liver disorders...",
        "negative": "Paracetamol is available in pharmacies..."
    },
    {
        "query": "children's aspirin dosage",
        "positive": "For children aged 6 to 12, the recommended dose...",
        "negative": "Aspirin was discovered in the 19th century..."
    },
    # ... more triplets
]

def prepare_embeddings(triplets: list[dict]) -> dict:
    """Generate embeddings for the triplets."""
    all_texts = []
    for t in triplets:
        all_texts.extend([t["query"], t["positive"], t["negative"]])

    response = client.embeddings.create(
        input=all_texts,
        model="text-embedding-3-large"
    )
    embs = np.array(
        [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    )

    n = len(triplets)
    return {
        "queries": embs[0::3],
        "positives": embs[1::3],
        "negatives": embs[2::3],
    }

De adapter zelf is een netwerk van twee lagen dat de 3.072 dimensies van het model projecteert naar 256, met finale normalisatie zodat uitvoervectoren vergelijkbaar blijven via cosine similarity. De verliesfunctie is een triplet margin loss: deze is nul zodra de query dichter bij de positieve dan bij de negatieve ligt met een marge van ten minste 0,2, en straft anders evenredig af. Met andere woorden, u leert het model alleen wat het nog niet heeft begrepen, en training stabiliseert natuurlijk zodra de triplets goed gescheiden zijn.

import torch
import torch.nn as nn
import torch.optim as optim

class EmbeddingAdapter(nn.Module):
    """Projection layer to adapt embeddings."""
    def __init__(self, input_dim: int = 3072, output_dim: int = 256):
        super().__init__()
        self.projection = nn.Sequential(
            nn.Linear(input_dim, output_dim),
            nn.ReLU(),
            nn.Linear(output_dim, output_dim),
        )

    def forward(self, x):
        projected = self.projection(x)
        return projected / projected.norm(dim=-1, keepdim=True)

def triplet_loss(anchor, positive, negative, margin=0.2):
    """Triplet margin loss."""
    dist_pos = 1 - torch.cosine_similarity(anchor, positive)
    dist_neg = 1 - torch.cosine_similarity(anchor, negative)
    return torch.relu(dist_pos - dist_neg + margin).mean()

def train_adapter(data: dict, epochs: int = 50):
    """Train the adapter on triplets."""
    model = EmbeddingAdapter()
    optimizer = optim.Adam(model.parameters(), lr=1e-3)

    queries = torch.tensor(data["queries"], dtype=torch.float32)
    positives = torch.tensor(data["positives"], dtype=torch.float32)
    negatives = torch.tensor(data["negatives"], dtype=torch.float32)

    for epoch in range(epochs):
        optimizer.zero_grad()

        q_proj = model(queries)
        p_proj = model(positives)
        n_proj = model(negatives)

        loss = triplet_loss(q_proj, p_proj, n_proj)
        loss.backward()
        optimizer.step()

        if (epoch + 1) % 10 == 0:
            print(f"Epoch {epoch + 1}/{epochs}, Loss: {loss.item():.4f}")

    return model

# Train
data = prepare_embeddings(triplets)
adapter = train_adapter(data)

# Save
torch.save(adapter.state_dict(), "medical_adapter.pt")

Een operationeel punt dat u niet mag missen: op de dag dat u deze adapter implementeert, moet elke vector die al in uw database is opgeslagen opnieuw door de projectie worden gehaald, anders vergelijkt u vectoren uit twee verschillende ruimtes. Plan een volledige herindexering van het corpus in uw productie-uitrol.

Benadering 2: Fine-tuning met Sentence Transformers

Wanneer de adapter niet voldoende is, moet u het embedding-model zelf aanpassen, wat een open model vereist dat u host—hier BAAI/bge-large-en-v1.5. Sentence Transformers maakt dit toegankelijk: u beschrijft voorbeelden als tekstparen met een continu label, waarbij 1,0 betekent “deze twee teksten moeten dicht bij elkaar liggen” en 0,2 betekent “ze lijken oppervlakkig op elkaar, duw ze uit elkaar”. De CosineSimilarityLoss duwt vervolgens de berekende cosine similarity naar het verstrekte label.

Drie epochen en honderd warmup-stappen zijn conservatieve waarden, en dat met reden: bij een bescheiden dataset vernietigt te lang trainen de algemene kennis van het model, waardoor het uitstekend wordt op uw voorbeelden en middelmatig overal elders.

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

# Load a base model
model = SentenceTransformer("BAAI/bge-large-en-v1.5")

# Prepare training examples
train_examples = [
    InputExample(
        texts=["paracetamol side effects",
               "Paracetamol can cause liver disorders"],
        label=1.0
    ),
    InputExample(
        texts=["paracetamol side effects",
               "Paracetamol is sold in pharmacies"],
        label=0.2
    ),
]

train_dataloader = DataLoader(train_examples, shuffle=True, batch_size=16)
train_loss = losses.CosineSimilarityLoss(model)

# Train
model.fit(
    train_objectives=[(train_dataloader, train_loss)],
    epochs=3,
    warmup_steps=100,
    output_path="./finetuned_medical_model"
)

# Use the fine-tuned model
embeddings = model.encode([
    "abdominal pain after taking medication",
    "adverse drug effects"
])

Een kwaliteitsdataset voorbereiden

Hier ligt de echte hobbel: niemand heeft duizend geannoteerde paren rondslingeren. De workaround is om ze te bouwen vanuit wat u al heeft, namelijk uw documenten. U legt elk document voor aan de LLM met de vraag welke vragen het precies beantwoordt, en u krijgt query-documentparen zonder handmatige annotatie. Een temperatuur van 0,7 zorgt ervoor dat de drie gegenereerde vragen voor hetzelfde document geen drie varianten van dezelfde zin zijn, en lstrip verwijdert de nummering die het model spontaan toevoegt.

def generate_training_pairs(
    documents: list[str],
    n_per_doc: int = 3
) -> list[dict]:
    """Generate query-document pairs for training."""
    pairs = []

    for doc in documents:
        response = client.chat.completions.create(
            model="gpt-5.6-terra",
            messages=[{
                "role": "user",
                "content": (
                    f"Here is a document:\n\n{doc[:500]}\n\n"
                    f"Generate {n_per_doc} questions that this document "
                    f"answers precisely. One question per line."
                )
            }],
            temperature=0.7
        )
        questions = response.choices[0].message.content.strip().split("\n")

        for q in questions[:n_per_doc]:
            q = q.strip().lstrip("0123456789.-) ")
            if q:
                pairs.append({"query": q, "document": doc})

    return pairs

Fine-tuning evalueren

Trainen met dalend verlies bewijst niets: de enige vraag die telt, is of het zoeken is verbeterd. De onderstaande functie meet recall@5 op dezelfde set queries, met en zonder adapter, simpelweg door adapter=None mee te geven om de basislijn te krijgen. Zowel het corpus als de queries gaan door de projectie wanneer deze wordt verstrekt, wat de voorwaarde is dat beide vectoren in dezelfde ruimte leven.

Voer deze vergelijking altijd uit voordat u implementeert. Het gebeurt regelmatig dat een adapter die op te weinig triplets is getraind, de recall verslechtert, en zonder meting zou u een regressie uitrollen in de veronderstelling dat u een verbetering levert.

def evaluate_before_after(
    queries: list[str],
    relevant_docs: list[list[str]],
    corpus: list[str],
    adapter=None
):
    """Compare performance before and after fine-tuning."""
    resp = client.embeddings.create(
        input=corpus, model="text-embedding-3-large"
    )
    corpus_embs = np.array(
        [d.embedding for d in sorted(resp.data, key=lambda x: x.index)]
    )

    if adapter:
        corpus_embs_adapted = adapter(
            torch.tensor(corpus_embs, dtype=torch.float32)
        ).detach().numpy()
    else:
        corpus_embs_adapted = corpus_embs

    recall_scores = []
    for query, relevants in zip(queries, relevant_docs):
        q_resp = client.embeddings.create(
            input=query, model="text-embedding-3-large"
        )
        q_emb = np.array(q_resp.data[0].embedding)

        if adapter:
            q_emb = adapter(
                torch.tensor(q_emb, dtype=torch.float32).unsqueeze(0)
            ).detach().numpy()[0]

        scores = corpus_embs_adapted @ q_emb
        top_5 = set(np.argsort(scores)[-5:])
        relevant_ids = set(
            i for i, d in enumerate(corpus) if d in relevants
        )
        recall = len(top_5 & relevant_ids) / len(relevant_ids)
        recall_scores.append(recall)

    return np.mean(recall_scores)

Belangrijkste punten

  • Fine-tuning van embeddings verbetert de prestaties in gespecialiseerde domeinen
  • Een lineaire adapter is de eenvoudigste methode en vaak voldoende
  • Sentence Transformers maakt diepere fine-tuning van het volledige model mogelijk
  • Een minimum van 1.000 geannoteerde paren wordt aanbevolen
  • Evalueer altijd voor en na om de winst te valideren