Salt la conținutul principal
Română— Alege o limbă
Meniu

Clasificarea textului cu embedding-uri

Lecția 17 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. Clasificare zero-shot
  3. Clasificare few-shot
  4. Clasificator supervizat ușor
  5. Compararea abordărilor
  6. Puncte cheie

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

AbordareExemple necesareAcuratețeLatență
Zero-shot0~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ă