Версиониране и връщане към предишни версии
На тази страница
Актуализация от 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. Защо да версионирате и да планирате връщане назад?
Отговор: Всяка фина настройка произвежда датиран модел: в случай на регресия в продукция, превключвате веднага към предишната версия – моделът се управлява като код.
Чисти данни, честно оценяване, контролирани версии: фина настройката е инженерска дисциплина – този курс ви даде пълния цикъл.