Fine-tuning LLM — jak dostosować model językowy do swoich potrzeb

Fine-tuning LLM — jak dostosować model językowy do swoich potrzeb

Ogólne modele językowe jak GPT-4 czy Claude są imponujące, ale nie zawsze idealne dla specyficznych zadań. Być może potrzebujesz modelu, który pisze w stylu Twojej marki, rozumie żargon branżowy, generuje kod w specyficznym frameworku lub klasyfikuje dokumenty według Twojej taksonomii. W takich przypadkach fine-tuning — dodatkowy trening modelu na Twoich danych — może być rozwiązaniem.

Czym jest fine-tuning?

Fine-tuning to proces dodatkowego trenowania wstępnie wytrenowanego modelu (pretrained model) na mniejszym, specjalistycznym zbiorze danych. Model zachowuje ogólną wiedzę z pretrainingu, ale uczy się nowych wzorców specyficznych dla Twojego zadania.

Analogia: model pretrained to absolwent uniwersytetu z szeroką wiedzą ogólną. Fine-tuning to staż w konkretnej firmie — uczy specyfiki branży, żargonu, procedur.

Fine-tuning vs RAG vs Prompt engineering

Zanim zdecydujesz się na fine-tuning, rozważ alternatywy:

Zasada: Zacznij od prompt engineeringu → jeśli nie wystarczy, dodaj RAG → jeśli nadal nie wystarczy, fine-tunuj.

Kiedy warto fine-tunować?

Dobre powody do fine-tuningu:

• Specyficzny styl/ton — model ma pisać jak Twoja marka, nie jak „generyczny AI"
• Format outputu — konsekwentne generowanie JSON, XML, raportów w określonym formacie
• Klasyfikacja domenowa — kategoryzowanie dokumentów wg Twojej taksonomii
• Specjalistyczny żargon — medyczny, prawny, techniczny język branżowy
• Redukcja kosztów — mały fine-tuned model może zastąpić drogi duży model
• Latencja — mniejszy fine-tuned model = szybsze odpowiedzi

Złe powody do fine-tuningu:

• Aktualna wiedza — użyj RAG zamiast fine-tuningu
• Odpowiedzi oparte na dokumentach — RAG jest lepszy
• Jednorazowe zadanie — prompt engineering wystarczy
• Brak danych treningowych — fine-tuning bez danych = degradacja modelu

Techniki fine-tuningu

1. Full fine-tuning

Trenowanie wszystkich parametrów modelu. Najlepsza jakość, ale:

• Wymaga dużo GPU (A100 80GB dla modeli 7B+)
• Ryzyko catastrophic forgetting (model „zapomina" ogólną wiedzę)
• Drogi i czasochłonny

Kiedy: Masz duży budget, dużo danych i potrzebujesz maksymalnej jakości.

2. LoRA (Low-Rank Adaptation)

Najpopularniejsza technika w 2026 roku. Zamiast trenować wszystkie parametry, LoRA dodaje małe, trenable macierze do wybranych warstw modelu. Oryginalne wagi pozostają zamrożone.

Zalety:

• 10-100x mniej parametrów do trenowania
• Możliwość uruchomienia na konsumenckich GPU (RTX 3090, 4090)
• Adaptery LoRA można łączyć i przełączać
• Minimalny catastrophic forgetting

Wady:

• Nieco niższa jakość niż full fine-tuning (ale różnica maleje)
• Wymaga doboru hiperparametrów (rank, alpha, target modules)

3. QLoRA (Quantized LoRA)

LoRA na skwantyzowanym modelu (4-bit). Pozwala fine-tunować modele 7B-13B na kartach z 16-24 GB VRAM.

Zalety:

• Ekstremalnie niskie wymagania sprzętowe
• RTX 3090 (24GB) wystarczy dla modeli 13B
• Jakość zbliżona do standardowej LoRA

Wady:

• Wolniejszy trening (kwantyzacja dodaje overhead)
• Drobna utrata jakości z kwantyzacji

4. PEFT (Parameter-Efficient Fine-Tuning)

Ogólna kategoria technik efektywnych pamięciowo: LoRA, Prefix Tuning, P-Tuning, Adapter Layers. Biblioteka PEFT od Hugging Face unifikuje te podejścia.

Przygotowanie danych treningowych

Jakość danych to 80% sukcesu fine-tuningu. Oto jak przygotować dane:

Format danych

Dla instruction fine-tuningu (najczęstszy przypadek):

{
  "instruction": "Napisz opis produktu w stylu naszej marki",
  "input": "Nazwa: Buty sportowe X200, Cechy: lekkie, oddychające, czarne",
  "output": "X200 to kwintesencja miejskiego biegu. Ultralight mesh oddycha z każdym krokiem..."
}

Ile danych potrzebujesz?

• Zmiana stylu/formatu: 100-500 przykładów
• Klasyfikacja: 500-2000 przykładów (zbalansowane klasy)
• Generowanie domenowe: 1000-5000 przykładów
• Pełna specjalizacja: 5000-50000+ przykładów

Zasady jakości danych

1. Jakość > ilość — 500 świetnych przykładów bije 5000 słabych
2. Różnorodność — pokryj różne scenariusze, edge cases
3. Spójność — ten sam styl, format, poziom szczegółowości
4. Brak błędów — ręcznie zweryfikuj próbkę danych
5. Balans — równa reprezentacja kategorii (dla klasyfikacji)

Narzędzia do przygotowania danych

• Argilla — open source platforma do anotacji z integracją LLM
• Label Studio — wszechstronne narzędzie do anotacji
• ChatGPT/Claude — generowanie syntetycznych danych (z weryfikacją!)
• DPO data — pary preferred/rejected do alignment

Praktyczny workflow fine-tuningu z QLoRA

Wymagania sprzętowe

• GPU NVIDIA z 16-24 GB VRAM (RTX 3090/4090 lub cloud A10/A100)
• 32+ GB RAM
• 50+ GB dysku (modele + dataset)
• Alternatywa: Google Colab Pro ($10/miesiąc), RunPod, Lambda Labs

Stack technologiczny

• Hugging Face Transformers — ładowanie modeli
• PEFT — implementacja LoRA/QLoRA
• BitsAndBytes — kwantyzacja modelu
• TRL — Transformer Reinforcement Learning (SFTTrainer)
• Datasets — ładowanie i preprocessing danych
• Wandb — tracking eksperymentów

Kroki

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer, SFTConfig

# 1. Kwantyzacja i ładowanie modelu
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct",
    quantization_config=bnb_config,
    device_map="auto",
)
model = prepare_model_for_kbit_training(model)

# 2. Konfiguracja LoRA
lora_config = LoraConfig(
    r=16,           # rank — większy = więcej parametrów
    lora_alpha=32,  # scaling factor
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)

# 3. Trening
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    args=SFTConfig(
        output_dir="./output",
        num_train_epochs=3,
        per_device_train_batch_size=4,
        learning_rate=2e-4,
        logging_steps=10,
        save_strategy="epoch",
    ),
)

trainer.train()

# 4. Zapis adaptera
model.save_pretrained("./my-lora-adapter")

Ewaluacja

• Perplexity — czy model lepiej przewiduje tekst z Twojej domeny?
• Task-specific metrics — accuracy, F1 (klasyfikacja), BLEU/ROUGE (generowanie)
• Human evaluation — ręczna ocena jakości outputu (najważniejsza!)
• A/B test — porównaj fine-tuned vs base model na realnych zadaniach

Popularne modele bazowe do fine-tuningu

Open source (darmowe)

• Llama 3.1 8B/70B (Meta) — najlepszy stosunek jakość/rozmiar
• Mistral 7B — szybki, dobry do prostych zadań
• Gemma 2 9B/27B (Google) — silny w rozumowaniu
• Qwen 2.5 7B/72B (Alibaba) — świetny multilingualnie
• Phi-3 mini/medium (Microsoft) — mały ale zdolny

Komercyjne API fine-tuning

• OpenAI — fine-tuning GPT-4o-mini ($8/M input tokens)
• Anthropic — fine-tuning Claude (dostępny dla enterprise)
• Google — fine-tuning Gemini przez Vertex AI

Więcej o modelach open source w naszym artykule Open source AI.

Wyzwania i pułapki

1. Catastrophic forgetting — model po fine-tuningu gorzej radzi sobie z ogólnymi zadaniami. Rozwiązanie: LoRA (zamrożone oryginalne wagi).

1. Overfitting — model „zapamiętuje" dane treningowe zamiast generalizować. Rozwiązanie: więcej danych, regularyzacja, early stopping.

1. Bias amplification — fine-tuning może wzmocnić biasy w danych. Rozwiązanie: zbalansowane dane, testowanie na edge cases.

1. Eval-washing — model dobrze wypada na benchmarku, ale źle w praktyce. Rozwiązanie: human evaluation na realnych zadaniach.

1. Koszty ukryte — GPU, przygotowanie danych, iteracje, monitoring. Policz TCO przed startem.

Podsumowanie

Fine-tuning LLM to potężne narzędzie, ale nie panaceum. W 2026 roku dzięki LoRA i QLoRA stał się dostępny nawet na konsumenckim sprzęcie. Kluczem do sukcesu jest: odpowiedni moment (po prompt engineeringu i RAG), jakościowe dane treningowe, właściwa technika (QLoRA dla większości przypadków) i rzetelna ewaluacja.

Zacznij od małego eksperymentu: weź model 7B, 500 przykładów i QLoRA. Oceń wyniki i iteruj. Fine-tuning to proces, nie jednorazowa operacja.