GELU-activeringsfunctie: formule, intuïtie en gebruik in deep learning

Activeringsfuncties bepalen welke signalen door een neuraal netwerk heen gaan en welke niet. Kies je de verkeerde, dan leert je model te langzaam of generaliseert het niet. ReLU was jarenlang de logische standaardkeuze omdat het snel was en goed genoeg voor de meeste taken.

GELU (Gaussian Error Linear Unit) veranderde dat. Het is nu de activeringsfunctie achter enkele van de meest capabele modellen ooit gebouwd, waaronder BERT en GPT.

In dit artikel behandel ik de intuïtie achter GELU, de formule, hoe het zich verhoudt tot andere activeringsfuncties en waar je het in de praktijk zou gebruiken.

Als je helemaal nieuw bent met activeringsfuncties in machine learning, lees dan onze Beginnersgids voor de Rectified Linear Unit (ReLU)-blogpost.

Wat is de GELU-activeringsfunctie?

GELU, of Gaussian Error Linear Unit, is een activeringsfunctie die invoerwaarden weegt op basis van hun grootte met een vloeiende en probabilistische benadering.

De meeste activeringsfuncties beslissen of ze het signaal wel of niet doorlaten. ReLU zet bijvoorbeeld alles wat negatief is op nul en laat de rest ongewijzigd door. GELU werkt anders. In plaats van een harde grens schaalt het invoerwaarden vloeiend op basis van hoe groot of klein ze zijn, wat betekent dat zelfs kleine negatieve waarden nog steeds kunnen bijdragen aan de output.

Het verschil met ReLU is dat GELU overal glad en continu is. Er is geen scherpe hoek bij nul en geen abrupte overgangen. Die gladheid kan tijdens het trainen uitmaken, omdat het de optimizer schonere gradiëntinformatie geeft om mee te werken.

Intuïtie achter GELU

Zie GELU als een filter dat niet alle invoer hetzelfde behandelt.

ReLU is bot: alles wat negatief is wordt elke keer op nul gezet. GELU vraagt daarentegen: “hoe waarschijnlijk is het dat deze invoerwaarde nuttig is?” Waarden die duidelijk groot en positief zijn, gaan vrijwel ongewijzigd door. Waarden die klein of negatief zijn, worden afgeschaald, niet volledig afgesneden.

Het resultaat is een vloeiende curve die minder relevante signalen onderdrukt zonder ze volledig te negeren.

Stel je voor dat je een stapel sollicitaties beoordeelt. Een strikt filter zou zonder uitzondering iedereen zonder diploma verwijderen. Een slimmer filter zou alsnog kandidaten overwegen die er dicht bij zitten, omdat ze misschien relevante ervaring hebben die compenseert. GELU werkt als het slimmere filter. Het maakt geen strakke knip, maar weegt elke invoer op basis van de grootte en bepaalt hoeveel ervan wordt doorgelaten.

Deze geleidelijke en probabilistische schaling maakt GELU anders. Er zijn geen scherpe overgangen en geen dode neuronen — alleen een vloeiende doorlaten-of-onderdrukkenbeslissing voor elke invoerwaarde.

GELU-formule

De exacte GELU-formule is gebaseerd op de cumulatieve verdelingsfunctie (CDF) van de Gaussische verdeling, geschreven als:

Cumulatieve verdelingsfunctie van Gauss

waarbij x de invoerwaarde is en Φ(x) de kans is dat een willekeurige variabele getrokken uit een standaardnormale verdeling kleiner is dan of gelijk aan x. Simpel gezegd vertelt Φ(x) je hoe “normaal” of verwacht de invoerwaarde is — en die kans gebruikt GELU om de invoer te schalen.

Hoe hoger de invoer, hoe dichter Φ(x) bij 1 komt, wat betekent dat de invoer vrijwel ongewijzigd doorgaat. Hoe lager de invoer, hoe dichter Φ(x) bij 0 komt, wat betekent dat de invoer wordt onderdrukt.

De benadering die in de praktijk wordt gebruikt

Het probleem met de exacte formule is dat het berekenen van Φ(x) duur is. Het omvat de foutfunctie, die geen eenvoudige gesloten vorm heeft en op schaal traag te berekenen is.

Deep learning-frameworks gebruiken in plaats daarvan deze benadering:

GELU-benaderingsformule

Deze benadering gebruikt tanh, wat snel is en goed wordt ondersteund op moderne hardware. Het resultaat is vrijwel identiek aan de exacte formule binnen het invoerbereik dat in de praktijk telt, en daarom gebruiken frameworks zoals PyTorch en TensorFlow dit standaard.

Natuurlijk hoef je geen van beide formules uit je hoofd te leren. Maar weten dat de benadering bestaat — en waarom — helpt je te begrijpen wat er daadwerkelijk gebeurt wanneer je GELU in je code aanroept.

GELU vs. andere activeringsfuncties

Elke activeringsfunctie gaat op een andere manier met de invoer om, en die verschillen zie je terug in hoe goed je model traint.

Zo ziet het verschil er visueel uit voordat we het in tekst uitleggen:

Grafiek: GELU versus andere activeringsfuncties

Sigmoid

Sigmoid perst alle invoerwaarden in een bereik tussen 0 en 1. Het is vloeiend, maar heeft een bekend probleem: verdwijnende gradiënten. Voor invoer die heel groot of heel klein is, wordt de gradiënt bijna nul, waardoor diepere lagen stoppen met leren. GELU heeft dit probleem niet, omdat de gradiënt betekenisvol blijft over een groter invoerbereik.

Tanh

Tanh lijkt op Sigmoid maar is gecentreerd rond nul, met outputs tussen -1 en 1. Het gaat beter om met negatieve invoer dan Sigmoid, maar lijdt nog steeds aan verdwijnende gradiënten aan de extremen. GELU levert een vloeiendere outputcurve met betere gradiëntdoorstroming in diepe netwerken.

ReLU

ReLU is snel en simpel: positieve invoer gaat ongewijzigd door, negatieve invoer wordt op nul gezet. De scherpe knip bij nul veroorzaakt het probleem van stervende neuronen — neuronen die na verloop van tijd steeds negatieve invoer krijgen, stoppen volledig met bijwerken. GELU voorkomt dit door negatieve invoer te schalen in plaats van af te kappen.

Leaky ReLU

Leaky ReLU lost het probleem van stervende neuronen op door een kleine fractie van de negatieve invoer door te laten. Het is een stap vooruit ten opzichte van ReLU, maar de overgang bij nul blijft scherp. GELU levert al met al een vloeiendere curve, wat vaak beter werkt in diepe architecturen waar de kwaliteit van de gradiënten zwaarder weegt.

Kort samengevat zijn dit de verschillen tussen deze vijf activeringsfuncties:

Tabel: GELU versus andere activeringsfuncties

Waarom GELU wordt gebruikt in transformers

Transformers zijn gewoon diepe neurale netwerken. En hoe dieper je netwerk, hoe belangrijker de kwaliteit van de gradiënt wordt.

Modellen zoals BERT en GPT stapelen tientallen lagen op elkaar. Op die diepte worden kleine problemen met gradiëntdoorstroming versterkt. Als je activeringsfunctie onstabiele of bijna-nul-gradiënten oplevert in bepaalde regio’s, werken de eerdere lagen in het netwerk tijdens het trainen nauwelijks bij, waardoor ze weinig leren.

GELU voorkomt dit door gradiënten vloeiend en niet-nul te houden over een groter invoerbereik. Er is geen afkapping zoals de nulgrens van ReLU, waardoor de optimizer een schoner signaal krijgt op elke laag, niet alleen die dicht bij de output.

Er is nog een reden waarom GELU goed past in transformer-architecturen. 

Transformers verwerken invoer via aandachtmechanismen die een breed scala aan activatiewaarden produceren — zowel positief als negatief. Een vloeiende activeringsfunctie kan beter met dat bereik overweg dan een met scherpe overgangen.

Toen het oorspronkelijke BERT-paper werd gepubliceerd, kozen de auteurs voor GELU boven ReLU en rapporteerden betere resultaten op hun benchmarks. GPT maakte dezelfde keuze. Sindsdien is GELU de standaardactivering in de meeste transformer-gebaseerde architecturen, niet omdat het nieuw is, maar omdat het beter werkt op de schaal waarop deze modellen opereren.

GELU in de praktijk

GELU gebruiken in je modellen is net zo eenvoudig als andere activeringsfuncties gebruiken. Zowel PyTorch als TensorFlow hebben ingebouwde ondersteuning.

PyTorch

In PyTorch kun je GELU toepassen als losstaande module of inline binnen een modeldefinitie. Hier is een eenvoudig feedforward-blok met GELU:

import torch
import torch.nn as nn

class FeedForwardBlock(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.act = nn.GELU()
        self.fc2 = nn.Linear(hidden_dim, input_dim)

    def forward(self, x):
        return self.fc2(self.act(self.fc1(x)))

block = FeedForwardBlock(input_dim=512, hidden_dim=2048)
x = torch.randn(8, 512)
output = block(x)

nn.GELU() staat tussen de twee lineaire lagen, precies waar je het in de feedforward-sublayer van een transformer vindt. De activatie draait na de eerste projectie en vóór de tweede.

TensorFlow

In TensorFlow is GELU beschikbaar via de Keras-API:

import tensorflow as tf
from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(2048, input_shape=(512,)),
    keras.layers.Activation("gelu"),
    keras.layers.Dense(512)
])

x = tf.random.normal((8, 512))
output = model(x)

Je kunt het ook direct als tekenreeksargument doorgeven aan een Dense-laag:

keras.layers.Dense(2048, activation="gelu")

Beide benaderingen leveren hetzelfde resultaat op.

Waar GELU past in een netwerk

GELU hoort op dezelfde plek als elke andere activeringsfunctie — direct na een lineaire transformatie en vóór de volgende laag. In transformer-architecturen betekent dat binnen de feedforward-sublayer, tussen de twee dense-projecties. In andere diepe netwerken plaats je het na je lineaire of convolutionele laag en laat je het de output schalen vóór je die doorgeeft.

Voordelen van GELU

Als je tot hier bent gekomen, ken je de grootste pluspunten van GELU vergeleken met andere activeringsfuncties. Hier is een korte samenvatting:

• Vloeiende activatie: GELU produceert een continue, differentieerbare curve zonder scherpe overgangen, wat de optimizer schonere informatie geeft bij elke stap.
• Betere gradiëntdoorstroming: GELU zet negatieve invoer niet op nul, waardoor gradiënten nog steeds kunnen doorstromen door neuronen die negatieve waarden ontvangen. Dit verkleint de kans dat neuronen tijdens het trainen doodgaan.
• Betere prestaties in diepe modellen: In diepe architecturen zoals transformers vertaalt het cumulatieve effect van vloeiendere gradiënten zich vaak in betere trainingsresultaten dan bij simpelere activeringsfuncties.

Beperkingen van GELU

GELU is niet in elke situatie de juiste keuze. Hier zijn een paar beperkingen waar je rekening mee moet houden:

• Duurder te berekenen dan ReLU: GELU omvat ofwel een foutfunctie of een op tanh gebaseerde benadering; beide kosten meer dan de eenvoudige drempelbewerking van ReLU. In grote modellen met veel lagen kan dit optellen.

• Minder intuïtief: Functies zoals ReLU zijn makkelijk te beredeneren — positieve waarden gaan door, negatieve niet. De probabilistische schaling van GELU is lastiger te interpreteren.

• Niet altijd nodig: Voor ondiepe netwerken of eenvoudigere taken biedt GELU geen betekenisvolle voordelen. ReLU of Leaky ReLU presteren vaak net zo goed tegen lagere rekenkosten.

Kortom: bouw je een transformer of een andere diepe architectuur, dan is GELU een solide standaard. Voor al het andere: benchmark voordat je je erop vastlegt.

Conclusie

GELU is geen universele upgrade en ook geen one-size-fits-all-oplossing die ReLU vervangt. Het is een bewuste ontwerpkeuze die de moeite waard is in specifieke contexten — denk aan diepe netwerken en transformer-modellen.

Werk je met BERT, GPT of een ander transformer-gebaseerd model, dan gebruik je GELU al — of je je daar nu bewust van was of niet. Nu weet je waarom het daar zit.

Voor al het andere komt de keuze van activeringsfunctie neer op trade-offs. Geen enkele functie wint altijd, en begrijpen wat elke functie doet is hoe je die keuze met vertrouwen — en niet uit gewoonte — maakt.

Vind je de verschillen tussen activeringsfuncties nog steeds verwarrend, schrijf je dan in voor onze Machine Learning Engineer Track om carrièreklaar te worden in machine learning en MLOps.