Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Δημιουργία Προσαρμοσμένων Αξιολογήσεων

Μάθημα 16 / 20 Ενημερώθηκε 3 Νοεμβρίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Προσαρμογή των αξιολογήσεων στον τομέα σας
  2. Μετάφραση μιας επιχειρηματικής απαίτησης σε ρουμπρίκα
  3. Όταν το μηχάνημα κρίνει καλύτερα από τον άνθρωπο
  4. Κάντε την αξιολόγηση επαναλήψιμη
  5. Βασικά σημεία

Το μάθημα ενημερώθηκε στις 3 Νοεμβρίου 2026 με βάση την τεκμηρίωση της OpenAI: οι παράμετροι temperature και top_p γίνονται δεκτές μόνο με προσπάθεια συλλογισμού (reasoning effort) ίση με none, ενώ τα μοντέλα GPT-5.6 συλλογίζονται από προεπιλογή (medium). Επομένως, οι κλήσεις που ορίζουν αυτές τις παραμέτρους πρέπει να καθορίζουν reasoning={"effort": "none"} (API Responses) ή reasoning_effort="none" (Chat Completions). Πηγές: Χρήση του GPT-6 · GPT-5.6 Terra.

Ενημέρωση 2 Νοεμβρίου 2026 — Πλατφόρμα Evals. Η OpenAI ανακοίνωσε το τέλος της πλατφόρμας Evals: οι υπάρχουσες αξιολογήσεις είναι σε λειτουργία μόνο ανάγνωσης από τις 31 Οκτωβρίου 2026, και τόσο ο πίνακας ελέγχου (dashboard) όσο και το API, συμπεριλαμβανομένων των βαθμολογητών (graders), θα κλείσουν στις 30 Νοεμβρίου 2026. Η OpenAI έχει δημοσιεύσει έναν οδηγό μετάβασης στο Promptfoo. Οι αρχές αξιολόγησης σε αυτό το μάθημα παραμένουν έγκυρες· αλλάζει μόνο το εργαλείο.

Προσαρμογή των αξιολογήσεων στον τομέα σας

Οι γενικοί βαθμολογητές δεν αρκούν για την αξιολόγηση της ποιότητας στον συγκεκριμένο τομέα σας. Ένα ιατρικό chatbot, ένας νομικός βοηθός και ένα εργαλείο συγγραφής μάρκετινγκ έχουν διαφορετικά κριτήρια ποιότητας, και αυτά τα κριτήρια δεν είναι απλώς πιο πολυάριθμα—είναι ιεραρχημένα διαφορετικά. Μια ασυμφωνία στο ύφος σε ένα newsletter είναι μια ενόχληση· η ίδια κατά προσέγγιση διατύπωση σε οδηγίες δοσολογίας είναι ένα σοβαρό σφάλμα. Ένας γενικός βαθμολογητής αντιμετωπίζει και τα δύο με τον ίδιο τρόπο, κάτι που ισοδυναμεί με το να μην αξιολογεί τίποτα απολύτως.

Γι’ αυτό χρειάζεστε προσαρμοσμένες αξιολογήσεις βασισμένες σε μια ρητή ρουμπρίκα (rubric) που μεταφράζει τις επιχειρηματικές σας προτεραιότητες σε βάρη. Αυτή είναι η ρουμπρίκα που θα κατασκευάσουμε.

Μετάφραση μιας επιχειρηματικής απαίτησης σε ρουμπρίκα

Μια ρουμπρίκα είναι μια λίστα σταθμισμένων κριτηρίων που αθροίζουν στο 1. Η πιο χρήσιμη άσκηση δεν είναι η κωδικοποίηση της δομής, η οποία παίρνει περίπου δεκαπέντε γραμμές, αλλά η συμπλήρωσή της: η απόφαση ότι τα οφέλη για τον πελάτη ζυγίζουν 0,25 ενώ το μήκος ζυγίζει μόνο 0,10 επιβάλλει μια ρητή συζήτηση με τους υπεύθυνους προϊόντος. Αυτό που τελικά προκύπτει είναι ένας κοινός ορισμός του «μιας καλής απάντησης» τον οποίο κανείς δεν μπορεί να αμφισβητήσει εκ των υστέρων.

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

Η μέθοδος valider αξίζει να καλείται στις δοκιμές, όχι απλώς να γράφεται. Οι ρουμπρίκες εξελίσσονται: προσθέτετε ένα κριτήριο συμμόρφωσης, αφαιρείτε ένα που δεν είναι πλέον χρήσιμο, και το άθροισμα αποκλίνει στο 1,15 χωρίς τίποτα να επισημαίνει την ανωμαλία. Οι βαθμολογίες παραμένουν υπολογίσιμες, απλώς λανθασμένες, και όταν συγκρίνονται μεταξύ εκδόσεων θα σας οδηγήσουν σε εσφαλμένα συμπεράσματα.

Ο βαθμολογητής μεταφράζει στη συνέχεια τη ρουμπρίκα σε ένα prompt, ζητά μια βαθμολογία 0–5 ανά κριτήριο και ανασυνθέτει μια σταθμισμένη συνολική βαθμολογία. Κάθε βαθμολογία συνοδεύεται από ένα σύντομο σχόλιο: αυτό είναι που θα σας επιτρέψει, όταν αναθεωρείτε κακές περιπτώσεις, να κατανοήσετε αν το μοντέλο απάντησε poorly ή αν το κριτήριό σας ήταν κακοδιατυπωμένο.

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

Προσοχή στον βρόχο υπολογισμού: ένα κριτήριο που λείπει από την απάντηση του κριτή αγνοείται σιωπηρά και συμβάλλει με μηδέν στη σταθμισμένη βαθμολογία. Μια εξαιρετική απάντηση θα μπορούσε επομένως να περιοριστεί στο 0,75 απλώς επειδή ο κριτής ξέχασε ένα κλειδί. Αν οι βαθμολογίες σας φαίνεται να έχουν κολλήσει κάτω από ένα ανεξήγητο ανώτατο όριο, επιθεωρήστε το scores_details πριν κατηγορήσετε το αξιολογούμενο μοντέλο.

Όταν το μηχάνημα κρίνει καλύτερα από τον άνθρωπο

Το να αναθέτετε σε ένα LLM να βαθμολογεί κώδικα είναι μια δαπανηρή συντόμευση: η μόνη ετυμηγορία που μετράει είναι η εκτέλεση. Ο παρακάτω βαθμολογητής συγχωνεύει τον παραγόμενο κώδικα και μια δοκιμή, τον γράφει σε ένα προσωρινό αρχείο, τον εκτελεί και μετρά τις επιτυχίες. Η προκύπτουσα βαθμολογία δεν χρειάζεται ερμηνεία—μια δοκιμή είτε περνάει είτε όχι.

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

Το timeout=10 δεν είναι ένα μέτρο άνεσης: ένα μοντέλο παράγει τακτικά ατέρμονους βρόχους, και χωρίς αυτό το όριο η εκστρατεία αξιολόγησής σας θα κολλήσει στην πρώτη αποτυχημένη περίπτωση. Θυμηθείτε επίσης ότι εκτελείτε κώδικα που δεν γράψατε εσείς—εκτός από ένα απομονωμένο περιβάλλον ανάπτυξης, αυτή η συνάρτηση απαιτεί ένα sandbox.

Η σύνοψη illustrates μια μικτή περίπτωση, όπου μέρος της κρίσης είναι μηχανικό και μέρος όχι. Το μήκος είναι μετρήσιμο: ο υπολογισμένος λόγος penalizes μια σύνοψη που είναι πολύ μικρή και μια που είναι πολύ μεγάλη συμμετρικά, κάτι που αποφεύγει το κόλπο του μοντέλου να αντιγράφει το πηγαίο κείμενο για να μην παραλείψει τίποτα. Η πιστότητα, από την άλλη πλευρά, δεν είναι μετρήσιμη από έναν κανόνα και επιστρέφει στον κριτή LLM, με μια άμεση ερώτηση για εφευρεμένες πληροφορίες.

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

Κάντε την αξιολόγηση επαναλήψιμη

Μια αξιολόγηση που την επαναλαμβάνετε χειροκίνητα τελικά παύει να επαναλαμβάνεται. Ο αγωγός (pipeline) encapsulates τη ρουμπρίκα και διατηρεί ένα ιστορικό εκστρατειών, μετατρέποντας μια εφάπαξ μέτρηση σε μια χρονοσειρά: βλέπετε ότι η μέση βαθμολογία έπεσε από 0,81 σε 0,79 μετά την αλλαγή του prompt της Τρίτης, πληροφορία που καμία μεμονωμένη εκτέλεση δεν θα μπορούσε να σας δώσει.

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

Μια συμβουλή για να ξεκινήσετε: χτίστε την πρώτη σας ρουμπρίκα σε μόλις είκοσι περιπτώσεις, ζητήστε να βαθμολογηθούν παράλληλα από τον κριτή LLM και από έναν ειδικό του τομέα, και στη συνέχεια συγκρίνετε τις δύο σειρές. Οι αποκλίσεις θα σας πουν ποια κριτήρια περιγράφονται poorly πολύ πριν σας πουν οτιδήποτε για την ποιότητα του μοντέλου.

Βασικά σημεία

  • Δημιουργήστε ρουμπρίκες αξιολόγησης ειδικές για τον επιχειρηματικό σας τομέα, με ρητά βάρη
  • Επαληθεύστε ότι το άθροισμα των βαρών παραμένει στο 1 καθώς η ρουμπρίκα εξελίσσεται
  • Συνδυάστε την αυτοματοποιημένη αξιολόγηση (κώδικας, μήκος) και το LLM-as-Judge (ποιότητα)
  • Δοκιμάστε τον παραγόμενο κώδικα εκτελώντας τον, με χρονικό όριο (timeout) και σε απομονωμένο περιβάλλον
  • Κατασκευάστε έναν επαναχρησιμοποιήσιμο αγωγό (pipeline) που διατηρεί ένα ιστορικό εκστρατειών