Création d'un Réseau de Neurones Simple

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

Aperçu du Jeu de Données

Le jeu de données des chiffres 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 de pixels d'une image en niveaux de gris 8×8. La variable cible (colonne '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 visons à prédire :

Définition de la Classe du Modèle

Tout d'abord, tous les modules PyTorch requis (nn, F) doivent être importés. Le module nn est utilisé pour définir les couches et architectures du modèle, tandis que le module F contient des fonctions d'activation, des fonctions de perte, et d'autres utilitaires souvent utilisés dans un style fonctionnel.

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

Architecture du Modèle

Puisque la tâche est une tâche simple de classification multiclasses, un perceptron multicouche (MLP) avec 2 couches cachées est suffisant.

Comme vous le savez déjà, un MLP se compose 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 comme des couches nn.Linear dans PyTorch.

Propagation Avant

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

Le tenseur d'entrée x est d'abord passé à travers la première couche entièrement connectée (fc1), suivie par 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 par 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

Étant donné que la classe du modèle est maintenant définie, nous pouvons maintenant 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 quelque peu 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 résultant 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 : nombres de neurones arbitraires (32 et 16);
Couche de sortie : correspond au nombre de classes (10 chiffres).

Implémentation Complète


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

# 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)

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 1