Klassificering av text med inbäddningar
På denna sida
Mål
- Klassificera text utan att träna en modell
- Implementera nollskotts- och fåskottsklassificering med inbäddningar
- Jämför prestanda mot en lättviktig övervakad klassificerare
Nollskottsklassificering (Zero-shot)
Semantisk sökning hittar dokument som liknar en fråga bland tusentals kandidater. Klassificering vänder på detta upplägg utan att ändra den underliggande mekaniken: dina “dokument” är nu dina kategorier (fem eller tio stycken), och “frågan” är den text du vill klassificera. Den etikett vars inbäddning ligger närmast blir förutsägelsen. Ingen träning, inga annoterade data, bara ett enda API-anrop.
Två implementeringsdetaljer i koden nedan förtjänar uppmärksamhet. För det första skickas texten och kategorinamnen i ett enda embeddings.create-anrop, vilket minskar latensen med antalet etiketter. För det andra omvandlar tillämpningen av softmax på likhetspoängen råa värden (som vanligtvis varierar mellan 0,3 och 0,5) till sannolikheter som summerar till 1. Du kan visa dessa sannolikheter för en användare eller jämföra dem mot en konfidensnivå.
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 detta exempel hamnar “aktiekursen föll med 15 % efter tillkännagivandet” som väntat under Finans. Metoden stöter på begränsningar när kategorierna är interna etiketter vars namn inte avslöjar något om deras innehåll. En etikett som “P1” eller “eskaleringsnivå 2” bär ingen utnyttjbar semantisk betydelse, vilket gör klassificeringen i princip slumpmässig.
Fåskottsklassificering (Few-shot)
Detta är exakt vad fåskottsklassificering löser. Istället för att representera en kategori med dess namn, representerar du den med medelpunkten (centroiden) för några verkliga exempel. Kategorin “bugg” är inte längre ordet “bugg” utan medelvärdet av inbäddningar för “appen kraschar vid start”, “500-fel på inloggningssidan” och “knappen fungerar inte på mobilen”. Tre till fem exempel per klass räcker oftast, och kostnaden förblir densamma som för ett enda API-anrop eftersom alla texter skickas tillsammans.
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']}")
Testärendet – “CSV-exporten saknar kolumner” – innehåller varken ordet “bugg” eller “fel”, men det liknar de tre exemplen på funktionsfel som angavs, så dit hamnar det. Observera att medelvärdesbildning av inbäddningar förutsätter en homogen kategori. Om dina exempel på “frågor” blandar faktureringsförfrågningar med API-frågor kommer deras medelpunkt att hamna i ett semantiskt ingenmansland. I så fall är det bättre att dela upp kategorin.
Lättviktig övervakad klassificerare
När du har flera dussin exempel per klass blir medelvärdesbildning slöseri med information: det plattar till punktmolnets form. En linjär klassificerare tränad på samma inbäddningar lär sig istället en beslutgräns. Inbäddningen hanterar språkförståelsen, medan LogisticRegression helt enkelt drar en geometrisk linje i det rummet. Detta resulterar i träningstider på några sekunder på en vanlig CPU, medan finjustering av en språkmodell skulle kräva en GPU.
Femdubbel korsvalidering är inte bara för showen. Den ger dig standardavvikelsen för noggrannheten, vilket ger en uppfattning om hur tillförlitlig din uppskattning är. Ett resultat på 0,91 ± 0,02 är användbart; 0,91 ± 0,15 signalerar en datamängd som är för liten eller obalanserad.
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]
Jämförelse av metoder
| Metod | Exempel som krävs | Noggrannhet | Latens |
|---|---|---|---|
| Nollskott (Zero-shot) | 0 | ~70–80 % | 1 API-anrop |
| Fåskott (3–5/klass) | 15–25 | ~80–90 % | 1 API-anrop |
| Övervakad (50+/klass) | 250+ | ~90–95 % | 1 API-anrop + inferens |
Läser du dessa tre rader i ordning beskriver de en progression du kan följa under hela produktlivscykeln. Börja med nollskott dag ett, helt utan data. När du manuellt har korrigerat ett tjugotal förutsägelser återanvänder du dem som fåskottsexempel. När antalet annoteringar överstiger femtio per klass tränar du den övervakade klassificeraren. Kom ihåg att raden för “latens” påminner dig om att även den övervakade modellen förblir snabb; lokal inferens lägger till försumbar overhead jämfört med API-anropet för inbäddningar.
Viktiga punkter
- Nollskottsklassificering jämför text med etiketter via inbäddningar
- Fåskott använder exempel för att definiera varje kategori
- En övervakad klassificerare (
LogisticRegression) ger bäst prestanda - Börja med nollskott och lägg sedan till exempel om noggrannheten är otillräcklig