Clasificarea textului cu embedding-uri
Pe această pagină
Obiective
- Clasificați textul fără a antrena un model
- Implementați clasificarea zero-shot și few-shot folosind embedding-uri
- Comparați performanța cu un clasificator supervizat ușor
Clasificare zero-shot
Căutarea semantică găsește documente similare unei interogări printre mii de candidați. Clasificarea inversează această configurație fără a modifica mecanismele de bază: „documentele“ dumneavoastră devin acum categoriile (cinci sau zece la număr), iar „interogarea“ este textul pe care doriți să îl clasificați. Eticheta al cărei embedding este cel mai apropiat devine predicția. Fără antrenament, fără date adnotate, doar un singur apel API.
Două detalii de implementare din codul de mai jos merită atenție. În primul rând, textul și numele categoriilor intră într-un singur apel embeddings.create, ceea ce reduce latența proporțional cu numărul de etichete. În al doilea rând, aplicarea funcției softmax asupra scorurilor de similaritate convertește valorile brute (care variază de obicei între 0,3 și 0,5) în probabilități care însumează 1. Puteți afișa aceste probabilități unui utilizator sau le puteți compara cu un prag de încredere.
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"])
În acest exemplu, „prețul acțiunii a scăzut cu 15% după anunț“ ajunge, firesc, la categoria Finanțe. Această abordare își atinge limita atunci când categoriile sunt etichete interne ale căror nume nu dezvăluie nimic despre conținutul lor. O etichetă precum „P1“ sau „escaladare nivel 2“ nu poartă niciun sens semantic exploatabil, făcând clasificarea practic aleatorie.
Clasificare few-shot
Exact aici intervine clasificarea few-shot. În loc să reprezentați o categorie prin numele său, o reprezentați prin centroidul câtorva exemple reale. Categoria „bug“ nu mai este cuvântul „bug“, ci media embedding-urilor pentru „aplicația se blochează la pornire“, „eroare 500 pe pagina de autentificare“ și „butonul nu funcționează pe mobil“. Trei până la cinci exemple per clasă sunt de obicei suficiente, iar costul rămâne cel al unui singur apel API, deoarece toate textele sunt trimise împreună.
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']}")
Tichetul de test – „exportul CSV nu conține toate coloanele“ – nu conține nici cuvântul „bug“, nici „eroare“, dar seamănă cu cele trei exemple de defecțiune furnizate, așa că acolo ajunge. Rețineți că medierea embedding-urilor presupune o categorie omogenă. Dacă exemplele dumneavoastră de tip „întrebare“ amestecă solicitări de facturare cu întrebări despre API, centroidul lor va cădea într-un „nimic semantic“. În acest caz, este mai bine să divizați categoria.
Clasificator supervizat ușor
Când aveți câteva zeci de exemple per clasă, medierea devine o risipă de informații: aplatizează forma norului de puncte. Un clasificator liniar antrenat pe aceleași embedding-uri învață în schimb o frontieră de decizie. Embedding-ul se ocupă de înțelegerea limbajului, în timp ce LogisticRegression desenează pur și simplu o linie geometrică în acel spațiu. Acest lucru rezultă în timpi de antrenament de câteva secunde pe un CPU standard, în timp ce fine-tuning-ul unui model de limbaj ar necesita un GPU.
Validarea încrucișată în cinci folduri (five-fold cross-validation) nu este doar pentru efect. Aceasta vă oferă abaterea standard a acurateței, oferindu-vă o idee despre cât de fiabilă este estimarea dumneavoastră. Un scor de 0,91 ± 0,02 este utilizabil; 0,91 ± 0,15 semnalează un set de date prea mic sau dezechilibrat.
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]
Compararea abordărilor
| Abordare | Exemple necesare | Acuratețe | Latență |
|---|---|---|---|
| Zero-shot | 0 | ~70-80% | 1 apel API |
| Few-shot (3-5/clasă) | 15-25 | ~80-90% | 1 apel API |
| Supervizat (50+/clasă) | 250+ | ~90-95% | 1 apel API + inferență |
Citite în ordine, aceste trei linii descriu o progresie pe care o puteți urma pe parcursul ciclului de viață al produsului. Începeți cu zero-shot în prima zi, fără niciun fel de date. Odată ce ați corectat manual vreo douăzeci de predicții, reciclați-le ca exemple few-shot. Când volumul de adnotări depășește cincizeci per clasă, antrenați clasificatorul supervizat. Rețineți că rândul „latență“ vă amintește că chiar și modelul supervizat rămâne rapid; inferența locală adaugă o suprasarcină neglijabilă în comparație cu apelul API de embedding.
Puncte cheie
- Clasificarea zero-shot compară textul cu etichetele prin intermediul embedding-urilor
- Few-shot folosește exemple pentru a defini fiecare categorie
- Un clasificator supervizat (
LogisticRegression) obține cea mai bună performanță - Începeți cu zero-shot, apoi adăugați exemple dacă acuratețea este insuficientă