Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Βελτιστοποίηση embeddings με fine-tuning

Μάθημα 21 / 22 Ενημερώθηκε 29 Ιουλίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Στόχοι
  2. Πότε να κάνετε fine-tuning;
  3. Προσέγγιση 1: Γραμμικός προσαρμογέας (Matryoshka)
  4. Προσέγγιση 2: Fine-tuning με Sentence Transformers
  5. Προετοιμασία ενός ποιοτικού συνόλου δεδομένων
  6. Αξιολόγηση του fine-tuning
  7. Βασικά σημεία

Στόχοι

  • Να κατανοήσετε πότε είναι απαραίτητο το fine-tuning των embeddings
  • Να προετοιμάσετε ένα σύνολο δεδομένων ζευγών για εκπαίδευση
  • Να υλοποιήσετε fine-tuning με ελαφριούς προσαρμογείς (adapters)

Πότε να κάνετε fine-tuning;

Ας ξεκινήσουμε με τα άσχημα νέα, που στην πραγματικότητα είναι καλά: στις περισσότερες περιπτώσεις, τα προ-εκπαιδευμένα μοντέλα embeddings λειτουργούν άψογα και το fine-tuning αποτελεί χάσιμο χρόνου. Μόνο τρεις καταστάσεις το δικαιολογούν πραγματικά. Η πρώτη είναι ένας τομέας με εξαιρετικά εξειδικευμένο λεξιλόγιο—ιατρική, νομικά, βιομηχανία—όπου το γενικό μοντέλο δεν γνωρίζει ότι το «MI» και το «έμφραγμα του μυοκαρδίου» αναφέρονται στο ίδιο πράγμα. Η δεύτερη είναι όταν φτάνετε σε ένα οροπέδιο: έχετε βελτιστοποιήσει τον τεμαχισμό (chunking), έχετε προσθέσει υβριδική αναζήτηση και επαναβαθμολόγηση (reranking), και οι μετρικές δεν βελτιώνονται. Η τρίτη είναι απλώς να διαθέτετε ήδη σχολιασμένα ζεύγη κειμένων, όμοια ή ανόμοια, που μένουν αναξιοποίητα στα αρχεία καταγραφής της αναζήτησής σας.

Αντιθέτως, παραλείψτε το fine-tuning αν έχετε λιγότερα από χίλια σχολιασμένα ζεύγη: η εκπαίδευση θα απομνημονεύσει τα παραδείγματά σας χωρίς να γενικεύσει. Παραλείψτε το επίσης αν η απόδοση είναι ήδη ικανοποιητική—μια βελτίωση δύο μονάδων στην ανάκληση (recall) δεν αξίζει τη συντήρηση ενός επιπλέον μοντέλου. Και πάνω απ’ όλα, επαληθεύστε ότι ένας καλύτερος τεμαχισμός ή ένα καλύτερο prompt δεν θα λύσουν το πρόβλημα: είναι σχεδόν πάντα φθηνότερο και ταχύτερο.

Προσέγγιση 1: Γραμμικός προσαρμογέας (Matryoshka)

Η πιο οικονομική προσέγγιση αφήνει το μοντέλο embeddings άθικτο. Το αφήνετε να παράγει τα διανύσματά του και στη συνέχεια εκπαιδεύετε ένα μικρό στρώμα προβολής από πάνω, το οποίο παραμορφώνει τον χώρο ώστε να φέρνει πιο κοντά ό,τι πρέπει να είναι κοντά στον δικό σας τομέα. Το μοντέλο της OpenAI παραμένει ένα «μαύρο κουτί» στο οποίο καλείστε μέσω API· εκπαιδεύονται μόνο μερικές εκατοντάδες χιλιάδες παράμετροι, σε CPU, σε λίγα λεπτά.

Η εκπαίδευση βασίζεται σε τριάδες: ένα ερώτημα, ένα έγγραφο που το απαντά και ένα έγγραφο που καλύπτει το ίδιο θέμα αλλά δεν το απαντά. Δείτε τα ιατρικά παραδείγματα παρακάτω—το αρνητικό για τις «παρενέργειες της παρακεταμόλης» δεν είναι ένα κείμενο για το ποδόσφαιρο, αλλά ένα κείμενο για την παρακεταμόλη που πωλείται στα φαρμακεία. Αυτό ονομάζεται «σκληρό αρνητικό» (hard negative) και είναι αυτό που διδάσκει πραγματικά το μοντέλο: ένα προφανές αρνητικό δεν διορθώνει τίποτα, καθώς το γενικό μοντέλο το έχει ήδη ταξινομήσει σωστά.

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

Ο ίδιος ο προσαρμογέας είναι ένα δίκτυο δύο στρωμάτων που προβάλλει τις 3.072 διαστάσεις του μοντέλου σε 256, με τελική κανονικοποίηση ώστε τα διανύσματα εξόδου να παραμένουν συγκρίσιμα μέσω ομοιότητας συνημιτόνου. Η συνάρτηση κόστους είναι μια triplet margin loss: μηδενίζεται μόλις το ερώτημα βρίσκεται πιο κοντά στο θετικό παρά στο αρνητικό κατά τουλάχιστον ένα περιθώριο 0,2, και επιβάλλει ποινή αναλογικά διαφορετικά. Με άλλα λόγια, διδάσκετε στο μοντέλο μόνο ό,τι δεν έχει ακόμη κατανοήσει και η εκπαίδευση σταθεροποιείται φυσικά μόλις οι τριάδες διαχωριστούν επαρκώς.

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

Ένα λειτουργικό σημείο που δεν πρέπει να χάσετε: την ημέρα που θα αναπτύξετε αυτόν τον προσαρμογέα, κάθε διάνυσμα που είναι ήδη αποθηκευμένο στη βάση δεδομένων σας πρέπει να περάσει ξανά μέσω της προβολής, διαφορετικά θα συγκρίνετε διανύσματα από δύο διαφορετικούς χώρους. Προγραμματίστε την πλήρη επαναδημιουργία ευρετηρίου (reindexing) του σώματος κειμένων κατά την ανάπτυξη στην παραγωγή.

Προσέγγιση 2: Fine-tuning με Sentence Transformers

Όταν ο προσαρμογέας δεν αρκεί, πρέπει να τροποποιήσετε το ίδιο το μοντέλο embeddings, κάτι που απαιτεί ένα ανοιχτό μοντέλο που φιλοξενείτε εσείς—εδώ το BAAI/bge-large-en-v1.5. Το Sentence Transformers καθιστά αυτό προσιτό: περιγράφετε τα παραδείγματα ως ζεύγη κειμένων με μια συνεχή ετικέτα, όπου το 1,0 σημαίνει «αυτά τα δύο κείμενα πρέπει να είναι κοντά» και το 0,2 σημαίνει «μοιάζουν επιφανειακά, απομακρύνετέ τα». Η CosineSimilarityLoss ωθεί στη συνέχεια την υπολογισμένη ομοιότητα συνημιτόνου προς την παρεχόμενη ετικέτα.

Τρεις εποχές (epochs) και εκατό βήματα προθέρμανσης (warmup steps) είναι συντηρητικές τιμές, και για καλό λόγο: σε ένα μέτριο σύνολο δεδομένων, η υπερβολικά μεγάλη εκπαίδευση καταστρέφει τις γενικές γνώσεις του μοντέλου, καθιστώντας το εξαιρετικό στα παραδείγματά σας και μέτριο παντού αλλού.

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

Προετοιμασία ενός ποιοτικού συνόλου δεδομένων

Εδώ βρίσκεται το πραγματικό εμπόδιο: κανείς δεν έχει χίλια σχολιασμένα ζεύγη έτοιμα. Η λύση είναι να ταδομήσετε από ό,τι ήδη διαθέτετε, δηλαδή τα έγγραφά σας. Υποβάλλετε κάθε έγγραφο στο LLM ζητώντας τις ερωτήσεις στις οποίες απαντά με ακρίβεια και λαμβάνετε ζεύγη ερώτησης-εγγράφου χωρίς χειροκίνητη σχολίαση. Μια θερμοκρασία 0,7 διασφαλίζει ότι οι τρεις ερωτήσεις που παράγονται για το ίδιο έγγραφο δεν είναι τρεις παραλλαγές της ίδιας πρότασης, και το lstrip καθαρίζει την αρίθμηση που προσθέτει αυθόρμητα το μοντέλο.

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

Αξιολόγηση του fine-tuning

Η εκπαίδευση με φθίνουσα απώλεια (loss) δεν αποδεικνύει τίποτα: το μόνο ερώτημα που έχει σημασία είναι αν η αναζήτηση βελτιώθηκε. Η παρακάτω συνάρτηση μετρά το recall@5 στο ίδιο σύνολο ερωτημάτων, με και χωρίς τον προσαρμογέα, απλώς περνώντας adapter=None για να λάβετε τη βασική γραμμή (baseline). Τόσο το σώμα κειμένων όσο και τα ερωτήματα περνούν μέσω της προβολής όταν παρέχεται, κάτι που αποτελεί προϋπόθεση για να βρίσκονται και τα δύο διανύσματα στον ίδιο χώρο.

Εκτελείτε πάντα αυτή τη σύγκριση πριν από την ανάπτυξη. Συμβαίνει τακτικά ένας προσαρμογέας εκπαιδευμένος σε πολύ λίγες τριάδες να υποβαθμίζει την ανάκληση (recall) και, χωρίς μέτρηση, θα αναπτύσσατε μια οπισθοδρόμηση νομίζοντας ότι αναπτύσσατε μια βελτίωση.

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)

Βασικά σημεία

  • Το fine-tuning των embeddings βελτιώνει την απόδοση σε εξειδικευμένους τομείς
  • Ένας γραμμικός προσαρμογέας είναι η απλούστερη μέθοδος και συχνά επαρκής
  • Το Sentence Transformers επιτρέπει βαθύτερο fine-tuning του πλήρους μοντέλου
  • Συνιστάται ελάχιστος αριθμός 1.000 σχολιασμένων ζευγών
  • Αξιολογείτε πάντα πριν και μετά για να επικυρώσετε το κέρδος