Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Beágyazások finomhangolása

21. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. Mikor érdemes finomhangolni?
  3. 1. megközelítés: Lineáris adapter (Matryoshka)
  4. 2. megközelítés: Finomhangolás Sentence Transformers segítségével
  5. Minőségi adathalmaz előkészítése
  6. A finomhangolás értékelése
  7. Főbb megállapítások

Célok

  • Megérteni, mikor szükséges a beágyazások finomhangolása
  • Páros adathalmaz előkészítése a tanításhoz
  • Finomhangolás megvalósítása könnyűsúlyú adapterekkel

Mikor érdemes finomhangolni?

Kezdjük a rossz hírrel, ami valójában jó: a legtöbb esetben az előre tanított beágyazási modellek tökéletesen működnek, és a finomhangolás felesleges erőfeszítés. Csak három helyzet indokolja igazán. Az első egy erősen specializált szókincset igénylő terület – orvostudomány, jog, ipar –, ahol az általános modell nem tudja, hogy az „MI“ és a „szívinfarktus“ ugyanarra utal. A második eset, amikor plafonra érsz: optimalizáltad a darabolást, hozzáadtad a hibrid keresést és az újrarendezést, de a mutatók nem mozdulnak. A harmadik eset pedig egyszerűen az, ha vannak kéznél annotált szövegpárjaid, hasonlóak vagy különbözőek, amelyek tétlenül hevernek a keresési naplóidban.

Ezzel szemben hagyd ki a finomhangolást, ha kevesebb mint ezer annotált párod van: a tanítás memorizálni fogja a példáidat általánosítás nélkül. Akkor is hagyd ki, ha a teljesítmény már kielégítő – két pontnyi javulás a visszaidézésben nem éri meg egy extra modell karbantartását. És mindenekelőtt ellenőrizd, hogy egy jobb darabolás vagy egy jobb prompt nem oldaná-e meg a problémát: ez szinte mindig olcsóbb és gyorsabb.

1. megközelítés: Lineáris adapter (Matryoshka)

A leggazdaságosabb megközelítés érintetlenül hagyja a beágyazási modellt. Hagyod, hogy előállítsa a vektorait, majd tanítasz rá egy kis vetítési réteget, amely úgy torzítja a teret, hogy közelebb hozza egymáshoz azt, aminek közel kell lennie a te doménedben. Az OpenAI modellje egy feketedoboz marad, amelyet API-n keresztül hívsz meg; csak néhány százezer paramétert tanítasz, CPU-n, percek alatt.

A tanítás hármasokon (tripleteken) alapul: egy lekérdezés, egy erre választ adó dokumentum, és egy dokumentum, amely ugyanarról a témáról szól, de nem ad választ. Nézd meg az alábbi orvosi példákat – a „paracetamol mellékhatásai“ lekérdezés negatív mintája nem egy focis szöveg, hanem egy a patikákban kapható paracetamolról szóló szöveg. Ezt hívják kemény negatív mintának (hard negative), és ez az, ami tanít valamit a modellnek: egy nyilvánvaló negatív minta semmit sem javít, mivel az általános modell ezt már helyesen osztályozta.

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

Maga az adapter egy kétrétegű hálózat, amely a modell 3072 dimenzióját 256-ra vetíti le, végső normalizálással, hogy a kimeneti vektorok továbbra is összehasonlíthatók maradjanak koszinusz-hasonlóság alapján. A veszteségfüggvény egy triplet margin loss: akkor nulla, ha a lekérdezés legalább 0,2 marginnal közelebb van a pozitívhoz, mint a negatívhoz, egyébként arányosan büntet. Más szóval, csak azt tanítod meg a modellnek, amit még nem értett meg, és a tanítás természetesen stabilizálódik, amint a hármasok jól elkülönülnek.

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

Egy működési szempont, amit nem hagyhatsz figyelmen kívül: azon a napon, amikor bevezeted ezt az adaptert, az adatbázisodban már tárolt minden egyes vektornak újra át kell esnie a vetítésen, különben két különböző térből származó vektorokat hasonlítanál össze. Tervezd meg a teljes korpusz újraindexelését a produkciós bevezetés során.

2. megközelítés: Finomhangolás Sentence Transformers segítségével

Amikor az adapter nem elég, magának a beágyazási modellnek a módosítására van szükség, amihez egy nyílt forráskódú modell szükséges, amelyet te hosztolsz – itt a BAAI/bge-large-en-v1.5. A Sentence Transformers ezt elérhetővé teszi: a példákat szövegpárokként írod le folytonos címkével, ahol az 1,0 azt jelenti, hogy „ennek a két szövegnek közel kell lennie“, a 0,2 pedig azt, hogy „felületesen hasonlónak tűnnek, taszítsd őket egymástól“. A CosineSimilarityLoss ezután a kiszámított koszinusz-hasonlóságot a megadott címke felé tolja.

Három epoch és száz warmup lépés konzervatív értékek, és jó okkal: szerény méretű adathalmazon a túl hosszú tanítás tönkreteszi a modell általános tudását, így az a te példáidon kiváló lesz, minden más területen pedig közepes.

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

Minőségi adathalmaz előkészítése

Itt rejlik az igazi akadály: senkinek nincs kéznél ezer annotált pár. A megoldás az, hogy abból építed fel őket, amid már van, nevezetesen a dokumentumaidból. Minden egyes dokumentumot beküldesz az LLM-nek azzal a kéréssel, hogy generálja le azokat a kérdéseket, amelyekre pontosan választ ad, így manuális annotálás nélkül kapsz kérdés-dokumentum párokat. A 0,7-es hőmérséklet biztosítja, hogy ugyanahhoz a dokumentumhoz generált három kérdés ne ugyanannak a mondatnak három variánsa legyen, a lstrip pedig megtisztítja a modell által spontán hozzáadott számozást.

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

A finomhangolás értékelése

A csökkenő veszteséggel történő tanítás semmit sem bizonyít: az egyetlen kérdés, ami számít, az az, hogy javult-e a keresés. Az alábbi függvény a recall@5 mutatót méri ugyanazon lekérdezések halmazán, adapterrel és anélkül, egyszerűen az adapter=None átadásával az alapvonal获取ásához. Mind a korpusz, mind a lekérdezések átesnek a vetítésen, ha az rendelkezésre áll, ami annak a feltétele, hogy mindkét vektor ugyanabban a térben legyen.

Mindig futtasd le ezt az összehasonlítást bevezetés előtt. Rendszeresen előfordul, hogy egy túl kevés hármason tanított adapter rontja a visszaidézést, és mérés nélkül úgy vezetnél be regressziót, hogy azt hitted, javítást vezetsz be.

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)

Főbb megállapítások

  • A beágyazások finomhangolása javítja a teljesítményt specializált doménekben
  • A lineáris adapter a legegyszerűbb módszer, és gyakran elegendő
  • A Sentence Transformers lehetővé teszi a teljes modell mélyebb finomhangolását
  • Legalább 1000 annotált pár ajánlott
  • Mindig végezz értékelést előtte és utána a nyereség igazolásához