Hoe een LLM Fine-Tunen: Methoden, Frameworks & Stap-voor-Stap Code [2026]

Een LLM fine-tunen betekent een voorgetraind model nemen en het trainen op jouw specifieke data zodat het jouw taak beter uitvoert dan welk prompt ook zou kunnen. De drempel is verlaagd: QLoRA + Unsloth laten je nu een 8-miljard-parameter model fine-tunen op een 12 GB consument-GPU voor minder dan €1 aan cloudkosten.

Deze gids behandelt het volledige traject -- wanneer je moet fine-tunen (vs. RAG of prompt engineering), welke methode en welk framework je kiest, hoe je je dataset voorbereidt, een copy-paste Llama 3-walkthrough, echte kostenscenario's en deployment.

Fine-Tuning in een Oogopslag

Voordat je ergens aan vastlegt, hier het snelle overzicht:

Laten we nu uitzoeken of fine-tuning echt de juiste keuze is voor jouw project.

Wanneer Moet Je een LLM Fine-Tunen? (vs. RAG vs. Prompt Engineering)

Dit is de vraag die de meeste ontwikkelaars overslaan -- en het kost hen weken verspilde moeite. Fine-tuning is krachtig, maar het is niet altijd het juiste gereedschap. Hier is een framework om te beslissen.

De beslissing draait om wat je probeert te veranderen. Hier zijn echte scenario's:

Als je de juiste AI-stack voor je SaaS kiest, is dit beslissingsframework stap één. Veel teams bouwen complexe RAG-pipelines terwijl een 500-voorbeeld fine-tune hen consistentere resultaten met lagere latentie zou geven.

Verdict: Fine-tune wanneer je het model consistent anders wilt laten gedragen, niet alleen andere dingen wilt laten weten. Als je alleen nieuwe kennis nodig hebt, is RAG goedkoper en makkelijker te onderhouden. Als je beide nodig hebt, ga dan voor hybrid.

Hoe Werkt LLM Fine-Tuning? Full vs. LoRA vs. QLoRA

Er zijn drie hoofdbenaderingen, die sterk verschillen in hardwarevereisten, kosten en kwaliteit. De trade-offs begrijpen voorkomt dat je óf te veel investeert óf te weinig levert.

Full Fine-Tuning (Als Budget Geen Rol Speelt)

Full fine-tuning werkt elke parameter in het model bij. Het levert de best mogelijke resultaten maar vereist enorme resources -- ruwweg 100+ GB VRAM voor een 7B-model (je moet het model, optimizerstatussen en gradiënten tegelijkertijd opslaan). Dit is H100-clusterterritorium. Tenzij je bij een goed gefinancierd lab zit, sla dit dan over.

LoRA: De PEFT-Revolutie

LoRA (Low-Rank Adaptation) bevriest het basismodel en voegt kleine trainbare matrices toe die adapters worden genoemd. In plaats van een enorme gewichtsmatrix W direct bij te werken, ontbindt LoRA de update in twee kleine matrices A en B, waarbij rang r veel kleiner is dan de modeldimensie. Het resultaat: je traint ongeveer 1–2% van de originele parameters terwijl je 98–99% van de kwaliteit van volledig fine-tunen behoudt.

De Hugging Face peft-bibliotheek is de standaard implementatie. LoRA-adapters zijn typisch 50–200 MB -- mini in vergelijking met het volledige model.

QLoRA: Fine-Tuning voor Iedereen

QLoRA gaat een stap verder dan LoRA. Het laadt het basismodel in 4-bit precisie met een speciaal gegevenstype genaamd NormalFloat4 (NF4), en past dan LoRA-adapters bovenop toe. De 4-bit kwantisering verlaagt VRAM-gebruik met nog eens ~25% vergeleken met standaard LoRA, terwijl bijna identieke kwaliteit behouden blijft.

Dit maakt fine-tuning toegankelijk. Een 7B-model dat 100+ GB nodig heeft voor volledig fine-tunen past in 12 GB met QLoRA.

Verdict: Voor 90% van de ontwikkelaars is QLoRA de juiste keuze. Het kwaliteitsverschil met volledig fine-tunen is verwaarloosbaar voor de meeste taken, en de hardwarebesparing is enorm. Begin daar en schaal alleen op als je evaluatiemetrics het eisen.

Welk Fine-Tuning Framework Gebruik je in 2026?

Een framework kiezen is belangrijker dan de meeste mensen beseffen. Het juiste bespaart uren aan setup en versnelt het training aanzienlijk. Hier is hoe de vier grote opties zich verhouden.

Hier de snelle aanbeveling:

• Eerste fine-tune? Gebruik Unsloth. Snelste training, gemakkelijkste setup, gratis Colab-notebooks om direct te starten.
• Wil je een web-UI zonder code? Gebruik LLaMA-Factory. De LLaMA-Board GUI laat je training configureren en starten vanuit een browser.
• Doe je alignment (RLHF, DPO, GRPO)? Gebruik TRL. Het is de Hugging Face standaard voor op voorkeur gebaseerde training, en v0.15.0 (maart 2026) heeft native GRPO-ondersteuning toegevoegd.
• Productie-pipelines op multi-GPU? Gebruik Axolotl. YAML-gebaseerde configs maken experimenten reproduceerbaar en auditeerbaar.

Een handige truc: Unsloth en LLaMA-Factory kunnen gecombineerd worden. LLaMA-Factory ondersteunt Unsloth als trainingsbackend, wat je de GUI-gemakken geeft met de snelheidsoptimalisaties van Unsloth.

Hoe Bereid je een Fine-Tuning Dataset Voor?

Datakwaliteit is de belangrijkste factor voor fine-tuning-succes. Een goed samengestelde dataset van 500 voorbeelden zal bijna altijd een ruis-rijke dataset van 10.000 voorbeelden overtreffen.

Dataset-Formaten

De twee dominante formaten zijn chat (OpenAI-compatibel) en instruction (Alpaca-stijl). Hier is hoe elk eruitziet in JSONL-formaat:

Chat-formaat (aanbevolen voor de meeste use cases):

{"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-formaat (Alpaca-stijl):

{"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)"}

Richtlijnen voor Datasetgrootte

Hoeveel data heb je eigenlijk nodig? Het hangt af van taakcomplexiteit:

1. 50–100 voorbeelden -- proof of concept, genoeg om te testen of fine-tuning helpt
2. 500–1.000 voorbeelden -- nuttig voor de meeste enkelvoudige taken (classificatie, extractie, opmaak)
3. 5.000–10.000 voorbeelden -- productiekwaliteitsresultaten voor complexe taken
4. 10.000+ voorbeelden -- afnemende meeropbrengst tenzij je taak een hoge variabiliteit heeft

Datakwaliteits-Checklist

Valideer je dataset voor het trainen aan deze criteria:

• Consistente opmaak in alle voorbeelden (zelfde systeem-prompt, zelfde uitvoerstructuur)
• Diverse voorbeelden die randgevallen en foutmodi dekken
• Geen tegenstrijdigheden (leer het model niet om zowel "ja" als "nee" te zeggen op hetzelfde invoerpatroon)
• Gebalanceerde verdeling van uitvoertypes (bij classificatie niet 90% van de voorbeelden in één klasse)
• Verwijder duplicaten en bijna-dubbele invoer

Pro-tip: Gebruik GPT-4 of Claude om initiële synthetische trainingsdata te genereren, en verfijn daarna met menselijke review. 500 hoogwaardige synthetische voorbeelden overtreffen vaak 5.000 ruisrijke echte voorbeelden. Meta's fine-tuning gids beveelt deze aanpak aan voor het bootstrappen van datasets.

Stap-voor-Stap: Llama 3 8B Fine-Tunen met QLoRA en Unsloth

Hier is de volledige walkthrough. Elk codeblok is klaar om te kopiëren en plakken -- je kunt dit draaien in een gratis Google Colab-notebook of op elke machine met 12+ GB VRAM.

Stap 1: Unsloth Installeren

pip install unsloth

Dat is alles. Unsloth verwerkt alle afhankelijkheden (transformers, peft, trl, bitsandbytes) automatisch.

Stap 2: Het Basismodel in 4-Bit Laden

from unsloth import FastLanguageModel

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

Dit downloadt het 4-bit gekwantiseerde model (~4 GB) en laadt het in GPU-geheugen. Op een RTX 3060 (12 GB) heb je ruim voldoende voor training.

Stap 3: LoRA-Adapters Configureren

# Voeg LoRA-adapters toe aan het model
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                # LoRA-rang -- 16 is de sweet spot voor de meeste taken
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,       # Schaalfactor (gewoonlijk gelijk aan r)
    lora_dropout=0,      # Unsloth optimaliseert voor 0 dropout
    bias="none",
)

Met r=16 train je ongeveer 40 miljoen parameters van 8 miljard -- minder dan 0,5% van het model. Dat is de magie van LoRA.

Stap 4: Je Dataset Laden

from datasets import load_dataset

# Laad je JSONL-dataset van Hugging Face Hub of lokaal bestand
dataset = load_dataset("json", data_files="train.jsonl", split="train")

# Formateer naar 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)

Dit neemt het JSONL-chatformaat uit de vorige sectie en past Llama 3's chattemplate toe. De tokenizer verwerkt alle speciale tokens (<|begin_of_text|>, <|eot_id|>, etc.).

Stap 5: Training Configureren en Starten

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,    # Effectieve batchgrootte = 8
        warmup_steps=5,
        max_steps=60,                     # Aanpassen op basis van datasetgrootte
        learning_rate=2e-4,               # Standaard voor QLoRA
        fp16=not is_bfloat16_supported(),
        bf16=is_bfloat16_supported(),
        logging_steps=1,
        output_dir="outputs",
        seed=42,
    ),
)

# Start training
trainer.train()

Belangrijke hyperparameters om te begrijpen:

• Learning rate (2e-4): De standaard voor QLoRA. Ga lager (2e-5) als je ziet dat het model algemene capaciteiten vergeet.
• Batchgrootte (2) x gradiëntaccumulatie (4): Effectieve batchgrootte van 8. Verhoog gradient_accumulation als je GPU geheugen tekortkomt.
• max_steps (60): Voor 500 voorbeelden is dit ongeveer 1 epoch. Begin met 1–3 epochs en kijk naar de validatieverliezen.
• Rang r (16): Lager (4–8) voor eenvoudige taken, hoger (32–64) voor complexe taken. 16 is een veilige standaard.

Stap 6: Opslaan en Testen

# Sla de LoRA-adapters op (klein -- ~50-200 MB)
model.save_pretrained("my-fine-tuned-model")
tokenizer.save_pretrained("my-fine-tuned-model")

# Snelle inferentietest
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))

Dat is de volledige pipeline. Op een RTX 4090 met Unsloth duurt het trainen van 500 voorbeelden ongeveer 15–30 minuten. Op een gratis Colab T4 reken je op 1–2 uur.

Wat Met API-Gebaseerd Fine-Tuning? (OpenAI, Google, Mistral)

Niet iedereen wil GPU's beheren. API-providers laten je fine-tunen via een eenvoudige upload-en-train workflow. Hier is hoe ze zich verhouden tot lokaal draaien.

Wanneer API-fine-tuning zinvol is: Je moet snel itereren, je dataset is klein, je wilt geen infrastructuur beheren, of je hebt specifiek een gesloten model zoals GPT-4o nodig.

Wanneer lokale fine-tuning wint: Gegevensprivacy is belangrijk (zorg, financiën, juridisch), je traint regelmatig, je wilt de gewichten bezitten en exporteren, of je optimaliseert voor kosten op schaal.

Verdict: API-fine-tuning is het snelste pad naar een proof of concept. Lokale fine-tuning is het goedkoopste pad naar productie. De meeste teams prototypen op een API, en schakelen dan over naar lokale Unsloth zodra ze de aanpak gevalideerd hebben.

Hoeveel Kost het Fine-Tunen van een LLM?

Het verhaal dat "fine-tuning duur is" zit nog vast in 2023. Hier zijn de werkelijke kosten vandaag.

De kostencurve vlakt snel af. Een startup die een 8B-model fine-tunet op RunPod geeft minder uit aan training dan aan een kopje koffie. Zelfs het 70B-productiescenario is onder de €30 -- dat is het lunch-budget van een junior developer voor een maand.

Cloud GPU-providers om te vergelijken: RunPod (beste spotprijzen), Lambda (betrouwbare on-demand H100s), Vast.ai (goedkoopst maar variabele kwaliteit) en Modal (serverless, per seconde betalen).

De bovenstaande grafiek laat zien waarom QLoRA het spel veranderd heeft. Een 7B-model dat een multi-GPU-cluster nodig had voor volledig fine-tunen past nu op een laptop-GPU. Het 70B-model daalt van "alleen cloud" naar één enkele A100.

Verdict: Je kunt een productiekwaliteit 8B-model fine-tunen voor minder dan €1. De kostenbarrière voor fine-tuning is verdwenen. De echte kosten zijn de tijd voor het voorbereiden van de dataset.

Hoe Evalueer je een Fine-Getuned Model?

Training is maar de helft van het werk. Zonder goede evaluatie kun je niet zeggen of je fine-getuned model daadwerkelijk verbeterd is -- of dat het gewoon je trainingsdata heeft gememoriseerd.

Geautomatiseerde Metrics

Volg deze tijdens en na het trainen:

• Trainingsverlies / perplexiteit: Moet gestaag afnemen en dan stabiliseren. Als het bijna naar nul daalt, ben je aan het overfitten.
• Taakspecifieke metrics: Nauwkeurigheid (classificatie), BLEU/ROUGE (samenvatting), exacte overeenkomst (extractie), F1 (multi-label). Kies de metric die overeenkomt met je taak.

Menselijke Evaluatie

Cijfers vangen niet alles. Voor generatieve taken:

• A/B-testen: Toon basismodel- vs. fine-getuned uitvoer naast elkaar. Laat 3–5 evaluatoren de betere reactie kiezen uit 50+ voorbeelden. Volg de winstpercentages.
• Likert-schaal beoordeling: Beoordeel uitvoer op relevantie (1–5), nauwkeurigheid (1–5) en toon (1–5). Bereken de gemiddelde verbetering ten opzichte van het basismodel.

Catastrofaal Vergeten Check

Dit is het deel dat de meeste ontwikkelaars overslaan. Na het fine-tunen, draai je model op een algemeen benchmark zoals MMLU of HellaSwag. Als scores meer dan 2–3 punten dalen, heeft je model te veel algemene kennis verloren. De oplossing: verlaag je learning rate, verminder epochs of schakel over naar LoRA (dat de basisgewichten bevriest).

Praktische regel: Houd altijd 10–20% van je dataset achter als testset. Evalueer nooit op trainingsdata -- dat vertelt je niets over echte prestaties.

Hoe Deploy je een Fine-Getuned Model?

Training is klaar. Nu moet je het serveren. De meeste gidsen slaan dit deel volledig over.

Stap 1: LoRA-Adapters Samenvoegen

Als je LoRA of QLoRA hebt gebruikt, voeg je de adapters terug samen in het basismodel voor inferentie:

# Voeg adapters samen met basismodel
model.merge_and_unload()
model.save_pretrained("merged-model")
tokenizer.save_pretrained("merged-model")

Stap 2: Kies je Deployment-Pad

Lokale ontwikkeling en testen -- Ollama:

# Converteer naar GGUF-formaat (Ollama's native formaat)
python llama.cpp/convert_hf_to_gguf.py merged-model --outfile model.gguf --outtype q4_k_m

# Maak een Ollama-model aan
ollama create my-fine-tuned-model -f Modelfile
ollama run my-fine-tuned-model

Productie serving -- vLLM:

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

Serverless (nul infrastructuur): Upload je model naar Together AI, Fireworks of Modal. Je krijgt een API-endpoint zonder servers te beheren. Kosten schalen met gebruik.

Geavanceerd: Multi-Adapter Serving

Hier is een patroon dat meer teams zouden moeten gebruiken: één basismodel in het geheugen houden en LoRA-adapters per request wisselen. Je zou een klantenservice-adapter, een code-review-adapter en een samenvattings-adapter kunnen bedienen -- allemaal van één GPU. vLLM ondersteunt dit native met de --enable-lora vlag.

Wat Zijn de Meest Voorkomende Fine-Tuning Fouten?

Na het debuggen van tientallen fine-tuning runs zijn dit de fouten die steeds weer opduiken.

1. Overfitten op kleine datasets. Je traint 10 epochs op 200 voorbeelden, het trainingsverlies komt bijna op nul, en het model herhaalt je trainingsdata letterlijk. Oplossing: maximaal 1–3 epochs, gebruik een validatieset en let op het verschil tussen trainingsverlies en evaluatieverlies.

2. Catastrofaal vergeten. Het model beheerst je specifieke taak maar kan geen normale gesprekken meer voeren. Oplossing: gebruik LoRA/QLoRA (bevriest basisgewichten), houd learning rates laag (2e-5 voor full fine-tuning, 2e-4 voor QLoRA) en evalueer op algemene benchmarks voor deployment.

3. Slechte datakwaliteit. Inconsistente opmaak, tegenstrijdigheden tussen voorbeelden of duplicaten. Het model leert de ruis. Oplossing: maak je data schoon voor het trainen. Altijd. Besteed meer tijd aan datacuratie dan aan hyperparameter-tuning.

4. Beginnen met een te groot model. Teams springen naar 70B omdat "groter beter is", maar kunnen de GPU-kosten dan niet betalen. Oplossing: begin met 8B. Als 8B met goede data je taak niet kan oplossen, zal 70B met dezelfde data het waarschijnlijk ook niet. Schaal eerst de datakwaliteit op, dan de modelgrootte.

5. Geen evaluatiepipeline. Trainen zonder een achtergehouden testset, dan deployen op basis van gevoel. Oplossing: splits je data 80/10/10 (train/val/test) voordat je begint. Vergelijk met het basismodel op elk testvoorbeeld.

6. Te hoge learning rate. Vernietigt de voorgetrainde kennis in de eerste stappen. Het model geeft wartaal uit. Oplossing: begin bij 2e-4 voor QLoRA, 2e-5 voor full fine-tuning. Als uitvoer verslechtert, ga dan lager.

Hoe Techsy LLM Fine-Tuning Aanpakt

Bij Techsy volgen we voor elk AI-project een strikte escalatieweg: prompt engineering eerst, RAG als tweede, fine-tuning alleen als de data aantoont dat het nodig is. De meeste klantprojecten vereisen eigenlijk geen fine-tuning -- goed ontworpen prompts of een RAG-pipeline lossen het probleem op met lagere kosten en complexiteit.

Als fine-tuning de juiste keuze is, verloopt ons proces zo:

1. Dataset-audit -- We bekijken de data van de klant op kwaliteit, dekking en opmaak. Als we niet genoeg voorbeelden hebben, helpen we een synthetische dataset op te bouwen met GPT-4 of Claude met menselijke review.
2. Framework-selectie -- Unsloth + QLoRA voor 90% van startupprojecten. Axolotl voor klanten die reproduceerbare multi-GPU-productiepipelines nodig hebben.
3. Training en evaluatie -- We trainen altijd met een achtergehouden testset en benchmarken tegen het basismodel. Als het fine-getuned model de doelmetric niet meetbaar verbetert, deployen we het niet.
4. Deployment -- vLLM voor productie-serving, multi-adapter patronen wanneer klanten meerdere gespecialiseerde modellen van één GPU nodig hebben.

We hebben fine-getuned modellen afgeleverd voor startups die geen enterprise GPU-budgetten konden betalen -- QLoRA op RunPod houdt kosten onder de €30 zelfs voor 70B-modellen.

Hulp nodig bij het fine-tunen van een LLM voor jouw use case? We helpen teams van ruwe data naar gedeployed model. Gratis consultatie aanvragen

Veelgestelde Vragen Over LLM Fine-Tuning

Wat is LLM fine-tuning?

LLM fine-tuning is het proces van een voorgetraind taalmodel trainen op je eigen taakspecifieke data zodat het die taak beter uitvoert. Je leert het model in feite nieuw gedrag, formaten of domeinexpertise aan die generieke prompting niet betrouwbaar kan bereiken.

Wanneer moet ik fine-tunen versus RAG gebruiken?

Fine-tune wanneer je wilt dat het model zich anders gedraagt -- consistent uitvoerformaat, domeinspecifieke taal, bepaalde toon. Gebruik RAG wanneer het model andere dingen moet weten, zeker als die kennis vaak verandert. Voor veel productiesystemen werkt een hybride aanpak het beste.

Hoeveel kost het fine-tunen van een LLM?

Ergens tussen de €0 en €540 afhankelijk van de schaal. De meeste individuele ontwikkelaars geven minder dan €1 uit met QLoRA op een RunPod RTX 4090 ($0,34/uur). Een 70B productiemodel op een A100 kost €17–27. Full fine-tuning op H100-clusters kost €270–540. API-fine-tuning (OpenAI) kost €3–25 voor 1.000 voorbeelden.

Kan ik een LLM fine-tunen op mijn laptop?

Ja, als je laptop een GPU heeft met 12+ GB VRAM. Een RTX 3060 laptop-GPU verwerkt 8B-modellen met QLoRA. Apple Silicon Macs met 16+ GB unified memory kunnen ook fine-tunen via MLX, hoewel het langzamer is dan CUDA. Voor grotere modellen heb je cloud-GPU's nodig.

Wat is het verschil tussen LoRA en QLoRA?

Beide voegen kleine trainbare adapterlagen toe terwijl het basismodel bevroren is. Het verschil: QLoRA kwantiseert ook het basismodel naar 4-bit precisie (NF4-gegevenstype), waardoor VRAM-gebruik met ~25% afneemt vergeleken met standaard LoRA. De kwaliteit is vrijwel identiek -- QLoRA bereikt 97–99% van de volledige fine-tuning kwaliteit.

Hoeveel trainingsvoorbeelden heb ik nodig?

Het hangt af van taakcomplexiteit. 50–100 voorbeelden zijn genoeg voor een proof of concept. 500–1.000 voorbeelden leveren nuttige resultaten op voor de meeste enkelvoudige taken. 5.000–10.000 voorbeelden leveren productiekwaliteit voor complexe taken. Boven de 10.000 heb je afnemende meeropbrengst tenzij je taak een extreem hoge variabiliteit heeft.

Welk basismodel moet ik fine-tunen in 2026?

Llama 3.x voor algemene taken (beste kwaliteits/grootte verhouding). Mistral voor Europese talen en efficiënte inferentie. Qwen 2.5 voor meertalige en codetaken. Phi-4 als je de kleinst mogelijke footprint nodig hebt. Gemma 2 voor integratie in het Google-ecosysteem.

Wat is GRPO en waarom is het belangrijk?

GRPO (Group Relative Policy Optimization), geïntroduceerd door DeepSeek, is een opvolger van RLHF voor alignment training. Het voornaamste voordeel: het vereist geen apart reward-model te trainen, wat de rekenkosten ongeveer halveert. TRL v0.15.0 ondersteunt GRPO native, waardoor het toegankelijk is voor iedereen die het Hugging Face-ecosysteem gebruikt.

Hoe voorkom ik catastrofaal vergeten?

Gebruik LoRA of QLoRA in plaats van full fine-tuning -- zij bevriezen de basismodelgewichten, wat algemene kennis bewaart. Houd je learning rate laag (2e-4 voor QLoRA, 2e-5 voor full). Train voor zo weinig epochs als nodig (1–3 is gewoonlijk genoeg). Na het trainen, draai je model op algemene benchmarks (MMLU, HellaSwag) om te verifiëren dat het niet achteruit gegaan is.

Kan ik tegelijk fine-tunen en RAG gebruiken?

Absoluut, en veel productiesystemen doen precies dat. Fine-tune voor gedrags- en formaatconsistentie, verbind dan RAG voor actuele kennisretrieval. Het fine-getuned model is beter in het gebruik van de opgehaalde context omdat het de taal en uitvoervereisten van je domein begrijpt.

Hoe lang duurt fine-tuning?

Voor de meeste projecten 30 minuten tot 8 uur. Een 8B-model met 500 voorbeelden op Unsloth + RTX 4090 is klaar in 15–30 minuten. Dezelfde job op een gratis Colab T4 duurt 1–2 uur. 70B-modellen op A100's duren 5–8 uur. Full fine-tuning op multi-GPU setups kan 20–40 uur duren.

Is de fine-tuning API van OpenAI het waard?

Voor snel prototypen ja. Je kunt een JSONL-bestand uploaden en in 30 minuten een fine-getuned GPT-4o-mini hebben zonder GPU-setup. Voor productie is lokale fine-tuning meestal beter: je bezit de gewichten, beheert je dataprivacy en de kosten zijn lager op schaal. De meeste teams beginnen met de API om de aanpak te valideren, en migreren dan naar lokaal.

Conclusie

Een LLM fine-tunen is niet langer de zwarte magie van twee jaar geleden. Hier zijn de belangrijkste lessen:

1. Begin met QLoRA + Unsloth -- verwerkt 90% van de use cases op consumenten-hardware
2. Goede data verslaat een groter model elke keer. Steek je energie in datasetkwaliteit, niet in GPU-upgrades.
3. De kostenbarrière is weg -- fine-tune een 8B-model voor minder dan €1 op cloud-GPU's
4. Evalueer altijd tegen het basismodel voor deployment. Als het niet meetbaar beter is, ship het dan niet.
5. Overweeg eerst RAG -- fine-tune alleen wanneer je het model anders wil laten gedragen, niet alleen andere dingen wil laten weten

Klaar om te implementeren? Bekijk onze Best LLM Fine-Tuning Tools & Platforms [binnenkort] voor een gedetailleerde vergelijking van training-frameworks en deployment-opties.

Als je deze gids nuttig vond, bekijk dan onze walkthrough over het kiezen van de juiste AI-stack voor de bredere architectuurbeslissingen rond AI-gestuurde producten.

Bronnen

• Unsloth GitHub Repository -- fine-tuning framework met 2–5x snelheidsverbeteringen
• Hugging Face TRL Documentatie -- SFTTrainer, DPO en GRPO-implementatie
• Hugging Face PEFT Documentatie -- LoRA en parameter-efficiënte fine-tuning
• QLoRA Paper (Dettmers et al., 2023) -- 4-bit NormalFloat kwantiseringsonderzoek
• LoRA Paper (Hu et al., 2021) -- low-rank adaptatie van grote taalmodellen
• OpenAI Fine-Tuning API Documentatie -- API-gebaseerde fine-tuning workflow
• RunPod GPU Cloud Prijzen -- referentie voor cloud GPU-kosten
• vLLM Documentatie -- productie LLM serving
• Meta Llama Fine-Tuning Gids -- officiële Llama trainingsaanbevelingen
• DeepSeekMath Paper (GRPO) -- Group Relative Policy Optimization