Embeddingų derinimas
Šiame puslapyje
Tikslai
- Suprasti, kada būtina derinti embeddingus
- Paruošti porų duomenų rinkinį mokymui
- Įgyvendinti derinimą naudojant lengvus adapterius
Kada derinti?
Pradėkime nuo blogų naujienų, kurios iš tikrųjų yra geros: daugeliu atvejų iš anksto apmokyti embeddingų modeliai veikia puikiai, o jų derinimas yra laiko švaistymas. Tik trys situacijos tai tikrai pateisina. Pirmoji – tai sritis su labai specializuota terminija: medicina, teisė, pramonė, kur bendros paskirties modelis nežino, kad „MI“ ir „miokardo infarktas“ reiškia tą patį. Antroji – kai pasiekiamas ribinis taškas: jau optimizavai chunkingą, pridėjai hibridinę paiešką ir perrikiavimą, o metrikos nejuda. Trečioji – tiesiog turi rankoje anotuočių tekstų poras, panašių ar nepanašių, kurios niekam nenaudojamos tavo paieškos žurnaluose.
Atvirkščiai, praleisk derinimą, jei turi mažiau nei tūkstantį anotuočių porų: mokymas tiesiog įsimins tavo pavyzdžius, bet neapibendrins. Praleisk jį ir tada, kai našumas jau tenkina – dviejų taškų padidėjimas prisiminime (recall) nėra vertas papildomo modelio palaikymo. Ir svarbiausia, patikrink, ar geresnis chunkingas ar geresnė užuomina (prompt) neišspręs problemos: tai beveik visada pigiau ir greičiau.
1 būdas: Tiesinis adapteris (Matryoshka)
Ekonomiškiausias požiūris palieka embeddingų modelį nepaliestą. Leidi jam generuoti vektorius, o tada viršuje apmokai mažą projekcijos sluoksnį, kuris iškraipo erdvę taip, kad suartintų tai, kas tavo srityje turi būti arti. OpenAI modelis lieka juoda dėže, pasiekiama per API; apmokomi tik keli šimtai tūkstančių parametrų, naudojant CPU, per kelias minutes.
Mokymasis remiasi tripletais: užklausa, dokumentas, kuris į ją atsako, ir dokumentas, kuris apima tą pačią temą, bet neatsako. Pažvelk į žemiau pateiktus medicininius pavyzdžius – neigiamas pavyzdys frazei „paracetamolio šalutinis poveikis“ nėra tekstas apie futbolą, o tekstas apie paracetamolį, parduodamą vaistinėse. Tai vadinama sunkiu neigiamu pavyzdžiu (hard negative), ir būtent jis moko modelį: akivaizdus neigiamas pavyzdys nieko nepataiso, nes bendros paskirties modelis jį jau teisingai klasifikavo.
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],
}
Pats adapteris yra dviejų sluoksnių tinklas, kuris projektuoja 3072 modelio matmenis žemyn iki 256, su galutine normalizacija, kad išvesties vektoriai išliktų palyginami naudojant kosinusinį panašumą. Nuostolių funkcija yra triplet margin loss: ji lygi nuliui, kai užklausa yra arčiau teigiamo pavyzdžio nei neigiamo bent 0,2 riba, o kitu atveju baudžia proporcingai. Kitaip tariant, mokai modelį tik to, ko jis dar nesuprato, ir mokymasis natūraliai stabilizuojasi, kai tripletai yra gerai atskirti.
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")
Yra vienas operacinis aspektas, kurio negali praleisti: tą dieną, kai diegsi šį adapterį, kiekvienas vektorius, jau saugomas tavo duomenų bazėje, turi būti vėl perduotas per projekciją, kitaip lygintum vektorius iš dviejų skirtingų erdvių. Numatyk visišką korpuso perindeksavimą savo gamybinėje diegimo versijoje.
2 būdas: Derinimas naudojant „Sentence Transformers“
Kai adapterio nepakanka, reikia modifikuoti patį embeddingų modelį, o tam reikia atviro kodo modelio, kurį talpini pats – šiuo atveju BAAI/bge-large-en-v1.5. „Sentence Transformers“ tai padaro prieinamą: aprašai pavyzdžius kaip tekstų poras su tęstine etikete, kur 1,0 reiškia „šie du tekstai turi būti arti“, o 0,2 reiškia „jie paviršutiniškai panašūs, stumk juos tolyn“. Tada CosineSimilarityLoss stumia apskaičiuotą kosinusinį panašumą link pateiktos etiketės.
Trys epochos ir šimtas sušildymo žingsnių yra konservatyvios vertės, ir ne be priežasties: esant kukliam duomenų rinkiniui, per ilgas mokymas sunaikina modelio bendrąsias žinias, todėl jis tampa puikus tavo pavyzdžiams, bet vidutiniškas visur kitur.
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"
])
Kokybiško duomenų rinkinio rengimas
Štai tikroji kliūtis: niekas neturi tūkstančio anotuočių porų gulintčių nenaudojamų. Apėjimo būdas – sukurti jas iš to, ką jau turi, būtent iš savo dokumentų. Pateiki kiekvieną dokumentą LLM ir prašai sugeneruoti klausimus, į kuriuos jis tiksliai atsako, taip gauni klausimų ir dokumentų poras be jokio rankinio anotavimo. 0,7 temperatūra užtikrina, kad trys vienam dokumentui sugeneruoti klausimai nebus trys to paties sakinio variantai, o lstrip išvalo numeraciją, kurią modelis spontaniškai prideda.
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
Derinimo vertinimas
Mokymas su mažėjančiais nuostoliais nieko neįrodo: vienintelis svarbus klausimas – ar paieška pagerėjo. Toliau pateikta funkcija matuoja recall@5 toje pačioje užklausų aibėje, su adapteriu ir be jo, tiesiog perduodant adapter=None, norint gauti bazinį lygį. Ir korpusas, ir užklausos perduodamos per projekciją, kai ji pateikiama, ir tai yra sąlyga, kad abu vektoriai egzistuotų toje pačioje erdvėje.
Visada atlik šį palyginimą prieš diegdamas. Pasitaiko reguliariai, kad adapteris, apmokytas su per mažai tripletų, pablogina prisiminimą (recall), ir be matavimų išleistum regresiją manydamas, kad išleidai patobulinimą.
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)
Svarbiausi punktai
- Embeddingų derinimas pagerina našumą specializuotose srityse
- Tiesinis adapteris yra paprasčiausias metodas ir dažnai pakankamas
- „Sentence Transformers“ leidžia giliau derinti visą modelį
- Rekomenduojama turėti bent 1000 anotuočių porų
- Visada įvertink prieš ir po, kad patvirtintum naudą