Aicmiú téacs le leabaithe
Ar an leathanach seo
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 chuige | Samplaí de dhíth | Cruinneas | Moill |
|---|---|---|---|
| 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