Metriċi u Punti ta' Referenza
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 għandhom jispeċifikawreasoning={"effort": "none"}(API Responses) jewreasoning_effort="none"(Chat Completions). Sorsi: Użu ta’ GPT-6 · GPT-5.6 Terra.
Kejl tal-Kwalità bil-Metriċi
Barra mill-punteġġi LLM-as-Judge, jeżistu metriċi kwantitattivi biex jiġu evalwati aspetti differenti tal-output tal-LLM. Il-valur tagħhom mhuwiex li huma aktar preċiżi—imħallef LLM mibni sew jara affarijiet li ebda formula qatt ma tara—imma li huma stabbli u rħas. Is-similarità tal-kożinu tirritorna l-istess numru eżatt f’kull ġirja, tispiċċa kważi xejn, u għalhekk tista’ tiġi eżegwita fuq eluf ta’ każijiet ma’ kull commit. Imbagħad, tirriżerva l-imħallef LLM għad-dimensjonijiet li verament jeħtieġuh.
Se nirrevedu l-metriċi essenzjali qabel ma ngħaqqduhom f’punti ta’ referenza riproduċibbli.
Tqabbil tas-Sinifikat Minflok il-Kliem
It-tqabbil ta’ żewġ testi karattru b’karattru jsir inutili malli l-frażar ikun liberu. Is-similarità semantika tevaża din il-problema: kull test jiġi kkonvertit f’vettur minn mudell ta’ embedding, u nkejlu l-angolu bejn iż-żewġ vetturi. Żewġ sentenzi li jgħidu l-istess ħaġa b’kliem differenti jippuntaw fl-istess direzzjoni.
import openai
import numpy as np
client = openai.OpenAI()
def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
"""Tikkalkula s-similarità tal-kożinu bejn żewġ vetturi."""
a = np.array(vec_a)
b = np.array(vec_b)
return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
def semantic_similarity(text_a: str, text_b: str) -> float:
"""Tkejjel is-similarità semantika bejn żewġ testi."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=[text_a, text_b],
)
vec_a = response.data[0].embedding
vec_b = response.data[1].embedding
return cosine_similarity(vec_a, vec_b)
# Eżempju
score = semantic_similarity(
"The cat is on the rug.",
"A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}") # ~0.85+
L-eżempju huwa instruttiv: żewġ sentenzi mingħajr ebda kelma komuni jiksbu punteġġ ogħla minn 0.85. Din hija s-saħħa tal-metodu, iżda wkoll in-nassa tiegħu. Is-similarità semantika tinjora n-negazzjoni u n-nuwansji tal-grad—“il-ħlas ġie aċċettat” u “il-ħlas ġie miċħud” jidhru simili ħafna fil-livell tal-vettur. Għalhekk, qatt tużaha waħedha biex tivvalida tweġiba fejn il-preċiżjoni fattwali hija importanti.
Meta l-mistoqsija tkun “it-tweġiba verament tindirizza l-mistoqsija magħmula?”, l-ebda formula ma tissostitwixxi l-ġudizzju. Il-punteġġ tar-rilevanza hawn taħt jifred dan il-ġudizzju f’tliet mistoqsijiet distinti: It-tweġiba hija diretta? Tibqa’ ffukata? Hija sħiħa? Din il-qsim huwa aħjar minn punteġġ globali għax jgħidlek f’liema direzzjoni għandek tikkoreġi l-prompt—mudell verbosu u mudell mhux sħiħ jeħtieġu korrezzjonijiet opposti.
def relevance_score(
question: str,
answer: str,
context: str | None = None,
) -> dict:
"""Tivvaluta jekk it-tweġiba hijiex rilevanti għall-mistoqsija."""
prompt = (
"Evalwa r-rilevanza ta' din it-tweġiba.\n\n"
f"Mistoqsija: {question}\n"
)
if context:
prompt += f"Kuntest ipprovdut: {context[:1000]}\n"
prompt += (
f"Tweġiba: {answer}\n\n"
"Kriterji:\n"
"1. It-tweġiba tindirizza direttament il-mistoqsija? (0-5)\n"
"2. It-tweġiba fiha informazzjoni mhux mitluba? (0-5, 5=ebda waħda)\n"
"3. It-tweġiba hija sħiħa? (0-5)\n\n"
"Irrispondi f'JSON bil-klijiet: direct, focus, completeness."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature teħtieġ effort none
input=prompt,
temperature=0.0,
)
import json
try:
scores = json.loads(response.output_text)
average = sum(scores.values()) / (len(scores) * 5)
return {"score": average, "details": scores}
except (json.JSONDecodeError, TypeError):
return {"score": 0, "error": "Parsing falliet"}
Innota l-frażar invertut tat-tieni kriterju, fejn 5 tfisser “l-ebda informazzjoni mhux mitluba”. Dan jippermetti li ż-żewġ punteġġi jiġu miżjuda fl-istess direzzjoni, iżda huwa kontra l-intuwizzjoni biex taqrah: meta żżid il-kriterji tiegħek stess, żomm din il-konvenzjoni inkella se tikseb medji li jippremjaw id-difett li inti kellek l-intenzjoni li tikkastiga.
Verifika li l-Mudell Mhuwiex Joħloq Informazzjoni Falza (Hallucinating)
F’applikazzjoni ta’ Mistoqsija u Tweġiba bbażata fuq dokumenti, il-metrika deċiżiva mhix il-kwalità tal-kitba iżda l-fidelità għas-sors. Il-prinċipju ta’ kontroll huwa sempliċi: ippreżenta lill-imħallef bil-kuntest oriġinali u t-tweġiba ġġenerata, u talbu jikklassifika kull dikjarazzjoni bħala appoġġjata mill-kuntest, nieqsa mill-kuntest, jew kontradittorja għalih. Id-distinzjoni bejn dawn l-aħħar żewġ kategoriji hija importanti, għax dikjarazzjoni sempliċiment nieqsa tista’ tkun għarfien ġenerali preċiż, filwaqt li dikjarazzjoni li tikkontradixxi s-sors hija dejjem żball.
def detect_hallucinations(
context: str,
answer: str,
) -> dict:
"""Tiskopri dikjarazzjonijiet mhux appoġġjati mill-kuntest."""
prompt = (
"Analiża din it-tweġiba u identifika kwalunkwe dikjarazzjoni "
"li MHIX appoġġjata mill-kuntest ipprovdut.\n\n"
f"Kuntest: {context[:3000]}\n\n"
f"Tweġiba: {answer}\n\n"
"Għal kull dikjarazzjoni fit-tweġiba, indika:\n"
"- supported: id-dikjarazzjoni tinsab fil-kuntest\n"
"- unsupported: id-dikjarazzjoni mhix fil-kuntest\n"
"- invented: id-dikjarazzjoni tikkontradixxi l-kuntest\n\n"
"Irrispondi f'JSON bil-kliem statements (lista) u "
"fidelity_score (0 sa 1)."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature teħtieġ effort none
input=prompt,
temperature=0.0,
)
import json
try:
return json.loads(response.output_text)
except json.JSONDecodeError:
return {"fidelity_score": 0, "error": "Parsing falliet"}
It-tronkament tal-kuntest għal 3,000 karattru huwa limitu li trid tkun konxju tiegħu: jekk is-sors jaqbeż din id-daqs, dikjarazzjonijiet perfettament preċiżi se jiġu kkuntati bħala mhux appoġġjati sempliċiment għax il-passaġġ li jiġġustifikahom ġie maqtugħ. Għal dokumenti twal, aqsam u evalwa skont it-taqsima minflok ma taċċetta pożittivi foloz sistematiku.
Assemblaġġ ta’ Punt ta’ Referenza Riproduċibbli
Punt ta’ referenza (benchmark) mhuwiex sempliċiment metrika oħra: huwa setup li jiffriża sett ta’ dejta u protokoll sabiex żewġ ġirjiet ikunu komparabbli. Il-klassi hawn taħt tkejjel ir-rilevanza, il-fidelità (meta l-kuntest ikun disponibbli), il-latency, u l-ispiża, imbagħad iżżomm kull riżultat datat u ttikkettjat skont il-verżjoni tal-prompt.
from dataclasses import dataclass, field
import time
@dataclass
class BenchmarkResult:
model: str
prompt_version: str
scores: dict
avg_latency: float
total_cost: float
date: str = field(default_factory=lambda: time.strftime("%Y-%m-%d"))
class Benchmark:
"""Punt ta' referenza riutilizzabbli biex tqabbel mudelli u prompts."""
def __init__(self, name: str, dataset: list[dict]):
self.name = name
self.dataset = dataset
self.results: list[BenchmarkResult] = []
def run(
self,
model: str,
system_prompt: str,
prompt_version: str,
) -> BenchmarkResult:
"""Tħaddem il-punt ta' referenza b'mudell u prompt mogħtija."""
relevance_scores = []
hallucination_scores = []
latencies = []
cost = 0
for case in self.dataset:
start = time.perf_counter()
response = client.responses.create(
model=model,
instructions=system_prompt,
input=case["input"],
)
latency = time.perf_counter() - start
latencies.append(latency)
# Evalwa
relevance = relevance_score(
case["input"], response.output_text
)
relevance_scores.append(relevance["score"])
if case.get("context"):
halluc = detect_hallucinations(
case["context"], response.output_text
)
hallucination_scores.append(
halluc.get("fidelity_score", 0)
)
result = BenchmarkResult(
model=model,
prompt_version=prompt_version,
scores={
"relevance": sum(relevance_scores) / len(relevance_scores),
"fidelity": (
sum(hallucination_scores) / len(hallucination_scores)
if hallucination_scores else None
),
},
avg_latency=sum(latencies) / len(latencies),
total_cost=cost,
)
self.results.append(result)
return result
def compare(self) -> str:
"""Tqabbel ir-riżultati kollha tal-punt ta' referenza."""
lines = [f"Punt ta' Referenza: {self.name}\n"]
for r in self.results:
lines.append(
f" {r.model} (prompt {r.prompt_version}) | "
f"Rilevanza: {r.scores['relevance']:.2f} | "
f"Latency: {r.avg_latency:.2f}s"
)
return "\n".join(lines)
L-output ta’ compare jpoġġi deliberatament ir-rilevanza u l-latency fuq l-istess linja, għax hekk tittieħed id-deċiżjoni fil-fatt. Mudell li jikseb żewġ mitt punt fir-rilevanza filwaqt li jirdoppja l-ħin ta’ rispons mhux għażla aħjar għal applikazzjoni interattiva; jista’ jkun għal ipproċessar matul il-lejl. It-tabella ma tiddeċidix għalik; tqiegħed il-kompromess eżatt quddiem għajnejk.
Fl-aħħar nett, total_cost tibqa’ żero f’din l-implimentazzjoni. Imlaha mill-oqsma tal-użu ritornati mill-API: tqabbil ta’ mudell li jħalli barra l-ispiża jħalli barra l-kriterju li se jsolvi d-diskussjoni mat-tim finanzjarju tiegħek.
Punti Ewlenin
- Is-similarità semantika tkejjel is-sinifikat iżda tibqa’ għamja għan-negazzjoni
- Fisser ir-rilevanza f’kriterji distinti minflok punteġġ globali
- Skopri l-ħolqien ta’ informazzjoni falza (hallucinations) billi tħabbat it-tweġiba mal-kuntest tas-sors
- Oħloq punti ta’ referenza riproduċibbli li jkejlu l-kwalità, il-latency u l-ispiża flimkien
- Għaqqad metriċi awtomatiċi u LLM-as-Judge għal evalwazzjoni sħiħa