Understanding the Role of Hidden Layer Neurons in Perceptron

Ce document présente une étude pratique sur le rôle des neurones dans la couche cachée d’un perceptron multicouche. Destiné aux étudiants et chercheurs en apprentissage automatique, il illustre comment paramétrer un perceptron à l’aide du logiciel R et du package « nnet » sur des données artificielles à deux variables explicatives. L’objectif est de comprendre le comportement du réseau et d’automatiser la détection du nombre optimal de neurones cachés.

Données utilisées

Les données proviennent d’un fichier « artificial.xls » contenant deux jeux de données de 2000 observations, chacune décrite par deux variables explicatives :

• X1, définie dans l’intervalle [-0.5 ; 0.5]
• X2, définie dans l’intervalle [0 ; 1]

La variable cible Y est binaire, prenant les valeurs {pos, neg}.

Le premier jeu, nommé « data2 », obéit à une règle simple :

Si (0.1 * X2 > X1^2) Alors Y = pos Sinon Y = neg

Le second jeu, « data4 », est plus complexe :

Si (X1 < 0)
  Alors Si (0.5 * X2 > 0.5 - |X1|) Alors Y = pos Sinon Y = neg
Sinon
  Si (X2 > X1 et 1 - X2 > X1) Alors Y = pos Sinon Y = neg

Dans un contexte réel, ces règles ne sont pas connues. Le but est que le perceptron apprenne ou approxime ces concepts à partir des données.

Perceptron multicouche avec R et le package « nnet »

Importation et préparation des données

Les données « data2 » sont converties en fichier texte tabulé et importées dans R :

# Chargement des données
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))

Les données sont ensuite divisées aléatoirement en deux échantillons égaux :

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() garantit la reproductibilité de la partition. Les caractéristiques similaires des deux échantillons confirment la validité de la subdivision aléatoire.

Construction du modèle perceptron

Le package « nnet » est utilisé pour créer un perceptron multicouche avec 2 neurones dans la couche cachée :

library(nnet)
set.seed(10)
model2 <- nnet(Y ~ ., skip=FALSE, size=2, data=data2.train, maxit=300, trace=FALSE)
print(model2)
print(summary(model2))

Les paramètres importants sont :

• skip=FALSE : présence d’une couche cachée
• size=2 : nombre de neurones dans la couche cachée
• maxit=300 : nombre maximal d’itérations pour assurer la convergence

La sortie affiche les poids synaptiques entre les entrées, la couche cachée et la sortie.

Évaluation du modèle

Une fonction d’évaluation calcule le taux d’erreur sur un échantillon donné :

err.rate <- function(test.data, model) {
  pred <- predict(model, newdata=test.data, type="class")
  mc <- table(test.data$Y, pred)
  error <- 1 - sum(diag(mc)) / sum(mc)
  return(error)
}

# Application sur l’échantillon test
print(err.rate(data2.test, model2))

Le taux d’erreur obtenu est très faible (0.004), indiquant une bonne généralisation du modèle sur ce jeu simple.

Détection automatique du nombre optimal de neurones

Algorithme de paramétrage automatique

Pour le jeu plus complexe « data4 », il est nécessaire de déterminer automatiquement le nombre optimal de neurones dans la couche cachée. La procédure est la suivante :

• Diviser les données en échantillons apprentissage et test
• Pour chaque nombre de neurones k de 1 à K (ici K=20), construire un modèle
• Évaluer le taux d’erreur sur l’échantillon test
• Choisir le plus petit k minimisant le taux d’erreur

Le code R correspondant :

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
}

Application sur les données « data4 »

Après importation et partition des données :

data4 <- read.table(file="artificial2d_data4.txt", sep="\t", dec=".", header=TRUE)
data4.train <- data4[index, ]
data4.test <- data4[-index, ]

La procédure automatique est lancée et les résultats sont visualisés :

plot(1:K, res, type="b", xlab="Neurones dans la couche cachée", ylab="Taux d'erreur sur test")

La courbe montre que dès k = 4 neurones, le modèle reproduit parfaitement le concept sous-jacent. Au-delà, une légère remontée du taux d’erreur peut apparaître, probablement due à des fluctuations d’échantillonnage plutôt qu’à un sur-apprentissage réel.

Vérification graphique

Puisque les données ont seulement deux variables, il est possible de visualiser la distribution des classes :

plot(data4$X1, data4$X2, pch=21, bg=c("blue","red")[unclass(data4$Y)], main="Problème data4")

Cette représentation montre clairement que quatre droites séparatrices sont nécessaires pour isoler les classes « pos » et « neg ».

Sélection des variables et paramétrage du réseau

Dans cet exemple, le nombre réduit de variables et leur pertinence étaient connus. En pratique, il faut souvent combiner la sélection des variables pertinentes avec la recherche de la bonne architecture du réseau.

Une approche consiste à imbriquer deux boucles :

• Une pour tester différentes combinaisons de variables prédictives
• Une autre pour tester différents nombres de neurones dans la couche cachée

Attention au risque de sur-apprentissage, car multiplier les hypothèses augmente la probabilité de solutions faussement optimales. De plus, l’échantillon de test devient alors partie intégrante du processus d’apprentissage, ce qui biaise l’évaluation.

Pour éviter cela, il est recommandé d’utiliser trois échantillons :

• 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

Glossaire des termes clés

• Perceptron multicouche : réseau de neurones avec une ou plusieurs couches cachées permettant d’apprendre des relations non linéaires.
• Couche cachée : couche intermédiaire entre les entrées et la sortie, composée de neurones qui extraient des caractéristiques complexes.
• Neurone : unité de calcul élémentaire dans un réseau de neurones, effectuant une combinaison pondérée des entrées suivie d’une fonction d’activation.
• Variable cible : variable à prédire, ici binaire (pos, neg).
• Variables explicatives (ou prédicteurs) : variables utilisées pour prédire la variable cible, ici X1 et X2.
• Taux d’erreur : proportion d’observations mal classées par le modèle.
• Partition aléatoire : division des données en sous-ensembles (apprentissage, test) de manière aléatoire.
• Package « nnet » : bibliothèque R pour la construction de réseaux de neurones simples.
• Fonction predict() : méthode pour générer des prédictions à partir d’un modèle entraîné.
• Sur-apprentissage (overfitting) : phénomène où un modèle s’adapte trop aux données d’apprentissage et perd en capacité de généralisation.
• Validation croisée : technique d’évaluation consistant à répéter plusieurs partitions apprentissage/test pour stabiliser l’estimation des performances.

Points clés à retenir

• Le perceptron multicouche peut apprendre des concepts non linéaires complexes à partir de données à deux variables.
• Le package R « nnet » permet de construire facilement des perceptrons avec un nombre paramétrable de neurones cachés.
• La division des données en échantillons apprentissage et test est essentielle pour évaluer la généralisation.
• Une procédure simple en boucle permet de détecter automatiquement le nombre optimal de neurones dans la couche cachée.
• La visualisation des données aide à comprendre la complexité du concept à apprendre et à justifier le nombre de neurones nécessaires.
• Dans des cas plus complexes, il faut combiner la sélection des variables et le paramétrage du réseau, en utilisant idéalement trois échantillons (apprentissage, validation, test) pour éviter les biais.
• Le perceptron reste une méthode performante en apprentissage supervisé, malgré la popularité croissante d’autres techniques comme les machines à vecteurs de support.