Salt la conținutul principal
Română— Alege o limbă
Meniu

Ajustarea fină a embedding-urilor

Lecția 21 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. Când să faceți ajustare fină?
  3. Abordarea 1: Adaptor liniar (Matryoshka)
  4. Abordarea 2: Ajustare fină cu Sentence Transformers
  5. Pregătirea unui set de date de calitate
  6. Evaluarea ajustării fine
  7. Puncte cheie

Obiective

  • Să înțelegeți când este necesară ajustarea fină a embedding-urilor
  • Să pregătiți un set de date de perechi pentru antrenament
  • Să implementați ajustarea fină cu adaptoare ușoare

Când să faceți ajustare fină?

Să începem cu vestea proastă, care este de fapt una bună: în majoritatea cazurilor, modelele de embedding pre-antrenate funcționează perfect, iar ajustarea fină reprezintă o pierdere de efort. Doar trei situații justifică cu adevărat această demers. Prima este un domeniu cu un vocabular extrem de specializat—medicină, drept, industrie—unde modelul generic nu știe că „MI“ și „infarct miocardic“ se referă la același lucru. A doua este atingerea unui platou: ați optimizat segmentarea (chunking), ați adăugat căutarea hibridă și reranking-ul, iar metricile nu mai progresează. A treia este simpla posesie a unor perechi de text annotate, similare sau disimilare, care stau degeaba în jurnalele dumneavoastră de căutare.

În schimb, renunțați la ajustarea fină dacă aveți mai puțin de o mie de perechi annotate: antrenamentul va memora exemplele dumneavoastră fără a generaliza. Renunțați la ea și dacă performanța este deja satisfăcătoare—un câștig de două puncte la recall nu merită mentenanța unui model suplimentar. Și, mai presus de toate, verificați dacă o segmentare mai bună sau un prompt mai eficient nu ar rezolva problema: este aproape întotdeauna mai ieftin și mai rapid.

Abordarea 1: Adaptor liniar (Matryoshka)

Cea mai economică abordare lasă modelul de embedding neatins. Îl lăsați să producă vectorii săi, apoi antrenați un strat mic de proiecție deasupra, care deformează spațiul pentru a apropia elementele care trebuie să fie apropiate în domeniul dumneavoastră. Modelul OpenAI rămâne o cutie neagră apelată prin API; doar câteva sute de mii de parametri sunt antrenați, pe CPU, în câteva minute.

Antrenamentul se bazează pe tripleți: o interogare (query), un document care răspunde la aceasta și un document care acoperă același subiect, dar nu răspunde. Uitați-vă la exemplele medicale de mai jos—negativul pentru „efecte secundare paracetamol“ nu este un text despre fotbal, ci un text despre paracetamolul vândut în farmacii. Acesta se numește negativ dificil (hard negative) și este ceea ce învață modelul ceva: un negativ evident nu corectează nimic, deoarece modelul generic l-a clasificat deja corect.

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

Adaptorul în sine este o rețea cu două straturi care proiectează cele 3.072 de dimensiuni ale modelului până la 256, cu o normalizare finală astfel încât vectorii de ieșire să rămână comparabili prin similaritate cosinus. Funcția de pierdere este o pierdere de margine pentru tripleți (triplet margin loss): aceasta devine zero imediat ce interogarea este mai apropiată de pozitiv decât de negativ cu cel puțin o margine de 0,2, și penalizează proporțional în caz contrar. Cu alte cuvinte, învățați modelul doar ceea ce nu a înțeles încă, iar antrenamentul se stabilizează natural odată ce tripleții sunt bine separați.

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

Un punct operațional pe care nu trebuie să îl scăpați din vedere: în ziua în care implementați acest adaptor, fiecare vector deja stocat în baza dumneavoastră de date trebuie să treacă din nou prin proiecție; altfel, ați compara vectori din două spații diferite. Planificați reindexarea completă a corpusului în rollout-ul dumneavoastră de producție.

Abordarea 2: Ajustare fină cu Sentence Transformers

Când adaptorul nu este suficient, trebuie să modificați modelul de embedding însuși, ceea ce necesită un model open-source pe care îl găzduiți—aici BAAI/bge-large-en-v1.5. Sentence Transformers face acest lucru accesibil: descrieți exemplele ca perechi de text cu o etichetă continuă, unde 1,0 înseamnă „aceste două texte ar trebui să fie apropiate“, iar 0,2 înseamnă „par superficial similare, îndepărtați-le“. Funcția CosineSimilarityLoss împinge apoi similaritatea cosinus calculată către eticheta furnizată.

Trei epoci și o sută de pași de încălzire (warmup) sunt valori conservative, și pe bună dreptate: pe un set de date modest, un antrenament prea lung distruge cunoștințele generale ale modelului, făcându-l excelent pe exemplele dumneavoastră și mediocru peste tot în rest.

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

Pregătirea unui set de date de calitate

Aici se află adevăratul obstacol: nimeni nu are la îndemână o mie de perechi annotate. Soluția de compromis este să le construiți din ceea ce aveți deja, și anume documentele dumneavoastră. Trimiteți fiecare document către LLM cerându-i întrebările la care răspunde precis și obțineți perechi întrebare-document fără nicio annotare manuală. O temperatură de 0,7 asigură că cele trei întrebări generate pentru același document nu sunt trei variante ale aceleiași propoziții, iar lstrip curăță numerotarea pe care modelul o adaugă spontan.

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

Evaluarea ajustării fine

Antrenamentul cu o pierdere în scădere nu dovedește nimic: singura întrebare care contează este dacă căutarea s-a îmbunătățit. Funcția de mai jos măsoară recall@5 pe același set de interogări, cu și fără adaptor, simplu prin transmiterea adapter=None pentru a obține linia de bază. Atât corpusul, cât și interogările trec prin proiecție atunci când aceasta este furnizată, ceea ce este condiția ca ambii vectori să trăiască în același spațiu.

Rulați întotdeauna această comparație înainte de implementare. Se întâmplă regulat ca un adaptor antrenat pe prea puțini tripleți să degradeze recall-ul și, fără măsurători, ați livra o regresie crezând că livrați o îmbunătățire.

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)

Puncte cheie

  • Ajustarea fină a embedding-urilor îmbunătățește performanța în domenii specializate
  • Un adaptor liniar este metoda cea mai simplă și adesea suficientă
  • Sentence Transformers permite o ajustare fină mai profundă a întregului model
  • Se recomandă un minim de 1.000 de perechi annotate
  • Evaluați întotdeauna înainte și după pentru a valida câștigul