Szövegosztályozás beágyazásokkal
Ezen az oldalon
Célok
- Szöveg osztályozása modell betanítása nélkül
- Zero-shot és few-shot osztályozás megvalósítása beágyazások használatával
- Teljesítmény összehasonlítása egy könnyűsúlyú felügyelt osztályozóval
Zero-shot osztályozás
A szemantikus keresés ezer számú jelölt közül talál a lekérdezéshez hasonló dokumentumokat. Az osztályozás megfordítja ezt a felállást anélkül, hogy megváltoztatná az alapvető mechanizmust: a „dokumentumaid“ most a kategóriáid (öt vagy tíz darab), a „lekérdezés“ pedig a szöveg, amelyet osztályozni szeretnél. Annak a címkének a beágyazása lesz az előrejelzés, amelyik a legközelebb található. Nincs betanítás, nincs annotált adat, csupán egyetlen API-hívás szükséges.
Az alábbi kódban két megvalósítási részlet érdemel figyelmet. Először is, a szöveg és a kategórianevek egyetlen embeddings.create hívásba kerülnek, ami a címkék számával arányosan csökkenti a késleltetést. Másodszor, a hasonlósági pontszámokra alkalmazott szoftmax függvény a nyers értékeket (amelyek jellemzően 0,3 és 0,5 között mozognak) 1-re összegződő valószínűségekké alakítja. Ezeket a valószínűségeket megjelenítheted a felhasználónak, vagy összehasonlíthatod egy megbízhatósági küszöbértékkel.
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"])
Ebben a példában a „a részvényárfolyam 15%-ot esett a bejelentés után“ szöveg meglepetés nélkül a Pénzügy kategóriába kerül. A megközelítés akkor ütközik korlátba, ha a kategóriák belső címkék, amelyek neve semmit nem árul el a tartalmukról. Egy olyan címke, mint a „P1“ vagy a „2. szintű eszkaláció“, nem hordoz kiaknázható szemantikai jelentést, így az osztályozás lényegében véletlenszerű lesz.
Few-shot osztályozás
Pont ezt javítja ki a few-shot osztályozás. Ahelyett, hogy egy kategóriát a nevével reprezentálnál, néhány valós példánnyal képzett súlyponttal (centrummal) teszed ezt. A „hiba“ kategória többé nem a „hiba“ szó, hanem az „az alkalmazás induláskor összeomlik“, „500-as hiba a bejelentkezési oldalon“ és „a gomb nem működik mobilon“ beágyazásainak átlaga. Osztályonként általában három-öt példa is elegendő, és a költség továbbra is egyetlen API-hívásnak felel meg, mivel az összes szöveget együtt küldjük el.
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']}")
A teszt jegy – „a CSV exportból hiányoznak az oszlopok“ – nem tartalmazza sem a „hiba“, sem a „hibaüzenet“ szót, de hasonlít a megadott három hibás működésre vonatkozó példára, így oda kerül besorolásra. Ne feledd, hogy a beágyazások átlagolása homogén kategóriát feltételez. Ha a „kérdés“ példáid vegyítik a számlázással kapcsolatos érdeklődéseket az API kérdésekkel, akkor a súlypontjuk szemantikai senkiföldjére kerül. Ilyen esetben jobb szétválasztani a kategóriát.
Könnyűsúlyú felügyelt osztályozó
Ha osztályonként több tucatnyi példád van, az átlagolás információpazarlás: ellapítja a pontfelhő alakját. Egy ugyanazon beágyazásokon betanított lineáris osztályozó ehelyett egy döntési határt tanul meg. A beágyazás végzi a nyelvi megértést, míg a LogisticRegression csupán egy geometriai vonalat húz ebben a térben. Ennek eredményeként a betanítási idő néhány másodperc egy szabványos CPU-n, szemben egy nyelvi modell finomhangolásával, amelyhez GPU szükséges.
Az ötszörös kereszthitelesítés (five-fold cross-validation) nem csak a show kedvéért van. Megadja a pontosság szórását, így képet kapsz arról, mennyire megbízható a becslésed. A 0,91 ± 0,02-es pontszám használható; a 0,91 ± 0,15 viszont túl kicsi vagy kiegyensúlyozatlan adathalmazra utal.
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]
Megközelítések összehasonlítása
| Megközelítés | Szükséges példák | Pontosság | Késleltetés |
|---|---|---|---|
| Zero-shot | 0 | ~70-80% | 1 API-hívás |
| Few-shot (3-5/osztály) | 15-25 | ~80-90% | 1 API-hívás |
| Felügyelt (50+/osztály) | 250+ | ~90-95% | 1 API-hívás + következtetés |
Ezt a három sort sorrendben olvasva egy olyan fejlődési ívet kapsz, amelyet a termék életciklusa során követhetsz. Kezdj a zero-shot módszerrel az első napon, amikor még nincs is adatod. Miután manuálisan kijavítottál húsz körüli előrejelzést, használd fel őket few-shot példaként. Amikor az annotált mennyiség osztályonként meghaladja az ötvenet, tanítsd be a felügyelt osztályozót. Ne feledd, hogy a „késleltetés“ sor arra emlékeztet: még a felügyelt modell is gyors marad; a helyi következtetés elhanyagolható többletterhet jelent a beágyazási API-híváshoz képest.
Főbb megállapítások
- A zero-shot osztályozás a szöveget a címkékhez hasonlítja beágyazások segítségével
- A few-shot példák használatával definiálja az egyes kategóriákat
- Egy felügyelt osztályozó (LogisticRegression) éri el a legjobb teljesítményt
- Kezdj zero-shot módszerrel, majd adj hozzá példákat, ha a pontosság nem kielégítő