Accueil – Chapitre 1
À la fin de ce chapitre 1, tu sauras : ce qu'est un pixel, comment un neurone calcule, comment le réseau reconnaît un chiffre, et comment l'entraînement améliore le « cerveau ».
Bienvenue ! Dans ce chapitre 1, tu vas découvrir la structure du réseau : comment un petit « cerveau » en ordinateur est fait pour reconnaître les chiffres écrits à la main (0, 1, 2… 9). Tu verras les pixels, les neurones, les formules et même comment on sauvegarde le cerveau. Au chapitre 2, on verra en détail comment il apprend (loss, descente de gradient). La façon dont le gradient est calculé pour tous les poids — la rétropropagation — sera expliquée plus en détail au chapitre 4 (l’idée) et au chapitre 5 (les formules).
De l'image au chiffre (en une image)
D'où viennent les images ? Elles viennent du jeu de données MNIST (chiffres manuscrits). Si le fichier data/mnist-subset.json est présent, on charge de vraies images ; sinon l'application utilise des images de démonstration générées automatiquement.
En résumé : Ce site explique comment un réseau de neurones apprend à reconnaître les chiffres. Après la structure (ici), tu verras comment il apprend (chapitre 2), comment l’analyser (chapitre 3), puis la rétropropagation (chapitre 4 et 5). Tu peux suivre le parcours étape par étape avec le bouton « Étape suivante » en haut.
Lexique
Objectif : Connaître les mots du projet (pixel, neurone, poids, biais, couche, réseau, epoch, loss, précision, rétropropagation).
- Pixel
- Un petit point de l’image. Chaque pixel a une valeur (souvent 0 = noir à 255 = blanc). Une image 28×28 a 784 pixels.
- Neurone
- Une « chose » qui reçoit des nombres en entrée, fait un calcul (entrées × poids + biais), puis applique une fonction (ReLU) pour produire un nombre en sortie.
- Poids
- Chaque connexion entre un neurone d’avant et un neurone d’après a un poids (un nombre). Le poids dit à quel point une entrée influence la sortie.
- Biais
- Un nombre ajouté dans le neurone. Il agit comme un seuil : « il faut au moins ce niveau pour que je m’active ».
- Couche
- Un ensemble de neurones qui reçoivent les mêmes entrées (la couche précédente) et envoient leurs sorties à la couche suivante.
- Réseau
- L’ensemble des couches connectées : entrées (784) → couche 1 (64) → couche 2 (64) → sorties (10).
- Epoch
- Un tour complet sur toutes les images d’entraînement. Plus on fait d’epochs, plus le réseau a le temps d’apprendre.
- Loss
- Fonction de coût : un nombre qui mesure l’erreur du réseau. Plus la loss est basse, moins le réseau se trompe.
- Précision
- Le pourcentage de bonnes réponses sur des images de test.
- Rétropropagation
- L’algorithme qui fait « remonter » l’erreur de la sortie vers les couches pour savoir comment modifier chaque poids.
Pixels
Objectif : Voir qu’une image est une grille de nombres (pixels). 28×28 = 784 nombres qui serviront d’entrées au réseau.
Chaque case de la grille ci-dessous est un pixel. Plus le pixel est blanc, plus sa valeur est grande (proche de 255). Plus il est noir, plus elle est proche de 0. L’ordinateur stocke souvent les pixels sur un octet (0–255).
Voir le vecteur : Les 784 pixels peuvent être mis « en ligne » pour former un vecteur de 784 nombres. C’est ce que le réseau reçoit en entrée.
Combien de pixels a une image MNIST ?
En résumé : Une image = 28×28 = 784 pixels. Chaque pixel = un nombre (0–255). Ces 784 nombres = les entrées du réseau.
Neurones
Objectif : Comprendre la formule d’un neurone : entrées × poids + biais, puis ReLU (max(0, x)).
Un neurone reçoit plusieurs nombres en entrée. Il multiplie chaque entrée par un poids, additionne le tout, ajoute un biais, puis applique une fonction d’activation. Ici on utilise ReLU : si le résultat est négatif, on le remplace par 0.
Un neurone reçoit plusieurs nombres en entrée. Vrai ou faux ?
En résumé : Neurone = entrées × poids + biais, puis ReLU. Chaque neurone « contient » un nombre (son activation).
Notre cerveau (réseau)
Objectif : Tu sauras que notre réseau a 784 entrées → 64 → 64 → 10 sorties, et que la sortie la plus forte donne le chiffre reconnu.
Notre réseau : 784 entrées (les pixels 28×28) → deux couches cachées de 64 neurones chacune (64 + 64) → 10 sorties (0 à 9). Chaque sortie est un nombre entre 0 et 1 : « à quel point le réseau pense que l'image est ce chiffre ». La sortie la plus forte indique le chiffre « vu » par le cerveau.
Explication détaillée du cerveau
- 784 entrées — Chaque image MNIST fait 28×28 pixels. 28×28 = 784. Le cerveau reçoit un nombre par pixel.
- Deux couches cachées de 64 neurones — La première reçoit les 784 entrées et calcule 64 valeurs (ReLU). La deuxième reçoit ces 64 valeurs et calcule 64 nouvelles (ReLU). Deux couches permettent d'apprendre des motifs un peu plus complexes tout en restant rapide et lisible (64+64 au lieu d'une seule barre de 128).
- 10 sorties — Une par chiffre 0 à 9. La plus grande indique la prédiction.
Pourquoi 64 + 64 ?
- On aurait pu garder une seule couche de 128. Avec deux fois 64, la structure est plus claire (deux blocs) et le réseau peut combiner les informations en deux étapes.
- Cette architecture (784 → 64 → 64 → 10) est adaptée au problème, simple à expliquer et rapide à entraîner dans le navigateur.
Pourquoi des couches ? On peut imaginer que la première couche détecte des petits bords, la suivante des formes (boucles, traits), puis on combine pour reconnaître le chiffre. Les couches décomposent le problème en étapes plus simples (bords → motifs → chiffre).
Le réseau est une fonction : 784 nombres en entrée (les pixels) → 10 nombres en sortie (un par chiffre). C'est une seule grosse fonction avec des milliers de paramètres (poids et biais).
Mini-quiz (sans note)
Combien de sorties a notre réseau pour MNIST ?
En résumé : Réseau = 784 (pixels) → 64 → 64 (couches cachées) → 10 (chiffres 0–9). La plus grande sortie = prédiction.
Les formules pas à pas
Objectif : Tu verras étape par étape comment les nombres circulent du pixel au chiffre reconnu.
Ici tu peux décortiquer : on choisit une image, puis on affiche étape par étape les calculs que le cerveau fait pour deviner le chiffre.
En résumé : Image → 784 nombres → couche 1 (64 valeurs) → couche 2 (64 valeurs) → 10 scores → le plus grand = chiffre reconnu.
L'apprentissage (rétropropagation)
Objectif : Comprendre que le réseau « apprend » en corrigeant ses poids à partir de l’erreur. L’erreur remonte (rétropropagation) pour dire comment modifier chaque poids.
Quand le réseau se trompe, on calcule l’erreur à la sortie. Cette erreur nous dit dans quel sens modifier les poids : c’est le gradient. La rétropropagation fait remonter cette information à travers toutes les couches pour mettre à jour chaque poids.
En résumé : Prédiction → comparaison avec la bonne réponse → calcul de l'erreur (gradient) → rétropropagation → correction des poids. À chaque entraînement, on fait un petit pas pour réduire l’erreur.
Entraînement
Objectif : Lancer l’entraînement du réseau, observer la loss et la précision, voir les courbes et comparer avant/après.
Epoch : 0 Loss : — Précision : — %
Courbe Loss et Précision
Avant / Après entraînement
Même image : prédiction avant et après quelques epochs.
—
—
En résumé : L’entraînement répète des epochs : on montre des images, on calcule l’erreur, on fait la rétropropagation et on met à jour les poids. La loss baisse, la précision monte.
Sauvegardes
Objectif : Sauvegarder le « cerveau » (poids) en téléchargeant un fichier, et le recharger plus tard depuis un fichier. Comparer deux cerveaux.
Comparer deux cerveaux
Jouer avec le dataset
Objectif : Cliquer sur des images MNIST et voir la prédiction du réseau, la confiance et les 10 sorties.
Activations des neurones en temps réel
784 entrées (image 28×28) → 64 → 64 → 10 sorties. Clique sur une image de la galerie pour voir les activations.
L’image est tournée de 90° à droite pour correspondre à l’ordre des entrées du réseau (pixel 0 en haut à droite, etc.).
En résumé : Tu cliques sur une image, le réseau donne un chiffre et un niveau de confiance. Les 10 barres = « à quel point le réseau pense que c’est 0, 1, … 9 ».
Dessiner un chiffre
Objectif : Dessiner un chiffre avec la souris (ou le doigt) et voir la prédiction du réseau en temps réel.
—
Pixels en rouge (activés automatiquement) : ceux qui ont fait choisir la réponse.
Jeux
Trouve l’intrus : Quatre images s’affichent, trois sont le même chiffre, une est différente. Clique sur l’intrus, puis le réseau donne sa prédiction.
Chrono : Le réseau voit un nombre d'images au choix le plus vite possible. Tu vois les prédictions et le temps.
L'intelligence en trompe-l'œil : ce que votre réseau de neurones ne vous dit pas
1. Introduction : Le mirage de la boîte noire
Nous vivons une époque fascinée par l'aura de « magie » qui entoure l'intelligence artificielle. Voir un algorithme identifier instantanément un chiffre griffonné sur un écran procure une satisfaction étrange, celle d'assister à la naissance d'une pensée numérique. Pourtant, derrière cette apparente clarté se cache une « boîte noire » dont les mécanismes internes sont bien plus déroutants que nous ne voulons l'admettre. Nous créons des systèmes qui fonctionnent, mais comprenons-nous vraiment comment ils parviennent à leurs conclusions ? En ouvrant le capot d'un réseau de neurones classique entraîné sur la base de données MNIST, nous découvrons un savant en camisole de force : un système capable de performances surhumaines, mais totalement dépourvu de bon sens.
2. Une précision presque surhumaine (et son ironie)
Le réseau de neurones « vanille » que nous analysons affiche une réussite insolente : il classe environ 96 % des nouvelles images sans erreur. Avec quelques ajustements, il grimpe à 98 %. Pour mettre cela en perspective, les réseaux modernes atteignent 99,75 %, un seuil où même un œil humain aguerri commencerait à douter de sa propre vision. Ce succès est d'autant plus ironique que nous n'avons jamais dicté à l'algorithme les règles du jeu : nous ne lui avons jamais expliqué qu'un « 8 » possède deux boucles ou qu'un « 7 » est composé de deux segments. Il a appris seul, par pur calcul statistique, à naviguer dans le chaos des écritures manuscrites.
3. Le chaos derrière l'ordre : le « minimum local heureux »
En théorie, nous aimons imaginer que le réseau est un architecte rigoureux : la première couche détecterait des bords nets, la seconde assemblerait ces bords en composants logiques. La réalité est bien moins élégante. En visualisant les poids des neurones, on ne trouve pas de géométrie claire, mais des motifs nébuleux, des formes « blobby » et des nuages de pixels qui semblent presque aléatoires.
Dans l'espace colossal de 13 002 dimensions — un paysage mathématique abstrait où chaque poids et chaque biais est un curseur que la machine ajuste — le réseau a simplement trouvé un « minimum local heureux ». C'est une vallée de moindre erreur dans laquelle il s'est installé, préférant une solution statistique efficace à la logique structurelle que nous espérions.
Pour comprendre la fragilité de cette logique, il suffit de regarder la transition d'un « 3 » vers un « 8 ». En étendant simplement quelques pixels, on voit les neurones de la deuxième couche s'activer de manière chaotique jusqu'à ce que la prédiction bascule, non pas parce que le réseau « voit » une nouvelle boucle, mais parce que son équation mathématique a franchi un seuil invisible.
4. L'arrogance du bruit : l'univers des dix chiffres
L'un des aspects les plus révélateurs de cette « intelligence » est son incapacité totale à admettre son ignorance. Présentez-lui une image de bruit statique, un chaos de pixels sans aucun sens, et le réseau ne sourcillera pas. Il identifiera ce vacarme comme un « 5 » avec une confiance absolue. Pourquoi ? Parce que pour ce réseau, l'univers entier n'est composé que de dix chiffres.
Le système n'a pas d'option « aucun de ces choix ». Sa vision du monde est si étriquée que même le néant ou le bruit doit être classé dans l'une de ses dix cases pré-établies. Sa fonction de coût ne l'a jamais incité à l'incertitude, mais uniquement à trancher.
Cela prouve une vérité cinglante : si ce réseau sait reconnaître les chiffres, il n'a absolument aucune idée de comment les dessiner. Il ne comprend pas la structure ; il ne fait que filtrer des données à travers un entonnoir rigide.
5. Une vision sans espace : le savant aveugle
La rigidité de cette technologie, héritée des recherches des années 80 et 90, frise l'absurde. Le réseau échoue dès qu'un chiffre est légèrement décalé ou mal centré. Plus troublant encore : l'algorithme ignore totalement que certains pixels sont adjacents. Pour lui, le pixel situé tout en haut à gauche et celui juste à sa droite sont aussi étrangers l'un à l'autre que s'ils se trouvaient aux extrémités opposées de l'image.
Si vous mélangiez les pixels de toutes vos images d'entraînement de manière aléatoire (mais constante), le réseau obtiendrait exactement les mêmes scores de précision. Cette absence totale de contexte spatial montre que l'algorithme ne perçoit pas des formes, mais des corrélations numériques froides. C'est une véritable leçon d'humilité : nous avons créé un système qui « voit » sans jamais comprendre la notion de voisinage.
6. Conclusion : Vers une intelligence plus flexible
Ce modèle n'est pas une finalité, c'est une relique technologique fascinante. C'est le point de départ nécessaire pour comprendre comment la rétropropagation (backpropagation) permet à une machine d'apprendre. Mais en creusant dans ces couches cachées, on réalise que plus le système semble performant, moins il semble intelligent au sens humain du terme.
Pour dépasser ces limites et atteindre une vision capable de transférer ses connaissances d'un coin de l'image à l'autre, il a fallu inventer les réseaux convolutifs (CNN). En attendant, une question demeure : si un système peut donner la bonne réponse à chaque fois sans jamais comprendre la question, est-il vraiment intelligent, ou n'est-il qu'un miroir mathématique de nos propres attentes ?
Générés par NotebookLM (Google).
Quiz : teste ta compréhension
Objectif : Répondre à des questions (QCM) et obtenir une note sur 20. Tu peux refaire le quiz pour t’améliorer.
Choisis un quiz :
Cartes mémoire
Cartes mémoire (flashcards) pour réviser les notions.
Chargement…
Générés par NotebookLM (Google).
Fiche enseignant
Contenu complet de la fiche pédagogique (objectifs, durée par section, séquences type, réponses aux quiz, idées d'activités, technique). Tout est issu du fichier FICHE-ENSEIGNANT.md.
Objectifs pédagogiques
- Comprendre qu’une image numérique est une grille de nombres (pixels).
- Comprendre le rôle d’un neurone : entrées × poids + biais, puis ReLU.
- Comprendre la structure du réseau 784 → 64 → 64 → 10.
- Comprendre que l’apprentissage corrige les poids (rétropropagation).
- Savoir ce que signifient epoch, loss et précision.
- Utiliser le quiz pour évaluer la compréhension (note sur 20).
Niveau et prérequis
Niveau : fin primaire / collège (6e–3e).
Prérequis : savoir lire un texte explicatif, manipuler une souris ou un écran tactile.
Durée indicative : 1 h à 1 h 30 pour le parcours complet ; séquences possibles de 30–45 min.
Structure du parcours
| Section | Durée indicative | Objectif |
|---|---|---|
| Accueil | 5 min | Présenter le projet et le résumé visuel « De l'image au chiffre ». |
| Lexique | 5 min | Consulter les définitions (pixel, neurone, poids, epoch, loss, etc.). |
| Pixels | 10 min | Grille 28×28, lecture pixel par pixel, lien image → 784 nombres. |
| Neurones | 10 min | Formule du neurone, ReLU, légende. |
| Cerveau (réseau) | 10 min | Architecture 784 → 64 → 64 → 10. |
| Formules pas à pas | 10 min | Choisir une image et voir les étapes du calcul. |
| Apprentissage | 10 min | Rétropropagation, erreur, gradient. |
| Entraînement | 15 min | Lancer l'entraînement, observer loss et précision, courbes. |
| Sauvegardes | 5 min | Sauvegarder / charger un « cerveau ». |
| Jouer | 10 min | Cliquer sur des images, voir prédiction et confiance. |
| Dessiner | 10 min | Dessiner un chiffre, voir la prédiction en temps réel. |
| Quiz | 10–15 min | Quiz final ou par thème, note sur 20. |
Séquences type
Séquence 1 (30 min) – Les bases
Accueil → Lexique (rapide) → Pixels → Neurones.
Points à souligner : image = grille de nombres ; neurone = calcul (entrées × poids + biais) puis ReLU.
Séquence 2 (30 min) – Le réseau et l'apprentissage
Cerveau → Formules pas à pas → Apprentissage.
Points à souligner : 784 entrées, 10 sorties ; l'erreur remonte pour corriger les poids.
Séquence 3 (30 min) – Entraînement et pratique
Entraînement (lancer 5–10 epochs) → Jouer → Dessiner → Quiz (par thème ou final).
Réponses au quiz final
- Combien de pixels ? → 784
- Plus un pixel est blanc → grande (proche de 255)
- À quoi servent les poids ? → À multiplier les entrées / régler l’importance
- Un neurone reçoit plusieurs entrées → Vrai
- Combien de sorties ? → 10
- Les 784 entrées correspondent à → Les pixels de l’image
- Rétropropagation → Elle fait remonter l’erreur pour corriger les poids
- Quand la loss baisse → Le réseau fait moins d’erreurs en moyenne
- Une epoch → Un tour complet sur toutes les images d’entraînement
- La précision mesure → Le % de bonnes réponses sur des images de test
Barème : 20 / nombre de questions par bonne réponse (ex. 10 questions → 2 points par question).
Idées d'activités en classe
- Débat : « Est-ce que ce réseau “comprend” vraiment le chiffre ? » (il calcule des nombres, il ne “voit” pas comme nous).
- Expérience : Comparer la prédiction avant et après entraînement sur la même image (section Entraînement, bloc « Avant / Après »).
- Défi : Dessiner un chiffre le plus lisible possible pour que le réseau le reconnaisse (section Dessiner).
- Trace écrite : Noter les mots du lexique et une phrase de résumé par section.
Technique
- Ouvrir le projet dans un navigateur (Chrome, Firefox, Edge). Si chargement de données : utiliser un serveur local (ex.
python -m http.server 8000). - Sauvegarde : téléchargement d’un fichier JSON. Chargement : choix d’un fichier (pas de stockage sur le serveur).
- Données : si
data/mnist-subset.jsonest absent, l'application utilise des images de démonstration.
Contact / crédits
Projet éducatif offert par DF AI Research à des fins non commerciales.
Voir README.md et AMELIORATIONS-EDUCATIVES.md pour plus de détails.