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

Jakość danych: czyszczenie i walidacja

Lekcja 4 z 16 Zaktualizowano 2 listopada 2026 Zaawansowany
Na tej stronie
  1. Dlaczego czyszczenie jest kluczowe
  2. Techniczna walidacja pliku
  3. Czyszczenie treści
  4. Sprawdzenie spójności
  5. Korzystanie z API walidacyjnego OpenAI
  6. Lista kontrolna przed dostrajaniem
  7. 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 wcześniej nie uruchomiły zadania dostrajania, nie mogą już tworzyć nowych; 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 potraktuj inżynierię promptów, RAG oraz ewaluacje.

Dlaczego czyszczenie jest kluczowe

Technicznie poprawny plik JSONL nie gwarantuje udanego dostrajania. Szumne, niespójne lub źle sformatowane dane pogorszą wydajność modelu zamiast ją poprawić – a najgorsze jest to, że nie wywołają żadnych błędów. Zadanie zakończy się sukcesem, model będzie gotowy, a problem odkryjesz dopiero w środowisku produkcyjnym. Ta lekcja omawia techniki czyszczenia i walidacji, które powinieneś zastosować przed przesłaniem danych.

Techniczna walidacja pliku

Zacznij od mechaniki: sprawdź, czy Twój plik jest poprawny składniowo i czy każda linia spełnia oczekiwany kontrakt. Poniższa funkcja przetwarza plik linia po linii, akumulując błędy zamiast zatrzymywać się przy pierwszym z nich (chcesz uzyskać pełną listę, a nie biegać tam i z powrotem dla każdego problemu) i zwraca przy okazji przydatne statystyki, takie jak obecność wiadomości systemowych i konwersacji wielowątkowych.

import json

def validate_jsonl(path: str) -> dict:
    """Validates a JSONL file and returns statistics."""
    errors = []
    stats = {"total": 0, "with_system": 0, "multi_turn": 0}
    valid_roles = {"system", "user", "assistant"}

    with open(path, "r", encoding="utf-8") as f:
        for i, line in enumerate(f, 1):
            stats["total"] += 1
            try:
                obj = json.loads(line.strip())
            except json.JSONDecodeError as e:
                errors.append(f"Line {i}: Invalid JSON — {e}")
                continue

            if "messages" not in obj:
                errors.append(f"Line {i}: Missing 'messages' key")
                continue

            messages = obj["messages"]
            if not isinstance(messages, list) or len(messages) < 2:
                errors.append(f"Line {i}: Minimum 2 messages required")
                continue

            for j, msg in enumerate(messages):
                role = msg.get("role")
                if role not in valid_roles:
                    errors.append(f"Line {i}, msg {j}: Invalid role")
                if not msg.get("content", "").strip():
                    errors.append(f"Line {i}, msg {j}: Empty content")

            if not any(m["role"] == "assistant" for m in messages):
                errors.append(f"Line {i}: No assistant message")

            if messages[0]["role"] == "system":
                stats["with_system"] += 1
            user_turns = sum(1 for m in messages if m["role"] == "user")
            if user_turns > 1:
                stats["multi_turn"] += 1

    return {"errors": errors, "stats": stats}

result = validate_jsonl("training_data.jsonl")
if result["errors"]:
    print(f"Errors: {len(result['errors'])}")
    for err in result["errors"][:10]:
        print(f"  - {err}")
else:
    print(f"File valid — {result['stats']['total']} examples")

Czyszczenie treści

Dokładne lub prawie identyczne wpisy wprowadzają stronniczość do treningu, nadmiernie reprezentując pewne wzorce. Dzieje się to naturalnie podczas agregowania wielu eksportów: to samo częste pytanie pojawia się trzydzieści razy w Twoich logach, a model dochodzi do wniosku, że zasługuje ono na trzydzieści razy większą uwagę niż inne. Hash złączonej treści wiadomości wystarczy, aby je wyeliminować.

import hashlib

def deduplicate(examples: list[dict]) -> list[dict]:
    """Removes duplicates based on message content."""
    seen = set()
    unique = []

    for ex in examples:
        content = "|".join(
            f"{m['role']}:{m['content']}" for m in ex["messages"]
        )
        h = hashlib.md5(content.encode()).hexdigest()

        if h not in seen:
            seen.add(h)
            unique.append(ex)

    print(f"Duplicates removed: {len(examples) - len(unique)}")
    return unique

Kolejnym krokiem jest normalizacja tekstu, która rozwiązuje cztery odrębne problemy. Należy usunąć wielokrotne spacje i zbędne znaki nowej linii, odziedziczone po kopiowaniu i wklejaniu. Kodowanie musi zostać ujednolicone do UTF-8 z usuniętymi znakami kontrolnymi – niewidocznymi, ale często obecnymi w eksportach z baz danych. Interpunkcja wymaga sprawdzenia: odpowiedź urwana w połowie uczy model przerywania samego siebie. Na koniec upewnij się co do spójności języka – jeśli chcesz stosować formę grzecznościową, sprawdź, czy żaden przykład nie używa formy nieformalnej, ponieważ model wiernie odtworzy tę mieszankę.

import re
import unicodedata

def normalize_text(text: str) -> str:
    """Normalizes text for training."""
    text = unicodedata.normalize("NFC", text)
    text = re.sub(r"[\x00-\x09\x0b-\x0c\x0e-\x1f\x7f]", "", text)
    text = re.sub(r"[ \t]+", " ", text)
    text = re.sub(r"\n{3,}", "\n\n", text)
    return text.strip()

Sprawdzenie spójności

Jeśli używasz wiadomości systemowej, musi ona być rygorystycznie identyczna we wszystkich przykładach. Dwa warianty różniące się tylko jednym słowem wystarczą, aby rozmyć sygnał: model przestaje uczyć się konkretnego polecenia, a zaczyna uczyć się nieostrej rodziny instrukcji. Sprawdzenie jest trywialne, a wynik często zaskakujący w przypadku korpusu tworzonego przez wiele osób.

def check_system_messages(examples: list[dict]):
    """Checks consistency of system messages."""
    system_msgs = set()
    for ex in examples:
        for msg in ex["messages"]:
            if msg["role"] == "system":
                system_msgs.add(msg["content"].strip())

    if len(system_msgs) > 1:
        print(f"Warning: {len(system_msgs)} different system messages")
        for sm in system_msgs:
            print(f"  - {sm[:80]}...")
    elif len(system_msgs) == 1:
        print("System message consistent")
    else:
        print("No system message used")

Rozkład długości odpowiedzi opowiada tę samą historię z innej perspektywy. Wysoce niejednorodne odpowiedzi sygnalizują, że korpus został napisany przez wiele osób z różnymi wyobrażeniami o tym, jak powinna wyglądać dobra odpowiedź, lub że do partii wkradł się wynik odstający. Próg użyty tutaj – maksimum większe niż pięciokrotność średniej – nie jest absolutny, ale kieruje Twoją uwagę we właściwe miejsce.

def analyze_lengths(examples: list[dict]):
    """Analyzes the distribution of response lengths."""
    lengths = []
    for ex in examples:
        for msg in ex["messages"]:
            if msg["role"] == "assistant":
                lengths.append(len(msg["content"]))

    if lengths:
        avg = sum(lengths) / len(lengths)
        mini, maxi = min(lengths), max(lengths)
        print(f"Response length — Avg: {avg:.0f} | Min: {mini} | Max: {maxi}")
        if maxi > avg * 5:
            print("High dispersion — check for outliers")

Korzystanie z API walidacyjnego OpenAI

Gdy już przeprowadzisz własne sprawdzenia, prześlij plik i pozwól OpenAI również go zwalidować. Jest to darmowe, natychmiastowe i uchroni Cię przed odkryciem problemu z formatem w momencie uruchamiania zadania.

from openai import OpenAI

client = OpenAI()

file = client.files.create(
    file=open("training_data.jsonl", "rb"),
    purpose="fine-tune"
)

print(f"File uploaded: {file.id}")
print(f"Status: {file.status}")

Jeśli plik zawiera błędy, status zmieni się na error wraz ze szczegółowym komunikatem. Napraw zgłoszone problemy przed ponowną próbą.

Lista kontrolna przed dostrajaniem

Przejdź przez tę listę po kolei przed utworzeniem zadania – każdy punkt odpowiada sprawdzianowi omówionemu powyżej, z wyjątkiem ostatniego, którego żaden skrypt nie zastąpi:

  • Plik JSONL jest poprawny składniowo
  • Brak duplikatów
  • Tekst znormalizowany (UTF-8, spacje, interpunkcja)
  • Wiadomości systemowe są spójne
  • Co najmniej 50 przykładów (idealnie 100+)
  • Przeprowadzono podział na zbiór treningowy i walidacyjny
  • Rozsądny rozkład długości
  • Przegląd ludzki losowej próbki

Kluczowe wnioski

  • Zawsze sprawdzaj składnię JSONL przed przesłaniem
  • Usuń duplikaty, aby uniknąć przeuczenia
  • Spójność wiadomości systemowej jest niezbędna
  • Sprawdź rozkład długości odpowiedzi
  • Poproś człowieka o przegląd próbki – jest to niezastąpione