Mannekiinide peenhäälestamine
Sellel lehel
Eesmärgid
- Mõista, millal on mannekiinide peenhäälestamine vajalik
- Valmistada ette paaride andmestik treenimiseks
- Rakendada peenhäälestust kergete adapteritega
Millal peenhäälestada?
Alustame halbadest uudistest, mis tegelikult on head: enamikul juhtudel töötavad eeltreenitud mannekiinide mudelid suurepäraselt ja peenhäälestamine on aja raiskamine. Ainult kolm olukorda õigustavad seda tõeliselt. Esimene on väga spetsiifilise sõnavaraga valdkond – meditsiin, õigus, tööstus –, kus üldine mudel ei tea, et „MI“ ja „müokardiinfarkt“ viitavad samale asjale. Teine on platoole jõudmine: oled optimeerinud tükkideks jagamist, lisanud hübriidotsingu ja ümberjärjestamise, kuid mõõdikud ei liigu. Kolmas on lihtsalt see, kui sul on käepärast annoteeritud tekstipaare, sarnaseid või erinevaid, mis seisavad jõude sinu otsingulogides.
Vastupidi, jäta peenhäälestamine vahele, kui sul on vähem kui tuhat annoteeritud paari: treenimine memoriseerib sinu näited ilma üldistamata. Jäta see vahele ka siis, kui jõudlus on juba rahuldav – kahepunktiline kasvu meenutamises (recall) ei ole väärt täiendava mudeli haldamist. Ja ennekõike veendu, et parem tükkideks jagamine või parem vihje probleemi ei lahenda: see on peaaegu alati odavam ja kiirem.
Lähenemine 1: Lineaarne adapter (Matrjoška)
Kõige ökonoomsem lähenemine jätab mannekiinide mudeli puutumata. Lased sellel genereerida oma vektorid ja treenid seejärel selle peale väikese projektsioonikihi, mis moonutab ruumi nii, et toob omavahel lähemale need, mis peavad sinu valdkonnas lähedal olema. OpenAI mudel jääb mustaks kastiks, mida kutsutakse API kaudu; treenitakse vaid mõnisada tuhat parameetrit, CPU-l, minutitega.
Treenimine tugineb tripletidele: päring, seda vastav dokument ja dokument, mis käsitleb sama teemat, kuid ei vasta päringule. Vaata allolevaid meditsiinilisi näiteid – negatiivne näide „paratsetamooli kõrvaltoimed“ jaoks ei ole tekst jalgpallist, vaid tekst paratsetamooli müügist apteekides. Seda nimetatakse raskeks negatiivseks näiteks (hard negative) ja just see õpetab mudelit midagi: ilmne negatiivne näide ei paranda midagi, kuna üldine mudel on selle juba õigesti klassifitseerinud.
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],
}
Adapter ise on kahekihiline võrk, mis projekteerib mudeli 3072 mõõdet alla 256-le, koos lõpliku normaliseerimisega, et väljundvektorid jääksid koosinuse sarnasuse abil võrreldavaks. Kadufunktsioon on tripleti marginaali kadu (triplet margin loss): see võrdub nulliga niipea, kui päring on positiivsele lähemal kui negatiivsele vähemalt 0,2 suuruse marginaali võrra, ja karistab vastasel juhul proportsionaalselt. Teisisõnu, õpetad mudelile ainult seda, mida see veel ei mõista, ja treenimine stabiliseerub loomulikult, kui tripletid on hästi eraldatud.
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")
Üks operatiivne punkt, mida sa ei tohi unustada: päeval, kui selle adapteri kasutusele võtad, peab iga sinu andmebaasis juba salvestatud vektor uuesti läbima projektsiooni, vastasel juhul võrdleksid vektoreid kahest erinevast ruumist. Planeeri tootmisse viimisel kogu korpuse ümberindekseerimine.
Lähenemine 2: Peenhäälestus Sentence Transformers’iga
Kui adapterist ei piisa, pead muutma enda mannekiinide mudelit, mis nõuab avatud mudelit, mida ise majutad – siin BAAI/bge-large-en-v1.5. Sentence Transformers muudab selle ligipääsetavaks: kirjeldad näiteid tekstipaaridena pideva sildiga, kus 1,0 tähendab „need kaks teksti peaksid olema lähedal“ ja 0,2 tähendab „need näivad pindmiselt sarnased, lükka need lahku“. CosineSimilarityLoss surub seejärel arvutatud koosinuse sarnasuse esitatud sildi poole.
Kolm epohhi ja sada soojendusetappi on konservatiivsed väärtused ja põhjusega: tagasihoidlikul andmestikul liiga kaua treenimine hävitab mudeli üldteadmised, muutes selle sinu näidetel suurepäraseks ja mujal keskpäraseks.
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"
])
Kvaliteetse andmestiku ettevalmistamine
Siin peitub tegelik takistus: kellelgi pole tuhandet annoteeritud paari lihtsalt olemas. Lahenduseks on nende koostamine sellest, mis sul juba on, nimelt sinu dokumentidest. Esitad iga dokumendi LLM-ile, küsides küsimusi, millele see täpselt vastab, ja saad küsimuste-dokumentide paarid ilma igasuguse käsitsi annoteerimiseta. Temperatuur 0,7 tagab, et sama dokumendi jaoks genereeritud kolm küsimust ei ole sama lause kolm varianti, ja lstrip puhastab nummerduse, mille mudel spontaanselt lisab.
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
Peenhäälestuse hindamine
Treenimine kahaneva kaoga ei tõesta midagi: ainus küsimus, mis loeb, on see, kas otsing on paranenud. Allpool olev funktsioon mõõdab recall@5 sama päringute hulga peal, nii adapteriga kui ka ilma, lihtsalt kasutades adapter=None, et saada baastase. Nii korpus kui ka päringud läbivad projektsiooni, kui see on esitatud, mis on tingimus selleks, et mõlemad vektorid oleksid samas ruumis.
Käivita see võrdlus alati enne kasutuselevõttu. Sageli juhtub, et liiga vähestel tripletidel treenitud adapter halvendab meenutamist (recall) ja ilma mõõtmiseta viiksid tootmisse regressiooni, arvates, et viid sisse parenduse.
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)
Peamised punktid
- Mannekiinide peenhäälestus parandab jõudlust spetsialiseerunud valdkondades
- Lineaarne adapter on lihtsaim meetod ja sageli piisav
- Sentence Transformers võimaldab kogu mudeli sügavamat peenhäälestust
- Soovitatav on vähemalt 1000 annoteeritud paari
- Hinda alati enne ja pärast, et valideerida saavutatud kasu