L'obiettivo è costruire una rete neurale di base in PyTorch utilizzando il digits dataset, un classico dataset nel campo del machine learning. Il compito consiste nel prevedere la cifra (target) a partire dall'immagine della sua scrittura a mano, rappresentata come un insieme di valori di pixel (feature).

Panoramica del Dataset

Il digits dataset contiene immagini di cifre scritte a mano rappresentate come valori numerici di pixel. Ogni campione è composto da 64 feature, corrispondenti alle intensità dei pixel di una immagine in scala di grigi 8×8. La variabile target (colonna 'target') rappresenta la classe della cifra (0-9), indicando quale numero rappresenta l'immagine.

Il primo passo consiste nella lettura del file CSV e nell'estrazione delle feature (X) e della variabile target (y), che rappresenta l'output che si desidera prevedere:

import pandas as pd

digits_df = pd.read_csv('https://content-media-cdn.codefinity.com/courses/1dd2b0f6-6ec0-40e6-a570-ed0ac2209666/section_3/digits.csv')
# Extract features and target
X = digits_df.drop(columns=["target"]).values
y = digits_df["target"].values

Definizione della Classe del Modello

Per prima cosa, è necessario importare tutti i moduli PyTorch richiesti (nn, F). Il modulo nn viene utilizzato per definire layer e architetture del modello, mentre il modulo F contiene funzioni di attivazione, funzioni di perdita e altre utility spesso utilizzate in stile funzionale.

import torch.nn as nn
import torch.nn.functional as F

Ora è possibile procedere con la definizione della classe del modello:

class DigitsClassifier(nn.Module):
    ...

Architettura del Modello

Poiché il compito è una semplice classificazione multiclasse, un percettrone multistrato (MLP) con 2 strati nascosti è sufficiente.

class DigitsClassifier(nn.Module):
    def __init__(self, input_features, hidden1, hidden2, output_classes):
        super().__init__()
        # Define the layers
        self.fc1 = nn.Linear(input_features, hidden1)  # Input to first hidden layer
        self.fc2 = nn.Linear(hidden1, hidden2)  # First hidden to second hidden layer
        self.out = nn.Linear(hidden2, output_classes)  # Second hidden to output layer

Come già sapete, un MLP è composto da layer completamente connessi (noti anche come layer densi), in cui i layer nascosti elaborano le caratteristiche di input e il layer di output fornisce le predizioni finali delle classi. Questi layer completamente connessi sono rappresentati come layer nn.Linear in PyTorch.

Propagazione in Avanti

Il metodo .forward() definisce la propagazione in avanti dei dati attraverso il modello.

def forward(self, x):
    # Pass data through layers with activation functions
    a1 = F.relu(self.fc1(x))  # First hidden layer with ReLU
    a2 = F.relu(self.fc2(a1))  # Second hidden layer with ReLU
    output = self.out(a2)          # Output layer (no activation for raw scores)
    return output

Il tensore di input x viene inizialmente passato attraverso il primo layer completamente connesso (fc1), seguito dalla funzione di attivazione ReLU per introdurre non linearità. Successivamente, attraversa il secondo layer completamente connesso (fc2), nuovamente seguito da ReLU.

Infine, i dati trasformati passano attraverso il layer di output (out), che produce i punteggi grezzi (logit) per le classi di output.

Creazione del Modello

Poiché la classe del modello è ora definita, possiamo ora definire i parametri del modello e istanziare il modello.

Analogamente al numero di layer nascosti, il numero di neuroni in ciascun layer nascosto viene scelto in modo arbitrario nel nostro esempio: 32 e 16 rispettivamente per il primo e il secondo layer nascosto.

Di conseguenza, il modello risultante è strutturato come segue:

• Layer di input: corrisponde al numero di feature nel dataset (64 per questo dataset);
• Layer nascosti: numero arbitrario di neuroni (32 e 16);
• Layer di output: corrisponde al numero di classi (10 digits).

Implementazione Completa