Klassificering af tekst med embeddings
På denne side
Mål
- Klassificér tekst uden at træne en model
- Implementér zero-shot og few-shot klassificering ved hjælp af embeddings
- Sammenlign ydeevnen med en letvægts overvåget klassificator
Zero-shot klassificering
Semantisk søgning finder dokumenter, der ligner en forespørgsel blandt tusindvis af kandidater. Klassificering vender denne opsætning på hovedet uden at ændre de underliggende mekanismer: dine “dokumenter” er nu dine kategorier (fem eller ti stykker), og “forespørgslen” er den tekst, du vil klassificere. Den label, hvis embedding ligger tættest på, bliver forudsigelsen. Ingen træning, ingen annoterede data, blot et enkelt API-kald.
To implementeringsdetaljer i koden nedenfor fortjener opmærksomhed. For det første sendes teksten og kategorinavnene i ét enkelt embeddings.create-kald, hvilket reducerer ventetiden med antallet af labels. For det andet konverterer anvendelsen af softmax på lighedsscoringerne rå værdier (typisk mellem 0,3 og 0,5) til sandsynligheder, der summerer til 1. Du kan vise disse sandsynligheder for en bruger eller sammenligne dem med en konfidencetærskel.
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"])
I dette eksempel havner “aktiekursen faldt med 15 % efter annonceringen” som forventet under Finans. Tilgangen støder på en begrænsning, når kategorierne er interne labels, hvis navne ikke afslører noget om deres indhold. En label som “P1” eller “eskaleringsniveau 2” bærer ingen udnyttelig semantisk betydning, hvilket gør klassificeringen i bund og grund tilfældig.
Few-shot klassificering
Det er præcis dette, few-shot klassificering løser. I stedet for at repræsentere en kategori med dens navn, repræsenterer du den ved centrum (centroiden) af nogle få rigtige eksempler. Kategorien “bug” er ikke længere ordet “bug”, men gennemsnittet af embeddings for “appen crascher ved opstart”, “500-fejl på login-siden” og “knappen virker ikke på mobil”. Tre til fem eksempler per klasse er normalt nok, og omkostningen svarer stadig til ét enkelt API-kald, da alle tekster sendes samlet.
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']}")
Testsagen – “CSV-eksporten mangler kolonner” – indeholder hverken ordet “bug” eller “fejl”, men den ligner de tre medfølgende eksempler på funktionsfejl, og derfor havner den der. Bemærk, at gennemsnitsberegning af embeddings forudsætter en homogen kategori. Hvis dine “spørgsmål”-eksempler blander fakturaspørgsmål med API-spørgsmål, vil deres centrum havne i semantisk ingenmandsland. I så fald er det bedre at opdele kategorien.
Letvægts overvåget klassificator
Når du har flere dusin eksempler per klasse, bliver gennemsnitsberegning spild af information: det udjævner punktskyens form. En lineær klassificator trænet på de samme embeddings lærer i stedet en beslutningsgrænse. Embeddinget håndterer sprogforståelsen, mens LogisticRegression blot tegner en geometrisk linje i det rum. Det resulterer i træningstider på få sekunder på en standard-CPU, hvor finjustering af en sprogmodel ville kræve en GPU.
Fem-fold krydsvalidering er ikke bare for show. Det giver dig standardafvigelsen for nøjagtigheden, hvilket giver en fornemmelse af, hvor pålideligt dit estimat er. En score på 0,91 ± 0,02 er brugbar; 0,91 ± 0,15 signalerer et datasæt, der er for lille eller ubalanceret.
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]
Sammenligning af tilgange
| Tilgang | Påkrævede eksempler | Nøjagtighed | Ventetid |
|---|---|---|---|
| Zero-shot | 0 | ~70-80 % | 1 API-kald |
| Few-shot (3-5/klass) | 15-25 | ~80-90 % | 1 API-kald |
| Overvåget (50+/klass) | 250+ | ~90-95 % | 1 API-kald + inferens |
Læst i rækkefølge beskriver disse tre linjer en progression, du kan følge gennem hele produktlivscyklussen. Start med zero-shot på dag ét, helt uden data. Når du manuelt har korrigeret en tyvetynd forudsigelser, kan du genbruge dem som few-shot eksempler. Når annotationsmængden overstiger halvtreds per klasse, træner du den overvågede klassificator. Husk, at rækken “ventetid” minder dig om, at selv den overvågede model forbliver hurtig; lokal inferens tilføjer ubetydeligt overhead sammenlignet med API-kaldet til embedding.
Vigtige pointer
- Zero-shot klassificering sammenligner tekst med labels via embeddings
- Few-shot bruger eksempler til at definere hver kategori
- En overvåget klassificator (
LogisticRegression) opnår den bedste ydeevne - Start med zero-shot, og tilføj derefter eksempler, hvis nøjagtigheden er utilstrækkelig