Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Klassifikazzjoni tat-test bl-użu ta' embeddings

Lezzjoni 17 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Għanijiet
  2. Klassifikazzjoni Zero-shot
  3. Klassifikazzjoni Few-shot
  4. Klassifikatur superviżjonat ħafif
  5. Tqabbil tal-approċċi
  6. Punti Ewlenin

Għanijiet

  • Ikklassifika test mingħajr ma tħarreġ mudell
  • Implimenta klassifikazzjoni zero-shot u few-shot bl-użu ta’ embeddings
  • Qabbel il-prestazzjoni ma’ klassifikatur superviżjonat ħafif

Klassifikazzjoni Zero-shot

It-tfittxija semantika ssib dokumenti simili għal mistoqsija fost eluf ta’ kandidati. Il-klassifikazzjoni taqleb din il-konfigurazzjoni mingħajr ma tbiddel il-mekkaniżmi sottostanti: id-”dokumenti” tiegħek issa huma l-kategoriji tiegħek (ħamsa jew għaxra minnhom), u l-”mistoqsija” hija t-test li trid tikklassifika. It-tikketta li l-embedding tagħha huwa l-eqreb issir il-previżjoni. L-ebda taħriġ, l-ebda data annotata, biss sejħa waħda għall-API.

Żewġ dettalji ta’ implimentazzjoni fil-kodiċi hawn taħt jisħqu attenzjoni. L-ewwel, it-test u l-ismijiet tal-kategoriji jidħlu f’sejħa waħda embeddings.create, li tnaqqas il-latency bin-numru ta’ tikketta. It-tieni, l-applikazzjoni ta’ softmax fuq l-iskor tas-similarità tikkonverti valuri mhux maħduma (tipikament ivarjaw bejn 0.3 u 0.5) f’probabbiltajiet li jammontaw għal 1. Tista’ turi dawn il-probabbiltajiet lil utent jew tqabbilhom ma’ limitu ta’ kunfidenza.

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

F’dan l-eżempju, “il-prezz tal-ishma niżel bi 15% wara l-ħabbar” jinżel b’mod naturali fil-Finanzi. L-approċċ jilħaq limitu meta l-kategoriji huma tikketta interni li isimhom ma jiżvela xejn dwar il-kontenut tagħhom. Tikketta bħal “P1” jew “escalation ta’ livell 2” ma ġġorr l-ebda tifsira semantika sfruttabbli, u tagħmel il-klassifikazzjoni essenzjalment każwali.

Klassifikazzjoni Few-shot

Dan huwa eżattament dak li ssewwi l-klassifikazzjoni few-shot. Minflok ma tirrappreżenta kategorija bl-isem tagħha, tirrappreżentaha miċ-ċentrojde ta’ ftit eżempji reali. Il-kategorija “bug” m’għadhiex il-kelma “bug” iżda l-medja tal-embeddings għal “l-app jikkraċċja meta jiftaħ”, “żball 500 fuq il-paġna tal-login”, u “il-buttuna ma taħdimx fuq il-mowbajl”. Tlieta sa ħames eżempji għal kull klassi ġeneralment huma biżżejjed, u l-ispiża tibqa’ dik ta’ sejħa waħda għall-API peress li t-testijiet kollha jintbagħtu flimkien.

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

It-ticket tat-test—“l-esportazzjoni CSV fiha nuqqas ta’ kolonni”—ma fihiex il-kelma “bug” jew “żball”, iżda tixbah lit-tliet eżempji ta’ ħsara pprovduti, allura hemmhekk tinżel. Innota li l-medja tal-embeddings tassumi kategorija omoġenja. Jekk l-eżempji tal-”mistoqsija” tiegħek iħalltu mistoqsijiet dwar il-fatturazzjoni ma’ mistoqsijiet dwar l-API, iċ-ċentrojde tagħhom se jaqa’ f’art imwarrba semantikament. F’dak il-każ, huwa aħjar li taqsam il-kategorija.

Klassifikatur superviżjonat ħafif

Meta jkollok diversi għexieren ta’ eżempji għal kull klassi, il-medja ssir ħela ta’ informazzjoni: tiċċatta l-forma tas-sħaba ta’ punti. Klassifikatur lineari mħarreġ fuq l-istess embeddings jitgħallem fruntiera ta’ deċiżjoni minflok. L-embedding jittratta l-fehim tal-lingwa, filwaqt li LogisticRegression sempliċiment tiġbed linja ġeometrika f’dak l-ispazju. Dan jirriżulta f’ħinijiet ta’ taħriġ ta’ ftit sekondi fuq CPU standard, filwaqt li t-titjib (fine-tuning) ta’ mudell tal-lingwa jkun jeħtieġ GPU.

Il-validazzjoni incroċjata b’ħames piegi (five-fold cross-validation) mhix biss għall-wiri. Tagħtik id-devjazzjoni standard tal-preċiżjoni, u tipprovdi sens ta’ kemm hija affidabbli l-istima tiegħek. Punteġġ ta’ 0.91 ± 0.02 huwa użabbli; 0.91 ± 0.15 jindika dataset li huwa żgħir wisq jew mhux ibbilanċjat.

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]

Tqabbil tal-approċċi

ApproċċEżempji meħtieġaPreċiżjoniLatency
Zero-shot0~70-80%Sejħa waħda għall-API
Few-shot (3-5/klassi)15-25~80-90%Sejħa waħda għall-API
Superviżjonat (50+/klassi)250+~90-95%Sejħa waħda għall-API + inferenza

Meta taqra dawn it-tliet linji f’ordni, jiddeskrivu progressjoni li tista’ ssegwi matul iċ-ċiklu tal-ħajja tal-prodott. Ibda b’zero-shot l-ewwel jum, mingħajr l-ebda data. Ladarba tkun ikkoreġejt manwalment għoxrin previżjoni jew hekk, erġa’ uża bħala eżempji few-shot. Meta l-volum tal-annotazzjoni jaqbeż il-ħamsin għal kull klassi, ħarreġ il-klassifikatur superviżjonat. Żomm f’moħħok li r-ringiela tal-”latency” tfakkrek li anke l-mudell superviżjonat jibqa’ mgħaġġel; l-inferenza lokali żżid overhead negliġibbli meta mqabbla mas-sejħa għall-API tal-embedding.

Punti Ewlenin

  • Il-klassifikazzjoni Zero-shot tqabbel it-test mat-tikketti permezz ta’ embeddings
  • Few-shot tuża eżempji biex tiddefinixxi kull kategorija
  • Klassifikatur superviżjonat (LogisticRegression) jikseb l-aħjar prestazzjoni
  • Ibda b’zero-shot, imbagħad żid eżempji jekk il-preċiżjoni ma tkunx biżżejjed