Création d'un Réseau de Neurones Simple
L'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 par 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 sous forme de 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 ('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 à prédire :
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
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 dans un style fonctionnel.
import torch.nn as nn
import torch.nn.functional as F
Il est maintenant possible de définir la classe du modèle :
class DigitsClassifier(nn.Module):
...
Lors de la définition d'une classe de modèle dans PyTorch, il est impératif d'hériter de nn.Module car cela fournit des fonctionnalités essentielles telles que la gestion automatique des paramètres, la définition de la méthode forward(), ainsi que l'utilisation d'utilitaires intégrés comme la sauvegarde/chargement du modèle et l'accès aux paramètres. Cela simplifie la création, l'entraînement et le déploiement des réseaux de neurones en prenant en charge de nombreuses tâches en arrière-plan.
Architecture du modèle
Étant donné qu'il s'agit d'une tâche simple de classification multiclasse, 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
L'appel super().__init__() initialise la classe parente nn.Module, permettant des fonctionnalités essentielles telles que le suivi des paramètres, l'enregistrement des sous-modules et la sauvegarde/chargement du modèle, qui sont cruciales pour la construction et l'entraînement du modèle.
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 de classe. 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, il est possible de définir les paramètres du modèle et d'instancier le modèle.
De la même manière que pour le nombre de couches cachées, le nombre de neurones dans chaque couche cachée est choisi de façon arbitraire dans cet exemple : 32 et 16 pour la première et la deuxième couche cachée, respectivement.
En conséquence, la structure du modèle résultant est la suivante :
- Couche d'entrée : correspond au nombre de caractéristiques dans le jeu de données (
64pour ce jeu de données) ; - Couches cachées : nombres de neurones arbitraires (
32et16) ; - Couche de sortie : correspond au nombre de classes (
10chiffres).
Implémentation complète
12345678910111213141516171819202122232425262728293031323334import 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)
Merci pour vos commentaires !
Demandez à l'IA
Demandez à l'IA
Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion
Génial!
Completion taux amélioré à 5Création d'un Réseau de Neurones Simple
Glissez pour afficher le menu
L'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 par 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 sous forme de 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 ('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 à prédire :
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
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 dans un style fonctionnel.
import torch.nn as nn
import torch.nn.functional as F
Il est maintenant possible de définir la classe du modèle :
class DigitsClassifier(nn.Module):
...
Lors de la définition d'une classe de modèle dans PyTorch, il est impératif d'hériter de nn.Module car cela fournit des fonctionnalités essentielles telles que la gestion automatique des paramètres, la définition de la méthode forward(), ainsi que l'utilisation d'utilitaires intégrés comme la sauvegarde/chargement du modèle et l'accès aux paramètres. Cela simplifie la création, l'entraînement et le déploiement des réseaux de neurones en prenant en charge de nombreuses tâches en arrière-plan.
Architecture du modèle
Étant donné qu'il s'agit d'une tâche simple de classification multiclasse, 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
L'appel super().__init__() initialise la classe parente nn.Module, permettant des fonctionnalités essentielles telles que le suivi des paramètres, l'enregistrement des sous-modules et la sauvegarde/chargement du modèle, qui sont cruciales pour la construction et l'entraînement du modèle.
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 de classe. 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, il est possible de définir les paramètres du modèle et d'instancier le modèle.
De la même manière que pour le nombre de couches cachées, le nombre de neurones dans chaque couche cachée est choisi de façon arbitraire dans cet exemple : 32 et 16 pour la première et la deuxième couche cachée, respectivement.
En conséquence, la structure du modèle résultant est la suivante :
- Couche d'entrée : correspond au nombre de caractéristiques dans le jeu de données (
64pour ce jeu de données) ; - Couches cachées : nombres de neurones arbitraires (
32et16) ; - Couche de sortie : correspond au nombre de classes (
10chiffres).
Implémentation complète
12345678910111213141516171819202122232425262728293031323334import 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)
Merci pour vos commentaires !
