Tutorial CNN con PyTorch: crea e addestra reti neurali convoluzionali in Python

Le Convolutional Neural Networks (CNN) sono un pilastro della computer vision moderna e abilitano applicazioni come il riconoscimento di immagini, il rilevamento facciale e le auto a guida autonoma. Queste reti sono progettate per estrarre automaticamente pattern e caratteristiche dalle immagini, risultando più potenti delle tecniche tradizionali di machine learning per i compiti visivi.

In questo tutorial implementeremo una CNN usando PyTorch, un framework di deep learning intuitivo e altamente efficiente sia per la ricerca sia per la produzione.

Prerequisiti: Deep Learning e PyTorch

Prima di entrare nei dettagli delle CNN, dovresti avere familiarità con il deep learning e con le librerie Python che useremo durante la configurazione dell'ambiente.

Il deep learning è un sottoinsieme del machine learning, in cui il modello di base è una rete di input, strati nascosti e output. Una rete può avere uno o molti strati nascosti. L'intuizione originaria dietro il deep learning era creare modelli ispirati a come il cervello umano apprende: tramite cellule interconnesse chiamate neuroni. Per questo continuiamo a chiamare i modelli di deep learning "reti neurali". Queste strutture a strati richiedono molti più dati rispetto ad altri modelli di apprendimento supervisionato per ricavare pattern dai dati non strutturati. In genere si parla di almeno centinaia di migliaia di punti dati.

Esistono diversi framework e pacchetti per implementare algoritmi di deep learning, ma qui ci concentreremo su PyTorch, uno dei framework più popolari e ben mantenuti. Oltre a essere usato dagli ingegneri in ambito industriale, PyTorch è lo strumento preferito anche dai ricercatori. Molti articoli di deep learning vengono pubblicati utilizzando PyTorch. È progettato per essere intuitivo e facile da usare, con molti punti in comune con la libreria Python NumPy. 

Se ti serve un ripasso di questi concetti, valuta di iscriverti oggi stesso al corso Deep Learning with PyTorch. 

Che cos'è una Convolutional Neural Network (CNN)?

Le reti neurali convoluzionali, comunemente chiamate CNN o ConvNet, sono un tipo specifico di rete neurale profonda particolarmente adatto ai compiti di computer vision. L'invenzione delle CNN risale agli anni ’80. Tuttavia, sono diventate mainstream solo negli anni 2010, a seguito dei progressi computazionali resi possibili dalle unità di elaborazione grafica (GPU). La rapida diffusione delle CNN ha contribuito a riportare in auge il campo delle reti neurali, dando vita alla cosiddetta "terza ondata delle reti neurali" in cui ci troviamo tuttora.

Le CNN sono specificamente ispirate alla corteccia visiva biologica. La corteccia ha piccole regioni di cellule sensibili ad aree specifiche del campo visivo. Questa idea è stata approfondita da un affascinante esperimento di Hubel e Wiesel nel 1962. 

Le CNN cercano di replicare questa caratteristica creando reti neurali complesse composte da strati diversi e specifici per il compito. Le CNN sono dette "feed-forward" perché l'informazione fluisce direttamente attraverso il modello. Non ci sono connessioni di feedback in cui gli output del modello vengono reintrodotti in esso, a differenza di altri modelli che usano tecniche come la retropropagazione.

In particolare, una CNN tipicamente è composta dai seguenti strati:

Strato convoluzionale

È il primo mattone di una CNN. Come suggerisce il nome, l'operazione matematica principale è la convoluzione, cioè l'applicazione di una finestra scorrevole a una matrice di pixel che rappresenta un'immagine. La funzione scorrevole applicata alla matrice si chiama kernel o filtro. Nello strato di convoluzione si applicano diversi filtri di uguale dimensione, e ciascun filtro è usato per riconoscere uno specifico pattern dall'immagine, come la curvatura delle cifre, i bordi, l'intera forma delle cifre e altro. 

Funzione di attivazione

Di norma, dopo ogni operazione di convoluzione si applica una funzione di attivazione ReLU. Questa funzione aiuta la rete a imparare relazioni non lineari tra le caratteristiche dell'immagine, rendendola più robusta nell'identificazione di pattern diversi. Contribuisce anche a mitigare il problema del gradiente che svanisce. 

Strato di pooling

L'obiettivo dello strato di pooling è estrarre le caratteristiche più significative dalla matrice convoluta. Ciò avviene applicando operazioni di aggregazione che riducono la dimensione della mappa delle caratteristiche (matrice convoluta), diminuendo così la memoria usata durante l'addestramento della rete.  Il pooling è importante anche per mitigare l'overfitting.

Strati completamente connessi

Questi strati si trovano in coda alla rete neurale convoluzionale, e i loro input corrispondono alla matrice monodimensionale appiattita generata dall'ultimo strato di pooling. Su di essi si applicano funzioni di attivazione ReLU per introdurre non linearità. 

Architettura di una rete neurale convoluzionale. Fonte: DataCamp

Puoi leggere una spiegazione più dettagliata della matematica dietro le CNN nel nostro tutorial Convolutional Neural Networks in Python.

Perché usare le CNN per la classificazione di immagini?

Le reti neurali convoluzionali sono state una delle innovazioni più influenti nel campo della computer vision. Hanno performato molto meglio dei modelli tradizionali di machine learning, come gli SVM e gli alberi decisionali, producendo risultati allo stato dell'arte. 

Inoltre, gli strati convoluzionali conferiscono alle CNN caratteristiche di invarianza alla traslazione, permettendo loro di identificare ed estrarre pattern e caratteristiche dai dati a prescindere da variazioni di posizione, orientamento, scala o traslazione.


Le CNN hanno avuto successo in molti casi d'uso e applicazioni reali, come:

• Classificazione di immagini, rilevamento di oggetti, segmentazione, riconoscimento facciale;
• Auto a guida autonoma che sfruttano sistemi di visione basati su CNN;
• Classificazione della struttura cristallina usando una rete neurale convoluzionale;
• Sistemi di telecamere di sicurezza.

Oltre ai compiti di classificazione di immagini, le CNN sono versatili e possono essere applicate a molti altri ambiti, come l'elaborazione del linguaggio naturale, l'analisi di serie temporali e il riconoscimento vocale.

Implementare una CNN con PyTorch

Ora che conosci la teoria delle CNN, è il momento di sporcarci le mani. In questa sezione costruiremo e alleneremo una semplice CNN con PyTorch. Il nostro obiettivo è creare un modello per classificare le cifre nelle immagini. Per addestrare e testare il modello useremo il famoso dataset MNIST, una raccolta di 70.000 immagini in scala di grigi 28x28 di cifre scritte a mano.

1. Importare le librerie necessarie

Qui sotto trovi le librerie che useremo in questo tutorial. In sostanza, sfrutteremo PyTorch per costruire la nostra CNN e il modulo di computer vision di PyTorch, torchvision, per scaricare e caricare il dataset MNIST. Infine, useremo anche torchmetrics per valutare le prestazioni del nostro modello.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


import torch
from torch import optim
from torch import nn
from torch.utils.data import DataLoader
from tqdm import tqdm

# !pip install torchvision
import torchvision

import torch.nn.functional as F
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# !pip install torchmetrics
import torchmetrics

2. Caricare e pre-processare il dataset

PyTorch include anche un ricco ecosistema di strumenti ed estensioni, tra cui torchvision, un modulo per la computer vision. Torchvision include diversi dataset di immagini che possono essere usati per addestrare e testare reti neurali. Nel nostro tutorial useremo il dataset MNIST. 

Per prima cosa scaricheremo e convertiremo il dataset MNIST in un tensore, la struttura dati centrale in PyTorch, simile agli array NumPy ma con supporto per l'accelerazione su GPU.

Poi useremo anche DataLoader per gestire batching e shuffling sia dei dataset di train sia di test. Un DataLoader di PyTorch può essere creato a partire da un Dataset per caricare i dati, suddividerli in batch ed eventualmente effettuare trasformazioni. Quindi fornisce un campione di dati pronto per l'addestramento. Nel codice seguente, carichiamo i dati e li salviamo in DataLoader con una dimensione di batch di 60 immagini:

batch_size = 60

train_dataset = datasets.MNIST(root="dataset/", download=True, train=True, transform=transforms.ToTensor())

train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)

test_dataset = datasets.MNIST(root="dataset/", download=True, train=False, transform=transforms.ToTensor())

test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)

Facoltativamente, il dataset di train potrebbe essere ulteriormente suddiviso in due partizioni di train e validation. La validation è una tecnica usata nel deep learning per valutare le prestazioni del modello durante l'addestramento. Aiuta a rilevare potenziale overfitting e underfitting dei nostri modelli, ed è particolarmente utile per ottimizzare gli iperparametri. Tuttavia, per semplicità, non useremo la validation in questo tutorial. Se vuoi saperne di più, trovi una spiegazione completa nel nostro corso Introduction to Deep Learning with PyTorch.

Ora che abbiamo i nostri dati, vediamo come appare un batch casuale di cifre:

def imshow(img):
   npimg = img.numpy()
   plt.imshow(np.transpose(npimg, (1, 2, 0)))
   plt.show()

# get some random training images
dataiter = iter(dataloader_train)
images, labels = next(dataiter)
labels
# show images
imshow(torchvision.utils.make_grid(images))

3. Definire l'architettura della CNN

Per risolvere il problema di classificazione, useremo la classe nn.Module, il mattoncino di PyTorch per creare in modo intuitivo architetture di reti neurali sofisticate. 

Nel codice seguente, creiamo una classe chiamata CNN, che eredita le proprietà della classe nn.Module. La classe CNN sarà il blueprint di una CNN con due strati convoluzionali, seguiti da uno strato completamente connesso. 

In PyTorch, usiamo nn.Conv2d per definire uno strato convoluzionale. Gli passiamo il numero di mappe di caratteristiche in input e in output. Impostiamo anche alcuni parametri necessari allo strato di convoluzione, tra cui la dimensione del kernel o filtro e il padding. 

Successivamente, aggiungiamo uno strato di max pooling con nn.MaxPool2d. In esso facciamo scorrere una finestra non sovrapposta sull'output dello strato convoluzionale precedente. In ogni posizione selezioniamo il valore massimo della finestra da far proseguire. Questa operazione riduce le dimensioni spaziali delle mappe di caratteristiche, diminuendo il numero di parametri e la complessità computazionale della rete. Infine, aggiungiamo uno strato lineare completamente connesso. 

La funzione forward() definisce come sono connessi i vari strati, aggiungendo diverse funzioni di attivazione ReLU dopo ogni strato convoluzionale.

class CNN(nn.Module):
   def __init__(self, in_channels, num_classes):

       """
       Building blocks of convolutional neural network.

       Parameters:
           * in_channels: Number of channels in the input image (for grayscale images, 1)
           * num_classes: Number of classes to predict. In our problem, 10 (i.e digits from  0 to 9).
       """
       super(CNN, self).__init__()

       # 1st convolutional layer
       self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=8, kernel_size=3, padding=1)
       # Max pooling layer
       self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
       # 2nd convolutional layer
       self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, padding=1)
       # Fully connected layer
       self.fc1 = nn.Linear(16 * 7 * 7, num_classes)

   def forward(self, x):
       """
       Define the forward pass of the neural network.

       Parameters:
           x: Input tensor.

       Returns:
           torch.Tensor
               The output tensor after passing through the network.
       """
       x = F.relu(self.conv1(x))  # Apply first convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = F.relu(self.conv2(x))  # Apply second convolution and ReLU activation
       x = self.pool(x)           # Apply max pooling
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x
       x = x.reshape(x.shape[0], -1)  # Flatten the tensor
       x = self.fc1(x)            # Apply fully connected layer
       return x

Una volta definita la classe CNN, possiamo creare il nostro modello e spostarlo sul dispositivo su cui verrà addestrato ed eseguito. 

Le reti neurali, incluse le CNN, mostrano prestazioni migliori quando girano su GPU, ma potrebbe non essere il caso del tuo computer. Pertanto, eseguiremo il modello su GPU solo quando disponibile; in caso contrario useremo una CPU normale.

device = "cuda" if torch.cuda.is_available() else "cpu"

model = CNN(in_channels=1, num_classes=10).to(device)
print(model)
>>> CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

4. Addestrare il modello CNN

Ora che abbiamo il nostro modello, è il momento di addestrarlo. Per farlo, dobbiamo innanzitutto stabilire come misureremo le prestazioni del modello. Poiché affrontiamo un problema di classificazione multiclasse, useremo la funzione di perdita cross-entropy, disponibile in PyTorch come nn.CrossEntropyLoss. Useremo anche l'ottimizzatore Adam, uno degli algoritmi di ottimizzazione più popolari. 

# Define the loss function
criterion = nn.CrossEntropyLoss()

# Define the optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001)

Itereremo su dieci epoche e sui batch di addestramento per istruire il modello ed eseguire la consueta sequenza di passaggi per ogni batch, come mostrato sotto.

num_epochs=10
for epoch in range(num_epochs):
 # Iterate over training batches
   print(f"Epoch [{epoch + 1}/{num_epochs}]")

   for batch_index, (data, targets) in enumerate(tqdm(dataloader_train)):
       data = data.to(device)
       targets = targets.to(device)
       scores = model(data)
       loss = criterion(scores, targets)
       optimizer.zero_grad()
       loss.backward()
       optimizer.step()

Epoch [1/10]
100%|██████████| 1000/1000 [00:13<00:00, 72.94it/s]
Epoch [2/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.27it/s]
Epoch [3/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.16it/s]
Epoch [4/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.00it/s]
Epoch [5/10]
100%|██████████| 1000/1000 [00:13<00:00, 75.69it/s]
Epoch [6/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.24it/s]
Epoch [7/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.23it/s]
Epoch [8/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.16it/s]
Epoch [9/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.96it/s]
Epoch [10/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.93it/s]

5. Valutare il modello

Una volta addestrato, possiamo valutare le prestazioni del modello sul dataset di test. Useremo l'accuracy, una metrica popolare per i problemi di classificazione. L'accuracy misura la proporzione di casi classificati correttamente sul numero totale di oggetti nel dataset. Si calcola dividendo il numero di predizioni corrette per il numero totale di predizioni effettuate dal modello. 

Per prima cosa, impostiamo la metrica di accuratezza da torchmetrics. Quindi usiamo il metodo .eval del modello per metterlo in modalità valutazione, perché alcuni strati nei modelli PyTorch si comportano diversamente in addestramento rispetto al test. Aggiungiamo anche un contesto Python con torch.no_grad, indicando che non effettueremo il calcolo dei gradienti.

Poi iteriamo sugli esempi di test senza calcolare i gradienti. Per ogni batch di test, otteniamo gli output del modello, prendiamo la classe più probabile e la passiamo alla funzione di accuratezza assieme alle etichette. Infine, calcoliamo le metriche e stampiamo i risultati. Abbiamo ottenuto un'accuracy di 0,98, il che significa che il nostro modello ha classificato correttamente il 98% delle cifre. Niente male!

# Set up of multiclass accuracy metric
acc = Accuracy(task="multiclass",num_classes=10)

# Iterate over the dataset batches
model.eval()
with torch.no_grad():
   for images, labels in dataloader_test:
       # Get predicted probabilities for test data batch
       outputs = model(images)
       _, preds = torch.max(outputs, 1)
       acc(preds, labels)
       precision(preds, labels)
       recall(preds, labels)

#Compute total test accuracy
test_accuracy = acc.compute()
print(f"Test accuracy: {test_accuracy}")

>>> Test accuracy: 0.9857000112533569

Potresti anche usare altre metriche di classificazione popolari, tra cui recall e precision. Te le raccontiamo con esempi pratici nel nostro corso Intermediate Deep Learning with PyTorch.

Migliorare le prestazioni del modello

Sebbene il nostro modello CNN raggiunga buone prestazioni, esistono diverse strategie per migliorarne ulteriormente accuratezza, robustezza e capacità di generalizzazione su nuovi dati. 

In questa sezione esploreremo tecniche chiave come data augmentation, ottimizzazione degli iperparametri e transfer learning per ottimizzare le prestazioni del modello.

Tecniche di data augmentation

La data augmentation è una tecnica usata per migliorare l'accuratezza del modello creando in modo casuale nuovi dati di addestramento. Ad esempio, durante il caricamento si possono applicare trasformazioni alle immagini di training, come ridimensionamento, flip orizzontale o verticale, rotazioni casuali e così via. In questo modo si creano immagini aumentate e si assegnano loro la stessa etichetta dell'immagine originale, aumentando così la dimensione del set di addestramento.

Aggiungere trasformazioni casuali alle immagini originali ci consente di generare più dati aumentando dimensione e diversità del set di training. Rende il modello più robusto alle variazioni e distorsioni comuni nelle immagini del mondo reale e riduce l'overfitting, poiché il modello impara a ignorare le trasformazioni casuali. 

Tuttavia, è importante usare cautela con la data augmentation, perché a volte può danneggiare il processo di addestramento. Ad esempio, nel nostro problema, se applichiamo il flip verticale al numero "6", sembrerà il numero "9". Passarlo al modello etichettato come "6" lo confonderà e ostacolerà l'addestramento. Questi esempi mostrano che, talvolta, specifiche augmentation possono impattare l'etichetta.

Ottimizzazione degli iperparametri

Un'altra strategia per migliorare le prestazioni del modello è modificare i valori degli iperparametri coinvolti nei diversi strati del modello. Questa ottimizzazione degli iperparametri richiede una profonda comprensione della matematica alla base delle reti neurali e del significato dei diversi iperparametri. 

Per esempio, potresti regolare gli strati della CNN cambiando la dimensione dei filtri o aumentando il padding. Potresti anche impostare un valore diverso per i pesi iniziali dei neuroni. 

Poiché non conosciamo a priori i valori ottimali degli iperparametri, sarà necessario un certo grado di tentativi ed errori. Di solito ciò si fa tramite una tecnica nota come grid search, che consente di valutare in modo sistematico un modello su una griglia di valori di parametro. 

Tieni però presente che questa tecnica è spesso computazionalmente costosa, soprattutto con reti neurali complesse e grandi dataset di addestramento.

Allo stesso modo, potresti aumentare la complessità del modello aggiungendo più strati convoluzionali e lineari. Tuttavia, fai attenzione quando aggiungi nuovi strati, perché il numero di neuroni può aumentare drasticamente, con tempi di addestramento più lunghi e potenziale overfitting.

Puoi approfondire l'ottimizzazione degli iperparametri nel nostro corso Introduction to Deep Learning with PyTorch.

Uso di modelli pre-addestrati

Addestrare modelli di deep learning da zero è un processo lungo e noioso, e in genere richiede molti dati di training. Spesso, invece, possiamo usare modelli pre-addestrati, cioè modelli che sono già stati addestrati su un certo compito. 

Talvolta possiamo riutilizzare direttamente un modello pre-addestrato se è già in grado di risolvere il compito che ci interessa. In altre occasioni potremmo dover adattare il modello pre-addestrato al nuovo compito. Questo è noto come transfer learning.

Usare modelli pre-addestrati in PyTorch è piuttosto semplice. Torchvision fornisce una raccolta di modelli pre-addestrati per vari compiti legati alle immagini. Questi modelli sono addestrati su dataset di immagini su larga scala e sono facilmente disponibili. Dai un'occhiata al nostro corso Deep Learning for Images with PyTorch per imparare tutto ciò che ti serve.

Distribuire il modello CNN

Dopo aver addestrato in PyTorch il tuo modello di classificazione altamente accurato, puoi ora salvare il modello e i suoi pesi pre-addestrati per un uso futuro e condividerlo con il tuo team, assicurandoti che possano caricarlo senza problemi.

Per salvare un modello, possiamo usare torch.save. Un'estensione file comune per i modelli torch è pt o pth. Per salvare i pesi del modello, passiamo model.state_dict a torch.save fornendo il nome del file di output, ad esempio MulticlassCNN.pth.

Per caricare un modello salvato, inizializziamo un nuovo modello con la stessa architettura. Quindi usiamo il metodo load dello state dict insieme a torch.load per caricare i parametri nel nuovo modello.

# Save the model
torch.save(model.state_dict(), 'MulticlassCNN.pth')

# Create a new model
loaded_model = CNN(in_channels=1, num_classes=10)

# Load the saved model
loaded_model.load_state_dict(torch.load('MulticlassCNN.pth'))
print(loaded_model)


CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

Conclusione

Abbiamo coperto una panoramica completa delle CNN, fornendo dettagli su ogni strato dell'architettura. Inoltre, abbiamo mostrato come implementare una CNN in PyTorch, coprendo i passaggi principali, dal caricamento dei dati e la progettazione del modello fino all'addestramento e alla valutazione. Infine, abbiamo analizzato diverse strategie per migliorare le prestazioni del modello. Abbiamo applicato tutte queste competenze a uno scenario reale relativo a un compito di classificazione multiclasse. 

C'è molto da imparare sul deep learning, probabilmente uno dei campi più entusiasmanti e impegnativi dell'IA. Per fortuna, DataCamp è qui per aiutarti. Dai un'occhiata ai nostri materiali e corsi dedicati e diventa un esperto di reti neurali:

• Introduzione alle Convolutional Neural Networks: una guida completa alle CNN nel deep learning 
• Convolutional Neural Networks in Python con Keras
• Python Convolutional Neural Networks (CNN) con TensorFlow: Tutorial
• Introduzione alle funzioni di attivazione nelle reti neurali 
• Master Deep Learning for Text with PyTorch Course
• Deep Learning in Python
• Come imparare il deep learning nel 2025: guida completa
• Intermediate Deep Learning with PyTorch Course
• Guida a certificazioni e certificati PyTorch