Fino podešavanje ugrađivanja (embeddings)
Na ovoj stranici
Ciljevi
- Razumjeti kada je fino podešavanje ugrađivanja nužno
- Pripremiti skup podataka parova za obuku
- Implementirati fino podešavanje pomoću laganih adaptera
Kada fino podesiti?
Krenimo s lošim vijestima, koje su zapravo dobre: u većini slučajeva unaprijed obučeni modeli ugrađivanja rade savršeno, pa je fino podešavanje gubitak truda. Samo tri situacije doista opravdavaju taj korak. Prva je domena s izrazito specijaliziranim rječnikom – medicina, pravo, industrija – gdje generički model ne zna da se „MI“ i „miokardijalni infarkt“ odnose na istu stvar. Druga je situacija kada si naišao/la na plato: optimizirao/la si chunking, dodao/la hibridno pretraživanje i ponovno rangiranje, a metrike se ne miču. Treća je jednostavno posjedovanje anotiranih tekstualnih parova, sličnih ili različitih, koji besposleno leže u tvojim zapisima pretraživanja.
S druge strane, preskoči fino podešavanje ako imaš manje od tisuću anotiranih parova: obuka će napamet naučiti tvoje primjere umjesto da generalizira. Preskoči ga i ako su performanse već zadovoljavajuće – dobitak od dvije točke u povratu (recall) ne vrijedi održavanja dodatnog modela. I prije svega, provjeri neće li problem riješiti bolje chunkiranje ili bolji prompt: gotovo je uvijek jeftinije i brže.
Pristup 1: Linearni adapter (Matryoshka)
Najekonomičniji pristup ostavlja model ugrađivanja netaknutim. Pustiš ga da proizvede svoje vektore, a zatim obučiš mali sloj projekcije na vrhu koji iskrivljuje prostor kako bi približio ono što u tvojoj domeni mora biti blizu. OpenAIjev model ostaje crna kutija kojoj se pristupa putem API-ja; obučava se samo nekoliko stotina tisuća parametara, na CPU-u, u nekoliko minuta.
Obuka se oslanja na tripletove: upit, dokument koji na njega odgovara i dokument koji pokriva istu temu, ali ne odgovara na upit. Pogledaj medicinske primjere u nastavku – negativan primjer za „nuspojave paracetamola“ nije tekst o nogometu, već tekst o paracetamolu koji se prodaje u ljekarnama. To se naziva tvrdi negativan primjer (hard negative) i upravo on nešto uči model: očiti negativan primjer ništa ne ispravlja jer ga je generički model već ispravno klasificirao.
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],
}
Sam adapter je dvoslojna mreža koja projicira 3.072 dimenzije modela na 256, uz konačnu normalizaciju kako bi izlazni vektori ostali usporedivi kosinusnom sličnošću. Funkcija gubitka je triplet margin loss: jednaka je nuli čim je upit bliži pozitivnom nego negativnom primjeru za barem marginu od 0,2, a u suprotnom kažnjava proporcionalno. Drugim riječima, model učiš samo ono što još nije shvatio, a obuka se prirodno stabilizira čim su tripleti dobro razdvojeni.
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")
Jedna operativna točka koju ne smiješ propustiti: dan kada rasporediš ovaj adapter, svaki vektor već pohranjen u tvojoj bazi podataka mora ponovno proći kroz projekciju; inače bi uspoređivao/la vektore iz dva različita prostora. Planiraj potpuno ponovno indeksiranje korpusa u svojoj produkcijskoj implementaciji.
Pristup 2: Fino podešavanje sa Sentence Transformers
Kada adapter nije dovoljan, moraš modificirati sam model ugrađivanja, što zahtijeva otvoreni model koji hostaš – ovdje BAAI/bge-large-en-v1.5. Sentence Transformers to čini dostupnim: primjere opisuješ kao tekstualne parove s kontinuiranom oznakom, gdje 1,0 znači „ova dva teksta trebala bi biti blizu“, a 0,2 znači „površno su slični, razdvoji ih“. CosineSimilarityLoss zatim gura izračunatu kosinusnu sličnost prema pruženoj oznaci.
Tri epohe i sto koraka zagrijavanja konzervativne su vrijednosti, i to s dobrim razlogom: na skromnom skupu podataka preduga obuka uništava opće znanje modela, čineći ga izvrsnim na tvojim primjerima, a osrednjim svugdje drugdje.
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"
])
Priprema kvalitetnog skupa podataka
Ovdje leži prava prepreka: nitko nema na raspolaganju tisuću anotiranih parova. Zaobilazno rješenje je izgraditi ih od onoga što već imaš, naime od svojih dokumenata. Svaki dokument pošalješ LLM-u tražeći pitanja na koja taj dokument precizno odgovara, i tako dobivaš parove pitanje-dokument bez ikakve ručne anotacije. Temperatura od 0,7 osigurava da tri pitanja generirana za isti dokument nisu tri varijante iste rečenice, a lstrip čisti numeraciju koju model spontano dodaje.
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
Evaluacija finog podešavanja
Obuka sa smanjenjem gubitka ništa ne dokazuje: jedino pitanje koje je bitno jest je li se pretraživanje poboljšalo. Funkcija u nastavku mjeri recall@5 na istom skupu upita, s adapterom i bez njega, jednostavnim prosljeđivanjem adapter=None za dobivanje osnovne linije. I korpus i upiti prolaze kroz projekciju kada je ona pružena, što je uvjet da oba vektora žive u istom prostoru.
Uvijek pokreni ovu usporedbu prije raspoređivanja. Redovito se događa da adapter obučen na premalo tripleta pogorša povrat (recall), a bez mjerenja bi isporučio regresiju misleći da isporučuješ poboljšanje.
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)
Ključne točke
- Fino podešavanje ugrađivanja poboljšava performanse u specijaliziranim domenama
- Linearni adapter je najjednostavnija metoda i često dovoljna
- Sentence Transformers omogućuje dublje fino podešavanje cijelog modela
- Preporučuje se minimum od 1.000 anotiranih parova
- Uvijek evaluiraj prije i nakon kako bi potvrdio/la dobitak