Residualblok

1. 1

   En byggesten i et residualt neuralt netværk, der implementerer en springende forbindelse (skip connection), så lagene lærer en residualfunktion i stedet for en direkte mapping.

   • I en typisk Residualblok med to konvolutionslag summeres inputtet med det transformerede output, aktiveret af en ReLU-funktion. — He et al., Deep Residual Learning for Image Recognition, 2015
   • Bottleneck-Residualblokke bruger et 1x1-konvolutionslag til at reducere dimensionen før de tunge lag. — He et al., Deep Residual Learning for Image Recognition, 2015

Residualblokke anvendes i dybe neurale netværk, især i ResNet-arkitekturer, for at muliggøre træning af meget dybe modeller (>100 lag) uden at lide under forsvindende gradienter. De er også grundlaget for moderne CNN-arkitekturer som ResNeXt og EfficientNet.

y = F(x, {Wi}) + x
hvor F(x, {Wi}) er residualfunktionen (f.eks. to konvolutionslag) og x er inputtet via identitetsspring.

import torch.nn as nn

class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.conv2 = nn.Conv2d(out_channels, out_channels, 3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, 1, stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )

    def forward(self, x):
        out = nn.ReLU(inplace=True)(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += self.shortcut(x)
        out = nn.ReLU(inplace=True)(out)
        return out

Simpel PyTorch-implementering af en Residualblok med to 3x3 konvolutionslag og en shortcut-forbindelse, der justerer dimensioner ved hjælp af 1x1-konvolution om nødvendigt.

Termen 'residual' kommer fra latin 'residuum' (rest) og refererer til den resterende del, som blokken skal lære, mens 'blok' betegner en modulær enhed. Begrebet blev introduceret af Kaiming He et al. i 2015 i forbindelse med ResNet.

• Deep Residual Learning for Image Recognition (He et al., 2015)