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

Novērtē savus uzdevumus: metodes, vērtētāji un pāreja uz Promptfoo

Nodarbība 15 no 20 Atjaunota 2026. gada 3. novembris Augstākais
Šajā lapā
  1. Kāpēc tev ir sistemātiski jāveic novērtēšana
  2. Izveido datukopu, kas atspoguļo reālo pasauli
  3. Izvēlies pareizo vērtētāju
  4. Saliec kopā pilnu novērtējumu
  5. Industrializē ar Promptfoo
  6. 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 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"} (Responses API) vai reasoning_effort="none" (Chat Completions). Avoti: Using GPT-6 · GPT-5.6 Terra.

Atjauninājums 2026. gada 2. novembrī — 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, bet informācijas panelis un API tiks slēgti 2026. gada 30. novembrī, ieskaitot vērtētājus. 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.

Kāpēc tev ir sistemātiski jāveic novērtēšana

Tu nevari uzlabot to, ko nemēri. Kad maini uzdevumu, modeli vai parametru, kā tu zini, ka kvalitāte patiešām ir uzlabojusies? Spontānā metode ir izmēģināt trīs vai četrus piemērus, atrast labākās atbildes un veikt izvēršanu. Tas regulāri neizdodas, jo testētie piemēri ir tieši tie, kas radīja problēmas pagājušajā nedēļā: tu mēri uzlabojumus tur, kur tos meklēji, un palaid garām regresijas gadījumos, kas jau iepriekš darbojās.

Novērtējumi (evals) pārvērš šo intuīciju objektīvā mērījumā. Līdz 2026. gadam OpenAI piedāvāja tam integrētu platformu Evals; tā kopš 2026. gada 31. oktobra ir tikai lasāma un tiks slēgta 30. novembrī. OpenAI tagad iesaka Promptfoo — atvērtā koda rīku novērtēšanai un „sarkanajai komandai” (red teaming). Labā ziņa ir tā, ka abiem ir vienādi būvbloki: testa dati, uzdevumi, modeļi un vērtēšanas kritēriji. Tas, ko tu šeit apgūsti Python kodā, ir tieši pārnēsājams, un nodarbības noslēgumā parādīta pāreja uz Promptfoo.

Visu procesu strukturē trīs jēdzieni. Datukopa (dataset) ir testu gadījumu kopums ar ievades un sagaidāmajām izvades vērtībām: tā ir tava atsauce, līdzvērtīga vienību testu suite. Vērtētājs (grader) ir novērtēšanas kritērijs — precīza atbilstība, LLM kā tiesnesis, punktu skaits — kas nosaka, vai konkrēta atbilde ir laba. Izpilde (run) ir novērtējuma veikšana datukopā ar konkrētu modeli un uzdevumu; tā ir vienība, ko salīdzini no vienas versijas uz nākamo.

Izveido datukopu, kas atspoguļo reālo pasauli

Testa gadījums sastāv no ievades, sagaidāmās izvades un metadatiem. Pēdējie nav tikai dekorācija: tie ļaus tev vēlāk saprast, ka kopējais rezultāts 87% apslēpj sabrukumu kategorijā „kods”, ko kompensē izcili rezultāti ģeogrāfijā. Bez kategorijas vai grūtības pakāpes tev ir tikai apkopots skaitlis, bet apkopots skaitlis nekad nepasaka, kur iejaukties.

import json

# Datukopa ir testu gadījumu saraksts
dataset = [
    {
        "input": "What is the capital of France?",
        "expected": "Paris",
        "metadata": {"category": "geography", "difficulty": "easy"},
    },
    {
        "input": "Explain Bayes' theorem in one sentence.",
        "expected": "Bayes' theorem calculates the probability "
                    "of an event based on known conditional probabilities.",
        "metadata": {"category": "mathematics", "difficulty": "medium"},
    },
    {
        "input": "Write a Python function that reverses a list.",
        "expected": "def reverse_list(lst): return lst[::-1]",
        "metadata": {"category": "code", "difficulty": "easy"},
    },
]

# Saglabā kā JSONL
with open("eval_dataset.jsonl", "w") as f:
    for case in dataset:
        f.write(json.dumps(case, ensure_ascii=False) + "\n")

Datukopa, kas izgudrota birojā, novērtē tavu iztēli, nevis tavu lietotni. Tavi lietotāji formulē savus pieprasījumus citādāk nekā tu: drukas kļūdas, nepabeigti jautājumi, netiešs konteksts. Tādēļ labākais testu gadījumu avots ir tavi pašu ražošanas dati, ar nosacījumu, ka cilvēks apstiprina atsauces atbildes — pretējā gadījumā tu iesaldē pašreizējās kļūdas kā normu.

import openai
import random

client = openai.OpenAI()

def create_dataset_from_logs(
    production_logs: list[dict],
    sample_size: int = 100,
) -> list[dict]:
    """Izveido novērtēšanas datukopu no ražošanas žurnāliem."""
    # Parauga atlase
    sample = random.sample(
        production_logs,
        min(sample_size, len(production_logs)),
    )

    dataset = []
    for log in sample:
        dataset.append({
            "input": log["prompt"],
            "expected": log["validated_response"],  # Cilvēka apstiprināta atbilde
            "metadata": {
                "source": "production",
                "date": log["date"],
                "original_model": log["model"],
            },
        })

    return dataset

Izvēlies pareizo vērtētāju

Precīzas atbilstības vērtētājs ir visstingrākais un ātrākais. Tas ir piemērots tikai uzdevumiem, kuros izvade ir ierobežota: trīs kategoriju klasifikācija, rēķina numura izgūšana, atbilde jā/nē. Izmantojot to brīvam tekstam, tas piešķirtu nulli perfektai atbildei tikai tāpēc, ka tā ir formulēta citādāk nekā atsauce.

def exact_grader(response: str, expected: str) -> dict:
    """Novērtē, vai atbilde precīzi sakrīt."""
    score = 1.0 if response.strip().lower() == expected.strip().lower() else 0.0
    return {"score": score, "type": "exact"}

Iekļaušanas vērtētājs atslābina nosacījumu: tas pārbauda sagaidāmo atslēgvārdu klātbūtni un atgriež daļēju rezultātu. Tas ir pareizais rīks atbildēm, kurām jāaptver obligāti punkti, neatkarīgi no formulējuma — piemēram, atbalsta atbildei, kurā jāmin atsaukuma termiņš un atgriešanas adrese. Tā vājā vieta ir labi zināma: teksts, kas satur pareizos vārdus absurda secībā, saņemtu perfektu rezultātu.

def inclusion_grader(response: str, keywords: list[str]) -> dict:
    """Pārbauda, vai atbilde satur sagaidāmos atslēgvārdus."""
    response_lower = response.lower()
    found = sum(1 for word in keywords if word.lower() in response_lower)
    score = found / len(keywords) if keywords else 0.0
    return {
        "score": score,
        "found": found,
        "total": len(keywords),
        "type": "inclusion",
    }

Un tad ir visspēcīgākais: cits LLM novērtē atbildes kvalitāti. LLM-as-Judge vērtētājs novērtē to, ko neviens mehānisks noteikums nevar — skaidrību, pilnīgumu, tonalitātes precizitāti. Divas īstenošanas detaļas padara to praktisku. Pirmkārt, temperature=0.0: bez tā viens un tas pats tiesnesis vienai un tai pašai atbildei dažādās izpildēs piešķirtu dažādus rezultātus, un tavs etalons zaudētu visu salīdzinošo vērtību. Otrkārt, rezerves risinājums priekš json.JSONDecodeError: tiesnesim, kas komentē, nevis atgriež JSON, nevajadzētu sabojāt visu kampaņu.

def llm_judge_grader(
    question: str,
    response: str,
    expected: str,
    criteria: str = "accuracy, completeness, clarity",
) -> dict:
    """Izmanto LLM, lai novērtētu atbildes kvalitāti."""
    judge_prompt = f"""Rate the quality of this response on a scale of 1 to 5.

Question: {question}
Expected Response: {expected}
Response to Evaluate: {response}

Criteria: {criteria}

Respond ONLY with JSON:
{{"score": <1-5>, "justification": "<short explanation>"}}"""

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

    import json
    try:
        result = json.loads(response_obj.output_text)
        result["normalized_score"] = result["score"] / 5.0
        return result
    except json.JSONDecodeError:
        return {"score": 0, "justification": "Parsing error", "normalized_score": 0}

Saliec kopā pilnu novērtējumu

Orķestrēšana nerada konceptuālas grūtības: tu iterē cauri datukopai, izsauc modeli ar sistēmas uzdevumu testēšanai, pielieto vērtētāju un apkopo rezultātus. Interesanti ir tas, ka vērtēšanas funkcija nāk kā parametrs, kas ļauj atkārtoti izpildīt tieši to pašu datukopu ar dažādiem kritērijiem atkarībā no kampaņas — iekļaušana ātrai pārbaudei izstrādes laikā, LLM tiesnesis validācijai pirms ražošanas.

async def run_eval(
    dataset: list[dict],
    model: str,
    system_prompt: str,
    grader_fn,
) -> dict:
    """Veic pilnu novērtējumu datukopai."""
    results = []

    for case in dataset:
        response = client.responses.create(
            model=model,
            instructions=system_prompt,
            input=case["input"],
        )

        score = grader_fn(response.output_text, case["expected"])
        results.append({
            "input": case["input"],
            "expected": case["expected"],
            "obtained": response.output_text,
            **score,
        })

    # Aprēķina apkopotos rādītājus
    scores = [r["score"] for r in results if "score" in r]
    return {
        "model": model,
        "num_cases": len(dataset),
        "average_score": sum(scores) / len(scores) if scores else 0,
        "min_score": min(scores) if scores else 0,
        "max_score": max(scores) if scores else 0,
        "results": results,
    }

Ziņojumā tiek saglabāts min_score un katra gadījuma detaļas, un tas ir apzināti. Vidējais rādītājs pastāsta, vai virzies uz priekšu; sliktāk novērtētie gadījumi pastāsta, kāpēc. Pieradini sevi pirms komentāru rakstīšanas par vidējo rādītāju izlasīt piecas sliktākās atbildes no katras izpildes: tieši tur, un reti kur citur, atradīsi nākamo labojumu, kas veicams.

Industrializē ar Promptfoo

Savu novērtējumu rakstīšana ar roku Python valodā ir izglītojoša; to uzturēšana laika gaitā ir ērtāka ar specializētu rīku. OpenAI migrācijas ceļvedis apraksta Promptfoo loģiku: novērtējums dzīvo konfigurācijas failā promptfooconfig.yaml, kas apvieno uzdevumus, modeli(-us), testu gadījumus un kritērijus — šeit tos sauc par asercijām. Tas tiek palaists no komandrindas, lokāli vai nepārtrauktās integrācijas vidē, un dzīvo līdzās lietotnes kodam.

description: Support ticket classification
prompts:
  - "Classify this ticket into a single category (billing, technical, account): {{ticket}}"
providers:
  - openai:gpt-6.1-sol
tests:
  - vars:
      ticket: "My card was charged twice this month."
    assert:
      - type: icontains
        value: billing
  - vars:
      ticket: "The app crashes when I open a PDF."
    assert:
      - type: icontains
        value: technical
promptfoo eval -c promptfooconfig.yaml --no-cache
promptfoo view
promptfoo validate config -c promptfooconfig.yaml   # konfigurācijas kļūdas gadījumā

Šīs nodarbības vērtētāji atgriežas kā asercijas: precīza atbilstība, atslēgvārdu iekļaušana un modeļa spriedums. OpenAI brīdina par pēdējo punktu: atjaunots vērtētājs, it īpaši LLM tiesnesis, ir jāvalidē vēlreiz, pirms to izmanto lēmuma pieņemšanai par regresiju, jo rezultāti no viena rīka uz citu nebūs obligāti identiski.

Galvenās atziņas

  • Novērtējumi pārvērš intuīciju objektīvā kvalitātes mērījumā
  • Izveido savas datukopas no reāliem ražošanas gadījumiem, ko apstiprinājis cilvēks
  • Izvēlies vērtētāju atkarībā no uzdevuma: precīzu ierobežotiem, iekļaušanu obligātiem punktiem, LLM-as-Judge niansēm
  • Iestati temperature=0.0 tiesnesim, lai rezultāti būtu reproducējami
  • Veic novērtējumus pirms katras uzdevuma vai modeļa maiņas
  • OpenAI Evals platforma tiek slēgta 2026. gada 30. novembrī: Promptfoo, ko iesaka OpenAI, pārņem datukopas, uzdevumus, modeļus un kritērijus konfigurācijas failā