Convolution

La convoluzione è l'operazione che fa scorrere su un input una piccola griglia di pesi, detta kernel o filtro, calcolando una somma pesata in ogni posizione. Nella visione artificiale (CV), l'input è un'immagine o una pila di mappe di caratteristiche e ogni kernel produce una mappa di output con valori elevati nei punti in cui compare il suo schema: un bordo verticale, una zona con una trama o, più in profondità nella rete, una parte di una ruota o di un volto. Da tempo si usano kernel progettati manualmente nell'elaborazione delle immagini per sfocare, aumentare la nitidezza e rilevare i bordi. In una rete neurale convoluzionale (CNN), i valori del kernel sono pesi del modello appresi durante l'addestramento, così la rete individua autonomamente i propri rilevatori di caratteristiche.

Come funziona la convoluzione#

In ogni posizione, il kernel viene sovrapposto a una porzione dell'input; ciascun peso del kernel viene moltiplicato per il valore sottostante dell'input e i prodotti vengono sommati, insieme a un bias, per ottenere un valore di output. Facendo scorrere il kernel per tutta l'altezza e la larghezza si produce una mappa di output bidimensionale. Gli input reali hanno diversi canali, come i canali rosso, verde e blu di un'immagine, quindi ogni kernel copre tutti i canali di input: un kernel 3×3 su un input a 64 canali contiene 3 × 3 × 64 = 576 pesi e produce comunque un solo canale di output. Un livello convoluzionale applica molti kernel di questo tipo e il numero di kernel determina il numero di canali di output; quindi, un livello da 64 a 128 canali con kernel 3×3 ha 3 × 3 × 64 × 128 = 73,728 pesi.

Lo stesso kernel viene riutilizzato in ogni posizione: per questo i livelli convoluzionali richiedono molti meno parametri dei livelli completamente connessi e riconoscono ovunque uno schema appreso in un angolo dell'immagine. Se l'input viene traslato, l'output si sposta della stessa quantità: questa proprietà è detta equivarianza alla traslazione. Ogni valore di output dipende solo da una piccola area dell'input e la sovrapposizione di più livelli amplia il campo recettivo riassunto da un valore di output profondo, passando da pochi pixel a gran parte dell'immagine.

Le librerie di deep learning calcolano in realtà la correlazione incrociata: la convoluzione matematica ribalta il kernel prima di farlo scorrere, mentre Conv2d di PyTorch non lo fa. Poiché il kernel viene appreso, la rete impara semplicemente i pesi ribaltati e, nella pratica, le due operazioni sono intercambiabili. Le librerie GPU, come cuDNN, riformulano di solito la convoluzione come una grande moltiplicazione di matrici oppure usano algoritmi basati su Winograd o FFT, che calcolano lo stesso risultato più velocemente del semplice scorrimento del kernel.

Stride, padding, dilatazione e gruppi#

Quattro iperparametri controllano la forma dell'output di una convoluzione e il costo del relativo calcolo:

• Stride: La distanza tra le posizioni del kernel. Uno stride pari a 2 salta una posizione ogni due e dimezza l'altezza e la larghezza dell'output: è così che molte CNN moderne riducono la risoluzione.
• Padding: Valori aggiuntivi, di solito zeri, aggiunti attorno al bordo dell'input. Un padding pari a 1 mantiene l'output di una convoluzione 3×3 della stessa dimensione dell'input con stride 1.
• Dilatazione: Aumenta la distanza tra i punti di campionamento del kernel, così un kernel 3×3 con dilatazione 2 copre un'area 5×5 usando gli stessi nove pesi e amplia il campo recettivo senza costi aggiuntivi.
• Gruppi: Suddivide i canali in gruppi indipendenti. Con un gruppo per canale, una convoluzione depthwise filtra ciascun canale separatamente e una successiva convoluzione pointwise 1×1 combina i canali: questa coppia, chiamata convoluzione depthwise separabile, è stata resa popolare da MobileNets per l'hardware mobile.

Per un input di dimensione n, una dimensione del kernel k, un padding p, uno stride s e una dilatazione d, la dimensione dell'output è ⌊(n + 2p − d(k − 1) − 1) / s⌋ + 1. Il frammento di codice qui sotto applica quattro livelli, ciascuno dei quali trasforma una mappa di caratteristiche a 64 canali e 80×80 in una a 128 canali:

import torch
from torch import nn

x = torch.randn(1, 64, 80, 80)  # a 64-channel, 80x80 feature map

# Four ways to map 64 input channels to 128 output channels
layers = {
    "standard 3x3": nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False),
    "stride 2": nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=False),
    "dilation 2": nn.Conv2d(64, 128, kernel_size=3, padding=2, dilation=2, bias=False),
    "depthwise separable": nn.Sequential(
        nn.Conv2d(64, 64, kernel_size=3, padding=1, groups=64, bias=False),  # one 3x3 filter per channel
        nn.Conv2d(64, 128, kernel_size=1, bias=False),  # 1x1 convolution mixes channels
    ),
}
for name, layer in layers.items():
    params = sum(p.numel() for p in layer.parameters())
    print(f"{name}: output {tuple(layer(x).shape)}, {params:,} weights")

Il livello standard produce (1, 128, 80, 80) con 73,728 pesi. Lo stride 2 dimezza l'output, portandolo a (1, 128, 40, 40), con gli stessi pesi; la dilatazione 2 mantiene la dimensione 80×80 e i 73,728 pesi, mentre ogni output vede un'area 5×5. La coppia depthwise separable produce lo stesso output (1, 128, 80, 80) usando solo 8,768 pesi, circa 8,4 volte meno. YOLO26 usa entrambe le idee: cinque convoluzioni 3×3 con stride 2 riducono un'immagine 640×640 alla griglia 20×20 della mappa di caratteristiche più profonda del backbone, mentre il ramo di classificazione della sua testa di rilevamento abbina convoluzioni depthwise 3×3 e pointwise 1×1 per ridurre i calcoli.

La convoluzione in altre dimensioni#

• Convoluzione 1D: Scorre lungo un solo asse, per forme d'onda audio, segnali dei sensori e serie temporali.
• Convoluzione 3D: Aggiunge un asse di profondità o temporale, per clip video e scansioni volumetriche come TC e RM nell'analisi delle immagini mediche.
• Convoluzione trasposta: Distribuisce ogni valore di input su un output più grande, aumentando la risoluzione delle mappe di caratteristiche nei modelli di segmentazione come U-Net. Ripristina la dimensione spaziale ridotta da una convoluzione con stride, usando pesi appresi specifici.

Convoluzione e operazioni correlate#

• Livello completamente connesso: Collega ogni input a ogni output con un peso dedicato. Una convoluzione è un livello completamente connesso limitato alle aree locali, con pesi condivisi tra le posizioni.
• Pooling: Fa scorrere una finestra come la convoluzione, ma applica una regola fissa, come prendere il valore massimo, senza pesi appresi.
• Self-attention: Calcola pesi dipendenti dai dati tra ogni coppia di posizioni, mettendo in relazione parti distanti di un'immagine in un unico livello. Una convoluzione applica ovunque lo stesso kernel fisso e vede solo una finestra locale, mantenendo così il costo lineare rispetto al numero di pixel.
• Filtraggio delle immagini: I filtri classici, come la sfocatura gaussiana e il rilevatore di bordi Sobel, sono convoluzioni con kernel fissi progettati manualmente. Anche filter2D di OpenCV calcola la correlazione, come le librerie di deep learning; ribaltando il kernel si ottiene una vera convoluzione.