Przejdź do głównej treści
Polski— Wybierz język
Menu

Iteracja: kiedy ponownie dostrajać model

Lekcja 13 z 16 Zaktualizowano 2 listopada 2026 Zaawansowany
Na tej stronie
  1. Dostrajanie to proces iteracyjny
  2. Analizuj błędy, zanim zaczniesz je naprawiać
  3. Rozpoznawanie momentu na iterację
  4. Wzbogacaj, zamiast zaczynać od zera
  5. Ciągłe dostrajanie i jego ograniczenia
  6. Pełny cykl
  7. Dokumentuj każdą iterację
  8. Kluczowe wnioski

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 formatowaniaDodaj więcej przykładów z poprawnym formatem
Model halucynuje na określone tematyDodaj przykłady, w których grzecznie odmawia
Wykryto przeuczenie (overfitting)Zmniejsz liczbę epok, urozmaic dane
Nowe przypadki użycia do objęciaDodaj przykłady dla tych przypadków
Skierowane negatywne opinie użytkownikówZamień 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.

1

Zbierz błędy

Zidentyfikuj przypadki, w których model zawodzi w produkcji lub podczas ewaluacji.

2

Kategoryzuj i ustalaj priorytety

Skategoryzuj błędy według typu i zajmij się najpierw tymi najczęstszymi.

3

Twórz przykłady korygujące

Zamień każdy błąd w przykład treningowy z poprawną odpowiedzią.

4

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ę