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

Aicmiú téacs le leabaithe

Ceacht 17 as 22 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Cuspóirí
  2. Aicmiú nialas-lámhaigh (Zero-shot)
  3. Aicmiú beagán-lámhaigh (Few-shot)
  4. Aicmitheoir faoi mhaoirseacht éadrom
  5. Cur chuigí a chur i gcomparáid
  6. Príomhphointí

Cuspóirí

  • Téacs a aicmiú gan múnla a oiliúint
  • Aicmiú nialas-lámhaigh (zero-shot) agus beagán-lámhaigh (few-shot) a chur i bhfeidhm ag baint úsáide as leabaithe
  • Feidhmíocht a chur i gcomparáid le haicmitheoir faoi mhaoirseacht éadrom

Aicmiú nialas-lámhaigh (Zero-shot)

Aimsíonn cuardach seimeantach doiciméid atá cosúil le hiarratas i measc na mílte iarrthóir. Casann an t-aicmiú an socrú seo bun os cionn gan na meicníochtaí bunúsacha a athrú: is iad do chatagóirí (cúig nó deich gcinn acu) do “dhoiciméid” anois, agus is é an téacs atá le haicmiú agatsa an “t-iarratas”. Is é an lipéad a bhfuil a leabaithe is gaire dó an tuar. Gan oiliúint, gan sonraí anótáilte, ach glao amháin ar an API.

Tá dhá shonra cur chun feidhme sa chód thíos ar fiú aird a thabhairt orthu. Ar an gcéad dul síos, téann an téacs agus ainmneacha na gcatagóirí isteach i nglao amháin embeddings.create, rud a laghdaíonn an moill de réir líon na lipéad. Ar an dara dul síos, nuair a chuirtear softmax i bhfeidhm ar na scóir chosúlachta, tiontaítear luachanna amha (a bhíonn idir 0.3 agus 0.5 de ghnáth) ina dóchúlachtaí a shuimíonn go 1. Is féidir leat na dóchúlachtaí seo a thaispeáint d’úsáideoir nó iad a chur i gcomparáid le tairseach muiníne.

from openai import OpenAI
import numpy as np

client = OpenAI()

def classifier_zero_shot(
    texte: str,
    categories: list[str],
    model: str = "text-embedding-3-large"
) -> dict:
    """Classifies text into categories without training."""
    # Embeddings for categories
    all_inputs = [texte] + categories
    response = client.embeddings.create(
        input=all_inputs,
        model=model
    )
    embs = [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    texte_emb = np.array(embs[0])
    cat_embs = np.array(embs[1:])

    # Similarity with each category
    scores = cat_embs @ texte_emb

    # Softmax to get probabilities
    exp_scores = np.exp(scores - np.max(scores))
    probas = exp_scores / exp_scores.sum()

    resultats = sorted(
        zip(categories, probas),
        key=lambda x: x[1], reverse=True
    )

    return {
        "prediction": resultats[0][0],
        "confiance": float(resultats[0][1]),
        "scores": {cat: float(p) for cat, p in resultats}
    }

# Usage
texte = "Le cours de l'action a chuté de 15% après l'annonce"
categories = ["Finance", "Sport", "Technologie", "Politique", "Santé"]

resultat = classifier_zero_shot(texte, categories)
print(f"Prédiction : {resultat['prediction']} "
      f"({resultat['confiance']:.1%})")
print("Scores :", resultat["scores"])

Sa sampla seo, titfidh “thit praghas na stoc 15% tar éis an fhógra” sa chuid Airgeadas gan amhras. Buaileann an cur chuige teorainn nuair is lipéid inmheánacha iad na catagóirí nach nochtann a n-ainmneacha aon rud faoina n-inneachar. Níl aon bhrí sheimeantach inúsáidte i lipéad cosúil le “P1” nó “éalú leibhéal 2”, rud a fhágann go bhfuil an t-aicmiú randamach go bunúsach.

Aicmiú beagán-lámhaigh (Few-shot)

Sin díreach an rud a réitíonn aicmiú beagán-lámhaigh. In ionad catagóir a léiriú lena hainm, déanann tú í a léiriú le lárphointe roinnt samplaí fíor. Ní an focal “fabht” atá sa chatagóir “fabht” a thuilleadh, ach meán na leabaithe do “titann an aip ar siúl”, “earráid 500 ar an leathanach logáilte isteach”, agus “ní oibríonn an cnaipe ar ghuthán póca”. De ghnáth, tá trí go cúig shampla in aghaidh an aicme go leor, agus fanann an costas mar an gcéanna le glao amháin ar an API ós rud é go seoltar na téacsanna go léir le chéile.

def classifier_few_shot(
    texte: str,
    exemples: dict[str, list[str]],
    model: str = "text-embedding-3-large"
) -> dict:
    """Classifies by similarity to labeled examples.

    Args:
        exemples: {"category": ["example1", "example2", ...]}
    """
    # Prepare all texts
    tous_textes = [texte]
    mapping = []
    for cat, txts in exemples.items():
        for t in txts:
            tous_textes.append(t)
            mapping.append(cat)

    # Embeddings in a single call
    response = client.embeddings.create(
        input=tous_textes, model=model
    )
    embs = [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    texte_emb = np.array(embs[0])

    # Average embeddings per category
    cat_embeddings = {}
    for i, cat in enumerate(mapping):
        emb = np.array(embs[i + 1])
        if cat not in cat_embeddings:
            cat_embeddings[cat] = []
        cat_embeddings[cat].append(emb)

    cat_moyennes = {
        cat: np.mean(embs_list, axis=0)
        for cat, embs_list in cat_embeddings.items()
    }

    # Similarity
    scores = {
        cat: float(np.dot(texte_emb, emb_moy) /
                    (np.linalg.norm(texte_emb) * np.linalg.norm(emb_moy)))
        for cat, emb_moy in cat_moyennes.items()
    }

    prediction = max(scores, key=scores.get)
    return {"prediction": prediction, "scores": scores}

# Usage
exemples = {
    "bug": [
        "L'application crash au démarrage",
        "Erreur 500 sur la page de connexion",
        "Le bouton ne fonctionne pas sur mobile",
    ],
    "feature": [
        "Pourriez-vous ajouter un mode sombre ?",
        "Il serait utile d'exporter en PDF",
        "Suggestion : intégrer un calendrier",
    ],
    "question": [
        "Comment changer mon mot de passe ?",
        "Où trouver les paramètres de notification ?",
        "Quelle est la limite de stockage ?",
    ],
}

texte = "L'export CSV ne contient pas toutes les colonnes"
resultat = classifier_few_shot(texte, exemples)
print(f"Catégorie : {resultat['prediction']}")

Níl an focal “fabht” ná “earráid” sa ticéad tástála—“tá colúin in easnamh san onnmhairiú CSV”—ach tá cosúlacht aige leis na trí shampla mífheidhmithe a soláthraíodh, mar sin sin an áit a dtiteann sé. Tabhair faoi deara go nglacann meánú leabaithe leis go bhfuil catagóir aonchineálach ann. Má mheascann do shamplaí “ceist” fiosruithe billeála le ceisteanna API, titfidh a lárphointe i dtír nach bhfuil ann go seimeantach. Sa chás sin, is fearr an chatagóir a roinnt.

Aicmitheoir faoi mhaoirseacht éadrom

Nuair a bhíonn roinnt dosaen sampla in aghaidh an aicme agat, is dramhaíl faisnéise é an meánú: cothromaíonn sé cruth an scamaill pointí. Foghlaimíonn aicmitheoir líneach arna oiliúint ar na leabaithe céanna teorainn chinntithe ina ionad sin. Déileálann an leabaithe le tuiscint teanga, agus ní dhéanann LogisticRegression ach líne gheoiméadrach a tharraingt sa spás sin. Mar thoradh air sin, bíonn amanna oiliúna cúpla soicind ar LAP caighdeánach, cé go n-éileodh múnla teanga a mhíneáil (fine-tuning) GPU.

Níl tras-bhailíochtú cúig-fhillteach ann ach le haghaidh taispeána. Tugann sé duit diall caighdeánach na cruinnis, rud a thugann tuiscint duit ar chomh hiontaofa agus atá do mheastachán. Tá scór 0.91 ± 0.02 inúsáidte; léiríonn 0.91 ± 0.15 tacar sonraí atá ró-bheag nó míchothromaithe.

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
import numpy as np

def entrainer_classifieur(
    textes: list[str],
    labels: list[str],
    model: str = "text-embedding-3-large"
) -> LogisticRegression:
    """Trains a classifier on embeddings."""
    # Generate embeddings
    response = client.embeddings.create(
        input=textes, model=model
    )
    X = np.array([d.embedding for d in sorted(response.data, key=lambda x: x.index)])

    # Train a classifier
    clf = LogisticRegression(max_iter=1000)
    
    # Cross-validation
    scores = cross_val_score(clf, X, labels, cv=5)
    print(f"Accuracy (5-fold CV) : {scores.mean():.3f} ± {scores.std():.3f}")

    # Train on the full dataset
    clf.fit(X, labels)
    return clf

def predire(clf, texte: str, model: str = "text-embedding-3-large") -> str:
    """Predicts the category of a text."""
    emb = client.embeddings.create(
        input=texte, model=model
    ).data[0].embedding
    return clf.predict([emb])[0]

Cur chuigí a chur i gcomparáid

Cur chuigeSamplaí de dhíthCruinneasMoill
Nialas-lámhach (Zero-shot)0~70-80%1 glao API
Beagán-lámhach (3-5/aicme)15-25~80-90%1 glao API
Faoi mhaoirseacht (50+/aicme)250+~90-95%1 glao API + tátail

Agus iad á léamh in ord, déanann na trí líne seo cur síos ar dhul chun cinn is féidir leat a leanúint ar fud shaolré an táirge. Tosaigh le nialas-lámhach ar an gcéad lá, gan aon sonraí ar fad. Nuair a bheidh fiche tuar nó mar sin ceartaithe agat de láimh, athchúrsáil iad mar shamplaí beagán-lámhaigh. Nuair a sháraíonn toirt na hanótála caoga in aghaidh na haicme, oiliúin an t-aicmitheoir faoi mhaoirseacht. Coinnigh i gcuimhne go gcuireann an ró “moill” i gcuimhne duit go bhfanann an múnla faoi mhaoirseacht tapa fiú; cuireann tátail áitiúil ualach neamhbhríoch leis i gcomparáid leis an nglao ar an API leabaithe.

Príomhphointí

  • Déanann aicmiú nialas-lámhaigh comparáid idir téacs agus lipéid trí leabaithe
  • Úsáideann beagán-lámhach samplaí chun gach catagóir a shainiú
  • Baintear an fheidhmíocht is fearr amach le haicmitheoir faoi mhaoirseacht (LogisticRegression)
  • Tosaigh le nialas-lámhach, ansin cuir samplaí leis mura leor an cruinneas