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

Μετρικές και Σημεία Αναφοράς

Μάθημα 17 / 20 Ενημερώθηκε 3 Νοεμβρίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Μέτρηση Ποιότητας με Μετρικές
  2. Σύγκριση Νοήματος και όχι Λέξεων
  3. Επαλήθευση ότι το Μοντέλο Δεν Παραισθάνεται (Hallucinating)
  4. Σύνθεση ενός Αναπαραγώγιμου Σημείου Αναφοράς (Benchmark)
  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.

Μέτρηση Ποιότητας με Μετρικές

Πέρα από τις βαθμολογίες τύπου LLM-as-Judge, υπάρχουν ποσοτικές μετρικές για την αξιολόγηση διαφορετικών πτυχών των εξόδων των LLM. Η αξία τους δεν έγκειται στο ότι είναι πιο ακριβείς—ένας καλά δομημένος κριτής LLM αντιλαμβάνεται πράγματα που κανένας τύπος δεν θα δει ποτέ—αλλά στο ότι είναι σταθερές και φθηνές. Η ομοιότητα συνημιτόνου επιστρέφει ακριβώς τον ίδιο αριθμό σε κάθε εκτέλεση, κοστίζει σχεδόν τίποτα και μπορεί επομένως να τρέξει σε χιλιάδες περιπτώσεις με κάθε commit. Στη συνέχεια, κρατάτε τον κριτή LLM για διαστάσεις που πραγματικά τον απαιτούν.

Θα εξετάσουμε τις βασικές μετρικές πριν τις συνθέσουμε σε αναπαραγώγιμα σημεία αναφοράς (benchmarks).

Σύγκριση Νοήματος και όχι Λέξεων

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

import openai
import numpy as np

client = openai.OpenAI()

def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
    """Υπολογίζει την ομοιότητα συνημιτόνου μεταξύ δύο διανυσμάτων."""
    a = np.array(vec_a)
    b = np.array(vec_b)
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))

def semantic_similarity(text_a: str, text_b: str) -> float:
    """Μετρά τη σημασιολογική ομοιότητα μεταξύ δύο κειμένων."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[text_a, text_b],
    )

    vec_a = response.data[0].embedding
    vec_b = response.data[1].embedding

    return cosine_similarity(vec_a, vec_b)

# Παράδειγμα
score = semantic_similarity(
    "The cat is on the rug.",
    "A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}")  # ~0.85+

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

Όταν το ερώτημα είναι «αν η απάντηση αντιμετωπίζει πραγματικά την ερώτηση που τέθηκε», κανένας τύπος δεν αντικαθιστά την κρίση. Η παρακάτω βαθμολογία συνάφειας αναλύει αυτή την κρίση σε τρεις distinct ερωτήσεις: Είναι η απάντηση άμεση; Παραμένει εστιασμένη; Είναι πλήρης; Αυτή η ανάλυση είναι καλύτερη από μια γενική βαθμολογία, επειδή σας λέει προς ποια κατεύθυνση να διορθώσετε το prompt—ένα μοντέλο που φλυαρεί και ένα μοντέλο που είναι ελλιπές απαιτούν αντίθετες διορθώσεις.

def relevance_score(
    question: str,
    answer: str,
    context: str | None = None,
) -> dict:
    """Αξιολογεί κατά πόσον η απάντηση είναι συναφής με την ερώτηση."""
    prompt = (
        "Αξιολογήστε τη συνάφεια αυτής της απάντησης.\n\n"
        f"Ερώτηση: {question}\n"
    )
    if context:
        prompt += f"Παρεχόμενο πλαίσιο: {context[:1000]}\n"
    prompt += (
        f"Απάντηση: {answer}\n\n"
        "Κριτήρια:\n"
        "1. Η απάντηση αντιμετωπίζει άμεσα την ερώτηση; (0-5)\n"
        "2. Η απάντηση περιέχει μη ζητούμενες πληροφορίες; (0-5, 5=καμία)\n"
        "3. Η απάντηση είναι πλήρης; (0-5)\n\n"
        "Απαντήστε σε JSON με τα κλειδιά: direct, focus, completeness."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # το temperature απαιτεί effort none
        input=prompt,
        temperature=0.0,
    )

    import json
    try:
        scores = json.loads(response.output_text)
        average = sum(scores.values()) / (len(scores) * 5)
        return {"score": average, "details": scores}
    except (json.JSONDecodeError, TypeError):
        return {"score": 0, "error": "Η ανάλυση απέτυχε"}

Σημειώστε την ανεστραμμένη διατύπωση του δεύτερου κριτηρίου, όπου το 5 σημαίνει «καμία μη ζητούμενη πληροφορία». Αυτό επιτρέπει την πρόσθεση των τριών βαθμολογιών προς την ίδια κατεύθυνση, αλλά είναι αντιδιαισθητικό στην ανάγνωση: όταν προσθέτετε τα δικά σας κριτήρια, τηρήστε αυτή τη σύμβαση, διαφορετικά θα λάβετε μέσους όρους που επιβραβεύουν το ελάττωμα που σκοπεύατε να τιμωρήσετε.

Επαλήθευση ότι το Μοντέλο Δεν Παραισθάνεται (Hallucinating)

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

def detect_hallucinations(
    context: str,
    answer: str,
) -> dict:
    """Εντοπίζει δηλώσεις που δεν υποστηρίζονται από το πλαίσιο."""
    prompt = (
        "Αναλύστε αυτή την απάντηση και εντοπίστε οποιαδήποτε δήλωση "
        "που ΔΕΝ υποστηρίζεται από το παρεχόμενο πλαίσιο.\n\n"
        f"Πλαίσιο: {context[:3000]}\n\n"
        f"Απάντηση: {answer}\n\n"
        "Για κάθε δήλωση στην απάντηση, υποδείξτε:\n"
        "- supported: η δήλωση βρίσκεται στο πλαίσιο\n"
        "- unsupported: η δήλωση δεν βρίσκεται στο πλαίσιο\n"
        "- invented: η δήλωση αντιφάσκει με το πλαίσιο\n\n"
        "Απαντήστε σε JSON με το κλειδί statements (λίστα) και "
        "fidelity_score (0 έως 1)."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # το temperature απαιτεί effort none
        input=prompt,
        temperature=0.0,
    )

    import json
    try:
        return json.loads(response.output_text)
    except json.JSONDecodeError:
        return {"fidelity_score": 0, "error": "Η ανάλυση απέτυχε"}

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

Σύνθεση ενός Αναπαραγώγιμου Σημείου Αναφοράς (Benchmark)

Ένα benchmark δεν είναι απλώς μια ακόμη μετρική: είναι μια ρύθμιση που παγώνει ένα σύνολο δεδομένων και ένα πρωτόκολλο, ώστε δύο εκτελέσεις να είναι συγκρίσιμες. Η παρακάτω κλάση μετρά τη συνάφεια, την πιστότητα (όταν υπάρχει πλαίσιο), τον χρόνο απόκρισης (latency) και το κόστος, και στη συνέχεια διατηρεί κάθε αποτέλεσμα χρονολογημένο και επισημασμένο με την έκδοση του prompt.

from dataclasses import dataclass, field
import time

@dataclass
class BenchmarkResult:
    model: str
    prompt_version: str
    scores: dict
    avg_latency: float
    total_cost: float
    date: str = field(default_factory=lambda: time.strftime("%Y-%m-%d"))

class Benchmark:
    """Επαναχρησιμοποιήσιμο benchmark για σύγκριση μοντέλων και prompts."""

    def __init__(self, name: str, dataset: list[dict]):
        self.name = name
        self.dataset = dataset
        self.results: list[BenchmarkResult] = []

    def run(
        self,
        model: str,
        system_prompt: str,
        prompt_version: str,
    ) -> BenchmarkResult:
        """Εκτελεί το benchmark με ένα δεδομένο μοντέλο και prompt."""
        relevance_scores = []
        hallucination_scores = []
        latencies = []
        cost = 0

        for case in self.dataset:
            start = time.perf_counter()
            response = client.responses.create(
                model=model,
                instructions=system_prompt,
                input=case["input"],
            )
            latency = time.perf_counter() - start
            latencies.append(latency)

            # Αξιολόγηση
            relevance = relevance_score(
                case["input"], response.output_text
            )
            relevance_scores.append(relevance["score"])

            if case.get("context"):
                halluc = detect_hallucinations(
                    case["context"], response.output_text
                )
                hallucination_scores.append(
                    halluc.get("fidelity_score", 0)
                )

        result = BenchmarkResult(
            model=model,
            prompt_version=prompt_version,
            scores={
                "relevance": sum(relevance_scores) / len(relevance_scores),
                "fidelity": (
                    sum(hallucination_scores) / len(hallucination_scores)
                    if hallucination_scores else None
                ),
            },
            avg_latency=sum(latencies) / len(latencies),
            total_cost=cost,
        )

        self.results.append(result)
        return result

    def compare(self) -> str:
        """Συγκρίνει όλα τα αποτελέσματα του benchmark."""
        lines = [f"Benchmark: {self.name}\n"]
        for r in self.results:
            lines.append(
                f"  {r.model} (prompt {r.prompt_version}) | "
                f"Συνάφεια: {r.scores['relevance']:.2f} | "
                f"Latency: {r.avg_latency:.2f}s"
            )
        return "\n".join(lines)

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

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

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

  • Η σημασιολογική ομοιότητα μετρά το νόημα αλλά παραμένει τυφλή στην άρνηση
  • Αναλύστε τη συνάφεια σε distinct κριτήρια αντί για μια γενική βαθμολογία
  • Εντοπίστε τις παραισθήσεις (hallucinations) αντιπαραθέτοντας την απάντηση με το αρχικό πλαίσιο
  • Δημιουργήστε αναπαραγώγιμα benchmarks που μετρούν την ποιότητα, τον χρόνο απόκρισης και το κόστος μαζί
  • Συνδυάστε αυτόματες μετρικές και LLM-as-Judge για μια ολοκληρωμένη αξιολόγηση