Klasifikacija teksta pomoću ugradnji
Na ovoj stranici
Ciljevi
- Klasificiraj tekst bez treniranja modela
- Implementiraj klasifikaciju s nula primjera (zero-shot) i s nekoliko primjera (few-shot) koristeći ugradnje
- Usporedi performanse s laganim nadziranim klasifikatorom
Klasifikacija s nula primjera (Zero-shot)
Semantičko pretraživanje pronalazi dokumente slične upitu među tisućama kandidata. Klasifikacija okreće ovu postavku bez promjene temeljne mehanike: tvoji „dokumenti“ sada su tvoje kategorije (njih pet ili deset), a „upit“ je tekst koji želiš klasificirati. Oznaka čija je ugradnja najbliža postaje predviđanje. Bez treniranja, bez anotiranih podataka, samo jedan poziv API-ju.
Dva detalja implementacije u kodu ispod zaslužuju pažnju. Prvo, tekst i nazivi kategorija idu u jedan poziv embeddings.create, što smanjuje kašnjenje za broj oznaka. Drugo, primjena softmaxa na rezultate sličnosti pretvara sirove vrijednosti (koje se obično kreću od 0,3 do 0,5) u vjerojatnosti koje zbrojene daju 1. Te vjerojatnosti možeš prikazati korisniku ili ih usporediti s pragom pouzdanosti.
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"])
U ovom primjeru, „cijena dionice pala je za 15% nakon objave“ neočekivano završava u kategoriji Finance. Ovaj pristup nailazi na granicu kada su kategorije interne oznake čija imena ne otkrivaju ništa o njihovu sadržaju. Oznaka poput „P1“ ili „eskala razine 2“ nema iskoristivo semantičko značenje, što klasifikaciju čini u biti nasumičnom.
Klasifikacija s nekoliko primjera (Few-shot)
Točno to rješava klasifikacija s nekoliko primjera. Umjesto da kategoriju predstavljaš njezinim imenom, predstavljaš je težištem nekoliko stvarnih primjera. Kategorija „bug“ više nije riječ „bug“, već prosjek ugradnji za „aplikacija se ruši pri pokretanju“, „greška 500 na stranici za prijavu“ i „gumb ne radi na mobitelu“. Obično je dovoljno tri do pet primjera po razredu, a trošak ostaje isti kao za jedan poziv API-ju jer se svi tekstovi šalju zajedno.
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']}")
Testni tiket – „CSV izvoz ne sadrži sve stupce“ – ne sadrži ni riječ „bug“ ni „greška“, ali nalikuje na tri priložena primjera kvara, pa tamo i završava. Imaj na umu da usrednjavanje ugradnji pretpostavlja homogenu kategoriju. Ako tvoji primjeri za „pitanje“ miješaju upite o naplati s pitanjima o API-ju, njihovo težište pasti će u semantičku ničiju zemlju. U tom je slučaju bolje podijeliti kategoriju.
Lagani nadzirani klasifikator
Kada imaš nekoliko desetaka primjera po razredu, usrednjavanje postaje rasipanje informacija: ono izravnava oblik oblaka točaka. Linearni klasifikator treniran na istim ugradnjama umjesto toga uči granicu odlučivanja. Ugradnja se brine za razumijevanje jezika, dok LogisticRegression jednostavno crta geometrijsku liniju u tom prostoru. To rezultira vremenima treniranja od nekoliko sekundi na standardnom CPU-u, dok bi fino podešavanje jezičnog modela zahtijevalo GPU.
Petosmjerna unakrsna validacija nije samo za pokazivanje. Ona ti daje standardnu devijaciju točnosti, pružajući osjećaj koliko je tvoja procjena pouzdana. Rezultat od 0,91 ± 0,02 upotrebljiv je; 0,91 ± 0,15 signalizira skup podataka koji je premalen ili neuravnotežen.
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]
Usporedba pristupa
| Pristup | Potrebni primjeri | Točnost | Kašnjenje |
|---|---|---|---|
| Zero-shot | 0 | ~70-80% | 1 API poziv |
| Few-shot (3-5/razredu) | 15-25 | ~80-90% | 1 API poziv |
| Nadzirani (50+/razredu) | 250+ | ~90-95% | 1 API poziv + zaključivanje |
Čitane redom, ove tri linije opisuju napredak koji možeš slijediti tijekom životnog ciklusa proizvoda. Kreni s zero-shot prvog dana, bez ikakvih podataka. Nakon što ručno ispraviš dvadesetak predviđanja, iskoristi ih kao primjere za few-shot. Kada volumen anotacija prijeđe pedeset po razredu, istreniraj nadzirani klasifikator. Imaj na umu da te red „Kašnjenje“ podsjeća da čak i nadzirani model ostaje brz; lokalno zaključivanje dodaje zanemarivo opterećenje u usporedbi s pozivom API-ju za ugradnje.
Ključne točke
- Klasifikacija s nula primjera uspoređuje tekst s oznakama putem ugradnji
- Klasifikacija s nekoliko primjera koristi primjere za definiranje svake kategorije
- Nadzirani klasifikator (LogisticRegression) postiže najbolje performanse
- Kreni s nula primjera, zatim dodaj primjere ako točnost nije dovoljna