Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Fine-tuning des embeddings

Nodarbība 21 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Objectifs
  2. Quand faire un fine-tuning ?
  3. Approche 1 : Adaptateur linéaire (Matryoshka)
  4. Approche 2 : Fine-tuning avec Sentence Transformers
  5. Préparer un jeu de données de qualité
  6. Évaluer le fine-tuning
  7. Galvenās atziņas

Objectifs

  • Comprendre quand le fine-tuning des embeddings est nécessaire
  • Préparer un jeu de données de paires pour l’entraînement
  • Implémenter un fine-tuning avec des adaptateurs légers

Quand faire un fine-tuning ?

Commençons par la mauvaise nouvelle, qui est en réalité une bonne nouvelle : dans la plupart des cas, les modèles d’embedding pré-entraînés fonctionnent parfaitement, et le fine-tuning est une perte de temps. Seules trois situations le justifient vraiment. La première concerne un domaine au vocabulaire hautement spécialisé — médecine, droit, industrie — où le modèle générique ignore que « IM » et « infarctus du myocarde » désignent la même chose. La seconde survient lorsque tu atteins un plateau : tu as optimisé le découpage, ajouté la recherche hybride et le reranking, mais les métriques ne bougent plus. La troisième est simplement la disponibilité de paires de textes annotés, similaires ou dissimilaires, qui dorment dans tes journaux de recherche.

À l’inverse, saute le fine-tuning si tu disposes de moins de mille paires annotées : l’entraînement mémorisera tes exemples sans généraliser. Évite-le aussi si les performances sont déjà satisfaisantes — un gain de deux points en rappel ne vaut pas la maintenance d’un modèle supplémentaire. Et surtout, vérifie qu’un meilleur découpage ou un meilleur prompt ne résoudra pas le problème : c’est presque toujours moins cher et plus rapide.

Approche 1 : Adaptateur linéaire (Matryoshka)

L’approche la plus économique laisse le modèle d’embedding intact. Tu le laisses produire ses vecteurs, puis tu entraînes une petite couche de projection par-dessus pour déformer l’espace et rapprocher ce qui doit l’être dans ton domaine. Le modèle d’OpenAI reste une boîte noire appelée via API ; seuls quelques centaines de milliers de paramètres sont entraînés, sur CPU, en quelques minutes.

L’entraînement repose sur des triplets : une requête, un document qui y répond, et un document qui traite du même sujet mais n’y répond pas. Observe les exemples médicaux ci-dessous : le négatif pour « effets secondaires du paracétamol » n’est pas un texte sur le football, mais un texte sur le paracétamol vendu en pharmacie. On appelle cela un « hard negative » (négatif difficile), et c’est ce qui apprend quelque chose au modèle : un négatif évident ne corrige rien, car le modèle générique l’a déjà classé correctement.

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

L’adaptateur lui-même est un réseau à deux couches qui projette les 3 072 dimensions du modèle vers 256, avec une normalisation finale pour que les vecteurs de sortie restent comparables par similarité cosinus. La fonction de perte est une triplet margin loss : elle est nulle dès que la requête est plus proche du positif que du négatif d’au moins une marge de 0,2, et pénalise proportionnellement sinon. Autrement dit, tu n’enseignes au modèle que ce qu’il n’a pas encore compris, et l’entraînement se stabilise naturellement une fois les triplets bien séparés.

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 point opérationnel crucial : le jour où tu déploies cet adaptateur, chaque vecteur déjà stocké dans ta base de données doit repasser par la projection, sinon tu comparerais des vecteurs issus de deux espaces différents. Prévois une réindexation complète du corpus lors de ton déploiement en production.

Approche 2 : Fine-tuning avec Sentence Transformers

Lorsque l’adaptateur ne suffit pas, tu dois modifier le modèle d’embedding lui-même, ce qui nécessite un modèle ouvert que tu héberges — ici BAAI/bge-large-en-v1.5. Sentence Transformers rend cela accessible : tu décris les exemples comme des paires de textes avec une étiquette continue, où 1,0 signifie « ces deux textes doivent être proches » et 0,2 signifie « ils semblent superficiellement similaires, éloigne-les ». La CosineSimilarityLoss pousse alors la similarité cosinus calculée vers l’étiquette fournie.

Trois époques et cent étapes de warmup sont des valeurs conservatrices, et pour bonne raison : sur un jeu de données modeste, un entraînement trop long détruit les connaissances générales du modèle, le rendant excellent sur tes exemples et médiocre partout ailleurs.

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

Préparer un jeu de données de qualité

Voici le véritable obstacle : personne n’a mille paires annotées qui traînent. La solution de contournement consiste à les construire à partir de ce que tu possèdes déjà, namely tes documents. Tu soumets chaque document au LLM en lui demandant les questions auxquelles il répond précisément, et tu obtiens des paires question-document sans aucune annotation manuelle. Une température de 0,7 garantit que les trois questions générées pour un même document ne sont pas trois variantes de la même phrase, et lstrip nettoie la numérotation que le modèle ajoute spontanément.

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

Évaluer le fine-tuning

Un entraînement avec une perte décroissante ne prouve rien : la seule question qui compte est de savoir si la recherche s’est améliorée. La fonction ci-dessous mesure le recall@5 sur le même ensemble de requêtes, avec et sans adaptateur, simplement en passant adapter=None pour obtenir la ligne de base. Le corpus et les requêtes passent tous deux par la projection lorsqu’elle est fournie, condition sine qua non pour que les deux vecteurs vivent dans le même espace.

Exécute toujours cette comparaison avant le déploiement. Il arrive régulièrement qu’un adaptateur entraîné sur trop peu de triplets dégrade le rappel, et sans mesure, tu mettrais en production une régression en croyant livrer une amélioration.

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)

Galvenās atziņas

  • Le fine-tuning des embeddings améliore les performances dans les domaines spécialisés
  • Un adaptateur linéaire est la méthode la plus simple et souvent suffisante
  • Sentence Transformers permet un fine-tuning plus profond du modèle complet
  • Un minimum de 1 000 paires annotées est recommandé
  • Évalue toujours avant et après pour valider le gain