Przejdź do głównej treści
Polski— Wybierz język
Menu

Klasyfikacja tekstu przy użyciu embeddingów

Lekcja 17 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Klasyfikacja zero-shot
  3. Klasyfikacja few-shot
  4. Lekki klasyfikator nadzorowany
  5. Porównanie podejść
  6. Kluczowe wnioski

Cele

  • Klasyfikuj tekst bez trenowania modelu
  • Wdróż klasyfikację zero-shot i few-shot przy użyciu embeddingów
  • Porównaj wydajność z lekkim klasyfikatorem nadzorowanym

Klasyfikacja zero-shot

Wyszukiwanie semantyczne znajduje dokumenty podobne do zapytania spośród tysięcy kandydatów. Klasyfikacja odwraca ten układ, nie zmieniając mechaniki działania: twoimi „dokumentami“ są teraz kategorie (pięć lub dziesięć), a „zapytaniem“ jest tekst, który chcesz sklasyfikować. Etykieta, której embedding jest najbliższy, staje się predykcją. Żadnego trenowania, żadnych danych z adnotacjami, tylko jedno wywołanie API.

Dwa szczegóły implementacyjne w poniższym kodzie zasługują na uwagę. Po pierwsze, tekst i nazwy kategorii trafiają do jednego wywołania embeddings.create, co skraca czas oczekiwania proporcjonalnie do liczby etykiet. Po drugie, zastosowanie funkcji softmax do wyników podobieństwa przekształca surowe wartości (zazwyczaj od 0,3 do 0,5) w prawdopodobieństwa sumujące się do 1. Możesz wyświetlić te prawdopodobieństwa użytkownikowi lub porównać je z progiem pewności.

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

W tym przykładzie zdanie „cena akcji spadła o 15% po ogłoszeniu“ niespodziankowo trafia do kategorii Finanse. Podejście to napotyka ograniczenie, gdy kategorie są wewnętrznymi etykietami, których nazwy nic nie mówią o ich zawartości. Etykieta taka jak „P1“ lub „escalacja poziomu 2“ nie niesie żadnego użytecznego znaczenia semantycznego, co sprawia, że klasyfikacja jest w istocie losowa.

Klasyfikacja few-shot

Właśnie to naprawia klasyfikacja few-shot. Zamiast reprezentować kategorię przez jej nazwę, reprezentujesz ją przez centroid kilku rzeczywistych przykładów. Kategoria „błąd“ to nie już słowo „błąd“, lecz średnia embeddingów dla fraz: „aplikacja crashuje przy starcie“, „błąd 500 na stronie logowania“ i „przycisk nie działa na mobile“. Zazwyczaj wystarczy od trzech do pięciu przykładów na klasę, a koszt pozostaje taki jak przy jednym wywołaniu API, ponieważ wszystkie teksty są wysyłane razem.

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

Testowe zgłoszenie – „eksport CSV nie zawiera wszystkich kolumn“ – nie zawiera ani słowa „błąd“, ani „error“, ale przypomina trzy podane przykłady awarii, więc tam właśnie trafia. Pamiętaj, że uśrednianie embeddingów zakłada jednorodność kategorii. Jeśli twoje przykłady dla kategorii „pytanie“ mieszają zapytania o rozliczenia z pytaniami o API, ich centroid wpadnie w semantyczną ziemię niczyją. W takim przypadku lepiej podzielić tę kategorię.

Lekki klasyfikator nadzorowany

Gdy masz kilkadziesiąt przykładów na klasę, uśrednianie staje się marnowaniem informacji: spłaszcza kształt chmury punktów. Liniowy klasyfikator wytrenowany na tych samych embeddingach uczy się zamiast tego granicy decyzyjnej. Embedding zajmuje się rozumieniem języka, podczas gdy LogisticRegression po prostu rysuje geometryczną linię w tej przestrzeni. Skutkuje to czasem trenowania rzędu kilku sekund na standardowym procesorze, podczas gdy fine-tuning modelu językowego wymagałby GPU.

Walidacja krzyżowa pięciokrotna (five-fold cross-validation) nie jest tylko dla pokazania. Daje ci odchylenie standardowe dokładności, co pozwala ocenić wiarygodność oszacowania. Wynik 0,91 ± 0,02 jest użyteczny; 0,91 ± 0,15 sygnalizuje zbiór danych, który jest zbyt mały lub niezbalansowany.

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]

Porównanie podejść

PodejścieWymagane przykładyDokładnośćOpóźnienie
Zero-shot0~70–80%1 wywołanie API
Few-shot (3–5/klasę)15–25~80–90%1 wywołanie API
Nadzorowany (50+/klasę)250+~90–95%1 wywołanie API + inferencja

Czytane po kolei, te trzy wiersze opisują progresję, którą możesz podążać przez cały cykl życia produktu. Zacznij od zero-shot pierwszego dnia, bez żadnych danych. Gdy ręcznie poprawisz około dwudziestu predykcji, wykorzystaj je jako przykłady few-shot. Gdy liczba adnotacji przekroczy pięćdziesiąt na klasę, wytrenuj klasyfikator nadzorowany. Miej na uwadze, że wiersz „opóźnienie“ przypomina, iż nawet model nadzorowany pozostaje szybki; lokalna inferencja dodaje pomijalny narzut w porównaniu z wywołaniem API embeddingów.

Kluczowe wnioski

  • Klasyfikacja zero-shot porównuje tekst z etykietami za pomocą embeddingów
  • Few-shot wykorzystuje przykłady do zdefiniowania każdej kategorii
  • Klasyfikator nadzorowany (LogisticRegression) osiąga najlepszą wydajność
  • Zacznij od zero-shot, a następnie dodaj przykłady, jeśli dokładność jest niewystarczająca