Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Embeddingų derinimas

Paskaita 21 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Tikslai
  2. Kada derinti?
  3. 1 būdas: Tiesinis adapteris (Matryoshka)
  4. 2 būdas: Derinimas naudojant „Sentence Transformers“
  5. Kokybiško duomenų rinkinio rengimas
  6. Derinimo vertinimas
  7. Svarbiausi punktai

Tikslai

  • Suprasti, kada būtina derinti embeddingus
  • Paruošti porų duomenų rinkinį mokymui
  • Įgyvendinti derinimą naudojant lengvus adapterius

Kada derinti?

Pradėkime nuo blogų naujienų, kurios iš tikrųjų yra geros: daugeliu atvejų iš anksto apmokyti embeddingų modeliai veikia puikiai, o jų derinimas yra laiko švaistymas. Tik trys situacijos tai tikrai pateisina. Pirmoji – tai sritis su labai specializuota terminija: medicina, teisė, pramonė, kur bendros paskirties modelis nežino, kad „MI“ ir „miokardo infarktas“ reiškia tą patį. Antroji – kai pasiekiamas ribinis taškas: jau optimizavai chunkingą, pridėjai hibridinę paiešką ir perrikiavimą, o metrikos nejuda. Trečioji – tiesiog turi rankoje anotuočių tekstų poras, panašių ar nepanašių, kurios niekam nenaudojamos tavo paieškos žurnaluose.

Atvirkščiai, praleisk derinimą, jei turi mažiau nei tūkstantį anotuočių porų: mokymas tiesiog įsimins tavo pavyzdžius, bet neapibendrins. Praleisk jį ir tada, kai našumas jau tenkina – dviejų taškų padidėjimas prisiminime (recall) nėra vertas papildomo modelio palaikymo. Ir svarbiausia, patikrink, ar geresnis chunkingas ar geresnė užuomina (prompt) neišspręs problemos: tai beveik visada pigiau ir greičiau.

1 būdas: Tiesinis adapteris (Matryoshka)

Ekonomiškiausias požiūris palieka embeddingų modelį nepaliestą. Leidi jam generuoti vektorius, o tada viršuje apmokai mažą projekcijos sluoksnį, kuris iškraipo erdvę taip, kad suartintų tai, kas tavo srityje turi būti arti. OpenAI modelis lieka juoda dėže, pasiekiama per API; apmokomi tik keli šimtai tūkstančių parametrų, naudojant CPU, per kelias minutes.

Mokymasis remiasi tripletais: užklausa, dokumentas, kuris į ją atsako, ir dokumentas, kuris apima tą pačią temą, bet neatsako. Pažvelk į žemiau pateiktus medicininius pavyzdžius – neigiamas pavyzdys frazei „paracetamolio šalutinis poveikis“ nėra tekstas apie futbolą, o tekstas apie paracetamolį, parduodamą vaistinėse. Tai vadinama sunkiu neigiamu pavyzdžiu (hard negative), ir būtent jis moko modelį: akivaizdus neigiamas pavyzdys nieko nepataiso, nes bendros paskirties modelis jį jau teisingai klasifikavo.

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

Pats adapteris yra dviejų sluoksnių tinklas, kuris projektuoja 3072 modelio matmenis žemyn iki 256, su galutine normalizacija, kad išvesties vektoriai išliktų palyginami naudojant kosinusinį panašumą. Nuostolių funkcija yra triplet margin loss: ji lygi nuliui, kai užklausa yra arčiau teigiamo pavyzdžio nei neigiamo bent 0,2 riba, o kitu atveju baudžia proporcingai. Kitaip tariant, mokai modelį tik to, ko jis dar nesuprato, ir mokymasis natūraliai stabilizuojasi, kai tripletai yra gerai atskirti.

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

Yra vienas operacinis aspektas, kurio negali praleisti: tą dieną, kai diegsi šį adapterį, kiekvienas vektorius, jau saugomas tavo duomenų bazėje, turi būti vėl perduotas per projekciją, kitaip lygintum vektorius iš dviejų skirtingų erdvių. Numatyk visišką korpuso perindeksavimą savo gamybinėje diegimo versijoje.

2 būdas: Derinimas naudojant „Sentence Transformers“

Kai adapterio nepakanka, reikia modifikuoti patį embeddingų modelį, o tam reikia atviro kodo modelio, kurį talpini pats – šiuo atveju BAAI/bge-large-en-v1.5. „Sentence Transformers“ tai padaro prieinamą: aprašai pavyzdžius kaip tekstų poras su tęstine etikete, kur 1,0 reiškia „šie du tekstai turi būti arti“, o 0,2 reiškia „jie paviršutiniškai panašūs, stumk juos tolyn“. Tada CosineSimilarityLoss stumia apskaičiuotą kosinusinį panašumą link pateiktos etiketės.

Trys epochos ir šimtas sušildymo žingsnių yra konservatyvios vertės, ir ne be priežasties: esant kukliam duomenų rinkiniui, per ilgas mokymas sunaikina modelio bendrąsias žinias, todėl jis tampa puikus tavo pavyzdžiams, bet vidutiniškas visur kitur.

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

Kokybiško duomenų rinkinio rengimas

Štai tikroji kliūtis: niekas neturi tūkstančio anotuočių porų gulintčių nenaudojamų. Apėjimo būdas – sukurti jas iš to, ką jau turi, būtent iš savo dokumentų. Pateiki kiekvieną dokumentą LLM ir prašai sugeneruoti klausimus, į kuriuos jis tiksliai atsako, taip gauni klausimų ir dokumentų poras be jokio rankinio anotavimo. 0,7 temperatūra užtikrina, kad trys vienam dokumentui sugeneruoti klausimai nebus trys to paties sakinio variantai, o lstrip išvalo numeraciją, kurią modelis spontaniškai prideda.

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

Derinimo vertinimas

Mokymas su mažėjančiais nuostoliais nieko neįrodo: vienintelis svarbus klausimas – ar paieška pagerėjo. Toliau pateikta funkcija matuoja recall@5 toje pačioje užklausų aibėje, su adapteriu ir be jo, tiesiog perduodant adapter=None, norint gauti bazinį lygį. Ir korpusas, ir užklausos perduodamos per projekciją, kai ji pateikiama, ir tai yra sąlyga, kad abu vektoriai egzistuotų toje pačioje erdvėje.

Visada atlik šį palyginimą prieš diegdamas. Pasitaiko reguliariai, kad adapteris, apmokytas su per mažai tripletų, pablogina prisiminimą (recall), ir be matavimų išleistum regresiją manydamas, kad išleidai patobulinimą.

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)

Svarbiausi punktai

  • Embeddingų derinimas pagerina našumą specializuotose srityse
  • Tiesinis adapteris yra paprasčiausias metodas ir dažnai pakankamas
  • „Sentence Transformers“ leidžia giliau derinti visą modelį
  • Rekomenduojama turėti bent 1000 anotuočių porų
  • Visada įvertink prieš ir po, kad patvirtintum naudą