Chapitre 5 — Réseaux de Neurones (Perceptron & MLP)

🎯 Objectifs d’apprentissage

À l’issue de ce chapitre, vous serez capable de :

• Comprendre le principe du neurone artificiel (perceptron)
• Identifier les fonctions d’activation et leur rôle
• Comprendre l’architecture d’un réseau multicouche
• Saisir l’intuition de la descente de gradient
• Connaître les grandes familles de réseaux profonds

1. Du perceptron au neurone artificiel

1.1 Histoire : le perceptron de Rosenblatt (1957)

Le perceptron est le premier modèle de neurone artificiel, inventé par Frank Rosenblatt en 1957. C’est un classifieur linéaire binaire inspiré du fonctionnement d’un neurone biologique.

1.2 Fonctionnement mathématique

Un perceptron prend en entrée un vecteur $\mathbf{x}=(x_1,x_2,...,x_n)$ et calcule :

Ou de manière plus compacte :

Où :

• $\mathbf{w}=(w_1,w_2,...,w_n)$ : vecteur de poids (coefficients)
• $b$ : biais (bias), décalage vertical
• $\text{sign}(z)$ : fonction qui renvoie +1 si $z\ge 0$, sinon -1

Interprétation géométrique : Le perceptron trace une frontière linéaire (droite en 2D, plan en 3D, hyperplan en dimension supérieure) qui sépare l’espace en deux régions.

1.3 Visualisation interactive

Expérimentez :

1. Ajoutez des points bleus (classe +1) avec un clic gauche
2. Ajoutez des points roses (classe -1) avec un clic droit
3. Ajustez les poids $w_1$, $w_2$ et le biais $b$ pour séparer les classes
4. Observez comment la droite noire (frontière de décision) bouge
5. Les points mal classés sont entourés d’un cercle rouge

Question : Pouvez-vous séparer deux classes disposées en cercles concentriques avec un perceptron ? Pourquoi ?

2. Limitations du perceptron : le problème XOR

Le perceptron ne peut classifier que des données linéairement séparables.

Exemple : la fonction XOR

Ces 4 points ne peuvent pas être séparés par une seule droite ! C’est la crise du perceptron des années 1970.

Visualisation :

<!-- Points -->
<!-- (0,0) -> 0 (Rouge) -->
<circle cx="10" cy="90" r="5" fill="red" />
<text x="15" y="85" font-size="10" fill="red">(0,0)</text>

<!-- (1,1) -> 0 (Rouge) -->
<circle cx="90" cy="10" r="5" fill="red" />
<text x="75" y="25" font-size="10" fill="red">(1,1)</text>

<!-- (1,0) -> 1 (Bleu) -->
<circle cx="90" cy="90" r="5" fill="blue" />
<text x="75" y="85" font-size="10" fill="blue">(1,0)</text>

<!-- (0,1) -> 1 (Bleu) -->
<circle cx="10" cy="10" r="5" fill="blue" />
<text x="15" y="25" font-size="10" fill="blue">(0,1)</text>

<!-- Impossible Line -->
<line x1="0" y1="0" x2="100" y2="100" stroke="gray" stroke-dasharray="4" />
<text x="40" y="50" font-size="10" fill="gray">Impossible ?</text>

Essayez de tracer une seule ligne droite qui met tous les Rouges d’un côté et tous les Bleus de l’autre. C’est impossible. Il faut une courbe (ou deux droites).

Solution : Empiler plusieurs perceptrons en couches → réseau multicouche.

3. Réseaux de neurones multicouches (MLP)

3.1 Architecture

Un Multi-Layer Perceptron (MLP) est composé de :

• Couche d’entrée : les features $x_1,x_2,...,x_n$
• Couches cachées : une ou plusieurs couches de neurones
• Couche de sortie : la prédiction $\hat{y}$

Entrée     Couche cachée     Sortie
  x₁  \      🔵           \
       \    /  \           🔵  →  ŷ
  x₂  --🔵      🔵        /
       /    \  /         
  x₃  /      🔵         

3.2 Calcul dans un neurone

Chaque neurone de la couche cachée calcule :

Où $f$ est une fonction d’activation non linéaire.

4. Fonctions d’activation

Les fonctions d’activation introduisent de la non-linéarité, permettant au réseau d’apprendre des relations complexes.

Pourquoi est-ce crucial ? Si on n’avait pas de fonction d’activation (ou juste une fonction linéaire $f(x)=ax$), empiler des couches ne servirait à rien.

• Mathématiquement : $W_2(W_{1}x)=(W_2{W}_1)x=W_{total}x$.
• Deux couches linéaires équivalent à une seule couche linéaire.

C’est la non-linéarité (la courbure) qui permet au réseau de tordre l’espace pour résoudre des problèmes comme XOR.

4.1 Sigmoïde

• Sort entre 0 et 1
• Historiquement populaire
• Problème : gradients qui “s’évanouissent” pour $|z|$ grand

4.2 Tangente hyperbolique (tanh)

• Sort entre -1 et 1
• Centrée en 0 (mieux que sigmoïde)

4.3 ReLU (Rectified Linear Unit)

• La plus utilisée aujourd’hui
• Simple et efficace
• Résout le problème des gradients évanescents
• Variantes : Leaky ReLU, ELU, GELU

4.4 La Sortie : Softmax (Classification Multi-classe)

Si on veut classer une image en 3 classes (Chat, Chien, Oiseau), la couche de sortie aura 3 neurones. Ils vont sortir des scores bruts (logits), par exemple : [2.0, 1.0, 0.1]. Pour transformer ça en probabilités (qui somment à 1), on utilise la fonction Softmax :

$P(y=j)=\frac{e^{z_j}}{{\sum }_k{e}^{z_k}}$

Cela “écrase” les scores pour qu’ils deviennent une distribution de probabilité (ex: [0.7, 0.2, 0.1]).

Graphique comparatif :

4.5 Visualisation Interactive

Comparez les différentes fonctions d’activation.

• Sigmoïde : Écrase tout entre 0 et 1.
• ReLU : Laisse passer le positif, met à zéro le négatif. C’est la plus efficace pour les réseaux profonds.

5. Apprentissage : la descente de gradient

5.1 Fonction de coût

Pour entraîner le réseau, on définit une fonction de coût $E$ qui mesure l’erreur :

(Erreur quadratique moyenne pour la régression)

5.2 Principe de la descente de gradient

On cherche les poids $\mathbf{w}$ qui minimisent $E$. Pour cela :

1. Calculer le gradient $\nabla E=\frac{\partial E}{\partial \mathbf{w}}$ (direction de plus forte montée)
2. Mettre à jour les poids dans la direction opposée :

Où $\eta$ est le taux d’apprentissage (learning rate), petit nombre comme 0.01.

5.3 Métaphore visuelle

Imaginez que vous êtes dans le brouillard au sommet d’une montagne (erreur élevée). Vous voulez descendre dans la vallée (erreur minimale). À chaque pas :

• Vous sentez la pente sous vos pieds (gradient)
• Vous faites un pas dans la direction de descente
• Vous recommencez jusqu’à atteindre le fond

Rétropropagation (backpropagation) : algorithme efficace pour calculer les gradients en propageant l’erreur de la sortie vers l’entrée.

5.4 Mathématiques de la Rétropropagation (Chain Rule)

Pour comprendre comment l’erreur se propage, il faut utiliser la règle de dérivation en chaîne. Prenons un réseau très simple : $x\stackrel{w_1}{\to }h\stackrel{w_2}{\to }\hat{y}$.

• $h=\sigma (w_{1}x)$
• $\hat{y}=\sigma (w_{2}h)$
• Erreur $E=\frac{1}{2}(\hat{y}-y{)}^2$

On veut savoir comment changer $w_1$ pour réduire $E$. On cherche $\frac{\partial E}{\partial w_1}$.

$\frac{\partial E}{\partial w_1}=\frac{\partial E}{\partial \hat{y}}\times \frac{\partial \hat{y}}{\partial h}\times \frac{\partial h}{\partial w_1}$

C’est le produit des dérivées locales :

1. Dérivée de l’erreur : $\frac{\partial E}{\partial \hat{y}}=(\hat{y}-y)$
2. Dérivée de la sortie : $\frac{\partial \hat{y}}{\partial h}={\sigma }^{\prime }(w_{2}h)\cdot w_2$
3. Dérivée de la couche cachée : $\frac{\partial h}{\partial w_1}={\sigma }^{\prime }(w_{1}x)\cdot x$

L’algorithme calcule ces termes de la fin vers le début (d’où “Rétro”-propagation) et les multiplie.

Note pour les matheux : La rétropropagation n’est rien d’autre qu’une application récursive du théorème de dérivation des fonctions composées (Chain Rule). Si $y=f(g(x))$, alors $\frac{dy}{dx}=f^{\prime }(g(x))\times g^{\prime }(x)$. Dans un réseau, l’erreur est une fonction composée de milliers de couches : $E=L(f_n(...f_1(x)...))$. On remonte la chaîne des dérivées de la fin vers le début.

6. Architectures modernes

6.1 Réseaux convolutifs (CNN)

Usage : Vision par ordinateur, images

• Convolutions : détection de motifs locaux (bords, textures, formes)
• Pooling : réduction de dimension
• Exemples : AlexNet, VGG, ResNet

6.2 Réseaux récurrents (RNN, LSTM)

Usage : Séquences, texte, séries temporelles

• Mémoire : prise en compte du contexte passé
• LSTM (Long Short-Term Memory) : résout le problème des gradients évanescents
• Applications : traduction, reconnaissance vocale

6.3 Transformers

Usage : Traitement du langage (GPT, BERT), vision (ViT)

• Attention : pondération de l’importance des différents éléments
• Parallélisable (plus rapide que RNN)
• Base des LLM (Large Language Models) comme ChatGPT

6.4 Réseaux génératifs

• GAN (Generative Adversarial Networks) : génération d’images réalistes
• Diffusion Models : DALL·E, Stable Diffusion
• VAE (Variational Autoencoders) : compression et génération

7. En pratique

7.1 Frameworks populaires

• PyTorch : très utilisé en recherche
• TensorFlow / Keras : écosystème complet, bon pour la production
• JAX : calcul différentiable haute performance

7.2 Exemple simple en PyTorch

import torch
import torch.nn as nn
 
# Définir un MLP simple
class SimpleMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(10, 64)  # 10 entrées → 64 neurones
        self.layer2 = nn.Linear(64, 32)  # 64 → 32
        self.layer3 = nn.Linear(32, 1)   # 32 → 1 sortie
        
    def forward(self, x):
        x = torch.relu(self.layer1(x))   # ReLU activation
        x = torch.relu(self.layer2(x))
        x = self.layer3(x)               # Pas d'activation en sortie
        return x
 
# Créer le modèle
model = SimpleMLP()
 
# Définir la fonction de coût et l'optimiseur
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
 
# Boucle d'entraînement (simplifié)
for epoch in range(100):
    # Forward pass
    predictions = model(X_train)
    loss = criterion(predictions, y_train)
    
    # Backward pass
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

8. Points clés à retenir

• Un perceptron est un classifieur linéaire simple : $y=\text{sign}(\mathbf{w}\cdot \mathbf{x}+b)$
• Les perceptrons seuls ne peuvent résoudre que des problèmes linéairement séparables
• Les réseaux multicouches (MLP) ajoutent des couches cachées avec activation non linéaire
• Les fonctions d’activation (ReLU, sigmoïde, tanh) apportent la non-linéarité
• L’apprentissage se fait par descente de gradient : ajuster les poids pour minimiser l’erreur
• Les architectures modernes (CNN, RNN, Transformers) sont des réseaux profonds spécialisés

🔗 Pour aller plus loin

• 3Blue1Brown : série vidéo sur les réseaux de neurones (excellente visualisation)
• Distill.pub : articles interactifs sur le deep learning
• Cours Stanford CS231n : vision par ordinateur et CNN
• The Neural Network Zoo : panorama des architectures

Prochain chapitre : Chapitre 6 — Deep Learning et IA Générative