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

Meastóireacht Uathoibrithe ar Phreabanna

Ceacht 16 as 16 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Meastóireacht Uathoibrithe ar Phreabanna
  2. Cineálacha Meastóireachta
  3. Píblíne Mheastóireachta Iomlán
  4. Sraith Tástála: Formáid
  5. Comhtháthú CI/CD
  6. Painéal Mheastóireachta
  7. Socraigh do Ghuardaí
  8. Príomhphointí
  9. Tástáil do Chuid Eolais

Nuashonraíodh an ceacht 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ú de réir réamhshocraithe (medium). Caithfidh glaonna a shocraíonn na paraiméadair seo reasoning={"effort": "none"} (API Freagraí) nó reasoning_effort="none" (Críochnú Comhrá) a shonrú dá bhrí sin. Foinse: GPT-6 a úsáid · GPT-5.6 Terra.

Meastóireacht Uathoibrithe ar Phreabanna

Is é an mheastóireacht uathoibrithe bunús píblíne aibí innealtóireachta preabanna. Ligeann sé duit cúlchéimeanna a bhrath, samhlacha a chur i gcomparáid, agus athruithe a bhailíochtú sula ndéantar imlonnú. Gan é, is gealltanas dall gach athrú preab.

Cineálacha Meastóireachta

Roinneann trí theaghlach meastóirí an obair de réir nádúr an aschuir a bhfuiltear ag súil leis, agus beidh ort roinnt acu a chomhcheangal beagnach i gcónaí.

Meastóireacht ar Mheaitseáil Chruinn

Do thascanna a bhfuil freagra amháin ionchais acu, is leor comparáid dhíreach. Déanann eval_exact_match normalú ar chás agus ar spás bán sula ndéantar comparáid: gan an réamhchúram seo, bheadh “Bug” agus “bug” á gcomhaireamh mar earráid, rud a chuirfeadh ort fadhb nach bhfuil ann a dheisiú.

Láimhseálann eval_set_match cásanna ina bhfuil an freagra ina thacar—eintitis a fuarthas i ndoiciméad, catagóirí a sannadh d’alt. Díorthaíonn sé cruinneas agus athghairm, dhá fhigiúr a insíonn scéalta éagsúla: léiríonn cruinneas ard le hathghairm íseal samhal ró-chúramach nach mbaineann ach an rud atá cinnte aici; nochtann an contrárthacht samhal a chruthaíonn hallúisiní chun bearnaí a líonadh. Déanann F1 achoimre áisiúil orthu ach ní chuireann sé in ionad iad chun diagnóis a dhéanamh.

def eval_exact_match(prediction: str, reference: str) -> bool:
    """Meaitseáil chruinn tar éis normalaithe."""
    return prediction.strip().lower() == reference.strip().lower()

def eval_set_match(prediction: set, reference: set) -> dict:
    """Meaitseáil tacair (eintitis, catagóirí)."""
    tp = len(prediction & reference)
    fp = len(prediction - reference)
    fn = len(reference - prediction)

    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
    f1 = (2 * precision * recall / (precision + recall)
          if (precision + recall) > 0 else 0)

    return {"precision": precision, "recall": recall, "f1": f1}

Meastóireacht Shéimeantach (Leabú)

Do fhreagraí téacs ina bhféadfadh an foclaíocht a bheith éagsúil, éiríonn meaitseáil chruinn absurd: deir “Seolfar d’ordú amárach” agus “Tá an seachadadh sceidealaithe don amárach” an rud céanna ach bheadh scór nialasach acu. Tomhaiseann cosain-chosúlacht idir leabuithe gaireacht shéimeantach seachas meaitseáil carachtair, ag tabhairt scór leanúnach ar ais.

Socraíonn tú an tairseach os a chionn a mheastar go bhfuil freagra inghlactha. Déan calabrú air ar roinnt dosaen péire a d’aicmigh tú de láimh mar “coibhéiseach” nó “éagsúil”, ansin roghnaigh an luach a scarann an dá ghrúpa is fearr: táirgeann tairseach a roghnaítear de réir intuighe torthaí chomh treallach gan tomhas ar bith, leis an mbreisean bhréagchineálachta rigear.

from openai import OpenAI
import numpy as np

client = OpenAI()

def eval_semantic_similarity(prediction: str,
                              reference: str) -> float:
    """Cosain-chosúlacht idir leabuithe."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[prediction, reference]
    )
    emb_pred = np.array(response.data[0].embedding)
    emb_ref = np.array(response.data[1].embedding)

    similarity = float(
        np.dot(emb_pred, emb_ref) /
        (np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
    )
    return similarity

Meastóireacht LLM (LLM mar Bhreitheamh)

Déanann an tsamhail meastóireacht ar cháilíocht freagra. Seo an cur chuige inmharthana amháin nuair nach bhfuil aon tagairt ann: ní scríobhfaidh aon duine an freagra tacaíochta “ceart” de láimh do dhá chéad ticéad.

Braitheann úsáideacht breitheamh ar roinnt rudaí. Ar an gcéad dul síos, an tsamhail a úsáidtear: roghnaíonn tú samhal níos cumasaí mar bhreitheamh, anseo gpt-5.6-sol, toisc go mbíonn claonadh ag breitheamh atá ar an leibhéal céanna leis an duine atá á mheastóireacht a lochtanna féin a bhailíochtú. Sa dara háit, údar a éileamh: cobhsaíonn gach scór a mhúineadh an breithiúnas agus ligeann sé duit a aithint nuair a úsáideann meastóir an critéar mícheart—is bratach dhearg é údar a phléann fad nuair ba é soiléireacht an critéar. Ar deireadh, cinntíonn temperature ag 0.1 cobhsaíocht scóir thar riteanna.

def eval_llm_judge(question: str, prediction: str,
                    criteria: list[str]) -> dict:
    """Meastóireacht ag samhail bhreithiúna."""
    criteria_text = "\n".join(
        f"- {c}: scór ó 1 go 5" do ch in criteria
    )

    response = client.responses.create(
        model="gpt-5.6-sol",  # Samhal níos cumasaí mar bhreitheamh
        reasoning={"effort": "none"},  # éilíonn temperature iarracht none
        instructions="Is meastóir saineolaí, neamhchlaonta tú.",
        input=f"""Déan meastóireacht ar an bhfreagra seo de réir na gcritéar seo a leanas:

Ceist a cuireadh: {question}

Freagra le meastóireacht: {prediction}

Critéir:
{criteria_text}

Do gach critéar, tabhair scór ó 1 go 5 le húdar.""",
        text={
            "format": {
                "type": "json_schema",
                "name": "evaluation",
                "schema": {
                    "type": "object",
                    "properties": {
                        "scores": {
                            "type": "array",
                            "items": {
                                "type": "object",
                                "properties": {
                                    "criterion": {"type": "string"},
                                    "score": {"type": "integer"},
                                    "justification": {"type": "string"}
                                },
                                "required": ["criterion", "score",
                                              "justification"],
                                "additionalProperties": False
                            }
                        },
                        "overall_score": {"type": "number"},
                        "verdict": {"type": "string"}
                    },
                    "required": ["scores", "overall_score", "verdict"],
                    "additionalProperties": False
                },
                "strict": True
            }
        },
        temperature=0.1
    )
    return json.loads(response.output_text)

Píblíne Mheastóireachta Iomlán

Cuirann EvalPipeline na bloic thógála seo le chéile: lódálann sé sraith tástála, ritheann sé an preab ar gach cás, cuireann sé gach meastóir soláthraithe i bhfeidhm, agus déanann sé scóir a thiomsú. Cuirtear meastóirí ar fáil mar liosta feidhmeanna, ar glaotar orthu go léir leis an síniú céanna; dá bhrí sin, ní éilíonn méadrach a chur leis aon mhodhnú ar an bpíblíne, agus is féidir leat meaitseáil chruinn, cosain-chosúlacht shéimeantach, agus breitheamh a rith ar an riteadh céanna gan íoc as giniúint faoi thrí.

Tiomsaíonn an modh summary na tócan a úsáideadh freisin. Cosnaíonn an líne seo atá cosúil le táthairge tú ó ghreim coiteann: ní gá gur é an rogha cheart leagan preab a ghnóthaíonn dhá phointe scóir agus a thríúnaíonn an bille, agus is fearr é sin a fhoghlaim ag am an mhalartaithe ná nuair a thagann an fhíseáil mhíosúil.

import json
from dataclasses import dataclass
from pathlib import Path

@dataclass
class TestCase:
    """Cás tástála le haghaidh meastóireachta."""
    input_text: str
    expected_output: str = None
    metadata: dict = None

class EvalPipeline:
    """Píblíne mheastóireachta uathoibrithe."""

    def __init__(self, test_suite_path: str):
        """Lódálann an tsraith tástála ó chomhad JSON."""
        data = json.loads(Path(test_suite_path).read_text())
        self.test_cases = [TestCase(**tc) for tc in data]
        self.results = []

    def run(self, prompt_config: dict,
            evaluators: list[callable]) -> dict:
        """Ritheann sé gach tástáil agus déanann sé meastóireacht ar thorthaí."""
        self.results = []

        for tc in self.test_cases:
            # Giniúint freagra
            response = client.responses.create(
                model=prompt_config["model"],
                reasoning={"effort": "none"},  # éilíonn temperature iarracht none
                instructions=prompt_config["system_prompt"],
                input=tc.input_text,
                temperature=prompt_config.get("temperature", 0.1)
            )

            prediction = response.output_text

            # Déan meastóireacht le gach meastóir
            scores = {}
            for evaluator in evaluators:
                score = evaluator(
                    question=tc.input_text,
                    prediction=prediction,
                    reference=tc.expected_output
                )
                scores[evaluator.__name__] = score

            self.results.append({
                "input": tc.input_text,
                "expected": tc.expected_output,
                "prediction": prediction,
                "scores": scores,
                "tokens": {
                    "input": response.usage.input_tokens,
                    "output": response.usage.output_tokens
                }
            })

        return self.summary()

    def summary(self) -> dict:
        """Déanann sé achoimre ar thorthaí na meastóireachta."""
        if not self.results:
            return {"error": "Gan aon toradh"}

        # Tiomsaigh scóir de réir meastóra
        all_scores = {}
        for result in self.results:
            for eval_name, score in result["scores"].items():
                if eval_name not in all_scores:
                    all_scores[eval_name] = []
                if isinstance(score, (int, float)):
                    all_scores[eval_name].append(score)
                elif isinstance(score, dict) and "f1" in score:
                    all_scores[eval_name].append(score["f1"])

        summary = {
            "total_tests": len(self.results),
            "average_scores": {
                name: sum(scores) / len(scores)
                for name, scores in all_scores.items()
                if scores
            },
            "total_token_cost": sum(
                r["tokens"]["input"] + r["tokens"]["output"]
                for r in self.results
            )
        }
        return summary

Sraith Tástála: Formáid

Fanann formáid na sraithe tástála beartaithe íosta: ionchur, an t-aschur a bhfuiltear ag súil leis, agus meiteashonraí saorchruthach. Tá na meiteashonraí seo níos úsáidí ná mar a dealraíonn sé—trí gach cás a chlibeáil de réir catagóire, briseann tú síos na scóir agus faigheann tú amach nach bhfuil do rangaire ag teip go randamach ach ar theaghlach sonrach iarratas, rud nach nochtann meán domhanda de 88%. Taispeánann na trí shampla thíos freisin cad ba chóir do shraith mhaith a bheith ann: cásanna soiléire, cosúil le tuairt tosaithe, ach freisin cásanna atá ar theorainn catagóire eile—tá ceist faoi ghné atá in easnamh an-chosúil le tuairisc fabht, agus ar an teorainn seo a chinntear cáilíocht rangaire.

[
    {
        "input_text": "Níl mo phacáiste tagtha",
        "expected_output": "gearán",
        "metadata": {"category": "seachadadh"}
    },
    {
        "input_text": "Conas is féidir liom mód dorcha a chumasú?",
        "expected_output": "ceist",
        "metadata": {"category": "gné"}
    },
    {
        "input_text": "Tuairteálann an aip ag tosú ar iOS 18",
        "expected_output": "fabht",
        "metadata": {"category": "teicniúil"}
    }
]

Comhtháthú CI/CD

Rith meastóireacht ar gach athrú preab. Tiontaíonn an fheidhm ci_eval_check tomhas ina gharda: ritheann sí an phíblíne, déanann sí comparáid idir an meánscór agus tairseach, agus filleann sí booleán a léirmhíníonn do shlabhra comhtháthaithe mar rath nó teip tógála. Ní shroicheann athrú a laghdaíonn cruinneas faoi bhun 85% an táirgeadh a thuilleadh, díreach mar a chuireann tástáil aonaid bhriste cumasc ar ceal.

Socraigh an tairseach bunaithe ar an scór atá bainte amach cheana féin ag an leagan reatha, ní ó idéal. Socraigh ró-ard é agus díbreoidh tú an foireann chun an fhíorú a sheachaint le díchumasuithe sealadacha a éiríonn buan; socraigh ró-íseal é agus ní bheidh tú ag seiceáil rud ar bith agus suaitheantas glas á thaispeáint agat. Ar deireadh, cuimhnigh go gcaithfidh an tsraith fanacht ionadaíoch don trácht fíor: ní chruthaíonn tairseach a chomhlíontar ar fhiche cás a scríobhadh dhá bhliain ó shin rud ar bith faoi na hiarratais inniu.

def ci_eval_check(prompt_config: dict,
                   test_suite: str,
                   min_score: float = 0.85) -> bool:
    """Geata CI/CD: seiceálann sé go bhfuil an preab ag comhlíonadh an scóir íosta."""
    pipeline = EvalPipeline(test_suite)

    def accuracy(question, prediction, reference):
        return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0

    results = pipeline.run(prompt_config, [accuracy])
    avg_score = results["average_scores"].get("accuracy", 0)

    print(f"Meánscór: {avg_score:.2%}")
    print(f"Tairseach íosta: {min_score:.2%}")

    if avg_score < min_score:
        print("TEIP: scór faoi bhun na tairsí")
        return False

    print("RATH: preab bailíochtaithe")
    return True

Painéal Mheastóireachta

Rianaigh éabhlóid scóir le himeacht ama. Ní insíonn scór amháin rud ar bith; insíonn an tsraith scéal do phreab agus freagraíonn sí an cheist a thagann suas i gcónaí i gcruinnithe: an bhfuilimid ag déanamh dul chun cinn? Cruthaíonn an fheidhm thíos tábla Markdown a chuireann taobh le taobh, do gach leagan, an meánscór, na tócan a úsáideadh, agus an costas measta. Níl an fhormáid gan chúis: greamaíonn sí go díreach isteach in iarratas tarraingthe, rud a dhéanann an chomparáid inléite do dhaoine nach osclóid do chód riamh.

def comparison_report(results: dict[str, dict]) -> str:
    """Gineann sé tuarascáil chomparáideach idir leaganacha preab."""
    report = "# Tuarascáil Mheastóireachta Chomparáideach\n\n"
    report += "| Leagan | Meánscór | Meántócan | Costas |\n"
    report += "|---------|---------------|----------------|------|\n"

    for version, data in results.items():
        score = data.get("average_scores", {})
        score_val = list(score.values())[0] if score else 0
        tokens = data.get("total_token_cost", 0)
        report += (f"| {version} | {score_val:.2%} | "
                   f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")

    return report

Socraigh do Ghuardaí

Tóg sraith de fhiche cás tástála do phreab fíor, ag cur cúpla cás imeallach in ionad fiche sampla compordach: ní mhúineann sraith a riteann ag 100% ar an gcéad iarracht rud ar bith duit. Cuir na trí chineál meastóra i bhfeidhm agus rith iad le chéile ar dhá leagan de do phreab. Tugann meaitseáil chruinn uimhir ghlan, gabhann cosain-chosúlacht shéimeantach athfhoclaíocht dhlíthiúil, agus soiléiríonn an breitheamh cásanna ina n-aontaíonn an dá cheann chéadta—tá na mí-aontuithe seo lán de cheachtanna faoin rud a bhfuil tú ag súil leis ón tsamhal i ndáiríre.

Déan comparáid, aithin an leagan buaiteach, ansin socraigh an script CI a chuireann cosc ar imlonnú má thiteann an scór. Beidh a fhios agat go n-oibríonn an córas an lá a dhiúltaíonn sé athrú a shíl tú a bheith soiléir.

Príomhphointí

  • Tá meastóireacht uathoibrithe riachtanach chun iteráil le muinín
  • Comhcheangail meastóireacht chruinn, shéimeantach, agus LLM-mar-bhreitheamh de réir mar is gá
  • Coinnigh sraith tástála a fhorbraíonn le d’iarratas
  • Comhtháthaigh meastóireacht i do CI/CD le tairseach íosta
  • Úsáid samhal níos cumasaí mar bhreitheamh chun samhal níos saoire a mheastóireacht
  • Doiciméadaigh scóir gach leagan chun éabhlóid a rianú

Tástáil do Chuid Eolais

Teicnící casta agus tionsclaíocht: an seiceáil deiridh.

1. Cad a chuimsíonn preab córais éifeachtach?

Freagra: Ról, raon feidhme, rialacha iompraíochta, formáid aschuir, agus láimhseáil cásanna imeallach—scríofa mar shonraíocht, tástáilte mar chód.

2. Cathin ba chóir duit féin-chomhsheasmhacht a úsáid?

Freagra: Ar fhadhbanna réasúnaíochta le freagraí infhíoraithe: gin roinnt réasúnuithe neamhspleácha agus coinnigh an freagra tromlaigh—éiríonn an t-athraitheacht ina chomhghuaillí.

3. Cad a ráthaíonn mód JSON le forfheidhmiú scéime?

Freagra: Aschur a chomhlíonann an scéime go docht (cineálacha, réimsí riachtanacha, eonaim)—bailíochtaithe ar thaobh an API agus athbhailíochtaithe sa chód (Scéima JSON, Zod) le haghaidh slabhra gan iontas.

4. Cad é bunú (grounding)?

Freagra: Freagraí a anchairú i bhfíricí soláthraithe (doiciméid, sonraí aisghafa) seachas cuimhne na samhla—leis an éileamh foinsí a lua nó staonadh lasmuigh díobh.

5. Cad é cuspóir catalóga preab leaganaithe?

Freagra: Chun preabanna a chóireáil mar arteafactaí: leaganacha, tástálacha A/B, meastóireachtaí uathoibrithe ar gach athrú—tá a fhios agat cad atá ag rith sa táirgeadh, agus cén fáth.

Is é an lúb dheireanach den chúrsa—leagan, tástáil, meastóireacht uathoibrithe—a chlaochlaíonn innealtóireacht phreabanna ceardaíochta ina cleachtas foirne.