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

Metriċi u Punti ta' Referenza

Lezzjoni 17 / 20 Aġġornat 3 ta’ Novembru 2026 Avvanzat
F'din il-paġna
  1. Kejl tal-Kwalità bil-Metriċi
  2. Tqabbil tas-Sinifikat Minflok il-Kliem
  3. Verifika li l-Mudell Mhuwiex Joħloq Informazzjoni Falza (Hallucinating)
  4. Assemblaġġ ta’ Punt ta’ Referenza Riproduċibbli
  5. Punti Ewlenin

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 għandhom jispeċifikaw reasoning={"effort": "none"} (API Responses) jew reasoning_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