Iteracja: kiedy ponownie dostrajać model
Na tej stronie
Aktualizacja z 2 listopada 2026 r. — Dostępność dostrajania. Usługa samodzielnego dostrajania modeli OpenAI jest wycofywana: od 7 maja 2026 r. organizacje, które nigdy nie uruchomiły zadania dostrajania, nie mogą już tworzyć nowych; od 2 lipca konieczne jest korzystanie z dostrajonego modelu w ciągu ostatnich 60 dni; a począwszy od 6 stycznia 2027 r., żaden klient nie będzie mógł uruchamiać nowych zadań. Już wytrenowane modele pozostają użyteczne do momentu wycofania ich modelu bazowego. Ten kurs nadal przydaje się do zrozumienia i wykorzystania istniejącego modelu; w przypadku nowych projektów priorytetowo potraktuj inżynierię promptów, RAG oraz ewaluacje.
Dostrajanie to proces iteracyjny
Twój pierwszy cykl dostrajania rzadko będzie idealny. Postęp wynika z cykli iteracyjnych: analizuj błędy, wzbogacaj dane, ponownie trenuj i ponownie ewaluuj. Ta lekcja nauczy Cię, jak identyfikować, kiedy i jak skutecznie przeprowadzać iteracje – oraz, co równie ważne, jak rozpoznawać sytuacje, w których ponowne trenowanie nie ma sensu.
Analizuj błędy, zanim zaczniesz je naprawiać
Naturalnym odruchem po rozczarowującej ewaluacji jest losowe dodawanie przykładów w nadziei, że sama ilość rozwiąże problem. To najszybsza droga do przepalenia budżetu szkoleniowego bez osiągania postępów. Zacznij od przyporządkowania każdej porażki do kategorii: nieprawidłowe formatowanie, niewłaściwy ton, błąd merytoryczny, niekompletna odpowiedź, odpowiedź niezgodna z tematem lub czysta halucynacja. Uzyskany rozkład wskazuje, na czym należy się skupić, i często ujawnia niespodziankę – to, co uważałeś za kwestię stylu, okazuje się problemem kompletności.
def analyze_errors(results: list[dict]) -> dict:
"""Categorizes errors from the fine-tuned model."""
categories = {
"format": [], # Incorrect response format
"tone": [], # Inappropriate tone
"factual": [], # Incorrect information
"incomplete": [], # Response too short or missing elements
"off_topic": [], # Does not answer the question
"hallucination": [] # Invents information
}
for r in results:
if r.get("score", 5) < 3:
# Classify the error (can be done manually or by an LLM)
category = classify_error(r)
categories[category].append(r)
print("Error distribution:")
for cat, errors in categories.items():
if errors:
print(f" {cat}: {len(errors)} cases")
return categories
Następnie przejrzyj przypadki w obrębie tej samej kategorii, aby znaleźć wspólny mianownik. Za każdym razem zadawaj sobie te same pytania: czy model zawodzi przy konkretnym typie pytań, czy błędy grupują się wokół określonych tematów i czy problem wynika z danych, czy z hiperparametrów? Błędy rozproszone we wszystkich tematach, ale zawsze tej samej natury, wskazują na brak przykładów; błędy skupione w jednej dziedzinie sygnalizują lukę w pokryciu tematu; a odpowiedzi zbyt ściśle trzymające się przykładów treningowych niezależnie od pytania świadczą o przeuczeniu (overfitting), które wymaga korekty po stronie liczby epok.
Rozpoznawanie momentu na iterację
Niektóre sygnały jednoznacznie wskazują na konieczność stworzenia nowej wersji, a każdy z nich wymaga innego działania. Model halucynujący na dany temat nie zostanie naprawiony przez pokazanie mu większej liczby poprawnych odpowiedzi na ten temat, lecz przez nauczenie go, by grzecznie odmawiał, gdy czegoś nie wie.
| Sygnał | Działanie |
|---|---|
| Powtarzające się błędy formatowania | Dodaj więcej przykładów z poprawnym formatem |
| Model halucynuje na określone tematy | Dodaj przykłady, w których grzecznie odmawia |
| Wykryto przeuczenie (overfitting) | Zmniejsz liczbę epok, urozmaic dane |
| Nowe przypadki użycia do objęcia | Dodaj przykłady dla tych przypadków |
| Skierowane negatywne opinie użytkowników | Zamień opinie na poprawione przykłady |
Z kolei kilka sytuacji powinno powstrzymać Cię przed ponownym trenowaniem. Gdy błędy są rzadkie i niesystematyczne, dostosowanie promptu rozwiąże je szybciej i taniej. Gdy skargi dotyczą opóźnień lub czasu oczekiwania, problem leży w infrastrukturze i żadna ilość trenowania tego nie naprawi. Gdy od ostatniej wersji zebrałeś tylko garstkę nowych przykładów, oczekiwany zysk nie pokryje kosztu uruchomienia zadania. A gdy dostępny stanie się nowy model bazowy, najpierw przetestuj go „tak jak jest“: czasem osiąga on samodzielnie, bez trenowania, to, z czym poprzednia wersja miała trudności.
Wzbogacaj, zamiast zaczynać od zera
Iteracja przyrostowa oznacza dodawanie ukierunkowanych przykładów do istniejącego zbioru danych bez dotykania reszty. Jest to najczęstsza i najprostsza operacja: ładujesz obecny plik, łączysz nowe przypadki i zapisujesz wszystko ponownie w formacie JSONL. Końcowa liczba służy jako kontrola – suma niezgodna z oczekiwaną wskazuje na błąd odczytu pliku lub utratę linii.
import json
def enrich_dataset(
existing_dataset: str,
new_examples: list[dict],
output: str
):
"""Adds new examples to the existing dataset."""
# Load existing data
with open(existing_dataset, "r") as f:
existing = [json.loads(l) for l in f]
# Merge
combined = existing + new_examples
# Save
with open(output, "w") as f:
for ex in combined:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
print(f"Enriched dataset: {len(existing)} + {len(new_examples)} = {len(combined)}")
Iteracja korygująca jest jeszcze cenniejsza, ponieważ zamienia Twoje porażki w surowiec. Każdy błąd wykryty w produkcji stanowi rzeczywiste pytanie; wystarczy, że napiszesz odpowiedź, którą chciałbyś zobaczyć, a para staje się przykładem treningowym. Pamiętaj, że błędna odpowiedź nie trafia do finalnego przykładu: pomaga udokumentować przypadek i zdecydować, czy korekta jest warta wysiłku, ale model uczy się wyłącznie na wersji poprawnej.
def error_to_example(
question: str,
bad_response: str,
good_response: str,
system_msg: str
) -> dict:
"""Transforms an error into a training example."""
return {
"messages": [
{"role": "system", "content": system_msg},
{"role": "user", "content": question},
{"role": "assistant", "content": good_response}
]
}
# Transform a batch of errors
corrections = []
for error in detected_errors:
correction = error_to_example(
question=error["question"],
bad_response=error["model_response"],
good_response=error["corrected_response"],
system_msg=SYSTEM_PROMPT
)
corrections.append(correction)
Ciągłe dostrajanie i jego ograniczenia
Nic nie stoi na przeszkodzie, aby dostrajać model, który został już wcześniej dostrajany: wystarczy przekazać jego pełny identyfikator w parametrze model zamiast nazwy modelu bazowego. Operacja ta jest kusząca, ponieważ trenuje tylko na nowych danych.
# Fine-tune from an already fine-tuned model
job_v2 = client.fine_tuning.jobs.create(
training_file=new_file.id,
model="ft:gpt-5.6-luna:org::suffix-v1:xxxxxxxx", # v1 model as base
suffix="my-assistant-v2"
)
Ostrzeżenie: ciągłe dostrajanie kumuluje błędy poznawcze (bias). Po 2–3 kolejnych iteracjach często lepiej jest zacząć od nowa od modelu bazowego, używając kompletnego, wzbogaconego zbioru danych. Każda warstwa wzmacnia osobliwości poprzedniej, w tym te niezamierzone, co kończy się tym, że model odpowiada ze sztywnością, której nikt go explicite nie nauczył.
Pełny cykl
Poniższe kroki tworzą pętlę, którą będziesz powtarzać dla każdej wersji. Jeśli zajmiesz się najczęstszymi błędami jako pierwszymi, kolejna wersja wykaże mierzalne zyski na zbiorze testowym; zajmowanie się nimi w niewłaściwej kolejności przyniesie jedynie rozproszone poprawy, które trudno będzie obronić przed zespołem.
Zbierz błędy
Zidentyfikuj przypadki, w których model zawodzi w produkcji lub podczas ewaluacji.
Kategoryzuj i ustalaj priorytety
Skategoryzuj błędy według typu i zajmij się najpierw tymi najczęstszymi.
Twórz przykłady korygujące
Zamień każdy błąd w przykład treningowy z poprawną odpowiedzią.
Ponownie wytrenuj i ewaluuj
Wytrenuj nową wersję i porównaj ją z poprzednią na tym samym zbiorze testowym.
Dokumentuj każdą iterację
Po czterech lub pięciu wersjach nikt nie pamięta, co odróżniało v2 od v3 ani dlaczego v4 zostało porzucone. Systematyczne rejestrowanie każdego uruchomienia – składu zbioru danych, źródła nowych przykładów, hiperparametrów, wyników i podjętej decyzji – zapewnia Ci dostęp do tych informacji, gdy regresja zmusi Cię do cofnięcia się w czasie. Zwróć szczególną uwagę na źródło nowych przykładów: tylko to powie Ci miesiące później, czy degradacja wynikała z źle dobranej partii danych.
iteration_log = {
"version": "v3",
"date": "2026-04-02",
"base_model": "gpt-5.6-luna",
"dataset": {
"train": 350,
"validation": 45,
"new_examples": 50,
"new_examples_source": "production errors week 12"
},
"hyperparameters": {
"n_epochs": 3,
"learning_rate_multiplier": "auto",
"batch_size": "auto"
},
"results": {
"validation_loss": 0.42,
"precision_test": 0.91,
"avg_csat": 4.3,
"improvement_vs_v2": "+5% precision, +0.2 CSAT"
},
"decision": "Deployed to production on 2026-04-03"
}
Kluczowe wnioski
- Dostrajanie jest procesem iteracyjnym – zaplanuj wiele cykli
- Kategoryzuj błędy, zanim zaczniesz naprawiać je w danych
- Zamieniaj opinie użytkowników w przykłady treningowe
- Po 2–3 kolejnych iteracjach zacznij od nowa od modelu bazowego
- Dokumentuj każdą iterację, aby utrzymać przejrzystą historię