Il nostro obiettivo è costruire una rete neurale di base in PyTorch utilizzando il digits dataset, un classico dataset nel machine learning. Il compito è 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 dei 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 nel leggere il file CSV ed estrarre le feature (X) e la variabile target (y), che rappresenta l'output che vogliamo prevedere:

import pandas as pd

digits_df = pd.read_csv('https://staging-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 usate in stile funzionale.

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

Possiamo ora procedere con la definizione della classe del modello:

class DigitsClassifier(nn.Module):
    ...

Architettura del Modello

Poiché il compito è una semplice classificazione multiclasse, un perceptrone multistrato (MLP) con 2 layer 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à noto, un MLP è composto da layer completamente connessi (detti anche layer densi), dove i layer nascosti elaborano le feature 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 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 cifre).

Implementazione Completa