Large language model architectures (NL)

Architecturen van grote taalmodellen (LLM) zijn de fundamentele principes en structuren die bepalen hoe grote taalmodellen worden opgebouwd, getraind en functioneren. Moderne LLM's, die menselijke taal kunnen begrijpen en genereren, zijn bijna volledig gebaseerd op de Transformer-architectuur, maar bevatten talrijke verbeteringen en uiteenlopende benaderingen gericht op het vergroten van efficiëntie, schaalbaarheid en mogelijkheden.

Families van LLM-architecturen (transformers)

Moderne grote taalmodellen zijn gebaseerd op de transformer-architectuur, maar maken er op verschillende manieren gebruik van afhankelijk van het doel: tekst begrijpen, een vervolg genereren of de ene tekst omzetten in een andere. In de praktijk worden drie families onderscheiden, waarbij de basisprincipes van de transformer behouden blijven.

1. Encoder‑only (alleen encoder)

Het model maakt uitsluitend gebruik van een encoder-stack en verwerkt de volledige invoertekst bidirectioneel. De voortraining is doorgaans gebaseerd op masked‑language modeling (MLM): een deel van de tokens wordt verborgen en het model leert ze terug te herstellen op basis van de context. Dankzij de bidirectionele context presteren dergelijke modellen goed bij taken op het gebied van tekstbegrip en scoring: classificatie, het herkennen van entiteiten, het herrangschikken van documenten en extractieve QA. Ze zijn niet bedoeld voor autoregressive generatie "vanaf nul".

In de praktijk worden aanvullende voortrainingsdobelstellingen toegepast voor de encoder‑only-familie: replaced token detection (RTD) in ELECTRA (een discriminatormodel herkent vervangen tokens) en contrastief leren van bi-encoders voor semantisch zoeken/retrieval (InfoNCE/softmax-loss op "vraag-document"-paren, zoals in Dense Passage Retrieval). Bij gebruik in RAG fungeren encoder‑only-modellen ofwel als bi-encoder (afzonderlijke codering van vraag en document voor snel ANN-zoeken), ofwel als cross-encoder (gezamenlijke codering van het paar voor nauwkeurige herrangschikking).

Voordelen:

• Hoge kwaliteit van tekstbegrip dankzij bidirectionele context: classificatie, NER, feitextractie, herrangschikking, extractieve QA.
• Parallelle verwerking en hoge doorvoer: één enkele forward pass zonder autogressie; eenvoudig te batchen voor massale scoring.
• Natuurlijke integratie met zoeken en RAG: als bi-encoder — snel semantisch zoeken; als cross-encoder — nauwkeurige herrangschikking.
• Efficiënte adaptatie: relatief compacte varianten (≈100–300 miljoen parameters; BERT‑base ≈110 miljoen) leveren na gerichte fine-tuning hoge kwaliteit.
• Stabiele latentie, onafhankelijk van de lengte van het gegenereerde antwoord (geen stapsgewijze decodering); geschikt voor offline scoring van grote collecties.
• Mogelijkheid om het contextvenster van encoders te vergroten via relatieve/rotatieposities en/of lokaal-sparse attention (bijv. Longformer/BigBird), wat nuttig is voor lange documenten.

Nadelen:

• Geen eigen generatieve mogelijkheden: voor dialogen en uitgebreide antwoorden is een decoder of een externe generatieve module vereist.
• Beperkte toepasbaarheid in interactieve scenario's: geen stapsgewijze generatie met statusbehoud.
• Mismatch tussen voortraining en vrije generatietaken: MLM sluit minder goed aan bij generatie dan causaal taalmodelleren.
• Historisch beperkt contextvenster (vaak 512 tokens in basisconfiguraties met absolute posities); uitbreiding vereist speciale positie-/attentieschema's en/of fine-tuning.
• Voor retrieval-taken is afzonderlijke contrastieve fine-tuning van de bi-encoder en/of cross-encoder vereist; zonder deze training is de kwaliteit van zoeken/herrangschikken doorgaans lager dan bij speciaal getrainde modellen.

Representatieve modellen: BERT en afgeleiden, evenals RoBERTa en DeBERTa (uitgebreide encoder‑only-varianten); voor alternatieve voortrainingsdobelstellingen — ELECTRA (RTD).

2. Decoder‑only (alleen decoder)

Alleen de decoder-stack wordt gebruikt met causale (van links naar rechts gerichte) attention: het model voorspelt het volgende token op basis van een gegeven prefix. Deze trainingsmodus — causal language modeling (CLM) — maakt deze modellen een natuurlijke keuze voor generatie: dialogen, uitgebreide antwoorden, creatieve tekst en programmacode. De keerzijde is een toename van latentie en KV-cachegeheugen bij lange prompts. In de praktijk worden voor decoder‑only veelvuldig technische optimalisaties toegepast: vermindering van de KV-cache via MQA en GQA, versnelling van inferentie via speculatief decoderen en serveroptimalisaties (PagedAttention/vLLM, continuous batching, chunked prefill).

Voordelen:

• Natuurlijke tekstgeneratie (CLM): sterke zero‑shot- en few‑shot-mogelijkheden; schaalt goed.
• Veelzijdigheid: één model lost talrijke taken op via instructies en voorbeelden in de prompt; combineert goed met RAG en het aanroepen van tools (tool use).
• Volwassen ecosysteem: praktijken voor instruction fine-tuning en gedragsafstemming (RLHF, DPO); open en commerciële implementaties beschikbaar.
• Uitgebreide inferentie-optimalisatiestack: MQA/GQA verminderen het KV-cachegeheugen en verhogen de doorvoer; speculatief decoderen versnelt inferentie zonder de verdeling te wijzigen; PagedAttention/vLLM met continuous batching en chunked prefill verhogen de end-to-end GPU-benutting.
• Ondersteuning van gestructureerde generatie voor strikte antwoordformaten (JSON/SQL/DSL), wat integratie met informatiesystemen en API's vereenvoudigt.

Nadelen:

• Verhoogde generatielatentie: sequentiële inferentie; de kosten van een nieuw token nemen toe met de lengte van de reeds verwerkte context (KV-cache).
• Minder voordelig bij het profiel "lange invoer – korte uitvoer" (samenvatting, vertaling) vergeleken met encoder–decoder, waarbij de invoer slechts eenmaal wordt gecodeerd.
• Beperking door eenrichtingscontext: bij begriptaken presteert het model soms slechter dan modellen met bidirectionele representatie (encoder‑only / encoder–decoder).
• Geheugen voor KV-cache kan een knelpunt vormen bij lange prompts en grote batches;
• Kwantisering van activaties/KV (INT8/FP8) versnelt inferentie, maar kan de kwaliteit bij lange contexten/code verslechteren; vereist zorgvuldige validatie (met name bij strikte SLA's).

Representatieve modellen: GPT‑3, GPT‑4 (architectuur- en datasetdetails niet openbaar), LLaMA en Llama 3 (8B/70B, 2024).

3. Encoder–decoder (encoder-decoder)

Deze architectuur combineert beide componenten. De encoder werkt bidirectioneel en de decoder causaal. De encoder analyseert de invoer eenmalig en vormt een representatie ervan; de decoder genereert de uitvoer door via cross‑attention naar deze representatie te verwijzen. Deze gescheiden aanpak is bijzonder nuttig wanneer een lange invoertekst moet worden omgezet in een korte uitvoer: machinevertaling, samenvatting, antwoorden op basis van documenten. Hoewel de methode hogere totale rekenkosten vereist (twee stacks en cross-attention), is het voordeel de gecontroleerde generatie op basis van een volledige analyse van de brontekst; daarbij wordt de codering eenmalig uitgevoerd en hergebruikt gedurende het gehele inferentieproces.

Voordelen:

• Conditionele generatie: de decoder maakt gebruik van cross‑attention naar de invoerrepresentatie.
• Efficiënt in het scenario "lange invoer → korte uitvoer": de invoer wordt slechts eenmaal gecodeerd.
• Geschikt voor het "text‑to‑text"-formaat en gecontroleerde uitvoer (taakspecifieke prefixen, speciale instructies).
• Stabiliteit en efficiëntie bij lange bronnen: in de decoderingsfase groeit alleen de self‑attention over de uitvoer, terwijl cross‑attention de vaste sleutels/waarden van de encoder hergebruikt (de invoer wordt niet bij elke stap opnieuw verwerkt).

Nadelen:

• Twee stacks verhogen de geheugen- en rekenvereisten tijdens training en gebruik.
• Bij zeer lange reeksen is de totale latentie vergelijkbaar met decoder‑only; autogressie blijft een knelpunt.
• Minder universele chatmodellen dan bij decoder‑only; wordt vaker ingezet als hoogwaardige seq2seq-engine voor specifieke taken.
• Bij een zeer lange invoer neemt het geheugen voor sleutels/waarden van cross‑attention in elke decoder-laag (over de gehele bron) toe, wat zorgvuldige planningvan de serving vereist.

Representatieve modellen: T5 (inclusief T5 v1.1 en de praktijk van instruction fine-tuning in FLAN‑T5) en BART.

Dense transformers - Dichte transformers

De klassieke en meest gebruikte LLM-architectuur: bij de verwerking van elk token wordt vrijwel de volledige set parameters van het model gebruikt. In tegenstelling tot sparse benaderingen (zoals Mixture‑of‑Experts) is er geen selectieve activering van deelnetwerken — elk blok werkt voor elk token.

Werking en architectuur

Basisstructuur. Het model is een stack van N identieke transformer-blokken. Elk blok bevat:

1. Multi‑Head Self‑Attention. Voor elk token worden drie vectoren berekend: Q (query), K (key), V (value); de attention wordt gedefinieerd als $\mathrm{softmax}\left(\frac{Q{K}^{\mathrm{\top }}+M}{\sqrt{d_k}}\right)\cdot V$, waarbij $M$ een masker is (causaal en/of padding-masker) dat ontoelaaatbare posities uitsluit. Meerdere "koppen" van attention houden parallel rekening met verschillende aspecten van de context (H koppen, doorgaans $d_{\mathrm{h}\mathrm{e}\mathrm{a}\mathrm{d}}=\frac{d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}}{H}$); hun aantal neemt toe met de schaal van het model.
2. Feed‑Forward Network (FFN). Twee lineaire lagen met een niet-lineariteit ertussen (doorgaans GELU/SiLU; in sommige moderne modellen SwiGLU). De tussenliggende dimensie is doorgaans $\approx 4d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}$; bij gebruik van SwiGLU wordt vaak $\approx \frac{8}{3}{d}_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}$ genomen om een vergelijkbaar aantal parameters te behouden. De FFN bevat een aanzienlijk aandeel van de parameters.

Aanvullende componenten. Er worden residuele verbindingen en laagnormalisatie gebruikt; in moderne LLM's wordt vaker Pre‑LN toegepast (normalisatie vóór de deelblokken) — dit verbetert de trainingsstabiliteit bij grote diepte. Naast de klassieke LayerNorm wordt steeds vaker RMSNorm gebruikt (vermindert de rekenkosten en werkt goed in grote modellen); in sommige modelfamilies wordt ook normalisatie in de attentieruimte toegepast (bijv. normalisatie van Q/K vóór softmax). Positionele representaties kunnen absoluut of relatief zijn; voor lange contexten is RoPE de de-facto standaard geworden.

Voorbeelden van modellen en schaal

• BERT‑Large: 24 lagen, dimensionaliteit 1024, 16 attentiekoppen, ≈340 miljoen parameters.
• GPT‑3 (175B): 96 lagen, dimensionaliteit 12288, 96 attentiekoppen, ≈175 miljard parameters.
• LLaMA‑65B: 80 lagen, dimensionaliteit 8192, 64 attentiekoppen, ≈65 miljard parameters.
• PaLM‑540B: 118 lagen, dimensionaliteit van de orde 18432, ≈540 miljard parameters.

Voordelen

• Uniforme blokken, goed bestudeerde trainingsregimes en voorspelbaar schalinggedrag.
• Kwaliteit verbetert als machtsfunctie bij toename van parameters en data; het compute‑optimal regime veronderstelt een gelijktijdige toename van modelomvang en aantal trainingstokens.
• Dezelfde architectuur dekt na fine-tuning een breed spectrum aan taken zonder wijzigingen op laagniveau.

Nadelen

• Volledige self‑attention heeft kwadratische complexiteit ten opzichte van de reekslengte ($O(n^2)$), wat het contextvenster beperkt.
• Volledige parameteractivering per generatiestap: in de decoder zonder MoE nemen de inferentiekosten per token ruwweg evenredig toe met het aantal parameters.
• Knelpunt: geheugenbandbreedte (memory‑bound): het laden van gewichten uit HBM beperkt vaak de inferentiesnelheid.

Beperkingen van schaling en context

• Het geheugen voor parameters groeit lineair met de modelomvang; het trainingsgeheugen neemt toe door gradiënten en optimalisatorstatussen.
• Basisconfiguraties waren historisch beperkt tot 2–4 duizend tokens. Moderne positionele schema's (RoPE) en uitbreidingstechnieken (Position Interpolation, YaRN e.d.) maken het mogelijk het venster met een orde van grootte of meer te vergroten, maar ten koste van extra reken- en geheugenbelasting.

Moderne optimalisaties

• FlashAttention. Exacte attention met inachtneming van de GPU-geheugenhiërarchie; vermindert geheugengebruik en versnelt training/inferentie bij lange reeksen.
• Vermindering en beheer van KV-cache. Multi‑Query Attention en Grouped‑Query Attention verminderen de cacheomvang en het geheugenverkeer; op serverniveau verhoogt PagedAttention (vLLM) de doorvoer via paginabeheer van de cache.
• Speculatief decoderen. Een concept (draft) model stelt een vervolg voor, waarna het hoofdmodel dit snel verifieert; er wordt versnelling bereikt zonder de uitvoerverdeling te wijzigen.

Sparse Models en Mixture‑of‑Experts (MoE)

MoE is een manier om de capaciteit van een model te vergroten zonder evenredige toename van de berekeningen per token. In plaats van één grote FFN-blok per laag wordt een set parallelle "experts" gebruikt (meerdere onafhankelijke FFN's), en een trainbaar routeringsnetwerk (gating network) selecteert voor elk token de top‑k meest relevante experts (doorgaans k=1–2; in sommige modellen k=4). Alleen de geselecteerde experts worden geactiveerd; hun uitvoer wordt gewogen en gesommeerd. Zo kan het totale aantal parameters honderden miljarden of zelfs biljoenen bedragen, terwijl slechts een klein aandeel per stap actief is.

Voorbeelden van modellen en schaal

• Switch Transformer (Google): tot ~1.6T parameters; top‑1-routering (één expert per token). Toonde aan dat MoE de capaciteit sterk kan vergroten bij vergelijkbare kosten per token.
• GLaM (Google): 1.2T parameters, 64 experts per laag, top‑2; per token worden ≈96.6B parameters geactiveerd (≈8%).
• Mixtral 8×7B (Mistral AI): ~46.7B parameters totaal, ≈12.9B actieve parameters per token, top‑2.
• Mixtral 8×22B: ~141B parameters totaal, ≈39B actieve parameters per token, top‑2.
• DBRX (Databricks): 132B parameters totaal, ≈36B actieve parameters per token; 16 experts en top‑4-routering (fine‑grained MoE).

Voordelen

• De rekenkosten worden bepaald door het aantal actieve experts k, niet door het totale aantal parameters: modellen op biljoenschaal kunnen worden getraind en gebruikt tegen kosten die vergelijkbaar zijn met aanzienlijk kleinere dense modellen.
• Specialisatie: experts "stemmen zich automatisch af" op talen/domeinen/patronen, wat de kwaliteit bij multidomeintaken verbetert.
• Flexibele inzet: veelgebruikte experts kunnen in geheugen worden gehouden terwijl zeldzame experts worden ingeladen (met de bijbehorende infrastructuur).

Beperkingen

• Lastbalancering: zonder regularisatie kan het routeringsnetwerk zich vastzetten op een deel van de experts (router collapse). Hulpverliezen (load‑balancing) en verbeterde routeringsschema's zijn noodzakelijk.
• Complexiteit van gedistribueerde berekeningen: expert parallelism en all‑to‑all-communicatie zijn vereist; communicatieoverhead en geheugenbeheer worden een knelpunt.
• Trainingsstabiliteit: routerinstellingen en capaciteitsbegrenzingen (capacity) zijn belangrijk, anders zijn kwaliteits- of convergentiedegradaties mogelijk.

Moderne verbeteringen

• Expert‑Choice routing: experts "kiezen" tokens, wat de balancering en convergentie verbetert bij vergelijkbare kosten.
• Fine‑grained MoE: een groter aantal kleinere experts (zoals in DBRX) biedt fijnere specialisatiegranulariteit.
• Sparse Upcycling: het omzetten van een dense model naar MoE vanuit zijn checkpoint maakt een substantiële kwaliteitsverbetering mogelijk tegen gematigde kosten.

Wanneer MoE zinvol is

• Grote multidomain-assistenten met een beperkt rekenbudget.
• Training op uitgebreide corpora waarbij specialisatie een voordeel oplevert.
• Scenario's met een geavanceerde gedistribueerde infrastructuur (veel GPU's/TPU's en snelle netwerken).

Wanneer dense modellen beter zijn: beperkte infrastructuur (1–2 GPU's), strenge vereisten voor voorspelbare latentie en eenvoudig deployen.

Retrieval‑Augmented Generation (RAG)

RAG is een architecturaal systeempatroon rondom een LLM, en geen interne architectuur van het model zelf. Het combineert een LLM (generatieve component) met een externe kennisbasis (retrievalcomponent), waardoor de beperking van het "parametrische geheugen" van het model kan worden gecompenseerd.

• Werking: Vóór de generatie haalt het LLM relevante documenten op uit een externe bron (wiki, bedrijfskennisbasis, web) en baseert het zijn antwoord daarop.
• Voordelen:
  • Vermindering van hallucinaties en verbetering van feitelijke nauwkeurigheid.
  • Actualiteit zonder volledig opnieuw trainen van het model.
  • Citeerbaarheid en traceerbaarheid van antwoorden.
• Toepassing: De de-facto standaard voor bedrijfsassistenten en systemen waarbij verifieerbare feiten en het werken met privé/sterk gespecialiseerde data vereist zijn.

Attentiemechanismen en contextverwerking

Basismatige self‑attention heeft kwadratische complexiteit ten opzichte van de reekslengte ($O(n^2)$), waardoor optimalisaties zijn ontwikkeld.

• Sparse Attention: Beperking van attention tot lokale vensters/patronen. Voorbeelden: Longformer, BigBird.
• FlashAttention: Herordening van berekeningen rekening houdend met de GPU-geheugenhiërarchie; levert een aanzienlijk voordeel op qua tijd en geheugen en is de de-facto standaard geworden bij het trainen van LLM's met lange contexten.
• MQA/GQA (versnelling van decodering): Multi‑Query Attention (gedeelde sleutels/waarden voor alle koppen) vermindert het KV-cacheverkeer. Grouped‑Query Attention brengt kwaliteit en snelheid in balans.
• Verbeterde positionele representaties:
  • ALiBi (Attention with Linear Biases): Lineaire verschuivingen in attentiescores verbeteren de generalisatie naar grotere lengtes.
  • RoPE (Rotary Position Embeddings): Relatieve positionele informatie via rotatie van Q/K; breed toegepast in moderne modellen (bijv. LLaMA).
  • Contextuitbreiding voor RoPE-modellen: Position Interpolation , YaRN , evenals NTK-aware modificaties maken het mogelijk het contextvenster efficiënt te vergroten zonder architectuurwijzigingen.

• Andere benaderingen voor lange reeksen:
  • Transformer‑XL: Recurrente geheugen tussen segmenten voor het modelleren van lange-afstandsafhankelijkheden.
  • Reformer: LSH‑attention en omkeerbare residuele blokken voor geheugenreductie.
  • Performer: Lineaire benadering van softmax‑attention (FAVOR+).
  • Linformer: Lage-rang benadering van de attentiematrix.

Modeloptimalisaties en trainingsinfrastructuur

Voor het trainen en deployen van LLM's worden gespecialiseerde technieken en frameworks gebruikt.

• Kwantisering (Quantization): Verlaging van de bitbreedte van gewichten vermindert geheugengebruik en versnelt inferentie. QLoRA maakt het mogelijk 4-bit modellen (inclusief 65B) efficiënt te fine-tunen bij kwaliteit die dicht bij volledige precisie ligt.
• Kennisdistillatie (Knowledge Distillation): Teacher→Student-training voor compacte modellen; voorbeeld — DistilBERT.
• Gedistribueerd trainen:
  • DeepSpeed en ZeRO — verdeling van parameters/gradiënten/optimalisatorstatussen voor het trainen van modellen op biljoenschaal.
  • Megatron‑LM — tensor- en pijplijnparallellisme voor zeer grote transformers.
• Ecosysteem en hulpmiddelen: Hugging Face Transformers en Accelerate bieden standaard modelimplementaties en integratie met DeepSpeed/FSDP voor training en inferentie.

Schalingswetten en compute‑optimal training

Empirische schalingswetten tonen aan dat de kruisentropische fout afneemt als machtsfunctie bij een toename van parameters, data en rekencapaciteit. Het Chinchilla-werk verfijnde de compute‑optimal-regimes: voor optimale efficiëntie moeten de modelomvang en het aantal trainingstokens gezamenlijk worden geschaald (voorbeeld — een 70B-model getraind op ~1.4T tokens, dat groter maar ondergetrainde modellen overtreft).

State Space Models (SSM)

State Space Models (SSM) zijn een alternatieve architectuur voor transformers voor het verwerken van lange reeksen. De aanpak is ontleend aan de regeltechniek en digitale signaalverwerking en lost het belangrijkste probleem van self‑attention op: de kwadratische toename van berekeningen naarmate de tekstlengte toeneemt.

Het kernprobleem en de oplossing

Het probleem van transformers. Het belangrijkste probleem van traditionele transformers is de kwadratische attentiecomplexiteit: een tekst die 10 keer zo lang is, vereist ongeveer 100 keer meer berekeningen.

De SSM-aanpak. In plaats van "tegelijkertijd aandacht te besteden aan alle woorden" doorloopt het model de tekst sequentieel en onderhoudt het een compacte interne geheugensstatus, die bij elke stap wordt bijgewerkt. Als gevolg hiervan groeien de tijd en het geheugenverbruik ruwweg lineair met de tekstlengte. Daarbij kan de training parallel worden uitgevoerd — via een convolutionele kernelrepresentatie (hoge doorvoer bij lange reeksen).

Werking

Een discrete SSM wordt beschreven door toestandsvergelijkingen en uitvoervergelijkingen:

$x_t=A{x}_{t-1}+B{u}_t,y_t=C{x}_t+D{u}_t$

waarbij $x_t$ de geheugenstatus is, $u_t$ de invoer (token) en $y_t$ de uitvoer. In diepe SSM's worden de matrices $A,B,C,D$ geparametriseerd om stabiliteit en efficiënte berekeningen op lange reeksen te garanderen. Dezelfde laag kan worden beschouwd als:

• recurrent (stap-voor-stap scannen) — geheugenefficiënte inferentie zonder KV-cache;
• convolutioneel — parallelle training met voorberekende kernel.

Belangrijkste architecturen en hybriden

• S4 (Structured State Spaces). De SSM-basislijn met stabiele parametrisering van de toestandsmatrix; toont efficiëntie op zeer lange reeksen.
• Mamba. Selectieve SSM's: de regels voor geheugenupdate zijn afhankelijk van de huidige invoer (het model beslist zelf wat het "in het geheugen houdt" en wat het "vergeet"). De implementatie is gericht op de GPU-geheugenhiërarchie; volgens de auteurs wordt een veelvoudige toename van de inferentiedoorvoer bereikt bij lineaire complexiteit ten opzichte van de lengte.
• RetNet. Het retention-mechanisme met drie modi: parallelle training, recurrente en blok-recurrente inferentie. Het doel is het combineren van snelle training (zoals bij transformers) met een efficiënte inferentiestroom (O(1) geheugen per token).
• Hybriden Attention+SSM. Voorbeeld — Jamba (afwisseling van Transformer- en Mamba-lagen plus MoE): rapporteert ondersteuning van contexten van de orde ~256K tokens bij aanzienlijk lagere geheugenbehoeften in vergelijking met puur transformer-modellen van vergelijkbare klasse.

Voordelen

• Lineaire complexiteit en geheugenreductie bij inferentie. Geen globale self‑attention en KV-cache; alleen een compacte status wordt opgeslagen.
• Parallelle training op lange reeksen. De convolutionele modus verhoogt de trainingsdoorvoer.
• Hardware-efficiëntie. Implementaties zijn gericht op de moderne geheugenhiërarchie (HBM/SRAM).
• Lange contexten en streaming. SSM+Attention-hybriden zijn praktisch voor honderdduizenden tokens bij gematigde resources.

Beperkingen en huidige praktijk

• Ecosysteemvolwassenheid. Hulpmiddelen en schalings"recepten" (instructies, RLHF/DPO) lopen nog achter op de transformer-stack.
• Kwaliteit en stabiliteit. Bij een aantal taken laten hybriden (Attention+SSM) een stabielere afweging "kwaliteit/snelheid/geheugen" zien dan "pure" SSM's.

Vergelijking van benaderingen (samengevat)

Kenmerk	Transformers	SSM	Hybriden (Attention+SSM)
Complexiteit ten opzichte van lengte	Kwadratisch (self‑attention)	Lineair (scan/convolutie)	Dicht bij lineair
Geheugen per token (inferentie)	KV-cache groeit met de context	O(1) status	Gematigde groei
Lange contexten	Speciale optimalisaties vereist	Natuurlijke ondersteuning	Praktisch tot ~256K
Ecosysteemvolwassenheid	Hoog	Groeiend	Groeiend

Praktische toepassingen

• Analyse van zeer lange documenten (boeken, rapporten, wetenschappelijke overzichten).
• Streamingverwerking en chatscenario's met lange geschiedenis zonder toenemende geheugenkosten.
• Omgevingen met beperkte resources (mobiele/edge-apparaten).
• Tijdreeksen en andere sequentiële gegevens.

Representatieve modellen: S4, Mamba, RetNet; Attention+SSM-hybriden (Jamba).

Evolutie van architecturen

• 2017 — het artikel "Attention Is All You Need" werd gepubliceerd. De transformer-architectuur werd geïntroduceerd: multi-head self‑attention en positionele coderingen maken het mogelijk modellen te trainen zonder recurrentie en convoluties; tegelijkertijd heeft attention kwadratische complexiteit ten opzichte van de contextlengte.

• 2018 — GPT‑1 en BERT werden geïntroduceerd. GPT‑1 gebruikt een decoder-only stack met causale attention voor generatie en vervolgens fine-tuning; BERT introduceert een bidirectionele encoder en MLM-voortraining voor tekstbegrip.

• 2019 — methoden werden voorgesteld voor het werken met lange reeksen en de decoder‑only werd geschaald. Transformer‑XL voegt "geheugen" en relatieve posities toe om het vaste venster te overstijgen; GPT‑2 toont een toename van zero‑shot-mogelijkheden bij toenemende schaal; BART demonstreert de effectiviteit van denoising-voortraining voor seq2seq.

• 2020 — het "text‑to‑text"-formaat werd geünificeerd en methoden voor lange documenten werden aangetoond. T5 formuleert een uniforme encoder–decoder-aanpak voor verschillende taken; Longformer en BigBird gebruiken sparse/gestructureerde attention voor lange teksten; GPT‑3 bevestigt de effectiviteit van het schalen van de dense decoder‑only.

• 2021 — positionele representaties werden verbeterd en parameterspaarsheid (MoE) werd aangetoond. RoPE en ALiBi verbeteren de generalisatie naar grotere lengtes; Switch Transformer en GLaM activeren slechts een deel van de experts per token, waardoor de capaciteit toeneemt zonder evenredige stijging van de inferentiekosten.

• 2022 — het compute‑optimal regime werd verfijnd en de inferentie op lange prompts werd versneld. Chinchilla toont het voordeel van een groter aantal trainingstokens bij gematigde modelomvang; PaLM met Multi‑Query Attention vermindert de KV-cacheomvang; FlashAttention versnelt attention op GPU.

• 2023 — contextvensters werden vergroot zonder laagwijzigingen en de serveraanlevering werd verbeterd. De LLaMA-lijn verankert de praktijken (RMSNorm, SwiGLU, RoPE); Position Interpolation en YaRN breiden de context uit; vLLM/PagedAttention beheert de KV-cache efficiënter.

• 2023 — GPT‑4 en Gemini tonen verwerking en generatie in meerdere modaliteiten binnen één modelfamilie.

• 2023 — State Space Models (SSM) werden geïntroduceerd. Mamba en RetNet hernemen sequentiële verwerking met een compacte status in plaats van KV-cache en leggen de basis voor hybride architecturen.

• 2024 — open MoE-modellen en Attention+SSM-hybriden werden gepubliceerd; attention op nieuwe GPU's werd versneld. Mixtral 8×7B/8×22B en DBRX bevestigen de praktische bruikbaarheid van MoE; Jamba combineert Transformer en Mamba voor zeer lange contexten; FlashAttention‑3 verhoogt de doorvoer.

Verwijzingen

• https://jalammar.github.io/illustrated-transformer/ The Illustrated Transformer — visuele uitleg

Literatuur

• Vaswani, A. et al. (2017). Attention Is All You Need. NIPS. https://arxiv.org/abs/1706.03762
• Devlin, J. et al. (2019). BERT. NAACL. https://arxiv.org/abs/1810.04805
• Brown, T. et al. (2020). Language Models are Few‑Shot Learners. NeurIPS. https://arxiv.org/abs/2005.14165
• Raffel, C. et al. (2020). Exploring the Limits of Transfer Learning with a Unified Text‑to‑Text Transformer (T5). JMLR. https://jmlr.org/papers/volume21/20-074/20-074.pdf
• Lewis, M. et al. (2019). BART: Denoising Sequence‑to‑Sequence Pre‑training. https://arxiv.org/abs/1910.13461
• Touvron, H. et al. (2023). LLaMA. https://arxiv.org/abs/2302.13971
• Chowdhery, A. et al. (2022). PaLM: Scaling Language Modeling with Pathways. https://arxiv.org/abs/2204.02311
• Dao, T. et al. (2022–2024). FlashAttention (1/2/3). https://arxiv.org/abs/2205.14135 ; https://arxiv.org/abs/2307.08691 ; https://arxiv.org/abs/2407.08608
• Shazeer, N. (2019). MQA. https://arxiv.org/abs/1911.02150
• Ainslie, J. et al. (2023). GQA. https://arxiv.org/abs/2305.13245
• Kwon, W. et al. (2023). PagedAttention / vLLM. https://arxiv.org/abs/2309.06180
• Leviathan, Y. et al. (2023). Speculative Decoding. https://arxiv.org/abs/2211.17192
• Fedus, W.; Zoph, B.; Shazeer, N. (2021/2022). Switch Transformers. https://arxiv.org/abs/2101.03961
• Du, N. et al. (2022). GLaM. https://proceedings.mlr.press/v162/du22c/du22c.pdf
• Jiang, A.Q. et al. (2024). Mixtral of Experts. https://arxiv.org/abs/2401.04088
• Databricks (2024). Introducing DBRX. https://www.databricks.com/blog/introducing-dbrx-new-state-art-open-llm
• NVIDIA (2024). Applying Mixture of Experts in LLM Architectures. https://developer.nvidia.com/blog/applying-mixture-of-experts-in-llm-architectures/
• Zhou, Y. et al. (2022). Expert Choice Routing. https://arxiv.org/abs/2202.09368
• Komatsuzaki, A. et al. (2022). Sparse Upcycling. https://arxiv.org/abs/2212.05055
• Lewis, P. et al. (2020). RAG. https://arxiv.org/abs/2005.11401
• Beltagy, I. et al. (2020). Longformer. https://arxiv.org/abs/2004.05150
• Zaheer, M. et al. (2020). BigBird. https://arxiv.org/abs/2007.14062
• Press, O. et al. (2022). ALiBi. https://arxiv.org/abs/2108.12409
• Su, J. et al. (2021). RoFormer (RoPE). https://arxiv.org/abs/2104.09864
• Chen, S. et al. (2023). Position Interpolation. https://arxiv.org/abs/2306.15595
• Peng, B. et al. (2023). YaRN. https://arxiv.org/abs/2309.00071
• Dettmers, T. et al. (2023). QLoRA. https://arxiv.org/abs/2305.14314
• Rajbhandari, S. et al. (2020). ZeRO. https://www.microsoft.com/en-us/research/publication/zero-memory-optimizations-toward-training-trillion-parameter-models/
• Shoeybi, M. et al. (2019). Megatron‑LM. https://arxiv.org/abs/1909.08053
• Kaplan, J. et al. (2020). Scaling Laws. https://arxiv.org/abs/2001.08361
• Hoffmann, J. et al. (2022). Chinchilla / Compute‑Optimal. https://arxiv.org/abs/2203.15556
• Gemini Team (2023). Gemini. https://arxiv.org/abs/2312.11805
• Bai, Y. et al. (2022). Constitutional AI. https://arxiv.org/abs/2212.08073
• OpenAI (2023). GPT‑4 Technical Report. https://arxiv.org/abs/2303.08774
• OpenAI (2023). DevDay: GPT‑4 Turbo 128k. https://openai.com/index/new-models-and-developer-products-announced-at-devday/
• Zhang, B.; Sennrich, R. (2019). RMSNorm. https://arxiv.org/abs/1910.07467
• Shazeer, N. (2020). GLU Variants / SwiGLU. https://arxiv.org/abs/2002.05202
• Gu, A.; Goel, K.; Ré, C. (2021). S4: Structured State Spaces. https://arxiv.org/abs/2111.00396
• Gu, A.; Dao, T. (2023/2024). Mamba: Selective State Spaces. https://arxiv.org/abs/2312.00752
• Sun, Y. et al. (2023). RetNet. https://arxiv.org/abs/2307.08621
• Lieber, O. et al. (2024). Jamba: Hybrid Transformer‑Mamba. https://arxiv.org/abs/2403.19887
• Dai, Z. et al. (2019). Transformer‑XL. https://arxiv.org/abs/1901.02860
• Kitaev, N.; Kaiser, L.; Levskaya, A. (2020). Reformer. https://arxiv.org/abs/2001.04451
• Choromanski, K. et al. (2021). Performer. https://arxiv.org/abs/2009.14794
• Wang, S. et al. (2020). Linformer. https://arxiv.org/abs/2006.04768