Evalwazzjoni Awtomatizzata tal-Prompts
F'din il-paġna
Lezzjoni aġġornata fit-3 ta’ Novembru 2026 abbażi tad-dokumentazzjoni ta’ OpenAI:
temperatureutop_phuma 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ċifikawreasoning={"effort": "none"}(Responses API) jewreasoning_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.