Une seule frontière linéaire ne peut résoudre que les problèmes dont les classes sont **linéairement séparables**, c'est-à-dire séparables par une unique coupe droite. Beaucoup de problèmes simples le sont, mais pas tous. Le contre-exemple classique est la fonction ou exclusif (XOR) de deux entrées binaires.

Les tables de vérité ci-dessous comparent AND, OR et XOR :

| $x_1$ | $x_2$ | AND | OR | XOR |

| --- | --- | --- | --- | --- |

| 0 | 0 | 0 | 0 | 0 |

| 0 | 1 | 0 | 1 | 1 |

| 1 | 0 | 0 | 1 | 1 |

| 1 | 1 | 1 | 1 | 0 |


Pour AND et OR les deux classes de sortie peuvent être séparées par une seule droite, donc un perceptron les résout. Pour XOR les points positifs $(0,1)$ et $(1,0)$ sont sur une diagonale et les points négatifs $(0,0)$ et $(1,1)$ sur l'autre. Aucune droite unique ne peut les séparer.

*Remarque :* XOR n'est pas une curiosité isolée. Il montre que certains motifs sont intrinsèquement non linéaires, donc tout modèle construit à partir d'une seule frontière linéaire est fondamentalement limité. La solution consiste à combiner plusieurs unités.

Si l'on place une couche d'unités entre l'entrée et la sortie, les premières unités peuvent découper l'espace avec plusieurs frontières et une unité ultérieure peut combiner leurs sorties. Deux droites peuvent isoler le motif XOR là où une seule n'y parvient pas. Cette couche intermédiaire est une **couche cachée**, et c'est elle qui transforme une unité unique en réseau.

Empiler des unités en couches, et des couches en un pipeline, donne un **réseau de neurones**. Un réseau est **profond** lorsqu'il possède plus d'une couche cachée entre l'entrée et la sortie. Chaque couche applique une application linéaire suivie d'une activation non linéaire, et les couches sont composées de sorte que la sortie de l'une alimente l'entrée de la suivante.

Le bénéfice est l'**apprentissage de représentations**. En apprentissage automatique classique, on conçoit les caractéristiques à la main, puis on les fournit à un modèle linéaire. Dans un réseau profond, les couches cachées apprennent leurs propres caractéristiques à partir de l'entrée brute : les premières couches capturent des motifs simples et les couches ultérieures les combinent en motifs plus abstraits. On spécifie l'architecture et l'objectif, et le réseau découvre les représentations intermédiaires par l'entraînement.

Avec un biais explicite, une unité possède un vecteur de poids $w$ et un biais scalaire $b$. Son activation est :

$$\boxed{ a = g(w^T x + b) }$$

Regroupons les unités de la couche $l$ dans une matrice de poids $W^{[l]}$ et un vecteur de biais $b^{[l]}$. La couche calcule une pré-activation $z^{[l]}$, puis une activation $a^{[l]}$ :

$$\boxed{ z^{[l]} = W^{[l]} a^{[l-1]} + b^{[l]}, \quad a^{[l]} = g^{[l]}(z^{[l]}) }$$

L'entrée alimente la première couche par $a^{[0]} = x$, et pour un réseau à $L$ couches la prédiction est la dernière activation :

$$\boxed{ a^{[0]} = x, \quad \hat{y} = a^{[L]} }$$

Ainsi le réseau est une composition d'applications de couches : $x = a^{[0]} \mapsto a^{[1]} \mapsto \cdots \mapsto a^{[L]} = \hat{y}$.

| Symbole | Signification | Forme |

| --- | --- | --- |

| $L$ | nombre de couches | scalaire |

| $n_l$ | nombre d'unités dans la couche $l$ | scalaire |

| $W^{[l]}$ | matrice de poids de la couche $l$ | $n_l \times n_{l-1}$ |

| $b^{[l]}$ | vecteur de biais de la couche $l$ | $n_l$ |

| $z^{[l]}$ | pré-activation de la couche $l$ | $n_l$ |

| $a^{[l]}$ | activation de la couche $l$ | $n_l$ |

| $g^{[l]}$ | fonction d'activation de la couche $l$ | appliquée élément par élément |

| $\hat{y}$ | prédiction, égale à $a^{[L]}$ | $n_L$ |

*Remarque :* l'activation $g^{[l]}$ agit composante par composante, donc un produit élément par élément plus loin s'écrit avec le symbole de Hadamard $\odot$. L'exposant entre crochets, $[l]$, indexe la couche, ce n'est pas une puissance.

Le schéma suivant montre le plus petit réseau utile : une couche d'entrée, une couche cachée et une couche de sortie.


Chaque flèche porte un poids issu de $W^{[l]}$, et chaque unité cachée et de sortie ajoute son biais issu de $b^{[l]}$ avant d'appliquer son activation. Cette couche cachée à deux unités est exactement ce qui permet au réseau de résoudre XOR, la tâche qui mettait en échec une unité unique.

---