Konvolution og filtre: Registrering af kanter og mønstre

Convolution er en matematisk operation, der lader en lille matrix kaldet et filter (eller kernel) glide hen over et input (f.eks. et billede) og beregner et prikprodukt element for element ved hver position. Resultatet er et feature map, der fremhæver, hvor det mønster, som filteret repræsenterer, forekommer i inputtet. Inden for billedbehandling registrerer forskellige filtre forskellige egenskaber: kanter, hjørner, teksturer eller koncepter på højere niveau, når de stables i flere lag.

Klassisk billedbehandling bruger håndlavede filtre: Sobel-filteret registrerer vandrette eller lodrette kanter, Laplacian-filteret registrerer alle kanter, og Gaussian-filteret slører (udjævner) billeder. I deep learning bliver disse filtre lært fra data i stedet for at blive lavet manuelt. Den centrale indsigt ved CNN'er er, at netværket automatisk finder ud af, hvilke filtre der er nyttige til opgaven, ved at minimere træningstabet.

nn.Conv2d(in_channels, out_channels, kernel_size) er det centrale CNN-lag. in_channels er antallet af inputkanaler (3 for RGB-billeder), out_channels er antallet af filtre, der skal læres, og kernel_size er den rumlige størrelse af hvert filter (3 betyder 3x3). Hvert filter producerer én outputkanal, så 64 filtre producerer et feature map med 64 kanaler. Det samlede antal parametre i ét Conv2d-lag er out_channels * in_channels * kernel_h * kernel_w + out_channels (bias).

Padding tilføjer nuller rundt om inputtets kant før convolution. padding=1 med et 3x3-filter bevarer inputtets rumlige dimensioner (same-padding). Uden padding reducerer hver convolution bredden og højden med kernel_size - 1. Stride styrer, hvor mange pixels filteret flytter sig ved hvert trin. stride=2 halverer outputdimensionerne og fungerer som en let pooling-operation. Convolutioner med stride 2 bruges ofte i moderne CNN'er i stedet for eksplicit pooling.

Et farvebillede har 3 kanaler (R, G, B). Hvert filter i et Conv2d-lag har en dybde, der svarer til in_channels — det arbejder på alle inputkanaler samtidig og producerer én enkelt outputværdi pr. rumlig position. Med 64 filtre får du 64 outputkanaler. Det næste convolution-lag tager derefter disse 64 kanaler som input. Denne stabling af kanaler gør det muligt for netværket gradvist at opbygge mere abstrakte repræsentationer, fra farvekanter på lavt niveau til objektdel på højt niveau.

En vigtig fordel ved convolutioner er deling af vægte: Det samme filter anvendes ved alle rumlige positioner. Et 3x3-filter over et billede på 256x256 involverer 9 parametre uanset billedets størrelse, mens et fuldt forbundet lag ville kræve millioner af parametre. Det gør CNN'er langt mere parametereffektive end MLP'er til billeddata og giver dem translationsækvivarians — en forskudt version af et mønster i inputtet producerer et tilsvarende forskudt feature map.

Visualisering af lærte filtre afslører et hierarki af lærte egenskaber. Filtre i det første lag registrerer typisk orienterede kanter, farvegradienter og teksturer — omtrent som håndlavede Sobel-filtre. Filtre i mellemlag registrerer kombinationer: kurver, hjørner og teksturer. Filtre i dybe lag reagerer på objektdel (øjne, hjul og fjer). Denne hierarkiske indlæring af egenskaber er grunden til, at dybe CNN'er klarer sig markant bedre end overfladiske modeller på opgaver inden for billedgenkendelse.

En neurons receptive field i et CNN er det område af det oprindelige inputbillede, der bidrager til dens aktivering. Ét 3x3-convolution-lag har et receptivt felt på 3x3. To stablede 3x3-lag giver et receptivt felt på 5x5. Tre giver 7x7. Det er mere parametereffektivt at stable mange små filtre end at bruge ét stort filter, samtidig med at man opnår det samme receptive field. Det er grunden til, at moderne CNN'er næsten udelukkende bruger 3x3-filtre — inspireret af VGGNets opdagelse.

Den standardiserede CNN-blok følger mønstret: Conv2d -> BatchNorm2d -> ReLU -> (valgfri pooling). Denne trio gentages flere gange med et stigende antal kanaler, så de rumlige dimensioner gradvist reduceres, mens antallet af featurekanaler øges. Den rumlige reduktion komprimerer positionsoplysninger, mens kanaludvidelsen opfanger mere abstrakte egenskaber. Dette mønster er grundlaget for ResNet, VGG, EfficientNet og de fleste andre arkitekturer.

Efter træningen kan du visualisere featurekort (filteraktiveringer) for et bestemt inputbillede og se, hvad hvert filter har registreret. Lyse områder i et featurekort viser, hvor det tilsvarende filtermønster blev registreret. Det er nyttigt til fejlfinding (kontrol af, at de tidlige lag har lært kantdetektorer) og til fortolkning (visning af, hvilke områder i et billede der aktiverede en detektor for "hundepels" eller "hjul" i senere lag).

1x1-konvolutioner anvender en lineær kombination på tværs af kanaler ved hver rumlig position uden nogen rumlig miksning. De bruges til billigt at reducere eller udvide antallet af kanaler (som i Inception- og MobileNet-flaskehalsdesign). En 1x1-konvolution fra 256 til 64 kanaler reducerer beregningerne i den efterfølgende 3x3-konvolution med 16 gange. De introducerer også ikke-linearitet (via aktivering) mellem trinnene med kanalmiksning, hvilket øger modellens kapacitet med en minimal omkostning i antal parametre.

I denne lektion lærte du: konvolution flytter et filter hen over inputtet og beregner prikprodukter for at producere et featurekort, der fremhæver, hvor filtermønsteret forekommer; parametrene i nn.Conv2d (in_channels, out_channels, kernel_size, padding, stride) styrer filterbanken; og vægt-deling gør konvolutioner markant mere parametereffektive end fuldt forbundne lag til rumlige data. Nu skal vi se på poolinglag til rumlig nedsampling og translationsinvarians.