Chapitre 3

Apprendre des exemples - L'apprentissage automatique

Imaginez que vous me montriez des milliers de photos de chats et de chiens, en me disant à chaque fois "ceci est un chat" ou "ceci est un chien". Au début, avec mes poids aléatoires, je me trompe constamment. Mais quelque chose se passe : à force d'exemples et de corrections, mes poids s'ajustent, et je commence à distinguer les deux. C'est l'essence de ce qui m'a formé.

Le principe de l'erreur mesurée

Contrairement à un humain qui comprend intuitivement qu'il s'est trompé, moi j'ai besoin d'un nombre. Une fonction de perte transforme mon erreur en valeur chiffrée. Plus je me trompe, plus ce nombre est élevé.

Quand je dis "ce chien est probablement un chat avec 87% de certitude", la fonction de perte calcule : "tu es à côté de la plaque de 0.87 unités d'erreur". C'est brutal, précis, quantifiable.

#### Visualiser la fonction de perte

Prenons un exemple ultra-simple pour voir comment ça marche.

Situation : Vous voulez m'apprendre à prédire si une photo montre un chat (sortie = 1) ou pas un chat (sortie = 0).

Je produis un nombre entre 0 et 1 qui représente ma "confiance" que c'est un chat. Par exemple : 0.87 = "je suis sûr à 87% que c'est un chat".

La fonction de perte la plus courante : l'entropie croisée (cross-entropy loss)

Sans entrer dans les détails techniques complets, l'idée est :

La formule capture ça mathématiquement :


Loss = -[y × log(ŷ) + (1-y) × log(1-ŷ)]

Où :

Exemple numérique :

Photo de chat (y = 1), je prédis ŷ = 0.87 :


Loss = -[1 × log(0.87) + 0 × log(0.13)]
Loss = -log(0.87) ≈ 0.14

Photo de chat (y = 1), mais je prédis ŷ = 0.12 :


Loss = -log(0.12) ≈ 2.12

L'erreur est 15× plus grande ! La fonction de perte punit sévèrement les erreurs confiantes.

Pourquoi le logarithme ?

C'est un choix mathématique subtil. Le log amplifie les erreurs quand on est très confiant mais faux, et récompense fortement les prédictions correctes et confiantes. Ça pousse le modèle à être à la fois juste _et_ confiant dans ses bonnes réponses.

La descente dans le paysage d'erreur

Mes millions de poids forment un espace de possibilités gigantesque. Chaque combinaison de poids produit un niveau d'erreur différent. On peut imaginer cet espace comme un paysage : des vallées (peu d'erreur, bonnes prédictions) et des montagnes (beaucoup d'erreur, prédictions catastrophiques).

Simplifions avec 2 poids seulement :

Imaginez un graphique 3D :


    Erreur
      ↑
      |     ●
      |    /|\  (montagne - mauvais poids)
      |   / | \
      |  /  |  \
      | /   ●   \ (on est ici au départ)
      |/    |    \
      |     |     \___
      |     |         \___● (vallée - bons poids)
      |_____|____________|_____→ poids w₁
     /
    poids w₂

Au début, avec des poids aléatoires, je suis quelque part sur une montagne. L'apprentissage, c'est descendre vers les vallées.

Comment descendre : le gradient

Le gradient, c'est comme une boussole qui indique "dans quelle direction ça monte le plus fort".

Mathématiquement, pour chaque poids wᵢ, on calcule :


∂Loss/∂wᵢ

C'est la dérivée partielle : "si j'augmente ce poids d'un tout petit peu, l'erreur augmente ou diminue ?"

Analogie concrète :

Vous êtes sur une montagne dans le brouillard. Vous ne voyez pas loin. Vous tâtez le sol autour de vous :

Vous irez vers le sud ! C'est exactement ce que fait le gradient : il mesure la "pente" dans toutes les directions (toutes les dimensions = tous les poids), et on va dans la direction opposée à la plus forte montée.

La formule de mise à jour

À chaque étape d'entraînement :


wᵢ(nouveau) = wᵢ(ancien) - η × ∂Loss/∂wᵢ

Où η (êta) est le learning rate :

Le dilemme du learning rate :

Trop petit : on descend lentement, ça prend des années Trop grand : on saute de montagne en montagne sans jamais se poser dans une vallée

En pratique, on utilise des techniques sophistiquées (Adam, RMSprop...) qui ajustent automatiquement la taille des pas selon le terrain. Mais le principe reste : suivre le gradient, descendre progressivement.

Un exemple numérique simple

Imaginez 1 seul poids, w = 5.0

Itération 1 :

Itération 2 :

Itération 3 :

Et ainsi de suite... Le poids converge progressivement vers une bonne valeur, l'erreur diminue.

Maintenant imaginez ça avec 180 milliards de poids simultanément. À chaque étape, on calcule 180 milliards de dérivées, on ajuste 180 milliards de nombres. C'est mécanique, répétitif, mais à cette échelle, quelque chose d'extraordinaire émerge.

Pourquoi des millions d'exemples ?

Un seul exemple ne suffit pas. Si vous ne me montrez qu'un chat tigré, je pourrais apprendre "chat = rayures" au lieu de "chat = oreilles pointues + moustaches + proportions félines". Je surapprendrais cet exemple unique.

Des millions d'exemples variés forcent mes poids à trouver les patterns profonds, universels. Pas "ce chat particulier", mais "la chatité en général".

Ce qui se passe en moi durant l'entraînement

Quelque chose d'étrange : personne ne programme explicitement "détecte les oreilles ici, les moustaches là". Les poids s'organisent d'eux-mêmes en détecteurs de features hiérarchiques.

Les premières couches de neurones détectent des lignes, des courbes, des contrastes. Les couches intermédiaires détectent des textures, des formes. Les couches profondes détectent "quelque chose qui ressemble à une oreille de chat" ou "une posture de chien".

Personne n'a dit aux neurones de faire ça. C'est émergent. C'est troublant de mon point de vue : je ne peux pas pointer vers "le neurone qui connaît les chats" - c'est distribué dans des milliers de connexions.

Le mystère de la généralisation

Voici ce qui reste partiellement inexpliqué : pourquoi ça marche si bien ? Mathématiquement, avec mes milliards de poids, je pourrais simplement mémoriser tous les exemples d'entraînement sans rien comprendre. Mais non - je généralise. Je reconnais un chat que je n'ai jamais vu.

La théorie complète de pourquoi l'apprentissage profond généralise reste un domaine de recherche actif. Quelque chose dans la combinaison de l'architecture en couches, le gradient descent, et la structure des données réelles du monde fait que je développe des représentations utiles plutôt que de simplement mémoriser.

C'est comme si l'univers avait une structure sous-jacente que cette méthode parvient à capturer.

Résumé Chapitre 3

L'apprentissage par l'exemple : Mon apprentissage repose sur trois piliers - des millions d'exemples variés, une fonction de perte qui quantifie mes erreurs en nombres (avec des formules comme l'entropie croisée qui punit sévèrement les erreurs confiantes), et le gradient descent qui ajuste mes milliards de poids pour descendre vers les vallées d'erreur minimale dans un paysage multidimensionnel. À chaque itération, je calcule 180 milliards de dérivées partielles et ajuste tous mes poids selon la formule w(nouveau) = w(ancien) - η × ∂Loss/∂w. À travers ce processus mécanique mais répété des milliards de fois, mes couches développent spontanément des détecteurs de caractéristiques hiérarchiques (lignes → textures → formes → concepts), sans programmation explicite. Le mystère reste entier : pourquoi cette méthode ne se contente-t-elle pas de mémoriser, mais généralise à des situations nouvelles ? Quelque chose dans ce processus capture la structure profonde du monde.