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

Evalwazzjoni Awtomatizzata tal-Prompts

Lezzjoni 16 / 16 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Evalwazzjoni Awtomatizzata tal-Prompts
  2. Tipi ta’ evalwazzjoni
  3. Pipeline ta’ evalwazzjoni kompluta
  4. Suite ta’ testijiet: format
  5. Integrazzjoni CI/CD
  6. Dashboard tal-evalwazzjoni
  7. Issettja l-guardrails tiegħek
  8. Punti Ewlenin
  9. Ittestja l-Għarfien Tiegħek

Lezzjoni aġġornata fit-3 ta’ Novembru 2026 abbażi tad-dokumentazzjoni ta’ OpenAI: temperature u top_p huma aċċettati biss b’sforz ta’ raġunar ta’ none, filwaqt li l-mudelli GPT-5.6 jirraġunaw b’mod awtomatiku (medium). Għalhekk, is-sejħiet li jistabbilixxu dawn il-parametri jridu jispeċifikaw reasoning={"effort": "none"} (Responses API) jew reasoning_effort="none" (Chat Completions). Sorsi: L-użu ta’ GPT-6 · GPT-5.6 Terra.

Evalwazzjoni Awtomatizzata tal-Prompts

L-evalwazzjoni awtomatizzata hija l-pedament ta’ pipeline matura ta’ prompt engineering. Tħallik tiskopri r-reġressjonijiet, tqabbel il-mudelli, u tivvalida l-bidliet qabel id-depljament. Mingħajrha, kull bidla fil-prompt hija logħba bl-għama.

Tipi ta’ evalwazzjoni

Tliet familji ta’ evalwaturi jaqsmu x-xogħol skont in-natura tal-output mistenni, u kważi dejjem se tgħaqqad aktar minn waħda minnhom.

Evalwazzjoni ta’ qbil eżatt

Għal tasks b’tweġiba mistennija waħda, tqabbil dirett huwa biżżejjed. eval_exact_match tinnormalizza l-każ u l-ispazji qabel ma tqabbel: mingħajr din il-prekawzjoni, “Bug” u “bug” jiġu meqjusa żball, u tbagħtek tirranġa problema li ma teżistix.

eval_set_match jittratta każijiet fejn it-tweġiba hija set—entitajiet misjuba f’dokument, kategoriji assenjati lil artiklu. Dan joħroġ precision u recall, żewġ figuri li jgħidu storji differenti: precision għolja b’recall baxx tindika mudell eċċessivament kawt li jaqbad biss dak li hu ċert bih; bil-kontra, tradixxi mudell li joħloq halucinazzjonijiet biex jimla n-nuqqasijiet. L-F1 ġġisommarizzahom b’mod konvenjenti iżda ma tissostitwixxihomx għad-dijanjosi.

def eval_exact_match(prediction: str, reference: str) -> bool:
    """Exact match after normalization."""
    return prediction.strip().lower() == reference.strip().lower()

def eval_set_match(prediction: set, reference: set) -> dict:
    """Set match (entities, categories)."""
    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}

Evalwazzjoni semantika (Embedding)

Għal tweġibiet fit-test fejn il-kliem jista’ jvarja, il-qbil eżatt isir absurd: “L-ordni tiegħek tiġi kkonsenjata għada” u “Il-konsenja hija skedata għada” jgħidu l-istess ħaġa iżda jiksbu żero. Is-similarità cosbejn l-embeddings tkejjel il-qrib semantiku u mhux it-tqabbil tal-karattri, u tirritorna punteġġ kontinwu.

Inti tistabbilixxi s-sodla li ‘l fuq minnha tweġiba titqies aċċettabbli. Ikkalibrha fuq ftit għexieren ta’ pari kklassifikati minnek b’mod manwali bħala “ekwivalenti” jew “differenti”, imbagħad agħżel il-valur li jaqsam l-aħjar iż-żewġ gruppi: sodla magħżula bl-istintaċċġ tipproduċi riżultati arbitrarji daqs kull kejl, bl-illużjoni żejda ta’ rigur.

from openai import OpenAI
import numpy as np

client = OpenAI()

def eval_semantic_similarity(prediction: str,
                              reference: str) -> float:
    """Cosine similarity between embeddings."""
    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

Evalwazzjoni b’LLM (LLM-as-Judge)

Il-mudell jevalwa l-kwalità ta’ tweġiba. Dan huwa l-uniku approċċ vijabbli meta ma tkun teżisti l-ebda referenza: ħadd mhu se jikteb bl-idejn ir-risposta ta’ support “korretta” għal mitejn ticket.

Dak li jagħmel ġudikatur użabbli jinvol xi ftit affarijiet. L-ewwel, il-mudell użat: tagħżel mudell aktar kapaċi bħala ġudikatur, hawn gpt-5.6-sol, għax ġudikatur fl-istess livell bħall-evalwat għandu t-tendenza li jikkonferma l-difetti tiegħu stess. It-tieni, li titlob ġustifikazzjoni: li mmotivaw kull punteġġ jistabbilizza l-ġudizzju u jħallik tiskopri evalwatur li qed juża l-kriterju ħażin—ġustifikazzjoni li titkellem dwar it-tul meta l-kriterju kien iċ-ċarezza hija sinjal ta’ allarm. Fl-aħħarnett, temperature fuq 0.1 tiżgura l-istabbiltà tal-punteġġi bejn l-eżekuzzjonijiet.

def eval_llm_judge(question: str, prediction: str,
                    criteria: list[str]) -> dict:
    """Evaluation by a judge model."""
    criteria_text = "\n".join(
        f"- {c}: score from 1 to 5" for c in criteria
    )

    response = client.responses.create(
        model="gpt-5.6-sol",  # More capable model as judge
        reasoning={"effort": "none"},  # temperature requires effort none
        instructions="You are an expert, impartial evaluator.",
        input=f"""Evaluate this response according to the following criteria:

Question asked: {question}

Response to evaluate: {prediction}

Criteria:
{criteria_text}

For each criterion, give a score from 1 to 5 with justification.""",
        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)

Pipeline ta’ evalwazzjoni kompluta

EvalPipeline tgħaqqad dawn il-blokki: iġġib suite ta’ testijiet, eżegwixxi l-prompt fuq kull każ, tapplika l-evalwaturi kollha provduti, u taġġrega l-punteġġi. L-evalwaturi jingħataw bħala lista ta’ funzjonijiet, kollha msejħa bl-istess firma; għalhekk żieda ta’ metriċi ma teħtieġx bidla fil-pipeline, u tista’ ġġib qbil eżatt, similarità semantika u ġudikatur fl-istess eżekuzzjoni mingħajr ma tħallas għall-ġenerazzjoni tliet darbiet.

Il-metodu summary jakkumula wkoll it-tokens ikkunsmati. Din il-linja tidher sekondarja iżda tipproteġik minn trapp komuni: verżjoni ta’ prompt li tikseb żewġ punti iżda ttriplika l-kont mhijiex neċessarjament l-għażla t-tajba, u aħjar tkun taf dan fil-ħin tal-kompromess milli meta jaslu l-kontijiet tas-sura.

import json
from dataclasses import dataclass
from pathlib import Path

@dataclass
class TestCase:
    """A test case for evaluation."""
    input_text: str
    expected_output: str = None
    metadata: dict = None

class EvalPipeline:
    """Automated evaluation pipeline."""

    def __init__(self, test_suite_path: str):
        """Loads the test suite from a JSON file."""
        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:
        """Runs all tests and evaluates results."""
        self.results = []

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

            prediction = response.output_text

            # Evaluate with each 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:
        """Summarizes evaluation results."""
        if not self.results:
            return {"error": "No results"}

        # Aggregate scores by 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

Suite ta’ testijiet: format

Il-format tas-suite tal-testijiet jibqa’ intenzjonalament minimali: input, output mistenni, u metadata free-form. Din il-metadata hija aktar utli milli tidher—billi ttikkettja kull każ b’kategorija, taqsam il-punteġġi u tiskopri li l-klassifikatur tiegħek mhux qed ifalli b’mod każwali iżda fuq familja speċifika ta’ talbiet, ħaġa li medja globali ta’ 88% ma turix. It-tliet eżempji hawn taħt juru wkoll x’għandha jkollha suite tajba: każijiet ċari, bħal crash fit-tluq, iżda wkoll każijiet li jmissu ma’ kategorija oħra—mistoqsija dwar funzjonalità nieqsa tidher ħafna bħala rapport ta’ bug, u huwa fuq din il-fruntiera li tiġi ddeterminata l-kwalità ta’ klassifikatur.

[
    {
        "input_text": "My package hasn't arrived",
        "expected_output": "complaint",
        "metadata": {"category": "delivery"}
    },
    {
        "input_text": "How do I enable dark mode?",
        "expected_output": "question",
        "metadata": {"category": "feature"}
    },
    {
        "input_text": "The app crashes on startup on iOS 18",
        "expected_output": "bug",
        "metadata": {"category": "technical"}
    }
]

Integrazzjoni CI/CD

Eżegwixxi l-evalwazzjoni fuq kull bidla fil-prompt. Il-funzjoni ci_eval_check tbiddel il-kejl f’guardrail: ġġibb l-pipeline, tqabbel il-punteġġ medju mas-sodla, u tirritorna boolean li l-ktajjen tal-integrazzjoni tiegħek jinterpretaw bħala suċċess jew falliment tal-bini. Bidla li tħalli l-precision taħt 85% ma tasalx għall-produzzjoni, eżatt kif unit test imkisser jimblokka merge.

Issettja s-sodla bbażata fuq il-punteġġ diġà miksub mill-verżjoni kurrenti, mhux minn ideali. Poġġiha għolja wisq u tkun ikkundannat lit-tim jaqbeż il-verifika b’diżattivi temporanji li jsiru permanenti; imbaxxha wisq u jkollok verifika ta’ xejn filwaqt li turi badge aħdar. Fl-aħħar, żomm f’moħħok li s-suite trid tibqa’ rappreżentattiva tat-traffiku reali: sodla milħuqa fuq għexieren ta’ każijiet miktuba żewġ snin ilu ma tipprova xejn dwar it-talbiet ta’ llum.

def ci_eval_check(prompt_config: dict,
                   test_suite: str,
                   min_score: float = 0.85) -> bool:
    """CI/CD gate: checks that the prompt meets the minimum score."""
    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"Average score: {avg_score:.2%}")
    print(f"Minimum threshold: {min_score:.2%}")

    if avg_score < min_score:
        print("FAILURE: score below threshold")
        return False

    print("SUCCESS: prompt validated")
    return True

Dashboard tal-evalwazzjoni

Segwi l-evoluzzjoni tal-punteġġi matul iż-żmien. Punteġġ wieħed ma jgħid xejn; is-serje taħsel il-ħkaia tal-prompt tiegħek u twieġeb il-mistoqsija li dejjem titla’ fil-laqgħat: qed nagħmlu progress? Il-funzjoni hawn taħt tipproduċi tabella Markdown li tqiegħed ħdejn xulxin, għal kull verżjoni, il-punteġġ medju, it-tokens ikkunsmati, u l-ispiża stmata. Il-format mhuwiex każwali: waħħlu direttament f’pull request, u jagħmel it-tqabbil leġġibbli għal nies li qatt ma jinftegħu l-kodiċi tiegħek.

def comparison_report(results: dict[str, dict]) -> str:
    """Generates a comparative report between prompt versions."""
    report = "# Comparative Evaluation Report\n\n"
    report += "| Version | Average Score | Average Tokens | 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

Issettja l-guardrails tiegħek

Ibni suite ta’ għoxrin każ ta’ test għal prompt reali, u poġġi ftit edge cases minflok għexieren eżempji komdi: suite li tgħaddi 100% fl-ewwel tentattiv ma tgħallem xejn. Implimenta t-tliet tipi ta’ evalwatur u ġġibhom flimkien fuq żewġ verżjonijiet tal-prompt tiegħek. Il-qbil eżatt jagħti numru nadif, is-similarità semantika taqbad riformulazzjonijiet leġittimi, u l-ġudikatur jdawwal każijiet fejn l-ewwel tnejn ma jaqblux—dawn id-diskrepenzi huma l-aktar fqien ta’ lezzjonijiet dwar x’verament nistennew mill-mudell.

Qabbel, identifika l-verżjoni rebbieħa, imbagħad issettja l-iskript ta’ CI li jimblokka d-depljament jekk il-punteġġ jinżel. Se tkun taf li s-sistema taħdem kuljum li ċaħdet bidla li kont tqis ovvja.

Punti Ewlenin

  • L-evalwazzjoni awtomatizzata hija essenzjali biex titera b’kunfidenza
  • Għaqqad evalwazzjoni eżatta, semantika u LLM-as-Judge skont il-bżonn
  • Żomm suite ta’ testijiet li tevolvi mal-applikazzjoni tiegħek
  • Integra l-evalwazzjoni fil-CI/CD tiegħek b’sodla minima
  • Uża mudell aktar kapaċi bħala ġudikatur biex tevalwa mudell irħis
  • Iddokumenta l-punteġġi ta’ kull verżjoni biex issegwi l-evoluzzjoni

Ittestja l-Għarfien Tiegħek

Tekniki avvanzati u industrializzazzjoni: iċ-ċekk finali.

1. X'għandu jkun fih system prompt effettiv?

Tweġiba: Rolle, ambitu, regoli ta’ imġiba, format tal-output, u trattament tal-edge cases—miktub bħala speċifikazzjoni, ittestjat bħala kodiċi.

2. Meta għandek tuża s-self-consistency?

Tweġiba: Fuq problemi ta’ raġunar b’tweġibiet verifikabbli: ġġenera raġunamenti indipendenti multipli u żomm it-tweġiba tal-maġġoranza—il-varjanza ssir alleata.

3. X'jiggarantixxi l-modalità JSON bl-enforcement tal-schema?

Tweġiba: Output strettament konformi max-schema (tipi, kampijiet meħtieġa, enums)—ivverifikat fuq in-naħa tal-API u riverifikat fil-kodiċi (JSON Schema, Zod) għal katina mingħajr sorpriżi.

4. X'inhu l-grounding?

Tweġiba: Li twaħħax ir-risposti mal-fatti provduti (dokumenti, data mkixfa) u mhux mal-memorja tal-mudell—bl-obbligu li ċċita s-sors jew tirrifjuta barra minnu.

5. X'inhu l-iskop ta' katalogu verżjonat ta' prompts?

Tweġiba: Li tittratta l-prompts bħala artefatti: verżjonijiet, tests A/B, evalwazzjonijiet awtomatizzati fuq kull bidla—tkun taf x’qed jaħdem fil-produzzjoni, u għaliex.

L-aħħar ċiklu tal-kors—verżjona, ittestja, evalwa awtomatikament—ittrasforma prompt engineering artifiċjali f’prattika ta’ tim.