LLM Fine-tuning cez LoRA a QLoRA (2026)

Úvod: Prečo fine-tuning a prečo práve LoRA?

Veľké jazykové modely ako Llama 4, Qwen 3 alebo Mistral sú neuveriteľne schopné — to asi nikoho neprekvapí. Ale čo ak potrebujete model, ktorý rozumie vášmu špecifickému doménovému slovníku? Alebo taký, ktorý odpovedá presne v štýle, aký vyžaduje váš produkt? Odpoveďou je fine-tuning — doladenie predtrénovaného modelu na vlastných dátach.

Háčik je v tom, že plný fine-tuning modelu s miliardami parametrov vyžaduje obrovský výpočtový výkon. Keby ste chceli plne dotrénovať 70B model, potrebovali by ste minimálne 4× A100 80GB GPU a proces by trval desiatky hodín — s nákladmi prevyšujúcimi tisíce dolárov. Pre väčšinu tímov a individuálnych vývojárov jednoducho nereálne.

A práve tu prichádzajú na scénu techniky PEFT (Parameter-Efficient Fine-Tuning), konkrétne LoRA (Low-Rank Adaptation) a QLoRA (Quantized LoRA). Tieto metódy umožňujú dotrénovať aj masívne modely na jedinom spotrebiteľskom GPU — s minimálnou stratou kvality oproti plnému fine-tuningu.

V tomto sprievodcovi si prejdeme všetko od teórie cez praktickú implementáciu až po nasadenie. Použijeme najnovšie nástroje roku 2026 vrátane Unsloth, TRL SFTTrainer a bitsandbytes. Na konci budete vedieť fine-tunovať vlastný LLM na vlastnom datasete — aj na GPU s 24 GB VRAM.

Ako funguje LoRA: Teória za efektívnym fine-tuningom

LoRA (Low-Rank Adaptation) dramaticky znižuje počet trénovateľných parametrov bez výrazného vplyvu na kvalitu výsledkov. Pozrime sa, ako to vlastne funguje.

Princíp nízkorangovej aproximácie

Pri plnom fine-tuningu aktualizujeme celú váhovú maticu W modelu. LoRA namiesto toho „zamrazí" pôvodné váhy a pridá dve malé matice A a B, ktorých súčin aproximuje zmenu váh:

W_new = W_original + ΔW
ΔW ≈ B × A

kde:
- W_original: pôvodná váhová matica (zamrazená, netrénuje sa)
- A: matica rozmerov (d × r), kde r << d
- B: matica rozmerov (r × k), kde r << k
- r: rank (hodnosť) — typicky 8, 16, 32 alebo 64

Poďme si to dať do perspektívy. Ak má pôvodná váhová matica rozmery 4096 × 4096 (čo je 16,7 milióna parametrov), LoRA s rankom 16 pridáva iba 4096 × 16 + 16 × 4096 = 131 072 parametrov. To je menej ako 1 % z pôvodného počtu. Zvyšných 99 % parametrov ostáva zamrazených.

Dosť elegantné riešenie, nie?

Ktoré vrstvy cieliť?

Výskum aj praktické experimenty ukazujú, že najlepšie výsledky dosiahnete, keď LoRA aplikujete na všetky lineárne vrstvy — nielen na attention bloky. Konkrétne to znamená:

Attention vrstvy: q_proj, k_proj, v_proj, o_proj
MLP vrstvy: gate_proj, up_proj, down_proj

Pôvodný výskumný článok QLoRA potvrdil, že cielenie na attention aj MLP vrstvy súčasne prináša najväčší nárast kvality. Čisto attention-only prístup jednoducho nestačí.

Kľúčové hyperparametre LoRA

Správne nastavenie hyperparametrov je rozhodujúce. Tu sú tie najdôležitejšie:

Rank (r): Určuje „kapacitu" adaptéra. Vyšší rank znamená viac trénovateľných parametrov a väčšiu schopnosť učenia, ale aj riziko overfittingu. Typický rozsah je 8–64. Pre jednoduché úlohy stačí r=8, pre komplexné doménové prispôsobenie skúste r=32 alebo r=64.
Alpha (α): Škálovací faktor aplikovaný na LoRA váhy. Efektívna miera škálovania sa počíta ako α/r. Osvedčená prax? Nastaviť alpha na dvojnásobok ranku (napr. r=16, α=32).
Dropout: Regularizačná technika, ktorá náhodne nuluje percento parametrov počas tréningu. Pomáha predchádzať overfittingu. Typická hodnota je 0,05–0,1.
Learning rate: Pre LoRA/QLoRA fine-tuning odporúčam začať s hodnotou 2e-4 a odtiaľ prípadne ladiť. Typický rozsah je 2e-4 až 5e-6.

QLoRA: 4-bitová kvantizácia pre maximálnu efektivitu

QLoRA posúva efektivitu LoRA ešte ďalej. Zatiaľ čo štandardné LoRA pracuje s 16-bitovou presnosťou, QLoRA pridáva 4-bitovú kvantizáciu základného modelu — čím redukuje spotrebu VRAM približne na štvrtinu. To je obrovský rozdiel, keď pracujete s obmedzenou GPU pamäťou.

Tri inovácie QLoRA

QLoRA zavádza tri kľúčové koncepty, ktoré stoja za zmienku:

4-bit NormalFloat (NF4): Informačne-teoreticky optimálny kvantizačný dátový typ pre normálne distribuované váhy. Prináša lepšie výsledky ako štandardné 4-bitové celé čísla alebo float formáty.
Dvojitá kvantizácia: Kvantizujú sa aj samotné kvantizačné konštanty, čo šetrí ďalších ~0,37 bitu na parameter. Pre 65B model to predstavuje úsporu zhruba 3 GB pamäte — nie je to zanedbateľné.
Stránkované optimalizéry: Využívajú NVIDIA unified memory na automatický prenos dát medzi GPU a CPU pamäťou pri výkyvoch spotreby, čím predchádzajú tým otravným out-of-memory chybám.

LoRA vs. QLoRA: Kedy čo použiť?

Rozhodnutie závisí hlavne od vašich hardvérových obmedzení:

Vlastnosť	LoRA (16-bit)	QLoRA (4-bit)
Presnosť	Mierne vyššia	Takmer ekvivalentná (95–99 %)
Spotreba VRAM	Vyššia (~4× viac)	Výrazne nižšia
Rýchlosť tréningu	Rýchlejší	~39 % pomalší
Odporúčaný HW	A100 80GB, H100	RTX 4090 24GB, A10G
Najlepšie pre	Maximálna kvalita	Obmedzený rozpočet/pamäť

Úprimne, pre väčšinu praktických scenárov je QLoRA tá správna voľba. Výskum opakovane ukázal, že QLoRA dokáže na mnohých benchmarkoch dosiahnuť výsledky porovnateľné s plným 16-bitovým fine-tuningom — a úspora pamäte je pri tom dramatická.

DoRA a pokročilé techniky: Čo prináša rok 2026

Ekosystém PEFT techník sa vyvíja rýchlo. Okrem klasického LoRA a QLoRA tu máme niekoľko zaujímavých nových prístupov, ktoré stoja za pozornosť.

DoRA: Weight-Decomposed Low-Rank Adaptation

DoRA (akceptované na ICML 2024 ako oral paper s 1,5 % mierou prijatia — čo samo o sebe hovorí o kvalite) rozkladá predtrénované váhy na dve zložky — magnitúdu a smer. LoRA sa potom aplikuje iba na aktualizáciu smeru, zatiaľ čo magnitúda sa trénuje samostatne.

A výsledky? Hovoria jasne:

+3,7 bodov na Llama 7B v úlohách common sense reasoning
+4,4 bodov na Llama 3 8B
Žiadna dodatočná inferenčná réžia — komponenty sa po tréningu zlúčia späť

DoRA je v podstate bezplatná náhrada za LoRA. Rovnaký výpočtový cost pri inferencii, ale výrazne lepšie výsledky. Ak vám to váš framework umožňuje, niet dôvodu nepoužiť DoRA namiesto klasického LoRA.

RoRA: Reliability Optimization for Rank Adaptation

RoRA rieši jeden dosť frustrujúci problém: pri klasickom LoRA aj DoRA výkon paradoxne klesá pri ranku vyššom ako r=32. Viac GPU pamäte teda neprinášalo lepšie výsledky (čo pôsobí dosť kontradiktórne). RoRA tento problém eliminuje optimalizáciou škálovacieho faktora a dosahuje:

+6,5 % presnosť oproti LoRA na LLaMA-7B
+2,9 % presnosť oproti DoRA na LLaMA-7B
Výnimočné výsledky pri fine-tuningu orezaných (pruned) modelov

Unsloth Dynamic 2.0 a QAT

Unsloth v roku 2026 priniesol dve funkcie, o ktorých sa oplatí vedieť:

Dynamic 2.0 kvantizácia: Namiesto rovnomernej kvantizácie všetkých vrstiev systém inteligentne prispôsobuje typ kvantizácie pre každú vrstvu a každý model zvlášť. Výsledok? Výrazne presnejšie kvantizované modely.
Quantization-Aware Training (QAT): V spolupráci s PyTorch umožňuje trénovateľnú kvantizáciu, ktorá obnoví až 70 % stratenej presnosti oproti naivnej kvantizácii. A čo je dôležité — žiadna dodatočná réžia pri inferencii.

Praktická implementácia s Unsloth: Krok za krokom

Tak, poďme sa pustiť do praxe. Ukážeme si kompletný postup fine-tuningu od inštalácie po tréning. Použijeme Unsloth — knižnicu, ktorá ponúka 2× rýchlejší tréning s o 70 % menšou spotrebou VRAM oproti štandardnému HuggingFace prístupu.

Krok 1: Inštalácia závislostí

# Inštalácia Unsloth a závislostí
pip install unsloth
pip install --no-deps bitsandbytes accelerate xformers trl peft
pip install sentencepiece protobuf datasets huggingface_hub

Krok 2: Načítanie modelu s kvantizáciou

Unsloth poskytuje FastLanguageModel, ktorý automaticky aplikuje optimalizácie a umožňuje načítať model v 4-bitovej presnosti:

from unsloth import FastLanguageModel
import torch

# Načítanie modelu s 4-bit kvantizáciou
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.3-70B-Instruct-bnb-4bit",
    max_seq_length=4096,
    dtype=None,             # auto-detekcia (float16/bfloat16)
    load_in_4bit=True,      # QLoRA režim
)

print(f"Model načítaný s {model.num_parameters():,} parametrami")

Rada na začiatok: skúste najprv menší model ako unsloth/Llama-3.1-8B-Instruct-bnb-4bit a pohrajte sa s rôznymi nastaveniami, kým neprejdete na väčšie modely. Ušetríte si čas aj nervy.

Krok 3: Pripojenie LoRA adaptérov

Namiesto aktualizácie každého parametra modelu LoRA injektuje nízkorangové matice do špecifických vrstiev:

# Konfigurácia LoRA adaptérov
model = FastLanguageModel.get_peft_model(
    model,
    r=32,                   # Rank — kapacita adaptéra
    target_modules=[        # Cielené moduly
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha=64,          # Škálovací faktor (2× rank)
    lora_dropout=0.05,      # Regularizácia
    bias="none",
    use_gradient_checkpointing="unsloth",  # Šetrí 30 % VRAM
    random_state=42,
)

# Kontrola počtu trénovateľných parametrov
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
total = sum(p.numel() for p in model.parameters())
print(f"Trénovateľné: {trainable:,} / {total:,} ({100*trainable/total:.2f} %)")

Typický výstup ukáže niečo ako „41M trénovateľných z 3.2B celkových (1,28 %)" — trénujete naozaj len zlomok modelu. A to je celý zmysel LoRA.

Krok 4: Príprava datasetu

Toto je pravdepodobne najdôležitejší krok celého procesu. Kvalita datasetu je absolútne kľúčová — platí jednoduché pravidlo: váš dataset je všetko. Nekvalitné dáta povedú k nekvalitným výsledkom, nech je technika akokoľvek sofistikovaná.

from datasets import load_dataset
from unsloth.chat_templates import get_chat_template, standardize_sharegpt

# Aplikácia chat šablóny
tokenizer = get_chat_template(
    tokenizer,
    chat_template="llama-3.1",
)

# Načítanie a štandardizácia datasetu
dataset = load_dataset("vašorganizácia/váš-dataset", split="train")
dataset = standardize_sharegpt(dataset)

# Formátovanie konverzácií
def formatting_func(examples):
    convos = examples["conversations"]
    texts = [
        tokenizer.apply_chat_template(
            convo, tokenize=False, add_generation_prompt=False
        )
        for convo in convos
    ]
    return {"text": texts}

dataset = dataset.map(formatting_func, batched=True)

# Rozdelenie na tréningový a validačný set
dataset = dataset.train_test_split(test_size=0.1, seed=42)
train_dataset = dataset["train"]
eval_dataset = dataset["test"]

print(f"Tréning: {len(train_dataset)} príkladov")
print(f"Validácia: {len(eval_dataset)} príkladov")

Krok 5: Konfigurácia tréningu

Tu sa odohráva „mágia". Nastavenie tréningových parametrov má zásadný vplyv na výsledky:

from trl import SFTTrainer, SFTConfig

sft_config = SFTConfig(
    output_dir="./outputs",
    # Hyperparametre tréningu
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,   # Efektívny batch = 16
    num_train_epochs=2,
    learning_rate=2e-4,
    lr_scheduler_type="cosine",
    warmup_ratio=0.1,
    # Presnosť a optimalizácia
    fp16=not torch.cuda.is_bf16_supported(),
    bf16=torch.cuda.is_bf16_supported(),
    optim="adamw_8bit",
    weight_decay=0.01,
    max_grad_norm=1.0,
    # Logovanie a evaluácia
    logging_steps=10,
    eval_strategy="steps",
    eval_steps=100,
    save_strategy="steps",
    save_steps=200,
    # Dĺžka sekvencií
    max_seq_length=4096,
    dataset_text_field="text",
    packing=True,                    # Efektívne balenie sekvencií
    seed=42,
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    args=sft_config,
)

# Spustenie tréningu
trainer_stats = trainer.train()
print(f"Tréning dokončený za {trainer_stats.metrics['train_runtime']:.0f} s")

Krok 6: Uloženie a export modelu

Po dokončení tréningu máte niekoľko možností, ako model uložiť a zdieľať:

# Uloženie LoRA adaptéra lokálne
model.save_pretrained("./lora-adapter")
tokenizer.save_pretrained("./lora-adapter")

# Alebo nahranie na Hugging Face Hub
model.push_to_hub("vašmeno/váš-model-lora", token="hf_...")
tokenizer.push_to_hub("vašmeno/váš-model-lora", token="hf_...")

# Export do GGUF formátu pre Ollama
model.save_pretrained_gguf(
    "model-gguf",
    tokenizer,
    quantization_method="q4_k_m",  # Kvalitný 4-bit formát
)

Príprava vlastného datasetu: Osvedčené postupy

Povedzme si to na rovinu — fine-tuning je len taký dobrý ako vaše dáta. Tu sú praktické odporúčania, ktoré som videl fungovať v reálnych projektoch.

Formát datasetu

TRL SFTTrainer podporuje niekoľko formátov. Najflexibilnejší je konverzačný formát ShareGPT:

{
  "conversations": [
    {"role": "system", "content": "Si expert na slovenské právo."},
    {"role": "user", "content": "Aký je rozdiel medzi s.r.o. a a.s.?"},
    {"role": "assistant", "content": "Hlavné rozdiely medzi spoločnosťou s ručením obmedzeným (s.r.o.) a akciovou spoločnosťou (a.s.) sú..."}
  ]
}

Koľko príkladov potrebujete?

Závisí od toho, čo chcete dosiahnuť:

Minimum: 200–500 príkladov pre jednoduchý štýlový transfer
Odporúčané: 2 000–5 000 príkladov pre spoľahlivé doménové prispôsobenie
Ideálne: 10 000+ príkladov pre komplexné úlohy s vysokou variabilitou

Ale pozor — 500 perfektných príkladov môže poraziť 5 000 nekvalitných. Kvalita vždy víťazí nad kvantitou.

Pravidlá kvality

Konzistentnosť: Formát odpovedí musí byť jednotný naprieč celým datasetom
Diverzita: Pokryte čo najširší rozsah otázok a scenárov z vašej domény
Presnosť: Každá odpoveď musí byť fakticky správna — model sa naučí reprodukovať chyby rovnako ochotne ako správne odpovede
Správna dĺžka: Odpovede by mali zodpovedať požadovanej dĺžke výstupov v produkcii
Deduplikácia: Odstráňte duplicitné alebo takmer identické príklady

Nasadenie fine-tunovaného modelu do produkcie

Fajn, model je natrénovaný. Čo teraz? Potrebujete ho nasadiť tam, kde ho budú používať vaši užívatelia. Tu sú najčastejšie scenáre nasadenia v roku 2026.

Nasadenie cez Ollama

Najjednoduchší spôsob lokálneho nasadenia — konverzia do GGUF formátu a spustenie cez Ollama:

# 1. Export do GGUF (viď krok 6 vyššie)
# 2. Vytvorenie Modelfile
cat << 'EOF' > Modelfile
FROM ./model-gguf/model-q4_k_m.gguf
PARAMETER temperature 0.7
PARAMETER top_p 0.9
SYSTEM "Si asistent špecializovaný na vašu doménu."
EOF

# 3. Vytvorenie a spustenie modelu v Ollama
ollama create moj-model -f Modelfile
ollama run moj-model

Nasadenie cez vLLM

Ak potrebujete produkčný API endpoint s vysokou priepustnosťou, vLLM je momentálne asi najlepšia voľba:

# Spustenie vLLM servera s LoRA adaptérom
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --enable-lora \
    --lora-modules moj-adapter=./lora-adapter \
    --max-lora-rank 64 \
    --gpu-memory-utilization 0.9

Zaujímavá vlastnosť vLLM je dynamické načítavanie viacerých LoRA adaptérov na jednom základnom modeli. Môžete tak obsluhovať rôznych zákazníkov s rôznymi prispôsobeniami bez toho, aby ste museli duplikovať celý model. To je dosť veľká vec z hľadiska nákladov.

Zlúčenie adaptéra s modelom

Ak neplánujete dynamicky prepínať medzi adaptérmi, môžete LoRA váhy jednoducho zlúčiť priamo do základného modelu:

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

# Načítanie base modelu a adaptéra
base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")
model = PeftModel.from_pretrained(base_model, "./lora-adapter")

# Zlúčenie a uloženie
merged_model = model.merge_and_unload()
merged_model.save_pretrained("./merged-model")
tokenizer = AutoTokenizer.from_pretrained("./lora-adapter")
tokenizer.save_pretrained("./merged-model")

Riešenie bežných problémov

Fine-tuning LLM nie je vždy priamočiary — občas sa veci pokazia. Tu sú problémy, na ktoré narazíte najčastejšie, a ako ich riešiť.

Out of Memory (OOM) chyby

Toto je asi najčastejší problém. Našťastie existuje niekoľko riešení:

Znížte per_device_train_batch_size na 1 alebo 2
Zvýšte gradient_accumulation_steps na kompenzáciu menšieho batchu
Znížte rank r (napr. z 64 na 16)
Prepnite z LoRA na QLoRA (load_in_4bit=True)
Aktivujte gradient checkpointing: use_gradient_checkpointing="unsloth"
Skráťte max_seq_length

Model generuje nezmyselné odpovede

Ak sa vám toto deje, skontrolujte tieto veci:

Používate správnu chat šablónu pre daný model? (Častejšia chyba, než by ste čakali.)
Overte kvalitu datasetu — nekvalitné dáta = nekvalitné výstupy, bez výnimky
Znížte počet epoch (1–2 sú zvyčajne optimálne) — viac epoch môže viesť k overfittingu
Skúste nižší learning rate

Vysoká tréningová strata (loss) neklesá

Zvýšte rank r — model pravdepodobne nemá dostatočnú kapacitu na učenie
Skontrolujte learning rate — príliš vysoká alebo nízka hodnota robí rovnaký problém
Overte, že dataset nie je príliš malý alebo príliš uniformný

Catastrophic forgetting

Jednou z veľkých výhod LoRA oproti plnému fine-tuningu je výrazne nižšie riziko katastrofálneho zabúdania. Keďže pôvodné váhy ostávajú zamrazené, model si zachováva svoje všeobecné znalosti. Ak napriek tomu pozorujete degradáciu:

Znížte počet tréningových epoch
Znížte learning rate
Pridajte do datasetu aj všeobecné príklady (10–20 % datasetu) — funguje to ako regularizácia

Porovnanie nákladov: Fine-tuning v roku 2026

Pozrime sa na orientačné náklady fine-tuningu rôznych modelov pomocou QLoRA na cloudových GPU. Tieto čísla vás možno príjemne prekvapia:

Model	GPU	VRAM	Čas (1 000 príkladov)	Odhad ceny
Llama 3.1 8B	RTX 4090	~8 GB	~30 minút	~2 $
Llama 3.3 70B	A100 80GB	~45 GB	~3 hodiny	~15 $
Qwen 3 30B-A3B (MoE)	RTX 4090	~18 GB	~1 hodina	~5 $
Llama 4 Scout 17B	H100 80GB	~50 GB	~2 hodiny	~20 $

V porovnaní s plným fine-tuningom, kde by 70B model stál 1 000 $ a viac, je QLoRA rádovo 50–100× lacnejší. A to pri minimálnom vplyve na kvalitu. Pomer cena/výkon je jednoducho výnimočný.

Najčastejšie otázky (FAQ)

Aký je rozdiel medzi LoRA a QLoRA?

LoRA (Low-Rank Adaptation) pridáva malé trénovateľné matice k zamrazeným váham modelu v 16-bitovej presnosti. QLoRA ide o krok ďalej — základný model kvantizuje do 4-bitovej presnosti, čím znižuje spotrebu VRAM približne na štvrtinu. Výsledná kvalita je takmer identická (95–99 % plného fine-tuningu), ale QLoRA je výrazne úspornejšia na pamäť. Pre väčšinu praktických prípadov je QLoRA tou správnou voľbou.

Koľko tréningových dát potrebujem na fine-tuning LLM?

Závisí to od zložitosti úlohy. Pre jednoduchý štýlový transfer stačí 200–500 kvalitných príkladov. Pre spoľahlivé doménové prispôsobenie odporúčam 2 000–5 000 príkladov. Kľúčová je však vždy kvalita, nie kvantita — 500 perfektných príkladov prekoná 5 000 priemerných.

Môžem fine-tunovať LLM na vlastnom notebooku?

Áno, s istými obmedzeniami. S QLoRA a Unsloth dokážete fine-tunovať 8B model na GPU s 8 GB VRAM (napr. RTX 3070). Pre väčšie modely (70B+) budete potrebovať minimálne 24 GB VRAM (RTX 4090) alebo cloudové GPU. Prípadne môžete využiť Google Colab alebo Kaggle — obe platformy ponúkajú GPU zadarmo (s istými limitmi).

Je DoRA lepšia ako LoRA?

Krátka odpoveď: áno. DoRA dosahuje konzistentne lepšie výsledky — napríklad +4,4 bodov na Llama 3 8B v úlohách reasoning. A čo je podstatné, nemá žiadnu dodatočnú inferenčnú réžiu, keďže komponenty sa po tréningu zlúčia späť. Ak váš framework DoRA podporuje (Unsloth aj PEFT knižnica ju podporujú), nie je dôvod ostať pri klasickom LoRA.

Ako nasadím fine-tunovaný model do produkcie?

Máte tri hlavné cesty: (1) Export do GGUF formátu a spustenie cez Ollama — najjednoduchšie pre lokálne nasadenie. (2) Použitie vLLM pre produkčné API s vysokou priepustnosťou — podporuje aj dynamické načítavanie viacerých LoRA adaptérov. (3) Zlúčenie LoRA adaptéra s base modelom a nasadenie ako bežný model. Voľba závisí od vašich požiadaviek na latenciu, priepustnosť a flexibilitu.