Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Prilagoditev vdelav (fine-tuning)

Lekcija 21 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Cilji
  2. Kdaj izvesti prilagoditev?
  3. Pristop 1: Linearni adapter (Matryoshka)
  4. Pristop 2: Prilagoditev s Sentence Transformers
  5. Priprava kakovostnega nabora podatkov
  6. Vrednotenje prilagoditve
  7. Ključne ugotovitve

Cilji

  • Razumeš, kdaj je prilagoditev vdelav nujna
  • Pripraviš parni nabor podatkov za usposabljanje
  • Implementiraš prilagoditev z lahkotnimi adapterji

Kdaj izvesti prilagoditev?

Začnimo z slabimi novicami, ki so pravzaprav dobre: v večini primerov predhodno usposobljeni modeli vdelav delujejo brezhibno in prilagoditev je izguba časa. Le trije scenariji jo resnično upravičujejo. Prvi je področje z zelo specializirano slovnico – medicina, pravo, industrija – kjer splošni model ne ve, da se “MI” in “miokardni infarkt” nanašata na isto stvar. Drugi je dosežen plato: optimiziral si razdrobljenost, dodal hibridno iskanje in ponovno razvrščanje, metrike pa se ne premaknejo. Tretji je preprosto dejstvo, da imaš pri roki anotirane besedilne pare, podobne ali različne, ki brezdelno ležijo v tvojih dnevnikih iskanja.

Nasprotno pa prilagoditev preskoči, če imaš manj kot tisoč anotiranih parov: usposabljanje si bo zapomnilo tvoje primere brez posploševanja. Preskoči jo tudi, če je zmogljivost že zadovoljiva – dvotočkovni porast priklica ni vreden vzdrževanja dodatnega modela. In predvsem preveri, ali boljša razdrobljenost ali boljši poziv ne bi rešila težave: skoraj vedno je ceneje in hitreje.

Pristop 1: Linearni adapter (Matryoshka)

Najbolj ekonomičen pristop pusti model vdelav nedotaknjen. Pustiš ga, da proizvede svoje vektorje, nato pa na vrhu usposobiš majhno projekcijsko plast, ki popači prostor tako, da približa tisto, kar mora biti na tvojem področju blizu. OpenAI-jev model ostane črna škatla, ki ji dostopaš prek API-ja; usposobiš le nekaj sto tisoč parametrov, na procesorju, v nekaj minutah.

Usposabljanje temelji na trojčkih: poizvedba, dokument, ki nanjo odgovarja, in dokument, ki obravnava isto temo, a ne odgovarja. Poglej spodnje medicinske primere – negativni primer za “stranski učinki paracetamola” ni besedilo o nogometu, temveč besedilo o paracetamolu, ki se prodaja v lekarnah. Temu pravimo trd negativen primer (hard negative) in prav to model nekaj nauči: očiten negativen primer ničesar ne popravi, saj ga je splošni model že pravilno razvrstil.

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 dvoslojno omrežje, ki projicira 3.072 dimenzij modela navzdol na 256, s končno normalizacijo, da ostanejo izhodni vektorji primerljivi s kosinusno podobnostjo. Funkcija izgube je triplet margin loss: enaka je nič, takoj ko je poizvedba bližje pozitivnemu kot negativnemu vsaj za rob 0,2, sicer pa kaznuje sorazmerno. Z drugimi besedami, model učiš le tistega, česar še ni razumel, in usposabljanje se naravno stabilizira, ko so trojčki dobro ločeni.

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")

Ena operativna točka, ki je ne smeš spregledati: na dan, ko ta adapter uvedeš v proizvodnjo, mora vsak vektor, že shranjen v tvoji zbirki podatkov, znova skozi projekcijo, sicer bi primerjal vektorje iz dveh različnih prostorov. Načrtuj popolno ponovno indeksiranje korpusa pri uvajanju v proizvodnjo.

Pristop 2: Prilagoditev s Sentence Transformers

Ko adapter ni dovolj, moraš spremeniti sam model vdelav, kar zahteva odprt model, ki ga gostiš sam – tukaj BAAI/bge-large-en-v1.5. Sentence Transformers to omogoča dostopno: primere opišeš kot besedilne pare z zvezno oznako, kjer 1,0 pomeni „ti dve besedili morata biti blizu”, 0,2 pa „videti sta si površno podobni, potisni ju narazen”. CosineSimilarityLoss nato potiska izračunano kosinusno podobnost proti podani oznaki.

Tri epohe in sto korakov ogrevanja so konservativne vrednosti, in to z dobrim razlogom: pri skromnem naboru podatkov predolgo usposabljanje uniči splošno znanje modela, zaradi česar je odličen na tvojih primerih in povprečen povsod drugje.

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"
])

Priprava kakovostnega nabora podatkov

Tu leži prava ovira: nihče nima tisoč anotiranih parov kar tako na zalogi. Obhodna pot je, da jih zgradiš iz tega, kar že imaš, namreč iz svojih dokumentov. Vsak dokument predložiš LLM-ju z zahtevo, naj napiše vprašanja, na katera ta dokument natančno odgovarja, in dobiš pare vprašanje-dokument brez ročnega anotiranja. Temperatura 0,7 zagotavlja, da tri vprašanja, ustvarjena za isti dokument, niso tri različice istega stavka, lstrip pa počisti oštevilčenje, ki ga model samodejno doda.

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

Vrednotenje prilagoditve

Usposabljanje z padajočo izgubo ne dokazuje ničesar: edino vprašanje, ki šteje, je, ali se je iskanje izboljšalo. Spodnja funkcija meri recall@5 na istem naboru poizvedb, z adapterjem in brez njega, preprosto tako, da podaš adapter=None za pridobitev izhodišča. Tako korpus kot poizvedbe gredo skozi projekcijo, ko je ta podana, kar je pogoj, da oba vektorja živita v istem prostoru.

To primerjavo vedno izvedi pred uvajanjem. Redno se zgodi, da adapter, usposobljen na premalo trojčkih, poslabša priklic, in brez merjenja bi sprožil regresijo, misleč, da si sprostil izboljšavo.

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 ugotovitve

  • Prilagoditev vdelav izboljša zmogljivost na specializiranih področjih
  • Linearni adapter je najpreprostejša metoda in pogosto zadostuje
  • Sentence Transformers omogoča globljo prilagoditev celotnega modela
  • Priporočljivo je vsaj 1.000 anotiranih parov
  • Pred in po prilagoditvi vedno izvedi vrednotenje za potrditev dobička