02 - Convolution arithmetic

Independence across axes

Convolutional layer parameters operate independently along each axis.
Formally, the choice of kernel size, stride, or padding along axis $j$ affects only the output size of axis $j$, and does not interact with axis $i\ne j$.

For example, in a 2D image: modifying the stride or padding along the horizontal axis changes the width of the output, but leaves the height unchanged.

Here, the term axis follows the same convention as in NumPy (and most deep learning libraries): axis 0 corresponds to rows (height), axis 1 to columns (width), and so on.

Dimostrazione $W_{\text{out}}=W_{\text{in}}-K+2P+1$

Note

Nel prosieguo, a meno di riferimenti espliciti, si assume che lo stride sia unitario: Stride $=1$

---

1. Quantità in gioco

Simbolo	Significato	Nota
$K$	dimensione del local receptive field (finestra $K\times K$ nel caso $2D$)	iper‑parametro
$P$	numero di valori nulli (zero padding) aggiunti per lato	iper‑parametro
$W_{\text{in}}$	estensione dell’input lungo una qualunque dimensione (qui si sceglie la larghezza)	dato del layer precedente
$W_{\text{out}}$	estensione dell’output lungo la stessa dimensione	incognita da calcolare

Il ragionamento per $W$ si replica mutatis mutandis per l’altezza $H$ e per qualsiasi altra dimensione spaziale (e.g. profondità nei dati 3‑D).

---

2. Estensione dovuta allo zero padding

Il padding inserisce $P$ valori nulli su ciascun lato della dimensione considerata. Se si considera la larghezza (width), ad esempio, questi vengono aggiunti ai bordi sinistro e destro dell’input.

La dimensione totale su cui il local receptive field potrà scorrere, ossia la dimensione effettiva ($W_{\text{eff}}$), è data dalla dimensione originale più i valori aggiunti su entrambi i lati.

$W_{\text{eff}}=W_{\text{in}}+2P$

In pratica, l’input viene “incorniciato” da zeri, passando da una struttura [dati] a una [zeri, dati, zeri] lungo quella dimensione.

---

3. Calcolo delle Posizioni del LRF (Stride = 1)

Per determinare la dimensione dell’output ($W_{\text{out}}$), bisogna contare in quante posizioni distinte il local receptive field (LRF), di dimensione $K$, può scorrere lungo la dimensione effettiva $W_{\text{eff}}$.

• Il primo LRF si allinea con l’inizio della dimensione effettiva. Il suo indice di partenza è quindi 0.

• L’ultimo LRF deve essere contenuto interamente nella dimensione effettiva. Un LRF di ampiezza $K$ che parte dall’indice $x$ occupa il range di indici $[x,x+K-1]$. Per garantire che l’LRF non “sfori” i limiti, il suo ultimo elemento ($x+K-1$) non può superare l’ultimo indice della dimensione effettiva ($W_{\text{eff}}-1$):

  $$x+K-1\le W_{\text{eff}}-1⟹x\le W_{\text{eff}}-K.$$

  dove $x$ è la massima posizione di partenza del LRF consentita.

Important

La posizione finale valida per l’inizio del LRF è quindi $x_{\text{max}}=W_{\text{eff}}-K$.

Conteggio Totale

L’estensione dell’output lungo la dimensione in esame ($W_{\text{out}}$) è uguale al numero totale di posizioni che l’LRF può assumere. Poiché gli indici di partenza vanno da $0$ a $W_{\text{eff}}-K$, il conteggio è: $W_{\text{out}}=(\text{Indice Finale}-\text{Indice Iniziale})+1$Sostituendo i valori trovati, si ottiene:$W_{\text{out}}=(W_{\text{eff}}-K)-0+1=W_{\text{eff}}-K+1$

---

4. Formula finale

Stante la formula ricavata al passo precedente:

$$W_{\text{out}}=W_{\text{eff}}-K+1$$

poiché :

$$W_{\text{eff}}=W_{\text{in}}+2P.$$

allora:

$$\boxed{W_{\text{out}}=W_{\text{in}}-K+2P+1}$$

Applicando lo stesso ragionamento alla dimensione verticale:

$$\boxed{H_{\text{out}}=H_{\text{in}}-K+2P+1}$$

e, in un dominio 3‑D, analogamente per la profondità.

Caso generale

La relazione

\text{dimensione_out} = \text{dimensione_in} - K + 2P + 1

$$\grave{e}valida\ast \ast perogniassespaziale\ast \ast dell’input.Applicandolostessoragionamentoaciascunassesiottieneladimensionecompletadell’output.$$

---

Formula generale per la dimensione dell’output (Stride $\ne 1$)

Quando lo stride $S$ è maggiore di 1, la finestra (LRF) salta di $S$ posizioni invece di scorrere di 1. In questo caso, il numero di posizioni valide è dato da:

$$\boxed{W_{\text{out}}=\lfloor \frac{W_{\text{in}}-K+2P}{S}\rfloor +1}$$

Info

La formula tiene conto del fatto che, partendo da indice 0 e saltando di $S$, l’ultima posizione utile è quella più grande per cui il filtro non esce dal dominio paddato.

Viene quindi calcolato quante volte il filtro “entra” nell’input con salto $S$, fino all’ultima posizione valida:

$$x_{\text{max}}=\lfloor \frac{W_{\text{eff}}-K}{S}\rfloor$$

e da qui il conteggio delle posizioni è $x_{\text{max}}+1$.

Applicando la stessa formula alla dimensione verticale o ad altre dimensioni spaziali:

$$\boxed{H_{\text{out}}=\lfloor \frac{H_{\text{in}}-K+2P}{S}\rfloor +1}$$

e in un dominio 3D si procede allo stesso modo per la profondità.

---

Padding che preserva la dimensione ($W_{out}=W_{in}$)

Imponendo che la dimensione spaziale dell’output identica a quella dell’input ($W_{out}=W_{in}$) nella formula (con $S=1$): $W_{out}=W_{in}-K+2P+1$ si ottiene: $W_{in}=W_{in}-K+2P+1$ Semplificando si arriva alla relazione che deve soddisfare il padding: $2P=K-1⟹\boxed{P=\frac{K-1}{2}}$

Tipo di Kernel	Concetto Chiave	Formula per il Padding (P)	Esempi Pratici
Dispari	Permette un padding esatto e simmetrico, mantenendo le dimensioni dell’output identiche a quelle dell’input (con stride 1).	$P=\frac{K-1}{2}$	- Se $K=3⟹P=1$ - Se $K=5⟹P=2$
Pari / Generale	Fornisce un valore di padding “ragionevole” quando un kernel pari è inevitabile. La soluzione non è perfettamente centrata.	$P=\lceil \frac{K}{2}-1\rceil$ (Equivalente a $P=\lfloor \frac{K}{2}\rfloor$)	- Per $K=4⟹P=\lfloor \frac{4}{2}\rfloor =2$ - Per $K=6⟹P=\lfloor \frac{6}{2}\rfloor =3$

Il Caso Standard: Kernel di Dimensione Dispari

La suddetta formula evidenzia un concetto fondamentale.

Poiché il padding $P$ deve essere un numero intero, una soluzione esatta e simmetrica è possibile solo quando il numeratore $(K-1)$ è pari, e cioè quando la dimensione del kernel $K$ è dispari. Questa è la ragione principale per cui nella pratica si usano quasi esclusivamente kernel di dimensione dispari ($3\times 3,5\times 5$, etc.). In questo scenario, la formula è semplice e diretta.

Esempi:

• Se $K=3$, il padding necessario è $P=(3-1)/2=1$.
• Se $K=5$, il padding necessario è $P=(5-1)/2=2$.

I Kernel Pari Non Preservano Esattamente la Dimensione

Allorché si usi un kernel di dimensione pari con stride $1$, è matematicamente impossibile preservare la dimensione esatta dell’input con un padding simmetrico. La formula con ceiling fornisce un valore di padding, ma l’output si ridurrà comunque.

Esempio con $K=4$:

1. Calcolo del Padding: $P=\lceil \frac{4}{2}-1\rceil =\lceil 2-1\rceil =1$.
2. Dimensione di Output Risultante: Usando la formula generale $W_{out}=W_{in}-K+2P+1$, si ottiene: $W_{out}=W_{in}-4+2(1)+1=W_{in}-1$

Come si vede, la dimensione di output si riduce di 1 pixel. Questo avviene perché un kernel pari non ha un pixel centrale, rendendo impossibile una sovrapposizione perfettamente simmetrica.

PyTorch mapping & quick checks

Symbol ↔ PyTorch args

Math symbol	Meaning	PyTorch (Conv2d/MaxPool2d/AvgPool2d)
$K$	kernel size	kernel_size
$P$	(symmetric) padding per side	padding (int/tuple) or 'same'¹
$S$	stride	stride
$D$	dilation	dilation
$K_{\text{eff}}$	effective kernel = $D(K-1)+1$	derived (no direct arg)

¹ Asymmetric padding in PyTorch: use torch.nn.ZeroPad2d((left, right, top, bottom)) or torch.nn.functional.pad(...) before the conv.

---

Output size (Conv/Pool) — PyTorch-exact

For 1D/2D/3D conv and pooling, PyTorch uses:

$$\text{out}=\lfloor \frac{\text{in}+2P-D(K-1)-1}{S}\rfloor +1$$

Equivalently, with effective kernel $K_{\text{eff}}=D(K-1)+1$:

$$\text{out}=\lfloor \frac{\text{in}+2P-K_{\text{eff}}}{S}\rfloor +1$$

Quick sanity checks (run in a PyTorch REPL)

import torch, torch.nn as nn
x = torch.zeros(1, 3, 32, 32)               # N=1,C=3,H=W=32
 
# 3x3, stride=1, padding=1  → out=32
m = nn.Conv2d(3, 8, kernel_size=3, stride=1, padding=1)
print(m(x).shape)  # torch.Size([1, 8, 32, 32])
 
# 5x5, stride=2, padding=2  → out=floor((32+4-5)/2)+1 = 16
m = nn.Conv2d(3, 8, kernel_size=5, stride=2, padding=2)
print(m(x).shape)  # torch.Size([1, 8, 16, 16])
 
# Dilation doubles the effective kernel: K_eff = 2*(3-1)+1 = 5
m = nn.Conv2d(3, 8, kernel_size=3, stride=1, padding=2, dilation=2)
print(m(x).shape)  # torch.Size([1, 8, 32, 32])  since (32+4-5)/1+1 = 32

---

"same" padding in PyTorch

• nn.Conv{1,2,3}d(..., padding='same') picks (possibly asymmetric) padding so that
  $\text{out}=\lceil \frac{\text{in}}{S}\rceil .$
• With stride $S=1$ and odd $K$ (any $D$), this reduces to symmetric padding
  $P=\frac{K_{\text{eff}}-1}{2}=\frac{D(K-1)}{2}.$
• With even $K_{\text{eff}}$ or $S>1$, PyTorch uses asymmetric padding internally to satisfy the ceil rule.

Example

x = torch.zeros(1, 3, 32, 32)
# stride=2, 'same' → out = ceil(32/2) = 16
m = nn.Conv2d(3, 16, kernel_size=3, stride=2, padding='same')
print(m(x).shape)  # torch.Size([1, 16, 16, 16])

---

Transposed conv (a.k.a. deconv) — PyTorch-exact

For nn.ConvTranspose{1,2,3}d:

$$\text{out}=(\text{in}-1)S-2P+D(K-1)+\text{output\_padding}+1$$

Example

x = torch.zeros(1, 8, 16, 16)
# K=3,S=2,P=1,output_padding=1 → out=(16-1)*2 - 2 + 2 + 1 + 1 = 32
m = nn.ConvTranspose2d(8, 3, kernel_size=3, stride=2, padding=1, output_padding=1)
print(m(x).shape)  # torch.Size([1, 3, 32, 32])

---

How dilation maps to your RF derivation

Plug into your formulas

In your receptive-field derivations, replace every kernel size $K$ with the effective kernel

$$K_{\text{eff}}=D(K-1)+1$$

for layers that use dilation $D>1$.
All RF recurrences and closed forms remain valid with $K\leftarrow K_{\text{eff}}$.

---

Asymmetric padding (p_l vs q_l) in PyTorch

Your notes distinguish left/right padding ($p_l$, $q_l$). PyTorch’s Conv2d(..., padding=…) is symmetric; if you need asymmetric padding to match your $p_l,q_l$ exactly:

import torch.nn.functional as F
 
def conv2d_asym(x, weight, bias=None, stride=1, dilation=1, pleft=0, pright=0, ptop=0, pbot=0):
    x = F.pad(x, (pleft, pright, ptop, pbot))   # (left, right, top, bottom)
    return F.conv2d(x, weight, bias=bias, stride=stride, padding=0, dilation=dilation)