Feedforward-neurale netwerken uitgelegd: een complete tutorial

Als je naar machine learning-algoritmen kijkt, zijn er maar weinig concepten zo fundamenteel als het feedforward-neuraal netwerk (FFNN). Als je ooit je eerste neurale netwerk hebt gebouwd, is de kans groot dat het een feedforward-netwerk was. Je ziet ze bijna overal terug — van simpele classificatieproblemen tot het aandrijven van lagen in diepe architecturen. 

Ik laat je eerst zien waar feedforward-neurale netwerken in het grote geheel thuishoren:

In deze tutorial leg ik uit wat een feedforward-neuraal netwerk precies is, hoe het is ontstaan en waarom het nog steeds relevant is. Ook bekijken we voorbeelden uit de praktijk.

Wat is een feedforward-neuraal netwerk?

Intuïtief kun je deze netwerkarchitectuur het best omschrijven als “Data stroomt alleen vooruit, geen lussen.”

In de kern verwerkt een FFNN data in één richting, van input naar output. Er is geen terugkoppeling, geen recursie en geen cycli (met uitzondering van backpropagation, daar komen we zo op). 

Toen ik dit voor het eerst leerde, hielp het beeld van een transportband in een fabriek me het meest. 

Waarom? 

Omdat elke stap in het proces (of elke laag in het netwerk) iets simpels met de input doet en het dan doorgeeft aan de volgende.

Zo werkt het:

1. Inputs gaan naar de eerste laag (de inputlaag).
2. Ze worden getransformeerd door gewichten en biases en door een activatiefunctie geleid.
3. Dit gaat zo door via één of meer verborgen lagen.
4. Uiteindelijk doet de outputlaag een voorspelling.

Voordat ik laat zien hoe zo’n netwerkarchitectuur eruitziet, wil ik een veelvoorkomend misverstand uit de weg ruimen:

“Feedforward-neurale netwerken zijn hetzelfde als MLP’s.”

Om dit misverstand te verhelderen, moeten we de vroege geschiedenis van deep learning verkennen. 

Vroege geschiedenis van deep learning

Perceptron: We beginnen met de perceptron, in de jaren 50 uitgevonden door Frank Rosenblatt. Het was een binaire classifier met één laag. Hoewel het niet alles kon oplossen (zoals XOR-problemen), legde het wel de basis voor neurale netwerken.

In simpele woorden werkte een perceptron zo:

1. Inputs: Elke input (zoals x_1, x_2, enz.) heeft een bijbehorend gewicht (w_1, w_2, enz.).
2. Gewogen som: De inputs worden vermenigvuldigd met hun gewichten en bij elkaar opgeteld, samen met een biais: z = w1*x1 + w2*x2+ ... + b.
3. Activatie: Het resultaat gaat door een stapfunctie (een activatie). Als de waarde boven een drempel ligt, geeft de perceptron een 1; anders een 0.

Kortom, de perceptron is een lineaire classifier, wat betekent dat hij alleen rechte (of hypervlak-)beslissingsgrenzen kon trekken. Enerzijds had de perceptron voordelen: heel simpel en elegant (geïnspireerd door de biologie) en computationeel goedkoop. Anderzijds kon hij geen problemen oplossen die niet lineair scheidbaar zijn, zoals het XOR-probleem. 

Multilayer perceptrons (MLP’s): Een paar decennia later, in de jaren 80, ontdekten onderzoekers dat als je meerdere perceptrons stapelt en niet-lineaire activatiefuncties toevoegt, je complexere problemen kunt oplossen. Deze structuur werd bekend als de multilayer perceptron.

Zo werkte het: 

1. Inputlaag: Neemt ruwe features uit de dataset op.
2. Verborgen lagen: Eén of meer lagen perceptrons die transformaties toepassen. Elke neuron voert z = w*x + b uit en stuurt dit door een niet-lineaire activatiefunctie zoals sigmoid, tanh, enz. 
3. Outputlaag: De laatste laag produceert de uiteindelijke voorspelling (bijv. klassekansen, regressiewaarden).

De toevoeging van deze niet-lineaire activaties was cruciaal. Zonder hen zou het stapelen van lagen neerkomen op één enkele lineaire transformatie. Mét hen kunnen MLP’s zeer complexe, niet-lineaire functies representeren.

Dit leidde tot een van de bekendste resultaten in de theorie van neurale netwerken: de universele-approximatietheorema. 

Dit theorema stelt dat een neuraal netwerk met zelfs maar één verborgen laag — zolang het een niet-lineaire activatiefunctie en genoeg neuronen heeft — elke continue functie op een begrensd domein kan benaderen. 

Deep-learningtijdperk: In de jaren 2010 belanden we in het deep-learningtijdperk. Met GPU’s en big data evolueerden FFNN’s naar diepere en krachtigere architecturen en vormden ze de basis voor CNN’s, RNN’s en Transformers — waar we nu in essentie zijn.

Terug naar het oorspronkelijke misverstand; we weten nu:

• Feedforward-neuraal netwerk (FFNN). De algemene categorie van elk neuraal netwerk waarbij data in één richting stroomt (input → verborgen → output), zonder lussen.
• Multilayer perceptron (MLP). Een type FFN met specifiek minstens één verborgen laag van perceptrons (neuronen met gewichten, biais en activatie).

Met andere woorden: alle MLP’s zijn FFNN’s, maar niet alle FFNN’s zijn MLP’s. Dit is een heel belangrijk punt om te onthouden. Een ander veelvoorkomend misverstand gaat over een perceptron met één laag (dus alleen input naar output).

Een perceptron met één laag is een FFNN, maar geen MLP! Pas zodra we verborgen lagen toevoegen, wordt het een MLP.

Dit onderscheid is belangrijk, want MLP’s zijn in staat tot universele functie-approximatie (met genoeg verborgen units en niet-lineaire activaties), terwijl simpele perceptrons met één laag beperkt zijn in wat ze kunnen representeren.

Architectuur van een feedforward-neuraal netwerk

In de vorige sectie hebben we veel geleerd over FFNN’s, maar simpel gezegd kun je ze zien als een stapel eenvoudige transformaties. Er zijn veel verschillende componenten die een FFNN vormen, dus laten we die in meer detail bekijken, in het bijzonder de MLP-structuur. 

In een MLP zijn er drie soorten lagen: input-, verborgen en outputlaag, die we eerder kort noemden. 

Kijk naar het bovenstaande diagram terwijl we deze lagen in meer detail verkennen. 

Inputlaag

Dit is het toegangspunt van het netwerk.  Elke neuron stelt één feature uit de dataset voor. Belangrijk: de inputlaag voert zelf geen berekeningen uit — hij geeft simpelweg ruwe getallen door. In ons voorbeeld, met slechts twee neuronen in de inputlaag, betekent dit dat onze dataset twee features bevat (of dat we er twee overwegen). 

Verborgen lagen

Hier gebeurt de echte berekening. We hebben twee verborgen lagen met elk vier neuronen. Elke neuron in een verborgen laag doet drie dingen:

1. Gewogen som: Elke input wordt met een gewicht vermenigvuldigd en vervolgens worden ze allemaal opgeteld. 
2. Biais: Er wordt een constante biais toegevoegd om de functie te kunnen verschuiven.
3. Activatiefunctie: Er wordt een niet-lineaire knijpfunctie zoals ReLU, tanh of sigmoid toegepast. Deze stap stelt het netwerk in staat complexe, niet-lineaire patronen te leren.

Outputlaag

De outputlaag produceert de uiteindelijke voorspelling en het ontwerp hangt af van het probleem dat we willen oplossen:

• Regressie problemen, zoals het voorspellen van huizenprijzen. In dit geval bevat de outputlaag één neuron zonder activatie (lineair). Waarom lineair? Omdat we waarden niet willen knijpen; huizenprijzen kunnen elke reële waarde aannemen.
• Binaire classificatie problemen (ja/nee-beslissingen), zoals voorspellen of een e-mail spam is of niet. Hier zou de outputlaag één neuron hebben met een sigmoidactivatie. Waarom sigmoid? Omdat we willen dat ons netwerk waarden tussen 0 en 1 uitgeeft (we voorspellen waarschijnlijkheden). 
• Multiklasse-classificatie (3 of meer klassen) — zoals een afbeelding classificeren als verschillende dieren. De outputlaag zou één neuron per klasse hebben, met softmax-activatie. Waarom softmax? Omdat het ruwe scores omzet in waarschijnlijkheden die optellen tot 1 (bijv. 70% kat, 20% hond, 10% paard).

Ter referentie: hier is een diagram met negen veelvoorkomende vormen van activatiefuncties die worden gebruikt in FFNN’s en deep learning in het algemeen. 

Voordat we verder gaan, is het ook belangrijk om te vermelden dat elke neuron in de ene laag is verbonden met elke neuron in de volgende laag (daarom noemen we het volledig verbonden). 

Terug naar ons voorbeeld, we hebben:

Params = (2⋅4+4)+(4⋅4+4)+(4⋅1+1)=12+20+5=37

Elke haak geeft het aantal parameters tussen opeenvolgende lagen weer, waarbij het aantal neuronen van de vorige en huidige laag met elkaar wordt vermenigvuldigd en daarna het aantal biais (d.w.z. het aantal neuronen in de huidige laag) wordt opgeteld. Probeer deze berekeningen ook op andere neurale netwerkvoorbeelden te doen ter oefening!

Een feedforward-neuraal netwerk trainen

In deep learning is trainen opgesplitst in twee stappen: forward pass/propagation en backpropagation. Simpel gezegd: forward propagation geeft ons voorspellingen, terwijl backpropagation is hoe we leren van fouten. 

Forward propagation 

Alles wat we tot nu toe hebben behandeld valt onder forward propagation. Samengevat: wanneer data door een MLP beweegt, voert elke laag dezelfde twee stappen uit, die wiskundig zo kunnen worden opgeschreven:

Hier is z de output na het vermenigvuldigen van de output van de vorige laag met de gewichten van de huidige laag en het optellen van de biais, ook wel de lineaire stap genoemd. 

Natuurlijk, als de vorige laag de inputlaag is, dan is dit x in plaats van al-1. De volgende stap is de activatiestap. Om dit wiskundig strikter te maken, kunnen we de gewichten en biais zo schrijven:

Backpropagation

Als we een output hebben gekregen, hoe laten we ons netwerk dan weten of die correct is? Of beter nog: hoe maken we het netwerk beter in de taak? Hier komt backpropagation in beeld. Je kunt het zien als het feedbacksysteem voor het netwerk: het vertelt het model hoe ver het ernaast zat en hoe het zichzelf moet bijstellen. We kunnen het zo opdelen:

1. Voorspellingen vergelijken: Kijk naar wat het model voorspelde (ŷ) en wat het echte antwoord was (y).
2. De fout berekenen: We gebruiken een verliesfunctie om te meten hoe fout de voorspelling was, zoals MSE.
3. Backpropageren (via de kettingregel): De gradiënten ten opzichte van alle biais en gewichten worden berekend. ∂L/∂w,∂L/∂b .
4. Gradientdescent-update: De respectieve parameters worden geüpdatet om het verlies te verkleinen volgens de onderstaande regel:

Hier is η de learning rate, een parameter die je kunt aanpassen om te bepalen hoeveel de parameters bij elke update veranderen. 

Na veel rondes van dit proces leert het netwerk geleidelijk en wordt het beter in de taak.

Om het duidelijker te maken, lopen we samen een heel klein voorbeeld door. Stel we hebben:

• Input: x = 2
• Doeloutput: y=4
• Voorspelling: ŷ = 3

Laten we nu de stappen doorlopen. 

1. Voorspelling vergelijken: ŷ =3, y = 4
2. Fout: Voor dit voorbeeld gebruiken we de MSE: L=(y−y^​)2=(4−3)2=1
3. Backpropageren: Het netwerk bepaalt met afgeleiden hoeveel elk gewicht en elke biais aan deze fout heeft bijgedragen en vervolgens updaten we elke parameter met de gradientdescent-stap. 

Een feedforward-neuraal netwerk coderen in PyTorch

We hebben de relevante wiskunde behandeld om een FFNN (specifiek een MLP) te bouwen. Om verder te gaan, gaan we dit coderen in PyTorch. 

Multilayer perceptron

# Imports we will be needing
import torch
import torch.nn as nn
import torch.optim as optim

X,y = dataset # Here will be our dataset 

# We have created a MLP here using nn.Sequential()
model = nn.Sequential(
    nn.Linear(2, 4),  # input layer → hidden layer (2 → 4)
    nn.ReLU(),        # relu activation function
    nn.Linear(4, 4), # hidden layer 1 → hidden layer 2 (4 → 4)
    nn.ReLU(), 
    nn.Linear(4, 1)   # hidden layer 2 → output (4 → 1)
)


criterion = nn.MSELoss()         # regression loss, i.e our loss function
optimizer = optim.SGD(model.parameters(), lr=0.1) # Optimizer using the Stochastic Gradient Descent

# Training Loop
EPOCHS = 200 # Number of epochs we will be training for
for epoch in range(EPOCHS):
    # Forward pass
    outputs = model(X)
    loss = criterion(outputs, y)

    # Backward pass
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()Mogelijk gemaakt door

Op dit punt zou je de PyTorch-code moeten kunnen koppelen aan de wiskundige stappen die we eerder hebben verkend. Je kunt echter een vraag hebben over epochs.

Een epoch is één volledige doorgang van de volledige trainingsdataset door het neurale netwerk. Stel bijvoorbeeld dat we 1.000 trainingsdatapunten hebben en batchgrootte = 100; nadat het netwerk alle 1.000 afbeeldingen heeft gezien (dus 10 batches), is dat 1 epoch. Trainen kost meestal veel epochs zodat het model zijn gewichten blijft verbeteren.

Convolutioneel neuraal netwerk

Ik wil ook kort andere FFNN’s noemen, waarvan een heel bekende het convolutioneel neuraal netwerk (CNN) is. 

Hoewel een CNN aan het einde ook een MLP bevat, heeft het aan het begin speciale lagen, de zogenaamde convolutionele lagen en poolinglagen. Eerst over convolutionele lagen: deze zijn essentieel omdat ze telkens alleen naar kleine lokale regio’s van de input kijken met behulp van een filter (of kernel).

Dit is erg nuttig bij het classificeren van afbeeldingen, omdat:

• Dense lagen elke pixel als afzonderlijk zouden behandelen en de ruimtelijke structuur negeren.
• Convolutionele lagen daarentegen randen, texturen en vormen in kleine patches kunnen detecteren — en die vervolgens combineren tot complexere patronen naarmate we dieper gaan.

Naast convolutionele lagen gebruiken CNN’s ook poolinglagen.

Belangrijk om te weten: poolinglagen leren geen parameters, maar downsamplen de featuremaps om ze kleiner en beter hanteerbaar te maken.

• De meest voorkomende is max pooling, die de maximumwaarde uit elk klein gebied neemt (bijv. een 2×2-venster).
• Pooling maakt het netwerk efficiënter en geeft ook translatie-invariantie (het netwerk vindt het belangrijker dát een feature bestaat dan waar precies).

We kunnen een CNN in PyTorch zo coderen:

class SimpleCNN(nn.Module): # Define our model as a class
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(1, 8, 3)     # 1→8 channels, 3x3 kernel
        self.pool = nn.MaxPool2d(2, 2)
        self.fc   = nn.Linear(8*13*13, 10) # flatten → 10 classes

    def forward(self, x): # Forward propagation function 
        x = self.pool(torch.relu(self.conv(x)))
        x = x.view(x.size(0), -1)          # flatten
        return self.fc(x)Mogelijk gemaakt door

In de bovenstaande code hebben we een heel eenvoudige CNN gemaakt, bestaande uit één convolutionele laag, één poolinglaag en één lineaire laag. 

Andere voorbeelden van feedforward-neurale netwerken

We hebben twee heel bekende en belangrijke voorbeelden van FFNN’s besproken, maar er zijn nog veel meer voorbeelden die revolutionair zijn geweest in hun respectieve domeinen, zoals:

1. Transformers: elk blok bevat een MLP/FFN-gedeelte (na self-attention vergroot + verkleint de “feedforward-laag” de dimensies).
2. Vision Transformers (ViT’s): passen transformerblokken (met FFNN’s erin) toe op beeldpatches.
3. Auto-encoders (de basisvariant): encoder + decoder zijn beide opgebouwd uit FFNN’s.
4. Aanbevelingssystemen (MLP-gebaseerd): bijv. Wide & Deep-modellen voor ranking en voorspellingen.

Tot slot

Hopelijk is duidelijk geworden hoe belangrijk FFNN’s zijn binnen AI. Zonder deze netwerken zou het moderne deep-learninglandschap niet bestaan.

Voor je verdere leerpad raad ik je sterk aan om backpropagation te beheersen en dieper in activatiefuncties te duiken. Omdat dit de basis is van deep learning, raad ik ook aan om Deep Learning met PyTorch te leren.