Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Luo mukautettuja arviointeja

Oppitunti 16 / 20 Päivitetty 3. marraskuuta 2026 Edistynyt
Tällä sivulla
  1. Räätälöi arvioinnit toimialallesi
  2. Käännä liiketoimintavaatimus arvostelumalliksi
  3. Milloin kone arvostelee paremmin kuin ihminen
  4. Tee arvioinnista toistettava
  5. Keskeiset asiat

Oppitunti päivitetty 3. marraskuuta 2026 OpenAI:n dokumentaation perusteella: temperature ja top_p hyväksytään vain, kun päättelypyrkimys on none, kun taas GPT-5.6-mallit päättelevät oletusarvoisesti (medium). Näitä parametreja asettavien kutsujen on siksi määritettävä reasoning={"effort": "none"} (API Responses) tai reasoning_effort="none" (Chat Completions). Lähteet: Using GPT-6 · GPT-5.6 Terra.

2. marraskuuta 2026 päivitys — Evals-alusta. OpenAI on ilmoittanut lopettavansa Evals-alustansa: olemassa olevat arvioinnit ovat olleet vain luku -tilassa 31. lokakuuta 2026 lähtien, ja sekä kojetaulu että API, arvostelijat mukaan lukien, suljetaan 30. marraskuuta 2026. OpenAI on julkaissut siirtymäoppaan Promptfoo:hon. Tämän oppitunnin arviointiperiaatteet pysyvät voimassa; vain työkalu muuttuu.

Räätälöi arvioinnit toimialallesi

Yleiskäyttöiset arvostelijat eivät riitä laadun arvioimiseen tietyllä toimialallasi. Lääketieteellisellä chatbotilla, lakiasiantuntijalla ja markkinointityökalulla on kaikilla erilaiset laatukriteerit, eikä ero ole vain kriteerien määrässä, vaan niiden priorisoinnissa. Sävyvirhe uutiskirjeessä on harmistus; sama epätarkkuus annostusohjeissa on vakava virhe. Yleiskäyttöinen arvostelija kohtelee molempia samalla tavalla, mikä tarkoittaa käytännössä sitä, ettei mitään arvioida lainkaan.

Siksi tarvitset mukautettuja arviointeja, jotka perustuvat eksplisiittiseen arvostelumalliin (rubric), joka muuntaa liiketoimintaprioriteettisi painoarvoiksi. Juuri sellaisen arvostelumallin rakennamme nyt.

Käännä liiketoimintavaatimus arvostelumalliksi

Arvostelumalli on luettelo painotetuista kriteereistä, joiden summa on 1. Hyödyllisin vaihe ei ole rakenteen koodaaminen, mikä vie noin viisitoista riviä, vaan sen täyttäminen: päätös, että asiakasedut painavat 0,25 ja pituus vain 0,10, pakottaa käymään eksplisiittisen keskustelun tuoteomistajien kanssa. Lopputuloksena on yhteinen määritelmä sille, mikä on “hyvä vastaus”, jota kukaan ei voi kiistää jälkikäteen.

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

Metodia valider kannattaa kutsua testeissä, eikä sitä pitäisi vain kirjoittaa. Arvostelumallit kehittyvät: lisäät vaatimustenmukaisuuskriteerin, poistat hyödyttömäksi käyneen kriteerin, ja summa lipuu arvoon 1,15 ilman, että mikään ilmoittaa poikkeamasta. Pisteet ovat edelleen laskettavissa, mutta ne ovat väärin, ja eri versioiden välillä vertailtaessa ne johtavat virheellisiin johtopäätöksiin.

Arvostelija kääntää sitten arvostelumallin kehotteeksi, pyytää 0–5 pistettä kullekin kriteerille ja muodostaa painotetun kokonaispistemäärän. Jokaisen pisteytyksen yhteydessä on lyhyt kommentti: tämän avulla voit tarkastellessasi huonoja tapauksia ymmärtää, oliko mallin vastaus huono vai oliko kriteerisi muotoilu epäselvä.

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

Varo laskentasilmukkaa: tuomarin vastauksesta puuttuva kriteeri jätetään hiljaisesti huomiotta ja se vaikuttaa painotettuun pisteeseen nollana. Erinomainen vastaus voi siis jäädä maksimissaan arvoon 0,75 pelkästään siksi, että tuomari unohti avaimen. Jos pisteesi näyttävät jumittuvan selittämättömän katon alle, tarkista scores_details ennen kuin syytät arvioitavaa mallia.

Milloin kone arvostelee paremmin kuin ihminen

LLM:n käyttäminen koodin arvosteluun on kallis oikotie: ainoa merkitsevä tuomio on suoritus. Alla oleva arvostelija yhdistää generoidun koodin ja testin, kirjoittaa ne väliaikaistiedostoon, suorittaa sen ja laskee onnistumiset. Tuloksena saatavaa pistemäärää ei tarvitse tulkita – testi joko läpäistään tai ei.

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

Asetus timeout=10 ei ole vain varotoimi: malli tuottaa säännöllisesti äärettömiä silmukoita, ja ilman tätä rajaa arviointikampanjasi jumittuu ensimmäiseen epäonnistuneeseen tapaukseen. Muista myös, että suoritat koodia, jota et ole kirjoittanut itse – eristetyssä kehitysympäristössä tämän funktion käyttö vaatii hiekkalaatikon (sandbox).

Yhteenveto havainnollistaa sekalaista tapausta, jossa osa arvioinnista on mekaanista ja osa ei. Pituus on mitattavissa: laskettu suhde rankaisee symmetrisesti sekä liian lyhyttä että liian pitkää yhteenvetoa, mikä estää mallia kikkailemasta kopioimalla lähdetekstin jättämättä mitään pois. Uskollisuutta ei sen sijaan voi mitata säännöllä, vaan se palautuu LLM-tuomarille suoralla kysymyksellä keksitystä informaatiosta.

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

Tee arvioinnista toistettava

Arviointi, jonka suoritat manuaalisesti uudelleen, lopulta jää tekemättä. Putkisto kapseloi arvostelumallin ja pitää yllä historiaa kampanjoista, muuttaen kertaluonteisen mittauksen aikasarjaksi: näet, että keskipisteet laskivat arvosta 0,81 arvoon 0,79 tiistain kehotemuutoksen jälkeen – tietoa, jota yksittäinen suoritus ei olisi voinut antaa.

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

Vinkki aloittamiseen: rakenna ensimmäinen arvostelumallisi vain kahdenkymmenen tapauksen pohjalta, pyydä LLM-tuomaria ja alaan erikoistunutta asiantuntijaa pisteyttämään ne rinnakkain ja vertaa sitten kahta sarjaa. Erot kertovat sinulle, mitkä kriteerit on kuvattu huonosti, kauan ennen kuin ne kertovat mitään mallin laadusta.

Keskeiset asiat

  • Luo liiketoimintaasi specifit arviointimallit eksplisiittisine painoarvoineen
  • Varmista, että painoarvojen summa pysyy arvossa 1 arvostelumallin kehittyessä
  • Yhdistä automatisoitu arviointi (koodi, pituus) ja LLM-as-Judge (laatu)
  • Testaa generoitua koodia suorittamalla se aikakatkaisulla ja eristetyssä ympäristössä
  • Rakenna uudelleenkäytettävä putkisto, joka pitää yllä historiaa kampanjoista