2D convolution

Input Multi-Canale

Sia l’input al layer convoluzionale:

$${\mathbf{A}}^{\text{in}}\in {\mathbb{R}}^{C_{\text{in}}\times H\times W}$$

• $C_{\text{in}}$: numero di canali di input (e.g. 3 per immagini RGB)
• $H,W$: dimensioni spaziali

Per ogni canale di uscita $j\in \{0,\dots ,C_{\text{out}}-1\}$, la rete apprende un filtro convoluzionale:

$${\mathbf{W}}_j=\{W_{jk}{\}}_{k=0}^{C_{\text{in}}-1}$$

dove ogni $W_{jk}\in {\mathbb{R}}^{K\times K}$ è un kernel 2D dedicato al canale di input $k$.
Questi kernel vengono impilati per formare un blocco 3D di pesi.

L’attivazione del canale di uscita $j$ è calcolata come:

$$\boxed{{\mathbf{A}}_j^{\text{out}}=f\left(b_j+\sum _{k=0}^{C_{\text{in}}-1}{W}_{jk}\ast {\mathbf{A}}_k^{\text{in}}\right)}$$

dove:

• $W_{jk}$: kernel 2D associato alla coppia formata dal canale di output $j$-esimo e dal canale di input $k$-esimo
• ${\mathbf{A}}_k^{\text{in}}$: k-esimo canale dell’input
• $\ast$: operazione di convoluzione 2D
• $b_j$: bias associato al canale di uscita $j$
• $f$: funzione di attivazione (es. ReLU)

Important

Per ogni $k$:

• il prodotto $W_{jk}\ast {\mathbf{A}}_k^{\text{in}}$ restituisce una matrice 2D (una feature map parziale);
• variando $k$, si ottengono $C_{\text{in}}$ matrici 2D;
• queste matrici vengono sommate tra loro elemento per elemento;
• infine si aggiunge il bias $b_j$ (broadcasted su tutta la matrice) e si applica la funzione di attivazione $f$.

📌 Il risultato finale è quindi una matrice 2D: la feature map completa corrispondente al canale di uscita $j$.

Ripetendo il processo per tutti i $j\in \{0,\dots ,C_{\text{out}}-1\}$ si ottiene:

$${\mathbf{A}}^{\text{out}}\in {\mathbb{R}}^{C_{\text{out}}\times H^{\prime }\times W^{\prime }}$$

📌 Nota

Ogni filtro convoluzionale ${\mathbf{W}}_j$ è una matrice tridimensionale di pesi,
composta da $C_{\text{in}}$ kernel 2D impilati, e produce una sola feature map di uscita.

In totale, un layer convoluzionale apprende $C_{\text{out}}$ filtri indipendenti,
ciascuno responsabile di una mappa distinta nell’output.

Important

Le CNN possono essere riguardate come estrattori generali di features da immagini/segnali: esse apprendono milioni di features extractors per ogni layer, ciascuno responsabile della rilevazione di specifici pattern nei dati.

Nella figura riportata, si osserva che le CNN esibiscono milioni di parametri anche in un singolo layer convoluzionale. Analogamente, anche gli MLP possono contenere un numero molto elevato di parametri, nell’ordine di $10^6$, $10^9$ o persino $10^{12}$. Sebbene anche nelle CNN si raggiungano valori simili, i loro parametri sono impiegati per apprendere features differenti.

In questo senso, le CNN sono vere e proprie feature representation learners, il che le distingue profondamente dagli MLP, i quali non possiedono un meccanismo esplicito per l’estrazione gerarchica delle caratteristiche.

Avendo espresso la convoluzione in forma compatta:

$$\boxed{{\mathbf{A}}_j^{\text{out}}=f(b_j+\sum _{k=0}^{C_{\text{in}}-1}{W}_{jk}\ast {\mathbf{A}}_k^{\text{in}})}$$

tale formula si può declinare elemento per elemento, tenendo conto che:

• l’asse $x$ cresce verso destra,
• l’asse $y$ cresce verso il basso,
• l’indice $\ell$ corrisponde allo spostamento orizzontale ($x$),
• l’indice $i$ corrisponde allo spostamento verticale ($y$).

Dunque, fissata la posizione $(x,y)$, si ottiene la forma locale:

$$\boxed{A_j^{\text{out}}[x,y]=f(b_j+\sum _{k=0}^{C_{\text{in}}-1}\sum _{i=0}^{K-1}\sum _{\ell =0}^{K-1}{W}_{jk}[i,\ell ]\cdot A_k^{\text{in}}[x+\ell -P,y+i-P\left]\right)}$$

Dettaglio: risultato delle convoluzioni 2D per canale

Per ciascun canale di input $k$, l’operazione

$$(W_{jk}\ast A_k^{\text{in}})[x,y]=\sum _{i=0}^{K-1}\sum _{\ell =0}^{K-1}{W}_{jk}[i,\ell ]\cdot A_k^{\text{in}}[x+\ell -P,y+i-P]$$

restituisce uno scalare: il valore in $(x,y)$ ottenuto dalla convoluzione 2D del kernel $W_{jk}$ sul canale $k$.

• $\ell$ è lo spostamento orizzontale (asse $x$), $i$ è lo spostamento verticale (asse $y$).
• Il padding $P$ garantisce che anche ai bordi siano disponibili tutte le $K^2$ posizioni del kernel.

Ripetendo questo calcolo per tutti i $k=0,\dots ,C_{\text{in}}-1$, si ottengono $C_{\text{in}}$ scalari.

Tali scalari vengono poi sommati elemento per elemento:

$$S[x,y]=\sum _{k=0}^{C_{\text{in}}-1}(W_{jk}\ast A_k^{\text{in}})[x,y],$$

e infine si applica bias e attivazione:

$$A_j^{\text{out}}[x,y]=f(b_j+S[x,y]).$$

📊 Riepilogo passo‑passo per posizione $(x,y)$

Passo	Descrizione
1	Per ogni $k$: calcola $(W_{jk}\ast A_k^{\text{in}})[x,y]$ sommando i prodotti su tutti gli offset $(i,\ell )$.
2	Somma i risultati: $S[x,y]={\sum }_k(W_{jk}\ast A_k^{\text{in}})[x,y]$.
3	Aggiungi il bias: $S[x,y]+b_j$.
4	Applica la funzione di attivazione: $A_j^{\text{out}}[x,y]=f(S[x,y]+b_j)$.

---

Esempio

Per ogni canale di uscita $j=0,\dots ,127$ e per ogni posizione $(x,y)\in \{\mathrm{0..4}{\}}^2$, si calcola:

$$\boxed{A_j^{\text{out}}[x,y]=f(b_j+\sum _{k=0}^2\sum _{i=0}^2\sum _{\ell =0}^2{W}_{jk}[i,\ell ]\cdot A_k^{\text{in}}[x+\ell -P,y+i-P])}$$

• la sommatoria su $k$ itera su ciascun canale di input $k$
• la tripla sommatoria ${\sum }_{k,i,\ell }$ accumula i contributi dei $3$ kernel $2D$
• il risultato in $(x,y)$ è un singolo valore che, a valle dell’applicazione di $f$, diventa l’entry $[x,y]$ della feature map $j$

	Dimensioni
Input dims	$7\times 7\times 3$	immagine RGB
Filtro per canale out $j$	$3\times 3\times 3$	$3$ kernel $2D$ da $3\times 3$
Patch spaziale valida	$5\times 5$	$(7-3)+1=5$
# output channels	$128$	quante feature map vogliamo
Output dims	$5\times 5\times 128$	$128$ patch $5\times 5$ impilate
Parametri per filtro	$3\times 3\times 3=27$	pesi di un singolo filtro
Parametri totali layer	$27\times 128=3,456$	pesi del layer

Quando si applica una convoluzione 2D a un input multicanale (e.g. un’immagine RGB), il processo può essere visualizzato in termini di blocchi 2D impilati per ciascun canale di input.

• Fissando un canale di output $j$, la rete utilizza un filtro convoluzionale dedicato per generare la feature map corrispondente.
• Tale filtro è composto da uno stack di $C_{\text{in}}$ kernel 2D, uno per ogni canale dell’input.
• Per ogni posizione spaziale $(x,y)$, il filtro viene centrato su quella posizione:
  • si calcola la convoluzione 2D tra ciascun kernel e il rispettivo canale di input
  • si ottengono $C_{\text{in}}$ mappe parziali (scalari)
  • questi scalari vengono sommati, poi si aggiunge un bias $b_j$ e si applica una funzione di attivazione $f$

Formula:

$$\boxed{A_j^{\text{out}}[x,y]=f\left(b_j+\sum _{k=0}^{C_{\text{in}}-1}(W_{jk}\ast A_k^{\text{in}})[x,y]\right)}$$

dove ogni $A_k^{\text{in}}$ è un’immagine 2D, ogni $W_{jk}$ è un kernel 2D.

---

Visualization

No Padding
$[1,1,1,1]$ Padding

---

Numbers of parameters involved

---

AlexNet and Gabor Filters

Nel $2012$ il gruppo di Hinton, che vinse la ImageNet Challenge con la rete AlexNet, si avvalse di filtri convoluzionali di dimensioni $11\times 11\times 3$: tali filtri, associati al primo layer (deputato a processare i dati di input ossia le immagini raw), erano $96$ e ciascuno è composto da $3$ kernel $11\times 11$.

Info

Laddove i kernel $3\times 3$ non possono essere visualizzati, sono solo un insieme di numeri, i kernel $11\times 11$ possono essere ispezionati visivamente.

Note

AlexNet è stata la prima istanza di successo di una rete CNN (a rigore anche la prima CNN proposta da Lecun fu un successo ma su scala piu piccola: il riconoscimento di caratteri manoscritti) su larga scala (ImageNet-scale: milioni di immagini e migliaia di categorie).

Nella seguente figura, a sinistra sono riportati i primi $40$ su $96$ filtri $11\times 11\times 3$ appresi automaticamente dal primo layer convoluzionale di AlexNet. A destra sono riportati i kernel convoluzionali di Gabor usati nell’Image Analysis per estrarre features.

Gabor filters vs AlexNet

È strabiliante notare come i filtri appresi automaticamente dal primo layer convoluzionale di AlexNet risultino sorprendentemente simili ai kernel convoluzionali di Gabor. La somiglianza tra gli estrattori di features appresi automaticamente e quelli progettati manualmente dall’uomo, come i filtri di Gabor, è sorprendente.

Motivazione intuitiva I filtri di Gabor sono estrattori di bordi di basso livello. Il primo layer di AlexNet è essenzialmente è un estrattore di features di bordi

Ciò accade nella retina umana: la prima cosa che avviene nella nostra retina è la sensibilità ai bordi.

CNN and Visual Cortex

Sussiste un chiaro parallelismo: la percezione visiva umana, l’estrazione matematica delle caratteristiche (come i filtri di Gabor) e l’estrazione automatica tramite CNN convergono tutte verso lo stesso principio fondamentale: il primo passo consiste nell’estrarre i bordi dall’immagine. Da questi bordi si costruiscono livelli superiori di astrazione.

Si parla, infatti, di una catena di livelli di astrazione.

Important

Le CNN sono un tool di apprendimento di rappresentazioni gerarchiche per le immagini.