# Fine-tunen van lokale modellen: de basis

Fine-tunen van lokale modellen past een bestaand model aan zodat het beter presteert op jouw specifieke taak. Het is een krachtige techniek, maar niet altijd de juiste keuze. Dit artikel legt de basis uit en helpt je beslissen of fine-tunen werkelijk nodig is.

[[TOC]]

## Wat is fine-tunen?

Een taalmodel is getraind op enorme hoeveelheden algemene tekst. Fine-tunen betekent dat je het model verder traint op een kleinere, specifieke set voorbeelden. Daardoor leert het jouw stijl, vakgebied of formaat beter aan. Het model verandert echt van binnen, anders dan bij een instructie die je per vraag meegeeft.

:::info title="Fine-tunen verandert het model zelf"
Bij fine-tunen pas je de parameters van het model aan. Het resultaat is een nieuw model dat jouw stijl of taak heeft geinternaliseerd, zonder dat je elke keer voorbeelden hoeft mee te geven.
:::

## Wanneer fine-tunen en wanneer niet?

Veel mensen denken te snel aan fine-tunen terwijl een eenvoudiger middel volstaat. Wil je het model toegang geven tot jouw documenten, dan is [[lokale-ai-rag-pipeline|RAG]] beter. Wil je een vaste toon of instructie, dan volstaat vaak een [[ollama-modelfile-aanmaken|Modelfile]]. Fine-tunen is pas zinvol als je een consistent gedragspatroon wilt dat met instructies niet lukt.

Gebruik deze vuistregel om de juiste techniek te kiezen:

| Wat je nodig hebt | Beste aanpak |
| --- | --- |
| Het model moet jouw documenten kennen | [[lokale-ai-rag-pipeline|RAG]] |
| Het model moet een vaste toon of rol hebben | [[ollama-modelfile-aanmaken|Modelfile]] |
| Het model moet een specifieke taak echt leren | Fine-tunen |
| Je wilt eerst gewoon iets uitproberen | [[ollama-installeren-macos|Start met Ollama]] |

## De rol van trainingsdata

Fine-tunen staat of valt met je trainingsdata. Je hebt voorbeelden nodig van invoer en gewenste uitvoer, vaak honderden tot duizenden. De kwaliteit van die voorbeelden bepaalt de kwaliteit van het resultaat. Slechte of inconsistente data levert een slechter model op, niet een beter.

:::warn title="Garbage in, garbage out"
Dit principe geldt extra sterk bij fine-tunen. Investeer ruim de meeste tijd in het zorgvuldig samenstellen en opschonen van je trainingsdata. Een klein, schoon dataset werkt beter dan een groot, rommelig dataset.
:::

## LoRA en QLoRA maken het haalbaar

Een volledig model fine-tunen vraagt enorme rekenkracht. Gelukkig bestaat LoRA (Low-Rank Adaptation), een techniek die slechts een klein deel van het model aanpast in plaats van alles. QLoRA gaat nog een stap verder door het basismodel in 4-bit te laden, waardoor het geheugengebruik fors daalt.

Dankzij deze technieken is een model van rond de 7 of 8 miljard parameters in 2026 te fine-tunen op een gewone computer. Met QLoRA en een tool als Unsloth lukt dat al op een videokaart met ongeveer 8 tot 12 GB geheugen, in een uur of wat. De resultaten zijn voor veel taken prima.

Het verschil op een rij:

- **LoRA** traint kleine aanpassingslagen bovenop het volledige basismodel. Geheugenvraag ligt grofweg in de orde van 16 tot 24 GB voor een model van 7 tot 8 miljard parameters.
- **QLoRA** kwantiseert het basismodel naar 4-bit en traint alleen de kleine adapters in hogere precisie. Daardoor zakt de geheugenvraag naar ongeveer 8 tot 12 GB.

## De basisstappen

Het fine-tunen zelf gebeurt meestal met een Python-framework dat de techniek voor je regelt. De gangbare stack in 2026 bestaat uit Python, PyTorch en de Hugging Face-bibliotheken `transformers`, `datasets`, `peft` en `trl`. Veel mensen gebruiken `Unsloth`, dat het trainen sneller maakt en het geheugengebruik beperkt.

Globaal doorloop je deze stappen:

:::howto title="Zo verloopt een fine-tune"
1. Stel een schone dataset samen van invoer- en uitvoervoorbeelden.
2. Laad een basismodel en kies LoRA of QLoRA als methode.
3. Stel een paar instellingen in, zoals het aantal trainingsronden en de leersnelheid.
4. Start het trainen en wacht tot het klaar is.
5. Test of het model zich beter gedraagt op jouw taak.
6. Converteer het resultaat naar een formaat dat je lokaal kunt draaien.
:::

## Je model in Ollama draaien

Na het fine-tunen wil je je model gewoon lokaal gebruiken. Er zijn twee routes, afhankelijk van wat je trainingstool oplevert.

:::accordion title="Twee manieren om je model in Ollama te krijgen"
De eerste route gebruikt een losse LoRA-adapter. Je maakt een Modelfile met `FROM <basismodel>` en daaronder `ADAPTER /pad/naar/adapter`. Belangrijk: gebruik in `FROM` exact hetzelfde basismodel als waarop je hebt getraind, anders krijg je onbetrouwbare resultaten.

De tweede route gebruikt een samengevoegd model. Je converteert het resultaat naar het GGUF-formaat, maakt een Modelfile met `FROM ./mijn-model.gguf` en importeert het met `ollama create mijn-model -f Modelfile`. Daarna draait het met `ollama run mijn-model`.
:::

:::tip title="Begin klein en realistisch"
Fine-tunen is geen wondermiddel en kost tijd om goed te doen. Probeer eerst RAG en een Modelfile uit. Lukt het daarmee niet, dan is fine-tunen de logische volgende stap, met een duidelijk doel voor ogen.
:::

## Verwachtingen managen

Fine-tunen maakt een model niet algemeen slimmer; het maakt het beter in een specifieke taak die je traint. Verwacht geen sprongen in algemene intelligentie. Wel kun je een model leren consequent in jouw format te antwoorden, een vakjargon te beheersen of een vaste structuur aan te houden.

:::faq
### Is fine-tunen hetzelfde als RAG?
Nee. RAG geeft documenten mee bij elke vraag zonder het model te wijzigen. Fine-tunen verandert het model zelf. Voor kennis is RAG meestal beter, voor gedrag fine-tunen.

### Heb ik een dure videokaart nodig om te fine-tunen?
Met LoRA en zeker met QLoRA niet per se. Deze technieken passen slechts een klein deel van het model aan, waardoor een model van 7 tot 8 miljard parameters op een videokaart met ongeveer 8 tot 12 GB geheugen haalbaar wordt.

### Hoeveel voorbeelden heb ik nodig?
Dat hangt af van de taak, maar reken op honderden tot duizenden schone, consistente voorbeelden voor een goed resultaat.

### Wat is het verschil tussen LoRA en QLoRA?
LoRA traint kleine aanpassingslagen bovenop het volledige model. QLoRA laadt het basismodel eerst in 4-bit, waardoor het geheugengebruik verder daalt en het op lichtere hardware past.

### Kan ik een fine-getuned model in Ollama draaien?
Ja. Je voegt een LoRA-adapter toe via `FROM` plus `ADAPTER` in een Modelfile, of je converteert het samengevoegde model naar GGUF en importeert het met ollama create. Daarna draait het gewoon lokaal.

### Welk framework gebruik ik om te fine-tunen?
De gangbare keuze in 2026 is Python met PyTorch en de Hugging Face-bibliotheken peft en trl. Tools als Unsloth maken het trainen sneller en zuiniger met geheugen.
:::

Fine-tunen is de geavanceerde stap als RAG en Modelfiles niet volstaan. Verken eerst [[lokale-ai-rag-pipeline|de RAG-aanpak]] of een [[ollama-modelfile-aanmaken|Modelfile]] voordat je aan fine-tunen begint.