Metrici de evaluare în DSPy în DSPy & Programare Algoritmică LLM: explicație și exemple

Optimizatorii au nevoie să știe ce înseamnă „mai bine”. O metrică este orice funcție Python care primește exemplul etichetat (example sau gold) și predicția (pred) și întoarce un scor; nu există o clasă de bază sau un decorator. Prin convenție, scorul este între 0.0 și 1.0, iar valoarea mai mare e mai bună. Documentația observă că semnăturile tipizate verifică deja structura ieșirii, deci metrica se poate concentra pe scopul sarcinii: corectitudine, acoperire, stil.

Semnătura completă este metric(gold, pred, trace=None, pred_name=None, pred_trace=None). trace este lista (predictor, intrări, ieșiri) a tuturor pașilor programului și este completată de optimizatori, nu de Evaluate; un tipar din documentație folosește trace is None pentru a întoarce un scor continuu la evaluare și un verdict da/nu la optimizare. pred_name și pred_trace restrâng urma la un singur predictor; le folosește GEPA.

Valoarea întoarsă poate fi bool (Evaluate raportează procentul de True), float (media) sau dspy.Prediction(score=..., feedback="..."): score se tratează ca un float, iar feedback este citit doar de GEPA. DSPy include metrici gata făcute: answer_exact_match și answer_passage_match (pe text normalizat) și judecătorii LLM SemanticF1 și CompleteAndGrounded, care sunt module DSPy.

Concepte cheie și caracteristici

Concept / Parametru	Descriere practică
`example / gold`	Exemplul din set (`dspy.Example`), cu etichetele corecte.
`pred`	`dspy.Prediction` produsă de program.
`trace=None`	Urma pașilor (`predictor`, intrări, ieșiri), dată de optimizatori.
`pred_name / pred_trace`	Numele și urma unui singur predictor, la notarea pe pași (GEPA).
`dspy.Prediction(score, feedback)`	Scor plus explicație text; `Evaluate` folosește doar `score`.
`dspy.evaluate.answer_exact_match(example, pred, trace=None, frac=1.0)`	Compară `pred.answer` cu `example.answer` după normalizare; cu `frac` sub 1.0 folosește F1 pe tokeni.
`dspy.evaluate.SemanticF1(threshold=0.66, decompositional=False)`	Judecător LLM: precizie și recall între `pred.response` și `example.response`.
`metric_threshold`	La BootstrapFewShot și MIPROv2: pragul pentru o metrică numerică; fără el, BootstrapFewShot tratează rezultatul ca bool.

Exemple practice și scenarii reale

Exemplul 1: Metrică cu scor parțial și verdict la optimizare

def metrica(example, pred, trace=None):
    corect = float(example.categorie == pred.categorie)
    scurt = float(len(pred.rezumat.split()) <= 40)
    scor = 0.7 * corect + 0.3 * scurt
    if trace is not None:      # în timpul optimizării: da / nu
        return scor >= 0.9
    return scor

Exemplul 2: Metrică cu feedback pentru GEPA

import dspy

def metrica_gepa(gold, pred, trace=None, pred_name=None, pred_trace=None):
    if gold.categorie != pred.categorie:
        return dspy.Prediction(
            score=0.0,
            feedback=f"Categoria corectă era {gold.categorie}, nu {pred.categorie}.",
        )
    return dspy.Prediction(score=1.0, feedback="Categoria este corectă.")

Exemplul 3: Judecător LLM scris ca semnătură

class Judecator(dspy.Signature):
    """Verifică dacă răspunsul conține faptele din răspunsul de referință."""
    intrebare: str = dspy.InputField()
    referinta: str = dspy.InputField()
    raspuns: str = dspy.InputField()
    scor: float = dspy.OutputField(desc="între 0.0 și 1.0")

judecator = dspy.ChainOfThought(Judecator)

def metrica_judecator(example, pred, trace=None):
    with dspy.context(lm=dspy.LM("openai/gpt-6-astra")):
        verdict = judecator(intrebare=example.intrebare,
                            referinta=example.raspuns,
                            raspuns=pred.raspuns)
    return verdict.scor

Greșeli frecvente și capcane

Folosești nume de câmpuri diferite de cele din program. answer_exact_match citește answer, iar SemanticF1 citește response; pentru alte nume scrie metrica ta.
Faci metrica nedeterministă fără să știi. Un judecător LLM poate da scoruri diferite la rulări diferite, iar demonstrațiile alese de BootstrapFewShot depind atunci de zgomot.
Scrii o metrică care aruncă excepții. Evaluate pune failure_score (implicit 0.0) și continuă, deci eroarea arată ca un scor mic.
Folosești o metrică „totul sau nimic” la sarcini de generare. Optimizatorul nu vede progresul parțial; un scor gradat sau un feedback pentru GEPA dă mai multă informație.

`Metrici de evaluare în DSPy` în DSPy & Programare Algoritmică LLM