Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Finjustering af embeddings

Lektion 21 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. Hvornår skal du finjustere?
  3. Tilgang 1: Lineær adapter (Matryoshka)
  4. Tilgang 2: Finjustering med Sentence Transformers
  5. Forberedelse af et kvalitetsdatasæt
  6. Evaluering af finjustering
  7. Vigtige pointer

Mål

  • Forstå hvornår finjustering af embeddings er nødvendig
  • Forberede et par-datasæt til træning
  • Implementere finjustering med lette adaptere

Hvornår skal du finjustere?

Lad os starte med de dårlige nyheder, som faktisk er gode: I de fleste tilfælde fungerer prætrænede embedding-modeller perfekt, og finjustering er spild af kræfter. Kun tre situationer berettiger det virkelig. Den første er et domæne med meget specialiseret ordforråd – medicin, jura, industri – hvor den generiske model ikke ved, at „MI” og „myokardieinfarkt” refererer til det samme. Den anden er, at du rammer et plateau: Du har optimeret chunking, tilføjet hybrid søgning og reranking, og dine nøgletal vil ikke rykke sig. Den tredje er simpelthen, at du allerede har annoterede tekstpar liggende, lignende eller forskellige, som står ubrugte i dine søgelogs.

Omvendt skal du springe finjustering over, hvis du har færre end tusind annoterede par: Træningen vil udenadslære dine eksempler uden at generalisere. Spring det også over, hvis ydeevnen allerede er tilfredsstillende – en gevinst på to point i recall er ikke værd at vedligeholde en ekstra model for. Og frem for alt skal du verificere, at bedre chunking eller en bedre prompt ikke vil løse problemet: Det er næsten altid billigere og hurtigere.

Tilgang 1: Lineær adapter (Matryoshka)

Den mest økonomiske tilgang lader embedding-modellen være urørt. Du lader den producere sine vektorer og træner derefter et lille projektionslag ovenpå, der forvrænger rummet for at bringe det tættere sammen, som skal være tæt i dit domæne. OpenAIs model forbliver en black box, der kaldes via API; kun et par hundrede tusind parametre trænes, på CPU, på få minutter.

Træningen afhænger af tripler: En forespørgsel, et dokument der svarer på den, og et dokument der dækker samme emne, men ikke svarer på den. Kig på medicineksemplerne nedenfor – negativet for „bivirkninger ved paracetamol” er ikke en tekst om fodbold, men en tekst om paracetamol solgt på apoteker. Dette kaldes et „hårdt negativ”, og det er det, der lærer modellen noget: Et åbenlyst negativ retter ikke noget, da den generiske model allerede har klassificeret det korrekt.

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],
    }

Selve adapteren er et netværk med to lag, der projicerer modellens 3.072 dimensioner ned til 256, med en endelig normalisering, så output-vektorerne forbliver sammenlignelige via cosinus-lichenhed. Tabsfunktionen er et triplet margin loss: Den bliver nul, så snart forespørgslen er tættere på det positive end på det negative med mindst en margin på 0,2, og straffer proportionalt ellers. Med andre ord lærer du kun modellen det, den endnu ikke har forstået, og træningen stabiliseres naturligt, når triplerne er godt adskilt.

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")

Et operationelt punkt du ikke må overse: Den dag du udruller denne adapter, skal hver vektor, der allerede er gemt i din database, gennemgå projektionen igen. Ellers ville du sammenligne vektorer fra to forskellige rum. Planlæg for komplet genindeksering af dit korpus i din produktionsudrulning.

Tilgang 2: Finjustering med Sentence Transformers

Når adapteren ikke er nok, skal du modificere selve embedding-modellen, hvilket kræver en åben model, som du hoster selv – her BAAI/bge-large-en-v1.5. Sentence Transformers gør dette tilgængeligt: Du beskriver eksempler som tekstpar med en kontinuerlig label, hvor 1,0 betyder „disse to tekster bør være tæt på hinanden”, og 0,2 betyder „de ligner overfladisk hinanden, pres dem fra hinanden”. CosineSimilarityLoss presser derefter den beregnede cosinus-lichenhed hen imod den angivne label.

Tre epocher og hundrede warmup-trin er konservative værdier, og med god grund: På et beskedent datasæt vil for lang træning ødelægge modellens generelle viden, hvilket gør den fremragende på dine eksempler og middelmådig alle andre steder.

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"
])

Forberedelse af et kvalitetsdatasæt

Her ligger den virkelige forhindring: Ingen har tusind annoterede par liggende. Løsningen er at bygge dem ud fra det, du allerede har, nemlig dine dokumenter. Du sender hvert dokument til LLM’en og beder om de spørgsmål, det besvarer præcist, og du får spørgsmål-dokument-par uden manuel annotation. En temperatur på 0,7 sikrer, at de tre spørgsmål genereret for samme dokument ikke er tre varianter af samme sætning, og lstrip rydder op i den nummerering, modellen tilføjer spontant.

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

Evaluering af finjustering

Træning med faldende tab beviser ingenting: Det eneste spørgsmål, der betyder noget, er om søgningen er blevet bedre. Funktionen nedenfor måler recall@5 på samme sæt af forespørgsler, med og uden adapteren, simpelthen ved at sende adapter=None for at få baseline. Både korpussen og forespørgslerne gennemgår projektionen, når den leveres, hvilket er betingelsen for, at begge vektorer befinder sig i samme rum.

Kør altid denne sammenligning før udrulning. Det sker regelmæssigt, at en adapter trænet på for få tripler forringer recall, og uden måling ville du udrulle en regression i den tro, at du udrullede en forbedring.

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)

Vigtige pointer

  • Finjustering af embeddings forbedrer ydeevnen i specialiserede domæner
  • En lineær adapter er den enkleste metode og ofte tilstrækkelig
  • Sentence Transformers muliggør dybere finjustering af hele modellen
  • Et minimum på 1.000 annoterede par anbefales
  • Evaluer altid før og efter for at validere gevinsten