Métricí agus Tagarmharcanna
Ar an leathanach seo
An ceacht nuashonraithe an 3 Samhain, 2026 bunaithe ar dhoiciméadú OpenAI: ní ghlactar le
temperatureagustop_pach le hiarracht réasúnaíochta denone, cé go ndéanann samhlacha GPT-5.6 réasúnú go huathoibríoch (medium). Caithfidh glaonna a shocraíonn na paraiméadair seoreasoning={"effort": "none"}(Freagraí API) nóreasoning_effort="none"(Críochnú Comhrá) a shonrú dá bhrí sin. Foinse: GPT-6 a úsáid · GPT-5.6 Terra.
Cáilíocht a thomhas le Métricí
Thar scóir LLM-as-Judge, tá métricí cainníochtúla ann chun gnéithe éagsúla d’aschuir LLM a mheas. Ní hé a luach ná go bhfuil siad níos cruinne – feiceann breitheamh LLM atá tógtha go maith rudaí nach bhfeicfidh foirmle riamh – ach go bhfuil siad cobhsaí agus saor. Tugann cosán-chosúlacht an uimhir chéanna ar ais gach uair a ritheann tú é, costais beagnach neamhní, agus mar sin is féidir é a rith ar na mílte cás le gach gealltanas (commit). Cuirfidh tú an breitheamh LLM in áirithe ansin do thoiseanna a éilíonn é go fírinneach.
Déanfaimid athbhreithniú ar na métricí riachtanacha sula gcuirfimid le chéile i dtagarmharcanna in-atáirgthe iad.
Brí a chur i gcomparáid seachas Focail
Éiríonn comparáid idir dhá théacs carachtar ar charachtar dodhéanta chomh luath agus a bhíonn an frásaíocht saor. Seachnaíonn cosúlacht shéimeantach an fhadhb seo: déantar veicteoir de gach téacs le samail chumhdaigh (embedding model), agus tomhaiseann muid an uillinn idir an dá veicteoir. Díreoidh dhá abairt a deir an rud céanna le focail éagsúla sa treo céanna.
import openai
import numpy as np
client = openai.OpenAI()
def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
"""Calculates the cosine similarity between two vectors."""
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:
"""Measures the semantic similarity between two texts."""
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)
# Example
score = semantic_similarity(
"The cat is on the rug.",
"A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}") # ~0.85+
Tá an sampla soilsitheach: scóráilonn dhá abairt gan aon fhocal i gcoiteann os cionn 0.85. Is é seo neart na modha, agus a gaiste freisin. Déanann cosúlacht shéimeantach neamhaird ar dhiúltú agus ar nuansaí céime – tá “glacadh leis an íocaíocht” agus “diúltaíodh don íocaíocht” an-chosúil ó thaobh na veicteoireachta de. Dá bhrí sin, ná húsáid é leis féin chun freagra a bhailíochtú áit a bhfuil tábhacht le cruinneas fíorasach.
Nuair is é an cheist “an bhfuil an freagra ag plé go fírinneach leis an gceist a cuireadh”, ní féidir le haon fhoirmle breithiúnas a chur in ionad. Briseann an scór ábharthachta thíos an breithiúnas seo síos ina thrí cheist ar leith: An bhfuil an freagra díreach? An bhfanann sé dírithe? An bhfuil sé iomlán? Tá an briseadh síos seo níos fearr ná scór domhanda toisc go n-insíonn sé duit cén treo chun an leid a cheartú – éilíonn samhaltóir fochallach agus samhaltóir neamhiomlán ceartúcháin contrártha.
def relevance_score(
question: str,
answer: str,
context: str | None = None,
) -> dict:
"""Evaluates whether the answer is relevant to the question."""
prompt = (
"Evaluate the relevance of this answer.\n\n"
f"Question: {question}\n"
)
if context:
prompt += f"Context provided: {context[:1000]}\n"
prompt += (
f"Answer: {answer}\n\n"
"Criteria:\n"
"1. Does the answer directly address the question? (0-5)\n"
"2. Does the answer contain unrequested information? (0-5, 5=none)\n"
"3. Is the answer complete? (0-5)\n\n"
"Respond in JSON with keys: direct, focus, completeness."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires 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 failed"}
Tabhair faoi deara an frásaíocht inbhéartaithe sa dara critéar, áit a gciallaíonn 5 “gan aon fhaisnéis nach iarradh”. Ligeann sé seo do na trí scór a chur leis sa treo céanna, ach tá sé contrártha don chiall le léamh: nuair a chuireann tú do chritéir féin leis, coinnigh an coinbhinsiún seo nó gheobhaidh tú meáin a dhuaiseoidh an locht a bhí beartaithe agat a phionósú.
A fhíorú nach bhfuil an Samhaltóir ag Hallucinateáil
I bhfeidhmchlár Ceist agus Freagra bunaithe ar dhoiciméid, ní hé cáilíocht na scríbhneoireachta an mhétric chinntitheach ach dílseacht don fhoinse. Is simplí an prionsabal rialaithe: cuir an comhthéacs bunaidh agus an freagra ginte i láthair an bhreithimh, agus iarr air gach ráiteas a aicmiú mar thacaíocht ag an gcomhthéacs, as láthair ón gcomhthéacs, nó contrártha dó. Tá tábhacht leis an idirdhealú idir an dá chatagóir dheireanacha seo, toisc go bhféadfadh ráiteas atá as láthair amháin a bheith ina eolas ginearálta cruinn, ach is earráid i gcónaí é ráiteas a thagann salach ar an bhfoinse.
def detect_hallucinations(
context: str,
answer: str,
) -> dict:
"""Detects statements not supported by the context."""
prompt = (
"Analyze this answer and identify any statement "
"that is NOT supported by the provided context.\n\n"
f"Context: {context[:3000]}\n\n"
f"Answer: {answer}\n\n"
"For each statement in the answer, indicate:\n"
"- supported: the statement is in the context\n"
"- unsupported: the statement is not in the context\n"
"- invented: the statement contradicts the context\n\n"
"Respond in JSON with the key statements (list) and "
"fidelity_score (0 to 1)."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires 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 failed"}
Is teorainn í an comhthéacs a ghearradh go 3,000 carachtar ar cheart duit a bheith ar an eolas fúithi: má sháraíonn an fhoinse an méid seo, déanfar ráitis atá cruinn go foirfe a chomhaireamh mar thacaíocht easnamhach simplí toisc gur gearradh an pas a thugann údar dóibh. I gcás doiciméad fada, roinn agus déan meastóireacht de réir alt seachas glacadh le dearbh-thorthaí dearfacha córasacha.
Tagarmharc In-atáirgthe a Chur le Chéile
Ní métric eile amháin é tagarmharc: is socruithe é a reoíonn tacar sonraí agus prótacal ionas go bhfuil dhá rith inchomparáide. Tomhaiseann an rang thíos ábharthacht, dílseacht (nuair atá comhthéacs ar fáil), moill, agus costas, agus coinníonn sé gach toradh dátaithe agus lipéadaithe de réir leagan an leide.
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:
"""Reusable benchmark for comparing models and 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:
"""Runs the benchmark with a given model and prompt."""
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)
# Evaluate
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:
"""Compares all benchmark results."""
lines = [f"Benchmark: {self.name}\n"]
for r in self.results:
lines.append(
f" {r.model} (prompt {r.prompt_version}) | "
f"Relevance: {r.scores['relevance']:.2f} | "
f"Latency: {r.avg_latency:.2f}s"
)
return "\n".join(lines)
Cuireann aschur compare ábharthacht agus moill ar an líne chéanna d’aon ghnó, mar is mar sin a dhéantar an cinneadh i ndáiríre. Ní rogha níos fearr é samhaltóir a ghnóthaíonn dhá chéadú pointe in ábharthacht agus am freagartha á dhúbailt d’fheidhmchlár idirghníomhach; d’fhéadfadh sé a bheith do phróiseáil thar oíche. Ní dhéanann an tábla an cinneadh duitse; cuireann sé an comhréiteach díreach os do chomhair.
Ar deireadh, fanann total_cost cothrom le nialas sa chur i bhfeidhm seo. Líon é isteach ó na réimsí úsáide a thugtar ar ais ag an API: fágann comparáid samhaltóra a fhágann costas ar lár an critéar ar lár a réiteoidh an díospóireacht le do fhoireann airgeadais.
Príomhphointí
- Tomhaiseann cosúlacht shéimeantach brí ach fanann sí dall ar dhiúltú
- Bris síos ábharthacht ina critéir ar leith seachas scór domhanda
- Brath hallucinations trí an freagra a chur i gcoinne chomhthéacs na foinse
- Cruthaigh tagarmharcanna in-atáirgthe a thomhaiseann cáilíocht, moill, agus costas le chéile
- Comhcheangail métricí uathoibríocha agus LLM-as-Judge le haghaidh meastóireachta iomláine