Klasifikacija besedila z vgradnjami
Na tej strani
Cilji
- Klasificiraj besedilo brez treniranja modela
- Implementiraj klasifikacijo brez primerov (zero-shot) in z nekaj primeri (few-shot) z uporabo vgradenj
- Primerjaj zmogljivost z lahkim nadzorovanim klasifikatorjem
Klasifikacija brez primerov (Zero-shot)
Semantično iskanje med tisoči kandidati poišče dokumente, podobne poizvedbi. Klasifikacija ta postopek obrne, ne da bi spremenila osnovno mehaniko: tvoji „dokumenti” so zdaj tvoje kategorije (pet ali deset jih je), „poizvedba” pa je besedilo, ki ga želiš klasificirati. Napoved postane oznaka, katere vgradnja je najbližja. Brez treniranja, brez označenih podatkov, samo en klic API-ja.
V spodnji kodi si zaslužita pozornost dve podrobnosti pri implementaciji. Prvič, besedilo in imena kategorij gresta v en sam klic embeddings.create, kar zmanjša zakasnitev za število oznak. Drugič, uporaba funkcije softmax na rezultatih podobnosti pretvori surove vrednosti (običajno med 0,3 in 0,5) v verjetnosti, ki se seštejejo v 1. Te verjetnosti lahko prikažeš uporabniku ali jih primerjaš s pragom zaupanja.
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"])
V tem primeru stavek „tečaj delnice je po napovedi padel za 15 %” nedvomno pristane v kategoriji Finance. Ta pristop naleti na mejo, ko so kategorije interne oznake, katerih imena ne razkrivajo ničesar o njihovi vsebini. Oznaka, kot je „P1” ali „eskalacija ravni 2”, nima uporabnega semantičnega pomena, zaradi česar je klasifikacija v bistvu naključna.
Klasifikacija z nekaj primeri (Few-shot)
Točno to popravi klasifikacija z nekaj primeri. Namesto da kategorijo predstavljaš z njenim imenom, jo predstaviš s težiščem nekaj resničnih primerov. Kategorija „napaka” ni več beseda „napaka”, temveč povprečje vgradenj za „aplikacija se ob zagonu sesuje”, „napaka 500 na prijavnici” in „gumb ne deluje na mobilni napravi”. Običajno zadostujejo trije do pet primerov na razred, strošek pa ostane enak kot pri enem samem klicu API-ja, saj so vsa besedila poslana skupaj.
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 listek – „izvoz CSV ne vsebuje vseh stolpcev” – ne vsebuje niti besede „napaka” niti „error”, vendar je podoben trem priloženim primerom okvare, zato pristane tam. Upoštevaj, da povprečenje vgradenj predpostavlja homogeno kategorijo. Če tvoji primeri za „vprašanje” mešajo poizvedbe o obračunih z vprašanji o API-ju, bo njihovo težišče pristalo v semantični ničevi deželi. V tem primeru je bolje kategorijo razdeliti.
Lahki nadzorovani klasifikator
Ko imaš na voljo nekaj deset primerov na razred, postane povprečenje zapravljanje informacij: splošči obliko oblaka točk. Linearni klasifikator, naučen na istih vgradnjah, se namesto tega nauči odločitvene meje. Vgradnja poskrbi za razumevanje jezika, LogisticRegression pa v tem prostoru preprosto nariše geometrijsko črto. To rezultira v časih treniranja, ki trajajo nekaj sekund na standardnem procesorju, medtem ko bi fino uglaševanje jezikovnega modela zahtevalo grafični procesor.
Petkratno navzkrižno preverjanje ni zgolj za pokazati. Doda ti standardni odklon točnosti, kar ti da občutek, kako zanesljiva je tvoja ocena. Rezultat 0,91 ± 0,02 je uporaben; 0,91 ± 0,15 pa signalizira nabor podatkov, ki je premajhen ali 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]
Primerjava pristopov
| Pristop | Potrebnih primerov | Točnost | Zakasnitev |
|---|---|---|---|
| Brez primerov (Zero-shot) | 0 | ~70–80 % | 1 klic API-ja |
| Z nekaj primeri (3–5/razred) | 15–25 | ~80–90 % | 1 klic API-ja |
| Nadzorovani (50+/razred) | 250+ | ~90–95 % | 1 klic API-ja + sklepanje |
Če te tri vrstice prebereš po vrstnem redu, opisujejo napredek, ki mu lahko slediš skozi življenjski cikel izdelka. Prvi dan začni z metodo brez primerov, brez kakršnih koli podatkov. Ko ročno popraviš kakih dvajset napovedi, jih ponovno uporabi kot primere za metodo z nekaj primeri. Ko količina označevanja preseže petdeset na razred, izurite nadzorovani klasifikator. Imej v mislih, da vrstica „zakasnitev” opominja, da tudi nadzorovani model ostane hiter; lokalno sklepanje doda zanemarljivo režijo v primerjavi s klicem API-ja za vgradnje.
Ključne ugotovitve
- Klasifikacija brez primerov primerja besedilo z oznakami prek vgradenj
- Metoda z nekaj primeri uporablja primere za opredelitev vsake kategorije
- Nadzorovani klasifikator (
LogisticRegression) doseže najboljšo zmogljivost - Začni z metodo brez primerov, nato dodaj primere, če točnost ni zadostna