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, 2025-2026)

• Llama 4 (Meta, 2025) — Scout 17B / Maverick 109B / Behemoth (~2T) — MoE, multimodalne, top open-weight
• Llama 3.3 70B (2024) — popularny dla fine-tuningu, sprawdzony
• Qwen 3 (Alibaba, 2025) — open reasoning, konkurencja dla DeepSeek R1
• DeepSeek V3 (671B MoE, 2024-2025) — popularna baza fine-tuningu, niskie koszty
• Mistral Small 3 / Medium 3 (2025) — efektywne europejskie modele
• Gemma 3 (Google, 2025) — multimodalne
• Phi-4 (Microsoft, koniec 2024) — mały, ale silny w rozumowaniu

Komercyjne API fine-tuning

• OpenAI — fine-tuning GPT-5 mini, GPT-4o
• Anthropic — fine-tuning Claude Haiku 4.5 (dostęp ograniczony 2025)
• Google — fine-tuning Gemini przez Vertex AI
• Together.ai / Fireworks — managed services dla Llama/DeepSeek/Qwen

Nowe techniki preference optimization (2024-2025)

• DPO (Direct Preference Optimization) — często prostsza i lepsza alternatywa RLHF, dziś standard
• SimPO (2024) — uproszczenie DPO bez modelu referencyjnego
• ORPO (2024) — łączy SFT i preference optimization w jednym kroku
• KTO — preference learning z binarnymi sygnałami
• GRPO (DeepSeek, 2024) — RL dla reasoning models bez critic network
• DoRA (Weight-Decomposed LoRA, 2024) — następca LoRA z lepszą jakością

Frameworki do fine-tuningu (2025)

• Unsloth — 2-5x szybszy fine-tuning z mniejszym zużyciem pamięci (najpopularniejszy)
• Axolotl — uproszczony fine-tuning (YAML config)
• LLaMA-Factory — wszechstronny
• Hugging Face PEFT — LoRA, QLoRA, DoRA, adaptery

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.