Fine-tuning thuis met Unsloth: wat kan en wat niet

Fine-tuning is niet langer voorbehouden aan datacenterteams met A100-clusters. Met Unsloth, QLoRA en een RTX 4090 — of zelfs een RTX 3090 — train je thuis een aangepast model op je eigen dataset. Maar de techniek werkt alleen als je begrijpt waar de grenzen liggen: in VRAM, in uren, en in de kwaliteit van je data.

Wat Unsloth oplost

Standaard fine-tuning via Hugging Face Transformers is geheugenintensief en traag. Voor een 8B-model heb je zonder optimalisaties al snel 40–80 GB VRAM nodig voor full fine-tuning — buiten bereik van elke consumer-GPU. LoRA (Low-Rank Adaptation) lost dat probleem gedeeltelijk op door alleen een kleine set extra parameters te trainen die bovenop de bevroren basisgewichten liggen. In plaats van alle 8 miljard parameters te updaten, update je typisch 0,1–1% daarvan. Kwaliteitsverlies ten opzichte van full fine-tuning: doorgaans minder dan 5–10%.

QLoRA gaat een stap verder: het basismodel wordt in 4-bit gekwantiseerd geladen, waarna LoRA-adapters in hogere precisie worden getraind. Dat bespaart nog eens 75% VRAM vergeleken met LoRA op bf16-gewichten. Een Llama 3.1 8B model dat normaal ~16 GB VRAM vraagt voor LoRA, past bij QLoRA in 8–10 GB — binnen bereik van een RTX 3080 of 3090.

Unsloth is een open-source trainingsframework dat LoRA en QLoRA via eigen Triton-kernels 2–3× sneller maakt dan de standaard Hugging Face-implementatie, met tegelijkertijd 30–90% minder VRAM-gebruik. Het werkt door fused kernels te schrijven voor de meest rekenintensieve operaties (RoPE-rotaties, attention, MLP-lagen) en padding-vrij sequentiepakken toe te passen. Resultaat: op een RTX 4090 train je Llama 3.1 8B met Unsloth in 3,2 uur op een middelgrote dataset, tegenover 5,8 uur met Axolotl op dezelfde hardware.

"Unsloth maakt fine-tuning op een consumer-GPU niet alleen mogelijk, maar ook verdraaglijk snel. Het enige wat het niet kan oplossen is een slechte dataset."

Naast snelheid ondersteunt Unsloth inmiddels een breed modellandschap: Llama 3.x, Mistral, Phi-3, Gemma 2, Qwen 2.5, DeepSeek-R1 en diverse MoE-architecturen. De installatie verloopt via pip of Conda en vereist CUDA 11.8 of hoger; een recente RTX-kaart met Ampere-architectuur of later is aanbevolen voor optimale throughput.

Hardware-realiteit per modelgrootte

De haalbare modelgrootte hangt direct af van je GPU. Onderstaande tabel toont de praktische grenzen bij QLoRA-training met Unsloth, batch size 1 en gradient checkpointing aan:

De RTX 4090 met 24 GB is op dit moment de beste consumer-keuze voor fine-tuning thuis. Je kunt er Llama 3.1 8B comfortabel op trainen met batch size 4–8, langere sequenties (tot 4096 tokens), en zelfs 13B-modellen passen er nog in. Voor 70B-modellen kom je met één kaart niet weg: dat vraagt twee 4090's of cloud-hardware.

Een praktijkrun voor Llama 3.1 8B met Unsloth op een RTX 4090 ziet er als volgt uit:

GPU:           NVIDIA RTX 4090 (24 GB VRAM)
Model:         unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit
Dataset:       2.000 voorbeelden (chat-format, Alpaca-stijl)
Seq. lengte:   2048 tokens
Batch size:    4 (met gradient accumulation 4 = eff. bs 16)
LoRA rank:     16, alpha 16, dropout 0
Epochs:        3
Trainingstijd: ~1,5–2 uur
VRAM-gebruik:  ~14–16 GB piek
Resultaat:     adapter ~100 MB (.safetensors)

Na de training exporteer je de LoRA-adapter en merge je die terug in het basismodel. Voor gebruik met llama.cpp of Ollama conversieer je het gemergde model naar GGUF via convert_hf_to_gguf.py uit de llama.cpp-repository, of via Unsloth's ingebouwde exportfunctie die dit in één stap doet. Het resulterende GGUF-bestand kwantiseer je naar Q4_K_M voor de beste balans tussen kwaliteit en bestandsgrootte (~4,9 GB voor 8B).

Dataset en trainingstijd

Fine-tuning staat of valt met de dataset — meer nog dan met de hardware. De vuistregel voor LoRA/QLoRA is ruimer dan mensen denken: 200–500 voorbeelden zijn genoeg voor eenvoudige classificatie of stijlconversie. Voor domeinspecifieke kennistaken heb je 1.000–5.000 voorbeelden nodig; complexe gedragsveranderingen (reasoning-stijl, strikte instructieopvolging) vragen eerder 5.000–10.000.

De absolute ondergrens is ruwweg 50–100 voorbeelden. Daaronder is het model te klein om iets zinvols te leren; in de praktijk memoriseert het de trainingsdata in plaats van te generaliseren.

Overfitting herken je aan drie signalen:

• De trainingsloss daalt terwijl de validatieloss stijgt of stagneert — het klassieke overfit-patroon
• Het model reproduceert letterlijke zinnen of structuren uit de trainingsvoorbeelden in de output
• Op prompts die sterk lijken op trainingsdata antwoordt het goed; op licht afwijkende varianten valt het terug op generiek taalmodelgedrag

Preventieve maatregelen: houd altijd een validatiesplit aan (90/10 is genoeg), beperk het aantal epochs (2–3 is zelden te weinig), en gebruik een lagere LoRA-rank (8 of 16 in plaats van 64+) bij kleine datasets. Unsloth toont loss-curves in real time in de Jupyter-output; let op wanneer train_loss en eval_loss van elkaar afwijken.

Trainingstijd op een RTX 4090 is behapbaar:

• 500 voorbeelden, 3 epochs → 15–25 minuten
• 2.000 voorbeelden, 3 epochs → 1,5–2 uur
• 10.000 voorbeelden, 3 epochs → 6–10 uur

Op een RTX 3090 reken je grofweg 40–60% meer tijd door het lagere VRAM-budget (minder parallelisme) en de iets tragere geheugenbandbreedte. Een RTX 4070 Ti Super (16 GB) zit daar tussenin en is voor de meeste thuisgebruikers een realistische keuze.

Wanneer fine-tuning zinloos is

Fine-tuning is populair, maar het is minder vaak de juiste keuze dan de hype doet vermoeden. In minstens drie situaties verlies je tijd en rekenkracht voor een slechter resultaat dan met een simpelere aanpak:

1. Je wil het model nieuwe feiten leren. Fine-tuning op feitelijke kennis (productinformatie, bedrijfsdocumentatie, recente gebeurtenissen) werkt slecht. Het model memoriseert de feiten niet betrouwbaar en hallucineert alsnog. De oplossing is RAG (Retrieval-Augmented Generation): laad de documenten in een vectordatabase en laat het model opzoeken in plaats van onthouden. Dat is sneller, betrouwbaarder en updatable zonder hertraining.

2. Je probleem is oplosbaar met prompt engineering. Als je een bepaalde toon, opmaak of redeneerstijl wil, probeer dan eerst een systeem-prompt met drie à vijf goede voorbeelden (few-shot). Moderne 8B-modellen volgen gedetailleerde instructies verrassend goed. Fine-tuning is pas zinvol als de instructies te lang worden om in elk verzoek mee te sturen, of als het model structureel niet naar het gewenste patroon convergeert.

3. Je dataset is kleiner dan 50 voorbeelden of van wisselende kwaliteit. Tien handmatig geschreven voorbeelden en honderd GPT-gegenereerde vulling leiden tot een model dat inconsistenter is dan het basismodel. Kwaliteit slaat kwantiteit: 200 zorgvuldig geschreven voorbeelden outperformen altijd 2.000 slordig gegenereerde. Als je de dataset niet kunt samenstellen met de vereiste kwaliteit, is fine-tuning op dit moment simpelweg niet geschikt.

De eerlijke samenvatting: fine-tuning is de juiste keuze als je een specifieke stijl, toon of gedragspatroon wil inbakken waarvoor de promptlengte onhaalbaar wordt, of als je een gespecialiseerd domein hebt met goede trainingsdata. Voor feitelijke kennis gebruik je RAG. Voor de rest gebruik je een systeemprompt.

Veelgestelde vragen

Kan ik fine-tunen op een AMD GPU?

Ja, maar met beperkingen. Unsloth draait momenteel alleen op NVIDIA CUDA. Op een AMD GPU (ROCm) kun je fine-tunen via de standaard Hugging Face + bitsandbytes-stack op Linux, maar je mist de Unsloth-snelheidswinst. ROCm-ondersteuning in Unsloth wordt actief ontwikkeld maar was medio 2025 nog niet productierijp.

Hoeveel schijfruimte heb ik nodig?

Reken voor een 8B-model op ~16 GB voor de bf16-basisgewichten, plus de LoRA-adapter (~100–300 MB). Het gemergte model is opnieuw ~16 GB; de GGUF Q4_K_M-versie ~4,9 GB. Totaal zit je al snel op 40–50 GB voor één fine-tuning-project inclusief tussenliggende checkpoints.

Moet ik een aparte trainingsmachine hebben?

Nee, maar je pc is tijdens training volledig bezet. De GPU draait op 95–100% belasting en neemt de meeste PCI-E-bandbreedte in beslag. Plan trainingsruns 's avonds of 's nachts. Gebruik je de machine ook als inferentie-server, zet die dan tijdelijk uit.

Is Unsloth gratis?

De open-source versie (Apache 2.0 licentie) is volledig gratis en ondersteunt alle gangbare modellen. Er is ook een betaalde Pro-variant met extra optimalisaties en ondersteuning, maar voor thuisgebruik is de gratis versie meer dan voldoende.

Kan ik een fine-tuned model commercieel gebruiken?

Dat hangt af van de licentie van het basismodel. Llama 3.1 heeft een community-licentie die commercieel gebruik toestaat zolang je maandelijks minder dan 700 miljoen actieve gebruikers hebt — geen probleem voor de meeste projecten. Controleer de licentie van elk basismodel apart; niet alle open-gewichtsmodellen staan commercieel gebruik toe.