Een uitleg zonder voorkennis
Hoe werkt een eenvoudig deep learning‑netwerk?
We bouwen het stap voor stap op — van het allerkleinste bouwsteentje, één neuron, tot een klein netwerk dat echt iets kan leren. Onderweg is het vooral vermenigvuldigen en optellen. Geen wiskundeknobbel nodig.
- 01 het neuron
- 02 de activatiefunctie
- 03 een laag
- 04 een klein netwerk
- 05 hoe het leert
Leren uit voorbeelden, niet uit regels
Stel: je wil een programma maken dat op een foto een kat herkent. De klassieke manier is regels schrijven: “heeft het puntige oren? snorharen? een staart?” In de praktijk werkt dat slecht — er zijn te veel uitzonderingen.
Een neuraal netwerk pakt het anders aan. In plaats van regels te bedenken, laat je het heel veel voorbeelden zien (“dit is een kat, dit niet…”). Het netwerk zoekt daar zelf het patroon in. Dat zelf-aanpassen aan voorbeelden noemen we leren.
En “deep” (diep)? Dat betekent gewoon dat het netwerk uit meerdere lagen bestaat, op elkaar gestapeld. Hoe meer lagen, hoe “dieper”. We beginnen klein en bouwen die diepte zelf op.
Het neuron: één rekenstapje
Een neuron is verrassend simpel. Het krijgt een paar getallen binnen (de invoer), en geeft één getal terug (de uitvoer). Daartussen doet het vier dingen:
Stap voor stap
1. Vermenigvuldigen. Elke invoer krijgt een gewicht (een getal dat zegt hoe belangrijk die invoer is). Een groot positief gewicht zegt “dit telt zwaar mee”; een negatief gewicht “dit werkt juist tegen”.
2. Optellen. Alle vermenigvuldigingen worden bij elkaar opgeteld. Daar komt nog een bias bij: een vast getal dat de hele som een duwtje omhoog of omlaag geeft, een soort drempel.
3. Activeren. Die som gaat door een activatiefunctie. Die maakt er een “net antwoord” van — bijvoorbeeld een getal tussen 0 en 1. Daarover dadelijk meer.
4. Uitvoeren. Wat eruit komt, is één getal. Klaar.
In formulevorm ziet dat er zo uit (laat je niet afschrikken — lees het gewoon als de vier stapjes hierboven):
ŷ = f(z) ← f is de activatiefunctie
Laten we het neuron laten beslissen of we gaan fietsen. Twee invoeren, allebei op een schaal van 0 tot 1:
x₁ = temperatuur (0 = koud → 1 = warm)
x₂ = regen (0 = droog → 1 = nat)
We kiezen gewichten die logisch zijn: warmte maakt fietsen aantrekkelijker (w₁ = 3), regen werkt sterk tegen (w₂ = −4), en als basis zijn we eerder geneigd thuis te blijven (b = −0,5). Als activatiefunctie nemen we de sigmoïde, die alles netjes tussen 0 en 1 plet.
Op een warme dag met wat lichte regen (x₁ = 0,9 x₂ = 0,2):
ŷ = f(1,4) = 0,80
De uitvoer is 0,80 — ruim boven 0,5. Het neuron zegt: ga fietsen. Op een koele dag met flinke regen (x₁ = 0,4 x₂ = 0,7) wordt z = −2,1 en de uitvoer 0,11 — blijf thuis. Hetzelfde rekenstapje, ander antwoord.
Probeer het zelf
Sleep aan de schuifjes en kijk hoe het neuron rekent en beslist.
Vaste gewichten in dit voorbeeld: w₁ = 3 (temperatuur telt mee), w₂ = −4 (regen telt zwaar tegen), b = −0,5 (drempel). De witte streep in de balk is 0,5 — daarboven “ga fietsen”, daaronder “blijf thuis”.
De activatiefunctie
Waarom dat extra stapje, de activatiefunctie? Zonder activatie zou een neuron alleen maar optellen en vermenigvuldigen — een kaarsrechte lijn. En als je rechte lijnen op elkaar stapelt, krijg je… weer een rechte lijn. Dan helpt diepte niets.
De activatiefunctie brengt een bocht aan. Net die bochten zorgen ervoor dat een netwerk ingewikkelde patronen kan leren. Twee komen heel vaak voor:
In ons fietsvoorbeeld gebruikten we de sigmoïde, zodat de uitvoer netjes leesbaar werd als een soort kans: 0,80 voelt als “waarschijnlijk wel”, 0,11 als “waarschijnlijk niet”.
Van één neuron naar een laag
Eén neuron kan maar naar één ding kijken. Maar je kan er meerdere naast elkaar zetten. Ze krijgen dezelfde invoer, maar hebben elk hun eigen gewichten. Zo let elk neuron op een ander patroon. Samen vormen ze een laag, en geven ze meerdere getallen terug.
Een klein netwerk: lagen op elkaar
Nu de echte truc. Je kan de uitvoer van de ene laag gebruiken als de invoer van de volgende. Stapel je lagen zo op elkaar, dan heb je een netwerk:
De eerste laag heet de invoerlaag, de laatste de uitvoerlaag. Alles ertussen heet verborgen laag — “verborgen” omdat je die getallen niet rechtstreeks afleest. Meer verborgen lagen = “dieper”. Dát is de “deep” in deep learning.
Een mooie manier om diepte te begrijpen: de vroege lagen vangen eenvoudige patronen op, latere lagen combineren die tot ingewikkeldere. Bij beeldherkenning bijvoorbeeld: eerst randjes, dan vormen, dan “dit lijkt op een oog”, en uiteindelijk “dit is een kat”.
Laten we getallen door het kleine netwerk sturen. Invoer: x₁ = 1, x₂ = 0. De verborgen neuronen gebruiken ReLU, het uitvoerneuron de sigmoïde.
Verborgen laag — elk neuron telt zijn eigen gewogen som op en past ReLU toe:
h₂ = ReLU( (−1)×1 + 3×0 ) = ReLU(−1) = 0
Merk op hoe h₂ door ReLU op 0 belandt: het negatieve resultaat wordt afgekapt. Uitvoerlaag — dit neuron leest h₁ en h₂ en gebruikt de sigmoïde:
ŷ = f(2,5) = 0,92
De einduitvoer is 0,92. Niets magisch — gewoon het neuron-stapje, een paar keer achter elkaar, laag na laag.
Hoe leert het netwerk?
Tot nu toe kozen wij de gewichten met de hand. Maar het hele punt van deep learning is dat het netwerk zelf de goede gewichten vindt. Hoe? Door te oefenen op voorbeelden waarvan we het juiste antwoord al kennen.
Aan het begin zijn alle gewichten gewoon willekeurig. Het netwerk raadt maar wat, en zit er flink naast. Daar begint het leren:
De vier begrippen, in mensentaal
Het verlies (loss) is één getal dat zegt hoe fout de voorspelling was. Voorspelde het netwerk 0,3 terwijl het juiste antwoord 1 was, dan is het verlies groot. Hoe kleiner het verlies, hoe beter.
De gradiënt is een soort helling. Stel je voor dat je geblinddoekt op een heuvel staat en de laagste plek zoekt. Je voelt met je voet welke kant naar beneden gaat. De gradiënt doet precies dat, maar dan voor het verlies: ze wijst voor elk gewicht aan welke kant het verlies kleiner maakt. Dat afdalen naar het laagste punt heet gradient descent.
De leersnelheid bepaalt hoe grote stappen je zet. Te groot en je schiet voorbij de laagste plek; te klein en het duurt eindeloos.
Backpropagatie (backpropagation) is de slimme boekhouding die, vertrekkend van de fout aan de uitvoer, terugrekent naar achter door alle lagen om te bepalen welk gewicht hoeveel aan de fout heeft bijgedragen. Zo weet het netwerk welk knopje het hoeveel moet verdraaien.
Eén keer alle voorbeelden doorlopen heet een epoch. Na heel veel epochs zijn de gewichten geen willekeurige getallen meer, maar precies de waarden die goede voorspellingen geven. Op dat moment heeft het netwerk “geleerd”.
In één adem
Een deep learning-netwerk is, van klein naar groot:
Een neuron vermenigvuldigt zijn invoer met gewichten, telt op (plus een bias), en stuurt de som door een activatiefunctie die er een bocht in legt. Zet je neuronen naast elkaar, dan krijg je een laag. Stapel je lagen, dan krijg je een netwerk — en meer lagen betekent “dieper”. Dat netwerk leert door op voorbeelden te oefenen: het voorspelt, meet zijn fout (het verlies), en stelt via gradient descent en backpropagatie al zijn gewichten telkens een klein beetje bij, tot het goed gokt.
Of nog korter: heel veel kleine “vermenigvuldig‑optel‑en‑buig”‑stapjes, met al hun knopjes afgesteld door voorbeelden.
Woordenlijst
- Neuron
- Het kleinste rekeneenheidje: vermenigvuldigt invoer met gewichten, telt op, en past een activatiefunctie toe.
- Gewicht
- Een getal dat zegt hoe belangrijk een bepaalde invoer is. Kan positief of negatief zijn.
- Bias
- Een vast getal dat bij de som komt; werkt als een drempel die het neuron makkelijker of moeilijker laat “aanslaan”.
- Activatiefunctie
- De stap die een bocht in de berekening brengt (bv. sigmoïde of ReLU). Zonder bocht zou diepte zinloos zijn.
- Laag
- Meerdere neuronen naast elkaar, met dezelfde invoer maar eigen gewichten.
- Verborgen laag
- Een laag tussen invoer en uitvoer waarvan je de getallen niet rechtstreeks afleest.
- Voorwaartse doorgang
- Het signaal van invoer naar uitvoer door het netwerk sturen om een voorspelling te krijgen.
- Verlies (loss)
- Eén getal dat meet hoe ver de voorspelling van het juiste antwoord af zit.
- Gradient descent
- Stap voor stap “bergaf” gaan: de gewichten telkens in de richting verschuiven die het verlies verkleint.
- Backpropagatie
- De methode die de fout van achter naar voor door het netwerk terugrekent om te weten welk gewicht hoeveel moet bijgesteld worden.
- Epoch
- Eén keer alle oefenvoorbeelden doorlopen. Trainen duurt meestal vele epochs.
Klaar voor een netwerk dat echt leert?
Tot hier ging het over de losse bouwstenen. In het vervolg zetten we ze samen tot een werkend, zelflerend netwerkje dat twee getallen leert optellen — met de volledige wiskunde, draaiende code in Java én Python, en een demo waarin je het live ziet leren. Daarna breiden we uit naar vier bewerkingen.