Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Fino podešavanje ugrađivanja (embeddings)

Lekcija 21 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Ciljevi
  2. Kada fino podesiti?
  3. Pristup 1: Linearni adapter (Matryoshka)
  4. Pristup 2: Fino podešavanje sa Sentence Transformers
  5. Priprema kvalitetnog skupa podataka
  6. Evaluacija finog podešavanja
  7. Ključne točke

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