Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Classification de texte avec des embeddings

Nodarbība 17 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Objectifs
  2. Classification zero-shot
  3. Classification few-shot
  4. Classifieur supervisé léger
  5. Comparaison des approches
  6. Galvenās atziņas

Objectifs

  • Classifier du texte sans entraîner de modèle
  • Mettre en œuvre une classification zero-shot et few-shot utilisant des embeddings
  • Comparer les performances avec un classifieur supervisé léger

Classification zero-shot

La recherche sémantique trouve des documents similaires à une requête parmi des milliers de candidats. La classification inverse cette configuration sans changer la mécanique sous-jacente : vos « documents » deviennent maintenant vos catégories (cinq ou dix d’entre elles), et la « requête » est le texte que vous souhaitez classer. L’étiquette dont l’embedding est le plus proche devient la prédiction. Aucun entraînement, aucune donnée annotée, juste un seul appel API.

Deux détails d’implémentation dans le code ci-dessous méritent votre attention. Premièrement, le texte et les noms des catégories vont dans un seul appel embeddings.create, ce qui réduit la latence proportionnellement au nombre d’étiquettes. Deuxièmement, l’application d’une fonction softmax aux scores de similarité convertit les valeurs brutes (généralement comprises entre 0,3 et 0,5) en probabilités qui somment à 1. Vous pouvez afficher ces probabilités à un utilisateur ou les comparer à un seuil de confiance.

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:
    """Classifie le texte dans des catégories sans entraînement."""
    # Embeddings pour les catégories
    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:])

    # Similarité avec chaque catégorie
    scores = cat_embs @ texte_emb

    # Softmax pour obtenir les probabilités
    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"])

Dans cet exemple, « le cours de l’action a chuté de 15 % après l’annonce » atterrit sans surprise dans la catégorie Finance. L’approche atteint une limite lorsque les catégories sont des étiquettes internes dont les noms ne révèlent rien sur leur contenu. Une étiquette comme « P1 » ou « escalade niveau 2 » ne porte aucun sens sémantique exploitable, rendant la classification essentiellement aléatoire.

Classification few-shot

C’est exactement ce que corrige la classification few-shot. Au lieu de représenter une catégorie par son nom, vous la représentez par le centroïde de quelques exemples réels. La catégorie « bug » n’est plus le mot « bug », mais la moyenne des embeddings pour « l’application plante au démarrage », « erreur 500 sur la page de connexion » et « le bouton ne fonctionne pas sur mobile ». Trois à cinq exemples par classe suffisent généralement, et le coût reste celui d’un seul appel API puisque tous les textes sont envoyés ensemble.

def classifier_few_shot(
    texte: str,
    exemples: dict[str, list[str]],
    model: str = "text-embedding-3-large"
) -> dict:
    """Classifie par similarité avec des exemples étiquetés.

    Args:
        exemples: {"category": ["example1", "example2", ...]}
    """
    # Préparer tous les textes
    tous_textes = [texte]
    mapping = []
    for cat, txts in exemples.items():
        for t in txts:
            tous_textes.append(t)
            mapping.append(cat)

    # Embeddings en un seul appel
    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])

    # Moyenne des embeddings par catégorie
    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()
    }

    # Similarité
    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']}")

Le ticket de test — « l’export CSV ne contient pas toutes les colonnes » — ne contient ni le mot « bug » ni « erreur », mais il ressemble aux trois exemples de dysfonctionnement fournis, c’est donc là qu’il atterrit. Notez que la moyenne des embeddings suppose une catégorie homogène. Si vos exemples « question » mélangent des demandes de facturation et des questions sur l’API, leur centroïde tombera dans un no man’s land sémantique. Dans ce cas, il vaut mieux scinder la catégorie.

Classifieur supervisé léger

Lorsque vous disposez de plusieurs dizaines d’exemples par classe, la moyenne devient un gaspillage d’informations : elle aplatit la forme du nuage de points. Un classifieur linéaire entraîné sur les mêmes embeddings apprend plutôt une frontière de décision. L’embedding gère la compréhension du langage, tandis que LogisticRegression trace simplement une ligne géométrique dans cet espace. Cela se traduit par des temps d’entraînement de quelques secondes sur un CPU standard, alors que le fine-tuning d’un modèle de langage nécessiterait un GPU.

La validation croisée à cinq plis n’est pas là pour faire joli. Elle vous donne l’écart-type de la précision, fournissant une idée de la fiabilité de votre estimation. Un score de 0,91 ± 0,02 est utilisable ; 0,91 ± 0,15 signale un jeu de données trop petit ou déséquilibré.

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:
    """Entraîne un classifieur sur des embeddings."""
    # Générer les 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)])

    # Entraîner un classifieur
    clf = LogisticRegression(max_iter=1000)
    
    # Validation croisée
    scores = cross_val_score(clf, X, labels, cv=5)
    print(f"Accuracy (5-fold CV) : {scores.mean():.3f} ± {scores.std():.3f}")

    # Entraîner sur l'ensemble complet des données
    clf.fit(X, labels)
    return clf

def predire(clf, texte: str, model: str = "text-embedding-3-large") -> str:
    """Prédit la catégorie d'un texte."""
    emb = client.embeddings.create(
        input=texte, model=model
    ).data[0].embedding
    return clf.predict([emb])[0]

Comparaison des approches

ApprocheExemples requisPrécisionLatence
Zero-shot0~70-80 %1 appel API
Few-shot (3-5/classe)15-25~80-90 %1 appel API
Supervisé (50+/classe)250+~90-95 %1 appel API + inférence

Lues dans l’ordre, ces trois lignes décrivent une progression que vous pouvez suivre tout au long du cycle de vie du produit. Commencez par le zero-shot dès le premier jour, sans aucune donnée. Une fois que vous avez corrigé manuellement une vingtaine de prédictions, recyclez-les en exemples few-shot. Lorsque le volume d’annotation dépasse cinquante par classe, entraînez le classifieur supervisé. Gardez à l’esprit que la ligne « latence » vous rappelle que même le modèle supervisé reste rapide ; l’inférence locale ajoute une surcharge négligeable par rapport à l’appel API d’embedding.

Galvenās atziņas

  • La classification zero-shot compare le texte aux étiquettes via des embeddings
  • Le few-shot utilise des exemples pour définir chaque catégorie
  • Un classifieur supervisé (LogisticRegression) atteint les meilleures performances
  • Commencez par le zero-shot, puis ajoutez des exemples si la précision est insuffisante