Accueil – Chapitre approfondi 1

À la fin de ce chapitre, tu sauras : ce qu’est un perceptron et un neurone sigmoïde, pourquoi la sigmoïde permet l’apprentissage, l’architecture des réseaux (entrée, cachée, sortie), la descente de gradient et la SGD, et comment implémenter un réseau pour les chiffres manuscrits.

Bienvenue dans le chapitre approfondi 1. Ce chapitre reprend en détail ce que le chapitre 1 présente de façon plus simple : les fondements des réseaux de neurones pour la reconnaissance des chiffres manuscrits. On y détaille les perceptrons, les neurones sigmoïdes, l’architecture des réseaux, la descente de gradient et la stochastic gradient descent, puis l’implémentation (code, résultats, hyperparamètres) et une ouverture vers le deep learning. La rétropropagation (comment le gradient est calculé) est abordée au chapitre 4 et 5, et encore plus en détail dans le chapitre approfondi 2.

Parcours du chapitre (en une image)

Perceptrons Sigmoïdes Architecture Descente ∇ Implémentation

En résumé : Ce chapitre approfondi couvre perceptrons, sigmoïdes, architecture, coût quadratique, descente de gradient, SGD, implémentation et ouverture vers le deep learning. Tu peux suivre le parcours avec le bouton « Étape suivante ».

Lexique

Objectif : Connaître les termes du chapitre (perceptron, seuil, biais, sigmoïde, couches, feedforward, fonction de coût, gradient, SGD, mini-batch, époque).

Perceptron
Neurone artificiel à entrées binaires : il calcule la somme pondérée w·x, la compare à un seuil (ou au biais b = −seuil), et sort 0 ou 1 selon que w·x + b ≤ 0 ou > 0.
Seuil
Valeur à partir de laquelle le perceptron « s’allume » (sortie 1). On peut remplacer le seuil par le biais b = −seuil : sortie 1 si w·x + b > 0.
Biais
Nombre b tel que la règle du perceptron s’écrit : sortie 1 si w·x + b > 0, sinon 0. Plus b est grand, plus il est facile d’obtenir une sortie 1.
Neurone sigmoïde
Comme le perceptron mais la sortie est σ(z) = 1/(1+e−z) avec z = w·x + b, donc une valeur entre 0 et 1. Un petit changement de poids entraîne un petit changement de sortie (nécessaire pour l’apprentissage).
σ(z) (sigmoïde)
Fonction σ(z) = 1/(1+e−z). Pour z grand positif, σ(z) ≈ 1 ; pour z grand négatif, σ(z) ≈ 0. C’est une version « lisse » du seuil du perceptron.
Couche d’entrée / cachée / sortie
Entrée : neurones qui reçoivent les données (ex. pixels). Cachée : neurones entre entrée et sortie. Sortie : neurones dont les valeurs donnent la réponse du réseau.
Feedforward
Réseau sans boucle : l’information va des entrées vers les sorties, couche par couche.
Fonction de coût (quadratique / MSE)
Mesure de l’erreur : C(w,b) = (1/2n) Σx ‖y(x) − a‖². Plus C est petit, mieux le réseau prédit.
Gradient ∇C
Vecteur des dérivées partielles de C. Il indique la direction de montée la plus raide ; son opposé donne la direction de descente la plus rapide.
Descente de gradient
Algorithme : à chaque pas, mettre à jour les paramètres dans la direction opposée au gradient : v → v − η∇C.
Taux d’apprentissage (η)
Nombre η > 0 qui fixe la taille du pas dans la descente de gradient. Trop grand = instabilité ; trop petit = apprentissage lent.
SGD (stochastic gradient descent)
Descente de gradient en estimant ∇C sur un petit échantillon aléatoire (mini-batch) au lieu de tout le jeu d’entraînement.
Mini-batch
Petit ensemble d’exemples tirés aléatoirement pour calculer une estimation du gradient et mettre à jour les poids.
Époque
Un passage complet sur toutes les données d’entraînement (en plusieurs mini-batches).
Rétropropagation
Algorithme qui calcule efficacement le gradient de la fonction de coût par rapport à tous les poids et biais (détaillé au chapitre 4).

Perceptrons

Objectif : Comprendre le perceptron : entrées binaires, poids, seuil (ou biais), sortie 0 ou 1 ; notation w·x + b ; exemple de décision ; NAND et universalité.

Un perceptron possède plusieurs entrées binaires x1, x2, … et produit une sortie binaire. Il calcule la somme pondérée Σj wjxj et la compare à un seuil : si la somme est strictement supérieure au seuil, la sortie vaut 1, sinon 0. En notant b = −seuil (le biais), la règle s’écrit : sortie = 1 si w·x + b > 0, sinon 0. On peut voir le perceptron comme un dispositif qui pèse des preuves pour prendre une décision.

Exemple (décision) : Tu décides d’aller à un festival selon la météo (x1), si quelqu’un t’accompagne (x2) et si les transports sont proches (x3). En mettant un grand poids sur la météo (w1=6) et un seuil 5, le perceptron sort 1 seulement si la météo est bonne, peu importe le reste. En baissant le seuil à 3, la sortie peut être 1 dans d’autres combinaisons (ex. météo bonne ou transports proches + accompagnement).

Manipuler un perceptron : choisis les entrées (0 ou 1), les poids et le biais ; la sortie s’affiche (w·x + b puis 0 ou 1).

Entrées : 0 0 0   Poids : w1= w2= w3=   Biais b=

w·x + b = 0   →   Sortie = 0

NAND : Avec 2 entrées, poids −2, −2 et biais 3, on obtient sortie 1 pour (0,0), (0,1), (1,0) et sortie 0 pour (1,1). C’est la porte logique NAND. Les réseaux de perceptrons peuvent ainsi calculer n’importe quelle fonction logique (universalité). L’intérêt des réseaux de neurones vient des algorithmes d’apprentissage qui règlent automatiquement les poids et biais à partir d’exemples.

En résumé : Perceptron = entrées binaires, poids, biais ; sortie 1 si w·x + b > 0, sinon 0. Exemple décision, NAND, universalité. L’apprentissage automatique ajuste w et b.

Neurones sigmoïdes

Objectif : Comprendre pourquoi on utilise la sigmoïde (petit Δpoids → petit Δsortie) ; formule σ(z) = 1/(1+e−z) ; lien avec le perceptron.

Pour apprendre, on a besoin qu’un petit changement des poids ou du biais provoque un petit changement de la sortie. Avec le perceptron, une légère modification peut faire passer la sortie de 0 à 1 d’un coup. On introduit donc le neurone sigmoïde : même entrées et poids, mais la sortie est σ(z) avec z = w·x + b et σ(z) = 1/(1+e−z). La sortie est alors un nombre entre 0 et 1. Quand z est très grand positif, σ(z) ≈ 1 ; quand z est très grand négatif, σ(z) ≈ 0. C’est une version « lisse » du seuil du perceptron.

La dérivée de σ intervient dans le calcul du gradient : σ′(z) = σ(z)(1−σ(z)). Un petit changement Δwj ou Δb produit approximativement un changement Δ(sortie) proportionnel (formule (5) du chapitre de référence). Cela permet d’ajuster les poids pas à pas pour réduire l’erreur.

Courbe sigmoïde : déplace z pour voir σ(z).

z = 0   →   σ(z) = 0.5

En résumé : Neurone sigmoïde : sortie = σ(w·x + b) avec σ(z) = 1/(1+e−z). Petit changement de poids → petit changement de sortie, ce qui permet l’apprentissage par gradient.

Architecture des réseaux

Objectif : Nommer les couches (entrée, cachée, sortie) ; feedforward ; mention des réseaux récurrents.

Un réseau est composé de couches. La couche la plus à gauche = entrée (les neurones d’entrée fournissent les données, ex. les pixels). La couche la plus à droite = sortie (réponse du réseau). Les couches entre les deux = cachées. Les réseaux où l’information circule uniquement des entrées vers les sorties (sans boucle) sont dits feedforward. Les réseaux avec boucles (sortie qui influence l’entrée plus tard) sont dits récurrents ; on se limite ici au feedforward.

Voir l’architecture : clique sur une couche pour voir son rôle.

Entréepixels / données
Cachéetraits / combinaisons
Sortieréponse

En résumé : Couches entrée, cachée(s), sortie. Réseau feedforward = pas de boucle.

Un réseau simple pour les chiffres (MNIST)

Objectif : 784 entrées (pixels 28×28), une couche cachée de n neurones (ex. 15 ou 30), 10 sorties (une par chiffre 0…9) ; pourquoi 10 sorties et pas 4.

Pour MNIST, chaque image fait 28×28 = 784 pixels. On utilise donc 784 neurones d’entrée. La couche cachée a un nombre n de neurones (on testera par ex. 15, 30 ou 100). La couche de sortie a 10 neurones : le neurone k « vote » pour le chiffre k (0 à 9) ; on prend le neurone dont l’activation est la plus forte comme prédiction. Pourquoi 10 et pas 4 (codage binaire) ? En pratique, 10 sorties donnent de meilleurs résultats car chaque sortie peut correspondre à des sous-formes du chiffre (ex. boucles, traits) plus naturellement qu’un bit de poids fort.

En résumé : 784 entrées (pixels), une couche cachée (n neurones), 10 sorties. La sortie maximale donne le chiffre prédit.

Apprentissage par descente de gradient

Objectif : Fonction de coût C(w,b) (MSE) ; minimiser C ; idée vallée/bille ; ΔC ≈ ∇C·Δv ; choix Δv = −η∇C ; application aux poids et biais ; SGD et mini-batches, époques.

On dispose d’exemples (images, étiquettes). On définit une fonction de coût C(w,b) = (1/2n) Σx ‖y(x) − a‖² (équation (6)) : plus les sorties a du réseau sont proches des cibles y(x), plus C est petit. L’objectif est de minimiser C en ajustant les poids w et les biais b. La descente de gradient : à chaque pas, on calcule le gradient ∇C (vecteur des dérivées partielles) et on met à jour v (ici w et b) selon v → v − η∇C, où η est le taux d’apprentissage. Ainsi C diminue à chaque pas (approximativement). L’analogie : une bille qui roule vers le bas d’une vallée (C = altitude).

En pratique, calculer ∇C sur tout le jeu d’entraînement à chaque pas serait trop coûteux. La stochastic gradient descent (SGD) : on tire aléatoirement un mini-batch d’exemples, on calcule le gradient sur ce mini-batch seulement, et on met à jour les poids. On répète jusqu’à avoir parcouru toutes les données = une époque. Puis on enchaîne d’autres époques.

Coût sur 10 sorties : compare sorties obtenues et cibles ; C = (1/2)‖y−a‖².

Sorties obtenues
Cibles

C = 0

Descente en 1D : la « bille » roule vers le minimum de C.

Position = 0   Pente = 0   C = 0

En résumé : C(w,b) = erreur quadratique moyenne. Descente de gradient : v → v − η∇C. SGD = gradient estimé sur un mini-batch ; une époque = un passage sur toutes les données.

Implémentation

Objectif : Structure du code (Network, feedforward, sigmoid, SGD, update_mini_batch, backprop) ; chargement MNIST ; résultats typiques (~95 %, ~96,5 % avec 100 neurones) ; rôle des hyperparamètres (η, taille mini-batch, nombre d’époques).

Le réseau est représenté par une classe avec : liste des tailles de couches ; initialisation aléatoire des poids et biais ; fonction feedforward qui applique a′ = σ(wa + b) couche par couche (équation (22)) ; fonction SGD qui, pour chaque époque, mélange les données, les découpe en mini-batches, et pour chaque mini-batch appelle update_mini_batch (calcul du gradient via la rétropropagation, puis mise à jour des poids et biais). La fonction sigmoid et sa dérivée sigmoid_prime sont utilisées dans le feedforward et la rétropropagation.

Mini feedforward : un tout petit exemple de a′ = σ(wa + b) avec 2 entrées et 2 neurones de sortie.

Entrée a = [a1, a2] avec a1 = et a2 = (entre 0 et 1).

On fixe les poids et biais pour simplifier :

  • Neurone 1 : w1 = [2, −1], b1 = 0,5
  • Neurone 2 : w2 = [−1, 2], b2 = −0,5

Calculs couche par couche :

z1 = 2·a1 − 1·a2 + 0,5 = 0,00   →   a′1 = σ(z1) = 0,50

z2 = −1·a1 + 2·a2 − 0,5 = 0,00   →   a′2 = σ(z2) = 0,50

Sur MNIST (50 000 images d’entraînement, 10 000 de test), avec une couche cachée de 30 neurones, 30 époques, mini-batch 10, η = 3, on obtient typiquement environ 95 % de bonnes réponses sur le test. Avec 100 neurones cachés, on peut atteindre environ 96,5 %. Si η est trop petit (ex. 0,001), l’apprentissage est très lent ; si η est trop grand (ex. 100), la loss ne descend pas correctement. Le débogage d’un réseau (choix des hyperparamètres) reste en partie empirique.

En résumé : Code = Network, feedforward (22), SGD, update_mini_batch, backprop. Résultats MNIST ~95–96,5 %. Hyperparamètres : η, taille mini-batch, nombre d’époques.

Vers le deep learning

Objectif : Idée de hiérarchie de concepts (sous-formes → formes → chiffre) ; réseaux profonds (plusieurs couches cachées) ; techniques depuis 2006.

On peut interpréter les couches comme une hiérarchie : les premières détectent des traits simples (bords), les suivantes des formes (boucles, segments), puis la combinaison donne le chiffre. Un réseau avec plusieurs couches cachées (réseau « profond ») peut ainsi construire des représentations de plus en plus abstraites. Historiquement, entraîner de tels réseaux avec la descente de gradient et la rétropropagation était difficile ; depuis 2006, des techniques ont permis d’entraîner des réseaux profonds (5 à 10 couches cachées et plus) avec succès.

En résumé : Deep learning = réseaux avec plusieurs couches cachées, hiérarchie de concepts. Techniques modernes permettent de les entraîner efficacement.

Exercices

Objectif : S’entraîner sur les notions du chapitre (perceptron, sigmoïde, gradient, SGD) via des exercices texte et des widgets.

Exercice 1 – Sigmoïdes simulant perceptrons (I)

Énoncé : Supposons qu’on multiplie tous les poids et biais d’un réseau de perceptrons par une constante c > 0. Montrer que le comportement du réseau ne change pas.

À faire avec le widget : Choisis w, b et les entrées x. Multiplie par c : la sortie (0 ou 1) doit rester la même. Vérifie avec différentes valeurs.

Perceptron à 2 entrées : x1 = x2 =   w1 = w2 = b =   c =

Sans c : w·x + b = 0 → sortie = 0     Avec c : (cw)·x + (cb) = 0 → sortie = 0

Solution : Pour chaque perceptron, la sortie dépend du signe de w·x + b. Si on remplace (w, b) par (cw, cb), alors c(w·x + b) a le même signe que w·x + b (car c > 0). Donc la sortie 0 ou 1 reste la même pour chaque neurone, et donc pour tout le réseau.

Exercice 2 – Sigmoïdes simulant perceptrons (II)

Énoncé : Remplaçons les perceptrons par des sigmoïdes et multiplions poids et biais par c > 0. Quand c → ∞, le comportement tend vers celui du perceptron (si w·x + b ≠ 0). Pourquoi ça échoue si w·x + b = 0 ?

Widget : Utilise le widget ci-dessous pour observer σ(c·(w·x+b)) quand tu augmentes c.

w·x + b =   c = 5

σ(c·(w·x+b)) = 0.92

En augmentant c, la sortie tend vers 0 ou 1 (comportement perceptron). Si w·x+b = 0, σ(0) = 0,5 toujours.

Solution (échec en 0) : Si w·x + b = 0, alors c·(w·x+b) = 0 pour tout c, donc σ(0) = 0,5. La sortie ne tend ni vers 0 ni vers 1.

Exercice 3 – Apprentissage en ligne (mini-batch = 1)

Énoncé : Donner un avantage et un inconvénient de l’apprentissage en ligne (mise à jour après chaque exemple) par rapport à la SGD avec mini-batch de taille 20.

À faire avec le widget : Clique sur « Simuler des mises à jour ». Compare l’évolution de la loss pour mini-batch = 1 (plus de zigzags) et mini-batch = 20 (plus stable).

Mini-batch = 1 :   (dernières losses simulées)

Mini-batch = 20 :

Solution : Avantage : mises à jour très fréquentes, le réseau réagit à chaque exemple. Inconvénient : l’estimation du gradient sur un seul exemple a une forte variance, ce qui peut rendre l’apprentissage instable ou plus lent.

Exercice 4 – Descente de gradient 1D

Interprétation géométrique : en une dimension, la pente (dérivée) indique si C monte ou descend ; un pas dans le sens opposé à la pente fait diminuer C.

À faire avec le widget : On te donne une pente (dérivée de C). Pour faire baisser C, dans quelle direction faut-il aller ? Choisis puis vérifie.

Pente (dérivée) = 2.5   →   Pour faire baisser C, il faut aller vers :

  Tu peux aussi utiliser le widget « Descente en 1D » dans la section Descente de gradient.

Exercice 5 – Preuve descente de gradient

Énoncé : Pour un pas de norme fixe ‖Δv‖ = ε, montrer que le choix Δv = −η∇C (avec η proportionnel à ε) minimise la diminution de C (inégalité de Cauchy–Schwarz).

Indication : On a ΔC ≈ ∇C·Δv. Pour ‖Δv‖ fixe, ce produit est minimal quand Δv est dans la direction opposée à ∇C (Cauchy–Schwarz : |∇C·Δv| ≤ ‖∇C‖ ‖Δv‖, avec égalité quand Δv est colinéaire à ∇C). Donc pour faire baisser C au maximum, on prend Δv proportionnel à −∇C.

À faire avec le widget : Joue avec l’angle entre ∇C et le pas Δv pour voir quand ΔC est le plus négatif (baisse maximale de C).

On fixe ici un gradient ∇C = (2, 1). Sa norme vaut ‖∇C‖ ≈ 0.

Norme du pas : ‖Δv‖ = 1 (fixe). Angle entre ∇C et Δv : 180°

Produit scalaire ∇C·Δv ≈ 0.00   →   ΔC ≈ ∇C·Δv.

Exercice 6 – Couche binaire (10 → 4 sorties)

Énoncé : Trouver des poids et biais pour une couche de neurones qui convertit les 10 sorties (une valeur 1 pour le chiffre reconnu, 0 ailleurs) en une représentation binaire sur 4 sorties (chiffre 0 à 9 codé en binaire).

À faire avec le widget : Choisis un chiffre de 0 à 9. Observe les 10 entrées (one-hot) et les 4 sorties binaires (bits du chiffre). Vérifie que le codage est correct pour chaque chiffre.

Chiffre :

Entrées (one-hot) : 1 0 0 0 0 0 0 0 0 0

Sorties binaires (bit 0 = poids faible … bit 3 = poids fort) : 0 0 0 0 = 0 en décimal.

Solution : Chaque sortie binaire est un bit. Par exemple, la sortie 0 = bit de poids faible (chiffre impair si 1). On peut prendre des poids 0 ou 1 selon la position du bit dans l’encodage du chiffre, et des seuils adaptés (ex. 0,5) pour que la somme des entrées actives donne 0 ou 1. Détail : pour le bit k (k = 0,1,2,3), le neurone k reçoit les entrées des indices j tels que le bit k de j vaut 1 ; poids 1, biais −0,5 ; sortie 1 si au moins une de ces entrées est 1.

Exercice 7 – Équation (22) en composantes

Énoncé : Écrire a′ = σ(wa + b) en composantes (a′j en fonction des ak, wjk, bj) et vérifier que ça correspond à la règle (4) du neurone sigmoïde.

À faire avec le widget : Un neurone avec 2 entrées a1, a2, poids w1, w2 et biais b. Calcule mentalement z = w1a1 + w2a2 + b puis a′ = σ(z), puis vérifie avec le widget.

a1 =   a2 =   w1 =   w2 =   b =

z = w1a1 + w2a2 + b = 0

a′ = σ(z) = 0

Solution : a′j = σ(Σk wjk ak + bj). C’est bien la sortie du neurone j : entrées ak, poids wjk, biais bj, fonction d’activation σ.

Exercice 8 – Réseau 2 couches (784 → 10)

Énoncé : Entraîner un réseau sans couche cachée (784 entrées → 10 sorties). Quelle précision peut-on attendre sur MNIST ?

À faire avec le widget : Lance une simulation (résultat indicatif) pour voir l’ordre de grandeur de la précision d’un réseau sans couche cachée, comparé au réseau avec couche cachée (~95–96 %).

Réponse : Un tel réseau est un classifieur linéaire (régression logistique multi-classe). La précision sur MNIST est nettement inférieure à un réseau avec une couche cachée (typiquement environ 85–92 %). À faire en JS ou en Python chez soi pour comparer avec le réseau 784 → n → 10.

En résumé : Les exercices permettent de vérifier la compréhension (scaling des poids, sigmoïde → perceptron, avantages/inconvénients SGD, interprétation 1D).

Quiz

Objectif : Tester ta compréhension (perceptron, sigmoïde, gradient, SGD) avec des questions à choix multiples.

Choisis un quiz :

Fiche enseignant

Fiche pédagogique pour le chapitre approfondi 1 : objectifs, niveau, durée, réponses aux exercices et au quiz.