De complete technische gids over grote taalmodellen — van hoe ruwe tekst getallen wordt, via de transformer-architectuur en het attention-mechanisme, tot training, alignment, inferentie, RAG en productie-implementatie. Geen vaagheid; echte vergelijkingen en echte code.
Een groot taalmodel (LLM) is een neuraal netwerk dat is getraind om het volgende token in een tekstsequentie te voorspellen. Dat ene doel — voorspelling van het volgende token — blijkt buitengewoon krachtig: om goed te voorspellen moet het model grammatica, feiten, redeneerpatronen, codesyntax en veel meer leren.
Het woord „groot“ verwijst naar het aantal parameters (miljarden tot biljoenen geleerde gewichten) en de omvang van de trainingsdata (biljoenen tokens uit het web, boeken en code). Bij voldoende schaal vertonen modellen emergente capaciteiten — vermogens die niet aanwezig zijn in kleinere modellen en niet expliciet getraind zijn, zoals meerstapsrekenkunde, analoog redeneren en in-context-learning uit een handvol voorbeelden.
Architectonisch is elk groot LLM van vandaag een decoder-only transformer (GPT-familie, Llama, Mistral, Claude, Gemini). Het model neemt een sequentie van token-ID's als invoer en produceert een kansverdeling over het vocabulaire voor het volgende token. Generatie is autoregressief: het model sampelt een token, voegt het toe aan de sequentie en herhaalt.
graph LR A[Input Text] --> B[Tokenizer] B --> C[Token IDs] C --> D[Embedding Layer] D --> E[Transformer Blocks xN] E --> F[LM Head] F --> G[Logits over Vocabulary] G --> H[Softmax + Sampling] H --> I[Next Token] I -->|Autoregressive loop| C
Capaciteiten die pas boven bepaalde schaaldrempels verschijnen — few-shot-learning, chain-of-thought-redeneren, instructies volgen — die niet expliciet getraind zijn.
Het model past zijn gedrag aan op basis van voorbeelden in de prompt (few-shot) zonder enige gewichtsaanpassing. Het contextvenster is het enige „geheugen“ tijdens inferentie.
De modelgewichten coderen een lossy compressie van het trainingscorpus. Feiten worden niet woordelijk opgeslagen — ze zijn verspreid over miljarden gewichten, en daarom treden hallucinaties op.
LLM's werken niet op karakters of woorden — ze werken op tokens, subwoordeenheden die worden geproduceerd door een tokenizer die op hetzelfde corpus is getraind. Inzicht in tokenization verklaart kosten, contextlengte en veel eigenaardigheden van modelgedrag.
GPT-2, GPT-3, GPT-4o, Llama 4, Mistral Large 3
Voegt iteratief het meest frequente aangrenzende byte- of karakterpaar samen. Begint bij afzonderlijke bytes en verwerkt daardoor elke Unicode-tekst zonder onbekende tokens.
BERT, DistilBERT, ALBERT
Vergelijkbaar met BPE, maar de samenvoegingen worden gekozen om de waarschijnlijkheid van de trainingsdata onder een taalmodel te maximaliseren, in plaats van de ruwe frequentie.
T5, Gemma, Qwen
Behandelt tokenization als een probabilistisch segmentatieprobleem. Taalonafhankelijk — werkt op ruwe tekst zonder voor-tokenization (spaties worden als gewone karakters behandeld).
| Woord | GPT-4o-tokens | Aantal tokens |
|---|---|---|
| transformer | transformer | 2 |
| tokenization | tokenization | 2 |
| def calculate_loss(logits): | def calculate_loss(logits): | 6 |
| Üniversität | Üniversität | 4 |
| hello | hello | 1 |
| (3 spaces) | 1 |
| Model | Tokenizer | Vocab-grootte | Opmerking |
|---|---|---|---|
| GPT-2 | BPE | 50,257 | Byte-level BPE |
| GPT-3 / GPT-3.5 | BPE (cl100k) | 100,277 | Gelijk aan GPT-4 |
| GPT-4 / GPT-4o | BPE (o200k) | 200,019 | Beter meertalig |
| Llama 3.x / 4.x | BPE (tiktoken) | 128,256 | Verbeterd t.o.v. de 32k van Llama 2 |
| Mistral v0.x | BPE (SentencePiece) | 32,768 | Klein maar efficiënt |
| Gemma 2 | SentencePiece | 256,000 | Zeer groot meertalig vocabulaire |
import tiktoken
# GPT-4o uses the o200k_base encoding
enc = tiktoken.get_encoding("o200k_base")
text = "Tokenization is the first step in every LLM pipeline."
tokens = enc.encode(text)
print(f"Token IDs: {tokens}")
# Token IDs: [5808, 2065, 374, 279, 1176, 3094, 304, 1475, 445, 11237, 15598, 13]
print(f"Token count: {len(tokens)}") # 12
print(f"Decoded: {[enc.decode([t]) for t in tokens]}")
# ['Token', 'ization', ' is', ' the', ' first', ' step', ' in', ' every', ' L', 'LM', ' pipeline', '.']
# Cost estimation: GPT-4o input = $2.50 / 1M tokens
cost_per_token = 2.50 / 1_000_000
print(f"Cost for this sentence: ${cost_per_token * len(tokens):.8f}")Geïntroduceerd in „Attention Is All You Need“ (Vaswani et al., 2017), verving de transformer recurrente netwerken door een volledig op attention gebaseerde architectuur. Elk groot LLM van vandaag bouwt op dit fundament.
graph TD A[Input Tokens] --> B[Token Embeddings] B --> C[+ Positional Encoding] C --> D[Multi-Head Self-Attention] D --> E[Add and Layer Norm] E --> F[Feed-Forward Network] F --> G[Add and Layer Norm] G --> H[Next Block or Output]
Het kerninzicht van de transformer: elk token kan tegelijkertijd aandacht besteden aan elk ander token in de sequentie. Uit een invoermatrix X produceren drie geleerde projecties queries (Q), keys (K) en values (V):
Multi-head attention voert H onafhankelijke attention-bewerkingen parallel uit, elk met verschillende geleerde projecties. Hierdoor kan het model gezamenlijk aandacht besteden aan informatie uit verschillende representatie-deelruimten. GPT-3 gebruikt 96 attention-heads; Llama 4 Maverick gebruikt grouped-query attention (GQA) voor efficiënte serving.
import torch
import torch.nn.functional as F
def scaled_dot_product_attention(Q, K, V, mask=None):
"""
Q, K, V: (batch, heads, seq_len, head_dim)
Returns: (batch, heads, seq_len, head_dim)
"""
d_k = Q.size(-1)
# Compute attention scores
scores = torch.matmul(Q, K.transpose(-2, -1)) / (d_k ** 0.5) # (batch, heads, seq, seq)
# Apply causal mask (decoder: attend only to past tokens)
if mask is not None:
scores = scores.masked_fill(mask == 0, float('-inf'))
# Softmax over key dimension
attn_weights = F.softmax(scores, dim=-1)
# Weighted sum of values
return torch.matmul(attn_weights, V), attn_weightsElk transformer-blok bevat een MLP met 2 lagen die onafhankelijk op elke tokenpositie wordt toegepast. De verborgen dimensie is doorgaans 4× de modeldimensie (bijv. d_model=4096, d_ff=16384 voor een typisch model van de 8B-klasse). Moderne LLM's gebruiken SwiGLU-activatie (een gated variant van SiLU) die ReLU en GELU empirisch overtreft.
FFN-lagen slaan het grootste deel van de feitelijke kennis in een model op — onderzoek toont dat „kennisneuronen“ geconcentreerd in de FFN kunnen worden gelokaliseerd en chirurgisch bewerkt (zie ROME/MEMIT). Attention verzorgt routering en compositie; FFN-lagen verzorgen de opslag.
Elke sublaag (attention, FFN) gebruikt een residuverbinding (output = x + sublayer(x)) en layer-normalisatie. Moderne LLM's gebruiken Pre-Norm (normaliseren vóór de sublaag) in plaats van Post-Norm voor trainingsstabiliteit, en RMSNorm (Root Mean Square-norm, zonder gemiddeldecentrering) voor efficiëntie.
| Type | Voorbeelden | Attention | Best voor |
|---|---|---|---|
| Encoder-only | BERT, RoBERTa, DeBERTa | Bidirectioneel (volledige attention) | Classificatie, NER, embeddings |
| Decoder-only | GPT-4o, Llama 4, Mistral Large 3, Claude Sonnet 4.6 | Causaal (van links naar rechts) | Tekstgeneratie, chat, redeneren |
| Encoder-Decoder | T5, FLAN-T5, BART | Volledige encoder + cross-attention | Vertaling, samenvatting, seq2seq |
Pretraining is de duurste fase — doorgaans meer dan 95 % van de totale rekenkracht. Het model ziet biljoenen tokens en leert het volgende te voorspellen. Dit eenvoudige doel produceert bij voldoende schaal de meeste capaciteiten die we met LLM's associëren.
Gegeven een sequentie van tokens [t₁, t₂, ..., tₙ] wordt het model getraind om de log-waarschijnlijkheid van elk token, gegeven alle voorafgaande tokens, te maximaliseren:
Elke voorwaartse doorloop verwerkt een volledige sequentie en produceert parallel op elke positie een verlies (teacher forcing). Tijdens inferentie worden tokens autoregressief gegenereerd, één voor één.
Hoffmann et al. (2022) toonden aan dat eerdere grote modellen (GPT-3, Gopher) ondergetraind waren — te veel parameters voor te weinig tokens. De optimale Chinchilla-verhouding is:
Optimale tokens ≈ 20× parameters
Een model met 7B parameters zou moeten trainen op ~140B tokens voor reken-optimale training. In de praktijk trainen modellen op veel meer (Llama 3.1 8B: 15T tokens; Llama 4-modellen: ~40T gesch.) omdat inferentiekosten ertoe doen — een kleiner maar meer getraind model is goedkoper om te serveren.
| Model | Parameters | Trainings-tokens | Jaar |
|---|---|---|---|
| GPT-2 | 117M – 1.5B | ~10B | 2019 |
| GPT-3 | 175B | ~300B | 2020 |
| Chinchilla | 70B | 1.4T | 2022 |
| Llama 2 (historical) | 7B – 70B | 2T | 2023 |
| Mistral 7B | 7.3B | ~8T (est.) | 2023 |
| Llama 3.1 8B | 8B | 15T | 2024 |
| Llama 3.1 405B | 405B | 15T | 2024 |
| Llama 4 Scout | ~17B active (MoE) | ~40T (est.) | 2025 |
| Llama 4 Maverick | ~17B active (MoE) | ~40T (est.) | 2025 |
Web-crawl op petabyte-schaal, ruw en gefilterd. Vormt het grootste deel van de meeste pretraining-corpora. Vereist uitgebreide kwaliteitsfiltering (deduplicatie, taaldetectie, verwijdering van toxiciteit).
Gecureerde dataset van 825 GB over 22 bronnen, waaronder GitHub, ArXiv, PubMed, FreeLaw, DM Mathematics. Open en reproduceerbaar.
Open reproducties van de LLaMA-trainingsdata. DCLM (DataComp-LM, 2024) richt zich op rigoureuze datakwaliteits-ablaties om optimale filterpijplijnen te vinden.
Books3, Gutenberg, ArXiv, S2ORC. Hoge signaal-ruisverhouding; cruciaal voor langvormig redeneren en feitelijke diepgang.
Elke GPU houdt een modelreplica; batches worden over GPU's verdeeld. Gradiënten worden na elke achterwaartse doorloop gemiddeld (AllReduce). Standaard voor alle groottes.
Afzonderlijke gewichtsmatrices worden over GPU's verdeeld. Vereist een interconnect met hoge bandbreedte (NVLink). Gebruikt voor modellen die het VRAM van één GPU overschrijden.
Verschillende lagen toegewezen aan verschillende GPU's. Micro-batches stromen door de pijplijn. Efficiënt voor zeer diepe modellen; vereist zorgvuldige planning om bubbels te minimaliseren.
Een vooraf getraind basismodel is een krachtige maar onvoorspelbare voorspeller van het volgende token — het zet elke tekst voort, inclusief schadelijke inhoud. Alignment-training transformeert het tot een behulpzame, onschadelijke en eerlijke assistent.
Het basismodel wordt fijngeregeld op een dataset van (instructie, ideale respons)-paren, geschreven of gecureerd door menselijke annotatoren. Dit leert het model het formaat van het volgen van instructies. Het trainingsdoel is identiek aan pretraining (cross-entropy), maar de dataset is klein (tienduizenden voorbeelden) en van hoge kwaliteit. Na SFT kan het model instructies volgen maar kan het nog onwaar of schadelijk zijn.
graph LR A[Pretrained LLM] --> B[SFT on Instruction Data] B --> C[SFT Model] C --> D[Generate Completions] D --> E[Human Preference Labels] E --> F[Train Reward Model] F --> G[RLHF with PPO] G --> H[Aligned LLM]
Reward-model: Menselijke annotatoren vergelijken paren van modelresponsen en labelen hun voorkeur. Een apart model wordt getraind om de door mensen geprefereerde respons voor een gegeven prompt te voorspellen. Dit scalaire reward-signaal vangt genuanceerde kwaliteitsoordelen die moeilijk als verliesfunctie te specificeren zijn.
PPO (Proximal Policy Optimisation): Het SFT-model (de „policy“) wordt geoptimaliseerd om de score van het reward-model te maximaliseren, terwijl een KL-divergentiestraf voorkomt dat het te ver van de SFT-baseline afdrijft (wat reward hacking zou veroorzaken). PPO is rekenkundig duur: het vereist vier modellen tegelijk in het geheugen.
Rafailov et al. (2023) toonden aan dat het RLHF-doel rechtstreeks op het policy-model kan worden geoptimaliseerd zonder apart reward-model of RL-lus. Gegeven paren van geprefereerde en afgewezen responsen herparametriseert DPO de reward als functie van de log-waarschijnlijkheden van het policy- en referentiemodel:
DPO is eenvoudiger, stabieler en goedkoper dan RLHF met PPO. De meeste open-source uitgelijnde modellen (Llama 4 Instruct, Mistral Instruct) gebruiken DPO of een variant (SimPO, IPO) voor de voorkeursalignmentfase.
| Methode | Reward-model | RL-lus | Stabiliteit | Gebruikt door |
|---|---|---|---|---|
| RLHF (PPO) | Ja | Ja (PPO) | Matig | InstructGPT, early ChatGPT |
| DPO | Nee | Nee | Hoog | Llama 4, Mistral, Zephyr |
| Constitutional AI (CAI) | Zelfkritiek | Ja (RLAIF) | Hoog | Claude (Anthropic) |
| GRPO / DAPO | Op regels gebaseerd | Groepsrelatief | Hoog | DeepSeek-R1, Qwen |
Bij elke generatiestap geeft het model een logit-vector van grootte |vocabulary| uit. De sampling-strategie bepaalt hoe één token uit deze verdeling wordt gekozen — en heeft een enorme impact op kwaliteit, diversiteit en coherentie van de uitvoer.
| Temperatuur | Effect | Toepassing |
|---|---|---|
| 0.0 (Greedy) | Kies altijd het token met de hoogste waarschijnlijkheid. Deterministisch. | Classificatie, gestructureerde extractie, feitelijke Q&A |
| 0.2 – 0.4 | Scherpere verdeling, volgt meestal het meest waarschijnlijke pad maar laat kleine variaties toe. | Codegeneratie, samenvatting |
| 0.6 – 0.8 | Gebalanceerd. Goede mix van coherentie en diversiteit. | Algemene chat, instructies volgen (standaard voor de meeste modellen) |
| 1.0 | Sampelt rechtstreeks uit de modelverdeling. Gevarieerder. | Creatief schrijven, brainstormen |
| > 1.0 | Vlakt de verdeling af. Verhoogt willekeur en herhaling. Produceert vaak incoherente uitvoer. | Zelden nuttig in productie |
Sorteer tokens op waarschijnlijkheid, neem de kleinste set waarvan de cumulatieve waarschijnlijkheid ≥ p, en sampel dan uit die set. Bij p=0,9 overweegt het model alleen tokens die samen 90 % van de waarschijnlijkheidsmassa uitmaken. Past de grootte van de kandidatenset dynamisch aan: bij zekerheid is de nucleus klein, bij onzekerheid breder.
Kap de verdeling af tot de k meest waarschijnlijke tokens en sampel daar dan uit. Eenvoudiger dan top-p maar gebruikt een vaste k ongeacht de vorm van de verdeling. Top-p heeft over het algemeen de voorkeur; top-k is nuttig wanneer u strikte controle over de grootte van de kandidatenset nodig hebt.
from openai import OpenAI
client = OpenAI()
# Factual / structured output: low temperature, no top-p
factual = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "What is the capital of France?"}],
temperature=0.0,
max_tokens=50,
)
# Creative writing: higher temperature + nucleus sampling
creative = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Write a haiku about neural networks."}],
temperature=0.9,
top_p=0.95,
max_tokens=100,
)
# Code generation: low temp, deterministic
code = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Write a Python quicksort function."}],
temperature=0.2,
max_tokens=300,
)Een transformer heeft geen inherent besef van tokenvolgorde — attention is permutatie-invariant. Positiecodering injecteert volgorde-informatie. De keuze van de coderingsmethode bepaalt hoe goed het model generaliseert naar sequenties die langer zijn dan zijn trainingslengte.
Een geleerde of vaste (sinusoïdale) vector wordt aan elk token-embedding op positie i toegevoegd. GPT-2 en BERT gebruiken geleerde absolute embeddings. Harde grens: het model kan niet generaliseren naar posities die het tijdens training nooit heeft gezien.
Codeert de positie door de Q- en K-vectoren in de complexe ruimte te roteren over een hoek evenredig met de positie. De attention-score hangt van nature af van de relatieve afstand tussen tokens. Gebruikt door Llama 4, Mistral Large 3, Qwen en de meeste moderne open-weight-modellen. Maakt context-uitbreidingstechnieken zoals YaRN en LongRoPE mogelijk.
Tijdens autoregressieve generatie herberekent het model bij elke stap de attention voor elk token — naïef O(n²) per stap. De KV-cache slaat de key- en value-tensoren van alle voorafgaande tokens op. Bij elke nieuwe stap worden alleen de Q, K, V van het nieuwe token berekend en worden de gecachte K, V toegevoegd. Dit reduceert de generatie van O(n²) naar O(n) per nieuw token.
| Model | Contextvenster | Positiecodering | Effectieve lengte* |
|---|---|---|---|
| GPT-4o | 128K | Geleerd + RoPE (gesch.) | 128K |
| Claude Sonnet 4.6 | 200K | Niet bekendgemaakt | ~150K (praktisch) |
| Gemini 2.5 Pro | 1M | Niet bekendgemaakt | ~500K (praktisch) |
| Llama 4 Maverick | 1M | RoPE | 1M |
| Mistral Large 3 | 128K | Sliding Window + RoPE | 128K |
| DeepSeek-R1 | 128K | RoPE | 128K |
*Effectieve lengte: het venster waarover het model informatie betrouwbaar ophaalt. „Lost in the middle“-onderzoek toont dat de prestaties afnemen voor inhoud die in het midden van zeer lange contexten is geplaatst.
RAG pakt twee fundamentele beperkingen van LLM's aan: hun kennis-afkapdatum en hun neiging tot hallucineren. In plaats van te vertrouwen op wat het model tijdens training heeft onthouden, haalt RAG ten tijde van de inferentie relevante documenten op en injecteert ze in de prompt.
graph LR A[User Query] --> B[Embed Query] B --> C[Vector Search] C --> D[Top-k Chunks] D --> E[Inject into Prompt] A --> E E --> F[LLM Generation] F --> G[Grounded Answer]
Query embedden → top-k-gelijkenisscan → chunks aan de prompt toevoegen → genereren. Eenvoudig maar gevoelig voor irrelevante ophaling en contextoverbelasting.
Voegt query-herschrijving, re-ranking (cross-encoders), hypothetische document-embeddings (HyDE), recursieve ophaling en contextcompressie toe.
Ontkoppelde pijplijn: routering, query-transformatie, ophaling, scoring, filtering en fusie kunnen elk onafhankelijk worden vervangen. Maximale flexibiliteit.
Splits elke N tokens met M-token-overlap. Snel maar kan midden in een zin afkappen. Goede uitgangsbasis.
Splits op zins- of alineagrenzen. Behoudt semantische eenheden maar de chunks variëren in grootte.
Groepeer zinnen met hoge embedding-gelijkenis tot coherente chunks. Beste ophaalkwaliteit; hoogste rekenkosten op indexeringsmoment.
Indexeer op meerdere granulariteiten (document → sectie → alinea). Haal op het niveau op dat overeenkomt met de specificiteit van de query.
| Database | Implementatie | Schaal | Best voor |
|---|---|---|---|
| pgvector | Zelf gehost (Postgres-ext.) | Miljoenen | Bestaande Postgres-gebruikers; eenvoudigere stack |
| Qdrant | Zelf gehost / cloud | Miljarden | Hoge prestaties, rijke filtering, open source |
| Weaviate | Zelf gehost / cloud | Miljarden | Multimodaal, hybride semantiek + trefwoord |
| Pinecone | Volledig beheerde cloud | Miljarden | Beheerde SaaS, minimale operatie |
| Chroma | Lokaal / zelf gehost | Miljoenen | Prototyping, lokale ontwikkeling |
De kloof tussen open-weight- en propriëtaire frontiermodellen is dramatisch kleiner geworden. Llama 4 Maverick evenaart GPT-4o op veel benchmarks; DeepSeek-R1 overtreft o1 in wiskunde en coderen tegen een fractie van de trainingskosten. De keuze gaat steeds meer over het implementatiemodel, gegevensprivacy en de totale eigendomskosten.
| Model | Parameters | Context | Licentie | MMLU | Beste toepassing |
|---|---|---|---|---|---|
| Open Weight | |||||
| Llama 4 Scout | ~17B active (MoE) | 1M | Llama 4 Community License | 79.6 | Snel, lange context, op het apparaat |
| Llama 4 Maverick | ~17B active (MoE) | 1M | Llama 4 Community License | 85.5 | Gebalanceerd qua capaciteit/kosten, lange context |
| Llama 4 Behemoth | ~288B active (MoE) | 128K | Llama 4 Community License | ~92 (est.) | Frontier-open-weight-taken |
| Mistral Large 3 | ~123B | 128K | Mistral Research License | 84.0 | Meertalige onderneming |
| Qwen2.5 72B | 72B | 128K | Apache 2.0 | 86.0 | Code, wiskunde, meertalig |
| DeepSeek-R1 | 671B MoE | 128K | MIT | 90.8 | Redeneren, wiskunde, wetenschap |
| Gemma 2 27B | 27B | 8K | Gemma License | 75.2 | Onderzoek, fijnregeling |
| Phi-4 | 14B | 16K | MIT | 84.8 | |
| Propriëtair | |||||
| GPT-4o | ~200B est. | 128K | Proprietary | 88.7 | Algemene frontier, multimodaal |
| Claude Sonnet 4.6 | Undisclosed | 200K | Proprietary | 88.7 | Lange context, coderen, veiligheid |
| Gemini 2.5 Pro | Undisclosed | 1M | Proprietary | 85.9 | Zeer lange context, multimodaal, redeneren |
| o3 / o1 | Undisclosed | 200K | Proprietary | ~91+ | Complex redeneren, frontieronderzoek |
LLM's op schaal serveren vereist het oplossen van geheugen (VRAM is schaars), doorvoer (veel gelijktijdige gebruikers) en latentie (gebruikers willen snelle eerste tokens). Het ecosysteem heeft voor elke uitdaging krachtige oplossingen ontwikkeld.
Het verlagen van de numerieke precisie van modelgewichten verkleint het VRAM en versnelt de berekening. Moderne technieken (GPTQ, AWQ, GGUF) passen quantisatie niet-uniform toe en beschermen de gevoeligste gewichten.
| Formaat | Bits/gewicht | Relatieve grootte | Kwaliteitsbehoud | Tooling |
|---|---|---|---|---|
| FP32 | 32 | 100% | 100 % (referentie) | PyTorch default |
| FP16 / BF16 | 16 | 50% | ~100 % | Standard training/inference |
| INT8 | 8 | 25% | ~99 % | bitsandbytes, TensorRT-LLM |
| INT4 (GPTQ/AWQ) | 4 | 12.5% | ~95–98 % | AutoGPTQ, AutoAWQ, llama.cpp |
| GGUF Q4_K_M | ~4.5 | ~14% | ~96 % | llama.cpp, Ollama |
| GGUF Q2_K | ~2.6 | ~8% | ~88 % | llama.cpp (CPU focus) |
PagedAttention voor efficiënt KV-cache-beheer, continue batching, tensorparallelisme. De gouden standaard voor GPU-serving met hoge doorvoer. OpenAI-compatibele API.
De productieserver van Hugging Face. Flash Attention 2, continue batching, speculatief decoderen. Drijft de Inference API aan.
Doodeenvoudige lokale serving via GGUF-modellen. Eén commando om elk model op te halen en uit te voeren. Niet ontworpen voor hoge gelijktijdigheid maar uitstekend voor ontwikkeling.
Pure C++-inferentie met GGUF-quantisatie. Draait op MacBook M-serie-CPU's en consument-GPU's. Drijft Ollama onder de motorkap aan.
vLLM's PagedAttention (Kwon et al., 2023) beheert het KV-cache-geheugen als virtueel geheugen in een besturingssysteem — door het op te splitsen in niet-aaneengesloten toegewezen pagina's van vaste grootte. Dit elimineert fragmentatie en verspilde reservering en maakt 2–24× meer doorvoer mogelijk dan HuggingFace Transformers bij gelijk GPU-geheugen.
Continue batching stelt nieuwe verzoeken in staat zich bij een lopende batch te voegen zodra een sequentie klaar is, in plaats van op de volledige batch te wachten. Dit verbetert de GPU-benutting bij workloads van variabele lengte drastisch.
# Start a vLLM server for Llama 4 Scout Instruct
# Requires: pip install vllm, CUDA GPU with ≥16GB VRAM
python -m vllm.entrypoints.openai.api_server \
--model meta-llama/Llama-4-Scout-17B-16E-Instruct \
--tensor-parallel-size 1 \
--max-model-len 32768 \
--dtype bfloat16 \
--port 8000
# The server exposes an OpenAI-compatible API:
curl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "meta-llama/Llama-4-Scout-17B-16E-Instruct",
"messages": [{"role": "user", "content": "Explain attention mechanisms."}],
"temperature": 0.7,
"max_tokens": 512
}'Evaluatie is een van de moeilijkste open problemen in LLM-onderzoek. Standaardbenchmarks meten specifieke capaciteiten maar correleren onvolmaakt met de bruikbaarheid in de praktijk. Een uitgebreide evaluatiestrategie combineert geautomatiseerde benchmarks, menselijke evaluatie en LLM-as-judge.
| Benchmark | Meet | Formaat | Beperking |
|---|---|---|---|
| MMLU | Brede kennis (57 vakken) | Meerkeuze met 4 opties | Meerkeuzeformaat; besmettingsrisico |
| HumanEval | Python-codegeneratie | Functievervollediging + unit-tests | Alleen Python; smalle taakverdeling |
| GSM8K | Rekenwoordproblemen van de basisschool | Vrijevorm-rekenkunde | Verzadigd door frontiermodellen (>95 %) |
| HellaSwag | Gezond-verstand-NLI | Zinsvervollediging met 4 opties | Verzadigd; adversarieel maar gedateerd |
| MT-Bench | Instructies volgen (meerdere beurten) | LLM-as-judge (GPT-4) | De GPT-4-jury heeft eigen vertekeningen |
| GPQA Diamond | Wetenschap op postdoctoraal niveau | Meerkeuze met 4 opties door domeinexperts | Kleine dataset; moeilijk te schalen |
| MATH-500 | Wedstrijdwiskunde | Exacte antwoordovereenkomst | Formaatgevoelig; oplossingen kunnen onthouden zijn |
| Model | MMLU | HumanEval | GSM8K | MATH |
|---|---|---|---|---|
| GPT-4o | 88.7 | 90.2 | 96.0 | 76.6 |
| Claude Sonnet 4.6 | 88.7 | 92.0 | 96.0 | 78.3 |
| Gemini 2.5 Pro | 85.9 | 84.1 | 91.7 | 67.7 |
| DeepSeek-R1 | 90.8 | 92.3 | 97.3 | 97.3 |
| Llama 4 Maverick | 85.5 | 85.4 | 95.0 | 72.0 |
| Llama 4 Scout | 79.6 | 77.0 | 89.0 | 58.0 |
| Mistral Large 3 | 84.0 | 92.0 | 93.0 | 69.0 |
| Llama 3.1 8B (2024) | 73.0 | 72.6 | 84.5 | 51.9 |
Voor open taken zonder referentieantwoorden kan een krachtig LLM responsen scoren met een gestructureerde rubriek. MT-Bench en Chatbot Arena gebruiken deze aanpak. Het belangrijkste risico is positievertekening (de jury verkiest antwoorden die als eerste verschijnen) en breedsprakigheidsvertekening (langere antwoorden scoren hoger ongeacht de kwaliteit).
from openai import OpenAI
client = OpenAI()
def llm_judge(question: str, answer: str, rubric: str) -> dict:
prompt = f"""You are an expert evaluator. Score the following answer on a 1-10 scale.
Question: {question}
Answer: {answer}
Rubric: {rubric}
Respond with JSON: {{"score": <int>, "reasoning": "<str>", "strengths": ["..."], "weaknesses": ["..."]}}"""
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": prompt}],
response_format={"type": "json_object"},
temperature=0.0,
)
import json
return json.loads(response.choices[0].message.content)
result = llm_judge(
question="Explain the attention mechanism in transformers.",
answer="Attention computes a weighted sum of values...",
rubric="Accuracy (4pt), Clarity (3pt), Completeness (3pt)",
)
print(f"Score: {result['score']}/10 — {result['reasoning']}")Begrijpen hoe LLM's werken is het fundament — maar het juiste model, de juiste implementatiearchitectuur en de juiste evaluatiestrategie voor uw specifieke toepassing kiezen vereist praktische ervaring. Ons team heeft productie-LLM-systemen gebouwd over RAG, agents, fijnregeling en bedrijfsimplementatie. Boek een consult om uw project te bespreken.