ResNet-architectuur: Residual Networks en skipverbindingen

Diepere neurale netwerken zouden beter moeten presteren. Maar in de praktijk is dat niet altijd zo.

Na een bepaalde diepte kan de nauwkeurigheid juist afnemen. Niet omdat het model overfit - maar omdat het trainen zelf stukloopt. Gradiënten neigen te verdwijnen voordat ze de vroege lagen bereiken, en die lagen stoppen met leren. Je zou denken dat meer lagen toevoegen het oplost, maar vaak maakt het dat alleen maar erger.

ResNet loste dit op met het kernidee van skipverbindingen. In plaats van elke laag te dwingen om vanaf nul te leren, laat het netwerk lagen overslaan en de input direct bij de output optellen.

In dit artikel leg ik uit hoe ResNet werkt, hoe de architectuur eruitziet en waarom het nog steeds een go-to algoritme is in moderne deep learning.

Wil je ResNet in de praktijk zien? Maak onze Image classification with ResNet-oefening als onderdeel van de cursus Deep Learning for Images with PyTorch.

Wat is de ResNet-architectuur?

ResNet - kort voor Residual Network - is een neurale netwerkarchitectuur die is ontworpen om het trainen van diepe netwerken praktisch te maken.

Het idee werd in 2015 geïntroduceerd door Microsoft Research. Het algoritme gebruikt residual connections om de trainingsproblemen te omzeilen die diepe netwerken destijds beperkten. Het idee was simpel, maar na deze ontdekking kon je voor het eerst betrouwbaar netwerken met 50, 101 of zelfs 152 lagen trainen - zonder dat de prestaties achteruitgingen.

Voor ResNet was zo diep gaan eigenlijk geen optie.

Waarom diepe netwerken lastig te trainen zijn

Meer lagen zouden meer kans moeten geven om te leren. In de praktijk begint na een bepaalde diepte alles stuk te lopen.

Er spelen hier twee problemen.

Het eerste is het verdwijnende-gradiëntenprobleem. Neurale netwerken leren door foutsignalen achterwaarts door het netwerk te sturen - een proces dat backpropagation heet. Elke laag past zijn gewichten aan op basis van dat signaal. Maar naarmate het signaal door veel lagen terugreist, wordt het keer op keer met kleine getallen vermenigvuldigd en krimpt het. Tegen de tijd dat het de vroege lagen bereikt, is er bijna niets meer over. Die lagen stoppen met updaten en dus met leren.

Het tweede is het degradatieprobleem. Dit is tegenintuïtief. Je zou verwachten dat een netwerk met 56 lagen minstens net zo goed presteert als een met 20 lagen - het heeft immers meer capaciteit. Maar onderzoekers vonden het omgekeerde. Het diepere netwerk presteerde slechter, zelfs op trainingsdata. Daarmee valt overfitting als oorzaak af. Het model onthoudt niet te veel. In plaats daarvan heeft het moeite met optimalisatie.

Dit is het cruciale onderscheid. Het zijn geen generalisatieproblemen die je oplost met dropout of regularisatie. Het zijn optimalisatieproblemen - het netwerk kan in eerste instantie geen goede gewichten vinden.

ResNets zijn ontworpen om deze twee problemen op te lossen. Ik laat je zien hoe.

Het kernidee: residual learning

Traditionele neurale netwerken proberen een directe mapping van input naar output te leren. Elke laag bekijkt wat er binnenkomt en probeert te bepalen wat eruit moet komen. Dat werkt prima voor ondiepe netwerken. Maar naarmate je dieper gaat, loop je tegen de twee eerder besproken problemen aan.

Met ResNet vraag je elk blok niet om de volledige mapping te leren, maar stel je een eenvoudigere vraag: wat moet ik toevoegen aan de input om de juiste output te krijgen?

Dat verschil heet het residu.

Dus in plaats van te leren:

Residual learning (1)

Leert het netwerk:

Residual learning (2)

Waarbij F(input) het residu is - de kleine correctie die het netwerk moet maken. Als de laag niets hoeft te veranderen, kan die F(input) naar nul duwen en de input ongewijzigd doorgeven.

Dit klinkt misschien als een kleine aanpassing. Maar het verandert wat het netwerk moet leren. Een kleine correctie leren is een veel eenvoudiger optimalisatieprobleem dan een volledige transformatie vanaf nul, en dát maakt diepere netwerken trainbaar.

Wat zijn skipverbindingen in ResNet?

Een skipverbinding is precies wat het klinkt - een directe route die één of meer lagen overslaat en de input naar een later punt in het netwerk voert.

In een traditioneel netwerk stroomt data sequentieel door elke laag. Elke laag transformeert de input en geeft het resultaat door aan de volgende. Skipverbindingen nemen de oorspronkelijke input en tellen die direct op bij de output van een laag verderop in het blok.

Zo kun je het je eenvoudig voorstellen:

Voorbeeld van een skipverbinding-grafiek

De input x reist tegelijk over twee paden. Eén pad gaat door de convolutionele lagen, die het residu F(x) leren. Het andere pad slaat die lagen over en sluit aan bij de optelslag. De uiteindelijke output is F(x) + x.

Deze shortcut doet iets belangrijks voor het trainen. Tijdens backpropagation kunnen gradiënten terugstromen via de skipverbinding, zonder door de tussenliggende lagen te gaan. Dat geeft de vroege lagen een schoner en sterker signaal om van te leren - precies wat ontbrak in diepe netwerken vóór ResNet.

Structuur van een ResNet-blok

Een residual block is de herhalende bouwsteen van een ResNet. Begrijp je één blok, dan begrijp je het hele netwerk.

Dit gebeurt er binnen een enkel blok:

1. De input x komt het blok binnen en splitst in twee paden

2. Eén pad gaat door twee convolutionele lagen, elk gevolgd door batchnormalisatie en een ReLU-activatie

3. Het andere pad slaat die lagen over - dit is de skipverbinding

4. Beide paden komen samen bij een optelslag, waar de oorspronkelijke input wordt opgeteld bij de output van de convolutionele lagen

5. Een laatste ReLU-activatie wordt op het resultaat toegepast

Of in diagramvorm:

ResNet-blokdiagram

De skipverbinding hier heet een identiteitsmapping - de input gaat ongewijzigd door en wordt direct opgeteld bij de geleerde output. Het is de eenvoudigste mogelijke shortcut zonder transformatie en zonder extra parameters.

Maar om te kunnen optellen, moeten beide paden tensors met dezelfde vorm produceren. Als de convolutionele lagen de ruimtelijke dimensies of het aantal kanalen veranderen, kan de input x niet worden opgeteld. In die gevallen past ResNet een projectieshortcut toe - een 1×1-convolutie op het skippad die x vervormt zodat het past.

De meeste blokken in een ResNet gebruiken identiteits-shortcuts. Projectieshortcuts verschijnen alleen wanneer dimensies veranderen, typisch wanneer het netwerk tussen stadia schakelt.

Typen ResNet-architecturen

ResNet komt in een paar standaardvarianten, elk genoemd naar het totale aantal lagen. De juiste keuze hangt af van waar je op optimaliseert - snelheid, nauwkeurigheid, of iets daartussenin.

Vergelijking van ResNet-architecturen

ResNet-18 en ResNet-34 gebruiken het standaard basic block - twee 3×3-convolutionele lagen met een skipverbinding. Ze zijn snel en goedkoop om te draaien, waardoor ze een goed startpunt zijn bij prototyping of als je met beperkte hardware werkt.

ResNet-50 en hoger schakelen over op een ander ontwerp, het zogeheten bottleneck-blok, dat drie lagen gebruikt in plaats van twee. Die verandering maakt diepere netwerken makkelijker te trainen zonder een evenredige sprong in rekencost. In de volgende sectie lees je hoe dat werkt.

ResNet-101 en ResNet-152 gaan nog een stap verder, ten koste van langere trainingstijden en hoger geheugengebruik. Ze zijn gangbaar in onderzoek en in productiesystemen waar nauwkeurigheid belangrijker is dan snelheid.

Voor het meeste praktische werk is ResNet-50 het standaard startpunt. Het heeft een goede balans tussen diepte en kost en wordt in elk belangrijk deep learning-framework goed ondersteund.

ResNet bottleneck-architectuur

Diepere ResNets gebruiken niet hetzelfde blokontwerp als ondiepere. Vanaf ResNet-50 schakelt de architectuur over op een bottleneck-blok, een drielaags ontwerp dat de rekencapaciteit beheersbaar houdt naarmate de diepte toeneemt.

Het blok gebruikt drie convoluties op rij:

• 1×1-convolutie - vermindert het aantal kanalen en maakt de input kleiner
• 3×3-convolutie - doet het eigenlijke feature learning op die kleinere representatie
• 1×1-convolutie - vergroot de kanalen weer naar de oorspronkelijke grootte

De eerste en laatste 1×1-convoluties fungeren als bottleneck - vandaar de naam. Ze comprimeren de data vóór de duurdere 3×3-convolutie draait en herstellen die erna.

Een 3×3-convolutie op een input met veel kanalen is rekenintensief. Door eerst de kanalen te verminderen, kan de 3×3-laag zijn werk doen op een veel kleinere input. Het resultaat is een blok dat dieper gaat zonder een evenredige sprong in rekencost.

De skipverbinding werkt hetzelfde als in een basic block - de input wordt opgeteld bij de output vóór de laatste activatie. Het enige verschil is dat hier bijna altijd een projectieshortcut nodig is, omdat de kanaaldimensies binnen het blok veranderen.

Hoe ResNet het verdwijnende-gradiëntenprobleem oplost

Het verdwijnende-gradiëntenprobleem draait om afstand. Hoe verder een gradiënt door een netwerk moet reizen, hoe meer hij krimpt - en tegen de tijd dat hij de vroege lagen bereikt, blijft er te weinig over om van te leren.

Skipverbindingen omzeilen dit probleem door gradiënten een korter pad te geven.

Tijdens backpropagation hoeven gradiënten niet door elke laag in volgorde te gaan. Ze kunnen direct via de skipverbinding terugstromen en de convolutionele lagen volledig omzeilen. Die shortcut houdt de gradiënt groot genoeg om de vroege lagen daadwerkelijk te updaten.

Dit verandert ook wat elk blok moet leren. In plaats van een volledige transformatie vanaf nul te vinden, hoeft het netwerk alleen een kleine correctie bovenop de input te leren. Dat is een veel eenvoudiger optimalisatieprobleem en betekent dat het netwerk dieper kan gaan zonder dat het trainen instabiel wordt.

Kortom, netwerken die eerder te diep waren om betrouwbaar te trainen, worden trainbaar.

ResNet vs. traditionele CNN-architecturen

Traditionele CNN's en ResNets leren allebei features uit afbeeldingen, maar doen dat op verschillende manieren.

In een traditionele CNN stroomt data in een rechte lijn door de lagen. Elke laag neemt de output van de vorige, past een transformatie toe en geeft het resultaat door. Dat werkt goed tot op zekere hoogte. Na een bepaalde diepte wordt de sequentiële structuur onbetrouwbaar tijdens backpropagation - gradiënten krimpen, vroege lagen stoppen met leren en de nauwkeurigheid daalt.

ResNet gaat niet in een rechte lijn. Skipverbindingen laten de input één of meer lagen overslaan en direct optellen bij de output verderop in het blok. Het netwerk leert nog steeds transformaties, maar heeft ook een directe route waar zowel data als gradiënten doorheen kunnen.

Zo verhouden de twee benaderingen zich:

ResNet versus traditionele CNN

De skipverbindingen helpen zowel met gradiënten als met het soepeler maken van de optimalisatie, waardoor het netwerk sneller en betrouwbaarder goede gewichten vindt.

Toepassingen van de ResNet-architectuur

De ResNet-architectuur duikt op bij een breed scala aan realistische taken.

Beeldclassificatie is waar ResNet begon. Het won de ImageNet Large Scale Visual Recognition Challenge in 2015 en is nog steeds een vaste keuze om afbeeldingen in categorieën in te delen, of dat nu medische scans, satellietbeelden of productfoto's zijn.

Objectdetectie-workflows gebruiken vaak ResNets. Frameworks als Faster R-CNN en Mask R-CNN combineren ResNet met een detectiehead die objecten in een afbeelding identificeert en lokaliseert. ResNet doet de feature-extractie en de detectiehead doet de rest.

Transfer learning is waar ResNet voor de meeste data scientists echt nuttig wordt. In plaats van vanaf nul te trainen - wat dagen kost en veel data - laad je een ResNet dat vooraf op ImageNet is getraind en finetune je het op je eigen dataset. De voorgetrainde gewichten coderen al nuttige laag-niveau-features zoals randen, texturen en vormen, dus je start vanaf een veel beter punt.

Feature-extractie pakt het vergelijkbaar aan. Je haalt je afbeeldingen door een voorgetrainde ResNet en trekt de output uit een van de latere lagen. Die outputs zijn compacte, betekenisvolle representaties van je afbeeldingen die je in een eenvoudigere classifier of clustering-algoritme kunt voeren.

In al deze use-cases werkt ResNet als een voorgetraind startpunt. De meeste deep learning-frameworks worden standaard geleverd met voorgetrainde ResNet-gewichten, waardoor het een van de makkelijkste architecturen is om mee te beginnen.

Voordelen en beperkingen van ResNet

ResNet was een echte stap vooruit in deep learning - maar zoals elke architectuur kent het trade-offs. Ik loop een paar voordelen en nadelen langs.

Voordelen

De meest voor de hand liggende is diepte. Skipverbindingen maken het mogelijk om netwerken met 50, 100 of zelfs 150+ lagen te trainen zonder tegen het degradatieprobleem aan te lopen. Dat was vóór ResNet niet betrouwbaar mogelijk.

Trainen is ook stabieler. De shortcut-paden geven gradiënten een schone route terug door het netwerk, wat betekent: minder finetunen, minder collapses en voorspelbaardere resultaten over verschillende taken en datasets.

En de prestatie is ook een voordeel. ResNet-varianten scoren consequent goed op beeldbenchmarks, en voorgetrainde ResNet-modellen transfereren goed naar nieuwe domeinen. Daarom blijven ze een standaard startpunt voor veel computer vision-projecten.

Beperkingen

ResNet is rekenintensief. Diepere varianten zoals ResNet-101 en ResNet-152 hebben veel geheugen en rekenkracht nodig, wat een beperking kan zijn als je met beperkte hardware werkt of snelle inferentie nodig hebt.

Het is ook niet voor elke taak de beste keuze. Voor kleinere datasets of eenvoudigere problemen doet een lichtere architectuur het vaak net zo goed voor een fractie van de kosten. Standaard kiezen voor ResNet-50 is niet altijd de juiste zet.

En op sommige gebieden is ResNet verdrongen. Architecturen zoals EfficientNet halen betere nauwkeurigheid per parameter op beeldtaken, en transformers hebben andere domeinen overgenomen. ResNet wordt nog breed gebruikt, maar het is niet langer de enige serieuze optie.

ResNet in moderne deep learning

Elf jaar na de introductie staat de ResNet-architectuur nog steeds sterk. Dat is niet gebruikelijk in deep learning.

De meeste practitioners grijpen nog steeds naar ResNet wanneer ze een betrouwbaar baseline-model voor een computer vision-taak nodig hebben. Het is goed begrepen, in elk belangrijk framework goed ondersteund en voorgetrainde gewichten zijn in elke grote bibliotheek beschikbaar. Dus als je iets nodig hebt dat werkt zonder veel geëxperimenteer, is ResNet meestal de eerste optie die je probeert.

Maar de invloed reikt verder dan de eigen varianten.

Het kernidee van ResNet - dat je een shortcut om lagen heen kunt toevoegen om informatie en gradiënten te laten stromen - bleek breed bruikbaar. DenseNet verfijnde dat idee door elke laag met elke andere laag te verbinden, niet alleen door één of twee over te slaan. En hoewel transformers een andere architectuur hebben, volgen de residual connections binnen elk transformerblok hetzelfde principe dat ResNet introduceerde.

Nieuwere architecturen zoals EfficientNet, ConvNeXt en vision transformers hebben de prestaties in specifieke gebieden verder opgevoerd. Maar ze hebben ResNet niet zozeer vervangen als wel voortgebouwd op wat het heeft neergezet.

Conclusie

De ResNet-architectuur draait om één ding: skipverbindingen. Dat ene idee loste twee problemen op die diepe netwerken tegenhielden - verdwijnende gradiënten en het degradatieprobleem - en maakte het praktisch om netwerken te trainen op een diepte die eerder niet mogelijk was.

Het idee om shortcuts tussen lagen toe te voegen is nu een standaardbouwsteen in moderne deep learning, te zien in DenseNet, transformers en de meeste architecturen die na 2015 zijn gebouwd.

Als je vandaag aan een computer vision-probleem werkt, is ResNet nog steeds een solide startpunt. Het is niet de nieuwste optie, maar wel een van de meest betrouwbare. Zie het als een baseline - je zult verrast zijn hoe het in 2026 de concurrentie nog steeds kan overtreffen.

Ben je nieuw in deep learning maar ken je de basis van Python, bekijk dan onze cursus Introduction to TensorFlow in Python - daarmee kun je in een weekend aan de slag met onderwerpen zoals ResNets.