Премини към основното съдържание
Български— Изберете език
Меню

Класификация на текст с вграждания

Урок 17 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Цели
  2. Класификация тип „нулев изстрел“ (Zero-shot)
  3. Класификация тип „няколко изстрела“ (Few-shot)
  4. Лек контролиран класификатор
  5. Сравняване на подходите
  6. Ключови изводи

Цели

  • Класифициране на текст без обучение на модел
  • Внедряване на класификация тип „нулев изстрел“ (zero-shot) и „няколко изстрела“ (few-shot) чрез вграждания
  • Сравняване на производителността с лек контролиран класификатор

Класификация тип „нулев изстрел“ (Zero-shot)

Семантичното търсене открива документи, подобни на заявка сред хиляди кандидати. Класификацията обръща тази настройка, без да променя основния механизъм: вашите „документи“ сега са вашите категории (пет или десет на брой), а „заявката“ е текстът, който искате да класифицирате. Етикетът, чието вграждане е най-близко, става прогнозата. Никакво обучение, никакви анотирани данни, само едно API обаждане.

Два детайла от изпълнението в кода по-долу заслужават внимание. Първо, текстът и имената на категориите се подават в едно единствено обаждане на embeddings.create, което намалява латентността с броя на етикетите. Второ, прилагането на софтбокс (softmax) към оценките за сходство преобразува суровите стойности (обикновено вариращи между 0.3 и 0.5) във вероятности, чийто сбор е 1. Можете да покажете тези вероятности на потребителя или да ги сравните с праг на доверие.

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

В този пример „цената на акцията спадна с 15% след обявлението“ очаквано попада в категория „Финанси“. Подходът достига границата си, когато категориите са вътрешни етикети, чиито имена не разкриват нищо за съдържанието им. Етикет като „P1“ или „ескалация от ниво 2“ не носи никакво използваемо семантично значение, което прави класификацията по същество случайна.

Класификация тип „няколко изстрела“ (Few-shot)

Точно това решава класификацията тип „няколко изстрела“. Вместо да представяте категорията чрез името ѝ, я представяте чрез центроида на няколко реални примера. Категорията „бъг“ вече не е думата „бъг“, а средното стойностно вграждане на „приложението се срива при стартиране“, „грешка 500 на страницата за вход“ и „бутонът не работи на мобилно устройство“. Обикновено са достатъчни три до пет примера на клас, а разходите остават тези на едно единствено API обаждане, тъй като всички текстове се изпращат заедно.

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

Тестовият билет – „CSV експортът липсващи колони“ – не съдържа нито думата „бъг“, нито „грешка“, но прилича на трите предоставени примера за неизправност, затова там попада. Имайте предвид, че осредняването на вгражданията предполага хомогенна категория. Ако вашите примери за „въпрос“ смесват запитвания относно фактуриране с въпроси за API, техният центроид ще попадне в семантична ничия земя. В такъв случай е по-добре да разделите категорията.

Лек контролиран класификатор

Когато разполагате с няколко десетки примера на клас, осредняването става загуба на информация: то изравнява формата на облака от точки. Линеен класификатор, обучен върху същите вграждания, вместо това научава граница на решение. Вграждането се справя с разбирането на езика, докато LogisticRegression просто чертае геометрична линия в това пространство. Това води до време за обучение от няколко секунди на стандартен процесор, докато фина настройка на езиков модел би изисквала GPU.

Кръстосаната валидация с пет сгъвания (five-fold cross-validation) не е просто за показ. Тя ви дава стандартното отклонение на точността, предоставяйки усещане за надеждността на вашата оценка. Резултат от 0.91 ± 0.02 е използваем; 0.91 ± 0.15 сигнализира за набор от данни, който е твърде малък или небалансиран.

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]

Сравняване на подходите

ПодходНеобходими примериТочностЛатентност
Нулев изстрел (Zero-shot)0~70-80%1 API обаждане
Няколко изстрела (3-5/клас)15-25~80-90%1 API обаждане
Контролиран (50+/клас)250+~90-95%1 API обаждане + извод

Прочетени последователно, тези три реда описват прогресия, която можете да следвате през целия жизнен цикъл на продукта. Започнете с нулев изстрел в първия ден, без никакви данни. След като ръчно коригирате около двадесет прогнози, рециклирайте ги като примери за „няколко изстрела“. Когато обемът на анотациите надхвърли петдесет на клас, обучете контролирания класификатор. Имайте предвид, че редът „латентност“ ви напомня, че дори контролираният модел остава бърз; локалният извод добавя пренебрежимо малко натоварване в сравнение с API обаждането за вграждане.

Ключови изводи

  • Класификацията тип „нулев изстрел“ сравнява текста с етикети чрез вграждания
  • „Няколко изстрела“ използва примери за дефиниране на всяка категория
  • Контролиран класификатор (LogisticRegression) постига най-добра производителност
  • Започнете с „нулев изстрел“, след това добавете примери, ако точността е недостатъчна