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

Oħloq Evalwazzjonijiet Personalizzati

Lezzjoni 16 / 20 Aġġornat 3 ta’ Novembru 2026 Avvanzat
F'din il-paġna
  1. Adatta l-evalwazzjonijiet għad-dominju tiegħek
  2. Ittrasforma rekwiżit tan-negozju f’rubrika
  3. Meta l-magna tiggudika aħjar mill-bniedem
  4. Agħmel l-evalwazzjoni ripetibbli
  5. Punti Ewlenin

Lezzjoni aġġornata fit-3 ta’ Novembru, 2026 ibbażata fuq id-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"} (API Responses) jew reasoning_effort="none" (Chat Completions). Sorsi: Using GPT-6 · GPT-5.6 Terra.

Aġġornament tat-2 ta’ Novembru, 2026 — Pjattaforma Evals. OpenAI ħabbret it-tmiem tal-pjattaforma Evals tagħha: l-evalwazzjonijiet eżistenti saru read-only mill-31 ta’ Ottubru, 2026, u kemm id-dashboard kif ukoll l-API, inklużi l-graders, jagħlqu fit-30 ta’ Novembru, 2026. OpenAI ippubblikat gwida ta’ migrazzjoni lejn Promptfoo. Il-prinċipji tal-evalwazzjoni f’din il-lezzjoni jibqgħu validi; qed jinbidel biss l-għodda.

Adatta l-evalwazzjonijiet għad-dominju tiegħek

Il-graders ġeneriċi mhumiex biżżejjed biex tivvaluta l-kwalità fid-dominju speċifiku tiegħek. Chatbot mediku, assistent legali, u għodda tal-kitba għall-marketing kull wieħed għandu kriterji ta’ kwalità differenti, u dawn il-kriterji mhumiex biss aktar numerużi—huma pprijoritizzati b’mod differenti. Diskrepanza fit-ton f’newsletter hija fastidju; l-istess approssimazzjoni f’istruzzjoni tad-dożaġġ hija żball serju. Grader ġeneriku jittratta ż-żewġ każijiet bl-istess mod, li jfisser li fil-fatt ma qed jevalwa xejn.

Għalhekk għandek bżonn evalwazzjonijiet personalizzati mibnija fuq rubrika espliċita li tittrasforma l-prijoritajiet tan-negozju tiegħek f’piżijiet. Dik hija r-rubrika li se nibnu.

Ittrasforma rekwiżit tan-negozju f’rubrika

Rubrika hija lista ta’ kriterji b’piż li jammontaw għal 1. L-eżerċizzju l-aktar utli mhux il-kodifikazzjoni tal-istruttura, li tieħu madwar ħmistax-il linja, iżda l-mili tagħha: id-deċiżjoni li l-benefiċċji għall-klijent jiżnu 0.25 filwaqt li t-tul jiżna biss 0.10 timponi konversazzjoni espliċita mas-sidien tal-prodott. Dak li tirriżulta huwa definizzjoni kondiviża ta’ “risposta tajba” li ħadd ma jista’ jikkontesta wara l-fatt.

from dataclasses import dataclass

@dataclass
class Critere:
    nom: str
    description: str
    poids: float  # 0 sa 1, somma tal-piżijiet = 1

@dataclass
class Rubrique:
    nom: str
    criteres: list[Critere]

    def valider(self) -> bool:
        total = sum(c.poids for c in self.criteres)
        return abs(total - 1.0) < 0.01

# Eżempju: rubrika għal assistent tal-kitba għall-marketing
rubrique_marketing = Rubrique(
    nom="Qualité rédaction marketing",
    criteres=[
        Critere("ton", "Le ton est professionnel et engageant", 0.20),
        Critere("cta", "Contient un appel à l'action clair", 0.15),
        Critere("benefices", "Met en avant les bénéfices client", 0.25),
        Critere("longueur", "Respecte la longueur demandée", 0.10),
        Critere("grammaire", "Aucune faute de grammaire ou orthographe", 0.15),
        Critere("marque", "Respecte les guidelines de la marque", 0.15),
    ],
)

Il-metodu valider jistħoqqilu li jissejjaħ fit-testijiet, mhux biss li jinkiteb. Ir-rubriki jevolvu: iżżid kriterju ta’ konformità, tneħħi wieħed li m’għadx utli, u s-somma tiċċaqlaq għal 1.15 mingħajr xejn li jiffaġġa l-anomalija. L-iskors jibqgħu kalkolabbli, sempliċiment żbaljati, u meta mqabbla bejn verżjonijiet differenti se jwassluk għal konklużjonijiet erronji.

Imbagħad il-grader jittrasforma r-rubrika f’prompt, jitlob punteġġ minn 0 sa 5 għal kull kriterju, u jerġa’ jikkomponea punteġġ globali b’piż. Kull punteġġ jiġi akkumpanjat minn kumment qasir: dan huwa dak li jippermettilek, meta tirrevedi każijiet ħżiena, tifhem jekk il-mudell irrispondiex ħażin jew jekk il-kriterju tiegħek kienx ifformulat ħażin.

import openai
import json

client = openai.OpenAI()

def evaluer_multi_criteres(
    question: str,
    reponse: str,
    rubrique: Rubrique,
) -> dict:
    """Jivvaluta risposta skont rubrika multi-kriterju."""

    criteres_texte = "\n".join(
        f"- {c.nom} (poids: {c.poids}): {c.description}"
        for c in rubrique.criteres
    )

    prompt = (
        "Évaluez cette réponse selon les critères suivants.\n"
        "Pour chaque critère, donnez un score de 0 à 5.\n\n"
        f"Question posée : {question}\n"
        f"Réponse à évaluer : {reponse}\n\n"
        f"Critères :\n{criteres_texte}\n\n"
        "Répondez en JSON avec un objet scores contenant pour chaque critère "
        "un score (0-5) et un commentaire court."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=prompt,
        temperature=0.0,
    )

    try:
        resultat = json.loads(response.output_text)
        scores = resultat.get("scores", {})

        # Ikkalkula l-punteġġ b'piż
        score_pondere = 0
        for critere in rubrique.criteres:
            if critere.nom in scores:
                score_brut = scores[critere.nom]["score"] / 5.0
                score_pondere += score_brut * critere.poids

        return {
            "score_global": score_pondere,
            "scores_details": scores,
            "rubrique": rubrique.nom,
        }
    except (json.JSONDecodeError, KeyError):
        return {"score_global": 0, "erreur": "Parsing échoué"}

Oqgħod attent għaċ-ċiklu tal-kalkolu: kriterju nieqes mir-risposta tal-imħallef jiġi injorat silenzjożament u jikkontribwixxi żero għall-punteġġ b’piż. Risposta eċċellenti għalhekk tista’ tieqaf f’0.75 sempliċiment għax l-imħallef insew ċavetta. Jekk il-punteġġi tiegħek jidhru mwaqqfa taħt limitu massimu mhux spjegat, iċċekkja scores_details qabel ma tlum il-mudell evalwat.

Meta l-magna tiggudika aħjar mill-bniedem

Li jkollok LLM jiggudika l-kodiċi hija shortcut għali: l-uniku verdett li jimpurta huwa l-eżekuzzjoni. Il-grader hawn taħt jikkonkatena l-kodiċi ġġenerat u test, jiktbu f’fajl temporanju, jesegwixxih, u jgħodd is-suċċessi. Il-punteġġ li jirriżulta ma jeħtieġ l-ebda interpretazzjoni—test jew jgħaddi jew ma jgħaddix.

import subprocess
import tempfile

def evaluer_code_python(
    code_genere: str,
    tests: list[str],
) -> dict:
    """Jivvaluta kodiċi Python billi jesegwixxih kontra t-testijiet."""
    resultats_tests = []

    for i, test in enumerate(tests):
        code_complet = f"{code_genere}\n\n{test}"

        with tempfile.NamedTemporaryFile(
            mode="w", suffix=".py", delete=False
        ) as f:
            f.write(code_complet)
            f.flush()

            try:
                resultat = subprocess.run(
                    ["python3", f.name],
                    capture_output=True,
                    text=True,
                    timeout=10,
                )
                succes = resultat.returncode == 0
                resultats_tests.append({
                    "test": i,
                    "succes": succes,
                    "sortie": resultat.stdout[:200],
                    "erreur": resultat.stderr[:200] if not succes else "",
                })
            except subprocess.TimeoutExpired:
                resultats_tests.append({
                    "test": i,
                    "succes": False,
                    "erreur": "Timeout (10s)",
                })

    nb_succes = sum(1 for r in resultats_tests if r["succes"])
    return {
        "score": nb_succes / len(tests) if tests else 0,
        "tests_passes": nb_succes,
        "tests_total": len(tests),
        "details": resultats_tests,
    }

Il-timeout=10 mhix prekawzjoni ta’ kumdità: mudell regolarment jipproduċi loops infiniti, u mingħajr dan il-limitu l-kampanja tal-evalwazzjoni tiegħek titwaqqaf fuq l-ewwel każ li jfalli. Ftakar ukoll li qed tesegwixxi kodiċi li ma kitibtix—barra ambjent ta’ żvilupp iżolat, din il-funzjoni teħtieġ sandbox.

Is-sommarju juri każ imħallat, fejn parti mill-ġudizzju hija mekkanika u parti le. It-tul huwa kejl: ir-raġġun ikkalkulat jippenalizza sommarju li huwa qasir wisq u wieħed li huwa twil wisq b’mod simetriku, li jevita t-trikka tal-mudell li jikkopja t-test sors biex ma jħalli xejn barra. Il-fidelità, min-naħa l-oħra, mhijiexkejla b’regola u terġa’ lura għall-imħallef LLM, b’mistoqsija diretta dwar informazzjoni inventata.

def evaluer_resume(
    texte_original: str,
    resume: str,
    longueur_cible: int = 100,
) -> dict:
    """Jivvaluta l-kwalità tas-sommarju."""
    mots_resume = len(resume.split())
    ratio_longueur = min(
        mots_resume / longueur_cible,
        longueur_cible / max(mots_resume, 1),
    )

    # Fidelità permezz ta' LLM
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=(
            f"Le résumé suivant est-il fidèle au texte original ? "
            f"Contient-il des informations inventées ?\n\n"
            f"Texte original (extrait) : {texte_original[:2000]}\n\n"
            f"Résumé : {resume}\n\n"
            f"Répondez en JSON avec les clés : fidélité (0-5), "
            f"hallucinations (oui/non), commentaire (court)."
        ),
        temperature=0.0,
    )

    try:
        fidelite = json.loads(response.output_text)
    except json.JSONDecodeError:
        fidelite = {"fidelite": 0, "hallucinations": "inconnu"}

    return {
        "score_longueur": ratio_longueur,
        "score_fidelite": fidelite.get("fidelite", 0) / 5.0,
        "hallucinations": fidelite.get("hallucinations", "inconnu"),
        "mots_resume": mots_resume,
        "longueur_cible": longueur_cible,
    }

Agħmel l-evalwazzjoni ripetibbli

Evalwazzjoni li terġa’ tagħmel manwalment eventwalment tieqaf milli ssir. Il-pipeline tinkapsula r-rubrika u żżomm storiku tal-kampanji, u tbiddel kejl ta’ darba f’serje temporali: tara li l-punteġġ medju niżel minn 0.81 għal 0.79 wara l-bidla tal-prompt tat-Tlieta, informazzjoni li l-ebda eżekuzzjoni iżolata ma setgħet tagħtik.

class PipelineEval:
    """Pipeline tal-evalwazzjoni riutilizzabbli."""

    def __init__(self, nom: str, rubrique: Rubrique):
        self.nom = nom
        self.rubrique = rubrique
        self.historique: list[dict] = []

    def evaluer_batch(
        self,
        dataset: list[dict],
        modele: str,
        prompt_systeme: str,
    ) -> dict:
        """Jivvaluta batch sħiħ u jirritorna metriċi."""
        resultats = []

        for cas in dataset:
            response = client.responses.create(
                model=modele,
                instructions=prompt_systeme,
                input=cas["input"],
            )

            eval_result = evaluer_multi_criteres(
                cas["input"],
                response.output_text,
                self.rubrique,
            )
            resultats.append(eval_result)

        scores = [r["score_global"] for r in resultats]
        rapport = {
            "pipeline": self.nom,
            "modele": modele,
            "nb_cas": len(dataset),
            "score_moyen": sum(scores) / len(scores),
            "score_min": min(scores),
            "score_max": max(scores),
        }

        self.historique.append(rapport)
        return rapport

Parir biex tibda: ibni l-ewwel rubrika tiegħek fuq għoxrin każ biss, agħmilha tiġi vvalutata parallelament mill-imħallef LLM u minn espert tad-dominju, imbagħad qabbel iż-żewġ serje. Id-diskrepanzi jgħidulek liema kriterji huma deskritti ħażin ferm qabel ma jgħidulek xi ħaġa dwar il-kwalità tal-mudell.

Punti Ewlenin

  • Oħloq rubriki ta’ evalwazzjoni speċifiċi għad-dominju tan-negozju tiegħek, b’piżijiet espliċiti
  • Ivvverifika li s-somma tal-piżijiet tibqa’ 1 hekk kif ir-rubrika tevolvi
  • Ikkombina evalwazzjoni awtomatizzata (kodiċi, tul) u LLM-as-Judge (kwalità)
  • Ittestja l-kodiċi ġġenerat billi tesegwixxih, b’timeout u f’ambjent iżolat
  • Ibni pipeline riutilizzabbli li żżomm storiku tal-kampanji