Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Upotusvektorien hienosäätö

Oppitunti 21 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Milloin hienosäätöä kannattaa tehdä?
  3. Lähestymistapa 1: Lineaarinen adapteri (Matryoshka)
  4. Lähestymistapa 2: Hienosäätö Sentence Transformersilla
  5. Laadukkaan datajoukon valmistelu
  6. Hienosäädön arviointi
  7. Keskeiset asiat

Tavoitteet

  • Ymmärrä, milloin upotusvektorien hienosäätö on tarpeen
  • Valmistele paridata joukko koulutusta varten
  • Toteuta hienosäätö kevyiden adapterien avulla

Milloin hienosäätöä kannattaa tehdä?

Aloitetaan huonoilla uutisilla, jotka ovat itse asiassa hyviä: useimmissa tapauksissa esikoulutetut upotusmallit toimivat moitteettomasti, ja hienosäätö on turhaa vaivannäköä. Vain kolme tilannetta oikeuttaa sen todella. Ensimmäinen on erikoistunutta sanastoa käyttävä ala – lääketiede, laki, teollisuus – jossa yleinen malli ei tiedä, että “MI” ja “sydäninfarkti” tarkoittavat samaa asiaa. Toinen on suorituskyvyn tasaantuminen: olet optimoinut tekstinpätkityksen, lisännyt hybridihaun ja uudelleenjärjestelyn, mutta mittarit eivät liiku. Kolmas on yksinkertaisesti se, että sinulla on käytössäsi annotoituja tekstipareja, samankaltaisia tai erilaisia, jotka lojuvat joutilaana hakulokeissasi.

Toisaalta ohita hienosäätö, jos sinulla on vähemmän kuin tuhat annotoitua paria: koulutus vain ulkolukee esimerkkisi yleistämisen sijaan. Ohita se myös, jos suorituskyky on jo tyydyttävä – kahden pisteen nousu osumatarkkuudessa ei ole yhden lisämallin ylläpidon arvoista. Ja ennen kaikkea varmista, ettei parempi pätkitys tai parempi kehote ratkaisisi ongelmaa: se on lähes aina halvempaa ja nopeampaa.

Lähestymistapa 1: Lineaarinen adapteri (Matryoshka)

Taloudellisin lähestymistapa jättää upotusmallin koskemattomaksi. Annat sen tuottaa vektorinsa, ja sen jälkeen koulutat sen päälle pienen projektio-kerroksen, joka vääristää avaruutta tuodakseen lähemmäs toisiaan ne asiat, jotka kuuluvat yhteen omalla alallasi. OpenAI:n malli pysyy mustana laatikkona, jota kutsutaan rajapinnan kautta; vain muutama sata tuhatta parametria koulutetaan, suorittimella (CPU), minuuteissa.

Koulutus perustuu tripletteihin: kysely, siihen vastaava dokumentti ja dokumentti, joka käsittelee samaa aihetta mutta ei vastaa kysymykseen. Katso alla olevia lääketieteellisiä esimerkkejä – negatiivinen esimerkki kyselylle “parasetamolin haittavaikutukset” ei ole teksti jalkapallosta, vaan teksti apteekeissa myytävästä parasetamolista. Tätä kutsutaan kovaksi negatiiviseksi esimerkiksi (hard negative), ja se on se, joka opettaa mallille jotain: ilmeinen negatiivinen esimerkki ei korjaa mitään, koska yleinen malli on jo luokitellut sen oikein.

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],
    }

Adapteri itsessään on kaksikerroksinen verkko, joka projisoi mallin 3 072 ulottuvuutta alas 256:een, lopullisella normalisoinnilla, jotta lähtövektorit pysyvät vertailukelpoisina kosinussimilariteetin avulla. Häviöfunktio on triplet margin loss: se on nolla heti, kun kysely on lähempänä positiivista kuin negatiivista vähintään 0,2:n marginaalilla, ja muuten se rankaisee suhteellisesti. Toisin sanoen opetat mallille vain sen, mitä se ei vielä ymmärrä, ja koulutus vakautuu luonnostaan, kun tripletit ovat hyvin erottuneet.

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

Yksi operatiivinen seikka, jota et saa missään nimessä unohtaa: sinä päivänä, kun otat tämän adapterin käyttöön, jokaisen tietokantaasi jo tallennetun vektorin on kuljettava projektion läpi uudelleen, muuten vertailisit kahden eri avaruuden vektoreita. Suunnittele koko korpuksen uudelleenindeksointi osaksi tuotantoon vientiäsi.

Lähestymistapa 2: Hienosäätö Sentence Transformersilla

Kun adapteri ei riitä, sinun on muokattava itse upotusmallia, mikä vaatii avoimen mallin, jonka isännöit itse – tässä tapauksessa BAAI/bge-large-en-v1.5. Sentence Transformers tekee tästä helppoa: kuvailet esimerkit tekstipareina, joilla on jatkuva label-arvo, jossa 1,0 tarkoittaa “näiden kahden tekstin pitäisi olla lähellä toisiaan” ja 0,2 tarkoittaa “ne näyttävät pinnallisesti samankaltaisilta, työnnä ne erilleen”. CosineSimilarityLoss pakottaa sitten lasketun kosinussimilariteetin kohti annettua label-arvoa.

Kolme epochia ja sata warmup-vaihetta ovat konservatiivisia arvoja, ja syystä: vaatimattomalla datajoukolla liian pitkä koulutus tuhoaa mallin yleisen tiedon, tehden siitä erinomaisen esimerkeillesi mutta keskinkertaisen kaikkialla muualla.

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

Laadukkaan datajoukon valmistelu

Tässä piilee todellinen este: kenelläkään ei ole valmiina tuhatta annotoitua paria. Ratkaisu on rakentaa ne siitä, mitä sinulla jo on, nimittäin dokumenteistasi. Syötät jokaisen dokumentin LLM:lle pyytäen kysymyksiä, joihin se vastaa tarkasti, ja saat kysely-dokumentti -pareja ilman manuaalista annotointia. Lämpötila 0,7 varmistaa, että samalle dokumentille generoidut kolme kysymystä eivät ole kolme varianttia samasta lauseesta, ja lstrip siivoaa numeroinnin, jonka malli lisää spontaanisti.

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

Hienosäädön arviointi

Koulutus laskevalla häviöllä ei prove mitään: ainoa kysymys, joka merkitsee, on parantuiko haku. Alla oleva funktio mittaa recall@5-arvoa samalla kyselyjoukolla, adapterin kanssa ja ilman, yksinkertaisesti välittämällä adapter=None saadaksesi perustason. Sekä korpus että kyselyt kulkevat projektion läpi, kun se on tarjolla, mikä on ehto sille, että molemmat vektorit ovat samassa avaruudessa.

Suorita tämä vertailu aina ennen käyttöönottoa. Säännöllisesti käy niin, että liian harvalla tripletillä koulutettu adapteri heikentää osumatarkkuutta, ja ilman mittausta julkaisisit regressioon luullen julkaisseesi parannuksen.

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)

Keskeiset asiat

  • Upotusvektorien hienosäätö parantaa suorituskykyä erikoistuneilla aloilla
  • Lineaarinen adapteri on yksinkertaisin menetelmä ja usein riittävä
  • Sentence Transformers mahdollistaa koko mallin syvällisemmän hienosäädön
  • Vähintään 1 000 annotoitua paria on suositeltavaa
  • Arvioi aina ennen ja jälkeen hyödyn vahvistamiseksi