Activatie-functies in LLM's: waarom SwiGLU en GELU ReLU vervangen

In de vroege dagen van diepe neurale netwerken gold de Rectified Linear Unit (ReLU) als de absolute standaard. Het verving de traditionele sigmoïde- en tangens hyperbolicus-functies omdat het een einde maakte aan het beruchte 'vanishing gradient'-probleem bij positieve activaties en computationeel extreem goedkoop was. Wie echter de configuratiebestanden van moderne open-weight en commerciële taalmodellen openslaat — van LLaMA en Mistral tot Gemma en GPT-varianten — treft vrijwel nergens meer een standaard ReLU aan. In plaats daarvan domineren functies als GELU (Gaussian Error Linear Unit) en afgeleiden van GLU zoals SwiGLU de feed-forward netwerken (FFN's) binnen elke transformatielaag.

Deze verschuiving is geen willekeurige trend of oppervlakkige optimalisatie. Het kiezen van een specifieke activatiefunctie bepaalt fundamenteel hoe gradiënten terugstromen tijdens de trainingsfase, hoe neuronen beslissen welke representaties worden doorgegeven, en hoeveel floating-point operaties (FLOPs) nodig zijn om een token te verwerken. In dit artikel ontleden we de wiskundige tekortkomingen van ReLU, onderzoeken we waarom soepele krommingen zoals in GELU betere representaties opleveren, en analyseren we waarom multiplicatieve gating-mechanismen zoals SwiGLU de huidige industriestandaard zijn geworden.

De rol van niet-lineariteit in transformer-architecturen

Zonder niet-lineaire activatiefuncties stort een neuraal netwerk, ongeacht de diepte of breedte, wiskundig gezien ineen tot een enkele lineaire transformatie. Immers: het achter elkaar uitvoeren van tien matrixvermenigvuldigingen W_n · ... · W_2 · W_1 · x is algebraïsch identiek aan één enkele vermenigvuldiging met een samengestelde matrix W_totaal. Om complexe talige relaties, syntaxis, logica en abstracte contexten te kunnen modelleren, moet een netwerk een continue, niet-lineaire functieapproximator zijn.

Binnen een klassieke transformer-laag bevindt de activatiefunctie zich in het Feed-Forward Network (ook wel de MLP-laag genoemd), dat direct volgt op het multi-head attention-mechanisme. Waar attention tokens in staat stelt om informatie met elkaar uit te wisselen over de hele context, is het FFN verantwoordelijk voor token-gewijze verwerking en kennisopslag. Typisch projecteert een eerste matrix W_1 de verborgen dimensie d_model naar een bredere tussenruimte (traditioneel 4 × d_model), waarna de activatiefunctie σ puntsgewijs wordt toegepast, voordat een tweede matrix W_2 de dimensie weer comprimeert naar d_model:

FFN(x) = \sigma(x W_1 + b_1) W_2 + b_2

De activatiefunctie σ fungeert hier als een fijnmazige filter. Het bepaalt welke kenmerken in de geëxpandeerde vectorruimte actief blijven en met welke intensiteit ze bijdragen aan de uiteindelijke token-representatie. Hoe deze filter zich gedraagt bij de randen en negatieve waarden dicteert de leerdynamiek van het volledige model.

De opkomst en tekortkomingen van ReLU in grote modellen

ReLU is gedefinieerd als het maximum van nul en de invoerwaarde: f(x) = max(0, x). De afgeleide is triviaal: 1 wanneer x > 0, en 0 wanneer x < 0. Deze eenvoud bracht convolutionele netwerken en vroege sequence models enorme doorbraken omdat forward- en backward passes nauwelijks rekenkracht vereisten. Desondanks stuiten moderne taalmodellen met miljarden parameters op drie fundamentele problemen bij het gebruik van pure ReLU.

Het eerste probleem is het 'Dying ReLU'-fenomeen. Wanneer een neuraal netwerk traint met hoge leersnelheden of grote batches, kunnen de gewichten van een neuron zodanig worden bijgewerkt dat de invoerwaarde x voor vrijwel alle representatieve trainingsvoorbeelden negatief uitvalt. Omdat de gradiënt van ReLU bij negatieve invoer exact nul is (f'(x) = 0), kan er via backpropagation geen enkel foutsignaal meer terugvloeien naar dit neuron. Het neuron 'sterft' effectief af en blijft permanent inactief tijdens de rest van de training, wat resulteert in ongebruikte modelcapaciteit.

Het tweede knelpunt is het gebrek aan differentieerbaarheid in het nulpunt. De abrupte overgang van 0 naar x introduceert een harde knik bij x = 0. In diepe netwerken met tientallen lagen zorgt dit voor abrupte discontinuïteiten in het optimalisatielandschap. Hierdoor kunnen optimalisatie-algoritmen zoals AdamW moeilijker navigeren naar stabiele, vlakke minima, wat het risico op instabiliteiten tijdens grootschalige trainingssessies vergroot.

Ten slotte dwingt ReLU strikte 'hard sparsity' af: alle negatieve activaties worden exact naar nul gedrukt. Hoewel sparsiteit theoretisch geheugenvoordelen kan bieden, blijkt bij taalmodellering dat subtiele, negatieve activatiewaarden vaak waardevolle contextuele informatie bevatten over wat een concept juist niet representeert. Door deze waarden abrupt te wissen, verliest het netwerk graduele expressiviteit.

GELU: probabilistische activering en zachte doorlating

Om de harde drempel van ReLU te verzachten introduceerden Dan Hendrycks en Kevin Gimpel in 2016 de Gaussian Error Linear Unit (GELU). GELU overbrugt het deterministische karakter van ReLU met probabilistische regularisatie zoals dropout. In plaats van een binaire poort toe te passen op basis van het teken van x, weegt GELU de invoerwaarde met de kans dat de invoer groter is dan een willekeurige variabele uit een standaard normale verdeling.

Wiskundig wordt GELU gedefinieerd via de cumulatieve distributiefunctie (CDF) van de standaard normale verdeling Φ(x):

GELU(x) = x \cdot \Phi(x) = x \cdot P(X \le x), \quad \text{waarbij } X \sim \mathcal{N}(0, 1)

Uitgeschreven met de Gaussische foutfunctie erf(x) resulteert dit in:

GELU(x) = 0.5 \cdot x \cdot \left(1 + \text{erf}\left(\frac{x}{\sqrt{2}}\right)\right)

Omdat het direct berekenen van de foutfunctie erf(x) computationeel zwaar is op grafische processors, gebruiken frameworks in de praktijk vaak een snelle polynomiale tanh-benadering:

GELU(x) \approx 0.5 \cdot x \cdot \left(1 + \tanh\left(\sqrt{\frac{2}{\pi}} \cdot \left(x + 0.044715 \cdot x^3\right)\right)\right)

Het cruciale voordeel van GELU is dat de functie niet-monotoon en overal continu differentieerbaar is. Voor sterk negatieve waarden convergeert de functie naar nul, maar voor licht negatieve waarden (tussen 0 en -2) duikt de functie onder de x-as tot een minimum van circa -0,17. Hierdoor blijven kleine negatieve gradiënten behouden tijdens de backpropagation-fase. Modellen zoals BERT, GPT-2 en GPT-3 kozen standaard voor GELU omdat dit aantoonbaar leidde tot snellere convergentie en lagere validatie-loss op grootschalige datasets.

Het principe van Gated Linear Units (GLU)

Hoewel GELU het gradient-probleem van ReLU oploste, bleef de structuur van de FFN-laag lineair gekoppeld aan de activatie: men vermenigvuldigt met een gewichtsmatrix, past de functie toe, en vermenigvuldigt opnieuw. In 2016 introduceerden Dauphin et al. de Gated Linear Unit (GLU) als een alternatieve benadering voor taalmodellering.

Een GLU splitst de transformatie op in twee parallelle lineaire projecties waarvan de elementen puntsgewijs (Hadamard-product, ⊗) met elkaar worden vermenigvuldigd. Eén tak fungeert als het signaalpad, terwijl de andere tak fungeert als een poort (gate) die reguleert hoeveel van het signaal mag passeren:

GLU(x, W, V, b, c) = (x W + b) \otimes \sigma(x V + c)

In de klassieke GLU is σ de standaardsigmoïde. Het revolutionaire inzicht hierachter is dat de gradiënt van de poortfunctie direct schaalt met de activatie van het signaalpad, en omgekeerd. In plaats van een statische drempelwaarde die voor elk invoerelement op dezelfde wijze functioneert, leert het netwerk dynamisch per invoertoken hoe strak de poort open- of dichtgezet moet worden. Dit verhoogt de expressiviteit van de laag aanzienlijk zonder dat de algehele diepte van het model toeneemt.

SwiGLU ontleed: waarom moderne modellen kiezen voor Swish-Gated units

In 2020 publiceerde Noam Shazeer (destijds onderzoeker bij Google) het invloedrijke paper "GLU Variants Improve Transformer". Shazeer onderzocht systematisch wat er gebeurt als de traditionele sigmoïde in een GLU wordt vervangen door moderne niet-lineaire functies zoals ReLU, GELU en Swish (ook wel SiLU genoemd, waarbij Swish(x) = x · sigmoid(β x)). Uit uitgebreide benchmarks bleek dat de variant genaamd SwiGLU consistent beter presteerde dan alle alternatieven.

De wiskundige definitie van een SwiGLU FFN-laag luidt als volgt (bias-termen worden in moderne architecturen vaak weggelaten):

\text{SwiGLU}(x) = \left(\text{Swish}_1(x W_{gate}) \otimes (x W_{up})\right) W_{down}

Hierbij vinden drie afzonderlijke matrixprojecties plaats:

• Gate projection (W_gate): Projecteert de vector naar de tussenruimte en wordt vervolgens getransformeerd door de Swish-functie.
• Up projection (W_up): Projecteert dezelfde invoervector parallel naar de tussenruimte zonder directe niet-lineariteit.
• Down projection (W_down): Projecteert het puntsgewijze product van de geactiveerde gate en de up-projectie terug naar de oorspronkelijke modeldimensie d_model.

In Python met PyTorch ziet een zuivere implementatie van een SwiGLU-gebaseerde MLP er compact uit:

import torch
import torch.nn as nn
import torch.nn.functional as F

class SwiGLUFeedForward(nn.Module):
  def __init__(self, d_model: int, d_ff: int):
    super().__init__()
    # Drie lineaire projecties zonder bias
    self.w_gate = nn.Linear(d_model, d_ff, bias=False)
    self.w_up = nn.Linear(d_model, d_ff, bias=False)
    self.w_down = nn.Linear(d_ff, d_model, bias=False)

  def forward(self, x: torch.Tensor) -> torch.Tensor:
    # Swish(x * W_gate) * (x * W_up)
    gate = F.silu(self.w_gate(x))
    up = self.w_up(x)
    return self.w_down(gate * up)

De wiskundige synergie tussen de zachte afkapping van SiLU en de multiplicatieve interactie van de lineaire up-projectie stelt het netwerk in staat om zeer fijnmazige beslissingsgrenzen te leren. Wanneer het model tijdens inferentie feiten of redeneerstappen formuleert, kan het specifieke representatiekanalen vrijwel volledig dempen zonder de gradiëntstroom tijdens de trainingsfase permanent af te knijpen.

De computationele afweging: FLOPs, geheugen en parametercompensatie

Een intuïtief nadeel van SwiGLU is de introductie van een derde gewichtsmatrix. Waar een traditionele GELU- of ReLU-laag twee matrices gebruikt (W_1 en W_2), vereist SwiGLU W_gate, W_up en W_down. Als men de tussenliggende dimensie d_ff gelijk zou houden aan de klassieke factor 4 × d_model, zou het aantal parameters en de benodigde rekenkracht in de FFN-laag met 50% toenemen (van 8 d_model^2 naar 12 d_model^2).

Om een eerlijke vergelijking mogelijk te maken en het aantal parameters en FLOPs identiek te houden aan een standaard transformer, schalen architecten de tussenruimte d_ff bij SwiGLU terug. In plaats van een expansiefactor van 4, kiest men gebruikelijk voor een factor van circa 8/3 ≈ 2,67 × d_model (vaak afgerond naar het dichtstbijzijnde veelvoud van 64 of 256 voor optimale GPU-matrixvermenigvuldiging via Tensor Cores).

Zelfs wanneer het totale aantal parameters exact gelijk wordt gehouden via deze herschaling, behaalt SwiGLU een significant lagere perplexiteit en betere downstream benchmarkscores dan een standaard 4x-GELU FFN. De computationele overhead per FLOP vertaalt zich dus in een hogere statistische efficiëntie per verwerkt token.

Impact op trainingsstabiliteit en hardware-efficiëntie

Naast modelcapaciteit spelen trainingsstabiliteit en hardware-uitvoering een doorslaggevende rol bij de keuze voor een activatiefunctie. Bij modellen die getraind worden op biljoenen tokens kunnen numerieke instabiliteiten (zoals loss-spikes of overstroomde floating-point representaties) miljoenen euro's aan verloren compute veroorzaken. Zodra we modellen in productieomgevingen draaien, is het essentieel om te begrijpen wat er onder de motorkap gebeurt tijdens inferentie, vooral omdat geheugenbandbreedte en kernel-fusie de uiteindelijke verwerkingssnelheid bepalen.

SwiGLU vereist dat tussenliggende activatievectoren in het snelle GPU-SRAM (Static Random-Access Memory) bewaard blijven om de puntsgewijze vermenigvuldiging uit te voeren. Moderne compilatietools en geoptimaliseerde kernels (zoals Triton of CUDA-fused kernels) combineren de SiLU-berekening, de up-projectie en de multiplicatie in één enkele geheugendoorgang. Hierdoor wordt de theoretische geheugenvertraging van de extra matrixoperatie nagenoeg geëlimineerd.

Bovendien zorgt de gladde afgeleide van SiLU/SwiGLU ervoor dat gradiëntwaarden tijdens mixed-precision training (met FP16 of BF16) minder snel onderstromen naar nul of exploderen naar oneindig, wat de noodzaak voor agressieve gradient clipping vermindert en stabielere leersnelheidsschema's mogelijk maakt.

Praktische vergelijking in moderne architecturen

De onderstaande tabel illustreert hoe toonaangevende transformer-architecturen de afgelopen jaren zijn overgestapt op geavanceerde activatiefuncties en bijbehorende FFN-dimensies:

De transitie naar SwiGLU zonder bias-termen is inmiddels universeel geadopteerd door vrijwel alle toonaangevende open model-families. Het weglaten van bias-vectoren vereenvoudigt de hardware-optimalisatie en verkleint de kans op drift in representaties bij zeer lange contextvensters.

De rol van activaties bij modelbetrouwbaarheid en evaluatie

Hoewel activatiefuncties primair architecturale componenten zijn, beïnvloeden ze indirect hoe modellen redeneren en feitelijke consistentie handhaven. Een model met een soepelere representatieruimte kan concepten genuanceerder scheiden, wat de kans op subtiele representatiefouten vermindert. Wanneer men in de praktijk uitkomsten toetst, helpt de methodiek voor het systematisch fact-checken van AI-antwoorden om te verifiëren of interne representaties daadwerkelijk leiden tot consistente output.

De verschuiving van ReLU naar GELU en uiteindelijk SwiGLU toont aan dat architecturale vooruitgang in diepe leersystemen niet alleen draait om domweg meer rekenkracht of grotere datasets. Door de wiskundige stroming van signalen en gradiënten door het netwerk te verfijnen via niet-lineaire gating-mechanismen, behalen hedendaagse LLM's aanzienlijk betere prestaties binnen hetzelfde hardware- en rekenbudget.