GELU-aktiveringsfunktion: Formel, intuition och användning i deep learning

Aktiveringsfunktioner avgör vilka signaler som släpps igenom i ett neuralt nätverk och vilka som inte gör det. Väljer du fel kan din modell antingen lära sig för långsamt eller misslyckas med att generalisera. ReLU var det rimliga standardvalet i många år eftersom den var snabb och tillräckligt bra för de flesta uppgifter.

GELU (Gaussian Error Linear Unit) ändrade på det. Den är nu aktiveringsfunktionen bakom några av de mest kapabla modeller som någonsin byggts, inklusive BERT och GPT.

I den här artikeln går jag igenom intuitionen bakom GELU, dess formel, hur den står sig mot andra aktiveringsfunktioner och var du faktiskt använder den i praktiken.

Om du är helt ny till aktiveringsfunktioner i maskininlärning, läs vårt nybörjarguide till Rectified Linear Unit (ReLU).

Vad är GELU-aktiveringsfunktionen?

GELU, eller Gaussian Error Linear Unit, är en aktiveringsfunktion som viktar indata baserat på deras magnitud med ett mjukt och probabilistiskt angreppssätt.

De flesta aktiveringsfunktioner fattar beslutet att antingen släppa igenom signalen eller blockera den. ReLU nollställer till exempel allt negativt och släpper igenom allt annat oförändrat. GELU fungerar annorlunda. I stället för en skarp avskärning skalar den indata mjukt beroende på hur stora eller små de är, vilket betyder att även små negativa värden fortfarande kan bidra till utdata.

Skillnaden mot ReLU är att GELU är slät och kontinuerlig överallt. Det finns ingen skarp hörna vid noll och inga abrupta övergångar. Den slätheten kan spela roll under träning eftersom den ger optimeraren renare gradientinformation att arbeta med.

Intuitionen bakom GELU

Tänk på GELU som ett filter som inte behandlar all indata likadant.

ReLU är burdus – allt negativt nollas, varje gång. GELU frågar i stället ”hur sannolikt är det att det här indatavärdet är användbart?” Värden som tydligt är stora och positiva passerar nästan oförändrade. Värden som är små eller negativa skalas ned, inte klipps bort helt.

Resultatet blir en mjuk kurva som dämpar mindre relevanta signaler utan att helt kassera dem.

Föreställ dig att du granskar en hög jobbansökningar. Ett strikt filter skulle ta bort alla utan examen, utan undantag. Ett smartare filter skulle fortfarande överväga kandidater som är nära, eftersom de kanske har relevant erfarenhet som kompenserar. GELU fungerar som det smartare filtret. Det gör inga strikta avskärningar, utan väger i stället varje indata efter dess magnitud och avgör hur mycket av den som ska släppas igenom.

Denna gradvisa och probabilistiska skalning är det som gör GELU annorlunda. Det finns inga skarpa övergångar och inga döda neuroner – bara ett mjukt beslut om att släppa igenom eller dämpa för varje indatavärde.

GELU-formeln

Den exakta GELU-formeln bygger på Gaussisk kumulativ fördelningsfunktion (CDF), skriven som:

Gaussisk kumulativ fördelningsfunktion

där x är indatavärdet och Φ(x) är sannolikheten att en slumpvariabel dragen från en standardnormalfördelning är mindre än eller lika med x. På ren svenska talar Φ(x) om hur ”normal” eller förväntad indata är – och den sannolikheten är vad GELU använder för att skala indata.

Ju högre indata, desto närmare 1 kommer Φ(x), vilket betyder att indata passerar nästan oförändrad. Ju lägre indata, desto närmare 0 kommer Φ(x), vilket betyder att indata dämpas.

Approximationen som används i praktiken

Problemet med den exakta formeln är att det är dyrt att beräkna Φ(x). Den involverar felintegralen, som inte har en enkel sluten form och är långsam att beräkna i stor skala.

Djupinlärningsramverk använder i stället denna approximation:

GELU-approximationsformel

Denna approximation använder tanh, som är snabb och välstöd på modern hårdvara. Resultatet är i praktiken nästan identiskt med den exakta formeln över det indataområde som spelar roll, vilket är anledningen till att ramverk som PyTorch och TensorFlow använder den som standard.

Du behöver förstås inte memorera någon av formlerna. Men att veta att approximationen finns – och varför – hjälper dig att förstå vad som faktiskt händer när du anropar GELU i din kod.

GELU jämfört med andra aktiveringsfunktioner

Varje aktiveringsfunktion hanterar indata på olika sätt, och de skillnaderna märks i hur väl din modell tränas.

Så här ser skillnaden ut visuellt innan vi förklarar den i text:

Diagram: GELU jämfört med andra aktiveringsfunktioner

Sigmoid

Sigmoid trycker ihop all indata till intervallet mellan 0 och 1. Den är slät, men har ett välkänt problem: försvinnande gradienter. För indata som är mycket stora eller mycket små närmar sig gradienten noll, vilket betyder att djupare lager slutar lära sig. GELU har inte det här problemet eftersom dess gradient förblir meningsfull över ett bredare indataområde.

Tanh

Tanh liknar Sigmoid men är centrerad kring noll, med utdata mellan -1 och 1. Den hanterar negativa indata bättre än Sigmoid, men lider fortfarande av försvinnande gradienter i ytterkanterna. GELU ger en mjukare utdatafunktion med bättre gradientflöde genom djupa nätverk.

ReLU

ReLU är snabb och enkel: positiva indata passerar oförändrade, negativa indata nollställs. Den skarpa avskärningen vid noll orsakar problemet med döende neuroner – neuroner som under tid alltid får negativa indata slutar helt att uppdateras. GELU undviker detta genom att skala negativa indata i stället för att klippa bort dem.

Leaky ReLU

Leaky ReLU åtgärdar problemet med döende neuroner genom att släppa igenom en liten andel negativa indata. Det är ett steg upp från ReLU, men övergången vid noll är fortfarande skarp. GELU ger en mjukare kurva överlag, vilket tenderar att fungera bättre i djupa arkitekturer där gradientkvalitet spelar större roll.

Sammanfattningsvis är här skillnaderna mellan dessa fem aktiveringsfunktioner:

Tabell: GELU jämfört med andra aktiveringsfunktioner

Varför GELU används i transformers

Transformers är helt enkelt djupa neurala nätverk. Och ju djupare nätverk, desto viktigare blir gradientkvaliteten.

Modeller som BERT och GPT staplar dussintals lager på varandra. På den djupnivån förstoras små problem med gradientflöde. Om din aktiveringsfunktion skapar instabila eller nära noll-gradienter i vissa områden uppdateras de tidiga lagren knappt under träning, vilket betyder att de inte lär sig särskilt mycket.

GELU undviker detta genom att hålla gradienterna mjuka och icke-noll över ett bredare indataområde. Det finns ingen avskärning som ReLUs nollgräns, så optimeraren får renare signal i varje lager, inte bara de nära utgången.

Det finns ytterligare en anledning till att GELU passar bra i transformerarkitekturer. 

Transformers bearbetar indata via uppmärksamhetsmekanismer som producerar ett brett spektrum av aktiveringsvärden – både positiva och negativa. En mjuk aktiveringsfunktion hanterar det spannet bättre än en med skarpa övergångar.

När den ursprungliga BERT-artikeln publicerades valde författarna GELU framför ReLU och rapporterade bättre resultat på sina benchmarktester. GPT gjorde samma val. Sedan dess har GELU blivit standardaktivering i de flesta transformerbaserade arkitekturer, inte för att den är ny, utan för att den fungerar bättre i den skala dessa modeller verkar på.

GELU i praktiken

Att använda GELU i dina modeller är lika enkelt som att använda andra aktiveringsfunktioner. Både PyTorch och TensorFlow har inbyggt stöd.

PyTorch

I PyTorch kan du använda GELU som en fristående modul eller inline i en modelldefinition. Här är ett enkelt feedforward-block som använder 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() ligger mellan de två linjära lagren, vilket är precis där du hittar den i en transformers feedforward-del. Aktiveringen körs efter den första projektionen och före den andra.

TensorFlow

I TensorFlow finns GELU tillgänglig via Keras-API:et:

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)

Du kan också skicka den direkt som en strängparameter till ett Dense-lager:

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

Båda tillvägagångssätten ger samma resultat.

Var GELU passar i ett nätverk

GELU hör hemma på samma plats som andra aktiveringsfunktioner – direkt efter en linjär transformation och före nästa lager. I transformerarkitekturer betyder det inne i feedforward-delen, mellan de två täta projektionerna. I andra djupa nätverk placerar du den efter ditt linjära eller konvolutionella lager och låter den skala utdata innan de skickas vidare.

Fördelar med GELU

Om du fortfarande läser vid det här laget känner du till de största försäljningsargumenten för GELU jämfört med andra aktiveringsfunktioner. Här är en kort sammanfattning:

• Mjuk aktivering: GELU ger en kontinuerlig, deriverbar kurva utan skarpa övergångar, vilket ger optimeraren renare information vid varje steg.
• Bättre gradientflöde: GELU nollställer inte negativa indata, så gradienter kan fortfarande fortplanta sig genom neuroner som får negativa värden. Detta minskar risken för att neuroner dör under träning.
• Bättre prestanda i djupa modeller: I djupa arkitekturer som transformers tenderar den kumulativa effekten av mjukare gradienter att ge bättre träningsresultat jämfört med enklare aktiveringsfunktioner.

Begränsningar med GELU

GELU är inte rätt val i alla situationer. Här är ett par begränsningar du bör känna till:

• Dyrare att beräkna än ReLU: GELU innebär antingen en felintegral eller en tanh-baserad approximation, vilka båda kostar mer än ReLUs enkla tröskeloperation. I stora modeller med många lager kan detta bli märkbar overhead.

• Mindre intuitiv: Funktioner som ReLU är lätta att resonera kring – positiva värden passerar, negativa gör det inte. GELUs probabilistiska skalning är svårare att tolka.

• Inte alltid nödvändig: För grunda nätverk eller enklare uppgifter ger GELU sällan meningsfulla fördelar. ReLU eller Leaky ReLU presterar ofta lika bra till lägre beräkningskostnad.

Sammanfattningsvis: om du bygger en transformer eller annan djup arkitektur är GELU ett stabilt standardval. För allt annat – benchmarka innan du bestämmer dig.

Slutsats

GELU är ingen universell uppgradering och inte heller en one-size-fits-all-lösning som ersätter ReLU. Det är ett genomtänkt designval som lönar sig i specifika sammanhang – tänk djupa nätverk och transformer-modeller.

Om du arbetar med BERT, GPT eller någon transformerbaserad modell använder du redan GELU, vare sig du tänkt på det eller inte. Nu vet du varför den finns där.

För allt annat handlar valet av aktiveringsfunktion om avvägningar. Ingen enskild funktion vinner varje gång, och att förstå vad varje gör är hur du väljer med självförtroende snarare än vana.

Om du fortfarande tycker att skillnaderna mellan aktiveringsfunktioner är förvirrande, anmäl dig till vår Machine Learning Engineer Track för att bli redo för en karriär inom maskininlärning och MLOps.