Wat is een residual blok?

Het residuele blok is een architecturaal element van neurale netwerken, geïntroduceerd in ResNet, dat helpt bij het bestrijden van het probleem van verdwijnende gradiënten tijdens het trainen van zeer diepe netwerken.

Het idee van het residuele blok is dat, in plaats van een directe mapping ( H(x) ) te leren, het blok een correctie ( F(x) = H(x) - x ) leert, oftewel het residu. Uiteindelijk wordt de uitgang van het blok berekend als:

[ \text{uitgang} = F(x) + x ]

waar:

• ( x ) de invoer van het blok is,
• ( F(x) ) het resultaat is van meerdere lagen (bijvoorbeeld convolutie, activaties).

Dit maakt het gemakkelijker voor de gradiënt om door de lagen te gaan, wat het trainen van diepe modellen verbetert.

Voorbeeld van een eenvoudig residueel blok (pseudo-code):

import torch
import torch.nn as nn

class ResidualBlock(nn.Module):
    def __init__(self, channels):
        super().__init__()
        self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm2d(channels)
        self.relu = nn.ReLU()
        self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(channels)

    def forward(self, x):
        residual = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        out += residual  # toevoegen van de invoer (skip-verbinding)
        out = self.relu(out)
        return out

Op deze manier maken residuele blokken het mogelijk om zeer diepe neurale netwerken te bouwen zonder afname van de trainingskwaliteit.