5 min read

AI

Het Kiezen van het Juiste AI-Model en Hardware

De Kernuitdaging: Model vs. Hardware

In wezen is de relatie eenvoudig:

  • Grotere, capabelere modellen vereisen over het algemeen krachtigere hardware.
  • De belangrijkste hardwarebron voor het draaien van Large Language Models (LLM’s) is meestal GPU-geheugen (VRAM).

Als je probeert een enorm model te draaien op een GPU met te weinig VRAM, zal het ofwel niet werken of extreem traag zijn (vooral als het systeem-RAM probeert te gebruiken, wat veel langzamer is voor deze taken).

De Modelzijde Begrijpen

Wanneer je naar modellen kijkt, vooral op platforms zoals Hugging Face of met tools zoals Ollama, bepalen een paar kernfactoren hun resourcebehoefte:

  1. Aantal Parameters (bijv. 7B, 13B, 70B):
- Dit is grofweg de "grootte" of "complexiteit" van het brein van het model. 'B' staat voor miljarden parameters.
- **Meer parameters betekent meestal dat het model _mogelijk_ slimmer is**, beter nuances begrijpt en meer kennis heeft.
- **MAAR, meer parameters vertalen zich direct naar meer benodigde VRAM en schijfruimte.**
  1. Kwantisatie (bijv. FP16, Q8_0, Q5_K_M, Q4_0):
- Denk hierbij aan het comprimeren van een bestand. Kwantisatie vermindert de precisie die wordt gebruikt om de parameters van het model (de getallen) op te slaan.
- **Waarom doen?** Om het model kleiner te maken! Een gekwantiseerd model neemt minder schijfruimte en, belangrijker nog, minder VRAM in beslag. Dit maakt het mogelijk grotere modellen op minder krachtige hardware te draaien.
- **De Afweging:** Minder precisie _kan_ de prestaties en nauwkeurigheid van het model verminderen. Het kan iets dommere fouten maken of nuance verliezen. Het doel is een balans te vinden.
- **Veelvoorkomende Types:**
  - `FP16` (Float Precision 16-bit): Half-precisie. Vaak de basis vóór kwantisatie. Goede kwaliteit, maar hogere VRAM-behoefte.
  - `Q8_0` (Gekwantiseerd 8-bit): Gebruikt 8 bits per parameter. Over het algemeen weinig kwaliteitsverlies t.o.v. FP16, maar de helft van de grootte.
  - `Q4_K_M`, `Q5_K_M`, enz. (Gekwantiseerd 4-bit, 5-bit, enz.): Gebruiken nog minder bits. Bieden aanzienlijke verkleining, waardoor grotere modellen op consument-GPU’s passen. `_K_M`-varianten worden vaak geprefereerd omdat ze slimme technieken gebruiken om kwaliteit beter te behouden dan eenvoudigere `_0` of `_1` types op hetzelfde bitniveau.
  - `Q2`, `Q3` (Gekwantiseerd 2/3-bit): Extreme kwantisatie. Zeer klein, maar vaak met aanzienlijk en soms onvoorspelbaar kwaliteitsverlies.
  1. Modelversie/Architectuur:
- Nieuwere modellen (zoals Qwen 2.5 vs Qwen 1.5, of Llama 3 vs Llama 2) presteren vaak beter dan oudere modellen _van dezelfde grootte_. Dit komt meestal door betere trainingstechnieken, meer data of verbeterde architecturen.
  1. Training vs. Inferentie:
    • Inferentie: Gewoon het model draaien om antwoorden te krijgen. Dit is wat de meeste mensen lokaal doen. VRAM-behoefte hangt vooral af van modelgewichten en conversatiecontext (KV-cache).
    • Training/Fine-tuning: Het model iets nieuws leren of aanpassen. Dit vereist veel meer VRAM omdat je niet alleen de gewichten, maar ook gradiënten en optimizerstaten moet opslaan (tussenberekeningen). We focussen hier vooral op inferentie, omdat dat meestal de start is.

De Hardwarezijde Begrijpen (Vooral VRAM bij Inferentie)

Hoeveel VRAM heb je echt nodig om een model te draaien (inferentie)? Dat hangt vooral af van een paar belangrijke dingen die op de GPU moeten worden opgeslagen:

  1. Modelgewichten: Dit is meestal het grootste deel. De benodigde VRAM hangt direct af van het aantal parameters en het kwantisatieniveau.
- **Grove Berekening:** `VRAM voor gewichten (GB) ≈ (Aantal parameters in miljarden * bits per parameter) / 8`
- _Voorbeeld (7 miljard parameters):_
  - `FP16 (16-bit)`: (7 \* 16) / 8 = 14 GB
  - `Q8_0 (8-bit)`: (7 \* 8) / 8 = 7 GB
  - `Q4_K_M (≈4-bit)`: (7 \* 4) / 8 = 3,5 GB
  - `Q2_K (≈2-bit)`: (7 \* 2) / 8 = 1,75 GB
  1. KV-cache (Key-Value Cache): Dit is geheugen dat wordt gebruikt om de context van een gesprek bij te houden. Zonder dit zou het model bij elk nieuw woord het hele gesprek opnieuw moeten lezen!
- **De grootte hangt sterk af van:**
  - **Contextlengte:** Hoeveel conversatiegeschiedenis het model kan verwerken (bijv. 4096 tokens, 32k tokens). Langere context = grotere KV-cache.
  - **Batchgrootte:** Hoeveel verzoeken je tegelijk verwerkt. Elk verzoek heeft zijn eigen KV-cache.
- **Impact:** De KV-cache kan gemakkelijk meerdere GB VRAM innemen, soms zelfs meer dan de modelgewichten, vooral bij lange contexten! Dit is vaak de bottleneck bij het draaien van modellen met lange contextvensters of meerdere gebruikers.
  1. Overhead: Een deel van de VRAM wordt altijd gebruikt door het GPU-stuurprogramma, de modelbibliotheken (zoals llama.cpp in Ollama) en de inferentie-engine zelf. Reken op 1–2GB of meer.

Alles Samen (Voorbeeldschatting):

Laten we de VRAM schatten voor een 7B Q4_K_M model (≈4-bit) met een standaard context van 4096 tokens voor één gebruiker:

  • Gewichten: ≈ 3,5 GB
  • KV-cache (schatting bij 4096 context): Ongeveer 4–8 GB (sterk variabel!)
  • Overhead: ≈ 1,5 GB
  • Totaal geschatte VRAM: 3,5 + 6 (gemiddelde schatting) + 1,5 = ~11 GB

Belangrijkste Inzicht: Zelfs een relatief klein 7B-model, gekwantiseerd tot 4-bit, kan de limiet van GPU’s met lage VRAM (zoals 8GB-kaarten) bereiken zodra je de KV-cache meerekent. Een 16GB-kaart is krap, terwijl 24GB meer speelruimte biedt. Meerdere gelijktijdige verzoeken vragen nog meer VRAM door meerdere KV-caches.

De Keuze Maken: Veelvoorkomende Afwegingen

Gebaseerd op communitydiscussies en benchmarks, zijn dit enkele algemene richtlijnen bij beperkte VRAM:

  • Meer Parameters vs. Minder Kwantisatie?
    • Over het algemeen geldt dat een groter model met meer kwantisatie beter presteert dan een kleiner model met minder kwantisatie, tot op zekere hoogte. Bijvoorbeeld, een 14B-model op Q4 kan beter zijn dan een 7B-model op Q8 of FP16, mits het in je VRAM past.
    • Sweet Spot: Kwantisatieniveaus zoals Q4_K_M en Q5_K_M bieden vaak de beste balans tussen grootte en prestaties voor veel modellen.
    • Vermijd Extremen: Q2 en Q3 leiden vaak tot aanzienlijke prestatieverlies en onvoorspelbaar gedrag. Een kleiner model op Q4 is meestal beter dan een groter op Q2. Boven Q5 nemen de baten snel af – de kwaliteitswinst van Q6 of Q8 is vaak niet de extra VRAM waard, tenzij je genoeg geheugen hebt.
  • Nieuwer vs. Ouder: Zoals vermeld, bieden nieuwere architecturen of versies (zoals Gemma 2 vs Gemma 1, of Llama 3 vs Llama 2) vaak betere resultaten, zelfs bij een vergelijkbaar of kleiner aantal parameters.
  • Nauwkeurigheid vs. Snelheid: Kleinere en sterker gekwantiseerde modellen draaien sneller (meer tokens per seconde), maar met mogelijk lagere kwaliteit.

Vergeet Systeem-RAM en CPU Niet!

Hoewel VRAM cruciaal is, spelen je gewone werkgeheugen (RAM) en processor (CPU) ook een belangrijke rol:

  • Systeem-RAM:
    • Nodig om het modelbestand van de schijf te laden voordat het naar de VRAM wordt gekopieerd.
    • Wordt gebruikt door het besturingssysteem, achtergrondtaken en de applicatie die het model bedient (zoals Ollama of een FastAPI-app).
    • Verwerkt gegevens (zoals invoertekst lezen).
    • Vuistregel: Zorg dat je minstens zoveel RAM hebt als de ongekwantiseerde modelgrootte (bijv. ~14GB RAM voor een 7B-model → 16GB minimaal, 32GB aanbevolen). Meer is nodig bij grote datasets of veel gelijktijdige verzoeken.
  • CPU:
    • Orkestreert het hele proces.
    • Verwerkt tokenisatie (woorden opdelen in tokens), draait de webserver en beheert verzoeken.
    • Een moderne multi-core CPU is aan te raden, maar bij inferentie is de GPU meestal de bottleneck (bij training is CPU-snelheid belangrijker).

Tools Zijn Ook Belangrijk (Kort)

Tools zoals Ollama maken het eenvoudig om modellen te draaien. Meer geavanceerde inferentie-engines zoals VLLM zijn ontworpen voor hoge prestaties (meer verzoeken per seconde, efficiënter VRAM-gebruik via technieken zoals PagedAttention), maar zijn complexer op te zetten. Voor beginners is Ollama uitstekend. Wie later maximale prestaties wil, kan alternatieven zoals VLLM overwegen.

Een Snelle Gids voor GGUF-Kwantisatietypes (Veelvoorkomende)

Bij gebruik van Ollama of llama.cpp zie je vaak GGUF-bestanden waarvan de naam de kwantisatie aanduidt. Hier is een grove kwaliteits-/groottehiërarchie (van kleinste/laagste kwaliteit tot grootste/hoogste kwaliteit):

  • Q2_K: Extreme kwantisatie (2-bit). Kleinste formaat, grootste kwaliteitsverlies. Alleen gebruiken bij zeer beperkte VRAM.
  • Q3_K_S, Q3_K_M, Q3_K_L: Agressieve (3-bit). Beter dan Q2, maar nog steeds merkbaar kwaliteitsverlies. _L is de beste binnen 3-bit.
  • Q4_0, Q4_1: Basis 4-bit. Redelijke verkleining. Nieuwere _K-methodes zijn meestal beter.
  • Q4_K_S, Q4_K_M: Populaire Keuze (4-bit). Uitstekende balans tussen grootte, VRAM-verbruik en kwaliteit. _M is iets groter/beter dan _S. Geweldige startoptie.
  • Q5_0, Q5_1: Basis 5-bit.
  • Q5_K_S, Q5_K_M: Populaire Keuze (5-bit). Iets betere kwaliteit dan Q4_K voor iets meer VRAM. _M is aanbevolen. Vaak de moeite waard als Q4_K_M goed past.
  • Q6_K: Hoge kwaliteit (6-bit). Merkbaar groter dan Q5_K. Goede optie bij voldoende VRAM en behoefte aan kwaliteit dicht bij Q8.
  • Q8_0: Bijna verliesvrij (8-bit). Zeer dicht bij FP16-kwaliteit. Vereist dubbel zoveel VRAM als Q4. Goed voor productie als hardware het toelaat.
  • FP16: Halfprecisie (16-bit). Geen kwantisatieverlies. Baseline voor kwaliteitsvergelijking. Vereist de meeste VRAM onder gangbare inferentietypes.
  • FP32: Volledige precisie (32-bit). Zelden gebruikt voor inferentie wegens enorme grootte. Vooral relevant bij training.

Aanbeveling: Voor een typisch 7B- of 13B-model op consument-GPU’s (zoals 16GB of 24GB VRAM) zijn Q4_K_M of Q5_K_M meestal de beste keuze om mee te beginnen.