3D convolution

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à.

🧱 Nota Bene — Padding nella profondità (dimensione $z$)

Nella convoluzione 3D, il kernel ha dimensione $K_D\times K_H\times K_W$ e viene fatto scorrere lungo tutte e tre le dimensioni: profondità ($z$), altezza ($x$), larghezza ($y$).

Se la profondità del kernel $K_D$ è tale da “sforare” i bordi del volume di input,
allora si applica un padding anche lungo la profondità, analogamente a quanto avviene per $x$ e $y$.

---

✅ Senza padding:

• Il kernel può essere centrato solo dove entra completamente.
• L’output ha profondità ridotta:
  $D_{\text{out}}=D-K_D+1$ (con stride = 1)

✅ Con padding:

• Si aggiunge padding sopra e sotto lungo $z$ (profondità).
• Questo consente al kernel di scorrere anche ai bordi del volume.
• L’output può mantenere la stessa profondità dell’input.

---

📌 Esempio:

• Input: $D=5$
• Kernel: $K_D=3$
• Padding: $P_D=1$

→ Il kernel può scorrere da $z=0$ a $z=4$
→ Output: $D_{\text{out}}=5$

---

🛠️ Conclusione:
Il padding in profondità è opzionale, ma fondamentale per mantenere l’allineamento tra input e output o per controllare la dimensione dell’output desiderato.

🎯 Nota Bene — Numero di Canali di Uscita ($C_{\text{out}}$)

Sia nella convoluzione 2D che in quella 3D, il numero di canali di uscita $C_{\text{out}}$ è una scelta indipendente dalle dimensioni spaziali del filtro convoluzionale.

• Per ottenere $C_{\text{out}}$ feature map in uscita, la rete apprende $C_{\text{out}}$ filtri distinti.
• Ogni filtro convoluzionale ha dimensione:
  • In 2D: $C_{\text{in}}\times K\times K$
  • In 3D: $C_{\text{in}}\times K_D\times K_H\times K_W$

---

🧠 Il numero di filtri (cioè $C_{\text{out}}$) determina la profondità dell’output,
ma non dipende dalle dimensioni spaziali del filtro, che controllano invece l’estensione locale dell’analisi sull’input.

🧭 Nota Bene — Differenza tra dati $(H,W,C_{\text{in}})$ e $(D,H,W,C_{\text{in}})$

Quando si lavora con reti convoluzionali, è fondamentale distinguere correttamente la struttura dell’input, soprattutto nel caso tridimensionale.

---

Caso 1 — Dati 2D multicanale → Forma: $(H,W,C_{\text{in}})$

• Ogni punto $(x,y)$ contiene un vettore di $C_{\text{in}}$ valori (es. RGB).
• Può essere visto come $C_{\text{in}}$ immagini 2D, una per ciascun canale.

✅ Convoluzione 2D → Filtro: $C_{\text{in}}\times K\times K$

---

Caso 2 — Dati 3D multicanale → Forma: $(D,H,W,C_{\text{in}})$

Quando si lavora con un input 3D multicanale di forma $(D,H,W,C_{\text{in}})$,
ci sono due modi naturali di raggruppare i dati:

---

1. Raggruppamento per canale (scelto dalle CNN 3D):

   • Si fissa un canale $k$.
   • L’intero volume tridimensionale $D\times H\times W$ relativo a quel canale è trattato come un blocco 3D.
   • In totale: $C_{\text{in}}$ blocchi 3D separati.

   Questo è il punto di vista usato nei layer convoluzionali 3D:
   l’input è rappresentato come un tensore 4D
   $A^{\text{in}}\in {\mathbb{R}}^{C_{\text{in}}\times D\times H\times W}$ (canali $\times$ profondità $\times$ altezza $\times$ larghezza).

---

2. Raggruppamento per profondità:

   • Si fissa un indice di profondità $z$.
   • Ogni slice $z$ corrisponde a un frame 2D di dimensione $H\times W$ con $C_{\text{in}}$ canali.
   • In totale: $D$ frame 2D multicanale, come nei video.

   Questo punto di vista è utile quando $D$ rappresenta il tempo,
   o una sequenza ordinata di dati (frame, istanti, scansioni).

---

📌 Quando usare ciascuna rappresentazione?

• Se $D$ rappresenta una dimensione spaziale o temporale reale
  (es. profondità, tempo nei video, asse nelle TAC),
  si usa il raggruppamento per canale → convoluzione 3D standard.

• Se invece $D$ è una proprietà interna al canale (es. spettro, feature astratte),
  può essere trattato come parte dei canali:
  si ridefinisce $C_{\text{in}}^{\prime }=D\cdot C_{\text{in}}$ e si può usare convoluzione 2D.

ℹ️ Profondità dell’output nella convoluzione 3D

In una convoluzione 3D, ogni canale di output genera una feature map tridimensionale,
di forma: $D_{\text{out}}\times H_{\text{out}}\times W_{\text{out}}$.

La profondità dell’output $D_{\text{out}}$ dipende da:

• profondità dell’input: $D$
• dimensione del kernel lungo la profondità: $K_D$
• padding lungo la profondità: $P_D$
• stride lungo la profondità: $S_D$

---

🧮 Formula generale per la profondità dell’output:

$$D_{\text{out}}=\lfloor \frac{D+2P_D-K_D}{S_D}\rfloor +1$$

---

📌 Quindi:

• Se non si usa padding ($P_D=0$):

  $$D_{\text{out}}=\lfloor \frac{D-K_D}{S_D}\rfloor +1$$

  👉 L’output avrà profondità ridotta rispetto all’input.

• Se si desidera che l’output abbia la stessa profondità dell’input ($D_{\text{out}}=D$),
  allora bisogna usare il **padding :

  $$P_D=\lfloor \frac{K_D-1}{2}\rfloor$$

---

✅ Il numero di canali di output $C_{\text{out}}$ è indipendente dalla profondità:
può essere scelto liberamente, come avviene nella convoluzione 2D.

Differenza tra $D$ e $K_D$

❗ È importante ricordare che nella convoluzione 3D:

• $D$ è la profondità dell’input (cioè quante “slice” ha ogni blocco 3D)
• $K_D$ è la profondità del kernel, ovvero quanto “spesso” è ciascun kernel 3D

---

✅ Non è necessario che $K_D=D$.

Al contrario:

• Spesso $K_D<D$, così il kernel può scorrere lungo la profondità
• Questo consente di catturare pattern locali nel tempo (es. video o segnali volumetrici)

---

📌 Analogamente a quanto avviene per altezza e larghezza ($K_H<H$, $K_W<W$), anche $K_D$ agisce come una finestra mobile che si sposta lungo l’asse della profondità.

Questo approccio permette di generare un output tridimensionale con profondità $D_{\text{out}}<D$ (a meno che non si usi padding “same” per mantenere $D_{\text{out}}=D$).