Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Cruthaigh Meastóireachtaí Saincheaptha

Ceacht 16 as 20 Nuashonraithe 3 Samhain 2026 Ardleibhéal
Ar an leathanach seo
  1. Meastóireachtaí a oiriúnú do do cheantar
  2. Aistriú riachtanais gnó go rubraic
  3. Nuair a dhéanann an mheaisín breithniú níos fearr ná an duine
  4. Déan an mheastóireacht in-athfheidhmithe
  5. Príomhphointí

An chuid seo nuashonraithe an 3 Samhain, 2026 bunaithe ar dhoiciméadú OpenAI: níl temperature agus top_p inghlactha ach le hiarracht réasúnaíochta de none, cé go ndéanann samhlacha GPT-5.6 réasúnú go huathoibríoch (medium). Caithfidh glaonna a shocraíonn na paraiméadair seo reasoning={"effort": "none"} (Freagraí API) nó reasoning_effort="none" (Críochnú Comhrá) a shonrú dá bhrí sin. Foinse: Using GPT-6 · GPT-5.6 Terra.

Nuashonrú an 2 Samhain, 2026 — Ardán Evals. D’fhógair OpenAI deireadh lena ardán Evals: tá meastóireachtaí atá ann cheana inléite amháin ón 31 Deireadh Fómhair, 2026, agus dúnfar an deasc rialaithe agus an API araon, lena n-áirítear grádálaithe, an 30 Samhain, 2026. D’fhoilsigh OpenAI treoir imirce go Promptfoo. Fanann prionsabail na meastóireachta sa chacht seo bailí; níl ann ach an uirlis atá ag athrú.

Meastóireachtaí a oiriúnú do do cheantar

Níl grádálaithe ginearálta leordhóthanach chun cáilíocht a mheas i do cheantar sonrach. Tá critéir cháilíochta difriúla ag chatbot leighis, ag cúntóir dlí, agus ag uirlis scríbhneoireachta margaíochta, agus níl na critéir seo níos líonmhaire amháin—tá tosaíochtaí difriúla acu. Is ábhar míshuaimhnis é mí-oiriúnú tóin i nuachtlitir; is earráid thromchúiseach an garbhríomh céanna in treoir dáileogáin. Déileálann grádálaí ginearálta leis an dá rud ar an mbealach céanna, rud a chiallaíonn nach bhfuil aon rud á mheastóireacht ar chor ar bith.

Sin an fáth a bhfuil gá agat le meastóireachtaí saincheaptha atá bunaithe ar rubraic shainráite a aistríonn do thosaíochtaí gnó go meáchain. Sin an rubraic atáimid chun a thógáil.

Aistriú riachtanais gnó go rubraic

Is liosta critéar meáchanaithe iad rubraic a shuimíonn go 1. Ní códú an struchtúir an cleachtadh is úsáidí, rud a thógann cúig líne déag nó mar sin, ach é a líonadh: an cinneadh a dhéanamh go bhfuil meáchan 0.25 ag buntáistí do chustaiméirí agus nach bhfuil ach 0.10 ag fad, cuireann sé sin comhrá sainráite ar siúl le húinéirí táirgí. Is é an toradh atá air sin ná sainmhíniú comhroinnte ar “freagra maith” nach féidir le haon duine a chur ina cheist ina dhiaidh sin.

from dataclasses import dataclass

@dataclass
class Critere:
    nom: str
    description: str
    poids: float  # 0 to 1, sum of weights = 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

# Example: rubric for a marketing writing assistant
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),
    ],
)

Is fiú an modh valider a ghlaow i dtástálacha, ní hamháin é a scríobh. Éabhlóidíonn rubraicí: cuireann tú critéar comhlíontachta leis, baineann tú ceann nach bhfuil úsáideach a thuilleadh, agus sleamhnaíonn an tsuim go 1.15 gan aon rud a chur an t-ainrialtacht in iúl. Fanann na scóir in-ríomha, ach tá siad mícheart, agus nuair a dhéantar comparáid eatarthu thar leaganacha, tiocfaidh siad ar chonclúidí earráideacha.

Aistríonn an grádálaí an rubraic ansin go pras, iarrann sé scór 0–5 in aghaidh gach critéir, agus athchumaidh sé scór domhanda meáchanaithe. Tagann trácht gairid le gach scór: sin an rud a ligfidh duit, agus tú ag athbhreithniú cásanna dona, a thuiscint ar fhreagair an tsamhail go dona nó ar mhí-shainmhínigh tú do chritéar.

import openai
import json

client = openai.OpenAI()

def evaluer_multi_criteres(
    question: str,
    reponse: str,
    rubrique: Rubrique,
) -> dict:
    """Evaluates a response against a multi-criteria rubric."""

    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", {})

        # Calculate weighted score
        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é"}

Bí ar an airdeall leis an lúb ríomha: déantar neamhaird ar chritéar atá in easnamh ó fhreagra an bhreithiúna go ciúin agus cuireann sé nialas leis an scór meáchanaithe. D’fhéadfadh freagra den scoth stad ag 0.75 mar sin toisc gur dhearmaid an breitheamh eochair. Má tá do scóir gafa faoi theorainn nach bhfuil míniú léi, déan iniúchadh ar scores_details sula gcuireann tú an locht ar an tsamhail atá á meastóireacht.

Nuair a dhéanann an mheaisín breithniú níos fearr ná an duine

Is bealach gearrtháite costasach é LLM a úsáid chun cód a ghrádáil: níl ann ach an breithiúnas a bhfuil tábhacht leis ná feidhmiú. Comhcheanglaíonn an grádálaí thíos an cód ginte agus tástáil, scríobhann sé go comhad sealadach é, feidhmíonn sé é, agus comhaireamh sé na rathanna. Ní gá aon léirmhíniú a dhéanamh ar an scór a thagann as sin—téann tástáil i bhfeidhm nó ní théann.

import subprocess
import tempfile

def evaluer_code_python(
    code_genere: str,
    tests: list[str],
) -> dict:
    """Evaluates Python code by executing it against tests."""
    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,
    }

Ní beart sócmhainne é an timeout=10: táirgeann samhail lúba gan teorainn go minic, agus gan an teorainn seo, gheobhaidh do fheachtas meastóireachta bac ar an gcéad chás teipthe. Cuimhnigh freisin go bhfuil tú ag feidhmiú cód nár scríobh tú féin—lasmuigh de thimpeallacht forbartha aonraithe, éilíonn an fheidhm seo gaineamhlann.

Léiríonn an achoimre cás measctha, áit a bhfuil cuid den bhreithiúnas meicniúil agus nach bhfuil cuid eile. Is féidir fad a thomhas: pionósíonn an cóimheas ríofa achoimre atá ró-ghearr agus ceann atá ró-fhada go siméadrach, rud a sheachnaíonn cleas na samhlaí an téacs foinseach a chóipeáil chun gan aon rud a fhágáil ar lár. Ar an láimh eile, ní féidir dílseacht a thomhas le riail agus filleann sé ar an mbreitheamh LLM, le ceist dhíreach faoi fhaisnéis chumtha.

def evaluer_resume(
    texte_original: str,
    resume: str,
    longueur_cible: int = 100,
) -> dict:
    """Evaluates summary quality."""
    mots_resume = len(resume.split())
    ratio_longueur = min(
        mots_resume / longueur_cible,
        longueur_cible / max(mots_resume, 1),
    )

    # Fidelity via 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,
    }

Déan an mheastóireacht in-athfheidhmithe

Stopfar meastóireacht a ritheann tú de láimh ar deireadh thiar á rith. Cuimsíonn an píblíne an rubraic agus coinníonn sí stair feachtais, ag casadh tomhais aonuaire go sraith ama: feiceann tú go bhfuil an meánscore titithe ó 0.81 go 0.79 tar éis athrú prais Dé Máirt, faisnéis nach bhféadfadh aon fheidhmiú aonair a thabhairt duit.

class PipelineEval:
    """Reusable evaluation pipeline."""

    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:
        """Evaluates a full batch and returns metrics."""
        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

Leid amháin chun tosú: tóg do chéad rubraic ar fhiche cás amháin, bíodh sé grádáilte go comhthreomhar ag an mbreitheamh LLM agus ag saineolaí ceantair, agus déan comparáid idir an dá shraith. Inseoidh na héagsúlachtaí duit cé na critéir atá mí-thuairiscithe i bhfad sula n-inseoidh siad aon rud duit faoi cháilíocht na samhla.

Príomhphointí

  • Cruthaigh rubraicí meastóireachta atá sonrach do do cheantar gnó, le meáchain shainráite
  • Fíoraigh go bhfanann suim na meáchan ag 1 de réir mar a fhorbraíonn an rubraic
  • Comhcheangail meastóireacht uathoibrithe (cód, fad) agus LLM-mar-Bhreitheamh (cáilíocht)
  • Tástáil cód ginte trí é a fheidhmiú, le teorainn ama agus timpeallacht aonraithe
  • Tóg píblíne in-athúsáidte a choinníonn stair feachtais