Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Ir-raffinar tal-embeddings

Lezzjoni 21 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Għanijiet
  2. Meta tagħmel raffinament?
  3. Approċċ 1: Adattatur lineari (Matryoshka)
  4. Approċċ 2: Raffinar b’Sentence Transformers
  5. Tħejjija ta’ sett ta’ data ta’ kwalità
  6. Evalwazzjoni tar-raffinar
  7. Punti Ewlenin

Għanijiet

  • tifhem meta jkun meħtieġ ir-raffinar tal-embeddings
  • tħejji sett ta’ data ta’ pari għat-taħriġ
  • timplimenta r-raffinar b’adattaturi ħfief

Meta tagħmel raffinament?

Ejja nibdew bl-aħbar ħażina, li fil-fatt hija tajba: fil-biċċa l-kbira tal-każijiet, il-mudelli tal-embeddings imħarrġa minn qabel jaħdmu perfettament, u r-raffinar huwa telf ta’ ħin. Hemm biss tliet sitwazzjonijiet li jiġġustifikawh verament. L-ewwel hija qasam b’vokabolarju speċjalizzat ħafna—mediċina, liġi, industrija—fejn il-mudell ġeneriku ma jafx li “MI” u “infart mijokardijaku” jirreferu għall-istess ħaġa. It-tieni hija meta tilħaq pjanċa: ottimizzajt il-qtugħ (chunking), żidt tfittxija ibrida u reranking, u l-metriki ma jiċċaqalqu xejn. It-tielet hija sempliċiment li jkollok pari ta’ testi annotati fuq idejk, simili jew dissimili, li qed jogħġbu f’reġistri tat-tfittxija tiegħek.

Bil-kontra, aqbeż ir-raffinar jekk għandek inqas minn elf par annotat: it-taħriġ se jiftakar l-eżempji tiegħek mingħajr ma jiġġeneralizza. Aqbiżu wkoll jekk il-prestazzjoni diġà hija sodisfaċenti—qligħ ta’ żewġ punti fir-recall ma jiswa xejn meta mqabbel mal-isforz li żżomm mudell addizzjonali. U fuq kollox, ivverifika li qtugħ aħjar jew prompt aħjar ma jsolvux il-problema: kważi dejjem ikun irħas u aktar mgħaġġel.

Approċċ 1: Adattatur lineari (Matryoshka)

L-aktar approċċ ekonomiku jħalli l-mudell tal-embedding intatt. Tħallih jipproduċi l-vetturi tiegħu, imbagħad taħriġ saff żgħir ta’ projezzjoni fuqu li jbiegħed l-ispazju biex iġib eqreb x’għandu jkun qrib fid-dominju tiegħek. Il-mudell ta’ OpenAI jibqa’ kaxxa sewda msejħa permezz tal-API; biss ftit mijiet ta’ eluf ta’ parametri jiġu mħarrġa, fuq CPU, f’ftit minuti.

It-taħriġ jiddependi fuq tripletti: mistoqsija, dokument li jwieġibha, u dokument li jkopri l-istess suġġett iżda ma jwieġibhiex. Ħares lejn l-eżempji mediċi hawn taħt—in-negattiv għal “effetti sekondarji tal-paracetamol” mhuwiex test dwar il-futbol, iżda test dwar il-paracetamol mibjugħ fl-ispiżeriji. Dan jissejjaħ negattiv iebsa (hard negative), u huwa dak li jgħallem lill-mudell xi ħaġa: negattiv ovvju ma jikkoreġi xejn peress li l-mudell ġeneriku diġà kklassifikah korrettament.

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-adattatur innifsu huwa netwerk ta’ żewġ saffi li jipprojetta d-3,072 dimensjoni tal-mudell ‘l isfel għal 256, b’normalizzazzjoni finali sabiex il-vetturi tal-output jibqgħu komparabbli permezz tas-similarità tal-kożinu. Il-funzjoni tat-telf hija triplet margin loss: tkun żero malli l-mistoqsija tkun eqreb lejn il-pożittiv milli lejn in-negattiv b’marġni ta’ mill-inqas 0.2, u tieħu penalità proporzjonali mod ieħor. Fi kliem ieħor, tgħallem lill-mudell biss dak li għadu ma fehimx, u t-taħriġ jistabbilizza naturalment ladarba t-tripletti jkunu separati sew.

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

Punt operattiv li ma tistax titlef: il-jum li tiddispjega dan l-adattatur, kull vettur diġà maħżun fil-bażi tad-data tiegħek irid jgħaddi mill-projezzjoni mill-ġdid, inkella tkun qed tqabbel vetturi minn żewġ spazji differenti. Ippjana għal reindicizzazzjoni sħiħa tal-korpus fir-rollout tal-produzzjoni tiegħek.

Approċċ 2: Raffinar b’Sentence Transformers

Meta l-adattatur ma jkunx biżżejjed, trid timmodifika l-mudell tal-embedding innifsu, li jeħtieġ mudell miftuħ li tospita int—hawnhekk BAAI/bge-large-en-v1.5. Sentence Transformers jagħmel dan aċċessibbli: tiddeskrivi l-eżempji bħala pari ta’ testi b’tikketta kontinwa, fejn 1.0 tfisser “dawn iż-żewġ testi għandhom ikunu qrib xulxin” u 0.2 tfisser “jidhru simili superficialment, ibiegħdhom”. Il-CosineSimilarityLoss imbagħad timbotta s-similarità tal-kożinu kkalkulata lejn it-tikketta pprovduta.

Tliet epoki u mitt pass ta’ tisħin (warmup) huma valuri konservattivi, u għal raġuni tajba: fuq sett ta’ data modest, taħriġ twil wisq jeqred l-għarfien ġenerali tal-mudell, u jagħmlu eċċellenti fuq l-eżempji tiegħek u medjokru kullimkien ieħor.

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

Tħejjija ta’ sett ta’ data ta’ kwalità

Hawnhekk jinsab l-ostakolu reali: ħadd m’għandu elf par annotat mimxi madwaru. Is-soluzzjoni hija li tibnihom minn dak li diġà għandek, jiġifieri d-dokumenti tiegħek. Tibgħat kull dokument lill-LLM u titlob il-mistoqsijiet li jwieġeb preċiżament, u tikseb pari ta’ mistoqsija-dokument mingħajr l-ebda annotazzjoni manwali. Temperatura ta’ 0.7 tiżgura li t-tliet mistoqsijiet iġġenerati għall-istess dokument ma jkunux tliet varjanti tal-istess sentenza, u lstrip tnaddaf in-numerazzjoni li l-mudell iżid spontanjament.

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

Evalwazzjoni tar-raffinar

It-taħriġ b’telf li jonqos ma jipprova xejn: l-unika mistoqsija li tgħodd hija jekk it-tfittxija titjibx. Il-funzjoni hawn taħt tkejjel ir-recall@5 fuq l-istess sett ta’ mistoqsijiet, bl-adattatur u mingħajru, sempliċiment billi tgħaddi adapter=None biex tikseb il-linja bażi. Kemm il-korpus kif ukoll il-mistoqsijiet jgħaddu mill-projezzjoni meta pprovduta, li hija l-kundizzjoni biex iż-żewġ vetturi jgħixu fl-istess spazju.

Dejjem ħaddem din il-komparazzjoni qabel ma tiddispjega. Jiġri regolarment li adattatur imħarreġ fuq ftit tripletti wisq jiddeterjora r-recall, u mingħajr kejl tkun qed tippubblika regressjoni taħseb li ppubblikajt titjib.

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)

Punti Ewlenin

  • Ir-raffinar tal-embeddings itejjeb il-prestazzjoni fuq domini speċjalizzati
  • Adattatur lineari huwa l-aktar metodu sempliċi u spiss biżżejjed
  • Sentence Transformers jippermetti raffinament aktar fond tal-mudell sħiħ
  • Huwa rrakkomandat minimu ta’ 1,000 par annotat
  • Dejjem evalwa qabel u wara biex tivvalida l-qligħ