Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Klassificering av text med inbäddningar

Lektion 17 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. Nollskottsklassificering (Zero-shot)
  3. Fåskottsklassificering (Few-shot)
  4. Lättviktig övervakad klassificerare
  5. Jämförelse av metoder
  6. Viktiga punkter

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

MetodExempel som krävsNoggrannhetLatens
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