Премини към основното съдържание
Български— Изберете език
Меню

Версиониране и връщане към предишни версии

Урок 16 от 16 Обновен 2 ноември 2026 г. Напреднало
На тази страница
  1. Защо да версионирате моделите си
  2. Именуване на версиите
  3. Поддържане на регистър на моделите
  4. Връщане към предишни версии за секунди
  5. Архивирайте данните, а не само моделите
  6. Автоматизирайте целия конвейер
  7. Почистване
  8. Ключови изводи
  9. Проверете знанията си

Актуализация от 2 ноември 2026 г. — Наличност на фина настройка. Самостоятелната услуга за фина настройка на OpenAI се преустановява: от 7 май 2026 г. организациите, които никога не са я използвали, вече не могат да създават задачи; от 2 юли трябва да сте използвали фина настроен модел през последните 60 дни; а считано от 6 януари 2027 г. никой клиент няма да може да стартира нови задачи. Вече обучените модели остават използваеми до оттеглянето на базовия им модел. Този курс остава полезен за разбиране и използване на съществуващ модел; за нови проекти дайте приоритет на инженерството на подкани (prompt engineering), RAG и оценяването.

Защо да версионирате моделите си

В производствена среда ще правите итерации върху фина настройвания си модел: нови данни, коригирани хиперпараметри, нов базов модел. Без строга система за версиониране ще загубите проследимост и способността да се върнете назад в случай на регресия. Сценарият винаги е един и същ: в понеделник сутрин потребителската обратна връзка се влошава, никой не знае кой модел всъщност работи или какви данни са го произвели, а екипът прекарва деня във възстановяване на информация, която един файл с няколко реда би запазил.

Именуване на версиите

Параметърът suffix на задачата за фина настройка е вашият първи инструмент за проследимост: низът, който поставите там, се озовава в крайния 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:
    """Регистър на фина настройвани модели."""

    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")

Връщане към предишни версии за секунди

Връщането към предишна версия има стойност само ако е бързо и не изисква размисъл. Тъй като вашето приложение чете името на модела от променлива на средата, промяната на версиите означава промяна на тази променлива и актуализиране на регистъра – без повторно внедряване на код, без рекомпилация. Функцията quick_rollback отива още по-далеч, като напълно заобикаля човешкия избор: тя избира последната налична стабилна версия и, ако няма такава, се връща към базовия модел. Тази последна разклонение е вашата абсолютна предпазна мрежа; задействайте я умишлено веднъж в тестова среда, докато залогът е нулев.

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:
        # Връщане към базовия модел
        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"
)

Автоматизирайте целия конвейер

Тези стъпки, изпълнявани на ръка, в крайна сметка се пропускат – особено архивирането, което идва последно и не блокира нищо. Съберете ги в един единствен скрипт, който свързва качването на файлове, стартирането на задачата, изчакването за приключване, записването в регистъра и след това архивирането на данните. Цикълът на изчакване заявява задачата на всеки тридесет секунди и спира при терминален статус; в случай на неуспех функцията се връща незабавно, вместо да продължава с несъществуващ модел.

def deployment_pipeline(
    training_file: str,
    validation_file: str,
    version: str,
    base_model: str = "gpt-5.6-luna",
    hyperparams: dict = None
):
    """Пълен конвейер: качване, обучение, оценяване, запис."""
    client = OpenAI()
    registry = ModelRegistry()

    # 1. Качване
    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. Обучение
    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. Изчакване за приключване
    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. Запис
    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_dataset(version, [training_file, validation_file], "archives/datasets")

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

Почистване

Моделите с фина настройка се съхраняват в 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}")

Ключови изводи

  • Използвайте версионирани суфикси, за да идентифицирате всеки модел
  • Поддържайте централизиран регистър с метрики и метаданни
  • Внедрете механизъм за бързо връщане към предишна версия
  • Архивирайте обучаващите данни с всяка версия
  • Автоматизирайте конвейера и редовно почиствайте старите модели: по-малко човешки грешки, по-малко ненужни разходи

Проверете знанията си

Преди да версионирате моделите си, валидирайте пълния цикъл на фина настройка.

1. Кога фина настройката е правилният инструмент – и кога не е?

Отговор: Добра е за закрепване на стил, формат или повтарящо се поведение, което подканите не постигат надеждно; лоша е за вкарване на нови знания – това е ролята на RAG.

2. Какво прави един обучаващ набор от данни с високо качество?

Отговор: Чисти, последователни и представителни примери във формат JSONL за разговор: няколкостотин отлични примера побеждават хиляди шумни такива.

3. Какво носи DPO в сравнение с контролираната фина настройка?

Отговор: Обучение чрез предпочитания: предоставяте двойки предпочитани/отхвърлени отговори и моделът научава „по-добро“, а не просто имитация – полезно за тон и фини компромиси.

4. Как валидирате фина настроен модел?

Отговор: Чрез сравняването му с базовия модел върху оценъчен набор, държан отделно от обучението, и след това чрез A/B тестване върху бизнес метрики – никога само въз основа на впечатление.

5. Защо да версионирате и да планирате връщане назад?

Отговор: Всяка фина настройка произвежда датиран модел: в случай на регресия в продукция, превключвате веднага към предишната версия – моделът се управлява като код.

Чисти данни, честно оценяване, контролирани версии: фина настройката е инженерска дисциплина – този курс ви даде пълния цикъл.