1. Introduction
Ce cours prolonge directement le cours de Machine Learning, qui concluait la partie Classification linéaire sur une remarque clé : un perceptron est une unité unique, et empilé en couches il devient un réseau de neurones. Cette leçon rend ce pont explicite. Elle rappelle ce qu'une seule unité peut faire, montre la tâche concrète (XOR) où une unité unique échoue, et fixe la notation utilisée dans tout le reste du cours.
Objectifs
- Rappeler le perceptron comme une unité unique avec une activation en marche d'escalier et une frontière linéaire.
- Comprendre pourquoi une seule unité ne peut pas résoudre XOR, ce qui motive les couches cachées.
- Comprendre ce que signifie « profond » et pourquoi les couches cachées apprennent des caractéristiques.
- Adopter la notation à biais explicite, par couche, utilisée tout au long de ce cours.
- Lire un réseau comme une composition d'applications de couches, de l'entrée à la prédiction.
1.1 Le perceptron, rappel
Le perceptron du cours de Machine Learning est une unité de calcul unique. Il attribue un score à une entrée par une combinaison linéaire de ses caractéristiques et fait passer ce score par un seuil dur. Avec les paramètres \(w\) et l'activation en marche d'escalier \(g\), son hypothèse est :
\[\boxed{ h(x) = g(w^T x), \quad g(z) = \begin{cases} 1 & \text{if } z \ge 0 \\ 0 & \text{otherwise} \end{cases} }\]L'équation \(w^T x = 0\) est un hyperplan, donc le perceptron sépare l'espace d'entrée par une seule frontière plane. Les points d'un côté reçoivent l'étiquette \(1\), les points de l'autre côté reçoivent l'étiquette \(0\).
Remarque : la frontière est linéaire parce que le score \(w^T x\) est linéaire en \(x\). Le seuil ne fait que choisir un côté, il ne courbe pas la frontière.
1.2 Pourquoi une seule unité ne suffit pas
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 |
AND et OR sont séparables par une seule droite, mais XOR ne l'est pas, et c'est pourquoi une seule unité ne peut pas le résoudre.
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.
1.3 Des unités aux réseaux
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.
Remarque : empiler des applications linéaires seules reviendrait à une seule application linéaire, donc l'activation non linéaire \(g\) entre les couches est essentielle. Sans elle, aucune profondeur n'ajouterait de puissance expressive. Les fonctions d'activation sont traitées dans les leçons suivantes.
1.4 Notation pour ce cours
Le cours de Machine Learning intégrait le biais dans le score avec la convention d'ordonnée à l'origine \(x_0 = 1\), de sorte qu'un seul produit scalaire \(w^T x\) portait le terme constant. Ce cours garde le biais explicite et utilise une matrice de poids distincte par couche. C'est la couture entre les deux cours : à partir d'ici, plus d'entrée augmentée et plus de biais intégré.
1.4.1 Une unité unique
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) }\]Le score \(w^T x + b\) est la même fonction affine qu'auparavant, sauf que le biais \(b\) est maintenant écrit explicitement au lieu d'être caché dans \(w\).
1.4.2 Une couche et un réseau
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}\).
1.4.3 Table des symboles
| 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.
Un réseau de neurones : une couche d'entrée, une couche cachée et une sortie. Chaque arête porte un poids et chaque unité ajoute un biais puis applique une activation g.
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.
La prochaine leçon formalise cette image sous la forme du perceptron multicouche, en écrivant la passe avant complète couche par couche et en choisissant les fonctions d'activation.
Suivant : Perceptron multicouche · Vue d'ensemble du cours