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

Αυτοματοποιημένη Αξιολόγηση Prompts

Μάθημα 16 / 16 Ενημερώθηκε 3 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Αυτοματοποιημένη Αξιολόγηση Prompts
  2. Τύποι Αξιολόγησης
  3. Πλήρης Διαδικασία Αξιολόγησης (Pipeline)
  4. Σουίτα Δοκιμών: Μορφή
  5. Ενσωμάτωση CI/CD
  6. Πίνακας Ελέγχου Αξιολόγησης
  7. Ρυθμίστε τις Δικλείδες Ασφαλείας σας
  8. Βασικά σημεία
  9. Δοκιμάστε τις Γνώσεις σας

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

Αυτοματοποιημένη Αξιολόγηση Prompts

Η αυτοματοποιημένη αξιολόγηση αποτελεί τον ακρογωνιαίο λίθο μιας ώριμης διαδικασίας μηχανικής prompts. Σάς επιτρέπει να εντοπίζετε υποχωρήσεις (regressions), να συγκρίνετε μοντέλα και να επικυρώνετε αλλαγές πριν την ανάπτυξη. Χωρίς αυτήν, κάθε αλλαγή σε ένα prompt είναι ένα τυφλό ρίσκο.

Τύποι Αξιολόγησης

Τρεις οικογένειες αξιολογητών κατανέμουν το έργο ανάλογα με τη φύση της αναμενόμενης εξόδου και σχεδόν πάντα θα συνδυάζετε πολλούς από αυτούς.

Αξιολόγηση Ακριβούς Ταύτισης (Exact Match)

Για εργασίες με μία μόνο αναμενόμενη απάντηση, αρκεί η άμεση σύγκριση. Η συνάρτηση eval_exact_match κανονικοποιεί τα πεζά/κεφαλαία και τα κενά πριν τη σύγκριση: χωρίς αυτή την προφύλαξη, το “Bug” και το “bug” θα μετρούσαν ως σφάλμα, στέλνοντάς σας να διορθώσετε ένα πρόβλημα που δεν υπάρχει.

Η συνάρτηση eval_set_match διαχειρίζεται περιπτώσεις όπου η απάντηση είναι ένα σύνολο—οντότητες που βρέθηκαν σε ένα έγγραφο, κατηγορίες που αποδόθηκαν σε ένα άρθρο. Εξάγει την ακρίβεια (precision) και την ανάκληση (recall), δύο μεγέθη που αφηγούνται διαφορετικές ιστορίες: υψηλή ακρίβεια με χαμηλή ανάκληση σηματοδοτεί ένα υπερβολικά προσεκτικό μοντέλο που εξάγει μόνο ό,τι είναι σίγουρο· το αντίστροφο προδίδει ένα μοντέλο που παραισθάνεται (hallucinates) για να καλύψει κενά. Το F1 τα συνοψίζει βολικά, αλλά δεν τα αντικαθιστά για τη διάγνωση.

def eval_exact_match(prediction: str, reference: str) -> bool:
    """Exact match after normalization."""
    return prediction.strip().lower() == reference.strip().lower()

def eval_set_match(prediction: set, reference: set) -> dict:
    """Set match (entities, categories)."""
    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}

Σημασιολογική Αξιολόγηση (Embedding)

Για κειμενικές απαντήσεις όπου η διατύπωση μπορεί να ποικίλλει, η ακριβής ταύτιση γίνεται παράλογη: το «Η παραγγελία σας θα παραδοθεί αύριο» και το «Η παράδοση έχει προγραμματιστεί για αύριο» λένε το ίδιο πράγμα, ωστόσο θα βαθμολογούνταν με μηδέν. Η συνημιτονοειδής ομοιότητα (cosine similarity) μεταξύ των ενσωματώσεων (embeddings) μετρά τη σημασιολογική εγγύτητα αντί για την αντιστοιχία χαρακτήρων, επιστρέφοντας μια συνεχή βαθμολογία.

Ορίζετε το κατώφλι πάνω από το οποίο μια απάντηση θεωρείται αποδεκτή. Βαθμονομήστε το σε μερικές δεκάδες ζεύγη που έχετε ταξινομήσει χειροκίνητα ως «ισοδύναμα» ή «διαφορετικά» και, στη συνέχεια, επιλέξτε την τιμή που διαχωρίζει καλύτερα τις δύο ομάδες: ένα κατώφλι επιλεγμένο με βάση την διαίσθηση παράγει αποτελέσματα τόσο αυθαίρετα όσο και η απουσία μέτρησης, με την επιπλέον ψευδαίσθηση του rigor.

from openai import OpenAI
import numpy as np

client = OpenAI()

def eval_semantic_similarity(prediction: str,
                              reference: str) -> float:
    """Cosine similarity between embeddings."""
    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

Αξιολόγηση από LLM (LLM-as-Judge)

Το μοντέλο αξιολογεί την ποιότητα μιας απάντησης. Αυτή είναι η μόνη βιώσιμη προσέγγιση όταν δεν υπάρχει αναφορά: κανείς δεν θα γράψει χειροκίνητα τη «σωστή» απάντηση υποστήριξης για διακόσια εισιτήρια.

Το τι καθιστά έναν κριτή χρησιμοποιήσιμο ανάγεται σε μερικά πράγματα. Πρώτον, το μοντέλο που χρησιμοποιείται: επιλέγετε ένα πιο ικανό μοντέλο ως κριτή, εδώ το gpt-5.6-sol, επειδή ένας κριτής στο ίδιο επίπεδο με τον αξιολογούμενο τείνει να επικυρώνει τα δικά του ελαττώματα. Δεύτερον, η απαίτηση αιτιολόγησης: η τεκμηρίωση κάθε βαθμολογίας σταθεροποιεί την κρίση και σάς επιτρέπει να εντοπίσετε έναν αξιολογητή που χρησιμοποιεί λάθος κριτήριο—μια αιτιολόγηση που συζητά το μήκος όταν το κριτήριο ήταν η σαφήνεια αποτελεί κόκκινη σημαία. Τέλος, το temperature στο 0.1 εξασφαλίζει σταθερότητα της βαθμολογίας μεταξύ των εκτελέσεων.

def eval_llm_judge(question: str, prediction: str,
                    criteria: list[str]) -> dict:
    """Evaluation by a judge model."""
    criteria_text = "\n".join(
        f"- {c}: score from 1 to 5" for c in criteria
    )

    response = client.responses.create(
        model="gpt-5.6-sol",  # More capable model as judge
        reasoning={"effort": "none"},  # temperature requires effort none
        instructions="You are an expert, impartial evaluator.",
        input=f"""Evaluate this response according to the following criteria:

Question asked: {question}

Response to evaluate: {prediction}

Criteria:
{criteria_text}

For each criterion, give a score from 1 to 5 with justification.""",
        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)

Πλήρης Διαδικασία Αξιολόγησης (Pipeline)

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

Η μέθοδος summary επίσης συσσωρεύει τα καταναλωθέντα tokens. Αυτή η φαινομενικά δευτερεύουσα γραμμή σάς προστατεύει από μια κοινή παγίδα: μια έκδοση prompt που κερδίζει δύο βαθμούς ενώ τριπλασιάζει το κόστος δεν είναι απαραίτητα η σωστή επιλογή και είναι καλύτερα να το μάθετε τη στιγμή της διαπραγμάτευσης (trade-off) παρά όταν φτάσει ο μηνιαίος λογαριασμός.

import json
from dataclasses import dataclass
from pathlib import Path

@dataclass
class TestCase:
    """A test case for evaluation."""
    input_text: str
    expected_output: str = None
    metadata: dict = None

class EvalPipeline:
    """Automated evaluation pipeline."""

    def __init__(self, test_suite_path: str):
        """Loads the test suite from a JSON file."""
        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:
        """Runs all tests and evaluates results."""
        self.results = []

        for tc in self.test_cases:
            # Generate response
            response = client.responses.create(
                model=prompt_config["model"],
                reasoning={"effort": "none"},  # temperature requires effort none
                instructions=prompt_config["system_prompt"],
                input=tc.input_text,
                temperature=prompt_config.get("temperature", 0.1)
            )

            prediction = response.output_text

            # Evaluate with each evaluator
            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:
        """Summarizes evaluation results."""
        if not self.results:
            return {"error": "No results"}

        # Aggregate scores by evaluator
        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

Σουίτα Δοκιμών: Μορφή

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

[
    {
        "input_text": "My package hasn't arrived",
        "expected_output": "complaint",
        "metadata": {"category": "delivery"}
    },
    {
        "input_text": "How do I enable dark mode?",
        "expected_output": "question",
        "metadata": {"category": "feature"}
    },
    {
        "input_text": "The app crashes on startup on iOS 18",
        "expected_output": "bug",
        "metadata": {"category": "technical"}
    }
]

Ενσωμάτωση CI/CD

Εκτελέστε την αξιολόγηση σε κάθε αλλαγή prompt. Η συνάρτηση ci_eval_check μετατρέπει τη μέτρηση σε δικλείδα ασφαλείας: εκτελεί τη διαδικασία, συγκρίνει τη μέση βαθμολογία με ένα κατώφλι και επιστρέφει μια boolean τιμή που η αλυσίδα ενσωμάτωσής σας ερμηνεύει ως επιτυχία ή αποτυχία build. Μια αλλαγή που ρίχνει την ακρίβεια κάτω από 85% δεν φτάνει πλέον στην παραγωγή, ακριβώς όπως ένα σπασμένο unit test εμποδίζει μια συγχώνευση.

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

def ci_eval_check(prompt_config: dict,
                   test_suite: str,
                   min_score: float = 0.85) -> bool:
    """CI/CD gate: checks that the prompt meets the minimum score."""
    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"Average score: {avg_score:.2%}")
    print(f"Minimum threshold: {min_score:.2%}")

    if avg_score < min_score:
        print("FAILURE: score below threshold")
        return False

    print("SUCCESS: prompt validated")
    return True

Πίνακας Ελέγχου Αξιολόγησης

Παρακολουθήστε την εξέλιξη της βαθμολογίας με την πάροδο του χρόνου. Μια μεμονωμένη βαθμολογία δεν λέει τίποτα· η σειρά αφηγείται την ιστορία του prompt σας και απαντά στην ερώτηση που πάντα προκύπτει στις συναντήσεις: κάνουμε πρόοδο; Η παρακάτω συνάρτηση παράγει έναν πίνακα Markdown που τοποθετεί δίπλα-δίπλα, για κάθε έκδοση, τη μέση βαθμολογία, τα καταναλωθέντα tokens και το εκτιμώμενο κόστος. Η μορφή δεν είναι τυχαία: επικολλάται απευθείας σε ένα pull request, καθιστώντας τη σύγκριση αναγνώσιμη για άτομα που δεν θα ανοίξουν ποτέ τον κώδικά σας.

def comparison_report(results: dict[str, dict]) -> str:
    """Generates a comparative report between prompt versions."""
    report = "# Comparative Evaluation Report\n\n"
    report += "| Version | Average Score | Average Tokens | Cost |\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

Ρυθμίστε τις Δικλείδες Ασφαλείας σας

Δημιουργήστε μια σουίτα είκοσι περιπτώσεων δοκιμής για ένα πραγματικό prompt, τοποθετώντας μερικές οριακές περιπτώσεις αντί για είκοσι άνετα παραδείγματα: μια σουίτα που περνάει στο 100% με την πρώτη προσπάθεια δεν σας διδάσκει τίποτα. Υλοποιήστε τους τρεις τύπους αξιολογητών και εκτελέστε τους μαζί σε δύο εκδόσεις του prompt σας. Η ακριβής ταύτιση δίνει έναν καθαρό αριθμό, η σημασιολογική ομοιότητα εντοπίζει νόμιμες αναδιατυπώσεις και ο κριτής φωτίζει περιπτώσεις όπου οι δύο πρώτοι διαφωνούν—αυτές οι διαφωνίες είναι οι πιο πλούσιες σε μαθήματα για το τι πραγματικά περιμένετε από το μοντέλο.

Συγκρίνετε, εντοπίστε την νικήτρια έκδοση και, στη συνέχεια, ρυθμίστε το σενάριο CI που μπλοκάρει την ανάπτυξη αν η βαθμολογία πέσει. Θα ξέρετε ότι το σύστημα λειτουργεί την ημέρα που θα απορρίψει μια αλλαγή που νομίζατε ότι ήταν προφανής.

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

  • Η αυτοματοποιημένη αξιολόγηση είναι απαραίτητη για την επαναληπτική διαδικασία με αυτοπεποίθηση
  • Συνδυάστε την αξιολόγηση ακριβούς ταύτισης, σημασιολογικής ομοιότητας και LLM-as-judge ανάλογα με τις ανάγκες
  • Διατηρήστε μια σουίτα δοκιμών που εξελίσσεται μαζί με την εφαρμογή σας
  • Ενσωματώστε την αξιολόγηση στο CI/CD σας με ένα ελάχιστο κατώφλι
  • Χρησιμοποιήστε ένα πιο ικανό μοντέλο ως κριτή για να αξιολογήσετε ένα φθηνότερο μοντέλο
  • Τεκμηριώστε τις βαθμολογίες κάθε έκδοσης για να παρακολουθείτε την εξέλιξη

Δοκιμάστε τις Γνώσεις σας

Προηγμένες τεχνικές και εκβιομηχάνιση: ο τελικός έλεγχος.

1. Τι περιέχει ένα αποτελεσματικό system prompt;

Απάντηση: Ρόλο, πεδίο εφαρμογής, κανόνες συμπεριφοράς, μορφή εξόδου και διαχείριση οριακών περιπτώσεων—γραμμένο σαν προδιαγραφή, δοκιμασμένο σαν κώδικας.

2. Πότε πρέπει να χρησιμοποιείτε self-consistency;

Απάντηση: Σε προβλήματα συλλογισμού με επαληθεύσιμες απαντήσεις: δημιουργήστε πολλαπλούς ανεξάρτητους συλλογισμούς και κρατήστε την απάντηση της πλειοψηφίας—η διακύμανση γίνεται σύμμαχος.

3. Τι εγγυάται η λειτουργία JSON με επιβολή σχήματος;

Απάντηση: Έξοδο που συμμορφώνεται αυστηρά με το σχήμα (τύποι, απαιτούμενα πεδία, enums)—επικυρωμένη στην πλευρά του API και επανεπικυρωμένη στον κώδικα (JSON Schema, Zod) για μια αλυσίδα χωρίς εκπλήξεις.

4. Τι είναι το grounding;

Απάντηση: Η αγκύρωση των απαντήσεων σε παρεχόμενα γεγονότα (έγγραφα, ανακτημένα δεδομένα) αντί στη μνήμη του μοντέλου—με την απαίτηση παραπομπής ή αποχής από εξωτερικές πηγές.

5. Ποιος είναι ο σκοπός ενός καταλόγου prompts με εκδόσεις;

Απάντηση: Να αντιμετωπίζονται τα prompts ως artifacts: εκδόσεις, δοκιμές A/B, αυτοματοποιημένες αξιολογήσεις σε κάθε αλλαγή—γνωρίζετε τι τρέχει στην παραγωγή και γιατί.

Ο τελικός βρόχος του μαθήματος—έκδοση, δοκιμή, αυτόματη αξιολόγηση—μετατρέπει την τεχνική μηχανική prompts από χειροτεχνία σε ομαδική πρακτική.