Architektura i mechanika konwolucyjnych sieci neuronowych (CNN)

Konwolucyjne sieci neuronowe (ang. Convolutional Neural Networks, CNN) stanowią fundament współczesnego przetwarzania sygnałów jedno- i wielowymiarowych w widzeniu komputerowym oraz analizie szeregów czasowych. Ich konstrukcja opiera się na trzech kluczowych zasadach: lokalnej łączności (ang. local connectivity), współdzieleniu wag (ang. weight sharing) oraz ekwiwariantności względem translacji (ang. translation equivariance). W przeciwieństwie do gęstych warstw liniowych (ang. fully-connected), w których każdy neuron wejściowy łączy się z każdym neuronem wyjściowym, operacja splotu pozwala zachować topologię danych przy drastycznym ograniczeniu liczby swobodnych parametrów.

Matematyczne podstawy operacji konwolucji (1D i 2D)

W ścisłym sensie matematycznym ciągła konwolucja (splot) dwóch funkcji f i g zdefiniowana jest jako całka:

W dyskretnych implementacjach stosowanych w uczeniu głębokim biblioteki obliczeniowe (np. cuDNN, PyTorch, TensorFlow) realizują w rzeczywistości operację wzajemnej korelacji (ang. cross-correlation), rezygnując z lustrzanego odbicia jądra (ang. kernel flipping). Różnica ta nie ma wpływu na proces optymalizacji, ponieważ wagi jądra są parametrami uczonymi gradientowo podczas propagacji wstecznej.

W przypadku dyskretnym 1D (stosowanym m.in. w sygnałach audio, analizie EKG lub modelowaniu sekwencji tekstowych) sygnał wejściowy x \in \mathbb{R}^L splotowany z filtrem w \in \mathbb{R}^K daje wyjście y \in \mathbb{R}^{L’}:

Dla tensora dwuwymiarowego (2D) z wieloma kanałami wejściowymi, gdzie wejście ma postać X \in \mathbb{R}^{C_{\text{in}} \times H \times W}, a zestaw wag dla c_{\text{out}}-tego filtra stanowi jądro W_{c_{\text{out}}} \in \mathbb{R}^{C_{\text{in}} \times K_h \times K_w} wraz z obciążeniem b_{c_{\text{out}}} \in \mathbb{R}, pojedynczy punkt na mapie cech Y \in \mathbb{R}^{C_{\text{out}} \times H_{\text{out}} \times W_{\text{out}}} wyraża się wzorem:

Wymiary wyjściowe mapy cech zależą bezpośrednio od parametrów siatki dyskretyzacji: paddingu (P), kroku (S), rozmiaru jądra (K) oraz dylatacji (D).

Parametry sterujące: Padding, Stride i Dilated Convolution

Kontrola przestrzennej propagacji sygnału przez warstwy splotowe wymaga precyzyjnego doboru hiperparametrów:

Ogólny wzór na przestrzenny wymiar wyjściowy dla danej osi ma postać:

Warstwy składowe sieci splotowych

Stabilny przepływ gradientu i budowa nieliniowej reprezentacji wymagają zestawienia warstw splotowych z mechanizmami redukcji wymiarowości i normalizacji aktywacji.

Ewolucja architektur: od LeNet do nowoczesnych motywów blokowych

Rozwój sieci konwolucyjnych przeszedł drogę od prostych sekwencji warstw do zaawansowanych topologii wykorzystujących rezydualność i separację wymiarów.

Kluczową innowacją współczesnych sieci jest zastąpienie standardowego splotu 2D jego wariantem Depthwise Separable Convolution. Składa się on z dwóch etapów: splotu depthwise (pojedynczy filtr 2D aplikowany niezależnie dla każdego kanału wejściowego) oraz splotu pointwise (standardowy splot 1×1 agregujący informacje wzdłuż osi kanałów). Zabieg ten redukuje złożoność obliczeniową z K^2 \cdot C_{\text{in}} \cdot C_{\text{out}} do K^2 \cdot C_{\text{in}} + C_{\text{in}} \cdot C_{\text{out}}, co przy standardowym jądrze 3×3 oznacza około 8-krotne do 9-krotne zmniejszenie liczby operacji mnożenia i akumulacji.

Analiza wymiarów tensorów i złożoność obliczeniowa

W warstwie o parametrach: jądro K_h \times K_w, kanały wejściowe C_{\text{in}}, kanały wyjściowe C_{\text{out}} oraz rozmiar wyjścia H_{\text{out}} \times W_{\text{out}}, parametryzacja i koszt obliczeń kształtują się następująco:

(gdzie +1 to wyraz wolny / bias na każdy kanał wyjściowy)

Liczba operacji zmiennoprzecinkowych (FLOPs) wynosi w przybliżeniu 2 \times \text{MACs}, z uwzględnieniem operacji dodawania i mnożenia. Oznacza to, że koszt obliczeniowy rośnie liniowo wraz z polem powierzchni wyjściowej mapy cech oraz kwadratowo względem szerokości kanałów przy symetrycznym skalowaniu C_{\text{in}} = C_{\text{out}}.

Praktyczna implementacja: PyTorch vs. TensorFlow

Poniżej przedstawiono porównanie implementacji modularnego bloku splotowego obejmującego splot 2D, normalizację wsadową, nieliniowość ReLU oraz rezydualne połączenie skrótowe w dwóch wiodących środowiskach uczenia maszynowego.

Wzorzec w środowisku PyTorch:

PyTorch przyjmuje konwencję formatu danych NCHW: (batch_size, channels, height, width).

import torch
import torch.nn as nn
class ResidualConvBlock(nn.Module):
    def __init__(self, in_channels: int, out_channels: int, stride: int = 1):
        super().__init__()
        self.conv1 = nn.Conv2d(
            in_channels, out_channels, kernel_size=3,
            stride=stride, padding=1, bias=False
        )
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(
            out_channels, out_channels, kernel_size=3,
            stride=1, padding=1, bias=False
        )
        self.bn2 = nn.BatchNorm2d(out_channels)
        
        # Dopasowanie wymiarów przy zmianie liczby kanałów lub kroku
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        residual = self.shortcut(x)
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += residual
        return self.relu(out)
# Weryfikacja kształtu wejścia i wyjścia
x = torch.randn(8, 64, 56, 56) # NCHW
block = ResidualConvBlock(in_channels=64, out_channels=128, stride=2)
y = block(x)
print(f"PyTorch output shape: {y.shape}") # Zwraca: torch.Size([8, 128, 28, 28])

Wzorzec w środowisku TensorFlow / Keras:

TensorFlow domyślnie przetwarza dane w układzie NHWC: (batch_size, height, width, channels).

import tensorflow as tf
from tensorflow.keras import layers
class TFResidualConvBlock(layers.Layer):
    def __init__(self, out_channels: int, stride: int = 1, **kwargs):
        super().__init__(**kwargs)
        self.out_channels = out_channels
        self.stride = stride
    def build(self, input_shape):
        in_channels = input_shape[-1]
        self.conv1 = layers.Conv2D(
            self.out_channels, kernel_size=3, strides=self.stride,
            padding="same", use_bias=False
        )
        self.bn1 = layers.BatchNormalization()
        self.relu = layers.Activation("relu")
        self.conv2 = layers.Conv2D(
            self.out_channels, kernel_size=3, strides=1,
            padding="same", use_bias=False
        )
        self.bn2 = layers.BatchNormalization()
        
        if self.stride != 1 or in_channels != self.out_channels:
            self.shortcut = tf.keras.Sequential([
                layers.Conv2D(self.out_channels, kernel_size=1, strides=self.stride, use_bias=False),
                layers.BatchNormalization()
            ])
        else:
            self.shortcut = lambda x: x
    def call(self, inputs, training=False):
        residual = self.shortcut(inputs)
        x = self.conv1(inputs)
        x = self.bn1(x, training=training)
        x = self.relu(x)
        x = self.conv2(x)
        x = self.bn2(x, training=training)
        return self.relu(x + residual)
# Weryfikacja kształtu wejścia i wyjścia
x_tf = tf.random.normal((8, 56, 56, 64)) # NHWC
tf_block = TFResidualConvBlock(out_channels=128, stride=2)
y_tf = tf_block(x_tf)
print(f"TensorFlow output shape: {y_tf.shape}") # Zwraca: (8, 28, 28, 128)

Zastosowania praktyczne i wytyczne inżynieryjne

Sieci splotowe pozostają wysoce wydajnym wyborem w architekturach produkcyjnych ze względu na deterministyczny profil pamięciowy i natywne wsparcie dla akceleratorów sprzętowych (Tensor Cores):

Źródła