Faltningsnät (CNN)

En bild på 224 × 224 × 3 har 150 000 tal. Ett fullt kopplat lager med 1 000 neuroner skulle ha 150 miljoner vikter — och lära sig samma kant på tusen olika platser separat.

Faltning (convolution): ett litet filter (3 × 3 × 3 = 27 vikter) glider över bilden och räknar samma sak överallt. 64 filter → 64 «kartor» över var något finns (kanter, färgövergångar). Samma vikter överallt = översättningsinvarians + få parametrar.

Pooling (max/medel över 2 × 2) halverar upplösningen; efter några lager täcker varje neuron ett stort receptivt fält och ser hela objekt. Stapla: faltning → ReLU → pooling, upprepa, sist ett litet fullt kopplat huvud.

Moderna alternativ (ViT) gör liknande med attention över bildlappar, men CNN är fortfarande effektivast på liten data.

import torch, torch.nn as nn

class LitetCNN(nn.Module):
    def __init__(self, klasser=10):
        super().__init__()
        self.f = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),   # 32×32 → 16×16
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),  # → 8×8
            nn.Conv2d(64, 128, 3, padding=1), nn.ReLU(), nn.AdaptiveAvgPool2d(1),
        )
        self.huvud = nn.Linear(128, klasser)
    def forward(self, x):
        return self.huvud(self.f(x).flatten(1))

m = LitetCNN()
print(sum(p.numel() for p in m.parameters()))    # ≈ 94 000 — jämför 150 M för ett dense-lager
print(m(torch.zeros(4, 3, 32, 32)).shape)         # (4, 10)

Parametrar i ett Conv2d(in, ut, k): in · ut · k · k + ut. Utdatastorlek med padding p och stride s: ⌊(H + 2p − k)/s⌋ + 1.

2D-faltning (egentligen korskorrelation i DL-bibliotek): $(x * w)[i,j] = \sum_{c}\sum_{u,v} x[c, i+u, j+v]\, w[c,u,v]$. Ett lager med $C_{in}$ in- och $C_{out}$ utkanaler och kärna $k$ har $C_{out}(C_{in}k^2 + 1)$ parametrar oberoende av bildstorlek. Receptivt fält växer additivt: efter $L$ lager med $k=3$, stride 1: $1 + 2L$; varje pooling/stride-2 dubblar tillväxten. Ekvivarians: $f(T_\delta x) = T_\delta f(x)$ för translationer $\delta$ (upp till kanteffekter); pooling ger approximativ invarians. Batchnormalisering och residualkopplingar gör djupa CNN (ResNet) tränbara.