Jak vyladit LLM: Metody, frameworky a kód krok za krokem [2026]

Vyladění LLM znamená vzít předtrénovaný model a dotrénovat ho na vašich konkrétních datech tak, aby váš úkol zvládal lépe, než by dokázal jakýkoli prompt. Vstupní bariéra se zhroutila: QLoRA + Unsloth vám dnes umožní vyladit model s 8 miliardami parametrů na 12GB běžné GPU za cloudové náklady pod 1 $.

Tento průvodce pokrývá celou cestu – kdy ladit (oproti RAG či prompt engineeringu), kterou metodu a framework vybrat, jak připravit dataset, návod s Llama 3 ke zkopírování a vložení, reálné cenové scénáře a nasazení.

Ladění v kostce

Než se k čemukoli zavážete, tady je rychlý přehled:

Teď pojďme zjistit, zda je ladění pro váš projekt skutečně to pravé.

Kdy byste měli LLM ladit? (vs. RAG vs. prompt engineering)

Tohle je otázka, kterou většina vývojářů přeskakuje – a stojí je to týdny promarněného úsilí. Ladění je mocné, ale ne vždy je to správný nástroj. Zde je rámec pro rozhodování.

Rozhodnutí v zásadě závisí na tom, co se snažíte změnit. Zde jsou reálné scénáře:

Pokud vybíráte správný AI stack pro svůj SaaS, je tento rozhodovací rámec krok číslo jedna. Mnoho týmů buduje složité RAG pipeline, přitom ladění s 500 příklady by jim přineslo konzistentnější výsledky s nižší latencí.

Verdikt: Laďte, když potřebujete, aby se model konzistentně choval jinak, ne jen věděl jiné věci. Pokud potřebujete pouze nové znalosti, RAG je levnější a snáze udržitelné. Pokud potřebujete obojí, zvolte hybrid.

Jak funguje ladění LLM? Full vs. LoRA vs. QLoRA

Existují tři hlavní přístupy a dramaticky se liší nároky na hardware, náklady a kvalitu. Pochopení kompromisů vás ochrání před přeinvestováním i nedodáním kvality.

Plné ladění (když na rozpočtu nezáleží)

Plné ladění aktualizuje každý parametr modelu. Přináší nejlepší možné výsledky, ale vyžaduje obrovské prostředky – zhruba 100+ GB VRAM pro 7B model (musíte současně uložit model, stavy optimalizéru i gradienty). Tohle je území clusterů s H100. Pokud nejste dobře financovaná laboratoř, přeskočte to.

LoRA: Revoluce PEFT

LoRA (Low-Rank Adaptation) zmrazí základní model a přidá malé trénovatelné matice zvané adaptéry. Místo přímé aktualizace obří matice vah W rozloží LoRA aktualizaci na dvě malé matice A a B, kde hodnost r je mnohem menší než dimenze modelu. Výsledek: trénujete zhruba 1–2 % původních parametrů a zároveň si zachováte 98–99 % kvality plného ladění.

Standardní implementací je knihovna peft od Hugging Face. Adaptéry LoRA mají typicky 50–200 MB – oproti celému modelu jsou drobné.

QLoRA: Ladění pro každého

QLoRA posouvá LoRA o krok dál. Načte základní model ve 4bitové přesnosti pomocí speciálního datového typu zvaného NormalFloat4 (NF4) a poté na něj aplikuje adaptéry LoRA. 4bitová kvantizace sníží spotřebu VRAM o dalších ~25 % oproti standardní LoRA, přičemž zachová téměř totožnou kvalitu.

Právě tohle zpřístupňuje ladění všem. 7B model, který na plné ladění potřebuje 100+ GB, se s QLoRA vejde do 12 GB.

Verdikt: Pro 90 % vývojářů je správnou volbou QLoRA. Rozdíl v kvalitě oproti plnému ladění je u většiny úloh zanedbatelný a úspora hardwaru je obrovská. Začněte tam a navyšujte, jen pokud to vaše evaluační metriky vyžadují.

Který framework pro ladění použít v roce 2026?

Na výběru frameworku záleží víc, než si většina lidí uvědomuje. Ten správný vám ušetří hodiny nastavování a výrazně urychlí trénink. Zde je srovnání čtyř hlavních možností.

Zde je rychlé doporučení:

• První ladění? Použijte Unsloth. Nejrychlejší trénink, nejjednodušší nastavení, bezplatné Colab notebooky pro okamžitý start.
• Potřebujete webové UI bez kódu? Použijte LLaMA-Factory. Jeho GUI LLaMA-Board vám umožní nakonfigurovat a spustit trénink z prohlížeče.
• Děláte zarovnání (RLHF, DPO, GRPO)? Použijte TRL. Je to standard Hugging Face pro trénink založený na preferencích a verze v0.15.0 (březen 2026) přidala nativní podporu GRPO.
• Provozujete produkční pipeline na více GPU? Použijte Axolotl. Konfigurace založené na YAML dělají experimenty reprodukovatelné a auditovatelné.

Jeden užitečný trik: Unsloth a LLaMA-Factory lze kombinovat. LLaMA-Factory podporuje Unsloth jako tréninkový backend, takže získáte pohodlí GUI s rychlostními optimalizacemi Unsloth. Týmy budující AI agenty využívající vyladěné modely často začínají s Unsloth pro rychlou iteraci a poté přecházejí na Axolotl pro produkční reprodukovatelnost.

Jak připravit dataset pro ladění?

Kvalita dat je jediným největším faktorem úspěchu ladění. Pečlivě připravený dataset s 500 příklady téměř pokaždé překoná zašuměný dataset s 10 000 příklady.

Formáty datasetu

Dva dominantní formáty jsou chat (kompatibilní s OpenAI) a instruction (ve stylu Alpaca). Zde je podoba každého z nich ve formátu JSONL:

Chat formát (doporučeno pro většinu případů užití):

{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "I ordered a laptop 3 days ago (order #4821) and it still says processing."}, {"role": "assistant", "content": "I can see order #4821 is currently in our warehouse being prepared for shipment. Laptops typically ship within 3-5 business days. You should receive a tracking number by tomorrow. Would you like me to flag this for priority processing?"}]}
{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "Can I return my keyboard? Order #3019, bought it last week."}, {"role": "assistant", "content": "Absolutely! Order #3019 is within our 30-day return window. I'll email you a prepaid return label right now. Once we receive the keyboard, your refund will process within 2-3 business days."}]}
{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "My monitor arrived cracked. Order #5573."}, {"role": "assistant", "content": "I'm sorry about that! For order #5573, I'm initiating an immediate replacement shipment -- no need to return the damaged unit. The new monitor will ship today with express delivery. You'll get a tracking email within the hour."}]}

Instruction formát (ve stylu Alpaca):

{"instruction": "Summarize the following customer complaint in one sentence.", "input": "I've been waiting 2 weeks for my refund and nobody responds to my emails. This is the worst customer service I've ever experienced.", "output": "Customer is frustrated by a 2-week delay in receiving their refund and lack of email response from support."}
{"instruction": "Classify the sentiment of this review.", "input": "The product works fine but shipping took forever.", "output": "Mixed (positive product, negative shipping)"}

Pokyny k velikosti datasetu

Kolik dat skutečně potřebujete? Záleží na složitosti úlohy:

1. 50–100 příkladů – proof of concept, dost na otestování, zda ladění pomáhá
2. 500–1 000 příkladů – užitečné pro většinu jednotlivých úloh (klasifikace, extrakce, formátování)
3. 5 000–10 000 příkladů – produkční kvalita pro složité úlohy
4. 10 000+ příkladů – klesající výnosy, pokud vaše úloha nemá vysokou variabilitu

Kontrolní seznam kvality dat

Před tréninkem ověřte svůj dataset podle těchto kritérií:

• Konzistentní formátování napříč všemi příklady (stejný systémový prompt, stejná struktura výstupu)
• Rozmanité příklady pokrývající okrajové případy a způsoby selhání
• Žádné rozpory (nenučte model říkat „ano" i „ne" na stejný vzor vstupu)
• Vyvážené rozložení typů výstupu (pokud děláte klasifikaci, nemějte 90 % příkladů v jedné třídě)
• Odstraňte duplicitní nebo téměř duplicitní záznamy

Tip pro profesionály: Použijte GPT-4 nebo Claude k vygenerování počátečních syntetických tréninkových dat a poté je zpřesněte lidskou kontrolou. 500 vysoce kvalitních syntetických příkladů často překoná 5 000 zašuměných reálných příkladů. Průvodce laděním od Meta tento přístup doporučuje pro bootstrapování datasetů.

Krok za krokem: Vylaďte Llama 3 8B s QLoRA a Unsloth

Zde je kompletní návod. Každý blok kódu je připraven ke zkopírování a vložení – můžete ho spustit v bezplatném notebooku Google Colab nebo na jakémkoli stroji s 12+ GB VRAM.

Krok 1: Nainstalujte Unsloth

pip install unsloth

To je vše. Unsloth automaticky vyřeší všechny závislosti (transformers, peft, trl, bitsandbytes).

Krok 2: Načtěte základní model ve 4 bitech

from unsloth import FastLanguageModel

# Load Llama 3.1 8B in 4-bit quantization
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

Tím se stáhne 4bitově kvantizovaný model (~4 GB) a načte se do paměti GPU. Na RTX 3060 (12 GB) budete mít pro trénink dostatečnou rezervu.

Krok 3: Nakonfigurujte adaptéry LoRA

# Add LoRA adapters to the model
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                # LoRA rank -- 16 is the sweet spot for most tasks
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,       # Scaling factor (usually equal to r)
    lora_dropout=0,      # Unsloth optimizes for 0 dropout
    bias="none",
)

S r=16 trénujete zhruba 40 milionů parametrů z 8 miliard – méně než 0,5 % modelu. To je kouzlo LoRA.

Krok 4: Načtěte svůj dataset

from datasets import load_dataset

# Load your JSONL dataset from Hugging Face Hub or local file
dataset = load_dataset("json", data_files="train.jsonl", split="train")

# Format into chat template
def format_chat(example):
    text = tokenizer.apply_chat_template(
        example["messages"],
        tokenize=False,
        add_generation_prompt=False,
    )
    return {"text": text}

dataset = dataset.map(format_chat)

Toto vezme chat formát JSONL z předchozí sekce a aplikuje chat šablonu Llama 3. Tokenizér zpracuje všechny speciální tokeny (<|begin_of_text|>, <|eot_id|> atd.).

Krok 5: Nakonfigurujte a spusťte trénink

from trl import SFTTrainer
from transformers import TrainingArguments
from unsloth import is_bfloat16_supported

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,    # Effective batch size = 8
        warmup_steps=5,
        max_steps=60,                     # Adjust based on dataset size
        learning_rate=2e-4,               # Standard for QLoRA
        fp16=not is_bfloat16_supported(),
        bf16=is_bfloat16_supported(),
        logging_steps=1,
        output_dir="outputs",
        seed=42,
    ),
)

# Start training
trainer.train()

Klíčové hyperparametry k pochopení:

• Learning rate (2e-4): Standard pro QLoRA. Snižte (2e-5), pokud vidíte, že model zapomíná obecné schopnosti.
• Batch size (2) × gradient accumulation (4): Efektivní batch size 8. Pokud GPU dojde paměť, zvyšte gradient_accumulation.
• max_steps (60): Pro 500 příkladů je to zhruba 1 epocha. Začněte s 1–3 epochami a sledujte validační ztrátu.
• Hodnost r (16): Nižší (4–8) pro jednoduché úlohy, vyšší (32–64) pro složité. 16 je bezpečný výchozí údaj.

Krok 6: Uložte a otestujte

# Save the LoRA adapters (small -- ~50-200 MB)
model.save_pretrained("my-fine-tuned-model")
tokenizer.save_pretrained("my-fine-tuned-model")

# Quick inference test
FastLanguageModel.for_inference(model)
inputs = tokenizer(
    [tokenizer.apply_chat_template(
        [{"role": "user", "content": "I need to return order #7742"}],
        tokenize=False,
        add_generation_prompt=True,
    )],
    return_tensors="pt",
).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

To je celá pipeline. Na RTX 4090 s Unsloth trvá trénink 500 příkladů zhruba 15–30 minut. Na bezplatné Colab T4 počítejte s 1–2 hodinami.

Co ladění přes API? (OpenAI, Google, Mistral)

Ne každý chce spravovat GPU. Poskytovatelé API vám umožní ladit prostřednictvím jednoduchého workflow nahraj-a-trénuj. Zde je srovnání s vlastním provozováním.

Kdy má ladění přes API smysl: Potřebujete rychle iterovat, váš dataset je malý, nechcete spravovat infrastrukturu nebo konkrétně potřebujete uzavřený model jako GPT-4o.

Kdy vyhrává lokální ladění: Záleží na soukromí dat (zdravotnictví, finance, právo), trénujete často, chcete váhy vlastnit a exportovat nebo optimalizujete náklady ve velkém měřítku.

Verdikt: Ladění přes API je nejrychlejší cestou k proof of concept. Lokální ladění je nejlevnější cestou k produkci. Většina týmů prototypuje na API a poté přejde na lokální Unsloth, jakmile přístup ověří.

Kolik stojí vyladění LLM?

Tvrzení, že „ladění je drahé", uvízlo v roce 2023. Zde je, kolik to skutečně stojí dnes.

Nákladová křivka se rychle zplošťuje. Startup ladící 8B model na RunPod utratí za trénink méně než za jeden šálek kávy. Dokonce i produkční scénář se 70B je pod 30 $ – to je jeden měsíc denního obědového rozpočtu juniorního vývojáře.

Poskytovatelé cloudových GPU, které stojí za srovnání: RunPod (nejlepší spotové ceny), Lambda (spolehlivé H100 na vyžádání), Vast.ai (nejlevnější, ale proměnlivá kvalita) a Modal (serverless, platba za sekundu).

Graf výše ukazuje, proč QLoRA změnila hru. 7B model, který na plné ladění vyžadoval cluster s více GPU, se nyní vejde na GPU notebooku. 70B model klesne z „pouze cloud" na jednu A100.

Verdikt: Produkčně kvalitní 8B model můžete vyladit za méně než 1 $. Nákladová bariéra ladění je pryč. Skutečným nákladem je čas na přípravu datasetu.

Jak vyhodnotit vyladěný model?

Trénink je jen polovina práce. Bez správného vyhodnocení nepoznáte, zda se váš vyladěný model skutečně zlepšil, nebo si jen zapamatoval tréninková data.

Automatizované metriky

Sledujte je během tréninku i po něm:

• Tréninková ztráta / perplexita: Měla by stabilně klesat a poté se ustálit. Pokud klesne téměř k nule, přetrénovali jste.
• Metriky specifické pro úlohu: Přesnost (klasifikace), BLEU/ROUGE (sumarizace), přesná shoda (extrakce), F1 (více štítků). Vyberte metriku odpovídající vaší úloze.

Lidské hodnocení

Čísla nezachytí vše. Pro generativní úlohy:

• A/B testování: Zobrazte výstup základního a vyladěného modelu vedle sebe. Nechte 3–5 hodnotitelů vybrat lepší odpověď napříč 50+ příklady. Sledujte míru výher.
• Hodnocení na Likertově škále: Hodnoťte výstupy podle relevance (1–5), přesnosti (1–5) a tónu (1–5). Spočítejte průměrné zlepšení oproti základnímu modelu.

Kontrola katastrofického zapomínání

Tohle je ta, kterou většina vývojářů přeskakuje. Po vyladění spusťte model na obecném benchmarku, jako je MMLU nebo HellaSwag. Pokud skóre klesnou o více než 2–3 body, váš model ztratil příliš mnoho obecných znalostí. Náprava: snižte learning rate, omezte epochy nebo přejděte na LoRA (která zmrazuje základní váhy).

Praktické pravidlo: Vždy vyčleňte 10–20 % datasetu jako testovací sadu. Nikdy nevyhodnocujte na tréninkových datech – to vám o výkonu v reálném světě neřekne nic.

Jak nasadit vyladěný model?

Trénink je hotový. Teď ho potřebujete servírovat. Většina průvodců tuto část zcela vynechává.

Krok 1: Slučte adaptéry LoRA

Pokud jste použili LoRA nebo QLoRA, slučte adaptéry zpět do základního modelu pro inferenci:

# Merge adapters into base model
model.merge_and_unload()
model.save_pretrained("merged-model")
tokenizer.save_pretrained("merged-model")

Krok 2: Vyberte cestu nasazení

Lokální vývoj a testování, Ollama:

# Convert to GGUF format (Ollama's native format)
python llama.cpp/convert_hf_to_gguf.py merged-model --outfile model.gguf --outtype q4_k_m

# Create an Ollama model
ollama create my-fine-tuned-model -f Modelfile
ollama run my-fine-tuned-model

Produkční servírování, vLLM:

# Start an OpenAI-compatible API server
python -m vllm.entrypoints.openai.api_server \
    --model merged-model \
    --host 0.0.0.0 \
    --port 8000

Serverless (nulová infrastruktura): Nahrajte model na Together AI, Fireworks nebo Modal. Získáte koncový bod API bez správy serverů. Náklady se škálují s využitím.

Pokročilé: Servírování více adaptérů

Zde je vzor, který by mělo používat víc týmů: nechte v paměti načtený jeden základní model a střídavě měňte adaptéry LoRA podle požadavku. Můžete servírovat adaptér pro zákaznickou podporu, adaptér pro kontrolu kódu a adaptér pro sumarizaci – vše z jedné GPU. vLLM to nativně podporuje příznakem --enable-lora.

Připraveni na implementaci? Podívejte se na naše Nejlepší nástroje a platformy pro ladění LLM [již brzy] pro hlubší srovnání možností nasazení.

Jaké jsou nejčastější chyby při ladění?

Poté, co jsme pomohli týmům odladit desítky tréninků, tohle jsou chyby, které se objevují znovu a znovu.

1. Přetrénování na malých datasetech. Trénujete 10 epoch na 200 příkladech, tréninková ztráta klesne téměř k nule a model papouškuje vaše tréninková data doslova. Náprava: maximálně 1–3 epochy, použijte validační sadu a sledujte mezeru mezi tréninkovou a evaluační ztrátou.

2. Katastrofické zapomínání. Model zvládne vaši konkrétní úlohu, ale už nedokáže vést základní konverzaci. Náprava: použijte LoRA/QLoRA (zmrazuje základní váhy), držte learning rate nízko (2e-5 pro plné ladění, 2e-4 pro QLoRA) a před nasazením vyhodnoťte na obecných benchmarcích.

3. Nekvalitní data. Nekonzistentní formátování, rozpory mezi příklady nebo duplicity. Model se naučí šum. Náprava: vyčistěte data před tréninkem. Vždy. Věnujte víc času kuraci dat než ladění hyperparametrů.

4. Začínat s příliš velkým modelem. Týmy skočí na 70B, protože „větší je lepší", a pak si nemohou dovolit náklady na GPU. Náprava: začněte s 8B. Pokud 8B s kvalitními daty vaši úlohu nevyřeší, 70B se stejnými daty pravděpodobně také ne. Nejprve navyšte kvalitu dat, poté velikost modelu.

5. Žádná evaluační pipeline. Trénink bez vyčleněné testovací sady a následné nasazení podle pocitu. Náprava: rozdělte data 80/10/10 (train/val/test) ještě před začátkem. Porovnávejte se základním modelem na každém testovacím příkladu.

6. Příliš vysoký learning rate. Zničí předtrénované znalosti v prvních několika krocích. Model vypouští nesmysly. Náprava: začněte na 2e-4 pro QLoRA, 2e-5 pro plné ladění. Pokud se výstupy zhoršují, snižte.

Jak Techsy přistupuje k ladění LLM

V Techsy u každého AI projektu dodržujeme přísnou eskalační cestu: nejprve prompt engineering, poté RAG, ladění jen tehdy, když data prokážou, že je potřeba. Většina klientských projektů ladění ve skutečnosti nevyžaduje – dobře zpracované prompty nebo RAG pipeline vyřeší problém s nižšími náklady a složitostí.

Když je ladění to pravé, náš proces vypadá takto:

1. Audit datasetu – Posoudíme kvalitu, pokrytí a formátování klientových dat. Pokud nemáme dost příkladů, pomůžeme vybudovat syntetický dataset pomocí GPT-4 nebo Claude s lidskou kontrolou.
2. Výběr frameworku – Unsloth + QLoRA pro 90 % startupových projektů. Axolotl pro klienty, kteří potřebují reprodukovatelné produkční pipeline na více GPU.
3. Trénink a vyhodnocení – Vždy trénujeme s vyčleněnou testovací sadou a porovnáváme se základním modelem. Pokud vyladěný model měřitelně nezlepší cílovou metriku, nenasadíme ho.
4. Nasazení – vLLM pro produkční servírování, vzory s více adaptéry, když klienti potřebují více specializovaných modelů z jedné GPU.

Dodali jsme vyladěné modely pro startupy, které si nemohly dovolit podnikové rozpočty na GPU – QLoRA na RunPod drží náklady pod 30 $ i pro 70B modely.

Potřebujete pomoci s vyladěním LLM pro váš případ užití? Pomáháme týmům dostat se od surových dat k nasazenému modelu. Získejte bezplatnou konzultaci

Časté dotazy o ladění LLM

Co je ladění LLM?

Ladění LLM je proces tréninku předtrénovaného jazykového modelu na vašich datech specifických pro daný úkol, aby tento úkol zvládal lépe. V podstatě model učíte nová chování, formáty nebo oborovou expertízu, kterých obecné promptování nedosáhne spolehlivě.

Kdy ladit a kdy použít RAG?

Laďte, když potřebujete, aby se model choval jinak – konzistentní formát výstupu, oborový jazyk, konkrétní tón. Použijte RAG, když model potřebuje vědět jiné věci, zejména pokud se tyto znalosti často mění. Pro mnoho produkčních systémů funguje nejlépe hybridní přístup.

Kolik stojí vyladění LLM?

Kdekoli od 0 do 540 $ podle měřítka. Většina jednotlivých vývojářů utratí pod 1 $ pomocí QLoRA na RunPod RTX 4090 (0,34 $/hod). Produkční 70B model na A100 stojí 17–27 $. Plné ladění na clusterech H100 vyjde na 270–540 $. Ladění přes API (OpenAI) stojí 3–25 $ za 1 000 příkladů.

Mohu vyladit LLM na svém notebooku?

Ano, pokud má váš notebook GPU s 12+ GB VRAM. GPU notebooku RTX 3060 zvládne 8B modely s QLoRA. Macy s Apple Silicon a 16+ GB sjednocené paměti mohou také ladit přes MLX, i když je to pomalejší než CUDA. Pro větší modely budete potřebovat cloudové GPU.

Jaký je rozdíl mezi LoRA a QLoRA?

Obě přidávají malé trénovatelné vrstvy adaptérů, zatímco zmrazují základní model. Rozdíl: QLoRA navíc kvantizuje základní model na 4bitovou přesnost (datový typ NF4), čímž sníží spotřebu VRAM o ~25 % oproti standardní LoRA. Kvalita je téměř totožná – QLoRA dosahuje 97–99 % kvality plného ladění.

Kolik tréninkových příkladů potřebuji?

Záleží na složitosti úlohy. 50–100 příkladů stačí na proof of concept. 500–1 000 příkladů přinese užitečné výsledky pro většinu jednotlivých úloh. 5 000–10 000 příkladů dodá produkční kvalitu pro složité úlohy. Nad 10 000 narážíte na klesající výnosy, pokud úloha nemá extrémně vysokou variabilitu.

Který základní model vyladit v roce 2026?

Llama 3.x pro obecné úlohy (nejlepší poměr kvality a velikosti). Mistral pro evropské jazyky a efektivní inferenci. Qwen 2.5 pro vícejazyčné a kódové úlohy. Phi-4, když potřebujete co nejmenší stopu. Gemma 2 pro integraci s ekosystémem Google.

Co je GRPO a proč na něm záleží?

GRPO (Group Relative Policy Optimization), představené DeepSeek, je nástupcem RLHF pro trénink zarovnání. Klíčová výhoda: nevyžaduje trénink samostatného modelu odměny, což sníží výpočetní náklady zhruba na polovinu. TRL v0.15.0 podporuje GRPO nativně, což ho zpřístupňuje každému, kdo používá ekosystém Hugging Face.

Jak předejít katastrofickému zapomínání?

Použijte LoRA nebo QLoRA místo plného ladění – zmrazují váhy základního modelu, což zachovává obecné znalosti. Držte learning rate nízko (2e-4 pro QLoRA, 2e-5 pro plné). Trénujte na co nejméně epoch (1–3 obvykle stačí). Po tréninku spusťte model na obecných benchmarcích (MMLU, HellaSwag), abyste ověřili, že nezregresoval.

Mohu ladit a poté použít RAG společně?

Rozhodně a mnoho produkčních systémů dělá přesně to. Vylaďte pro konzistenci chování a formátu a poté připojte RAG pro aktuální získávání znalostí. Vyladěný model lépe využívá získaný kontext, protože rozumí jazyku a požadavkům na výstup vašeho oboru.

Jak dlouho ladění trvá?

Pro většinu projektů 30 minut až 8 hodin. 8B model s 500 příklady na Unsloth + RTX 4090 skončí za 15–30 minut. Stejná úloha na bezplatné Colab T4 trvá 1–2 hodiny. 70B modely na A100 trvají 5–8 hodin. Plné ladění na sestavách s více GPU může trvat 20–40 hodin.

Vyplatí se API pro ladění od OpenAI?

Pro rychlé prototypování ano. Můžete nahrát soubor JSONL a mít vyladěný GPT-4o-mini za 30 minut bez jakékoli konfigurace GPU. Pro produkci je obvykle lepší lokální ladění: vlastníte váhy, kontrolujete soukromí dat a náklady jsou ve velkém měřítku nižší. Většina týmů začne s API pro ověření přístupu a poté migruje na lokální.

Závěr

Ladění LLM už není černá magie jako před dvěma lety. Zde jsou klíčové závěry:

1. Začněte s QLoRA + Unsloth – zvládne 90 % případů užití na běžném hardwaru
2. Kvalitní data porazí větší model pokaždé. Věnujte úsilí kvalitě datasetu, ne upgradům GPU.
3. Nákladová bariéra je pryč – vylaďte 8B model za méně než 1 $ na cloudových GPU
4. Vždy vyhodnocujte vůči základnímu modelu před nasazením. Pokud není měřitelně lepší, nenasazujte ho.
5. Nejprve zvažte RAG – laďte, jen když potřebujete, aby se model choval jinak, ne jen věděl jiné věci

Připraveni na implementaci? Podívejte se na naše Nejlepší nástroje a platformy pro ladění LLM [již brzy] pro podrobné srovnání tréninkových frameworků a možností nasazení.

Pokud vám tento průvodce přišel užitečný, prohlédněte si náš návod o výběru správného AI stacku pro širší architektonická rozhodnutí kolem produktů poháněných AI.

Zdroje

• Repozitář Unsloth na GitHub – framework pro ladění se 2–5× vyšší rychlostí
• Dokumentace Hugging Face TRL – implementace SFTTrainer, DPO a GRPO
• Dokumentace Hugging Face PEFT – LoRA a parametricky efektivní ladění
• Článek o QLoRA (Dettmers a kol., 2023) – výzkum 4bitové kvantizace NormalFloat
• Článek o LoRA (Hu a kol., 2021) – nízkohodnostní adaptace velkých jazykových modelů
• Dokumentace OpenAI API pro ladění – workflow ladění přes API
• Ceník cloudových GPU RunPod – reference nákladů na cloudové GPU
• Dokumentace vLLM – produkční servírování LLM
• Průvodce laděním Meta Llama – oficiální doporučení pro trénink Llama
• Článek DeepSeekMath (GRPO) – Group Relative Policy Optimization