Le perceptron et les bases des réseaux de neurones

L’ordinateur est né pour résoudre des problèmes qui n’existaient pas avant lui ; mais le neurone artificiel est né d’un rêve plus ancien — comprendre comment l’esprit apprend.

— Adaptation libre d’une réflexion sur les origines de l’intelligence artificielle

Nous entrons dans la Partie IV de cet ouvrage, consacrée aux réseaux de neurones. Ce premier chapitre retrace la naissance du neurone artificiel, formalise le perceptron de Rosenblatt, explore ses capacités et ses limites, puis ouvre la voie au perceptron multicouche (MLP) et, au-delà, à l’apprentissage profond. Le perceptron est un modèle historiquement fondateur : c’est le point de départ de toute l’architecture moderne des réseaux de neurones. Le comprendre en profondeur — son algorithme d’apprentissage, son théorème de convergence, ses échecs sur des problèmes non linéairement séparables — est indispensable pour apprécier les motivations qui ont conduit aux réseaux profonds.

Show code cell source

Hide code cell source

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.colors import ListedColormap

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)
np.random.seed(42)

Introduction historique

L’histoire des réseaux de neurones est indissociable de celle de l’intelligence artificielle. Elle est ponctuée d’enthousiasmes, de désillusions et de renaissances.

Le neurone biologique. Le système nerveux est constitué de milliards de neurones interconnectés. Chaque neurone reçoit des signaux électriques par ses dendrites, les intègre dans le corps cellulaire (soma), et, si la somme des signaux dépasse un certain seuil, propage un potentiel d’action le long de son axone vers d’autres neurones via les synapses. Cette architecture massivement parallèle et adaptative a inspiré les pionniers de l’IA.

McCulloch et Pitts (1943). Warren McCulloch (neurophysiologiste) et Walter Pitts (logicien) proposent le premier modèle mathématique du neurone : une unité logique binaire qui calcule une fonction à seuil de ses entrées. Ce modèle montre qu’un réseau de tels neurones peut, en principe, calculer n’importe quelle fonction logique.

Le perceptron de Rosenblatt (1958). Frank Rosenblatt introduit le perceptron, le premier modèle doté d’un algorithme d’apprentissage automatique. Contrairement au modèle de McCulloch-Pitts dont les poids sont fixés à la main, le perceptron ajuste ses poids à partir des données. Rosenblatt démontre un théorème de convergence : si les données sont linéairement séparables, l’algorithme trouve une solution en un nombre fini d’itérations. L’enthousiasme est immense.

L’hiver de l’IA (1969–1980s). Marvin Minsky et Seymour Papert publient Perceptrons (1969), une analyse mathématique rigoureuse des limites du perceptron simple. Ils montrent qu’il ne peut pas apprendre la fonction XOR, ni aucune fonction non linéairement séparable. Cette démonstration, combinée à l’absence d’algorithme d’apprentissage efficace pour les réseaux multicouches, contribue à un tarissement des financements et de l’intérêt pour les réseaux de neurones.

La résurgence (1986–présent). La découverte de la rétropropagation du gradient (Rumelhart, Hinton et Williams, 1986) permet d’entraîner des perceptrons multicouches. Les progrès du calcul GPU, l’explosion des données disponibles et des architectures innovantes (réseaux convolutifs, récurrents, Transformers) ont conduit à la révolution actuelle de l”apprentissage profond. Nous y reviendrons dans les chapitres suivants.

Le neurone artificiel

Le neurone artificiel est l’unité de base de tout réseau de neurones. Son fonctionnement s’inspire — de manière simplifiée — du neurone biologique.

Définition 194 (Neurone artificiel)

Un neurone artificiel est une fonction \(f : \mathbb{R}^d \to \mathbb{R}\) définie par :

\[f(\mathbf{x}) = \varphi\!\left(\sum_{j=1}^d w_j x_j + b\right) = \varphi(\mathbf{w}^\top \mathbf{x} + b)\]

où :

• \(\mathbf{x} = (x_1, \ldots, x_d)^\top \in \mathbb{R}^d\) est le vecteur d’entrée,

• \(\mathbf{w} = (w_1, \ldots, w_d)^\top \in \mathbb{R}^d\) est le vecteur de poids (analogues de l’efficacité synaptique),

• \(b \in \mathbb{R}\) est le biais (analogue du seuil d’activation),

• \(\varphi : \mathbb{R} \to \mathbb{R}\) est la fonction d’activation.

Remarque 167

L’analogie biologique est la suivante : les entrées \(x_j\) correspondent aux signaux reçus par les dendrites ; les poids \(w_j\) à la force des connexions synaptiques ; la somme pondérée \(\mathbf{w}^\top \mathbf{x} + b\) à l’intégration dans le soma ; la fonction d’activation \(\varphi\) au mécanisme de déclenchement du potentiel d’action. Cette analogie est utile pour l’intuition, mais il faut garder à l’esprit que le neurone artificiel est une simplification drastique du neurone biologique.

Show code cell source

Hide code cell source

# Visualisation schématique d'un neurone artificiel
fig, ax = plt.subplots(figsize=(9, 5))
ax.set_xlim(-1, 11)
ax.set_ylim(-1, 7)
ax.set_aspect('equal')
ax.axis('off')

# Entrées
entrees = ['$x_1$', '$x_2$', '$x_3$', '$x_d$']
y_positions = [5.5, 4.0, 2.5, 0.5]
for i, (label, yp) in enumerate(zip(entrees, y_positions)):
    ax.plot(1, yp, 'o', color='steelblue', markersize=18, zorder=5)
    ax.text(0.2, yp, label, fontsize=14, ha='center', va='center')
    ax.annotate('', xy=(4.2, 3), xytext=(1.5, yp),
                arrowprops=dict(arrowstyle='->', color='gray', lw=1.5))
    w_label = f'$w_{i+1}$' if i < 3 else '$w_d$'
    mid_x = 2.8
    mid_y = (yp + 3) / 2 + 0.2
    ax.text(mid_x, mid_y, w_label, fontsize=10, color='coral', ha='center')

# Points de suspension
ax.text(0.2, 1.5, r'$\vdots$', fontsize=16, ha='center', va='center')

# Somme
circle = plt.Circle((5, 3), 0.8, color='#FFD700', ec='black', lw=2, zorder=5)
ax.add_patch(circle)
ax.text(5, 3, r'$\Sigma$', fontsize=18, ha='center', va='center', weight='bold')
ax.text(5, 1.8, '$+\\, b$', fontsize=11, ha='center', color='darkred')

# Activation
ax.annotate('', xy=(7.5, 3), xytext=(5.8, 3),
            arrowprops=dict(arrowstyle='->', color='black', lw=2))
rect = plt.Rectangle((7.5, 2.2), 1.5, 1.6, color='#55A868', ec='black',
                       lw=2, zorder=5, alpha=0.8)
ax.add_patch(rect)
ax.text(8.25, 3, r'$\varphi$', fontsize=18, ha='center', va='center',
        color='white', weight='bold')

# Sortie
ax.annotate('', xy=(10.5, 3), xytext=(9, 3),
            arrowprops=dict(arrowstyle='->', color='black', lw=2))
ax.text(10.8, 3, '$y$', fontsize=14, ha='center', va='center')

ax.set_title("Schéma d'un neurone artificiel", fontsize=14, pad=15)
plt.tight_layout()
plt.show()

Fonctions d’activation

Le choix de la fonction d’activation \(\varphi\) détermine le comportement du neurone et du réseau. Nous présentons les fonctions classiques, de la plus simple à la plus moderne.

Définition 195 (Fonction de Heaviside (seuil))

La fonction de Heaviside est définie par :

\[\begin{split}\varphi(z) = \mathbb{1}_{z \geq 0} = \begin{cases} 1 & \text{si } z \geq 0 \\ 0 & \text{si } z < 0 \end{cases}\end{split}\]

C’est la fonction d’activation originelle du perceptron. Elle produit une sortie binaire. Son principal défaut est de ne pas être dérivable (en \(z = 0\)), ce qui empêche l’utilisation de méthodes d’optimisation par gradient.

Définition 196 (Fonction sigmoïde)

La fonction sigmoïde (ou logistique) est définie par :

\[\sigma(z) = \frac{1}{1 + e^{-z}}\]

Elle est lisse, dérivable partout, bornée dans \((0, 1)\) et sa dérivée vaut \(\sigma'(z) = \sigma(z)(1 - \sigma(z))\). Elle souffre du problème de saturation : pour \(|z|\) grand, \(\sigma'(z) \approx 0\), ce qui ralentit l’apprentissage par gradient (vanishing gradient).

Définition 197 (Fonction tangente hyperbolique)

\[\tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}} = 2\sigma(2z) - 1\]

Elle est centrée en zéro (image dans \((-1, 1)\)), ce qui est un avantage par rapport à la sigmoïde. Cependant, elle souffre aussi de saturation aux extrêmes.

Définition 198 (Fonction ReLU et variantes)

La Rectified Linear Unit (ReLU) est définie par :

\[\text{ReLU}(z) = \max(0, z)\]

Leaky ReLU : \(\text{LeakyReLU}(z) = \max(\alpha z, z)\) avec \(\alpha \approx 0.01\), évitant les neurones « morts ».

ELU (Exponential Linear Unit) : \(\text{ELU}(z) = z\) si \(z > 0\), et \(\alpha(e^z - 1)\) sinon.

Swish/SiLU : \(\text{Swish}(z) = z \cdot \sigma(z)\), une activation lisse et non monotone qui a montré des performances supérieures dans certaines architectures profondes.

Définition 199 (Fonction softmax)

Pour un vecteur \(\mathbf{z} = (z_1, \ldots, z_K)^\top \in \mathbb{R}^K\), la softmax est définie par :

\[\text{softmax}(\mathbf{z})_k = \frac{e^{z_k}}{\sum_{j=1}^K e^{z_j}}, \quad k = 1, \ldots, K\]

Elle transforme un vecteur de scores en une distribution de probabilités (\(\sum_k \text{softmax}(\mathbf{z})_k = 1\)). Elle est utilisée en couche de sortie pour la classification multiclasse.

Remarque 168

Propriétés comparées des fonctions d’activation :

• Monotonie : toutes sont monotones sauf Swish.

• Dérivabilité : Heaviside n’est pas dérivable en 0 ; ReLU n’est pas dérivable en 0 (mais sous-dérivable) ; les autres sont \(C^\infty\).

• Saturation : sigmoïde et tanh saturent ; ReLU ne sature pas pour \(z > 0\) mais produit des neurones morts pour \(z < 0\) ; Leaky ReLU et ELU corrigent ce défaut.

• En pratique, ReLU est le choix par défaut pour les couches cachées, et softmax pour la couche de sortie en classification.

Show code cell source

Hide code cell source

# Graphes comparatifs des fonctions d'activation
z = np.linspace(-5, 5, 500)

def heaviside(z):
    return (z >= 0).astype(float)

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def relu(z):
    return np.maximum(0, z)

def leaky_relu(z, alpha=0.1):
    return np.where(z > 0, z, alpha * z)

def elu(z, alpha=1.0):
    return np.where(z > 0, z, alpha * (np.exp(z) - 1))

def swish(z):
    return z * sigmoid(z)

activations = [
    ("Heaviside", heaviside(z), '#4C72B0'),
    ("Sigmoïde", sigmoid(z), '#DD8452'),
    ("tanh", np.tanh(z), '#55A868'),
    ("ReLU", relu(z), '#C44E52'),
    ("Leaky ReLU", leaky_relu(z), '#8172B3'),
    ("ELU", elu(z), '#937860'),
    ("Swish/SiLU", swish(z), '#DA8BC3'),
]

fig, axes = plt.subplots(2, 4, figsize=(16, 7), sharex=True)
axes = axes.flatten()

for i, (name, values, color) in enumerate(activations):
    ax = axes[i]
    ax.plot(z, values, color=color, linewidth=2.2)
    ax.axhline(0, color='gray', linewidth=0.5, linestyle='--')
    ax.axvline(0, color='gray', linewidth=0.5, linestyle='--')
    ax.set_title(name, fontsize=12)
    ax.set_xlim(-5, 5)
    ax.set_xlabel("$z$")

# Graphe comparatif superposé
ax = axes[7]
for name, values, color in activations[1:]:  # sans Heaviside pour lisibilité
    ax.plot(z, values, color=color, linewidth=1.8, label=name)
ax.axhline(0, color='gray', linewidth=0.5, linestyle='--')
ax.axvline(0, color='gray', linewidth=0.5, linestyle='--')
ax.set_title("Comparaison", fontsize=12)
ax.legend(fontsize=7, loc='upper left')
ax.set_xlim(-5, 5)
ax.set_xlabel("$z$")

plt.suptitle("Fonctions d'activation", fontsize=14, y=1.02)
plt.tight_layout()
plt.show()

Show code cell source

Hide code cell source

# Dérivées des fonctions d'activation
def sigmoid_deriv(z):
    s = sigmoid(z)
    return s * (1 - s)

def tanh_deriv(z):
    return 1 - np.tanh(z)**2

def relu_deriv(z):
    return (z > 0).astype(float)

def leaky_relu_deriv(z, alpha=0.1):
    return np.where(z > 0, 1, alpha)

derivees = [
    ("Sigmoïde'", sigmoid_deriv(z), '#DD8452'),
    ("tanh'", tanh_deriv(z), '#55A868'),
    ("ReLU'", relu_deriv(z), '#C44E52'),
    ("Leaky ReLU'", leaky_relu_deriv(z), '#8172B3'),
]

fig, axes = plt.subplots(1, 4, figsize=(16, 3.5), sharex=True)
for i, (name, values, color) in enumerate(derivees):
    ax = axes[i]
    ax.plot(z, values, color=color, linewidth=2)
    ax.axhline(0, color='gray', linewidth=0.5, linestyle='--')
    ax.axvline(0, color='gray', linewidth=0.5, linestyle='--')
    ax.set_title(name, fontsize=12)
    ax.set_xlim(-5, 5)
    ax.set_xlabel("$z$")
plt.suptitle("Dérivées des fonctions d'activation", fontsize=14, y=1.05)
plt.tight_layout()
plt.show()

Le perceptron simple

Le perceptron simple est un classifieur binaire linéaire. Son algorithme d’apprentissage est l’un des premiers algorithmes d’apprentissage automatique.

Définition 200 (Perceptron simple)

Le perceptron simple est un classifieur binaire défini par :

\[\hat{y} = \text{signe}(\mathbf{w}^\top \mathbf{x} + b)\]

où \(\text{signe}(z) = +1\) si \(z \geq 0\) et \(-1\) sinon. La frontière de décision est l’hyperplan \(\{\mathbf{x} \in \mathbb{R}^d : \mathbf{w}^\top \mathbf{x} + b = 0\}\).

Algorithme d’apprentissage

Définition 201 (Algorithme d’apprentissage du perceptron)

Étant donné un jeu d’entraînement \(\{(\mathbf{x}_i, y_i)\}_{i=1}^n\) avec \(y_i \in \{-1, +1\}\) et un taux d’apprentissage \(\eta > 0\) :

1. Initialiser \(\mathbf{w} \leftarrow \mathbf{0}\), \(b \leftarrow 0\).

2. Répéter jusqu’à convergence :

   • Pour chaque \((\mathbf{x}_i, y_i)\) :

     • Calculer \(\hat{y}_i = \text{signe}(\mathbf{w}^\top \mathbf{x}_i + b)\).

     • Si \(\hat{y}_i \neq y_i\) (mauvaise classification) :

       • \(\mathbf{w} \leftarrow \mathbf{w} + \eta \, y_i \, \mathbf{x}_i\)

       • \(b \leftarrow b + \eta \, y_i\)

La règle de mise à jour pousse l’hyperplan dans la direction de l’observation mal classée.

Remarque 169

L’intuition de la règle de mise à jour est géométrique. Lorsqu’un point \(\mathbf{x}_i\) de classe \(y_i = +1\) est mal classé (c’est-à-dire \(\mathbf{w}^\top \mathbf{x}_i + b < 0\)), on ajoute \(\eta \mathbf{x}_i\) au vecteur de poids, ce qui « tourne » l’hyperplan vers \(\mathbf{x}_i\). Symétriquement, si \(y_i = -1\) et que le point est du mauvais côté, on soustrait \(\eta \mathbf{x}_i\).

Théorème de convergence du perceptron

Proposition 52 (Théorème de convergence du perceptron)

Soit \(\{(\mathbf{x}_i, y_i)\}_{i=1}^n\) un jeu de données linéairement séparable, c’est-à-dire qu’il existe \(\mathbf{w}^* \in \mathbb{R}^d\) avec \(\|\mathbf{w}^*\| = 1\) et une marge \(\gamma > 0\) tels que \(y_i (\mathbf{w}^{*\top} \mathbf{x}_i) \geq \gamma\) pour tout \(i\). Soit \(R = \max_i \|\mathbf{x}_i\|\). Alors l’algorithme du perceptron (avec \(\eta = 1\) et biais absorbé) fait au plus

\[\left\lfloor \frac{R^2}{\gamma^2} \right\rfloor\]

erreurs avant de converger.

Proof. Absorbons le biais en ajoutant une coordonnée constante 1 aux entrées : \(\tilde{\mathbf{x}}_i = (\mathbf{x}_i^\top, 1)^\top\) et \(\tilde{\mathbf{w}} = (\mathbf{w}^\top, b)^\top\). Notons \(\tilde{\mathbf{w}}^{(t)}\) le vecteur de poids après \(t\) mises à jour, avec \(\tilde{\mathbf{w}}^{(0)} = \mathbf{0}\). Soit \((\mathbf{x}_{i_t}, y_{i_t})\) le point mal classé à l’étape \(t\), de sorte que \(\tilde{\mathbf{w}}^{(t)} = \tilde{\mathbf{w}}^{(t-1)} + y_{i_t} \tilde{\mathbf{x}}_{i_t}\).

Borne inférieure (le vecteur de poids s’aligne avec la solution) :

\[\tilde{\mathbf{w}}^{*\top} \tilde{\mathbf{w}}^{(t)} = \tilde{\mathbf{w}}^{*\top} \tilde{\mathbf{w}}^{(t-1)} + y_{i_t} \tilde{\mathbf{w}}^{*\top} \tilde{\mathbf{x}}_{i_t} \geq \tilde{\mathbf{w}}^{*\top} \tilde{\mathbf{w}}^{(t-1)} + \gamma\]

Par récurrence : \(\tilde{\mathbf{w}}^{*\top} \tilde{\mathbf{w}}^{(t)} \geq t\gamma\). Par Cauchy-Schwarz : \(\|\tilde{\mathbf{w}}^{(t)}\| \geq t\gamma\).

Borne supérieure (la norme du vecteur de poids croît lentement) :

\[\|\tilde{\mathbf{w}}^{(t)}\|^2 = \|\tilde{\mathbf{w}}^{(t-1)}\|^2 + 2 y_{i_t} \tilde{\mathbf{w}}^{(t-1)\top} \tilde{\mathbf{x}}_{i_t} + \|\tilde{\mathbf{x}}_{i_t}\|^2\]

Comme le point est mal classé, \(y_{i_t} \tilde{\mathbf{w}}^{(t-1)\top} \tilde{\mathbf{x}}_{i_t} \leq 0\), donc \(\|\tilde{\mathbf{w}}^{(t)}\|^2 \leq \|\tilde{\mathbf{w}}^{(t-1)}\|^2 + R^2\). Par récurrence : \(\|\tilde{\mathbf{w}}^{(t)}\|^2 \leq t R^2\).

Conclusion. En combinant : \(t^2 \gamma^2 \leq \|\tilde{\mathbf{w}}^{(t)}\|^2 \leq t R^2\), d’où \(t \leq R^2 / \gamma^2\).

Implémentation from scratch

Show code cell source

Hide code cell source

class Perceptron:
    """Perceptron simple implémenté from scratch."""

    def __init__(self, eta=1.0, max_iter=1000):
        self.eta = eta
        self.max_iter = max_iter

    def fit(self, X, y):
        n, d = X.shape
        self.w = np.zeros(d)
        self.b = 0.0
        self.errors_per_epoch = []

        for epoch in range(self.max_iter):
            errors = 0
            for i in range(n):
                y_hat = np.sign(self.w @ X[i] + self.b)
                if y_hat == 0:
                    y_hat = -1
                if y_hat != y[i]:
                    self.w += self.eta * y[i] * X[i]
                    self.b += self.eta * y[i]
                    errors += 1
            self.errors_per_epoch.append(errors)
            if errors == 0:
                break
        return self

    def predict(self, X):
        activation = X @ self.w + self.b
        return np.where(activation >= 0, 1, -1)

    def score(self, X, y):
        return np.mean(self.predict(X) == y)

Show code cell source

Hide code cell source

# Données linéairement séparables
from sklearn.datasets import make_blobs

X_sep, y_sep = make_blobs(n_samples=200, centers=2, cluster_std=1.0,
                            random_state=42)
y_sep = 2 * y_sep - 1  # conversion en {-1, +1}

perc = Perceptron(eta=1.0, max_iter=100)
perc.fit(X_sep, y_sep)

print(f"Convergence en {len(perc.errors_per_epoch)} époques")
print(f"Précision sur l'entraînement : {perc.score(X_sep, y_sep):.2%}")

Convergence en 2 époques
Précision sur l'entraînement : 100.00%

Show code cell source

Hide code cell source

def plot_decision_boundary(model, X, y, ax, title="", resolution=0.02):
    """Trace la frontière de décision d'un classifieur."""
    cmap_bg = ListedColormap(['#FDDBC7', '#D1E5F0'])
    cmap_pts = ListedColormap(['#D6604D', '#4393C3'])

    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, resolution),
                          np.arange(y_min, y_max, resolution))
    grid = np.c_[xx.ravel(), yy.ravel()]

    if hasattr(model, 'predict'):
        Z = model.predict(grid)
    else:
        Z = model(grid)
    Z = Z.reshape(xx.shape)

    ax.contourf(xx, yy, Z, alpha=0.3, cmap=cmap_bg)
    ax.scatter(X[y == -1, 0], X[y == -1, 1], c='#D6604D', edgecolors='k',
               linewidths=0.5, s=30, label='Classe -1')
    ax.scatter(X[y == 1, 0], X[y == 1, 1], c='#4393C3', edgecolors='k',
               linewidths=0.5, s=30, label='Classe +1')
    ax.set_title(title, fontsize=12)
    ax.legend(fontsize=8)

fig, axes = plt.subplots(2, 1, figsize=(9, 9))

plot_decision_boundary(perc, X_sep, y_sep, axes[0],
                        title="Perceptron --- frontière de décision")

axes[1].plot(perc.errors_per_epoch, 'o-', color='steelblue', markersize=4)
axes[1].set_xlabel("Époque")
axes[1].set_ylabel("Nombre d'erreurs")
axes[1].set_title("Convergence de l'algorithme du perceptron")
plt.tight_layout()
plt.show()

Limitations du perceptron simple

Le perceptron simple ne peut apprendre que des frontières de décision linéaires. Cette limitation a été formalisée de manière célèbre par Minsky et Papert.

Le problème XOR

Proposition 53 (Impossibilité du XOR par un perceptron simple)

La fonction XOR, définie sur \(\{0, 1\}^2\) par :

\(x_1\)	\(x_2\)	\(x_1 \oplus x_2\)
0	0	0
0	1	1
1	0	1
1	1	0

n’est pas linéairement séparable et ne peut donc pas être apprise par un perceptron simple.

Proof. Supposons par l’absurde qu’il existe \(w_1, w_2, b \in \mathbb{R}\) tels que le perceptron \(\hat{y} = \text{signe}(w_1 x_1 + w_2 x_2 + b)\) calcule le XOR. Alors :

1. \((0,0) \to -1\) : \(b < 0\)

2. \((0,1) \to +1\) : \(w_2 + b \geq 0\), soit \(w_2 \geq -b > 0\)

3. \((1,0) \to +1\) : \(w_1 + b \geq 0\), soit \(w_1 \geq -b > 0\)

4. \((1,1) \to -1\) : \(w_1 + w_2 + b < 0\)

De (2) et (3) : \(w_1 + w_2 \geq -2b > 0\). Mais (4) exige \(w_1 + w_2 < -b\), donc \(-2b \leq w_1 + w_2 < -b\), ce qui donne \(-2b < -b\), soit \(b > 0\). Contradiction avec (1). Aucun hyperplan ne sépare les quatre points. \(\square\)

Show code cell source

Hide code cell source

# Visualisation du problème XOR
X_xor = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_xor = np.array([-1, 1, 1, -1])

perc_xor = Perceptron(eta=1.0, max_iter=100)
perc_xor.fit(X_xor, y_xor)

fig, axes = plt.subplots(2, 1, figsize=(9, 9))

# XOR : pas de frontière linéaire possible
ax = axes[0]
ax.scatter(X_xor[y_xor == 1, 0], X_xor[y_xor == 1, 1], c='#4393C3',
           s=200, edgecolors='k', linewidths=1.5, zorder=5, label='Classe +1')
ax.scatter(X_xor[y_xor == -1, 0], X_xor[y_xor == -1, 1], c='#D6604D',
           s=200, edgecolors='k', linewidths=1.5, zorder=5, label='Classe -1')
ax.set_title("Problème XOR --- pas de séparation linéaire", fontsize=12)
ax.set_xlim(-0.5, 1.5)
ax.set_ylim(-0.5, 1.5)
ax.set_xlabel("$x_1$")
ax.set_ylabel("$x_2$")
ax.legend(fontsize=10)
ax.set_aspect('equal')

# Tentatives de droites séparatrices (aucune ne fonctionne)
xx = np.linspace(-0.5, 1.5, 100)
for slope, intercept, ls in [(-1.0, 0.8, '--'), (1.0, -0.2, '-.'), (0, 0.5, ':')]:
    ax.plot(xx, slope * xx + intercept, linestyle=ls, color='gray', alpha=0.6)

# Courbe d'erreurs : le perceptron ne converge jamais
ax = axes[1]
ax.plot(perc_xor.errors_per_epoch, 'o-', color='coral', markersize=3)
ax.set_xlabel("Époque")
ax.set_ylabel("Nombre d'erreurs")
ax.set_title("Perceptron sur XOR --- pas de convergence", fontsize=12)
ax.axhline(0, color='gray', linestyle='--', linewidth=0.5)
plt.tight_layout()
plt.show()

Remarque 170

Le résultat de Minsky et Papert ne concerne que le perceptron simple (sans couche cachée). Un réseau avec une seule couche cachée de deux neurones suffit à résoudre le XOR. Cette observation est la motivation centrale du perceptron multicouche.

Perceptron multicouche (MLP)

Pour dépasser les limitations du perceptron simple, on empile plusieurs couches de neurones. Le modèle résultant — le perceptron multicouche — est capable d’apprendre des frontières de décision arbitrairement complexes.

Architecture

Définition 202 (Perceptron multicouche)

Un perceptron multicouche (MLP, Multi-Layer Perceptron) est un réseau de neurones organisé en couches :

• Une couche d’entrée de \(d\) neurones (les features).

• Une ou plusieurs couches cachées de \(h_1, h_2, \ldots, h_L\) neurones.

• Une couche de sortie de \(K\) neurones (\(K = 1\) pour la classification binaire, \(K\) classes pour la multiclasse).

Chaque neurone d’une couche est connecté à tous les neurones de la couche suivante (réseau entièrement connecté ou fully connected). L’information se propage de la couche d’entrée vers la sortie : on parle de réseau feedforward.

Notation matricielle

Définition 203 (Propagation avant (forward pass))

Notons \(\mathbf{a}^{(0)} = \mathbf{x}\) l’entrée. Pour la couche \(\ell = 1, \ldots, L+1\) :

\[\mathbf{z}^{(\ell)} = \mathbf{W}^{(\ell)} \mathbf{a}^{(\ell-1)} + \mathbf{b}^{(\ell)}\]

\[\mathbf{a}^{(\ell)} = \varphi^{(\ell)}(\mathbf{z}^{(\ell)})\]

où \(\mathbf{W}^{(\ell)} \in \mathbb{R}^{h_\ell \times h_{\ell-1}}\) est la matrice de poids, \(\mathbf{b}^{(\ell)} \in \mathbb{R}^{h_\ell}\) le vecteur de biais, et \(\varphi^{(\ell)}\) la fonction d’activation de la couche \(\ell\). La sortie du réseau est \(\hat{\mathbf{y}} = \mathbf{a}^{(L+1)}\).

Remarque 171

Le nombre total de paramètres d’un MLP à couches \(d, h_1, h_2, \ldots, h_L, K\) est :

\[\sum_{\ell=1}^{L+1} (h_{\ell-1} \cdot h_\ell + h_\ell)\]

Par exemple, un réseau \(784 \to 256 \to 128 \to 10\) possède \(784 \times 256 + 256 + 256 \times 128 + 128 + 128 \times 10 + 10 = 235\,146\) paramètres.

Théorème d’approximation universelle

Proposition 54 (Théorème d’approximation universelle (Cybenko, 1989 ; Hornik, 1991))

Soit \(\varphi\) une fonction d’activation continue, bornée et non constante (par exemple, la sigmoïde). Alors, pour toute fonction continue \(f : [0, 1]^d \to \mathbb{R}\) et pour tout \(\varepsilon > 0\), il existe un réseau à une seule couche cachée avec un nombre fini de neurones tel que

\[\sup_{\mathbf{x} \in [0, 1]^d} |f(\mathbf{x}) - \hat{f}(\mathbf{x})| < \varepsilon\]

Autrement dit, un MLP à une couche cachée est un approximateur universel : il peut approximer toute fonction continue à une précision arbitraire, pourvu que la couche cachée soit suffisamment large.

Remarque 172

Ce théorème est un résultat d”existence : il garantit qu’une solution existe, mais ne dit rien sur la manière de la trouver (algorithme d’apprentissage) ni sur le nombre de neurones nécessaires (qui peut être exponentiellement grand). En pratique, les réseaux profonds (plusieurs couches) atteignent de meilleures performances avec moins de paramètres que les réseaux larges et peu profonds, grâce à la composition hiérarchique de représentations.

Show code cell source

Hide code cell source

# Résolution du XOR avec un MLP à une couche cachée (à la main)
# Architecture : 2 -> 2 -> 1

# Poids choisis manuellement pour résoudre XOR
# Couche cachée : neurone 1 = OR, neurone 2 = AND
W1 = np.array([[1, 1],
               [1, 1]])
b1 = np.array([-0.5, -1.5])  # seuils pour OR et AND

# Couche de sortie : OR et NOT AND
W2 = np.array([[1, -2]])
b2 = np.array([-0.5])

def mlp_xor(X):
    """MLP à deux couches résolvant le XOR."""
    z1 = X @ W1.T + b1
    a1 = (z1 > 0).astype(float)  # Heaviside
    z2 = a1 @ W2.T + b2
    return np.where(z2 >= 0, 1, -1).ravel()

print("Vérification du MLP sur XOR :")
for x, y_true in zip(X_xor, y_xor):
    y_pred = mlp_xor(x.reshape(1, -1))[0]
    print(f"  x = {x}  ->  y_pred = {y_pred:+d}  (attendu : {y_true:+d})"
          f"  {'ok' if y_pred == y_true else 'ERREUR'}")

Vérification du MLP sur XOR :
  x = [0 0]  ->  y_pred = -1  (attendu : -1)  ok
  x = [0 1]  ->  y_pred = +1  (attendu : +1)  ok
  x = [1 0]  ->  y_pred = +1  (attendu : +1)  ok
  x = [1 1]  ->  y_pred = -1  (attendu : -1)  ok

Show code cell source

Hide code cell source

# Visualisation de la résolution du XOR par le MLP
fig, axes = plt.subplots(3, 1, figsize=(9, 12))

# Neurone 1 : OR
ax = axes[0]
resolution = 0.01
xx, yy = np.meshgrid(np.arange(-0.5, 1.6, resolution),
                      np.arange(-0.5, 1.6, resolution))
grid = np.c_[xx.ravel(), yy.ravel()]
Z_or = (grid @ W1[0] + b1[0] > 0).astype(float).reshape(xx.shape)
ax.contourf(xx, yy, Z_or, alpha=0.3, cmap='Blues')
ax.scatter(X_xor[:, 0], X_xor[:, 1], c=['#D6604D', '#4393C3', '#4393C3', '#4393C3'],
           s=200, edgecolors='k', linewidths=1.5, zorder=5)
ax.set_title("Neurone caché 1 (OR)", fontsize=11)
ax.set_xlabel("$x_1$"); ax.set_ylabel("$x_2$")
ax.set_aspect('equal')

# Neurone 2 : AND
ax = axes[1]
Z_and = (grid @ W1[1] + b1[1] > 0).astype(float).reshape(xx.shape)
ax.contourf(xx, yy, Z_and, alpha=0.3, cmap='Oranges')
ax.scatter(X_xor[:, 0], X_xor[:, 1], c=['#D6604D', '#D6604D', '#D6604D', '#4393C3'],
           s=200, edgecolors='k', linewidths=1.5, zorder=5)
ax.set_title("Neurone caché 2 (AND)", fontsize=11)
ax.set_xlabel("$x_1$"); ax.set_ylabel("$x_2$")
ax.set_aspect('equal')

# Sortie : XOR = OR AND NOT AND
ax = axes[2]
Z_xor = mlp_xor(grid).reshape(xx.shape)
ax.contourf(xx, yy, Z_xor, alpha=0.3, cmap=ListedColormap(['#FDDBC7', '#D1E5F0']))
ax.scatter(X_xor[y_xor == 1, 0], X_xor[y_xor == 1, 1], c='#4393C3',
           s=200, edgecolors='k', linewidths=1.5, zorder=5, label='+1')
ax.scatter(X_xor[y_xor == -1, 0], X_xor[y_xor == -1, 1], c='#D6604D',
           s=200, edgecolors='k', linewidths=1.5, zorder=5, label='-1')
ax.set_title("Sortie du MLP (XOR)", fontsize=11)
ax.set_xlabel("$x_1$"); ax.set_ylabel("$x_2$")
ax.set_aspect('equal')
ax.legend(fontsize=9)

plt.suptitle("Décomposition du XOR par un MLP à 2 neurones cachés", fontsize=13, y=1.03)
plt.tight_layout()
plt.show()

Exemple pratique : MLPClassifier de Scikit-learn

Passons à une mise en oeuvre avec MLPClassifier de Scikit-learn sur un jeu de données non linéairement séparable, pour montrer la puissance du perceptron multicouche.

Show code cell source

Hide code cell source

from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_moons, make_circles
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score

# Jeu de données en forme de lunes (non linéairement séparable)
X_moons, y_moons = make_moons(n_samples=600, noise=0.25, random_state=42)
y_moons_signed = 2 * y_moons - 1  # conversion en {-1, +1}

X_train, X_test, y_train, y_test = train_test_split(
    X_moons, y_moons_signed, test_size=0.3, random_state=42)

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

print(f"Entraînement : {X_train_sc.shape[0]} échantillons")
print(f"Test :          {X_test_sc.shape[0]} échantillons")

Entraînement : 420 échantillons
Test :          180 échantillons

Show code cell source

Hide code cell source

# Influence du nombre de neurones et de couches
architectures = [
    (5,),
    (20,),
    (50,),
    (20, 10),
    (50, 30),
    (50, 30, 10),
]

fig, axes = plt.subplots(2, 3, figsize=(16, 10))
axes = axes.flatten()

for i, hidden in enumerate(architectures):
    mlp = MLPClassifier(hidden_layer_sizes=hidden, activation='relu',
                         max_iter=2000, random_state=42)
    mlp.fit(X_train_sc, y_train)
    acc_train = mlp.score(X_train_sc, y_train)
    acc_test = mlp.score(X_test_sc, y_test)

    ax = axes[i]
    # Frontière de décision
    x_min, x_max = X_train_sc[:, 0].min() - 0.5, X_train_sc[:, 0].max() + 0.5
    y_min, y_max = X_train_sc[:, 1].min() - 0.5, X_train_sc[:, 1].max() + 0.5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                          np.arange(y_min, y_max, 0.02))
    Z = mlp.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
    ax.contourf(xx, yy, Z, alpha=0.3,
                cmap=ListedColormap(['#FDDBC7', '#D1E5F0']))
    ax.scatter(X_train_sc[y_train == -1, 0], X_train_sc[y_train == -1, 1],
               c='#D6604D', s=10, alpha=0.6)
    ax.scatter(X_train_sc[y_train == 1, 0], X_train_sc[y_train == 1, 1],
               c='#4393C3', s=10, alpha=0.6)
    ax.set_title(f"Couches : {hidden}\n"
                 f"Train : {acc_train:.1%} | Test : {acc_test:.1%}",
                 fontsize=10)
    ax.set_xlabel("$x_1$"); ax.set_ylabel("$x_2$")

plt.suptitle("Influence de l'architecture du MLP sur la frontière de décision",
             fontsize=14, y=1.02)
plt.tight_layout()
plt.show()

Remarque 173

On observe que même un MLP avec une seule couche cachée de 5 neurones capture déjà la forme non linéaire des données. En augmentant le nombre de neurones et de couches, la frontière de décision devient plus flexible, mais le risque de surapprentissage augmente. En pratique, on contrôle ce risque par la régularisation (paramètre alpha dans Scikit-learn), le early stopping ou le dropout (abordé dans les chapitres suivants).

Show code cell source

Hide code cell source

# Courbe d'apprentissage : évolution de la perte
mlp_track = MLPClassifier(hidden_layer_sizes=(50, 30), activation='relu',
                            max_iter=500, random_state=42)
mlp_track.fit(X_train_sc, y_train)

fig, ax = plt.subplots(figsize=(9, 5))
ax.plot(mlp_track.loss_curve_, color='steelblue', linewidth=2)
ax.set_xlabel("Itération")
ax.set_ylabel("Perte (log-loss)")
ax.set_title("Courbe de perte du MLP (50, 30) sur les données 'moons'")
ax.set_yscale('log')
plt.tight_layout()
plt.show()

print(f"Précision finale --- Train : {mlp_track.score(X_train_sc, y_train):.2%}"
      f" | Test : {mlp_track.score(X_test_sc, y_test):.2%}")

Précision finale --- Train : 95.71% | Test : 94.44%

Show code cell source

Hide code cell source

# Comparaison sur un second jeu : cercles concentriques
X_circles, y_circles = make_circles(n_samples=600, noise=0.1,
                                      factor=0.4, random_state=42)
y_circles_signed = 2 * y_circles - 1

X_tr_c, X_te_c, y_tr_c, y_te_c = train_test_split(
    X_circles, y_circles_signed, test_size=0.3, random_state=42)

scaler_c = StandardScaler()
X_tr_cs = scaler_c.fit_transform(X_tr_c)
X_te_cs = scaler_c.transform(X_te_c)

fig, axes = plt.subplots(3, 1, figsize=(9, 12))

# Perceptron simple
perc_c = Perceptron(eta=1.0, max_iter=100)
perc_c.fit(X_tr_cs, y_tr_c)
plot_decision_boundary(perc_c, X_tr_cs, y_tr_c, axes[0],
                        title=f"Perceptron simple\n"
                              f"Acc : {perc_c.score(X_te_cs, y_te_c):.1%}")

# MLP (20,)
mlp_c1 = MLPClassifier(hidden_layer_sizes=(20,), activation='relu',
                         max_iter=2000, random_state=42)
mlp_c1.fit(X_tr_cs, y_tr_c)
plot_decision_boundary(mlp_c1, X_tr_cs, y_tr_c, axes[1],
                        title=f"MLP (20,)\n"
                              f"Acc : {mlp_c1.score(X_te_cs, y_te_c):.1%}")

# MLP (50, 30)
mlp_c2 = MLPClassifier(hidden_layer_sizes=(50, 30), activation='relu',
                         max_iter=2000, random_state=42)
mlp_c2.fit(X_tr_cs, y_tr_c)
plot_decision_boundary(mlp_c2, X_tr_cs, y_tr_c, axes[2],
                        title=f"MLP (50, 30)\n"
                              f"Acc : {mlp_c2.score(X_te_cs, y_te_c):.1%}")

plt.suptitle("Perceptron simple vs MLP sur les cercles concentriques",
             fontsize=13, y=1.03)
plt.tight_layout()
plt.show()

Exemple 17 (Interprétation des résultats)

Sur les cercles concentriques, le perceptron simple est incapable de séparer les deux classes (frontière linéaire dans un problème circulaire). Le MLP avec une couche de 20 neurones capture déjà la structure circulaire, et le MLP à deux couches (50, 30) produit une frontière de décision très propre. Cela illustre concrètement la puissance de la non-linéarité introduite par les couches cachées.

Du perceptron au deep learning

Ce chapitre a posé les fondations de l’architecture neuronale : du neurone artificiel unique au perceptron multicouche. Le chemin vers le deep learning passe par plusieurs étapes que nous aborderons dans les chapitres suivants :

1. Rétropropagation et optimisation (chapitre 17) : l’algorithme de rétropropagation du gradient permet d’entraîner efficacement un MLP en calculant les gradients de la fonction de perte par rapport à chaque poids, couche par couche. Nous y étudierons aussi les optimiseurs modernes (SGD avec momentum, Adam, etc.) et les techniques de régularisation (dropout, batch normalization).

2. Frameworks : PyTorch (chapitre 18) : les bibliothèques de deep learning (PyTorch, TensorFlow) automatisent la différentiation, gèrent le calcul sur GPU et fournissent des abstractions de haut niveau pour construire, entraîner et déployer des réseaux.

3. Au-delà du MLP : les réseaux convolutifs (chapitre 19) exploitent la structure spatiale des images ; les réseaux récurrents (chapitre 20) traitent les séquences ; les Transformers (chapitre 23) révolutionnent le traitement du langage naturel.

Remarque 174

Le perceptron multicouche, malgré sa simplicité relative, reste un composant fondamental des architectures modernes. Les couches entièrement connectées (fully connected ou dense) sont présentes dans presque tous les réseaux profonds, au moins en couche de sortie. Comprendre le MLP est donc un prérequis essentiel pour aborder le deep learning.

Résumé

Ce chapitre a couvert les fondations des réseaux de neurones :

1. Le neurone artificiel modélise une unité de calcul simple : somme pondérée, biais et fonction d’activation.

2. Les fonctions d’activation (Heaviside, sigmoïde, tanh, ReLU, Leaky ReLU, ELU, Swish, softmax) déterminent le comportement non linéaire du réseau. Le choix de ReLU pour les couches cachées et de softmax pour la sortie en classification est devenu standard.

3. Le perceptron simple apprend une frontière linéaire. Le théorème de convergence garantit qu’il trouve une solution si les données sont linéairement séparables, en au plus \(R^2/\gamma^2\) mises à jour.

4. Les limitations du perceptron simple (impossibilité du XOR) motivent le passage au perceptron multicouche.

5. Le perceptron multicouche (MLP), grâce aux couches cachées et aux fonctions d’activation non linéaires, est un approximateur universel capable d’apprendre des frontières de décision arbitrairement complexes.

6. L’entraînement du MLP par rétropropagation du gradient sera l’objet du chapitre suivant.