Perceptron multicouche (MLP) : architecture, fonctionnement et implémentation avec TensorFlow/Keras

Architecture du MLP : couches d’entrée, cachées et de sortie

Le perceptron multicouche (MLP) est un réseau de neurones artificiels organisé en couches successives. Chaque neurone d’une couche reçoit des signaux de tous les neurones de la couche précédente, les transforme via une fonction d’activation, puis transmet le résultat à la couche suivante. Cette structure en couches permet au réseau d’apprendre des relations complexes et non linéaires entre les données d’entrée et de sortie.

Le rôle de chaque couche est strictement défini : la couche d’entrée reçoit les caractéristiques brutes des données, les couches cachées (une ou plusieurs) extraient progressivement des motifs de plus en plus abstraits, et la couche de sortie produit le résultat final adapté à la tâche. Un neurone de biais est ajouté à chaque couche (sauf la couche d’entrée) ; il possède une valeur constante de 1 et son propre poids, appris pendant l’entraînement.

Rôle et dimensionnement de chaque couche

• Couche d’entrée : nombre de neurones = nombre de caractéristiques (features) des données
• Couche cachée : une ou plusieurs, chaque neurone reçoit la sortie de tous les neurones précédents
• Couche de sortie : dimensionnée selon la tâche (1 neurone pour binaire, N pour multi-classe)
• Neurone de biais : constante égale à 1, poids propre appris, présent sur chaque couche sauf l’entrée

Le choix du nombre de couches cachées et de neurones par couche est un compromis : trop peu de neurones limite la capacité d’apprentissage, trop nombreux entraînent un risque de surapprentissage. La pratique courante consiste à partir d’une architecture simple et à l’augmenter progressivement selon les performances observées sur un ensemble de validation.

Architecture type : exemple concret 10-20-3

Prenons un exemple concret avec une architecture 10-20-3, couramment utilisée pour illustrer le fonctionnement d’un MLP. La couche d’entrée contient 10 neurones, correspondant à 10 caractéristiques numériques décrivant chaque exemple (par exemple, des mesures physiques d’une fleur ou des attributs d’un produit). Vient ensuite une couche cachée de 20 neurones avec une activation ReLU (Rectified Linear Unit), qui introduit la non-linéarité nécessaire pour capturer des relations complexes. Enfin, la couche de sortie contient 3 neurones, chacun correspondant à une classe distincte ; une activation softmax convertit les sorties brutes en probabilités, dont la somme vaut 1. La classe prédite est celle associée au neurone ayant la probabilité la plus élevée.

Cette architecture illustre parfaitement le principe de dimensionnement : l’entrée est imposée par les données, la sortie par la tâche de classification, et la couche cachée constitue l’espace de représentation intermédiaire où le réseau apprend ses propres caractéristiques. Le choix de 20 neurones cachés est un point de départ raisonnable ; il peut être ajusté selon la complexité du problème. Avant l’entraînement, une normalisation des données est recommandée : mise à l’échelle dans l’intervalle [0, 1] ou [-1, +1], ou standardisation pour obtenir une moyenne 0 et variance 1. Cette étape accélère la convergence et améliore la stabilité du modèle.

Fonctions d’activation : types, rôles et choix selon la couche

La fonction d’activation est le cœur de la non-linéarité du MLP. Sans elle, l’empilement des couches équivaudrait à un simple modèle linéaire, incapable de capturer des relations complexes. Les fonctions les plus courantes sont la sigmoïde, la tanh (dont les sorties idéales dans [0, 1] ou [-1, +1] aident à la convergence), et la ReLU, souvent utilisée pour les couches cachées de l’exemple Keras.

Le choix de l’activation dépend de la couche. Les couches cachées utilisent généralement ReLU pour sa simplicité et son efficacité. Pour la couche de sortie, l’activation doit correspondre à la tâche : une softmax pour la classification multi-classes, une sigmoïde pour la classification binaire, et une fonction d’identité pour la régression, où les données sont souvent standardisées (moyenne 0 et variance 1).

Chaque fonction transforme la somme pondérée des entrées, introduisant la non-linéarité indispensable pour séparer des données non linéairement séparables. Le choix de la bonne activation est donc un compromis entre la vitesse d’apprentissage et la stabilité, influençant directement la capacité du perceptron multicouche à modéliser des fonctions complexes.

Rétropropagation et descente de gradient : l’apprentissage du MLP

Rétropropagation : calcul des gradients et mise à jour des paramètres

Une fois l’architecture définie, le MLP doit apprendre. C’est la rétropropagation (backpropagation) qui rend cet apprentissage possible. Cet algorithme calcule le gradient de la fonction de perte par rapport à chaque poids et biais du réseau. Concrètement, il propage l’erreur de la couche de sortie vers la couche d’entrée, en passant par les couches cachées.

Ce processus itératif ajuste les paramètres pour minimiser l’erreur de prédiction. La complexité temporelle de la rétropropagation est de O(i·n·(m·h + (k-1)·h·h + h·o)), où i représente le nombre d’itérations, n le nombre d’exemples, m et o les tailles des couches d’entrée et de sortie, et h la taille des couches cachées. Cette formule illustre pourquoi le choix du nombre de neurones dans les couches cachées impacte directement le temps d’entraînement.

Pendant la phase d’apprentissage, le réseau compare sa prédiction à la valeur réelle, calcule l’erreur, puis rétropropage cette erreur pour ajuster les poids. Cette boucle se répète jusqu’à ce que la perte atteigne un seuil acceptable ou qu’un nombre maximal d’itérations soit atteint.

Descente de gradient, taux d’apprentissage et optimiseurs (SGD, Adam, L-BFGS)

La descente de gradient est l’algorithme d’optimisation qui guide la mise à jour des poids. Elle fonctionne en déplaçant les paramètres dans la direction où la perte diminue le plus rapidement. Le taux d’apprentissage contrôle la taille de ces déplacements : un taux élevé accélère la convergence mais risque de dépasser l’optimum, tandis qu’un taux faible assure une progression stable mais plus lente. Il est recommandé d’expérimenter différents taux et programmes d’apprentissage pour trouver le bon équilibre.

Plusieurs optimiseurs sont disponibles pour entraîner un MLP. Le SGD (Stochastic Gradient Descent) est le plus classique : il initialise les poids aléatoirement puis optimise itérativement. L’optimiseur Adam adapte automatiquement le taux d’apprentissage pour chaque paramètre, ce qui le rend particulièrement efficace en pratique. L-BFGS est une méthode quasi-Newton qui convient aux problèmes de petite taille. Pour choisir le bon optimiseur, testez-les sur votre jeu de données : il n’existe pas de solution universelle.

Poids et biais : initialisation, apprentissage et rôle dans les connexions

Chaque connexion entre deux neurones de couches adjacentes possède un poids qui indique l’importance du signal transmis. Ces poids sont appris pendant la formation : au départ, ils sont initialisés avec des valeurs aléatoires faibles, puis ajustés itérativement par rétropropagation pour minimiser l’erreur de prédiction.

Le biais fonctionne comme un seuil interne : il s’ajoute à la somme pondérée des entrées avant l’application de la fonction d’activation. Sans biais, le neurone serait contraint de passer par l’origine, ce qui limiterait sa capacité d’adaptation. Chaque neurone des couches cachées et de sortie possède son propre biais, également appris durant l’entraînement.

Pour un MLP avec une couche d’entrée de 10 neurones, une couche cachée de 20 neurones et une couche de sortie de 3 neurones, le nombre total de paramètres à apprendre est de 10×20 + 20×3 = 260 poids, plus 20 + 3 = 23 biais. La complexité temporelle de la rétropropagation pour ce réseau s’exprime en O(i·n·(m·h + (k-1)·h·h + h·o)).

Les méthodes d’initialisation Xavier et He ajustent la variance des poids selon le nombre de neurones entrants et sortants, évitant ainsi les problèmes de gradients qui s’atténuent ou explosent. Pour les données d’entrée, une mise à l’échelle entre [0, 1] ou [-1, +1], ou une standardisation avec moyenne 0 et variance 1, améliore considérablement la convergence.

La régularisation L2, contrôlée par le paramètre alpha, pénalise les poids trop importants et prévient le sur-apprentissage en forçant le réseau à répartir l’information sur davantage de connexions.

Implémentation d’un MLP avec TensorFlow/Keras et scikit-learn

Passons maintenant à la pratique. Deux bibliothèques dominent l’implémentation d’un MLP : TensorFlow/Keras pour un contrôle fin et la gestion du GPU, et scikit-learn pour des prototypes rapides et propres. Chacune a ses forces, et le choix dépend de votre objectif.

Exemple de code Keras : MLP pas à pas

Avec Keras, l’architecture se définit en empilant des couches via l’API `Sequential`. Pour un problème de classification multi-classes (par exemple sur le jeu de données iris, qui contient 3 classes), le code suit une structure très lisible.

Un exemple concret reprend l’architecture vue plus haut : une couche d’entrée de 10 neurones, une couche cachée de 20 neurones avec activation ReLU, et une couche de sortie de 3 neurones avec activation softmax. L’entraînement repose ensuite sur la compilation du modèle, en choisissant un optimiseur comme Adam et la fonction de perte adaptée à la tâche.

python
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

Architecture : 10 -> 20 -> 3

modele = Sequential([
Dense(20, activation=’relu’, input_shape=(10,)), # couche cachée
Dense(3, activation=’softmax’) # sortie multi-classes
])

modele.compile(optimizer=’adam’,
loss=’categorical_crossentropy’,
metrics=[‘accuracy’])
Avant d’entraîner, une étape cruciale est la préparation des données. Il faut les mettre à l’échelle, idéalement dans l’intervalle [0, 1] ou [-1, +1], ou les standardiser pour qu’elles aient une moyenne de 0 et une variance de 1. Cette normalisation accélère considérablement la convergence du modèle.

MLPClassifier et MLPRegressor avec scikit-learn

Pour des expérimentations rapides, scikit-learn propose deux classes clés en une seule ligne : `MLPClassifier` pour la classification et `MLPRegressor` pour la régression avec sortie continue. Bien que leur fonctionnement interne soit identique, voici ce qui les distingue :

– `MLPClassifier` : effectue la classification par rétropropagation ; il gère aussi bien le binaire que le multi-classes.
– `MLPRegressor` : traite les sorties continues ; sa fonction de perte par défaut est l’erreur quadratique moyenne.
– Pas de GPU : scikit-learn est limité au CPU, contrairement à TensorFlow.
– Mise à l’échelle [0, 1] : requise pour de bons résultats, tout comme avec Keras.
– Régularisation L2 : contrôlée par le paramètre `alpha`, elle permet de limiter le sur-apprentissage.

python
from sklearn.neural_network import MLPClassifier

jeu de données iris : 3 classes

clf = MLPClassifier(hidden_layer_sizes=(20,), alpha=0.01, max_iter=200)
clf.fit(X_standardise, y) # X_standardise : données normalisées
Une différence notable réside dans la gestion des données : Keras attend des tenseurs et nécessite souvent un découpage manuel en ensembles d’entraînement et de validation, tandis que scikit-learn s’intègre nativement avec `train_test_split`. Ce dernier est donc idéal pour valider une idée rapidement, alors que Keras brille par sa flexibilité, notamment pour les architectures profondes et l’utilisation de GPU.

Classification : applications pratiques du MLP et limites

Le perceptron multicouche est un algorithme d’apprentissage supervisé capable de modéliser des fonctions non linéaires complexes. Il excelle en classification multi-classes : pour le jeu de données iris, une architecture avec 3 neurones en sortie prédit la catégorie de chaque fleur. En pratique, on l’utilise pour la reconnaissance d’images, la vision par ordinateur ou le traitement du langage naturel.

Pour la régression, MLPRegressor de scikit-learn produit une sortie continue avec une fonction de perte par erreur carrée. Ces modèles sont puissants mais présentent des limites : sans GPU, l’entraînement sur de grands volumes de données devient lent, et une mauvaise initialisation des poids mène souvent à des minima locaux. Une standardisation des données (moyenne 0, variance 1) reste indispensable pour stabiliser l’apprentissage.