Perceptron Training Example

Ce laboratoire propose une exploration pratique du perceptron multicouche appliqué à des données artificielles à deux variables explicatives. L’objectif est de comprendre le rôle des neurones dans la couche cachée et d’illustrer la détection automatique du nombre optimal de neurones avec le logiciel R et le package « nnet ». Pour réaliser ce TP, il est nécessaire d’avoir une installation fonctionnelle de R, ainsi que les fichiers de données « artificial2d_data2.txt » et « artificial2d_data4.txt ».

Objectifs

• Importer et préparer des jeux de données artificielles en R.
• Construire un perceptron multicouche avec le package « nnet ».
• Évaluer les performances du modèle à l’aide d’une matrice de confusion et du taux d’erreur.
• Mettre en place un algorithme automatique pour détecter le nombre optimal de neurones dans la couche cachée.
• Visualiser graphiquement les données et les résultats pour mieux comprendre le comportement du perceptron.

Prérequis et installation

• Logiciel R installé avec le package « nnet » disponible.
• Fichiers de données « artificial2d_data2.txt » et « artificial2d_data4.txt » convertis depuis Excel en fichiers texte tabulés.
• Connaissances de base en apprentissage supervisé, en particulier sur les réseaux de neurones et la notion de couche cachée.
• Notions élémentaires de manipulation de données en R (importation, partition, fonctions).

Importation et préparation des données

La première étape consiste à importer le jeu de données « data2 » dans R. Ce fichier contient 2000 observations avec deux variables explicatives X1 et X2, ainsi qu’une variable cible binaire Y.

On utilise la commande read.table() pour charger les données, puis summary() pour vérifier leurs caractéristiques.

# Chargement des données "data2"
data2 <- read.table(file="artificial2d_data2.txt",sep="\t",dec=".",header=TRUE)

# Nombre d'observations
n <- nrow(data2)
print(n)

# Résumé des variables
print(summary(data2))

Ensuite, on divise aléatoirement les données en deux échantillons égaux : apprentissage et test. Cette partition est essentielle pour évaluer la capacité de généralisation du modèle.

# Partition en échantillons apprentissage et test
set.seed(5)
index <- sample(n, 1000)
data2.train <- data2[index, ]
data2.test <- data2[-index, ]

print(summary(data2.train))
print(summary(data2.test))

La commande set.seed(5) garantit la reproductibilité des résultats. Un résumé similaire des deux échantillons indique une bonne répartition aléatoire.

Construction du modèle perceptron multicouche

Nous utilisons le package « nnet » pour construire un perceptron multicouche avec une couche cachée de 2 neurones. Le nombre maximal d’itérations est fixé à 300 pour assurer la convergence.

# Chargement du package nnet
library(nnet)

# Construction du perceptron multicouche avec 2 neurones cachés
set.seed(10)
model2 <- nnet(Y ~ ., skip=FALSE, size=2, data=data2.train, maxit=300, trace=FALSE)

print(model2)
print(summary(model2))

L’option skip=FALSE indique la présence d’une couche cachée, et size=2 définit le nombre de neurones dans cette couche. Le modèle est entraîné sur l’échantillon d’apprentissage.

La sortie affiche les poids synaptiques entre les entrées, la couche cachée et la sortie, ainsi que les biais. Ces paramètres définissent la fonction de décision apprise.

Évaluation du modèle

Pour évaluer la performance du perceptron, on crée une fonction qui calcule le taux d’erreur sur un échantillon donné. Cette fonction utilise la prédiction du modèle et construit une matrice de confusion.

# Fonction pour calculer le taux d'erreur
err.rate <- function(test.data, model) {
  # Prédiction sur l'échantillon test
  pred <- predict(model, newdata=test.data, type="class")
  # Matrice de confusion
  mc <- table(test.data$Y, pred)
  # Taux d'erreur
  error <- 1 - sum(diag(mc)) / sum(mc)
  return(error)
}

# Calcul du taux d'erreur sur l'échantillon test
print(err.rate(data2.test, model2))

Le taux d’erreur obtenu est très faible (0.004), ce qui indique une excellente capacité de généralisation du modèle sur ce jeu de données simple.

Détection automatique du nombre optimal de neurones

Pour le jeu de données plus complexe « data4 », il est nécessaire de déterminer automatiquement le nombre adéquat de neurones dans la couche cachée. Cette étape est cruciale car un nombre insuffisant de neurones limite la capacité d’apprentissage, tandis qu’un nombre trop élevé peut entraîner un sur-apprentissage.

On divise les données en échantillons apprentissage et test, puis on entraîne plusieurs modèles avec un nombre croissant de neurones (de 1 à 20). Pour chaque modèle, on calcule le taux d’erreur sur l’échantillon test.

# Chargement des données "data4"
data4 <- read.table(file="artificial2d_data4.txt", sep="\t", dec=".", header=TRUE)

# Partition en apprentissage et test (mêmes indices que précédemment)
data4.train <- data4[index, ]
data4.test <- data4[-index, ]

# Recherche du nombre optimal de neurones
K <- 20
res <- numeric(K)
for (k in 1:K) {
  set.seed(10)
  model <- nnet(Y ~ ., skip=FALSE, size=k, data=data4.train, maxit=300, trace=FALSE)
  error <- err.rate(data4.test, model)
  res[k] <- error
}

# Affichage graphique du taux d'erreur en fonction du nombre de neurones
plot(1:K, res, type="b", xlab="Neurones dans la couche cachée", ylab="Taux d'erreur sur test")

La courbe obtenue montre que le taux d’erreur diminue rapidement jusqu’à 4 neurones, puis se stabilise. Cela indique que 4 neurones suffisent pour modéliser correctement le concept complexe de « data4 ».

Un pic d’erreur à 14 neurones suggère un possible sur-apprentissage, mais il s’agit probablement d’un artefact lié aux fluctuations d’échantillonnage. Une validation croisée serait recommandée pour affiner cette analyse, mais elle n’est pas abordée ici pour simplifier le TP.

Visualisation des données et confirmation du modèle

Pour mieux comprendre pourquoi 4 neurones sont nécessaires, on projette les observations de « data4 » dans le plan défini par X1 et X2, en colorant les points selon leur classe.

# Représentation graphique des données
plot(data4$X1, data4$X2, pch=21, bg=c("blue","red")[unclass(data4$Y)], main="Problème data4")

Cette visualisation montre clairement que la séparation des classes nécessite plusieurs droites séparatrices, justifiant la nécessité d’une couche cachée avec plusieurs neurones.

Sélection de variables et paramétrage avancé

Dans cet exemple, nous avons travaillé avec seulement deux variables explicatives, toutes pertinentes. En situation réelle, il est souvent nécessaire de sélectionner les variables adéquates et de déterminer simultanément la bonne architecture du réseau.

Une approche possible consiste à imbriquer deux boucles : une pour tester différentes combinaisons de variables, l’autre pour tester différents nombres de neurones. Cependant, cette méthode augmente le risque de sur-apprentissage, car l’échantillon de test peut devenir partie prenante du processus de sélection.

Pour éviter ce biais, il est conseillé d’utiliser trois échantillons distincts :

• Apprentissage : pour entraîner les modèles.
• Validation (ou sélection) : pour choisir le meilleur modèle.
• Test : pour évaluer la performance finale du modèle sélectionné, sans biais.

Cette séparation garantit une estimation non biaisée des performances en prédiction.

Résultats attendus

• Sur « data2 », un perceptron multicouche avec 2 neurones dans la couche cachée doit atteindre un taux d’erreur très faible (environ 0.004) sur l’échantillon test.
• Sur « data4 », la procédure automatique doit indiquer que 4 neurones dans la couche cachée minimisent le taux d’erreur en généralisation.
• La visualisation des données doit montrer une séparation non triviale des classes, justifiant la complexité du modèle.
• La courbe du taux d’erreur en fonction du nombre de neurones doit présenter une décroissance rapide jusqu’à 4 neurones, puis une stabilisation.

Pièges courants

• Ne pas fixer la graine aléatoire (set.seed()) peut entraîner des résultats non reproductibles.
• Utiliser un nombre insuffisant d’itérations (maxit) peut empêcher la convergence du modèle.
• Confondre l’échantillon de test avec l’échantillon de validation peut biaiser l’évaluation des performances.
• Ne pas vérifier la répartition aléatoire des échantillons peut conduire à des échantillons déséquilibrés, faussant l’apprentissage.
• Ignorer le risque de sur-apprentissage en augmentant trop le nombre de neurones sans validation croisée.
• Ne pas visualiser les données peut empêcher de comprendre la complexité du problème et la nécessité d’une architecture adaptée.