Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Jemné ladění vnoření (embeddings)

Lekce 21 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Kdy ladit?
  3. Přístup 1: Lineární adaptér (Matryoshka)
  4. Přístup 2: Jemné ladění se Sentence Transformers
  5. Příprava kvalitního datasetu
  6. Hodnocení jemného ladění
  7. Klíčové poznatky

Cíle

  • Pochopit, kdy je jemné ladění vnoření nezbytné
  • Připravit párový dataset pro trénink
  • Implementovat jemné ladění pomocí lehkých adaptérů

Kdy ladit?

Začněme špatnou zprávou, která je ve skutečnosti dobrou: ve většině případů předtrénované modely vnoření fungují dokonale a jemné ladění je plýtváním úsilím. Pouze tři situace jej skutečně ospravedlňují. První je doména s vysoce specializovanou slovní zásobou – medicína, právo, průmysl – kde obecný model neví, že „MI“ a „infarkt myokardu“ označují totéž. Druhou je dosažení plató: optimalizoval jsi chunking, přidal hybridní vyhledávání a přerazování (reranking), ale metriky se ani nepohnuly. Třetí je prostě mít po ruce anotované textové páry, podobné či nepodobné, které leží ladem v tvých vyhledávacích logách.

Naopak jemné ladění přeskoč, pokud máš méně než tisíc anotovaných párů: trénink si tvé příklady zapamatuje, aniž by generalizoval. Přeskoč ho také, pokud je výkon již uspokojivý – zisk dvou bodů v recallu nestojí za udržování dalšího modelu. A především si ověř, zda problém nevyřeší lepší chunking nebo lepší prompt: téměř vždy je to levnější a rychlejší.

Přístup 1: Lineární adaptér (Matryoshka)

Nejúspornější přístup ponechává model vnoření nedotčený. Necháš ho generovat vektory a následně natrénuješ malou projekční vrstvu navíc, která prostor deformuje tak, aby sblížila to, co musí být ve tvé doméně blízko u sebe. Model OpenAI zůstává černou skřínkou volanou přes API; trénuje se pouze několik set tisíc parametrů, na CPU, během minut.

Trénink spoléhá na triplety: dotaz, dokument, který na něj odpovídá, a dokument, který pokrývá stejné téma, ale neodpovídá. Podívej se na níže uvedené lékařské příklady – negativum pro „vedlejší účinky paracetamolu“ není text o fotbale, ale text o paracetamolu prodávaném v lékárnách. Tomu se říká tvrdé negativum (hard negative) a právě to model něco učí: zřejmé negativum nic neopraví, protože obecný model jej již správně klasifikoval.

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

Samotný adaptér je dvouvrstvá síť, která projektuje 3 072 rozměrů modelu dolů na 256, s finální normalizací, aby výstupní vektory zůstaly porovnatelné pomocí kosinové podobnosti. Funkce ztráty je triplet margin loss: rovná se nule, jakmile je dotaz blíže k pozitivu než k negativu alespoň o margin 0,2, a v opačném případě trestá úměrně. Jinými slovy, model učíš pouze tomu, co ještě nepochopil, a trénink se přirozeně stabilizuje, jakmile jsou triplety dobře odděleny.

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

Jeden provozní bod, který nesmíš přehlédnout: v den nasazení tohoto adaptéru musí každý vektor již uložený v tvé databázi projít opětovnou projekcí, jinak bys porovnával vektory ze dvou různých prostorů. Naplánuj si kompletní přeindexování korpusu při nasazení do produkce.

Přístup 2: Jemné ladění se Sentence Transformers

Když adaptér nestačí, musíš upravit samotný model vnoření, což vyžaduje otevřený model, který hostíš – zde BAAI/bge-large-en-v1.5. Sentence Transformers to zpřístupňuje: příklady popíšeš jako textové páry se spojitou nálepkou, kde 1,0 znamená „tyto dva texty by měly být blízko“ a 0,2 znamená „povrchově vypadají podobně, odtlač je od sebe“. CosineSimilarityLoss následně tlačí vypočtenou kosinovou podobnost směrem k poskytnuté nálepce.

Tři epochy a sto kroků zahřívání (warmup) jsou konzervativní hodnoty a z dobrého důvodu: u skromného datasetu příliš dlouhý trénink ničí obecné znalosti modelu, čímž se stává vynikajícím na tvých příkladech a průměrným všude jinde.

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

Příprava kvalitního datasetu

Zde leží skutečná překážka: nikdo nemá po ruce tisíc anotovaných párů. Obcházením je vytvořit je z toho, co již máš, totiž ze svých dokumentů. Každý dokument předložíš LLM s žádostí o otázky, na které přesně odpovídá, a získáš páry otázka-dokument bez jakékoli manuální anotace. Teplota 0,7 zajišťuje, že tři otázky vygenerované pro stejný dokument nejsou tři varianty téže věty, a lstrip čistí číslování, které model spontánně přidává.

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

Hodnocení jemného ladění

Trénink s klesající ztrátou nic nedokazuje: jediná otázka, na které záleží, je, zda se vyhledávání zlepšilo. Níže uvedená funkce měří recall@5 na stejné sadě dotazů, s adaptérem i bez něj, prostým předáním adapter=None pro získání baseline. Korpus i dotazy procházejí projekcí, pokud je poskytnuta, což je podmínkou pro to, aby oba vektory žily ve stejném prostoru.

Toto srovnání vždy spusť před nasazením. Stává se pravidelně, že adaptér natrénovaný na příliš málo tripletů recall zhorší, a bez měření bys nasadil regresi v domnění, že nasazuješ zlepšení.

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)

Klíčové poznatky

  • Jemné ladění vnoření zlepšuje výkon ve specializovaných doménách
  • Lineární adaptér je nejjednodušší metoda a často postačuje
  • Sentence Transformers umožňují hlubší jemné ladění celého modelu
  • Doporučuje se minimum 1 000 anotovaných párů
  • Vždy proveď hodnocení před a po ladění pro ověření zisku