Klasifikavimas naudojant įterpinius
Šiame puslapyje
Tikslai
- Klasifikuoti tekstą nemokant modelio
- Įgyvendinti „nulinio šūvio“ (zero-shot) ir „kelių šūvių“ (few-shot) klasifikavimą naudojant įterpinius
- Palyginti našumą su lengvu prižiūrimu klasifikatoriumi
„Nulinio šūvio“ (Zero-shot) klasifikavimas
Semantinė paieška tūkstančiuose kandidatų suranda dokumentus, panašius į užklausą. Klasifikavimas šią sąranką apverčia aukštyn kojomis, nekeisdamas pagrindinės mechanikos: tavo „dokumentai“ dabar yra tavo kategorijos (penkios ar dešimt jų), o „užklausa“ – tai tekstas, kurį nori klasifikuoti. Etiketė, kurios įterpinys yra arčiausiai, tampa prognoze. Joks mokymas, jokių anotuotų duomenų, tik vienas API iškvietimas.
Toliau pateiktame kode verta atkreipti dėmesį į dvi įgyvendinimo detales. Pirma, tekstas ir kategorijų pavadinimai siunčiami vienu embeddings.create iškvietimu, taip sumažinant delsą tiek kartų, kiek yra etikečių. Antra, taikant „softmax“ funkciją panašumo balams, žaliavos reikšmės (paprastai svyruojančios nuo 0,3 iki 0,5) paverčiamos tikimybėmis, kurių suma lygi 1. Šias tikimybes gali rodyti naudotojui arba lyginti su pasitikėjimo slenksčiu.
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"])
Šiame pavyzdyje frazė „akcijų kaina nukrito 15 % po pranešimo“ be jokios nuostobos patenka į „Finansų“ kategoriją. Šis metodas pasiekia savo ribą, kai kategorijos yra vidinės etiketės, kurių pavadinimai nieko nepasako apie jų turinį. Etiketė kaip „P1“ arba „2 lygio eskalacija“ neturi jokios panaudojamos semantinės prasmės, todėl klasifikavimas tampa beveik atsitiktinis.
„Kelių šūvių“ (Few-shot) klasifikavimas
Būtent tai ir išsprendžia „kelių šūvių“ klasifikavimas. Užuot atstovavęs kategorijai jos pavadinimu, ją atstovauji kelių realių pavyzdžių centroidu (vidurkiu). Kategorija „klaida“ („bug“) nebėra žodis „klaida“, o vidurkis įterpinių, gautų iš frazių: „programėlė užstringa paleidimo metu“, „500 klaida prisijungimo puslapyje“ ir „mygtukas neveikia mobiliuosiuose įrenginiuose“. Paprastai pakanka trijų–penkių pavyzdžių vienai klasei, o kaina išlieka tokia pati kaip vieno API iškvietimo, nes visi tekstai siunčiami kartu.
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']}")
Bandomasis bilietas – „CSV eksporte trūksta stulpelių“ – neturi nei žodžio „klaida“, nei „error“, tačiau jis panašus į tris pateiktus veikimo sutrikimo pavyzdžius, todėl ten ir patenka. Atkreipk dėmesį, kad įterpinių vidurkio skaičiavimas daro prielaidą, jog kategorija yra vienalytė. Jei tavo „klausimų“ pavyzdžiai maišo sąskaitų faktūrų užklausas su API klausimais, jų centroidas atsidurs semantinėje niekieno žemėje. Tokiu atveju geriau kategoriją padalinti.
Lengvas prižiūrimas klasifikatorius
Kai turi keliasdešimt pavyzdžių vienai klasei, vidurkio skaičiavimas tampa informacijos švaistymu: tai išlygina taškų debesies formą. Tiesinis klasifikatorius, apmokytas tų pačių įterpinių pagrindu, vietoj to išmoksta sprendimo ribą. Įterpinys rūpinasi kalbos supratimu, o LogisticRegression tiesiog nubrėžia geometrinę liniją toje erdvėje. Dėl to mokymo laikas trunka kelias sekundes naudojant standartinį procesorių, tuo tarpu kalbos modelio derinimas (fine-tuning) reikalautų GPU.
Penkių kartų kryžminė validacija (five-fold cross-validation) nėra tik dėl grožio. Ji suteikia tikslumo standartinį nuokrypį, leisdamas suprasti, kiek patikimas tavo įvertis. 0,91 ± 0,02 rezultatas yra naudojamas; 0,91 ± 0,15 signalizuoja, kad duomenų rinkinys yra per mažas arba subalansuotas neteisingai.
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]
Metodų palyginimas
| Metodas | Reikalingi pavyzdžiai | Tikslumas | Delsa |
|---|---|---|---|
| Zero-shot | 0 | ~70–80 % | 1 API iškvietimas |
| Few-shot (3–5/klasei) | 15–25 | ~80–90 % | 1 API iškvietimas |
| Prižiūrimas (50+/klasei) | 250+ | ~90–95 % | 1 API iškvietimas + išvada |
Skaitant šias tris eilutes iš eilės, matyti progresiją, kurios gali laikytis viso produkto gyvavimo ciklo metu. Pradėk nuo „zero-shot“ pirmąją dieną, neturėdamas jokių duomenų. Kai rankiniu būdu ištaisi apie dvidešimt prognozių, panaudok jas kaip „few-shot“ pavyzdžius. Kai anotacijų apimtis viršija penkiasdešimt vienai klasei, apmokyk prižiūrimą klasifikatorių. Atmink, kad „delsos“ eilutė primena, jog net ir prižiūrimas modelis išlieka greitas; vietinė išvada priduria nereikšmingą apkrovą, palyginti su įterpinių API iškvietimu.
Svarbiausi punktai
- „Zero-shot“ klasifikavimas lygina tekstą su etiketėmis naudojant įterpinius
- „Few-shot“ naudoja pavyzdžius kiekvienai kategorijai apibrėžti
- Prižiūrimas klasifikatorius (
LogisticRegression) pasiekia geriausią našumą - Pradėk nuo „zero-shot“, tada pridėk pavyzdžių, jei tikslumo nepakanka