Notre objectif est de construire un réseau de neurones PyTorch basique en utilisant le jeu de données digits, un jeu de données classique en apprentissage automatique. La tâche consiste à prédire le chiffre (cible) à partir de l'image de son écriture manuscrite, représentée comme un ensemble de valeurs de pixels (caractéristiques).

Présentation du jeu de données

Le jeu de données digits contient des images de chiffres manuscrits représentées par des valeurs numériques de pixels. Chaque échantillon se compose de 64 caractéristiques, correspondant aux intensités des pixels d'une image en niveaux de gris 8×8. La variable cible ('target') représente la classe du chiffre (0-9), indiquant à quel chiffre correspond l'image.

La première étape consiste à lire le fichier CSV et à extraire les caractéristiques (X) et la variable cible (y), qui représente la sortie que nous souhaitons prédire :

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

Définition de la classe du modèle

Tout d'abord, il convient d'importer tous les modules PyTorch nécessaires (nn, F). Le module nn est utilisé pour définir les couches et architectures du modèle, tandis que le module F contient les fonctions d'activation, fonctions de perte et autres utilitaires souvent utilisés de manière fonctionnelle.

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

Nous pouvons maintenant procéder à la définition de la classe du modèle :

class DigitsClassifier(nn.Module):
    ...

Architecture du modèle

Étant donné que la tâche est une classification multiclasse simple, un perceptron multicouche (MLP) avec 2 couches cachées est suffisant.

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

Comme vous le savez déjà, un MLP est composé de couches entièrement connectées (également appelées couches denses), où les couches cachées traitent les caractéristiques d'entrée, et la couche de sortie fournit les prédictions finales des classes. Ces couches entièrement connectées sont représentées par des couches nn.Linear dans PyTorch.

Propagation avant

La méthode .forward() définit la propagation avant des données à travers le modèle.

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

Le tenseur d'entrée x est d'abord transmis à la première couche entièrement connectée (fc1), suivie de la fonction d'activation ReLU pour introduire la non-linéarité. Il passe ensuite par la deuxième couche entièrement connectée (fc2), à nouveau suivie de ReLU.

Enfin, les données transformées passent par la couche de sortie (out), qui produit les scores bruts (logits) pour les classes de sortie.

Création du modèle

Puisque la classe du modèle est maintenant définie, nous pouvons désormais définir les paramètres du modèle et instancier le modèle.

De même que pour le nombre de couches cachées, le nombre de neurones dans chaque couche cachée est choisi de manière arbitraire dans notre exemple : 32 et 16 pour la première et la deuxième couche cachée, respectivement.

Par conséquent, le modèle obtenu est structuré comme suit :

• Couche d'entrée : correspond au nombre de caractéristiques dans le jeu de données (64 pour ce jeu de données) ;
• Couches cachées : nombre arbitraire de neurones (32 et 16) ;
• Couche de sortie : correspond au nombre de classes (10 chiffres).

Implémentation complète