01 - CNN: Reti Convoluzionali da Zero a Production

CNN: Reti Convoluzionali da Zero a Production

Come fa un computer a "vedere" un gatto in una foto? Come distingue un segnale stradale da un volto umano? La risposta sta nelle Convolutional Neural Networks (CNN), l'architettura di deep learning che ha rivoluzionato la computer vision. Dalle auto a guida autonoma alla diagnosi medica per immagini, le CNN sono il motore invisibile dietro milioni di applicazioni che usiamo ogni giorno.

In questo primo articolo della serie Computer Vision con Deep Learning, costruiremo la tua comprensione delle CNN partendo da zero: cosa sono, come funzionano i filtri convoluzionali, quali architetture hanno fatto la storia e come implementare e addestrare una CNN completa in PyTorch. Al termine avrai le competenze per classificare immagini reali e portare il modello in produzione.

1. Da Pixel a Feature: Come un Computer Vede le Immagini

Per noi umani, guardare una foto è un atto naturale. Il nostro cervello riconosce istantaneamente forme, colori, contorni e oggetti. Ma per un computer, un'immagine è solo una griglia di numeri. Ogni pixel è rappresentato da valori numerici che indicano l'intensità luminosa.

1.1 Un'Immagine come Matrice di Numeri

Un'immagine in scala di grigi è una matrice 2D dove ogni cella contiene un valore tra 0 (nero) e 255 (bianco). Un'immagine a colori è composta da tre canali (Red, Green, Blue), ciascuno una matrice separata. Un'immagine 224x224 a colori è quindi un tensore di dimensione 3 x 224 x 224, ovvero 150.528 valori numerici.

Immagine 4x4 (scala di grigi, valori 0-255):

+-----+-----+-----+-----+
|  10 |  20 |  30 |  40 |
+-----+-----+-----+-----+
|  50 | 120 | 180 |  60 |
+-----+-----+-----+-----+
|  70 | 200 | 220 |  80 |
+-----+-----+-----+-----+
|  90 | 100 | 110 | 130 |
+-----+-----+-----+-----+

Immagine a colori (3 canali RGB):
Canale R: [[10, 20, ...], ...]  --> tonalita di rosso
Canale G: [[30, 40, ...], ...]  --> tonalita di verde
Canale B: [[50, 60, ...], ...]  --> tonalita di blu

Tensore finale: shape = (3, H, W)  --> (canali, altezza, larghezza)
    

1.2 perchè le Reti Neurali Dense Non Bastano

Il primo approccio che verrebbe in mente è appiattire l'immagine in un vettore 1D e passarla a una rete neurale fully connected (densa). Per un'immagine 224x224x3, questo significherebbe un layer di input con 150.528 neuroni. Con un hidden layer da 1.000 neuroni, avresti già 150 milioni di parametri solo nel primo layer.

Le CNN risolvono tutti questi problemi sfruttando tre intuizioni fondamentali: localita (i pattern visivi sono locali), condivisione dei pesi (lo stesso filtro funziona ovunque nell'immagine) e invarianza alla traslazione (un bordo è un bordo indipendentemente da dove si trova).

2. L'Operazione di Convoluzione

La convoluzione è l'operazione matematica al cuore delle CNN. Un piccolo filtro (detto kernel) scorre sull'immagine di input, calcolando ad ogni posizione una somma pesata dei pixel coperti. Il risultato è una nuova matrice chiamata feature map, che evidenzia un pattern specifico (bordo verticale, bordo orizzontale, angolo, texture).

2.1 Kernel e Sliding Window

Un kernel è una piccola matrice di pesi (tipicamente 3x3 o 5x5) che viene fatta scorrere (slide) su tutta l'immagine di input. Ad ogni posizione, i valori del kernel vengono moltiplicati elemento per elemento con i pixel sottostanti e sommati per produrre un singolo valore nella feature map di output.

Input (5x5):                  Kernel (3x3):
+---+---+---+---+---+        +----+----+----+
| 1 | 2 | 3 | 0 | 1 |       | -1 |  0 |  1 |
+---+---+---+---+---+        +----+----+----+
| 0 | 1 | 2 | 3 | 1 |       | -1 |  0 |  1 |
+---+---+---+---+---+        +----+----+----+
| 1 | 0 | 1 | 2 | 0 |       | -1 |  0 |  1 |
+---+---+---+---+---+        +----+----+----+
| 2 | 1 | 0 | 1 | 3 |       (Filtro per bordi verticali)
+---+---+---+---+---+
| 0 | 1 | 2 | 1 | 0 |
+---+---+---+---+---+

Posizione (0,0): applica kernel ai pixel evidenziati [*]
[*1][*2][*3]  0   1
[*0][*1][*2]  3   1         Calcolo:
[*1][*0][*1]  2   0         (-1x1)+(0x2)+(1x3)+(-1x0)+(0x1)+(1x2)+(-1x1)+(0x0)+(1x1)
 2   1   0   1   3         = -1 + 0 + 3 + 0 + 0 + 2 - 1 + 0 + 1 = 4
 0   1   2   1   0

Output feature map (3x3):
+---+---+---+
| 4 | . | . |    <-- Il 4 appena calcolato
+---+---+---+
| . | . | . |    Il kernel scorre e calcola ogni cella
+---+---+---+
| . | . | . |
+---+---+---+
    

La differenza fondamentale tra le CNN e l'elaborazione tradizionale delle immagini è che nelle CNN i valori del kernel non sono fissati a mano. La rete apprende automaticamente i filtri ottimali durante il training attraverso la backpropagation. I primi layer imparano a rilevare bordi e texture semplici, mentre i layer più profondi combinano queste feature in pattern sempre più complessi (occhi, ruote, volti).

3. Componenti di una CNN

Una CNN è composta da diversi tipi di layer, ognuno con un ruolo specifico. Capire cosa fa ogni componente è fondamentale per progettare architetture efficaci.

3.1 Convolutional Layer

Il layer convoluzionale applica multipli filtri all'input, producendo una feature map per ogni filtro. Se applichi 32 filtri 3x3 a un'immagine RGB, ottieni 32 feature maps, ciascuna che evidenzia un pattern diverso. I parametri chiave sono:

Formula dimensione output:
  output_size = (input_size - kernel_size + 2 * padding) / stride + 1

Esempio: input 32x32, kernel 3x3
  Stride=1, Padding=0: (32 - 3 + 0) / 1 + 1 = 30x30  (si riduce)
  Stride=1, Padding=1: (32 - 3 + 2) / 1 + 1 = 32x32  (same padding)
  Stride=2, Padding=1: (32 - 3 + 2) / 2 + 1 = 16x16  (dimezza)

Stride=1, Padding=1 ("same"):
  Input:  [A B C D E]     Output: [A B C D E]  --> stessa dimensione
          (con zero-padding ai bordi)

Stride=2 (dimezza la risoluzione):
  Input:  [A B C D E F]   Output: [A C E]  --> meta dimensione
          (salta un pixel ad ogni passo)
    

3.2 Activation Function (ReLU)

Dopo ogni convoluzione si applica una funzione di attivazione non-lineare. La più comune è la ReLU (Rectified Linear Unit): f(x) = max(0, x). ReLU azzera tutti i valori negativi e lascia invariati quelli positivi. Senza la non-linearita, una sequenza di convoluzioni sarebbe equivalente a una singola trasformazione lineare, rendendo la rete incapace di apprendere pattern complessi.

ReLU:     f(x) = max(0, x)        Semplice, veloce, standard
LeakyReLU: f(x) = x se x>0, 0.01x altrimenti   Evita "dying ReLU"
GELU:     f(x) = x * Phi(x)      Usata nei Transformers, smooth
Swish:    f(x) = x * sigmoid(x)  Usata in EfficientNet

Input feature map:          Dopo ReLU:
+----+-----+----+           +----+----+----+
| -3 |  5  | -1 |          |  0 |  5 |  0 |
+----+-----+----+           +----+----+----+
|  2 | -7  |  4 |          |  2 |  0 |  4 |
+----+-----+----+           +----+----+----+
| -2 |  1  | -5 |          |  0 |  1 |  0 |
+----+-----+----+           +----+----+----+
    

3.3 Pooling Layer

Il pooling riduce le dimensioni spaziali delle feature maps, diminuendo il numero di parametri e rendendo la rete più robusta a piccole variazioni nella posizione delle feature. I due tipi principali sono Max Pooling (prende il valore massimo in ogni finestra) e Average Pooling (calcola la media).

Input (4x4):                    Output (2x2):
+----+----+----+----+           +----+----+
| 12 |  20|  30|  0 |          | 20 | 30 |  max(12,20,0,8)=20
+----+----+----+----+    -->   +----+----+    max(30,0,2,14)=30
|  0 |  8 |  2 | 14 |          | 15 | 16 |
+----+----+----+----+           +----+----+
| 15 |  2 |  3 | 16 |
+----+----+----+----+          Riduce 4x4 --> 2x2
|  1 |  6 |  7 |  8 |         (dimezza altezza e larghezza)
+----+----+----+----+

Max Pooling: prende il massimo --> preserva le feature più forti
Avg Pooling: calcola la media --> effetto di smoothing
Global Average Pooling: media su tutta la feature map --> un singolo valore per canale
    

3.4 Batch Normalization

La Batch Normalization (BatchNorm) normalizza l'output di ogni layer affinche abbia media zero e varianza unitaria. Questo stabilizza il training, permette learning rate più alti e funge da leggero regolarizzatore. In pratica, si inserisce un layer BatchNorm dopo ogni convoluzione, prima dell'attivazione.

4. Architettura CNN Tipica

Una CNN standard segue un pattern ricorrente: blocchi di estrazione feature (convoluzione + attivazione + pooling) seguiti da layer fully connected per la classificazione finale. Con la profondità, le feature maps diminuiscono in dimensione spaziale ma aumentano in numero di canali, catturando pattern sempre più astratti.

Input Immagine (3 x 32 x 32)
    |
    v
[Conv2d 3->32, 3x3, pad=1] --> [BatchNorm] --> [ReLU] --> [MaxPool 2x2]
    |  Feature maps: 32 x 16 x 16
    v
[Conv2d 32->64, 3x3, pad=1] --> [BatchNorm] --> [ReLU] --> [MaxPool 2x2]
    |  Feature maps: 64 x 8 x 8
    v
[Conv2d 64->128, 3x3, pad=1] --> [BatchNorm] --> [ReLU] --> [MaxPool 2x2]
    |  Feature maps: 128 x 4 x 4
    v
[Flatten]  -->  Vettore di 128 * 4 * 4 = 2048 valori
    |
    v
[Linear 2048 -> 256] --> [ReLU] --> [Dropout 0.5]
    |
    v
[Linear 256 -> 10]  --> Output: 10 classi (es. CIFAR-10)
    |
    v
[Softmax]  --> Probabilità per ogni classe: [0.02, 0.01, 0.85, ...]

Flusso delle dimensioni:
  (3, 32, 32) -> (32, 16, 16) -> (64, 8, 8) -> (128, 4, 4) -> (2048) -> (256) -> (10)
  [immagine]    [bordi, texture] [parti]       [oggetti]       [decisione]  [classe]
    

5. Evoluzione delle Architetture CNN

La storia delle CNN è segnata da architetture rivoluzionarie, ciascuna delle quali ha introdotto idee che hanno cambiato il campo. Conoscere questa evoluzione è fondamentale per capire le scelte architetturali moderne.

5.1 LeNet-5 (1998) - La Pioniera

Progettata da Yann LeCun per il riconoscimento di cifre scritte a mano (MNIST), LeNet-5 e la prima CNN ad avere successo pratico. Con soli 5 layer e 60.000 parametri, ha dimostrato che le convoluzioni potevano apprendere feature discriminanti dalle immagini. Era usata per leggere automaticamente gli assegni bancari.

5.2 AlexNet (2012) - La Rivoluzione

AlexNet ha vinto la competizione ImageNet 2012 con un margine enorme, riducendo l'errore dal 26% al 16%. Le innovazioni chiave: training su GPU (due NVIDIA GTX 580), funzione di attivazione ReLU al posto della sigmoide, Dropout per la regolarizzazione e data augmentation. Questo risultato ha convinto il mondo accademico e industriale che il deep learning funzionava.

5.3 VGGNet (2014) - La Profondità Conta

VGG ha dimostrato che reti più profonde producono risultati migliori. La sua idea chiave e radicale nella semplicità: usare solo filtri 3x3 impilati. Due layer 3x3 consecutivi hanno lo stesso campo recettivo di un singolo layer 5x5, ma con meno parametri e più non-linearita. VGG-16 ha 16 layer e 138 milioni di parametri.

5.4 EfficientNet (2019) - Scaling Intelligente

EfficientNet ha introdotto il compound scaling: invece di aumentare solo la profondità (come VGG) o la larghezza, scala uniformemente tutte e tre le dimensioni (profondità, larghezza, risoluzione dell'input) con coefficienti bilanciati. EfficientNet-B0 raggiunge il 77.1% di accuracy su ImageNet con soli 5.3 milioni di parametri, un rapporto accuracy-parametri senza precedenti.

5.5 ConvNeXt (2022) - La CNN Modernizzata

ConvNeXt dimostra che le CNN, modernizzate con tecniche ispirate ai Vision Transformers, possono competere con (e superare) le architetture transformer. Le innovazioni includono: kernel 7x7 depthwise separabili, LayerNorm al posto di BatchNorm, attivazione GELU, e un design "isomorphic" con stadi di dimensioni crescenti. ConvNeXt V2, nella versione E-ConvNeXt-Tiny, raggiunge l'80.6% Top-1 con soli 2.0 GFLOPs, eccellente per deployment efficiente.

6. ResNet e Skip Connections

ResNet (Residual Networks), proposta da He et al. nel 2015, ha risolto uno dei problemi fondamentali del deep learning: il degradation problem. Prima di ResNet, aggiungere layer a una rete profonda peggiorava i risultati anziche migliorarli, anche sul training set. La soluzione è tanto elegante quanto semplice.

6.1 Il Problema del Vanishing Gradient

Durante la backpropagation, i gradienti vengono moltiplicati ripetutamente attraverso i layer della rete. Se queste moltiplicazioni producono valori minori di 1, i gradienti "svaniscono" esponenzialmente man mano che si propagano verso i layer iniziali. Con 50 o più layer, i gradienti diventano cosi piccoli che i primi layer smettono di apprendere. Studi recenti confermano che senza skip connections, le norme L2 dei gradienti calano drasticamente nei layer iniziali, mentre con le skip connections rimangono uniformi lungo tutta la rete.

Rete profonda SENZA skip connections (50 layer):

  Layer 50   Layer 49   Layer 48  ...  Layer 2    Layer 1
  grad=1.0 * 0.8      * 0.8     ...  * 0.8      * 0.8

  Gradiente al layer 1: 0.8^49 = 0.00001  --> quasi zero!
  I primi layer NON apprendono.

Rete profonda CON skip connections (ResNet):

  Il gradiente ha un "percorso diretto" attraverso le skip connections.
  Non viene moltiplicato ripetutamente per valori piccoli.
  Gradiente al layer 1: ~0.5  --> i layer apprendono normalmente!
    

6.2 La Soluzione: Residual Learning

L'idea geniale di ResNet e semplice: invece di far apprendere a un blocco la trasformazione completa H(x), gli fai apprendere solo la differenza (residuo) rispetto all'input: F(x) = H(x) - x. L'output del blocco diventa y = F(x) + x, dove x è l'input che "salta" il blocco tramite una skip connection (o shortcut connection).

Blocco Standard:                    Residual Block:

    x                                   x ------+
    |                                   |        |
    v                                   v        | (skip connection)
  [Conv 3x3]                         [Conv 3x3] |
    |                                   |        |
  [BatchNorm]                        [BatchNorm] |
    |                                   |        |
  [ReLU]                             [ReLU]      |
    |                                   |        |
  [Conv 3x3]                         [Conv 3x3] |
    |                                   |        |
  [BatchNorm]                        [BatchNorm] |
    |                                   |        |
    v                                   v        |
  H(x) = output                     F(x) + x <--+
                                        |
                                      [ReLU]
                                        |
                                        v
                                      output

Se F(x) = 0, l'output è semplicemente x (identità).
La rete può "saltare" un blocco se non serve.
Questo rende il training di reti profonde stabile.
    

7. Training di una CNN

Addestrare una CNN significa trovare i valori ottimali per tutti i kernel (filtri) e i pesi dei layer fully connected. Questo avviene attraverso un processo iterativo di forward pass, calcolo della loss e backpropagation dei gradienti.

7.1 Loss Function

Per la classificazione di immagini, la loss function standard è la Cross-Entropy Loss. Misura quanto le probabilità predette dalla rete si discostano dalle etichette reali. Una predizione perfetta produce loss = 0; una predizione completamente sbagliata produce loss tendente a infinito.

Etichetta reale (one-hot): [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]  (classe "gatto" = indice 2)

Predizione buona:          [0.02, 0.03, 0.85, 0.02, 0.01, 0.02, 0.01, 0.02, 0.01, 0.01]
  Loss = -log(0.85) = 0.16    --> Loss bassa, predizione corretta

Predizione cattiva:        [0.30, 0.25, 0.05, 0.10, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05]
  Loss = -log(0.05) = 3.00    --> Loss alta, predizione sbagliata
    

7.2 Optimizer

L'optimizer aggiorna i pesi della rete nella direzione che riduce la loss. I più usati sono:

7.3 Data Augmentation

La data augmentation è una tecnica fondamentale per prevenire l'overfitting e migliorare la generalizzazione della rete. Consiste nell'applicare trasformazioni casuali alle immagini di training (rotazioni, flip, crop, cambi di luminosita) per creare variazioni sintetiche senza raccogliere nuovi dati.

Immagine Originale:     Trasformazioni:

  +-------+             [Flip orizzontale]    --> Immagine specchiata
  | Gatto |             [Rotazione +-15 gradi]--> Leggera rotazione
  | --o-- |             [Random Crop]         --> Ritaglio casuale
  |  /|\  |             [Color Jitter]        --> Variazione colori
  +-------+             [Gaussian Noise]      --> Aggiunta rumore
                        [Cutout/Erasing]      --> Maschera rettangolare casuale
                        [MixUp]               --> Media pesata di 2 immagini
                        [CutMix]              --> Porzione di un'immagine sovrapposta

Effetto: da 50.000 immagini di training, ogni epoca vede variazioni
diverse, come se avessi milioni di immagini uniche.
    

8. Implementazione Completa in PyTorch

Passiamo dalla teoria alla pratica. Implementeremo una CNN completa per classificare le immagini del dataset CIFAR-10 (60.000 immagini 32x32 in 10 classi: aeroplano, automobile, uccello, gatto, cervo, cane, rana, cavallo, nave, camion).

8.1 Setup e Dataset

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

# Trasformazioni con data augmentation per il training
train_transform = transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomCrop(32, padding=4),
    transforms.ColorJitter(brightness=0.2, contrast=0.2),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.4914, 0.4822, 0.4465],   # Media CIFAR-10
        std=[0.2470, 0.2435, 0.2616]     # Std CIFAR-10
    ),
])

# Trasformazioni per il test (nessuna augmentation)
test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.4914, 0.4822, 0.4465],
        std=[0.2470, 0.2435, 0.2616]
    ),
])

# Caricamento dataset
train_dataset = torchvision.datasets.CIFAR10(
    root='./data', train=True, download=True, transform=train_transform
)
test_dataset = torchvision.datasets.CIFAR10(
    root='./data', train=False, download=True, transform=test_transform
)

# DataLoader con batching e shuffling
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=4)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=4)

CLASSES = ['aereo', 'auto', 'uccello', 'gatto', 'cervo',
           'cane', 'rana', 'cavallo', 'nave', 'camion']
    

8.2 Definizione del Modello

class ResidualBlock(nn.Module):
    """Blocco residuale con skip connection."""

    def __init__(self, in_channels: int, out_channels: int, stride: int = 1):
        super().__init__()
        self.conv1 = nn.Conv2d(
            in_channels, out_channels, kernel_size=3,
            stride=stride, padding=1, bias=False
        )
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.conv2 = nn.Conv2d(
            out_channels, out_channels, kernel_size=3,
            stride=1, padding=1, bias=False
        )
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

        # Skip connection: se le dimensioni cambiano, usa conv 1x1
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1,
                          stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        identity = self.shortcut(x)

        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out = out + identity   # Skip connection
        out = self.relu(out)

        return out


class CIFAR10CNN(nn.Module):
    """CNN con blocchi residuali per classificazione CIFAR-10."""

    def __init__(self, num_classes: int = 10):
        super().__init__()
        # Primo layer convoluzionale
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(32)
        self.relu = nn.ReLU(inplace=True)

        # Blocchi residuali con profondità crescente
        self.layer1 = self._make_layer(32, 64, num_blocks=2, stride=1)
        self.layer2 = self._make_layer(64, 128, num_blocks=2, stride=2)
        self.layer3 = self._make_layer(128, 256, num_blocks=2, stride=2)

        # Classificatore finale
        self.global_avg_pool = nn.AdaptiveAvgPool2d((1, 1))
        self.dropout = nn.Dropout(0.3)
        self.fc = nn.Linear(256, num_classes)

    def _make_layer(
        self, in_ch: int, out_ch: int, num_blocks: int, stride: int
    ) -> nn.Sequential:
        layers = [ResidualBlock(in_ch, out_ch, stride)]
        for _ in range(1, num_blocks):
            layers.append(ResidualBlock(out_ch, out_ch, stride=1))
        return nn.Sequential(*layers)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.relu(self.bn1(self.conv1(x)))   # (B, 32, 32, 32)
        x = self.layer1(x)                        # (B, 64, 32, 32)
        x = self.layer2(x)                        # (B, 128, 16, 16)
        x = self.layer3(x)                        # (B, 256, 8, 8)
        x = self.global_avg_pool(x)               # (B, 256, 1, 1)
        x = x.view(x.size(0), -1)                 # (B, 256)
        x = self.dropout(x)
        x = self.fc(x)                            # (B, 10)
        return x
    

8.3 Training Loop

def train_model(
    model: nn.Module,
    train_loader: DataLoader,
    test_loader: DataLoader,
    epochs: int = 50,
    lr: float = 0.01
) -> dict:
    """Addestra il modello e restituisce la storia del training."""

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model = model.to(device)

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(
        model.parameters(), lr=lr, momentum=0.9, weight_decay=1e-4
    )
    scheduler = optim.lr_scheduler.OneCycleLR(
        optimizer, max_lr=lr, epochs=epochs,
        steps_per_epoch=len(train_loader)
    )

    history = {'train_loss': [], 'test_loss': [], 'test_acc': []}

    for epoch in range(epochs):
        # --- Training ---
        model.train()
        running_loss = 0.0

        for images, labels in train_loader:
            images, labels = images.to(device), labels.to(device)

            optimizer.zero_grad()
            outputs = model(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            scheduler.step()

            running_loss += loss.item()

        avg_train_loss = running_loss / len(train_loader)

        # --- Evaluation ---
        model.eval()
        test_loss = 0.0
        correct = 0
        total = 0

        with torch.no_grad():
            for images, labels in test_loader:
                images, labels = images.to(device), labels.to(device)
                outputs = model(images)
                loss = criterion(outputs, labels)
                test_loss += loss.item()
                _, predicted = outputs.max(1)
                total += labels.size(0)
                correct += predicted.eq(labels).sum().item()

        avg_test_loss = test_loss / len(test_loader)
        accuracy = 100.0 * correct / total

        history['train_loss'].append(avg_train_loss)
        history['test_loss'].append(avg_test_loss)
        history['test_acc'].append(accuracy)

        print(
            f"Epoch [{epoch+1}/{epochs}] "
            f"Train Loss: {avg_train_loss:.4f} | "
            f"Test Loss: {avg_test_loss:.4f} | "
            f"Accuracy: {accuracy:.2f}%"
        )

    return history


# Esecuzione
model = CIFAR10CNN(num_classes=10)
history = train_model(model, train_loader, test_loader, epochs=50, lr=0.1)

# Output atteso dopo 50 epoche con OneCycleLR:
# Test Accuracy: ~92-93%
    

9. Transfer Learning

Nella pratica, raramente si addestra una CNN da zero. Il transfer learning permette di riutilizzare modelli pre-addestrati su grandi dataset (come ImageNet con 1.2 milioni di immagini e 1.000 classi) e adattarli al proprio problema specifico. Questo riduce drasticamente i tempi di training, la quantità di dati necessaria e migliora le prestazioni.

9.1 Feature Extraction vs Fine-Tuning

import torchvision.models as models

def create_transfer_model(
    num_classes: int,
    freeze_backbone: bool = True
) -> nn.Module:
    """Crea un modello con transfer learning da ResNet-18."""

    # Carica ResNet-18 pre-addestrato su ImageNet
    model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)

    # Strategia 1: Feature Extraction (congela il backbone)
    if freeze_backbone:
        for param in model.parameters():
            param.requires_grad = False

    # Sostituisci il classificatore finale
    num_features = model.fc.in_features  # 512 per ResNet-18
    model.fc = nn.Sequential(
        nn.Dropout(0.3),
        nn.Linear(num_features, 256),
        nn.ReLU(),
        nn.Dropout(0.2),
        nn.Linear(256, num_classes)
    )

    return model


# Feature extraction: solo il classificatore viene addestrato
feature_model = create_transfer_model(num_classes=10, freeze_backbone=True)

# Fine-tuning: tutto il modello viene riaddestrato
finetune_model = create_transfer_model(num_classes=10, freeze_backbone=False)

# Per il fine-tuning, usa un learning rate più basso
optimizer = optim.AdamW([
    {'params': finetune_model.layer4.parameters(), 'lr': 1e-4},
    {'params': finetune_model.fc.parameters(), 'lr': 1e-3},
], weight_decay=1e-2)
    

Guida al Transfer Learning:

                     Dati simili a ImageNet     Dati diversi da ImageNet
                     (oggetti, animali, scene)  (medico, satellite, micro)
                  +---------------------------+---------------------------+
  Pochi dati      | Feature Extraction         | Feature Extraction        |
  (<1.000 img)   | Congela tutto, addestra FC | + Aumenta data augment.   |
                  +---------------------------+---------------------------+
  Molti dati      | Fine-tuning ultimi layer   | Fine-tuning completo      |
  (>5.000 img)    | LR basso per il backbone   | o training da zero        |
                  +---------------------------+---------------------------+
    

10. Metriche di Valutazione

L'accuracy da sola non basta per capire se una CNN funziona bene. Con dataset sbilanciati (es. 95% classe A, 5% classe B), un modello che predice sempre "classe A" ha 95% di accuracy ma è completamente inutile. Servono metriche più granulari.

Confusion Matrix (predizioni vs realta):

              Predetto:  aereo  auto  uccel  gatto  cervo  cane  rana  caval  nave  camion
  Reale:
  aereo                  [92]    1     2      0      0      0     1     0     3      1
  auto                    0    [95]    0      0      0      0     0     0     1      4
  uccello                 3      0   [85]     3      2      2     3     1     1      0
  gatto                   0      1     2    [78]     1      12    3     2     0      1
  cervo                   1      0     3      2    [88]     1     2     3     0      0

Interpretazione:
- Diagonale = predizioni corrette (più alto = meglio)
- Fuori diagonale = errori (confusioni tra classi)
- gatto vs cane: 12 gatti classificati come cani --> classi "confuse"
    

from sklearn.metrics import (
    classification_report,
    confusion_matrix
)
import numpy as np


def evaluate_model(
    model: nn.Module,
    test_loader: DataLoader,
    device: torch.device,
    class_names: list[str]
) -> dict:
    """Valuta il modello e restituisce metriche dettagliate."""

    model.eval()
    all_preds = []
    all_labels = []

    with torch.no_grad():
        for images, labels in test_loader:
            images = images.to(device)
            outputs = model(images)
            _, predicted = outputs.max(1)
            all_preds.extend(predicted.cpu().numpy())
            all_labels.extend(labels.numpy())

    preds_array = np.array(all_preds)
    labels_array = np.array(all_labels)

    # Report dettagliato per classe
    report = classification_report(
        labels_array, preds_array,
        target_names=class_names, output_dict=True
    )

    # Confusion matrix
    cm = confusion_matrix(labels_array, preds_array)

    # Accuracy globale
    accuracy = np.mean(preds_array == labels_array) * 100

    print(f"Accuracy globale: {accuracy:.2f}%")
    print(classification_report(
        labels_array, preds_array, target_names=class_names
    ))

    return {'accuracy': accuracy, 'report': report, 'confusion_matrix': cm}
    

11. Deployment: Da Modello Addestrato a Produzione

Addestrare un modello è solo metà del lavoro. Per portarlo in produzione devi esportarlo in un formato ottimizzato, creare un'API di inference e containerizzare il tutto per il deployment scalabile.

11.1 Esportazione del Modello

import torch.onnx

def export_model(model: nn.Module, export_path: str) -> None:
    """Esporta il modello in TorchScript e ONNX."""

    model.eval()
    dummy_input = torch.randn(1, 3, 32, 32)

    # --- TorchScript ---
    scripted_model = torch.jit.trace(model, dummy_input)
    scripted_model.save(f"{export_path}/model_scripted.pt")
    print("TorchScript salvato.")

    # --- ONNX ---
    torch.onnx.export(
        model,
        dummy_input,
        f"{export_path}/model.onnx",
        input_names=['image'],
        output_names=['prediction'],
        dynamic_axes={
            'image': {0: 'batch_size'},
            'prediction': {0: 'batch_size'}
        },
        opset_version=17
    )
    print("ONNX salvato.")


export_model(model, './exports')
    

11.2 API di Inference con FastAPI

# inference_api.py
from fastapi import FastAPI, UploadFile
from PIL import Image
import torch
import torchvision.transforms as transforms
import io

app = FastAPI(title="CNN Image Classifier")

# Carica il modello TorchScript
model = torch.jit.load("./exports/model_scripted.pt")
model.eval()

CLASSES = ['aereo', 'auto', 'uccello', 'gatto', 'cervo',
           'cane', 'rana', 'cavallo', 'nave', 'camion']

preprocess = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.4914, 0.4822, 0.4465],
        std=[0.2470, 0.2435, 0.2616]
    ),
])


@app.post("/predict")
async def predict(file: UploadFile):
    """Classifica un'immagine caricata."""
    image_bytes = await file.read()
    image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
    tensor = preprocess(image).unsqueeze(0)

    with torch.no_grad():
        outputs = model(tensor)
        probabilities = torch.softmax(outputs, dim=1)
        confidence, predicted = probabilities.max(1)

    return {
        "class": CLASSES[predicted.item()],
        "confidence": round(confidence.item() * 100, 2),
        "all_probabilities": {
            name: round(prob.item() * 100, 2)
            for name, prob in zip(CLASSES, probabilities[0])
        }
    }

# Esecuzione: uvicorn inference_api:app --host 0.0.0.0 --port 8000
    

11.3 Containerizzazione con Docker

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY exports/ ./exports/
COPY inference_api.py .

EXPOSE 8000

CMD ["uvicorn", "inference_api:app", "--host", "0.0.0.0", "--port", "8000"]

# Build: docker build -t cnn-classifier .
# Run:   docker run -p 8000:8000 cnn-classifier
# Test:  curl -X POST -F "file=@cat.jpg" http://localhost:8000/predict
    

Pipeline: Training --> Export --> Container --> Deploy

  [Training]          [Export]           [Container]        [Deploy]
  PyTorch + GPU  -->  TorchScript/ONNX  -->  Docker     -->  Kubernetes
  50 epoche          ~10 MB file            FastAPI          Auto-scaling
  ~92% accuracy      Ottimizzato             Health checks   Load balancer
                     No dipendenza Python    GPU opzionale   Monitoring

Alternativa serverless:
  Export ONNX --> AWS Lambda + ONNX Runtime --> API Gateway
  Pro: Pay-per-use, zero infrastruttura da gestire
  Contro: Cold start (~2s), limite 250MB package
    

Conclusioni e Prossimi Passi

In questo articolo abbiamo costruito una comprensione completa delle Convolutional Neural Networks, partendo dai fondamenti (come un computer vede le immagini, l'operazione di convoluzione) fino all'implementazione pratica (CNN con residual blocks in PyTorch) e al deployment in produzione (TorchScript, ONNX, FastAPI, Docker).

Abbiamo visto come l'evoluzione delle architetture, da LeNet-5 nel 1998 a ConvNeXt nel 2022, abbia progressivamente migliorato le performance grazie a idee come le skip connections (ResNet), il compound scaling (EfficientNet) e il design ispirato ai transformer (ConvNeXt).

Nel prossimo articolo della serie approfondiremo il Transfer Learning e il Fine-Tuning: come scegliere il modello pre-addestrato giusto, le strategie di fine-tuning progressivo, il domain adaptation e tecniche avanzate come il knowledge distillation. Nel terzo articolo affronteremo la Object Detection con YOLO, il sistema di rilevamento oggetti in tempo reale più utilizzato nell'industria.