Classificatie van tekst met embeddings
Op deze pagina
Doelstellingen
- Tekst classificeren zonder een model te trainen
- Zero-shot en few-shot classificatie implementeren met behulp van embeddings
- Prestaties vergelijken met een lichtgewicht supervised classifier
Zero-shot classificatie
Semantisch zoeken vindt documenten die overeenkomen met een query tussen duizenden kandidaten. Classificatie draait deze opzet om zonder de onderliggende mechanismen te wijzigen: uw “documenten” zijn nu uw categorieën (vijf of tien stuks), en de “query” is de tekst die u wilt classificeren. Het label waarvan de embedding het dichtst bij ligt, wordt de voorspelling. Geen training, geen geannoteerde data, slechts één API-aanroep.
Twee implementatiedetails in de onderstaande code verdienen aandacht. Ten eerste gaan de tekst en de categorienamen samen in één embeddings.create-aanroep, wat de latentie verlaagt met het aantal labels. Ten tweede zet het toepassen van softmax op de similariteitsscores ruwe waarden (doorgaans variërend van 0,3 tot 0,5) om in kansen die samen 1 optellen. U kunt deze kansen aan een gebruiker tonen of vergelijken met een betrouwbaarheidsdrempel.
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"])
In dit voorbeeld belandt “de aandelenkoers daalde met 15% na de aankondiging” zoals verwacht onder Finance. Deze aanpak stuit op een limiet wanneer categorieën interne labels zijn waarvan de namen niets onthullen over de inhoud. Een label als “P1” of “level 2 escalation” draagt geen bruikbare semantische betekenis, waardoor de classificatie in feite willekeurig wordt.
Few-shot classificatie
Dit is precies wat few-shot classificatie oplost. In plaats van een categorie door zijn naam weer te geven, representeert u deze door het zwaartepunt van enkele reële voorbeelden. De categorie “bug” is niet langer het woord “bug”, maar het gemiddelde van embeddings voor “de app crasht bij het opstarten”, “500-fout op de inlogpagina” en “de knop werkt niet op mobiel”. Drie tot vijf voorbeelden per klasse volstaan meestal, en de kosten blijven die van één API-aanroep omdat alle teksten samen worden verzonden.
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']}")
Het testticket—“de CSV-export mist kolommen”—bevat noch het woord “bug” noch “fout”, maar het lijkt op de drie verstrekte voorbeelden van storingen, dus daar belandt het. Houd er rekening mee dat het middelen van embeddings uitgaat van een homogene categorie. Als uw “vraag”-voorbeelden facturatievragen mengen met API-vragen, zal hun zwaartepunt in semantisch niemandsland belanden. In dat geval is het beter de categorie te splitsen.
Lichtgewicht supervised classifier
Wanneer u enkele tientallen voorbeelden per klasse heeft, is middelen een verspilling van informatie: het vlak de vorm van de puntenwolk af. Een lineaire classifier die op dezelfde embeddings is getraind, leert in plaats daarvan een beslissingsgrens. De embedding regelt het taalbegrip, terwijl LogisticRegression eenvoudigweg een geometrische lijn in die ruimte trekt. Dit resulteert in trainingstijden van enkele seconden op een standaard CPU, terwijl het fine-tunen van een taalmodel een GPU zou vereisen.
Voudfold-cross-validatie is niet alleen voor de show. Het geeft u de standaardafwijking van de nauwkeurigheid, wat inzicht biedt in de betrouwbaarheid van uw schatting. Een score van 0,91 ± 0,02 is bruikbaar; 0,91 ± 0,15 signaleert een dataset die te klein of onevenwichtig is.
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]
Benaderingen vergelijken
| Benadering | Vereiste voorbeelden | Nauwkeurigheid | Latentie |
|---|---|---|---|
| Zero-shot | 0 | ~70-80% | 1 API-aanroep |
| Few-shot (3-5/klass) | 15-25 | ~80-90% | 1 API-aanroep |
| Supervised (50+/klass) | 250+ | ~90-95% | 1 API-aanroep + inferentie |
Deze drie regels beschrijven, achtereenvolgens gelezen, een progressie die u gedurende de productlevenscyclus kunt volgen. Begin op dag één met zero-shot, zonder enige data. Zodra u twintig of zo voorspellingen handmatig heeft gecorrigeerd, hergebruikt u deze als few-shot voorbeelden. Wanneer het annotatievolume vijftig per klasse overschrijdt, traint u de supervised classifier. Houd in gedachten dat de rij “latentie” u eraan herinnert dat zelfs het supervised model snel blijft; lokale inferentie voegt verwaarloosbare overhead toe vergeleken met de API-aanroep voor embeddings.
Belangrijkste punten
- Zero-shot classificatie vergelijkt tekst met labels via embeddings
- Few-shot gebruikt voorbeelden om elke categorie te definiëren
- Een supervised classifier (LogisticRegression) behaalt de beste prestaties
- Begin met zero-shot en voeg vervolgens voorbeelden toe als de nauwkeurigheid ontoereikend is