Impara Creazione di una Semplice Rete Neurale

L'obiettivo è costruire una rete neurale di base in PyTorch utilizzando il digits dataset, un classico dataset nell'apprendimento automatico. 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 perceptrone 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à noto, un MLP è composto da strati completamente connessi (detti anche strati densi), dove gli strati nascosti elaborano le caratteristiche di input e lo strato di output fornisce le predizioni finali delle classi. Questi strati completamente connessi sono rappresentati come strati 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 prima passato attraverso il primo strato completamente connesso (fc1), seguito dalla funzione di attivazione ReLU per introdurre non linearità. Successivamente attraversa il secondo strato completamente connesso (fc2), nuovamente seguito da ReLU.

Infine, i dati trasformati passano attraverso lo strato di output (out), che produce i punteggi grezzi (logits) per le classi di output.

Creazione del Modello

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

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

Di conseguenza, il modello risultante è strutturato come segue:

Strato di input: corrisponde al numero di caratteristiche nel dataset (64 per questo dataset);
Strati nascosti: numero arbitrario di neuroni (32 e 16);
Strato di output: corrisponde al numero di classi (10 cifre).

Implementazione Completa


              12345678910111213141516171819202122232425262728293031323334
            
import torch.nn as nn
import torch.nn.functional as F
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

# Define the model class
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

    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
      
# Define model parameters
input_features = X.shape[1]  # Number of features (pixels)
hidden1 = 32  # Number of neurons in first hidden layer
hidden2 = 16  # Number of neurons in second hidden layer
output_classes = len(digits_df["target"].unique())  # Number of unique digits (0-9)
# Create an instance of the model
model = DigitsClassifier(input_features, hidden1, hidden2, output_classes)
# Display the model structure
print(model)

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 1

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Suggested prompts:

Can you explain how to train this model on the digits dataset?

What loss function and optimizer should I use for this classification task?

How do I evaluate the model's performance after training?

Awesome!

Completion rate improved to 5

Scorri per mostrare il menu