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

Έκδοση και Επαναφορά

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

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

Γιατί να εκδίδετε τα μοντέλα σας

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

Ονοματοδοσία εκδόσεων

Η παράμετρος suffix της εργασίας fine-tuning είναι το πρώτο σας εργαλείο ιχνηλασιμότητας: η συμβολοσειρά που τοποθετείτε εκεί καταλήγει στο τελικό ID του μοντέλου και παραμένει αναγνώσιμη παντού—στα αρχεία καταγραφής σας, στη διαμόρφωσή σας, στην κονσόλα σας. Υιοθετήστε μια σύμβαση και τηρήστε την.

# Σύμβαση: {name}-v{major_version}.{minor_version}
job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    model="gpt-5.6-luna",
    suffix="support-client-v2.1"
)

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

ΈκδοσηΤι σηματοδοτεί
v1.0Πρώτο μοντέλο επικυρωμένο σε παραγωγή
v1.1Διόρθωση δεδομένων (ίδιες υπερπαράμετροι)
v2.0Αλλαγή βασικού μοντέλου ή στρατηγικής
v2.1Προσαρμογή υπερπαραμέτρων

Διατήρηση μητρώου μοντέλων

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

import json
import datetime

class ModelRegistry:
    """Μητρώο fine-tuned μοντέλων."""

    def __init__(self, path: str = "model_registry.json"):
        self.path = path
        try:
            with open(path, "r") as f:
                self.registry = json.load(f)
        except FileNotFoundError:
            self.registry = {"models": [], "production": None}

    def record(
        self,
        version: str,
        model_id: str,
        job_id: str,
        dataset_info: dict,
        hyperparams: dict,
        metrics: dict,
        notes: str = ""
    ):
        """Καταγράφει ένα νέο μοντέλο στο μητρώο."""
        entry = {
            "version": version,
            "model_id": model_id,
            "job_id": job_id,
            "date": datetime.datetime.now().isoformat(),
            "dataset": dataset_info,
            "hyperparameters": hyperparams,
            "metrics": metrics,
            "notes": notes,
            "status": "candidate"
        }
        self.registry["models"].append(entry)
        self._save()
        print(f"Model {version} recorded: {model_id}")

    def promote(self, version: str):
        """Προωθεί ένα μοντέλο στην παραγωγή."""
        old = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                m["status"] = "production"
                self.registry["production"] = version
                break

        if old:
            for m in self.registry["models"]:
                if m["version"] == old:
                    m["status"] = "retired"

        self._save()
        print(f"Production: {old} -> {version}")

    def rollback(self, version: str):
        """Επαναφορά σε προηγούμενη έκδοση."""
        self.promote(version)
        print(f"Rollback performed to {version}")

    def production_model(self) -> str:
        """Επιστρέφει το ID του μοντέλου στην παραγωγή."""
        version = self.registry["production"]
        for m in self.registry["models"]:
            if m["version"] == version:
                return m["model_id"]
        return None

    def history(self):
        """Εμφανίζει το ιστορικό των μοντέλων."""
        print(f"{'Version':<12} {'Status':<12} {'Date':<12} {'Val Loss':<10}")
        print("-" * 50)
        for m in self.registry["models"]:
            date = m["date"][:10]
            loss = m["metrics"].get("validation_loss", "N/A")
            print(f"{m['version']:<12} {m['status']:<12} {date:<12} {loss}")

    def _save(self):
        with open(self.path, "w") as f:
            json.dump(self.registry, f, indent=2, ensure_ascii=False)

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

registry = ModelRegistry()

# Καταγραφή νέου μοντέλου
registry.record(
    version="v2.1",
    model_id="ft:gpt-5.6-luna:org::support-v2.1:abc123",
    job_id="ftjob-xyz789",
    dataset_info={"train": 350, "validation": 45},
    hyperparams={"n_epochs": 3, "lr": "auto"},
    metrics={"validation_loss": 0.38, "precision_test": 0.93},
    notes="Added 50 fix examples for refunds"
)

# Προώθηση στην παραγωγή
registry.promote("v2.1")

# Σε περίπτωση προβλήματος, επαναφορά
registry.rollback("v2.0")

Επαναφορά σε δευτερόλεπτα

Μια επαναφορά έχει αξία μόνο αν είναι γρήγορη και δεν απαιτεί σκέψη. Εφόσον η εφαρμογή σας διαβάζει το όνομα του μοντέλου από μια μεταβλητή περιβάλλοντος, η αλλαγή έκδοσης σημαίνει αλλαγή αυτής της μεταβλητής και ενημέρωση του μητρώου—χωρίς επανα-development κώδικα, χωρίς recompilation. Η συνάρτηση quick_rollback πηγαίνει ένα βήμα παραπέρα παρακάμπτοντας εντελώς την ανθρώπινη επιλογή: picks up την τελευταία διαθέσιμη σταθερή έκδοση και, αν δεν υπάρχει, επιστρέφει στο βασικό μοντέλο. Αυτός ο τελευταίος κλάδος είναι το απόλυτο δίχτυ ασφαλείας σας· ενεργοποιήστε τον εθελοντικά μία φορά σε περιβάλλον δοκιμών, ενώ τα διακυβεύματα είναι μηδενικά.

import os

def deploy_model(version: str, registry: ModelRegistry):
    """Αναπτύσσει ένα μοντέλο ενημερώνοντας τη μεταβλητή περιβάλλοντος."""
    model_id = None
    for m in registry.registry["models"]:
        if m["version"] == version:
            model_id = m["model_id"]
            break

    if not model_id:
        raise ValueError(f"Version {version} not found")

    # Ενημέρωση διαμόρφωσης
    os.environ["OPENAI_FT_MODEL"] = model_id
    registry.promote(version)

    print(f"Model deployed: {version} ({model_id})")
    return model_id

def quick_rollback(registry: ModelRegistry):
    """Επαναφορά στην τελευταία σταθερή έκδοση."""
    production = registry.registry["production"]
    versions = [
        m for m in registry.registry["models"]
        if m["version"] != production and m["status"] != "retired"
    ]

    if not versions:
        # Fallback to base model
        os.environ["OPENAI_FT_MODEL"] = "gpt-5.6-luna"
        print("Rollback to base model")
        return

    last_stable = versions[-1]
    deploy_model(last_stable["version"], registry)

Αρχειοθέτηση δεδομένων, όχι μόνο μοντέλων

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

import shutil

def archive_dataset(version: str, files: list[str], archive_folder: str):
    """Αρχειοθετεί τα δεδομένα εκπαίδευσης για μια δεδομένη έκδοση."""
    folder = f"{archive_folder}/{version}"
    os.makedirs(folder, exist_ok=True)

    for file in files:
        shutil.copy2(file, folder)

    print(f"Data archived in {folder}")

archive_dataset(
    "v2.1",
    ["train.jsonl", "validation.jsonl", "test.jsonl"],
    "archives/datasets"
)

Αυτοματοποίηση του πλήρους pipeline

Αυτά τα βήματα, όταν εκτελούνται χειροκίνητα, τελικά παραλείπονται—ειδικά η αρχειοθέτηση, που έρχεται τελευταία και δεν μπλοκάρει τίποτα. Συγκεντρώστε τα σε ένα ενιαίο script που αλυσιδώνει την upload αρχείων, την εκκίνηση εργασίας, την αναμονή ολοκλήρωσης, την καταγραφή στο μητρώο και στη συνέχεια την αρχειοθέτηση των δεδομένων. Ο βρόχος αναμονής ερωτά την εργασία κάθε τριάντα δευτερόλεπτα και σταματά σε μια τελική κατάσταση· σε περίπτωση αποτυχίας, η συνάρτηση επιστρέφει αμέσως αντί να συνεχίσει με ένα ανύπαρκτο μοντέλο.

def deployment_pipeline(
    training_file: str,
    validation_file: str,
    version: str,
    base_model: str = "gpt-5.6-luna",
    hyperparams: dict = None
):
    """Πλήρες pipeline: upload, train, evaluate, record."""
    client = OpenAI()
    registry = ModelRegistry()

    # 1. Upload
    print("Uploading data...")
    train = client.files.create(file=open(training_file, "rb"), purpose="fine-tune")
    val = client.files.create(file=open(validation_file, "rb"), purpose="fine-tune")

    # 2. Training
    print("Launching fine-tuning...")
    params = {"training_file": train.id, "validation_file": val.id,
              "model": base_model, "suffix": version}
    if hyperparams:
        params["hyperparameters"] = hyperparams

    job = client.fine_tuning.jobs.create(**params)

    # 3. Wait for completion
    import time
    while True:
        job = client.fine_tuning.jobs.retrieve(job.id)
        if job.status in ("succeeded", "failed"):
            break
        time.sleep(30)

    if job.status == "failed":
        print(f"Failure: {job.error}")
        return None

    # 4. Record
    registry.record(
        version=version,
        model_id=job.fine_tuned_model,
        job_id=job.id,
        dataset_info={"train": training_file, "validation": validation_file},
        hyperparams=hyperparams or {},
        metrics={"trained_tokens": job.trained_tokens}
    )

    # 5. Archive data
    archive_dataset(version, [training_file, validation_file], "archives/datasets")

    print(f"Pipeline complete: {job.fine_tuned_model}")
    return job.fine_tuned_model

Καθαρισμός

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

def clean_old_models(registry: ModelRegistry, keep: int = 3):
    """Διαγράφει παλιά μοντέλα διατηρώντας τα τελευταία N."""
    models = registry.registry["models"]
    production = registry.registry["production"]

    candidates = [
        m for m in models
        if m["version"] != production
    ]

    to_delete = candidates[:-keep] if len(candidates) > keep else []

    for m in to_delete:
        try:
            client.models.delete(m["model_id"])
            print(f"Deleted: {m['version']} ({m['model_id']})")
        except Exception as e:
            print(f"Error deleting {m['version']}: {e}")

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

  • Χρησιμοποιήστε εκδοτικά suffixes για να αναγνωρίζετε κάθε μοντέλο
  • Διατηρήστε ένα κεντρικοποιημένο μητρώο με μετρικές και μεταδεδομένα
  • Υλοποιήστε έναν μηχανισμό γρήγορης επαναφοράς
  • Αρχειοθετήστε τα δεδομένα εκπαίδευσης με κάθε έκδοση
  • Αυτοματοποιήστε το pipeline και καθαρίζετε τακτικά τα παλιά μοντέλα: λιγότερα ανθρώπινα λάθη, λιγότερο περιττό κόστος

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

Πριν εκδώσετε τα μοντέλα σας, επικυρώστε τον πλήρη κύκλο fine-tuning.

1. Πότε είναι το fine-tuning το κατάλληλο εργαλείο—και πότε όχι;

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

2. Τι κάνει ένα σύνολο δεδομένων εκπαίδευσης υψηλής ποιότητας;

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

3. Τι προσφέρει το DPO σε σύγκριση με το supervised fine-tuning;

Απάντηση: Μάθηση προτιμήσεων: παρέχετε ζεύγη προτιμώμενων/απορριφθέντων απαντήσεων και το μοντέλο μαθαίνει το «καλύτερο» αντί για απλή μίμηση—χρήσιμο για τόνο και λεπτές ισορροπίες.

4. Πώς επικυρώνετε ένα fine-tuned μοντέλο;

Απάντηση: Συγκρίνοντάς το με το βασικό μοντέλο σε ένα σύνολο αξιολόγησης που κρατείται ξεχωριστό από την εκπαίδευση και στη συνέχεια με A/B testing σε επιχειρηματικές μετρικές—ποτέ μόνο βάσει εντύπωσης.

5. Γιατί να εκδίδετε και να σχεδιάζετε για επαναφορά;

Απάντηση: Κάθε fine-tuning παράγει ένα χρονολογημένο μοντέλο: σε περίπτωση υποβάθμισης στην παραγωγή, επιστρέφετε αμέσως στην προηγούμενη έκδοση—το μοντέλο διαχειρίζεται σαν κώδικας.

Καθαρά δεδομένα, ειλικρινής αξιολόγηση, ελεγχόμενες εκδόσεις: το fine-tuning είναι μια μηχανική πειθαρχία—αυτό το μάθημα σας έδωσε τον πλήρη κύκλο.