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

Σύγκριση με το Βασικό Μοντέλο

Μάθημα 11 / 16 Ενημερώθηκε 2 Νοεμβρίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Γιατί η συστηματική σύγκριση έχει σημασία
  2. Ορισμός της βάσης αναφοράς
  3. Δημιουργία απαντήσεων παράλληλα
  4. Αξιοποίηση τρίτου μοντέλου ως κριτή
  5. Σύγκριση κόστους
  6. Σύγκριση λανθάνουσας καθυστέρησης (Latency)
  7. Λήψη απόφασης βάσει αποτελεσμάτων
  8. Βασικά σημεία

Ενημέρωση 2 Νοεμβρίου 2026 — Διαθεσιμότητα Fine-tuning. Η αυτοεξυπηρετούμενη διαδικασία fine-tuning της OpenAI καταργείται σταδιακά: από τις 7 Μαΐου 2026, οι οργανισμοί που δεν την έχουν χρησιμοποιήσει ποτέ δεν μπορούν πλέον να δημιουργήσουν εργασίες· από τις 2 Ιουλίου, πρέπει να έχετε χρησιμοποιήσει ένα μοντέλο fine-tuned τις τελευταίες 60 ημέρες· και ξεκινώντας από τις 6 Ιανουαρίου 2027, κανένας πελάτης δεν θα μπορεί να ξεκινήσει νέες εργασίες. Τα ήδη εκπαιδευμένα μοντέλα παραμένουν usable μέχρι να αποσυρθεί το βασικό τους μοντέλο. Αυτό το μάθημα παραμένει χρήσιμο για την κατανόηση και την αξιοποίηση ενός υπάρχοντος μοντέλου· για νέα έργα, δώστε προτεραιότητα στη μηχανική prompts, στο RAG και στις αξιολογήσεις.

Γιατί η συστηματική σύγκριση έχει σημασία

Το fine-tuning έχει κόστος: χρόνος προετοιμασίας δεδομένων, έξοδα εκπαίδευσης και πολυπλοκότητα συντήρησης. Πρέπει να αποδείξετε ότι το fine-tuned μοντέλο σας προσφέρει μια μετρήσιμη βελτίωση σε σχέση με το βασικό μοντέλο χρησιμοποιώντας ένα ισχυρό prompt. Αν η διαφορά είναι οριακή, το fine-tuning μπορεί να μην αξίζει τον κόπο.

Ο πειρασμός σε αυτή την άσκηση είναι να συγκρίνετε το εκπαιδευμένο μοντέλο σας με ένα βασικό μοντέλο που έχει λάβει κακές οδηγίες. Αυτό οδηγεί σε μια κολακευτική αλλά άνευ αξίας επίδειξη: νικήσατε έναν αντίπαλο που αποδυναμώσατε εσείς οι ίδιοι. Η μόνη τίμια σύγκριση αντιπαραθέτει το fine-tuned μοντέλο σας με την καλύτερη δυνατή χρήση του βασικού μοντέλου.

Ορισμός της βάσης αναφοράς

Η βάση αναφοράς είναι το βασικό μοντέλο με το βέλτιστο system prompt σας. Βελτιστοποιήστε αυτό το prompt πριν προχωρήσετε στη σύγκριση. Συγκεκριμένα, αυτό σημαίνει να καταγράψετε τους κανόνες που διδάξατε σιωπηρά μέσω παραδειγμάτων κατά τη διάρκεια του fine-tuning: τον ρόλο, τον τόνο, το αναμενόμενο μήκος και τον τρόπο ολοκλήρωσης μιας συνομιλίας. Το παρακάτω prompt κάνει ακριβώς αυτό για έναν βοηθό υποστήριξης· σημειώστε ότι το fine-tuned μοντέλο δεν χρειάζεται τέτοιες οδηγίες, καθώς αυτοί οι κανόνες είναι πλέον ενσωματωμένοι στα βάρη του.

from openai import OpenAI

client = OpenAI()

OPTIMIZED_SYSTEM_PROMPT = """You are a customer support assistant for TechCorp.
Rules:
- Respond professionally and empathetically
- Always propose a concrete solution
- Limit responses to 3 sentences maximum
- End with a follow-up question"""

def baseline_response(question: str) -> str:
    """Gets a response from the base model."""
    response = client.responses.create(
        model="gpt-5.6-luna",
        instructions=OPTIMIZED_SYSTEM_PROMPT,
        input=question
    )
    return response.output_text

def fine_tune_response(question: str, model_ft: str) -> str:
    """Gets a response from the fine-tuned model."""
    response = client.responses.create(
        model=model_ft,
        input=question
    )
    return response.output_text

Δημιουργία απαντήσεων παράλληλα

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

import json

def compare_models(
    questions: list[str],
    base_model: str,
    ft_model: str,
    system_prompt: str
) -> list[dict]:
    """Compares responses from two models on the same questions."""
    comparisons = []

    for q in questions:
        # Base model with optimized prompt
        r_base = client.responses.create(
            model=base_model,
            instructions=system_prompt,
            input=q
        )

        # Fine-tuned model (minimal or no prompt)
        r_ft = client.responses.create(
            model=ft_model,
            input=q
        )

        comparisons.append({
            "question": q,
            "baseline_response": r_base.output_text,
            "ft_response": r_ft.output_text
        })

    return comparisons

# Test questions
test_questions = [
    "My package hasn't arrived.",
    "How do I reset my password?",
    "Your product isn't working as expected.",
    "I would like a refund.",
    "What are your opening hours?",
]

results = compare_models(
    test_questions,
    "gpt-5.6-luna",
    "ft:gpt-5.6-luna:org::suffix:xxxxxxxx",
    OPTIMIZED_SYSTEM_PROMPT
)

Αξιοποίηση τρίτου μοντέλου ως κριτή

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

def judge_comparison(comparison: dict) -> dict:
    """Has a third-party model judge the comparison."""
    prompt = f"""Compare these two responses to the same question.

Question: {comparison['question']}

Response A: {comparison['baseline_response']}

Response B: {comparison['ft_response']}

For each criterion, indicate which response is better (A, B, or tie):
1. Relevance of the response
2. Professionalism of tone
3. Adherence to expected format
4. Usefulness to the user

Respond in JSON: {{"relevance": "A/B/tie", "tone": "A/B/tie", "format": "A/B/tie", "usefulness": "A/B/tie", "overall_winner": "A/B/tie"}}"""

    response = client.responses.create(
        model="gpt-5.6-sol",
        input=prompt
    )

    try:
        return json.loads(response.output_text)
    except json.JSONDecodeError:
        return {"error": "Response not parseable"}

# Judge all comparisons
judgments = [judge_comparison(c) for c in results]

Τώρα συγκεντρώστε αυτές τις ετυμηγορίες σε έναν ενιαίο αριθμό. Το ποσοστό βελτίωσης—το μερίδιο των ζευγών όπου κερδίζει το fine-tuned μοντέλο—διαβάζεται σε σχέση με προκαθορισμένα κατώφλια: πάνω από 60%, το κέρδος είναι σαφές· μεταξύ 40% και 60%, ζυγίστε το κέρδος έναντι του επιπλέον κόστους· κάτω από αυτό, το fine-tuning σας δεν έχει αποδείξει την αξία του και το πρόβλημα σχεδόν πάντα βρίσκεται στα δεδομένα.

def comparison_score(judgments: list[dict]) -> dict:
    """Calculates the overall comparison score."""
    scores = {"A_wins": 0, "B_wins": 0, "tie": 0}

    for j in judgments:
        winner = j.get("overall_winner", "tie")
        if winner == "A":
            scores["A_wins"] += 1
        elif winner == "B":
            scores["B_wins"] += 1
        else:
            scores["tie"] += 1

    total = len(judgments)
    print(f"Base model wins: {scores['A_wins']}/{total}")
    print(f"Fine-tuned model wins: {scores['B_wins']}/{total}")
    print(f"Tie: {scores['tie']}/{total}")

    improvement_rate = scores["B_wins"] / total * 100
    print(f"\nImprovement rate: {improvement_rate:.1f}%")

    if improvement_rate >= 60:
        print("Fine-tuning provides a significant improvement.")
    elif improvement_rate >= 40:
        print("Modest improvement—check if the cost is justified.")
    else:
        print("Fine-tuning does not provide a clear improvement.")

    return scores

comparison_score(judgments)

Σύγκριση κόστους

Η ποιότητα αποτελεί μόνο το ήμισυ της απόφασης. Το fine-tuning συχνά μειώνει τα tokens εισόδου καθώς το μεγάλο prompt καθίσταται περιττό, αλλά κάθε token που χρεώνεται σε ένα fine-tuned μοντέλο κοστίζει περισσότερο. Αυτές οι δύο επιδράσεις έλκονται προς αντίθετες κατευθύνσεις και μόνο ο υπολογισμός αποφασίζει. Η παρακάτω συνάρτηση τις αντιπαραθέτει για έναν μήνα κίνησης: η μείωση ενός prompt από 500 σε 50 tokens αντισταθμίζει περισσότερο από μια διπλασιασμένη τιμή εισόδου, αλλά αυτό δεν θα ίσχυε με ένα ήδη σύντομο βασικό prompt.

def compare_costs(
    requests_per_day: int,
    base_prompt_tokens: int,
    ft_prompt_tokens: int,
    avg_output_tokens: int,
    base_input_price: float,
    ft_input_price: float,
    output_price: float
):
    """Compares monthly costs between base and fine-tuned models."""
    days = 30

    base_cost = days * requests_per_day * (
        base_prompt_tokens * base_input_price / 1_000_000 +
        avg_output_tokens * output_price / 1_000_000
    )

    ft_cost = days * requests_per_day * (
        ft_prompt_tokens * ft_input_price / 1_000_000 +
        avg_output_tokens * output_price / 1_000_000
    )

    savings = base_cost - ft_cost
    print(f"Monthly base cost: ${base_cost:.2f}")
    print(f"Monthly fine-tuned cost: ${ft_cost:.2f}")
    print(f"Monthly savings: ${savings:.2f}")

# Example
compare_costs(
    requests_per_day=1000,
    base_prompt_tokens=500,   # long prompt with instructions
    ft_prompt_tokens=50,       # short prompt, behavior is integrated
    avg_output_tokens=200,
    base_input_price=0.15,
    ft_input_price=0.30,        # fine-tuned costs more per token
    output_price=0.60
)

Σύγκριση λανθάνουσας καθυστέρησης (Latency)

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

import time

def measure_latency(model: str, questions: list[str], prompt: str = "") -> float:
    """Measures the average latency of a model."""
    latencies = []
    for q in questions:
        start = time.time()
        kwargs = {"model": model, "input": q}
        if prompt:
            kwargs["instructions"] = prompt
        client.responses.create(**kwargs)
        latencies.append(time.time() - start)

    avg = sum(latencies) / len(latencies)
    print(f"{model} — Average latency: {avg:.2f}s")
    return avg

Λήψη απόφασης βάσει αποτελεσμάτων

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

ΑποτέλεσμαΕνέργεια
Το FT κερδίζει σε ποιότητα + κόστοςΑναπτύξτε το fine-tuned μοντέλο
Το FT κερδίζει σε ποιότητα, χάνει σε κόστοςΑξιολογήστε αν η ποιότητα δικαιολογεί το επιπλέον κόστος
Παρόμοια αποτελέσματαΠαραμείνετε στο βασικό μοντέλο + prompt
Κερδίζει το ΒασικόΒελτιώστε τα δεδομένα σας και δοκιμάστε ξανά

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

  • Συγκρίνετε πάντα με ένα βασικό μοντέλο + βελτιστοποιημένο prompt, όχι με ένα βασικό prompt
  • Χρησιμοποιήστε την κρίση LLM για να αυτοματοποιήσετε την ποιοτική σύγκριση
  • Μετρήστε το κόστος και τη λανθάνουσα καθυστέρηση, όχι μόνο την ποιότητα
  • Ένα ποσοστό βελτίωσης 60%+ δικαιολογεί το fine-tuning
  • Αν το fine-tuning δεν προσφέρει σαφή βελτίωση, επιμείνετε στη μηχανική prompts