Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Klasifikácia textu pomocou vektorových reprezentácií

Lekcia 17 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Ciele
  2. Klasifikácia Zero-shot
  3. Klasifikácia Few-shot
  4. Ľahký supervízovaný klasifikátor
  5. Porovnanie prístupov
  6. Kľúčové poznatky

Ciele

  • Klasifikovať text bez tréningu modelu
  • Implementovať klasifikáciu typu zero-shot a few-shot pomocou vektorových reprezentácií
  • Porovnať výkon s ľahkým supervízovaným klasifikátorom

Klasifikácia Zero-shot

Sémantické vyhľadávanie nájde medzi tisícami kandidátov dokumenty podobné dopytu. Klasifikácia tento postup obráti, pričom základná mechanika zostane nezmenená: tvojimi „dokumentmi“ sú teraz kategórie (päť alebo desať) a „dopytom“ je text, ktorý chceš klasifikovať. Štítok, ktorého vektorová reprezentácia je najbližšie, sa stane predpoveďou. Žiadny tréning, žiadne anotované dáta, len jedno volanie API.

Dva implementačné detaily v kóde nižšie si zaslúžia pozornosť. Po prvé, text a názvy kategórií idú do jedného volania embeddings.create, čo znižuje latenciu úmerne počtu štítkov. Po druhé, aplikácia softmaxu na skóre podobnosti prevedie surové hodnoty (zvyčajne v rozsahu 0,3 až 0,5) na pravdepodobnosti, ktorých súčet je 1. Tieto pravdepodobnosti môžeš zobraziť používateľovi alebo ich porovnať s prahovou hodnotou spoľahlivosti.

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 príklade sa veta „cena akcie klesla o 15 % po oznámení“ očakávane zaradí do kategórie Finance. Tento prístup naráža na limit, keď sú kategórie interné štítky, ktorých názvy nič neprezrádzajú o ich obsahu. Štítok ako „P1“ alebo „escalácia úrovne 2“ nemá žiadny využiteľný sémantický význam, čo robí klasifikáciu v podstate náhodnou.

Klasifikácia Few-shot

Presne toto rieši klasifikácia few-shot. Namiesto reprezentácie kategórie jej názvom ju reprezentuješ centroidom niekoľkých reálnych príkladov. Kategória „bug“ už nie je slovo „bug“, ale priemer vektorových reprezentácií pre „aplikácia padá pri štarte“, „chyba 500 na prihlasovacej stránke“ a „tlačidlo nefunguje na mobile“. Zvyčajne stačia tri až päť príkladov na triedu a náklady zostávajú rovnaké ako pri jednom volaní API, keďže všetky texty sa odosielajú naraz.

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í ticket – „export CSV neobsahuje všetky stĺpce“ – neobsahuje ani slovo „bug“, ani „chyba“, ale podobá sa trom poskytnutým príkladom poruchy, takže tam skončí. Všimni si, že spriemerovanie vektorových reprezentácií predpokladá homogénnu kategóriu. Ak tvoje príklady pre kategóriu „otázka“ miešajú dopyty týkajúce sa fakturácie s otázkami o API, ich centroid spadne do sémantickej nikoho země. V takom prípade je lepšie kategóriu rozdeliť.

Ľahký supervízovaný klasifikátor

Keď máš k dispozícii niekoľko desiatok príkladov na triedu, spriemerovanie sa stáva plytvaním informáciami: splošťuje tvar mračna bodov. Lineárny klasifikátor natrénovaný na rovnakých vektorových reprezentáciách sa namiesto toho naučí rozhodovaciu hranicu. Vektorová reprezentácia sa postará o pochopenie jazyka a LogisticRegression jednoducho nakreslí geometrickú čiaru v tomto priestore. To vedie k časom tréningu v ráde niekoľkých sekúnd na bežnom CPU, zatiaľ čo jemné doladenie jazykového modelu by si vyžadovalo GPU.

Päťnásobná krížová validácia nie je len na okrasu. Poskytuje ti smerodajnú odchýlku presnosti, čo ti dáva predstavu o spoľahlivosti tvojho odhadu. Skóre 0,91 ± 0,02 je použiteľné; 0,91 ± 0,15 signalizuje dataset, ktorý je príliš malý alebo 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]

Porovnanie prístupov

PrístupPotrebné príkladyPresnosťLatencia
Zero-shot0~70 – 80 %1 volanie API
Few-shot (3 – 5/trieda)15 – 25~80 – 90 %1 volanie API
Supervízovaný (50+/trieda)250+~90 – 95 %1 volanie API + inferencia

Ak si tieto tri riadky prečítaš v poradí, opisujú progresiu, ktorú môžeš nasledovať počas životného cyklu produktu. Začni s zero-shot hneď v prvý deň, úplne bez dát. Akonáhle manuálne opravíš asi dvadsať predpovedí, recykluj ich ako príklady pre few-shot. Keď objem anotácií presiahne päťdesiat na triedu, natrénuj supervízovaný klasifikátor. Maj na pamäti, že riadok „latencia“ ti pripomína, že aj supervízovaný model zostáva rýchly; lokálna inferencia pridáva zanedbateľnú réžiu v porovnaní s volaním API pre vektorové reprezentácie.

Kľúčové poznatky

  • Klasifikácia zero-shot porovnáva text so štítkami pomocou vektorových reprezentácií
  • Few-shot využíva príklady na definovanie každej kategórie
  • Supervízovaný klasifikátor (LogisticRegression) dosahuje najlepší výkon
  • Začni s zero-shot a následne pridaj príklady, ak je presnosť nedostatočná