Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Mionchoigeartú leabaithe

Ceacht 21 as 22 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Cuspóirí
  2. Cathain a dhéanfaidh tú mionchoigeartú?
  3. Cur Chuige 1: Oiriúnóir líneach (Matryoshka)
  4. Cur Chuige 2: Mionchoigeartú le Sentence Transformers
  5. Tacar sonraí ardchaighdeáin a ullmhú
  6. Mionchoigeartú a mheas
  7. Príomhphointí

Cuspóirí

  • Tuiscint a fháil ar cathain is gá mionchoigeartú leabaithe
  • Tacar sonraí péirí a ullmhú don oiliúint
  • Mionchoigeartú a chur i bhfeidhm le hoiriúnóirí éadroma

Cathain a dhéanfaidh tú mionchoigeartú?

Tosaímid leis an drochscéal, ar scéal maith i ndáiríre é: i bhformhór na gcásanna, oibríonn samhlacha leabaithe réamhoilte go foirfe, agus is cur amú ama é mionchoigeartú. Níl ach trí chás a thugann údar ceart leis. Is é an chéad chás ná fearann le foclóir an-speisialaithe—leigheas, dlí, tionscal—nach bhfuil a fhios ag an tsamhail ghinearálta go dtagraíonn “MI” agus “infarctú miócairdiach” don rud céanna. Is é an dara cás ná buaicphointe a bhaint amach: tá tú tar éis píosaí a optamú, cuardach hibrideach agus athrangú a chur leis, agus ní bhogann na méadrachtaí. Is é an tríú cás ná péirí téacs anótáilte a bheith agat cheana féin, cosúil nó difriúil, ina luí gan úsáid i do loganna cuardaigh.

Os a choinne sin, déan neamhaird ar mhionchoigeartú má tá níos lú ná míle péire anótáilte agat: déanfaidh an t-oiliúint do shamplaí a mheabhrú gan ginearálú a dhéanamh. Déan neamhaird air freisin má tá an fheidhmíocht sásúil cheana féin—ní fiú gnóthachan dhá phointe i nglaoch cuimhne samhl bhreise a chothabháil. Agus os cionn gach rud, fíoraigh nach réiteoidh píosaí níos fearr nó leid níos fearr an fhadhb: is beagnach i gcónaí níos saoire agus níos tapúla é sin.

Cur Chuige 1: Oiriúnóir líneach (Matryoshka)

Is é an cur chuige is eacnamaíúla ná an tsamhail leabaithe a fhágáil gan athrú. Ligean tú di a veicteoirí a tháirgeadh, ansin oiliúint a dhéanamh ar shraith réamh-mheastacháin bheag os a cionn a chuarann an spás chun rudaí a thabhairt níos gaire dá chéile a chaithfidh a bheith gar i do fhearann. Fanann samhail OpenAI ina bosca dubh ar a dtugtar trí API; níl ach cúpla céad míle paraiméadar á n-oiliúint, ar LAP, i gceann cúpla nóiméad.

Braitheann an t-oiliúint ar thripléid: ceist, doiciméad a fhreagraíonn í, agus doiciméad a chlúdaíonn an t-ábhar céanna ach nach bhfreagraíonn í. Féach ar na samplaí leighis thíos—ní téacs faoi pheil é an diúltach do “fo-iarsmaí paracetamóil”, ach téacs faoi pharacetamól a dhíoltar i gcógaslanna. Tugtar diúltach crua air seo, agus is é seo a mhúineann rud éigin don tsamhail: ní cheartaíonn diúltach soiléir rud ar bith ós rud é go rangú an tsamhail ghinearálta é i gceart cheana féin.

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

Is líonra dhá shraith é an t-oiriúnóir féin a dhéanann réamh-mheastachán ar 3,072 toise na samhla síos go 256, le normalú deiridh ionas go bhfanann veicteoirí aschurtha inchomparáide de réir cosúlachta comhshínis. Is é an fheidhm chaillteanais ná triplet margin loss: tá sé cothrom le nialas chomh luath agus atá an cheist níos gaire don dearfach ná don diúltach ar a laghad faoi imeall 0.2, agus pionósíonn sé go comhréireach murach sin. I bhfocail eile, ní mhúineann tú don tsamhail ach an rud nach dtuigeann sí fós, agus cobhsaíonn an t-oiliúint go nádúrtha nuair a bhíonn na tripléid scartha go maith.

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

Seo pointe oibríochtúil nach féidir leat a bheith ar iarraidh: an lá a imlonnaíonn tú an t-oiriúnóir seo, caithfidh gach veicteoir atá stóráilte cheana i do bhunachar sonraí dul tríd an réamh-mheastachán arís, nó bheadh tú ag déanamh comparáide idir veicteoirí ó dhá spás éagsúla. Pleanáil athinnéacsú iomlán an chorpais i do rolladh táirgeachta.

Cur Chuige 2: Mionchoigeartú le Sentence Transformers

Nuair nach leor an t-oiriúnóir, ní mór duit an tsamhail leabaithe féin a mhodhnú, rud a éilíonn samhail oscailte a óstálann tú féin—anseo BAAI/bge-large-en-v1.5. Déanann Sentence Transformers é seo inrochtana: déanann tú cur síos ar shamplaí mar péirí téacs le lipéad leanúnach, áit a gciallaíonn 1.0 “ba chóir go mbeadh an dá théacs seo gar dá chéile” agus ciallaíonn 0.2 “tá siad cosúil go superfisialach, brúigh iad óna chéile.” Ansin brúíonn an CosineSimilarityLoss an chosúlacht chomhshínis ríofa i dtreo an lipéid a soláthraíodh.

Is luachanna coimeádacha iad trí thréimhse agus céad céim téimh, agus tá cúis mhaith leis sin: ar thacar sonraí measartha, scriosann oiliúint ró-fhada eolas ginearálta na samhla, rud a fhágann go bhfuil sí den scoth ar do shamplaí agus measartha i ngach áit eile.

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

Tacar sonraí ardchaighdeáin a ullmhú

Seo an bac fíor: níl míle péire anótáilte ag duine ar bith ina luí timpeall. Is é an bealach timpeall air ná iad a thógáil as an rud atá agat cheana, eadhon do dhoiciméid. Cuir gach doiciméad faoi bhráid an LLM ag iarraidh na gceisteanna a fhreagraíonn sé go beacht, agus faigheann tú péirí ceiste-doiciméad gan aon anótáil láimhe. Cinntíonn teocht 0.7 nach trí leagan den abairt chéanna iad an trí cheist a ghintear don doiciméad céanna, agus glanann lstrip an uimhriú a chuireann an tsamhail leis go spontáineach.

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

Mionchoigeartú a mheas

Ní chruthaíonn oiliúint le caillteanas ag laghdú rud ar bith: ní haon cheist eile atá tábhachtach ach an bhfuil feabhas tagtha ar an gcuardach. Tomhaiseann an fheidhm thíos glaoch cuimhne@5 ar an tacar céanna ceisteanna, leis an oiriúnóir agus gan é, trí adapter=None a rith go simplí chun an bonnlíne a fháil. Téann an corpas agus na ceisteanna tríd an réamh-mheastachán nuair a sholáthraítear é, rud atá mar choinníoll go mbeidh an dá veicteoir sa spás céanna.

Rith an chomparáid seo i gcónaí sula ndéanann tú imlonnú. Tarlaíonn sé go rialta go ndéanann oiriúnóir a oiliúint ar ró-bheag tripléad dochar don ghlaoch cuimhne, agus gan tomhas, sheolfá cúlú ag ceapadh gur feabhsú a sheol tú.

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)

Príomhphointí

  • Feabhsaíonn mionchoigeartú leabaithe feidhmíocht ar fhearainn speisialaithe
  • Is é oiriúnóir líneach an modh is simplí agus is minic a leor é
  • Cuireann Sentence Transformers ar chumas mionchoigeartú níos doimhne ar an tsamhail iomlán
  • Moltar íosmhéid 1,000 péire anótáilte
  • Déan meastóireacht i gcónaí roimh agus tar éis chun an gnóthachan a bhailíochtú