Ouvrir le PDF Visualizing_Gradient_Descent.pdf — Lecture directement :
Générés par NotebookLM (Google).
Accueil – Chapitre 2
À la fin de ce chapitre 2, tu sauras : ce qu'est le score d'erreur (on appelle ça la loss), comment la méthode qui fait descendre l'erreur pas à pas (descente de gradient) marche, et comment la taille du pas (taux d'apprentissage) et la rétropropagation permettent au réseau de s'améliorer.
Léo veut que son réseau reconnaisse les chiffres. Pour ça, le réseau doit moins se tromper. Comment ? En mesurant son erreur (le score d'erreur, qu'on appelle la loss) et en la faisant baisser, pas à pas.
Pour toi (avec Léo) : On veut que le réseau se trompe de moins en moins. Pour ça, on mesure son erreur (un nombre), puis on la fait baisser, pas à pas. Pas de magie : juste des maths !
Bienvenue dans le chapitre 2 ! Au chapitre 1, tu as vu la structure du réseau (pixels, neurones, 784→64→64→10). Ici on voit comment il apprend : la règle qui calcule le score d'erreur (fonction de coût, ou loss), la méthode pour faire descendre l'erreur pas à pas (descente de gradient) et la taille du pas (taux d'apprentissage, ou learning rate). Comment ce gradient est calculé concrètement pour chaque poids ? On en reparlera plus en détail au chapitre 4 (l’idée de la rétropropagation) et au chapitre 5 (les formules avec la règle de la chaîne).
De l'erreur aux meilleurs poids (en une image)
À retenir : Le réseau apprend en faisant baisser son score d'erreur, pas à pas.
En résumé : Le chapitre 2 explique comment le réseau « apprend » en minimisant la loss grâce à la descente de gradient. Tu peux suivre le parcours avec le bouton « Étape suivante ».
Lexique
Objectif : Connaître les mots du chapitre 2 (coût, fonction de coût, gradient, descente de gradient, taux d'apprentissage, minimum local, données d'entraînement, données de test).
- Coût / Loss
- Un nombre qui mesure à quel point le réseau se trompe (le score d'erreur). Plus la loss est basse, mieux c'est. Comme si : la note d'une dictée — plus il y a de fautes, plus la note est mauvaise.
- Fonction de coût
- La règle qui permet de calculer ce score à partir des sorties du réseau et des bonnes réponses (étiquettes). Comme si : la règle du maître pour compter les fautes.
- Gradient
- Un vecteur qui indique la direction où la fonction de coût monte le plus vite ; son opposé indique où elle descend le plus vite. Comme si : une flèche qui dit « l'erreur monte par ici » ; on va dans le sens inverse pour la faire baisser.
- Descente de gradient
- L'algorithme : à chaque pas, on modifie les poids dans la direction opposée au gradient pour faire baisser la loss. Comme si : descendre une colline en regardant où ça descend le plus.
- Taux d'apprentissage (learning rate)
- La taille du pas à chaque mise à jour. Trop grand = on peut osciller ; trop petit = on avance lentement. Comme si : faire de tout petits pas ou de très grands pas pour descendre la colline.
- Minimum local
- Un « creux » dans le paysage de la loss : on peut s'y retrouver coincé sans être au meilleur minimum global. Comme si : une petite cuvette où la balle s'arrête, alors qu'il existe un fond plus bas ailleurs.
- Données d'entraînement
- Les images (et leurs étiquettes) sur lesquelles le réseau apprend en ajustant ses poids.
- Données de test
- Des images que le réseau n'a pas vues à l'entraînement ; on les utilise pour mesurer la précision.
Rappel
Objectif : Se rappeler que le réseau a pour but de reconnaître les chiffres manuscrits et que son comportement dépend des poids et biais.
Notre objectif : reconnaître les chiffres écrits à la main (0 à 9). Chaque image fait 28×28 pixels, soit 784 nombres en entrée. Le réseau a la structure 784 → 64 → 64 → 10 : 10 sorties (une par chiffre), et la plus forte indique la prédiction. Tout ce que fait le réseau est déterminé par ses poids et biais (des milliers de paramètres). Dans ce chapitre 2, on voit comment ces paramètres sont ajustés pour que le réseau s'améliore (loss, descente de gradient).
En résumé : Réseau = 784 entrées, 10 sorties. Comportement = poids et biais. Ici on apprend à les faire évoluer pour réduire l'erreur.
Données d'entraînement
Objectif : Comprendre qu'on n'écrit pas les règles à la machine : on lui donne des exemples (images + étiquettes) et un algorithme qui ajuste les poids.
On ne dit pas à l'ordinateur : « un 3 a deux boucles en haut ». On lui donne des exemples : des images de chiffres avec la bonne réponse (l'étiquette). L'ensemble de ces exemples s'appelle les données d'entraînement. Le réseau voit ces images, fait une prédiction, et un algorithme modifie les poids pour que la prédiction se rapproche de la bonne réponse. Pour vérifier que le réseau a bien appris (et pas seulement mémorisé), on utilise d'autres images qu'il n'a jamais vues : les données de test. Le jeu de données MNIST contient des dizaines de milliers de chiffres manuscrits étiquetés, qu'on peut séparer en entraînement et test.
Exemples réels MNIST : chaque image est étiquetée (ce que « dit » la donnée).
Chargement des images…
Image (28×28 pixels) + étiquette = un exemple d'entraînement. Le réseau apprend à partir de milliers de tels exemples.
En résumé : Entraînement = exemples (image + étiquette). L'algorithme ajuste les poids. Les données de test servent à mesurer la précision.
La fonction de coût
Maintenant qu'on a des exemples (données d'entraînement), on veut mesurer à quel point le réseau se trompe. Comment ?
Objectif : Comprendre que le score d'erreur (loss) mesure à quel point le réseau se trompe en comparant ses sorties à ce qu'on voudrait (1 pour le bon chiffre, 0 pour les autres).
Pour toi (avec Léo) : C'est comme quand tu compares ta réponse à la bonne : plus c'est proche, mieux c'est. Ici on regarde les 10 sorties du réseau et on mesure à quel point elles sont proches de ce qu'on voudrait.
Quand le réseau voit une image (par ex. un 3), on veut que la sortie du neurone « 3 » soit proche de 1 et que les autres sorties soient proches de 0. Au début (poids aléatoires), les sorties sont n'importe quoi. La règle qui calcule le score d'erreur (fonction de coût, ou loss) mesure cette erreur : on calcule la somme des carrés des différences entre chaque sortie et la valeur cible. Plus cette somme est petite, plus le réseau a bien répondu. Plus elle est grande, plus il se trompe.
En mots : pour chaque neurone de sortie, on regarde (valeur obtenue − valeur voulue)², puis on additionne le tout. C'est une façon classique de mesurer l'erreur.
Voir concrètement : on a vu une image de « 3 ». Les 10 sorties du réseau (obtenues) vs ce qu'on voudrait (cibles). Le score d'erreur = somme des carrés des différences.
Chiffre vu : 3
■ Sorties obtenues ■ Cibles (voulu)
Score d'erreur (loss) = 0 (plus c'est petit, mieux le réseau reconnaît)
On prend chaque différence (obtenu − voulu), on la met au carré pour que les erreurs comptent vraiment et ne s'annulent pas quand on les additionne, puis on additionne le tout. C'est une façon classique de mesurer l'erreur.
Clique sur une barre « sorties obtenues » pour modifier sa valeur (0 → 0,2 → … → 1 → 0). Le score d'erreur se recalcule : plus les sorties sont proches des cibles, plus il est bas. C'est ce nombre qu'on minimise par la descente de gradient.
À quoi sert la fonction de coût (loss) ?
À retenir : Plus le score d'erreur (loss) est petit, mieux le réseau reconnaît les chiffres.
En résumé : La loss = un nombre qui mesure l'erreur (ex. somme des carrés des différences entre sorties et cibles). Plus la loss est basse, mieux le réseau prédit.
Coût sur beaucoup d'images
Sur une image on a un score d'erreur. Mais le réseau doit s'améliorer sur toutes les images. Comment faire ?
Objectif : Comprendre qu'on calcule la loss sur toutes les images d'entraînement et qu'on en fait la moyenne pour avoir un seul nombre.
Pour toi (avec Léo) : Sur une image on a un score d'erreur. Sur toutes les images, on fait la moyenne de ces scores → un seul nombre qu'on veut faire baisser.
Le réseau ne doit pas juste bien faire sur une image : il doit s'améliorer sur tout le jeu d'entraînement. On calcule donc le score d'erreur (loss) pour chaque image, puis on fait la moyenne. Ce nombre unique résume « à quel point le réseau est mauvais » sur l'ensemble des exemples. C'est ce coût moyen qu'on cherche à faire baisser en modifiant les poids.
Voir concrètement : le score d'erreur sur chaque image (exemple avec 5 images), puis la moyenne.
Chaque barre = loss d’une image. La moyenne = un seul nombre qu’on minimise à l’entraînement.
Coût moyen = 0
En pratique, la descente de gradient met à jour les poids pour faire baisser ce coût moyen sur tout le jeu d’entraînement.
À retenir : Un seul nombre (la moyenne des scores d'erreur) pour piloter l'apprentissage.
En résumé : Coût moyen = moyenne des losses sur toutes les images d'entraînement. Un seul nombre pour piloter l'apprentissage.
Trouver le minimum
Maintenant qu'on sait mesurer l'erreur (le score d'erreur), on veut la faire baisser. Comment ? En regardant la pente et en faisant un pas vers le bas, encore et encore.
Objectif : Comprendre qu'on ne calcule pas le minimum exact ; on part des poids actuels, on regarde la pente, on fait un pas vers le bas, et on répète.
Pour toi (avec Léo) : Le haut de la colline = beaucoup d'erreur. Le fond = peu d'erreur. La balle cherche le fond. C'est comme ça que le réseau « descend » son erreur.
On veut que le score d'erreur (loss) soit la plus petite possible. Pour une fonction compliquée (avec des milliers de paramètres), on ne peut pas résoudre l'équation « pente = 0 » directement. L'idée est simple : à l'endroit où on est (les poids actuels), on regarde dans quelle direction la loss descend, on fait un petit pas dans cette direction, et on recommence. C'est comme une balle qui roule vers le bas d'une colline : elle suit la pente jusqu'à arriver dans un creux (un minimum).
Défi : Clique sur « Faire un pas » ou « Lancer » pour faire descendre la balle jusqu'en bas. Quand tu as réussi, tu comprends comment le réseau fait pareil avec ses milliers de réglages !
Voir concrètement : la « colline » = le score d'erreur (loss). La balle = notre position. Elle roule vers le minimum.
Axe horizontal = paramètre (poids) ; axe vertical = score d'erreur (loss). La balle roule vers le minimum.
Position = 0 (où est la balle sur la colline) | Pente = 0 (négatif → la balle va à droite pour descendre) | Score d'erreur = 0 (plus c'est petit, mieux c'est)
Chaque pas = une mise à jour des poids dans la direction qui fait baisser la loss. C'est l'idée de la descente de gradient.
À retenir : Faire baisser l'erreur = regarder la pente, faire un pas vers le bas, répéter. Comme la balle qui roule vers le fond de la vallée.
En résumé : Minimiser la loss = regarder la pente, faire un pas vers le bas, répéter. Métaphore : la balle qui roule vers le fond de la vallée.
Descente : la pente et le sens du pas
En une dimension (un seul paramètre), on voit la pente et le sens du pas. Dans la section suivante : quand il y a plein de réglages, la pente devient une flèche — le gradient.
Objectif : Comprendre qu'en 1D : pente négative → on va à droite pour descendre ; pente positive → on va à gauche. La taille du pas peut être proportionnelle à la pente.
Imagine une courbe (une dimension) : le score d'erreur (loss) en fonction d'un seul paramètre. Si la pente est négative, la courbe descend vers la droite → on décide d'augmenter un peu le paramètre (aller à droite). Si la pente est positive, la courbe monte vers la droite → on diminue le paramètre (aller à gauche). Si la taille du pas est proportionnelle à la pente, quand on s'approche du minimum (pente qui s'annule), les pas deviennent tout petits : on évite de « dépasser » le creux.
Voir : la pente (tangente) et la direction du pas (flèche). Pente négative → pas à droite ; pente positive → pas à gauche.
Astuce : utilise l'animation « La balle qui descend la colline » dans la section Trouver le minimum pour voir la pente et le sens du pas en action.
En résumé : Pente négative → pas vers la droite ; pente positive → pas vers la gauche. Pas proportionnel à la pente pour ne pas overshooter.
Le gradient (quand il y a plein de réglages)
Quand il y a plusieurs paramètres (pas juste un), la « pente » devient une flèche : le gradient. Même idée que la balle qui descend, mais en plein de directions à la fois.
Objectif : Comprendre qu'en plusieurs dimensions la « pente » devient un vecteur (le gradient) qui indique la direction de montée la plus raide ; son opposé donne la descente la plus rapide.
Pour toi (avec Léo) : Le gradient = la flèche qui indique où l'erreur monte le plus. On va dans l'autre sens pour la faire descendre.
Quand il y a plusieurs paramètres (pas juste un), la « pente » devient un vecteur : le gradient. Ce vecteur indique la direction dans laquelle le score d'erreur (loss) monte le plus vite. La longueur du gradient indique à quel point la pente est raide. Donc si on va dans la direction opposée (moins le gradient), on descend le plus vite. L'algorithme s'appelle descente de gradient : à chaque étape, on calcule le gradient, on fait un pas dans la direction opposée, et on répète.
Formule du pas : à chaque mise à jour, nouvelle position = ancienne position − η × gradient. En notation mathématique : le pas est −η∇C, où ∇C est le gradient de la fonction de coût et η (êta) le taux d'apprentissage. C'est ce pas qu'on soustrait des poids et biais pour faire baisser la loss.
Voir en 2D : courbes de niveau du score d'erreur (loss). ∇ = gradient (monte) ; flèche verte = descente (vers le minimum).
La flèche rouge = où l'erreur monte ; la flèche verte = où on va pour la faire descendre.
Que fait la descente de gradient ?
En résumé : Le gradient = direction de montée la plus raide. Descente de gradient = faire un pas dans la direction opposée pour diminuer la loss.
Taux d'apprentissage (taille du pas)
Objectif : Comprendre que la taille du pas (learning rate, η) fixe de combien on avance à chaque fois : trop grand = oscillations ou dépassement ; trop petit = avancée lente.
La taille du pas à chaque mise à jour s'appelle le taux d'apprentissage (ou learning rate, souvent noté η). S'il est trop grand, on peut sauter de l'autre côté du minimum et osciller sans converger, ou « dépasser » (overshooting). S'il est trop petit, on avance très lentement et l'entraînement prend beaucoup de temps. En pratique, on choisit une valeur qui fait baisser le score d'erreur (loss) de façon régulière (tu peux observer la courbe dans la section Entraînement du chapitre 1).
Voir concrètement : même colline, mais tu choisis la taille du pas. Trop grand = la balle dépasse et oscille. Trop petit = on avance lentement.
Taille du pas (η) :
Même courbe de score d'erreur (loss). La taille du pas (η) fixe de combien la balle se déplace à chaque clic.
Position = 0 (où est la balle) | Pente = 0 | Pas = 0 (de combien elle avance)
Le learning rate (η) est un hyperparamètre : trop grand on oscille, trop petit l’entraînement est lent. En pratique on le règle pour une descente stable.
Si le learning rate est trop grand, que peut-il se passer ?
À retenir : Taille du pas trop grande → la balle dépasse et oscille ; trop petite → on avance tout doucement.
En résumé : Learning rate = taille du pas. Trop grand → oscillations ; trop petit → lent. Il faut le régler pour une descente stable.
Et dans notre réseau ? 13 002 réglages
Objectif : Comprendre que le gradient est un vecteur avec autant de composantes que de poids et biais (environ 13 mille) ; la rétropropagation calcule ce vecteur efficacement.
Pour toi (avec Léo) : Imagine 13 002 boutons à tourner. Le gradient te dit pour chaque bouton : « tourne un peu plus à gauche » ou « à droite ». C'est environ 13 mille réglages (comme le nombre de mots dans un long texte).
Notre réseau a des milliers de poids et biais (par ex. 13 002, soit environ 13 mille). Le gradient est alors un vecteur avec 13 002 nombres : une petite modification suggérée pour chaque paramètre. Chaque composante dit : augmenter ou diminuer ce poids, et dans quelle mesure ce changement compte. Certains poids ont un impact fort sur le score d'erreur (loss), d'autres faible ; le gradient encode cette importance. L'algorithme qui calcule ce gradient efficacement s'appelle la rétropropagation (tu l'as vue au chapitre 1) : l'erreur « remonte » de la sortie vers les couches pour dire comment modifier chaque connexion.
Voir : le gradient = un vecteur avec une composante par paramètre (13 002 réglages). La rétropropagation le calcule en une passe.
∇ = gradient (13 002 nombres)
Chaque segment = une composante du gradient (un poids ou un biais). L'animation suggère le flux de la rétropropagation.
En résumé : Gradient = vecteur de 13 002 « coups de réglage ». La rétropropagation calcule ce vecteur pour tout le réseau.
En pratique
Objectif : Savoir où aller pour voir le score d'erreur (loss) et la précision en action (entraînement du chapitre 1).
Voir en pratique : Va dans la section Entraînement du chapitre 1. Lance quelques epochs et regarde la courbe du score d'erreur (loss) (elle doit baisser) et la précision (elle doit monter). Le bloc « Avant / Après entraînement » te montre la même image avant et après : tu vois que les poids ont changé et que la prédiction s'améliore.
En résumé : Entraînement (chapitre 1) → courbe du score d'erreur (loss) qui baisse, précision qui monte. C'est la descente de gradient en action.
L'intelligence artificielle ne « pense » pas : pourquoi l'apprentissage machine est un simple exercice de calcul
1. Introduction : Le mystère du chiffre manuscrit
Comment un ordinateur parvient-il à reconnaître un « 3 » griffonné à la main ? Pour nous, c'est une évidence visuelle immédiate. Pour une machine, ce qui ressemble à de la « pensée » est en réalité une orchestration mathématique rigoureuse. Tout commence par une grille de 28×28 pixels. Ces 784 valeurs de gris constituent les entrées d'un réseau de neurones organisé en couches.
À l'intérieur de ce réseau, aucun concept abstrait ne circule. Ce sont 13 002 paramètres — des poids et des biais — qui agissent comme autant de curseurs invisibles, filtrant l'information pour transformer le chaos des pixels en une prédiction claire. Ce que nous percevons comme une intuition cognitive est le produit d'une architecture logique où chaque connexion a été finement ajustée.
2. L'apprentissage n'est qu'un exercice de calcul
L'un des plus grands malentendus concernant l'IA est l'idée que la machine « apprend » par curiosité ou par imitation humaine. En réalité, le processus est radicalement différent : on ne dicte pas à l'ordinateur les règles géométriques d'un chiffre. On utilise un algorithme qui sculpte les 13 002 paramètres du réseau pour qu'il devienne plus précis face à des exemples réels.
Une fois qu'on voit comment ça marche, ça ressemble moins à de la science-fiction qu'à un exercice de calcul. Cette distinction est capitale pour quiconque souhaite comprendre la technologie actuelle. L'apprentissage machine n'est pas une quête de conscience, mais un pur exercice d'optimisation. Il s'agit de trouver le point le plus bas d'une fonction mathématique complexe. Une fois la magie dissipée, il ne reste que du calcul différentiel.
3. La fonction de coût : apprendre par l'échec
Pour qu'un réseau s'améliore, il doit disposer d'une mesure objective de sa propre médiocrité. C'est le rôle de la « fonction de coût ». Lorsqu'on initialise un réseau, ses poids et biais sont aléatoires ; face à l'image d'un « 3 », sa réponse sera un bruit numérique incohérent.
La fonction de coût quantifie cette erreur en calculant la somme des carrés des différences entre les activations obtenues et les valeurs cibles (un « 1 » pour le neurone du 3, et des « 0 » pour les autres). Mais attention : pour être réellement efficace, la machine ne se contente pas d'évaluer une seule image. Elle calcule le coût moyen sur les dizaines de milliers d'exemples de la base MNIST. Plus ce coût moyen est élevé, plus le réseau « doit se sentir mal » (métaphoriquement). Ce chiffre unique résume à lui seul à quel point les 13 002 paramètres actuels sont éloignés de la solution.
4. La descente de gradient : la balle qui roule vers la solution
Puisqu'il est impossible de deviner instantanément la configuration parfaite dans un paysage aussi vaste, on utilise la « descente de gradient ». L'analogie est physique : imaginez une balle que l'on lâche sur un relief accidenté et qui roule naturellement vers le fond de la vallée.
Voici les trois concepts clés de cette progression :
- La pente (le slope) : elle indique la direction dans laquelle il faut ajuster les paramètres pour descendre le plus vite possible. Elle guide la machine pour savoir s'il faut augmenter ou diminuer chaque poids.
- Le pas (le learning rate) : c'est la taille de l'ajustement. S'il est bien dosé, il diminue à l'approche du fond pour gagner en précision. Cependant, s'il est trop grand, la balle risque de bondir par-dessus la vallée, provoquant des oscillations instables ou un dépassement de la cible (overshooting).
- Le minimum local : le risque est de rester coincé dans une petite cuvette, une solution « satisfaisante » mais qui n'est pas le point le plus bas du relief global.
5. 13 002 ajustements : la direction dans l'hyper-espace
Le gradient n'est pas une simple valeur, c'est un vecteur unique dans un espace à 13 002 dimensions. Imaginez une flèche pointant dans une direction incroyablement complexe, indiquant simultanément comment modifier chacun des 13 002 réglages pour réduire le coût le plus efficacement possible.
Chaque composante de ce vecteur nous indique quels changements offrent le meilleur rendement. Certains poids, parce qu'ils sont liés à des traits caractéristiques essentiels du chiffre « 3 », ont un impact massif sur le coût, tandis que d'autres sont négligeables. Le gradient encode cette hiérarchie de l'importance, permettant au réseau de prioriser les connexions qui transforment réellement le signal en reconnaissance.
6. Conclusion : De l'optimisation à la compréhension
En résumé, ce que nous nommons « apprentissage » est le résultat d'une minimisation rigoureuse d'une fonction de coût. Bien que nous maîtrisions chaque étape mathématique — du calcul des pentes à la rétropropagation du gradient — le résultat final n'en demeure pas moins une prouesse d'émergence technologique. C'est de cette simple mécanique de précision que surgit la capacité de la machine à identifier des motifs que nous pensions réservés à l'esprit humain.
Cela nous impose une réflexion : si notre propre capacité à reconnaître un visage ou un chiffre peut être réduite à un calcul de pente dans un espace à haute dimension, que reste-t-il de l'étincelle humaine face à la pure puissance de l'optimisation ?
Générés par NotebookLM (Google).
Quiz : teste ta compréhension
Objectif : Répondre à des questions sur le chapitre 2 (fonction de coût, gradient, learning rate) et obtenir une note sur 20.
Choisis un quiz :
Cartes mémoire
Cartes mémoire (flashcards) pour réviser les notions du chapitre 2.
Chargement…
Générés par NotebookLM (Google).
Fiche enseignant
Contenu de la fiche pédagogique pour le chapitre 2 (objectifs, durée par section, réponses aux quiz, idées d'activités).
Objectifs pédagogiques (Chapitre 2)
- Comprendre que la fonction de coût (loss) mesure l'erreur du réseau.
- Comprendre l'idée de minimisation : regarder la pente, faire un pas vers le bas, répéter.
- Comprendre le gradient comme direction de descente la plus rapide.
- Comprendre le rôle du taux d'apprentissage (learning rate).
- Savoir que la rétropropagation calcule le gradient pour tous les poids.
- Utiliser le quiz chapitre 2 pour évaluer la compréhension (note sur 20).
Niveau et prérequis
Niveau : fin primaire / collège (6e–3e).
Prérequis : avoir vu le chapitre 1 (structure du réseau, pixels, neurones, rétropropagation).
Durée indicative : 45 min à 1 h pour le parcours complet du chapitre 2.
Structure du parcours (Chapitre 2)
| Section | Durée indicative | Objectif |
|---|---|---|
| Accueil | 5 min | Présenter l'objectif du chapitre 2 (loss, gradient, learning rate). |
| Lexique | 5 min | Définitions : coût, gradient, descente de gradient, taux d'apprentissage. |
| Rappel | 5 min | Rappel 784→64→64→10, poids et biais. |
| Données d'entraînement | 5 min | Exemples étiquetés, entraînement vs test, MNIST. |
| Fonction de coût | 10 min | Loss = mesure de l'erreur, somme des carrés. |
| Coût moyen | 5 min | Moyenne sur tout le jeu d'entraînement. |
| Minimiser / Pente / Gradient | 15 min | Métaphore balle, descente de gradient. |
| Learning rate / Dimensions | 10 min | Taille du pas, 13 002 dimensions, rétropropagation. |
| En pratique | 5 min | Lien vers entraînement chapitre 1, courbes. |
| Quiz | 10 min | Quiz final chapitre 2, note sur 20. |
Réponses aux quiz courts (Chapitre 2)
- À quoi sert la fonction de coût ? → À mesurer à quel point le réseau se trompe.
- Que fait la descente de gradient ? → Elle modifie les poids dans la direction qui fait baisser la loss.
- Si le learning rate est trop grand ? → On peut osciller ou dépasser le minimum.
Réponses au quiz final Chapitre 2
- À quoi sert la fonction de coût ? → À mesurer l'erreur du réseau.
- Que fait la descente de gradient ? → Modifie les poids pour faire baisser la loss.
- Learning rate trop grand ? → Oscillations ou dépassement.
- Qu'est-ce que le gradient ? → Vecteur indiquant la direction de montée la plus raide (opposé = descente).
- Données d'entraînement vs test ? → Entraînement = exemples pour ajuster ; test = images jamais vues pour mesurer.
- Qui calcule le gradient ? → La rétropropagation.
- Coût moyen ? → Moyenne des losses sur toutes les images d'entraînement.
- Métaphore de la balle ? → Elle roule vers le bas (minimum) en suivant la pente.
Barème : 20 / nombre de questions par bonne réponse.
Idées d'activités
- Débat : « L'IA pense-t-elle vraiment ? » (après la section « L'IA ne pense pas »).
- Expérience : Lancer l'entraînement (chapitre 1) et observer la courbe de loss en direct.
- Trace écrite : Noter les mots du lexique chapitre 2 et une phrase par section.
Technique
Même environnement que le chapitre 1. Le chapitre 2 ne charge pas le réseau MNIST ; les liens « En pratique » pointent vers le chapitre 1.
