Salt la conținutul principal
Română— Alege o limbă
Meniu

Evaluarea automată a prompturilor

Lecția 16 din 16 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Evaluarea automată a prompturilor
  2. Tipuri de evaluare
  3. Flux complet de evaluare
  4. Suita de teste: Format
  5. Integrarea CI/CD
  6. Panoul de evaluare
  7. Configurați-vă barierele de siguranță
  8. Puncte cheie
  9. Testați-vă cunoștințele

Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii temperature și top_p sunt acceptați doar cu un efort de raționament de none, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specifice reasoning={"effort": "none"} (API-ul Responses) sau reasoning_effort="none" (Chat Completions). Surse: Utilizarea GPT-6 · GPT-5.6 Terra.

Evaluarea automată a prompturilor

Evaluarea automată reprezintă piatra de temelie a unui flux de lucru matur în ingineria prompturilor. Aceasta vă permite să detectați regresii, să comparați modele și să validați modificările înainte de implementare. Fără ea, fiecare schimbare de prompt este o loterie oarbă.

Tipuri de evaluare

Trei familii de evaluatori împart sarcina în funcție de natura rezultatului așteptat, iar dumneavoastră veți combina aproape întotdeauna mai mulți dintre ei.

Evaluarea prin potrivire exactă (Exact Match)

Pentru sarcinile cu un singur răspuns așteptat, comparația directă este suficientă. eval_exact_match normalizează majusculele și spațiile albe înainte de comparare: fără această precauție, „Bug“ și „bug“ ar fi contorizate ca erori, determinându-vă să remediați o problemă inexistentă.

eval_set_match gestionează cazurile în care răspunsul este o mulțime—entități găsite într-un document, categorii atribuite unui articol. Aceasta derivează precizia și recall-ul, două cifre care spun povești diferite: o precizie ridicată cu un recall scăzut semnalează un model excesiv de prudent, care extrage doar ceea ce este sigur; inversul trădează un model care halucinează pentru a umple golurile. F1 le rezumă convenabil, dar nu le înlocuiește pentru diagnostic.

def eval_exact_match(prediction: str, reference: str) -> bool:
    """Potrivire exactă după normalizare."""
    return prediction.strip().lower() == reference.strip().lower()

def eval_set_match(prediction: set, reference: set) -> dict:
    """Potrivire de mulțimi (entități, categorii)."""
    tp = len(prediction & reference)
    fp = len(prediction - reference)
    fn = len(reference - prediction)

    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
    f1 = (2 * precision * recall / (precision + recall)
          if (precision + recall) > 0 else 0)

    return {"precision": precision, "recall": recall, "f1": f1}

Evaluarea semantică (Embedding)

Pentru răspunsurile text unde formularea poate varia, potrivirea exactă devine absurdă: „Comanda dumneavoastră va fi livrată mâine“ și „Livrarea este programată pentru mâine“ spun același lucru, dar ar obține scor zero. Similaritatea cosinusică dintre embedding-uri măsoară proximitatea semantică, nu potrivirea caracter cu caracter, returnând un scor continuu.

Dumneavoastră stabiliți pragul peste care un răspuns este considerat acceptabil. Calibrați-l pe câteva zeci de perechi pe care le-ați clasificat manual ca „echivalente“ sau „diferite“, apoi alegeți valoarea care separă cel mai bine cele două grupuri: un prag ales după instinct produce rezultate la fel de arbitrare ca absența oricărei măsurători, cu iluzia suplimentară a rigoarei.

from openai import OpenAI
import numpy as np

client = OpenAI()

def eval_semantic_similarity(prediction: str,
                              reference: str) -> float:
    """Similaritate cosinusică între embedding-uri."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[prediction, reference]
    )
    emb_pred = np.array(response.data[0].embedding)
    emb_ref = np.array(response.data[1].embedding)

    similarity = float(
        np.dot(emb_pred, emb_ref) /
        (np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
    )
    return similarity

Evaluarea prin LLM (LLM-as-Judge)

Modelul evaluează calitatea unui răspuns. Aceasta este singura abordare viabilă atunci când nu există un răspuns de referință: nimeni nu va scrie de mână răspunsul „corect“ la suport pentru două sute de tichete.

Ceea ce face un judecător utilizabil se reduce la câteva aspecte. În primul rând, modelul utilizat: alegeți un model mai capabil ca judecător, aici gpt-5.6-sol, deoarece un judecător la același nivel cu cel evaluat tinde să își valideze propriile defecte. În al doilea rând, solicitarea justificării: motivarea fiecărui scor stabilizează judecata și vă permite să identificați un evaluator care folosește criteriul greșit—o justificare care discută despre lungime atunci când criteriul era claritatea este un semnal de alarmă. În final, temperature la 0.1 asigură stabilitatea scorurilor între execuții.

def eval_llm_judge(question: str, prediction: str,
                    criteria: list[str]) -> dict:
    """Evaluare de către un model judecător."""
    criteria_text = "\n".join(
        f"- {c}: scor de la 1 la 5" for c in criteria
    )

    response = client.responses.create(
        model="gpt-5.6-sol",  # Model mai capabil ca judecător
        reasoning={"effort": "none"},  # temperature necesită effort none
        instructions="Sunteți un evaluator expert și imparțial.",
        input=f"""Evaluați acest răspuns conform următoarelor criterii:

Întrebare pusă: {question}

Răspuns de evaluat: {prediction}

Criterii:
{criteria_text}

Pentru fiecare criteriu, acordați un scor de la 1 la 5 cu o justificare.""",
        text={
            "format": {
                "type": "json_schema",
                "name": "evaluation",
                "schema": {
                    "type": "object",
                    "properties": {
                        "scores": {
                            "type": "array",
                            "items": {
                                "type": "object",
                                "properties": {
                                    "criterion": {"type": "string"},
                                    "score": {"type": "integer"},
                                    "justification": {"type": "string"}
                                },
                                "required": ["criterion", "score",
                                              "justification"],
                                "additionalProperties": False
                            }
                        },
                        "overall_score": {"type": "number"},
                        "verdict": {"type": "string"}
                    },
                    "required": ["scores", "overall_score", "verdict"],
                    "additionalProperties": False
                },
                "strict": True
            }
        },
        temperature=0.1
    )
    return json.loads(response.output_text)

Flux complet de evaluare

EvalPipeline asamblează aceste blocuri de construcție: încarcă o suită de teste, rulează promptul pentru fiecare caz, aplică toți evaluatorii furnizați și agregă scorurile. Evaluatorii sunt transmiși ca o listă de funcții, toate apelate cu aceeași semnătură; adăugarea unei metrici nu necesită, prin urmare, nicio modificare a fluxului, iar dumneavoastră puteți rula potrivirea exactă, similaritatea semantică și un judecător asupra aceleiași execuții fără a plăti generarea de trei ori.

Metoda summary acumulează, de asemenea, token-ii consumați. Această linie, aparent secundară, vă protejează de o capcană comună: o versiune de prompt care câștigă două puncte de scor în timp ce triplează factura nu este neapărat alegerea corectă, iar este mai bine să aflați acest lucru la momentul compromisului decât când sosește factura lunară.

import json
from dataclasses import dataclass
from pathlib import Path

@dataclass
class TestCase:
    """Un caz de test pentru evaluare."""
    input_text: str
    expected_output: str = None
    metadata: dict = None

class EvalPipeline:
    """Flux automat de evaluare."""

    def __init__(self, test_suite_path: str):
        """Încarcă suita de teste dintr-un fișier JSON."""
        data = json.loads(Path(test_suite_path).read_text())
        self.test_cases = [TestCase(**tc) for tc in data]
        self.results = []

    def run(self, prompt_config: dict,
            evaluators: list[callable]) -> dict:
        """Rulează toate testele și evaluează rezultatele."""
        self.results = []

        for tc in self.test_cases:
            # Generează răspunsul
            response = client.responses.create(
                model=prompt_config["model"],
                reasoning={"effort": "none"},  # temperature necesită effort none
                instructions=prompt_config["system_prompt"],
                input=tc.input_text,
                temperature=prompt_config.get("temperature", 0.1)
            )

            prediction = response.output_text

            # Evaluează cu fiecare evaluator
            scores = {}
            for evaluator in evaluators:
                score = evaluator(
                    question=tc.input_text,
                    prediction=prediction,
                    reference=tc.expected_output
                )
                scores[evaluator.__name__] = score

            self.results.append({
                "input": tc.input_text,
                "expected": tc.expected_output,
                "prediction": prediction,
                "scores": scores,
                "tokens": {
                    "input": response.usage.input_tokens,
                    "output": response.usage.output_tokens
                }
            })

        return self.summary()

    def summary(self) -> dict:
        """Rezumă rezultatele evaluării."""
        if not self.results:
            return {"error": "Niciun rezultat"}

        # Agregare scoruri pe evaluator
        all_scores = {}
        for result in self.results:
            for eval_name, score in result["scores"].items():
                if eval_name not in all_scores:
                    all_scores[eval_name] = []
                if isinstance(score, (int, float)):
                    all_scores[eval_name].append(score)
                elif isinstance(score, dict) and "f1" in score:
                    all_scores[eval_name].append(score["f1"])

        summary = {
            "total_tests": len(self.results),
            "average_scores": {
                name: sum(scores) / len(scores)
                for name, scores in all_scores.items()
                if scores
            },
            "total_token_cost": sum(
                r["tokens"]["input"] + r["tokens"]["output"]
                for r in self.results
            )
        }
        return summary

Suita de teste: Format

Formatul suitei de teste rămâne intenționat minimal: un input, rezultatul așteptat și metadate libere. Aceste metadate sunt mai utile decât par—etichetând fiecare caz pe categorii, descompuneți scorurile și descoperiți că clasificatorul dumneavoastră nu eșuează aleatoriu, ci pe o familie specifică de cereri, lucru pe care o medie globală de 88% nu îl relevă. Cele trei exemple de mai jos arată, de asemenea, ce ar trebui să conțină o suită bună: cazuri clare, precum o eroare de pornire, dar și cazuri la granița cu o altă categorie—o întrebare despre o funcție lipsă seamănă mult cu un raport de bug, iar la această graniță se decide calitatea unui clasificator.

[
    {
        "input_text": "Pachetul meu nu a sosit",
        "expected_output": "plângere",
        "metadata": {"category": "livrare"}
    },
    {
        "input_text": "Cum activez modul întunecat?",
        "expected_output": "întrebare",
        "metadata": {"category": "funcționalitate"}
    },
    {
        "input_text": "Aplicația se blochează la pornire pe iOS 18",
        "expected_output": "bug",
        "metadata": {"category": "tehnic"}
    }
]

Integrarea CI/CD

Rulați evaluarea la fiecare modificare a promptului. Funcția ci_eval_check transformă măsurătoarea într-o barieră de siguranță: rulează fluxul, compară scorul mediu cu un prag și returnează un boolean pe care lanțul dumneavoastră de integrare îl interpretează ca succes sau eșec al build-ului. O modificare care scade precizia sub 85% nu mai ajunge în producție, la fel cum un test unitar defect blochează un merge.

Stabiliți pragul pe baza scorului deja obținut de versiunea curentă, nu dintr-un ideal. Dacă îl setați prea sus, condamnați echipa să ocolească verificarea prin dezactivări temporare care devin permanente; dacă îl setați prea jos, nu verificați nimic în timp ce afișați o insignă verde. În final, rețineți că suita trebuie să rămână reprezentativă pentru traficul real: un prag atins pe douăzeci de cazuri scrise acum doi ani nu dovedește nimic despre cererile de astăzi.

def ci_eval_check(prompt_config: dict,
                   test_suite: str,
                   min_score: float = 0.85) -> bool:
    """Barieră CI/CD: verifică dacă promptul atinge scorul minim."""
    pipeline = EvalPipeline(test_suite)

    def accuracy(question, prediction, reference):
        return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0

    results = pipeline.run(prompt_config, [accuracy])
    avg_score = results["average_scores"].get("accuracy", 0)

    print(f"Scor mediu: {avg_score:.2%}")
    print(f"Prag minim: {min_score:.2%}")

    if avg_score < min_score:
        print("EȘEC: scor sub prag")
        return False

    print("SUCCES: prompt validat")
    return True

Panoul de evaluare

Urmăriți evoluția scorurilor în timp. Un singur scor nu spune nimic; seria spune povestea promptului dumneavoastră și răspunde la întrebarea care apare mereu în ședințe: facem progrese? Funcția de mai jos produce un tabel Markdown care alătură, pentru fiecare versiune, scorul mediu, token-ii consumați și costul estimat. Formatul nu este accidental: se lipește direct într-un pull request, făcând comparația lizibilă pentru persoanele care nu vă vor deschide niciodată codul.

def comparison_report(results: dict[str, dict]) -> str:
    """Generează un raport comparativ între versiunile de prompt."""
    report = "# Raport de evaluare comparativă\n\n"
    report += "| Versiune | Scor Mediu | Tokeni Medii | Cost |\n"
    report += "|---------|---------------|----------------|------|\n"

    for version, data in results.items():
        score = data.get("average_scores", {})
        score_val = list(score.values())[0] if score else 0
        tokens = data.get("total_token_cost", 0)
        report += (f"| {version} | {score_val:.2%} | "
                   f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")

    return report

Configurați-vă barierele de siguranță

Construiți o suită de douăzeci de cazuri de test pentru un prompt real, plasând câteva cazuri limită în loc de douăzeci de exemple confortabile: o suită care trece 100% de la prima încercare nu vă învață nimic. Implementați cele trei tipuri de evaluatori și rulați-le împreună pe două versiuni ale promptului dumneavoastră. Potrivirea exactă oferă un număr clar, similaritatea semantică prinde reformulările legitime, iar judecătorul luminează cazurile în care primele două sunt în dezacord—aceste dezacorduri sunt cele mai bogate în lecții despre ceea ce așteptați cu adevărat de la model.

Comparați, identificați versiunea câștigătoare, apoi configurați scriptul CI care blochează implementarea dacă scorul scade. Veți ști că sistemul funcționează în ziua în care respinge o modificare pe care o credeați evidentă.

Puncte cheie

  • Evaluarea automată este esențială pentru a itera cu încredere
  • Combinați evaluarea exactă, semantică și LLM-as-judge după nevoie
  • Mențineți o suită de teste care evoluează odată cu aplicația dumneavoastră
  • Integrați evaluarea în CI/CD cu un prag minim
  • Utilizați un model mai capabil ca judecător pentru a evalua un model mai ieftin
  • Documentați scorurile fiecărei versiuni pentru a urmări evoluția

Testați-vă cunoștințele

Tehnici avansate și industrializare: verificarea finală.

1. Ce conține un prompt de sistem eficient?

Răspuns: Rol, domeniu de aplicare, reguli de comportament, format de ieșire și gestionarea cazurilor limită—scrise ca o specificație, testate ca un cod.

2. Când ar trebui să utilizați auto-coerența (self-consistency)?

Răspuns: La problemele de raționament cu răspunsuri verificabile: generați multiple raționamente independente și păstrați răspunsul majoritar—varianța devine un aliat.

3. Ce garantează modul JSON cu impunerea schemei?

Răspuns: O ieșire care respectă strict schema (tipuri, câmpuri obligatorii, enum-uri)—validată la nivelul API-ului și revalidată în cod (JSON Schema, Zod) pentru un lanț fără surprize.

4. Ce este ancorarea (grounding)?

Răspuns: Ancorarea răspunsurilor în fapte furnizate (documente, date recuperate) mai degrabă decât în memoria modelului—cu cerința de a cita sau de a se abține de la surse externe.

5. Care este scopul unui catalog de prompturi versionat?

Răspuns: Tratarea prompturilor ca artefacte: versiuni, teste A/B, evaluări automate la fiecare modificare—știți ce rulează în producție și de ce.

Bucla finală a cursului—versiune, test, evaluare automată—transformă ingineria prompturilor artizanală într-o practică de echipă.