Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Izveido pielāgotus novērtējumus

Nodarbība 16 no 20 Atjaunota 2026. gada 3. novembris Augstākais
Šajā lapā
  1. Pielāgo novērtējumus savai nozarei
  2. Pārvērt biznesa prasību vērtēšanas skalā
  3. Kad mašīna vērtē labāk nekā cilvēks
  4. Padari novērtēšanu atkārtojamu
  5. Galvenās atziņas

Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri temperature un top_p tiek pieņemti tikai ar spriešanas piepūli (reasoning effort) vērtībā none, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tādēļ izsaukumos, kuros iestatīti šie parametri, ir jānorāda reasoning={"effort": "none"} (API Responses) vai reasoning_effort="none" (Chat Completions). Avoti: Using GPT-6 · GPT-5.6 Terra.

2026. gada 2. novembra atjauninājums — Evals platforma. OpenAI ir paziņojusi par savas Evals platformas darbības izbeigšanu: esošie novērtējumi kopš 2026. gada 31. oktobra ir tikai lasāmi, un gan informācijas panelis, gan API, ieskaitot vērtētājus, tiks slēgti 2026. gada 30. novembrī. OpenAI ir publicējusi migrācijas ceļvedi uz Promptfoo. Šajā nodarbībā aplūkotie novērtēšanas principi paliek spēkā; mainās tikai rīks.

Pielāgo novērtējumus savai nozarei

Vispārīgi vērtētāji nav pietiekami, lai novērtētu kvalitāti tavā konkrētajā nozarē. Medicīnas čatbotam, juridiskajam asistentam un mārketinga rakstīšanas rīkam ir dažādi kvalitātes kritēriji, un šie kritēriji nav tikai skaitliski lielāki — tie ir dažādi prioritizēti. Tonālās neatbilstības gadījums informatīvajā vēstulē ir kaitinošs; tāda pati neprecizitāte devas instrukcijās ir nopietna kļūda. Vispārīgs vērtētājs abus gadījumus aplūko vienādi, kas faktiski nozīmē, ka netiek novērtēts nekas.

Tieši tāpēc tev ir nepieciešami pielāgoti novērtējumi, kas balstīti uz skaidru vērtēšanas skalas (rubric) sistēmu, kura pārvērš tavas biznesa prioritātes svaros. Tieši tādu skalas sistēmu mēs tagad izveidosim.

Pārvērt biznesa prasību vērtēšanas skalā

Vērtēšanas skala ir svērto kritēriju saraksts, kuru summa ir 1. Noderīgākais uzdevums nav koda struktūras programmēšana, kas aizņem aptuveni piecpadsmit rindiņas, bet gan tās aizpildīšana: lēmuma pieņemšana, ka klientu ieguvumiem ir svars 0,25, bet garumam tikai 0,10, piespiež tevi vest skaidru sarunu ar produkta īpašniekiem. Rezultātā tu iegūsti kopīgu „labas atbildes” definīciju, par kuru neviens vēlāk nevarēs strīdēties.

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),
    ],
)

Metode valider ir pelnījusi, lai to izsauktu testos, nevis tikai uzrakstītu. Vērtēšanas skalas evolucionē: tu pievieno atbilstības kritēriju, noņem tādu, kas vairs nav noderīgs, un summa nobīdās uz 1,15, bet nekas nenorāda uz anomāliju. Rezultāti joprojām ir aprēķināmi, tikai nepareizi, un, salīdzinot tos starp versijām, tie novedīs pie kļūdainiem secinājumiem.

Vērtētājs pēc tam pārvērš vērtēšanas skalu promptā, pieprasa 0–5 ballu vērtējumu katram kritērijam un apkopo svērto globālo rezultātu. Katram vērtējumam pievienots īss komentārs: tieši tas ļaus tev, pārskatot sliktos gadījumus, saprast, vai modelis ir sniedzis sliktu atbildi, vai arī tavs kritērijs bija slikti formulēts.

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é"}

Uzmanies ar aprēķinu ciklu: ja tiesneša atbildē trūkst kāds kritērijs, tas tiek klusi ignorēts un dod nuldi svērtajam rezultātam. Lieliska atbilde tādējādi varētu sasniegt maksimāli 0,75 vienkārši tāpēc, ka tiesnesis ir aizmirsis kādu atslēgu. Ja tavi rezultāti šķiet iestrēguši zem neizskaidrojama griesta, pirms vaino novērtēto modeli, pārbaudi scores_details.

Kad mašīna vērtē labāk nekā cilvēks

LLM izmantot koda vērtēšanai ir dārgs īsceļš: vienīgais spriedums, kam ir nozīme, ir izpilde. Tālāk redzamais vērtētājs apvieno ģenerēto kodu un testu, ieraksta to pagaidu failā, izpilda to un saskaita veiksmīgās izpildes. Iegūtajam rezultātam nav nepieciešama interpretācija — tests vai nu izdodas, vai ne.

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,
    }

Iestatījums timeout=10 nav tikai drošības pasākums: modeļi regulāri ģenerē bezgalīgus ciklus, un bez šī ierobežojuma tava novērtēšanas kampaņa iestrēgs pie pirmā neizdevušā gadījuma. Atceries arī, ka tu izpildi kodu, ko neesi rakstījis pats — ārpus izolētas izstrādes vides šī funkcija prasa smilškasti (sandbox).

Kopsavilkums ilustrē jauktu gadījumu, kur daļa vērtējuma ir mehāniska, bet daļa nav. Garums ir izmērāms: aprēķinātais attiecības rādītājs sodīs gan pārāk īsu, gan pārāk garu kopsavilkumu simetriski, kas novērš modeļa triku nokopēt avota tekstu, lai neko neizlaistu. Savukārt uzticamību nevar izmērīt ar likumu, un tā atgriežas pie LLM tiesneša ar tiešu jautājumu par izgudrotu informāciju.

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,
    }

Padari novērtēšanu atkārtojamu

Novērtējums, ko atkārto manuāli, galu galā pārstās tikt atkārtots. Konveijers (pipeline) kapsulē vērtēšanas skalu un glabā kampaņu vēsturi, pārvēršot vienreizēju mērījumu laika rindā: tu redzi, ka vidējais rezultāts ir krities no 0,81 uz 0,79 pēc otrdienas prompta izmaiņām — informācija, ko neviens izolēts izpildījums tev nevarētu sniegt.

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

Viens padoms, lai sāktu: izveido savu pirmo vērtēšanas skalu, balstoties tikai uz divdesmit gadījumiem, liec to vērtēt paralēli gan LLM tiesnesim, gan nozares ekspertam, un pēc tam salīdzini abas rindas. Atšķirības tev pateiks, kuri kritēriji ir slikti aprakstīti, ilgi pirms tās tev pastāstīs kaut ko par modeļa kvalitāti.

Galvenās atziņas

  • Izveido vērtēšanas skalas, kas specifiskas tavai biznesa nozarei, ar skaidriem svariem
  • Pārliecinies, ka svaru summa paliek 1, kamēr vērtēšanas skala attīstās
  • Apvieno automatizētu novērtēšanu (kods, garums) un LLM-as-Judge (kvalitāte)
  • Testē ģenerēto kodu, to izpildot, ar noilgumu un izolētā vidē
  • Izveido atkārtoti izmantojamu konveijeru, kas glabā kampaņu vēsturi