Wat is He Initialization?

Wat is He Initialization eigenlijk?

Stel je voor: je bouwt een enorm lang telefoonspel met honderden mensen in een rij. Als de eerste persoon té zacht fluistert, is het bericht aan het eind onverstaanbaar. Roept iemand té hard, dan schreeuwen alle volgende ook te hard en verstaat niemand meer iets. Je moet de startvolume precies goed zetten.

Precies dat probleem speelt bij neurale netwerken. Wanneer je een nieuw netwerk bouwt, moet elke verbinding tussen neuronen een beginwaarde krijgen — we noemen dat een 'gewicht'. Kies je die waarden te klein, dan verdwijnt het signaal al na een paar lagen. Kies je ze te groot, dan ontploft alles en leert het netwerk helemaal niets.

He Initialization (vernoemd naar onderzoeker Kaiming He) is een slim recept om die beginwaarden precies goed te kiezen. Het houdt rekening met hoeveel verbindingen elk neuron heeft: hoe meer inkomende lijntjes, hoe kleiner de startwaarden moeten zijn. Zo blijft het signaal mooi stabiel, van de eerste tot de allerlaatste laag.

Waarom heb je dit nodig?

Vroeger kozen mensen vaak willekeurige kleine getallen tussen -0,1 en 0,1, of ze gebrueerden een andere methode (Xavier/Glorot Initialization). Dat werkte prima voor bepaalde soorten netwerken, maar zodra je ReLU activatiefuncties ging gebruiken — en die zijn tegenwoordig enorm populair — ging het mis. Het signaal stierf halverwege, of het netwerk leerde extreem langzaam.

He Initialization lost dat op door de beginwaarden aan te passen aan het type activatiefunctie. Het zorgt ervoor dat:

• Signalen stabiel blijven tijdens het naar voren reizen door het netwerk

• Gradiënten niet verdwijnen bij het terugreizen (backpropagation)

• Training veel sneller verloopt omdat het netwerk niet eerst moet worstelen met slechte startwaarden

• Diepere netwerken mogelijk worden zonder dat ze vastlopen

Een praktijkvoorbeeld

Je traint een beeldherkenningsnetwerk met 50 lagen om foto's van huisdieren te classificeren. Zonder goede initialisatie zie je dit:

• Na 100 trainingsstappen: het netwerk gokt nog steeds willekeurig, accuracy blijft hangen op 10%

• De loss-grafiek blijft plat of schiet alle kanten op

• Het duurt uren voordat er ook maar iets verbetert

Met He Initialization:

• Al na 20 stappen zie je duidelijke verbetering

• De loss daalt gestaag

• Na een half uur train je al redelijke herkenning

Het verschil zit 'm in die eerste momenten: het netwerk kan direct beginnen met zinvol leren, in plaats van eerst moeizaam uit een slecht startpunt te kruipen.

Hoe werkt het technisch?

He Initialization kiest voor elke verbinding een willekeurig getal uit een speciale verdeling. Die verdeling is breder of smaller afhankelijk van hoeveel neuronen er in de vorige laag zitten. De formule houdt daar precies rekening mee.

Denk aan een waterleiding: heb je één dikke hoofdleiding die zich splitst in honderd dunne kraantjes, dan moet de druk in elk kraantje lager zijn dan in die hoofdleiding. Anders spuit alles alle kanten op. He Initialization rekent die 'druk' automatisch uit.

Bij ReLU-activatiefuncties (die negatieve waarden naar nul knippen) gaat extra signaal verloren. He Initialization compenseert dat door de startwaarden net iets groter te maken dan bij andere methodes.

Waar kom je het tegen?

Bijna alle moderne deep learning frameworks gebruiken He Initialization als standaardoptie voor ReLU-netwerken:

• PyTorch — torch.nn.init.kaiming_normal_() of kaiming_uniform_()

• TensorFlow/Keras — kernel_initializer='he_normal' of 'he_uniform'

• JAX — via jax.nn.initializers.he_normal()

Als je een voorgetraind model downloadt (ResNet, EfficientNet, YOLO), zijn de gewichten al geoptimaliseerd. Maar bij het bouwen van een eigen architectuur of fine-tunen van vroege lagen kies je vaak zelf de initialisatie.

In wetenschappelijke papers over nieuwe architecturen zie je vaak in de methodesectie staan: "weights initialized using He initialization" — een signaal dat de auteurs zorgvuldig met hun startwaarden zijn omgegaan.

Wat kun je ermee?

Als je zelf neurale netwerken bouwt of experimenteert met nieuwe architecturen, is He Initialization je beste vriend bij ReLU-achtige functies. Het scheelt je uren debuggen wanneer een netwerk niet wil trainen. Check in de documentatie van je framework hoe je het instelt — meestal is het één regel code.

Gebruik je Sigmoid of Tanh als activatiefunctie? Dan is Xavier/Glorot Initialization waarschijnlijk beter. Moderne netwerken gebruiken echter overwegend ReLU-varianten, dus He is tegenwoordig de standaard geworden.