Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Klasifikace textu pomocí vnoření

Lekce 17 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Klasifikace Zero-shot
  3. Klasifikace Few-shot
  4. Lehký supervizovaný klasifikátor
  5. Porovnání přístupů
  6. Klíčové poznatky

Cíle

  • Klasifikovat text bez trénování modelu
  • Implementovat klasifikaci zero-shot a few-shot pomocí vnoření
  • Porovnat výkonnost s lehkým supervizovaným klasifikátorem

Klasifikace Zero-shot

Sémantické vyhledávání nachází dokumenty podobné dotazu mezi tisíci kandidáty. Klasifikace tento postup obrací, aniž by změnila základní mechaniku: tvými „dokumenty“ jsou nyní kategorie (pět nebo deset z nich) a „dotazem“ je text, který chceš klasifikovat. Štítek, jehož vnoření je nejblíže, se stane predikcí. Žádný trénink, žádná anotovaná data, jen jedno volání API.

Dva implementační detaily v níže uvedeném kódu si zaslouží pozornost. Zaprvé, text a názvy kategorií jdou do jediného volání embeddings.create, což snižuje latenci o počet štítků. Zadruhé, aplikace softmaxu na skóre podobnosti převádí surové hodnoty (obvykle v rozmezí 0,3 až 0,5) na pravděpodobnosti, jejichž součet je 1. Tyto pravděpodobnosti můžeš zobrazit uživateli nebo je porovnat s prahem spolehlivosti.

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"])

V tomto příkladu se věta „cena akcie klesla o 15 % po oznámení“ nepřekvapivě zařadí do kategorie Finance. Tento přístup naráží na limit, když jsou kategorie interními štítky, jejichž názvy nic neprozrazují o jejich obsahu. Štítek jako „P1“ nebo „eskalace úrovně 2“ nese žádný využitelný sémantický význam, což činí klasifikaci v podstatě náhodnou.

Klasifikace Few-shot

Přesně to řeší klasifikace few-shot. Místo reprezentace kategorie jejím názvem ji reprezentuješ těžištěm několika reálných příkladů. Kategorie „bug“ již není slovo „bug“, ale průměr vnoření pro „aplikace padá při spuštění“, „chyba 500 na přihlašovací stránce“ a „tlačítko nefunguje na mobilu“. Obvykle stačí tři až pět příkladů na třídu a náklady zůstávají stejné jako u jednoho volání API, protože všechny texty jsou odeslány najednou.

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

Testovací tiket – „export CSV postrádá sloupce“ – neobsahuje ani slovo „bug“, ani „chyba“, ale podobá se třem poskytnutým příkladům poruchy, takže tam skončí. Všimni si, že průměrování vnoření předpokládá homogenní kategorii. Pokud tvoje příklady pro kategorii „otázka“ mísí dotazy týkající se fakturace s dotazy na API, jejich těžiště spadne do sémantické nikoho země. V takovém případě je lepší kategorii rozdělit.

Lehký supervizovaný klasifikátor

Když máš několik desítek příkladů na třídu, průměrování se stává plýtváním informacemi: zplošťuje tvar mraku bodů. Lineární klasifikátor natrénovaný na stejných vnořeních se místo toho naučí rozhodovací hranici. Vnoření se stará o pochopení jazyka, zatímco LogisticRegression pouze vykreslí geometrickou čáru v tomto prostoru. To vede k časům tréninku řádově v sekundách na běžném CPU, zatímco jemné ladění jazykového modelu by vyžadovalo GPU.

Pětinásobná křížová validace není jen pro show. Poskytuje ti směrodatnou odchylku přesnosti, což dává představu o tom, jak spolehlivý tvůj odhad je. Skóre 0,91 ± 0,02 je použitelné; 0,91 ± 0,15 signalizuje datovou sadu, která je příliš malá nebo nevyvážená.

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]

Porovnání přístupů

PřístupPožadované příkladyPřesnostLatence
Zero-shot0~70–80 %1 volání API
Few-shot (3–5/třída)15–25~80–90 %1 volání API
Supervizovaný (50+/třída)250+~90–95 %1 volání API + inference

Čteno v pořadí tyto tři řádky popisují progresi, kterou můžeš následovat během životního cyklu produktu. Začni s zero-shot první den, zcela bez dat. Jakmile ručně opravíš zhruba dvacet predikcí, recykluj je jako příklady pro few-shot. Když objem anotací překročí padesát na třídu, natrénuj supervizovaný klasifikátor. Měj na paměti, že řádek „latence“ ti připomíná, že i supervizovaný model zůstává rychlý; lokální inference přidává zanedbatelnou režii ve srovnání s voláním API pro vnoření.

Klíčové poznatky

  • Klasifikace zero-shot porovnává text se štítky pomocí vnoření
  • Few-shot využívá příklady k definici každé kategorie
  • Supervizovaný klasifikátor (LogisticRegression) dosahuje nejlepšího výkonu
  • Začni s zero-shot, poté přidej příklady, pokud je přesnost nedostatečná