La capacité de prédire des valeurs continues est essentielle dans de nombreux domaines : prévisions financières, estimation de prix immobiliers, évaluation de la consommation énergétique, etc. Pour ces tâches, les méthodes linéaires montrent rapidement leurs limites dès que les relations deviennent complexes. Les réseaux de neurones, et en particulier le Perceptron Multi-Couche (MLP), apportent une solution robuste et flexible pour modéliser ces dépendances non linéaires.

Un MLP peut être utilisé efficacement en régression à condition d’adapter sa structure et ses fonctions de perte. Cet article explore pas à pas le fonctionnement d’un MLP pour la régression, illustre l'entraînement d’un modèle avec Python, et souligne les points d’attention à garder en tête.

Fonctionnement d’un MLP en régression

Un MLP est composé de plusieurs couches : une couche d’entrée, des couches cachées et une couche de sortie. Chaque neurone dans une couche effectue une opération simple : il prend les entrées, applique une combinaison linéaire (somme pondérée + biais), puis une fonction d’activation non linéaire comme ReLU ou tanh.

Pour une couche cachée, la sortie peut être décrite par la formule :

a = activation(W * x + b)

où :

x est l’entrée,
W est la matrice des poids,
b est le biais,
a est la sortie (activation).

Dans le cas d’une régression, la dernière couche ne contient aucune fonction d’activation, ce qui permet au réseau de produire une valeur numérique brute.

Fonction de perte adaptée à la régression

La fonction de perte la plus utilisée est la MSE (Mean Squared Error), ou erreur quadratique moyenne. Elle se calcule comme :

MSE = (1/N) * Σ (yi - ŷi)²

où :

yi est la vraie valeur,
ŷi est la valeur prédite,
N est le nombre d’exemples.

Cette fonction est différentiable, facile à implémenter, et pénalise fortement les grandes erreurs

Mise en pratique avec le jeu de données California Housing

Nous allons maintenant mettre en œuvre un modèle de régression neuronale sur des données tabulaires réelles. Le jeu de données California Housing contient des informations sur des logements en Californie. L’objectif est de prédire la valeur médiane d’un logement à partir de variables comme la densité de population ou le revenu moyen.

Chargement et préparation des données

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

data = fetch_california_housing(as_frame=True)
X = data.data
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Ce que fait ce code :

Il charge les données California Housing.
Il sépare les données en entraînement et test.
Il normalise les valeurs avec StandardScaler pour que chaque variable ait une moyenne nulle et un écart-type de 1. C’est indispensable avec les MLP pour stabiliser l’apprentissage.

Construction du modèle MLP

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(X_train.shape[1],)))
model.add(Dense(32, activation='relu'))
model.add(Dense(1))  # couche de sortie linéaire

Explication :

Le modèle comporte deux couches cachées avec 64 et 32 neurones, activées par ReLU.
La couche de sortie ne contient aucune fonction d’activation, car nous voulons prédire une valeur réelle (et non une probabilité).

Compilation et entraînement du modèle

model.compile(optimizer='adam', loss='mse', metrics=['mae'])

history = model.fit(X_train, y_train, validation_split=0.2,
                    epochs=100, batch_size=32, verbose=1)

Explication :

L’optimiseur Adam est utilisé pour ajuster les poids.
La fonction de perte mse calcule l'erreur quadratique moyenne.
La métrique mae (Mean Absolute Error) est ajoutée pour évaluer l’erreur moyenne en valeur absolue.
validation_split=0.2 réserve 20 % des données d'entraînement pour évaluer le modèle à chaque époque.

Évaluation du modèle

loss, mae = model.evaluate(X_test, y_test)
print(f"Erreur absolue moyenne sur le test set : {mae:.2f}")

Ce que ça permet de voir :

Cette évaluation nous indique la performance du modèle sur des données jamais vues pendant l'entraînement.
La mae retournée est interprétable facilement : par exemple, une erreur moyenne de 0.5 signifie que le modèle se trompe de 0.5 unités en moyenne.

Visualisation de la performance

import matplotlib.pyplot as plt

plt.plot(history.history['loss'], label='Entraînement')
plt.plot(history.history['val_loss'], label='Validation')
plt.title("Évolution de la perte (MSE)")
plt.xlabel("Époques")
plt.ylabel("Perte")
plt.legend()
plt.grid(True)
plt.show()

Ce graphique montre :

La courbe d’entraînement diminue régulièrement si le réseau apprend bien.
Une courbe de validation qui remonte alors que celle d’entraînement continue de descendre indique un surapprentissage (overfitting).

Limites et remarques importantes

1. Sensibilité aux données brutes

Le MLP ne gère pas bien les données brutes non normalisées. La standardisation est indispensable pour que le réseau converge correctement.

2. Boîte noire

Un MLP ne permet pas d’interpréter directement l’effet de chaque variable sur la sortie, contrairement à une régression linéaire. Cela limite son usage dans les cas où l’explicabilité est cruciale.

3. Risque de surapprentissage

Avec un petit jeu de données, un MLP peut facilement surapprendre. Il faut utiliser une validation croisée ou du dropout si besoin.

4. Nécessité d’un bon réglage

Le choix du nombre de neurones, du nombre de couches, de l’optimiseur, etc., a un impact important sur les performances. Il faut tester plusieurs combinaisons pour trouver un bon compromis.

Un Perceptron Multi-Couche (MLP) bien entraîné peut produire des prédictions précises dans un cadre de régression, surtout lorsque les données présentent des relations non linéaires complexes. Grâce à son adaptabilité, il s'intègre bien aux pipelines de machine learning modernes. Toutefois, son efficacité dépend fortement de la qualité des données d’entrée, du prétraitement, et des choix d'architecture.

Régression par MLP expliquée simplement : un guide pratique pour prédire des données continues