Monitorowanie procesu uczenia
Na tej stronie
Aktualizacja z 2 listopada 2026 r. — Dostępność fine-tuningu. Usługa samodzielnego fine-tuningu OpenAI jest wycofywana: od 7 maja 2026 r. organizacje, które nigdy z niej nie korzystały, nie mogą już tworzyć zadań; od 2 lipca musisz użyć dostrojonego modelu w ciągu ostatnich 60 dni; a począwszy od 6 stycznia 2027 r., żaden klient nie będzie mógł uruchomić 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 traktuj inżynierię promptów, RAG oraz ewaluacje.
Dlaczego monitorować proces uczenia
Uruchomienie zadania fine-tuningu i zapomnienie o nim zostawia Cię z fait accompli: godzinę później odkrywasz model, nie wiedząc, co działo się w międzyczasie. Obserwując metryki podczas działania procesu uczenia, wcześnie wyłapujesz problemy, decydujesz się dostosować hiperparametry przed spaleniem całego budżetu i przede wszystkim rozumiesz, dlaczego jedno uruchomienie wypadło lepiej od drugiego. Monitorowanie zamienia serię prób w dyscyplinę inżynierską.
Dwie metryki, które musisz czytać
Błąd uczenia (training loss) mierzy, jak bardzo model myli się na danych treningowych – czyli dokładnie na tych danych, które właśnie przetwarza. Powinien on maleć wraz z kolejnymi krokami: to znak, że nauka postępuje. Błąd, który stagnuje lub ponownie rośnie, wskazuje na problem, zazwyczaj źle skalibrowaną szybkość uczenia lub zbyt heterogeniczny korpus.
Błąd walidacji (validation loss) mierzy wydajność na danych, których model nigdy nie widział podczas uczenia – pliku, który odłożyłeś na bok podczas podziału. Jest to najbardziej wiarygodna metryka do oceny rzeczywistej jakości Twojego modelu, ponieważ jest to jedyna metryka, której model nie może poprawić poprzez zapamiętywanie. To ich wspólna ewolucja dostarcza diagnozy.
| Błąd uczenia | Błąd walidacji | Diagnoza |
|---|---|---|
| Malejący | Malejący | Wszystko w porządku, kontynuuj |
| Malejący | Rosnący | Przeuczenie (overfitting) — zmniejsz liczbę epok |
| Stagnujący | Stagnujący | Niedouczenie (underfitting) — zwiększ szybkość uczenia |
| Oscylujący | Oscylujący | Niestabilność — zmniejsz szybkość uczenia |
Drugi wiersz to ten, który w produkcji kosztuje najwięcej: malejący błąd uczenia przy jednoczesnym wzroście błędu walidacji opisuje model, który zapamiętuje Twoje przykłady na pamięć. Na papierze wszystko wydaje się poprawiać; w rzeczywistości każdy dodatkowy krok pogarsza jego zdolność do odpowiadania na pytania, których wcześniej nie widział.
Śledzenie zdarzeń przez API
API nie wysyła powiadomień: musisz regularnie odpytywać zadanie. Poniższa pętla pobiera nowe zdarzenia, wyświetla je w porządku chronologicznym, unikając ponownego wyświetlania tych już widzianych, i zwraca kontrolę, gdy tylko zadanie osiągnie stan końcowy.
from openai import OpenAI
import time
client = OpenAI()
def monitor_job(job_id: str):
"""Monitors a job in real time."""
last_event = None
while True:
job = client.fine_tuning.jobs.retrieve(job_id)
# Fetch new events
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id=job_id,
limit=50
)
for event in reversed(events.data):
if last_event and event.id == last_event:
continue
print(f"[{event.created_at}] {event.message}")
if events.data:
last_event = events.data[0].id
if job.status in ("succeeded", "failed", "cancelled"):
print(f"\nJob finished: {job.status}")
if job.status == "succeeded":
print(f"Model: {job.fine_tuned_model}")
return job
time.sleep(30)
# Usage
job = monitor_job("ftjob-xxxxxxxxxxxxxxxx")
Zdarzenia nie zawierają tylko komunikatów tekstowych: niosą również wartości błędu dla każdego kroku. Ich wyodrębnienie pozwala narysować krzywą zamiast czytać linie logów, a to właśnie na krzywej gołym okiem zauważysz skok błędu walidacji.
def extract_metrics(job_id: str) -> dict:
"""Extracts loss metrics from a completed job."""
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id=job_id,
limit=200
)
training_losses = []
validation_losses = []
for event in events.data:
data = event.data
if data and "train_loss" in str(data):
training_losses.append(data)
if data and "valid_loss" in str(data):
validation_losses.append(data)
return {
"training": training_losses,
"validation": validation_losses
}
Punkty kontrolne i wyniki pośrednie
OpenAI zapisuje punkty kontrolne (checkpoints) podczas uczenia. Jeśli zadanie nie powiedzie się lub je anulujesz, czasami możesz odzyskać użyteczny punkt kontrolny pośredni – innymi słowy, przerwane uruchomienie niekoniecznie oznacza stratę. Jest to również cenne rozwiązanie w przypadku późnego przeuczenia: punkt kontrolny wykonany przed skokiem błędu walidacji może być lepszy niż model końcowy.
# List checkpoints for a job
checkpoints = client.fine_tuning.jobs.checkpoints.list(
fine_tuning_job_id=job.id
)
for cp in checkpoints.data:
print(f"Step {cp.step_number}")
print(f" Model: {cp.fine_tuned_model_checkpoint}")
if cp.metrics:
print(f" Training loss: {cp.metrics.train_loss:.4f}")
if hasattr(cp.metrics, "valid_loss"):
print(f" Validation loss: {cp.metrics.valid_loss:.4f}")
Kiedy przerwać proces
Trzy sygnały uzasadniają przerwanie trwającego procesu uczenia. Pierwszym jest błąd walidacji, który rośnie od kilku kroków, a nie tylko jednego: pojedyncza wartość to szum, trend na pięciu punktach to przeuczenie. Drugim jest błąd uczenia bliski zera, co oznacza, że model odtwarza Twoje przykłady słowo w słowo i nie ma się już od nich czego nauczyć. Trzeci jest bardziej prozaiczny: Twoje testy nie poprawiają się z jednego punktu kontrolnego do drugiego, a każdy dodatkowy krok tylko zwiększa rachunek.
# If you detect a problem, cancel the job
client.fine_tuning.jobs.cancel(job.id)
print("Job cancelled. Adjust your data or hyperparameters and relaunch.")
Raport podsumowujący dla każdego uruchomienia
Zakończ każdą sesję uczenia stworzeniem użytecznego zapisu. Poniższa funkcja zbiera w jednym wyjściu ID zadania, model bazowy, użyte epoki, liczbę przetrenowanych tokenów oraz metryki z ostatniego punktu kontrolnego. Wklej te raporty do dziennika uruchomień: za miesiąc powiedzą Ci, dlaczego zachowałeś tę wersję, a nie inną.
def job_report(job_id: str):
"""Generates a summary report for the job."""
job = client.fine_tuning.jobs.retrieve(job_id)
print("=" * 50)
print(f"Job: {job.id}")
print(f"Base model: {job.model}")
print(f"Status: {job.status}")
print(f"Epochs: {job.hyperparameters.n_epochs}")
if job.status == "succeeded":
print(f"Fine-tuned model: {job.fine_tuned_model}")
print(f"Trained tokens: {job.trained_tokens}")
if job.status == "failed":
print(f"Error: {job.error}")
# Checkpoints
checkpoints = client.fine_tuning.jobs.checkpoints.list(
fine_tuning_job_id=job_id
)
if checkpoints.data:
latest = checkpoints.data[0]
print(f"Latest checkpoint: step {latest.step_number}")
if latest.metrics:
print(f" Train loss: {latest.metrics.train_loss:.4f}")
print("=" * 50)
job_report("ftjob-xxxxxxxxxxxxxxxx")
Kluczowe wnioski
- Zawsze monitoruj błąd walidacji – to Twój prawdziwy wskaźnik jakości
- Jeśli błąd walidacji rośnie, masz do czynienia z przeuczeniem: zmniejsz liczbę epok
- Punkty kontrolne pozwalają odzyskać stan pośredni
- Automatyzuj monitorowanie dla długotrwałych zadań
- Dokumentuj metryki z każdego uruchomienia, aby porównywać swoje iteracje