06 - Conv3D (1)

Nel caso di convoluzione 3D, l’intuizione si estende a blocchi 3D:

• Per ogni canale $C_{in}$ l’input è un blocco tridimensionale: profondità $D$, altezza $H$, larghezza $W$
• Se ci sono $C_{\text{in}}$ canali, si hanno $C_{\text{in}}$ blocchi 3D, uno per ciascun canale
• Ogni $A_k^{\text{in}}\in {\mathbb{R}}^{D\times H\times W}$ rappresenta il $k$-esimo canale di input come un volume 3D

Fissando un canale di output $j$:

• Il filtro convoluzionale usato dalla rete è uno stack di $C_{\text{in}}$ kernel 3D, ognuno di dimensione $K_D\times K_H\times K_W$
• Questi kernel scorrono nei rispettivi blocchi di input

---

Calcolo del valore in uscita $A_j^{\text{out}}[z,x,y]$

Per ogni posizione spaziale $(z,x,y)$ nella mappa di output del canale $j$, il valore viene calcolato nel seguente modo:

1. Per ogni canale $k$ dell’input:

   • Si applica il kernel 3D $W_{jk}\in {\mathbb{R}}^{K_D\times K_H\times K_W}$ sovrapponendolo al volume tridimensionale $A_k^{\text{in}}$ in modo che il centro del kernel cada sulla posizione $(z,x,y)$

   • Si estrae quindi una regione cubica di dimensione $K_D\times K_H\times K_W$ dal $k$-esimo canale dell’input

   • Questo significa che la finestra del kernel scorre lungo le tre dimensioni $(z,x,y)$, e a ogni passo raccoglie un blocco locale dell’input allineato con i pesi del kernel

   • Si calcola infine il prodotto scalare elemento per elemento tra questa regione e il kernel $W_{jk}$:

     
     
   $$(W_{jk}\ast A_k^{\text{in}})[z,x,y]=\sum _{d=0}^{K_D-1}\sum _{i=0}^{K_H-1}\sum _{\ell =0}^{K_W-1}{W}_{jk}[d,i,\ell ]\cdot A_k^{\text{in}}[z+d-P_D,x+\ell -P_H,y+i-P_W]$$

2. Si sommano i contributi di tutti i canali $k$:

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

3. Si aggiunge il bias $b_j$ e si applica la funzione di attivazione $f$:

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

Note

Ogni valore $A_j^{\text{out}}[z,x,y]$ rappresenta uno scalare all’interno della mappa tridimensionale del canale di uscita $j$.

---

Formula esplicita: versione element-wise

Esplicitando completamente la convoluzione 3D rispetto agli indici:

$$\boxed{A_j^{\text{out}}[z,x,y]=f\left(b_j+\sum _{k=0}^{C_{\text{in}}-1}\underset{(W_{jk}\ast A_k^{\text{in}})[z,x,y]}{\underbrace{\sum _{d=0}^{K_D-1}\sum _{i=0}^{K_H-1}\sum _{\ell =0}^{K_W-1}{W}_{jk}[d,i,\ell ]\cdot A_k^{\text{in}}[z+d-P_D,x+\ell -P_H,y+i-P_W]}}\right)}$$

• $d$: scorre la profondità
• $i$: scorre le righe (altezza)
• $\ell$: scorre le colonne (larghezza)
• $P_D$, $P_H$, $P_W$: padding lungo ciascun asse

Il kernel convoluzionale viene sovrapposto a un blocco tridimensionale per ogni canale, ed esegue un prodotto scalare canale per canale.

🔢 Esempio concreto: convoluzione 3D con più canali

Si supponga di avere:

• Un input tridimensionale con $C_{\text{in}}=2$ canali
• Ogni canale è un volume $A_k^{\text{in}}\in {\mathbb{R}}^{6\times 6\times 6}$, con assi:
  • $z$: profondità (fronte ↔ retro)
  • $x$: larghezza (sinistra → destra)
  • $y$: altezza (alto → basso)
• Un filtro convoluzionale per il canale di output $j$, composto da:
  • Uno stack di $C_{\text{in}}$ kernel 3D, ciascuno di dimensione $3\times 3\times 3$: $W_{jk}\in {\mathbb{R}}^{3\times 3\times 3}$
• SI usi padding 1 lungo tutte le dimensioni, così l’output avrà ancora dimensione $6\times 6\times 6$

---

Si consideri la posizione $(z,x,y)=(2,2,2)$ nell’output.

A questa posizione:

• Si posiziona ogni kernel $W_{jk}$ (uno per ciascun canale $k$) con il suo centro su $(2,2,2)$
• Da ogni volume di input $A_k^{\text{in}}$ si estrae un blocco cubico di dimensione $3\times 3\times 3$:
  • Profondità: da $z-1$ a $z+1$ → $[1,2,3]$
  • Larghezza ($x$): da $x-1$ a $x+1$ → $[1,2,3]$
  • Altezza ($y$): da $y-1$ a $y+1$ → $[1,2,3]$

In notazione Python-like:

$$\text{Blocco estratto da }{A}_k^{\text{in}}:A_k^{\text{in}}[1:4,1:4,1:4]$$

✴️ Questo processo viene fatto per ogni canale $k=0,\dots ,C_{\text{in}}-1$.

🧮 Per ciascun canale di input $k$:

• Si calcola il prodotto scalare tra il blocco estratto da $A_k^{\text{in}}$ e il corrispondente kernel $W_{jk}$

📌 Alla fine:

• Si sommano i contributi da tutti i canali
• Si aggiunge il bias $b_j$
• Si applica la funzione di attivazione

Risultato:

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

---

Conv 2D vs 3D

	Convoluzione 2D	Convoluzione 3D
Input	$C_{\text{in}}$ immagini 2D	$C_{\text{in}}$ blocchi 3D
Filtro convoluzionale	Stack di kernel 2D	Stack di kernel 3D
Per ogni posizione	Prodotto scalare 2D × 2D	Prodotto scalare 3D × 3D
Uscita (canale $j$)	$A_j^{\text{out}}[x,y]$	$A_j^{\text{out}}[z,x,y]$

🔎 Geometria vs Notazione tensoriale

• La descrizione geometrica riguarda le dimensioni spaziali effettive di un oggetto (e.g. larghezza, altezza, profondità).
• La descrizione in termini di tensore aggiunge dimensioni “astratte” usate per rappresentare aspetti logico-strutturali come canali, batch o filtri.
• Di conseguenza, un oggetto che geometricamente è $n$-dimensionale può corrispondere a un tensore di ordine superiore.

Esempio:
Un kernel cubico che agisce nello spazio è geometricamente 3D (profondità, altezza, larghezza).
Se però lo si considera in un modello neurale con più canali di input, la sua rappresentazione diventa un tensore 4D (canali × profondità × altezza × larghezza).
Le ulteriori dimensioni non sono spaziali, ma descrivono la struttura dei dati.

Note

📎 Ogni filtro convoluzionale 3D è un blocco 4D di pesi con forma $C_{\text{in}}\times K_D\times K_H\times K_W$

📎 La profondità del kernel $K_D$ non deve coincidere con la profondità dell’input $D$:
il kernel viene spostato lungo $z$ esattamente come lungo $x$ e $y$

🚫 Limitazioni delle convoluzioni 3D

Le CNN con convoluzioni 3D non sono molto diffuse perché:

• Il numero di parametri cresce rapidamente con le dimensioni del volume (profondità, altezza, larghezza)
• Richiedono più memoria e potenza computazionale rispetto alle CNN 2D

Le CNN funzionano molto bene su segnali 1D e immagini 2D, ma per dati 3D non rappresentano lo stato dell’arte.

➤ I Transformer, al contrario, sono dimension-agnostic e stanno emergendo come alternativa più efficace per strutture dati complesse e ad alta dimensionalità.