07 - Conv3D (2)

🧱 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$).