Tekstiklassifikatsioon manuste abil
Sellel lehel
Eesmärgid
- Klassifitseeri teksti ilma mudelit treenimata
- Rakenda null- ja väheste näidetega klassifikatsiooni, kasutades manuseid
- Võrdle tulemuslikkust kergekaalise järelevalvega klassifikaatoriga
Null-näitega klassifikatsioon
Semantiline otsing leiab tuhandete kandidaatide hulgast päringuga sarnaseid dokumente. Klassifikatsioon pöörab selle stsenaariumi ümber, muutmata alusmehhanisme: sinu „dokumendid“ on nüüd sinu kategooriad (viis või kümme) ja „päring“ on tekst, mida soovid klassifitseerida. Silt, mille manus on kõige lähemal, saab ennustuseks. Ei mingit treenimist, ei märgendatud andmeid, vaid üksainus API väljakutse.
Allpool toodud koodis väärivad tähelepanu kaks rakendusdetaili. Esiteks sisestatakse tekst ja kategooriate nimed ühte embeddings.create väljakutsesse, mis vähendab latentsust siltide arvu võrra. Teiseks teisendab sarnasusskooridele softmaxi rakendamine toorväärtused (tavaliselt vahemikus 0,3–0,5) tõenäosusteks, mille summa on 1. Saad need tõenäosused kasutajale kuvada või võrrelda neid usalduslävendiga.
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"])
Selles näites maandub lause „aktsia hind langes pärast teadet 15%“ üllatamatult kategooriasse Finance. See lähenemine jõuab piirini, kui kategooriad on sisemised sildid, mille nimed ei reeda nende sisust midagi. Silt nagu „P1“ või „taseme 2 eskaleerimine“ ei kanna kasutatavat semantilist tähendust, muutes klassifikatsiooni sisuliselt juhuslikuks.
Väheste näidetega klassifikatsioon
Just seda probleemi lahendab väheste näidetega klassifikatsioon. Kategooria esindamiseks ei kasutata selle nime, vaid mõne reaalse näite tsentroidi. Kategooria „bug“ ei ole enam sõna „bug“, vaid keskmine manustest lausetele „rakendus jookseb käivitamisel kokku“, „500 viga sisselogimislehel“ ja „nupp ei tööta mobiilis“. Tavaliselt piisab klassi kohta kolmest kuni viiest näitest ning kulud jäävad ühe API väljakutse tasemele, kuna kõik tekstid saadetakse koos.
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']}")
Testpilet – „CSV eksport ei sisalda kõiki veerge“ – ei sisalda ei sõna „bug“ ega „error“, kuid see sarnaneb esitatud kolme rikke näitega, mistõttu sinna see ka maandub. Pane tähele, et manuste keskmistamine eeldab homogeenset kategooriat. Kui sinu „küsimuse“ näited segavad arvelduspäringuid API küsimustega, langeb nende tsentroid semantilisse mitte kuhugi. Sel juhul on parem kategooria lahku lüüa.
Kergekaaline järelevalvega klassifikaator
Kui sul on klassi kohta mitukümmend näidet, on keskmistamine info raiskamine: see lamendab punktipilve kuju. Samadel manustel treenitud lineaarne klassifikaator õpib hoopis otsustuspiiri. Manus tegeleb keele mõistmisega, samas kui LogisticRegression tõmbab sellesse ruumi lihtsalt geomeetrilise joone. See tähendab, et treenimisaeg on tavalisel protsessoril vaid mõni sekund, samas kui keelemudeli häälestamine nõuaks GPU-d.
Viiekordne ristvalideerimine ei ole pelgalt ilu pärast. See annab sulle täpsuse standardhälbe, pakkudes aimu hinnangu usaldusväärsusest. Tulemus 0,91 ± 0,02 on kasutatav; 0,91 ± 0,15 annab märku, et andmestik on liiga väike või tasakaalustamata.
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]
Lähenemisviiside võrdlus
| Lähenemine | Vajalikke näiteid | Täpsus | Latentsus |
|---|---|---|---|
| Null-näide | 0 | ~70–80% | 1 API väljakutse |
| Väheste näidetega (3–5/klass) | 15–25 | ~80–90% | 1 API väljakutse |
| Järelevalvega (50+/klass) | 250+ | ~90–95% | 1 API väljakutse + järeldus |
Neid kolme rida järjest lugedes kirjeldavad need arengut, mida saad toote elutsükli vältel järgida. Alusta esimesel päeval null-näitega, omamata ühtegi andmet. Kui oled käsitsi parandanud umbes kakskümmend ennustust, taaskasuta need väheste näidetena. Kui märgenduste maht ületab klassi kohta viiskümmend, treeni järelevalvega klassifikaator. Pea meeles, et rida „latentsus“ tuletab meelde, et isegi järelevalvega mudel jääb kiireks; kohalik järeldus lisab võrreldes manuste API väljakutsega tühise koormuse.
Peamised punktid
- Null-näitega klassifikatsioon võrdleb teksti siltidega manuste abil
- Väheste näidetega kasutatakse iga kategooria määratlemiseks näiteid
- Järelevalvega klassifikaator (
LogisticRegression) saavutab parima tulemuslikkuse - Alusta null-näitega ja lisa seejärel näiteid, kui täpsus on ebapiisav