Finjustering av inbäddningar
På denna sida
Mål
- Förstå när finjustering av inbäddningar är nödvändig
- Förbereda ett parvis dataset för träning
- Implementera finjustering med lätta adaptrar
När ska du finjustera?
Låt oss börja med de dåliga nyheterna, som egentligen är goda: i de flesta fall fungerar förtränade inbäddningsmodeller utmärkt, och finjustering är slöseri med tid. Endast tre situationer motiverar det verkligen. Den första är en domän med mycket specialiserad terminologi – medicin, juridik, industri – där den generiska modellen inte vet att “MI” och “hjärtinfarkt” syftar på samma sak. Den andra är att du har nått ett platå: du har optimerat chunking, lagt till hybrid sökning och reranking, men metrarna rör sig inte. Den tredje är helt enkelt att du har annoterade textpar till hands, lika eller olika, som ligger overksamma i dina sökloggar.
Å andra sidan, hoppa över finjustering om du har färre än tusen annoterade par: träningen kommer att memorera dina exempel utan att generalisera. Hoppa över det också om prestandan redan är tillfredsställande – en ökning med två poäng i recall är inte värd besväret att underhålla en extra modell. Och framför allt, verifiera att bättre chunking eller en bättre prompt inte löser problemet: det är nästan alltid billigare och snabbare.
Metod 1: Linjär adapter (Matryoshka)
Det mest ekonomiska tillvägagångssättet lämnar inbäddningsmodellen orörd. Du låter den producera sina vektorer och tränar sedan ett litet projektionsskikt ovanpå som böjer rummet så att det som behöver ligga nära varandra i din domän faktiskt hamnar nära. OpenAIs modell förblir en svart låda som anropas via API; endast några hundratusen parametrar tränas, på CPU, på några minuter.
Träningen förlitar sig på tripler: en fråga, ett dokument som svarar på den, och ett dokument som täcker samma ämne men inte svarar på frågan. Titta på medicinska exemplen nedan – det negativa exemplet för “biverkningar av paracetamol” är inte en text om fotboll, utan en text om paracetamol som säljs på apotek. Detta kallas ett hårt negativt exempel (hard negative), och det är vad som lär modellen något: ett uppenbart negativt exempel korrigerar ingenting eftersom den generiska modellen redan har klassificerat 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],
}
Själva adaptern är ett nätverk med två lager som projicerar modellens 3 072 dimensioner ner till 256, med en slutlig normalisering så att utdatavektorerna förblir jämförbara via kosinussimilaritet. Förlustfunktionen är en triplet margin loss: den blir noll så snart frågan ligger närmare det positiva exemplet än det negativa med minst en marginal på 0,2, och bestraffar proportionellt annars. Med andra ord lär du bara modellen det den ännu inte har förstått, och träningen stabiliseras naturligt när triplerna är väl åtskilda.
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")
En operativ punkt du inte får missa: den dag du distribuerar denna adapter måste varje vektor som redan finns lagrad i din databas passera genom projektionen igen, annars skulle du jämföra vektorer från två olika rum. Planera för en fullständig omindexering av korpusen i din produktionslansering.
Metod 2: Finjustering med Sentence Transformers
När adaptern inte räcker till måste du modifiera själva inbäddningsmodellen, vilket kräver en öppen modell som du värdar – här BAAI/bge-large-en-v1.5. Sentence Transformers gör detta tillgängligt: du beskriver exempel som textpar med en kontinuerlig etikett, där 1,0 betyder “dessa två texter bör ligga nära varandra” och 0,2 betyder “de ser ytligt lika ut, knuffa isär dem”. CosineSimilarityLoss trycker sedan den beräknade kosinussimilariteten mot den angivna etiketten.
Tre epoch och hundra uppvärmningssteg är konservativa värden, och av goda skäl: på ett blygsamt dataset förstör för lång träning modellens allmänna kunskap, vilket gör den utmärkt på dina exempel och medioker överallt annars.
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"
])
Förbereda ett dataset av hög kvalitet
Här ligger det verkliga hindret: ingen har tusen annoterade par liggandes. Lösningen är att bygga dem från det du redan har, nämligen dina dokument. Du skickar varje dokument till LLM:n och ber om de frågor det svarar på exakt, och du får fråga-dokument-par utan manuell annotering. En temperatur på 0,7 säkerställer att de tre frågor som genereras för samma dokument inte är tre varianter av samma mening, och lstrip rensar bort numreringen som modellen lägger till 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
Utvärdera finjustering
Att träna med minskande förlust bevisar ingenting: den enda frågan som spelar roll är om sökningen har förbättrats. Funktionen nedan mäter recall@5 på samma uppsättning frågor, med och utan adapter, helt enkelt genom att skicka adapter=None för att få baslinjen. Både korpusen och frågorna passerar genom projektionen när den tillhandahålls, vilket är villkoret för att båda vektorerna ska leva i samma rum.
Kör alltid denna jämförelse innan distribution. Det händer regelbundet att en adapter tränad på för få tripler försämrar recall, och utan mätning skulle du lansera en försämring i tron att du levererade en förbättring.
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)
Viktiga punkter
- Finjustering av inbäddningar förbättrar prestanda inom specialiserade domäner
- En linjär adapter är den enklaste metoden och ofta tillräcklig
- Sentence Transformers möjliggör djupare finjustering av hela modellen
- Minst 1 000 annoterade par rekommenderas
- Utvärdera alltid före och efter för att validera vinsten