1 · Le neurone artificiel : une somme pondérée, puis une décision
Un neurone artificiel reçoit plusieurs nombres en entrée, en fait une somme pondérée, ajoute une constante, et passe le résultat dans une fonction qui décide de « l'activation » du neurone. L'analogie avec le neurone biologique s'arrête là : c'est une unité de calcul, définie par trois choses.
- Les entrées x₁, x₂, …, xₙ : les nombres qu'on lui donne — des pixels, des mesures de capteurs, les sorties d'autres neurones.
- Les poids w₁, w₂, …, wₙ : un coefficient par entrée. Un poids grand et positif signifie « cette entrée compte beaucoup, dans ce sens » ; proche de zéro, « cette entrée ne compte pas » ; négatif, « cette entrée joue contre ». Ce sont les poids que l'apprentissage modifie.
- Le biais b : une constante ajoutée à la somme, qui déplace le seuil de déclenchement. Sans biais, un neurone dont toutes les entrées valent zéro sortirait toujours zéro ; le biais lui donne un point de départ réglable.
Le calcul complet s'écrit en une ligne : z = w₁x₁ + w₂x₂ + … + wₙxₙ + b, puis a = σ(z), où σ est la fonction d'activation. On note souvent la somme pondérée comme un produit scalaire, z = w·x + b.
Les poids et le biais sont les paramètres du neurone : ce que l'entraînement modifie, et la seule chose que le neurone conserve une fois entraîné. Les entrées et la sortie sont des activations : ce qui circule, recalculé à chaque passage. L'erreur δ dont il sera question à la section 7 n'appartient à aucune de ces deux catégories : ce n'est pas un attribut du neurone mais une quantité de travail, calculée pour chaque neurone pendant un pas d'entraînement, utilisée pour corriger ses poids, puis oubliée. Pendant l'entraînement seulement, on garde aussi en mémoire z et a de la passe avant, parce que la passe arrière en a besoin — c'est ce qui explique qu'entraîner un réseau demande deux à trois fois plus de mémoire que l'utiliser.
Un exemple concret. Un neurone doit estimer si un fournisseur risque un retard de livraison, à partir de trois entrées normalisées entre 0 et 1 : la distance (x₁), la part de ce fournisseur dans le volume (x₂), le nombre de retards l'an passé (x₃). Avec les poids w = (0,3 ; −0,2 ; 0,9) et le biais b = −0,4, un fournisseur à x = (0,5 ; 0,8 ; 0,6) donne z = 0,15 − 0,16 + 0,54 − 0,4 = 0,13. Le poids de 0,9 sur les retards passés dit que c'est le signal dominant ; le poids négatif sur la part de volume dit qu'un gros fournisseur est plutôt fiable. Personne n'a écrit ces règles : ce sont des nombres, et l'apprentissage va les ajuster.
2 · Les fonctions d'activation : introduire la non-linéarité
Si chaque neurone ne faisait qu'une somme pondérée, empiler des couches ne servirait à rien : une composition de fonctions linéaires est encore une fonction linéaire, et le réseau entier ne saurait tracer que des droites. La fonction d'activation, appliquée après la somme, casse cette linéarité. C'est elle qui permet au réseau d'approcher des formes arbitrairement complexes — un résultat démontré en 1989 (théorème d'approximation universelle de Cybenko puis Hornik) : une seule couche cachée suffisamment large peut approcher n'importe quelle fonction continue.
La marche du perceptron n'est pas dérivable, donc inutilisable pour l'apprentissage par gradient. La sigmoïde et tanh sont lisses mais « saturent » : loin de zéro, leur pente est presque nulle et le signal d'apprentissage s'éteint. ReLU (Rectified Linear Unit) n'a pas ce défaut pour z > 0 et coûte une seule comparaison : c'est l'activation par défaut des réseaux profonds depuis 2012. Sigmoïde et tanh se ressemblent à dessein : tanh est une sigmoïde étirée et recentrée — tanh(z) = 2·σ(2z) − 1. La différence est l'échelle des sorties, entre 0 et 1 pour l'une (avec 0,5 au centre, ligne pointillée), entre −1 et 1 pour l'autre (avec 0 au centre), et la pente au centre, quatre fois plus forte pour tanh. Les quatre panneaux sont tracés à la même échelle, z de −4 à +4.
Pourquoi parler de dérivées ? Parce qu'apprendre, pour un réseau, consiste à ajuster ses poids dans le sens qui réduit l'erreur (sections 6 et 7). Pour savoir dans quel sens pousser un poids, il faut connaître la pente de chaque fonction traversée par le signal : si je modifie un peu z, de combien bouge la sortie ? C'est exactement ce que mesure la dérivée. Une fonction d'activation doit donc être dérivable, et sa dérivée doit rester bon marché à calculer, car on l'évalue des milliards de fois. Celle de la sigmoïde s'exprime à partir de sa propre valeur, σ(z)·(1 − σ(z)) ; celle de ReLU vaut 1 si z > 0 et 0 sinon — une simple comparaison.
Dans les couches cachées, la réponse est presque toujours ReLU. En sortie, l'activation est choisie selon la forme de la réponse attendue, et c'est là qu'intervient softmax, qui n'a rien à voir avec ReLU. ReLU s'applique à un neurone isolé et laisse passer les valeurs positives. Softmax s'applique à toute une couche de sortie à la fois : elle prend les scores bruts z₁, z₂, …, zₖ des k neurones de sortie et les transforme en k nombres positifs dont la somme fait 1, soit une distribution de probabilités. Formule : softmaxᵢ = exp(zᵢ) / Σⱼ exp(zⱼ). Avec trois scores (2,0 ; 1,0 ; 0,1), on obtient (0,66 ; 0,24 ; 0,10) : le premier candidat l'emporte, mais le réseau exprime aussi son doute.
| Question posée au réseau | Forme de la sortie | Activation de sortie | Exemple concret |
|---|---|---|---|
| Oui ou non ? | Une probabilité entre 0 et 1 | Sigmoïde | Ce fournisseur livrera-t-il en retard ? Cette pièce est-elle défectueuse ? Ce courriel est-il un hameçonnage ? |
| Lequel parmi k ? | k probabilités qui somment à 1 | Softmax | Quel type de défaut sur cette photo de soudure (fissure, porosité, inclusion, aucun) ? Quel mot vient ensuite, parmi 100 000 tokens ? |
| Plusieurs oui/non à la fois | k probabilités indépendantes | Une sigmoïde par sortie | Quels risques cette usine cumule-t-elle (inondation, sécheresse, canicule) ? Plusieurs réponses peuvent être vraies en même temps. |
| Combien ? | Un nombre réel, sans borne | Aucune (sortie linéaire) | Quel délai de livraison, en jours ? Quelle consommation électrique demain, en MWh ? Quel prix de l'urée le mois prochain ? |
Une distinction mérite d'être explicitée : la sigmoïde, tanh et ReLU agissent neurone par neurone, alors que softmax agit sur toute la couche. Dans le premier cas, la sortie d'un neurone ne dépend que de sa propre somme z ; les neurones d'une même couche s'ignorent, et c'est voulu — le calcul est trivialement parallèle, et rien ne justifie de coupler des détecteurs qui cherchent des choses différentes. C'est le cas général, et c'est le seul cas dans les couches cachées. Softmax existe pour une raison précise : quand la question est « laquelle de ces k réponses ? », les réponses sont en concurrence — une seule est vraie — et la probabilité de « fissure » n'a de sens que rapportée aux scores de « porosité », « inclusion » et « aucun défaut ». Il faut donc regarder tous les scores à la fois pour normaliser : chaque sortie est divisée par la somme des exponentielles de toutes les autres. Augmenter le score d'une classe fait mécaniquement baisser la probabilité des autres, ce qu'une sigmoïde par neurone ne ferait jamais.
Avec deux classes, softmax se réduit exactement à une sigmoïde sur la différence des scores : la sigmoïde est le cas particulier k = 2. Le même mécanisme « par couche » sert ailleurs : dans le Transformer, c'est un softmax qui répartit l'attention d'un token entre tous les autres, et les couches de normalisation (batch norm, layer norm, section 9) agissent elles aussi sur un ensemble de neurones à la fois — mais ce ne sont pas des activations, elles ne cassent pas la linéarité, elles remettent à l'échelle.
Et dans les couches cachées : quelle fonction, et pour quels neurones ?
Première règle, presque sans exception : tous les neurones d'une même couche cachée utilisent la même fonction d'activation. Rien ne l'interdit techniquement — chaque neurone pourrait avoir la sienne — mais rien ne le justifie non plus : les neurones d'une couche jouent le même rôle (détecter des motifs dans la couche précédente), leurs poids se chargent de les différencier, et une activation uniforme permet de calculer toute la couche en une seule opération matricielle sur GPU. Les seules constructions qui mélangent des activations le font de manière structurée, pas neurone par neurone : les portes des LSTM combinent des sigmoïdes (qui décident « combien laisser passer », entre 0 et 1) et des tanh (qui portent le contenu) ; les blocs GLU/SwiGLU des modèles de langage récents (Llama, Mistral) coupent une couche en deux moitiés, l'une passant par SiLU, l'autre linéaire, et multiplient les deux — la première sert de porte à la seconde. Dans les deux cas, chaque moitié reste uniforme.
Deuxième règle : le choix se fait par famille d'architecture, et l'on prend la valeur par défaut de sa famille. ReLU pour les perceptrons multicouches et les réseaux convolutifs classiques ; GELU pour les Transformers depuis BERT et GPT-2 ; SiLU (aussi appelée Swish) pour les détecteurs d'images récents comme YOLO ou EfficientNet et, sous forme SwiGLU, pour les grands modèles de langage ouverts. Ces variantes de ReLU corrigent son seul vrai défaut : un neurone dont z est négatif pour tous les exemples a une dérivée nulle, ne reçoit plus de gradient et ne se réveille jamais — le neurone « mort », qui peut toucher 10 à 40 % d'une couche mal initialisée. Leaky ReLU laisse passer une petite pente (0,01 à 0,1) du côté négatif ; GELU et SiLU sont des versions lisses qui laissent passer un peu de signal négatif près de zéro. Sigmoïde et tanh ne s'emploient plus dans les couches cachées d'un réseau profond, à cause de la saturation vue plus haut ; tanh subsiste dans les petits réseaux et les récurrents.
À droite de zéro, les quatre sont quasiment identiques ; tout se joue autour de zéro et à gauche. ReLU coupe net (dérivée nulle) ; Leaky garde une pente ; GELU et SiLU passent légèrement sous zéro, ce qui adoucit l'optimisation.
| Fonction | Où on la trouve | Quand la choisir | Coût |
|---|---|---|---|
| ReLU | Perceptrons multicouches, CNN classiques (ResNet), réseaux embarqués | Par défaut sur données tabulaires, capteurs, images ; le choix le plus rapide à exécuter et à quantifier | Une comparaison |
| Leaky ReLU | Anciennes versions de YOLO, GAN | Quand une part notable des neurones ReLU meurt (activations à zéro sur tout un lot) | Une comparaison |
| GELU | BERT, GPT-2/3, Vision Transformers | Par défaut dans un Transformer ; rarement un gain ailleurs | Une erf ou son approximation |
| SiLU / Swish, SwiGLU | YOLO v5 et suivants, EfficientNet, Llama, Mistral | Par défaut dans ces familles ; SwiGLU si l'on construit un modèle de langage | Une exponentielle |
| tanh | LSTM/GRU, petits réseaux, couches de contrôle | Quand la sortie d'une couche doit rester bornée et centrée (signal de commande, état d'un réseau récurrent) | Une exponentielle |
| Sigmoïde | Portes des LSTM, mécanismes d'attention par canal | Jamais comme activation cachée ordinaire ; seulement comme « porte » entre 0 et 1 | Une exponentielle |
Troisième règle, la plus utile pour une organisation qui fait entraîner un modèle : ce choix pèse peu. Entre ReLU et GELU sur un même réseau, l'écart de performance se mesure en fractions de point ; la profondeur, la largeur, la qualité des données et la durée d'entraînement pèsent dix fois plus. On ne change l'activation par défaut de sa famille que sur un constat précis — des neurones morts, une quantification qui se passe mal — et jamais neurone par neurone.
3 · Du neurone au réseau : couches, largeur, profondeur
Un réseau est un assemblage de neurones organisés en couches. La couche d'entrée ne calcule rien : elle expose les données. Chaque couche cachée est un rang de neurones qui reçoivent tous les mêmes entrées — les sorties de la couche précédente — mais chacun avec ses propres poids et son propre biais. La couche de sortie produit la réponse. Quand chaque neurone d'une couche est relié à tous ceux de la suivante, on parle de réseau entièrement connecté, ou perceptron multicouche.
Compte des paramètres : (3×4 + 4) + (4×4 + 4) + (4×2 + 2) = 16 + 20 + 10 = 46 poids et biais. Le même comptage donne 175 milliards pour GPT-3 : la mécanique est identique, seule l'échelle change.
La largeur (nombre de neurones par couche) et la profondeur (nombre de couches) sont des choix de conception, pas des paramètres appris. Une intuition utile : chaque couche transforme la représentation des données, et les couches successives construisent des notions de plus en plus abstraites. Sur des images, les premières couches d'un réseau entraîné détectent des contours, les suivantes des textures et des parties d'objets, les dernières des objets entiers — ce n'est pas programmé, c'est ce que l'apprentissage produit.
En notation matricielle, une couche entière se calcule d'un coup : a⁽ˡ⁾ = σ(W⁽ˡ⁾ a⁽ˡ⁻¹⁾ + b⁽ˡ⁾), où W⁽ˡ⁾ est la matrice des poids de la couche l (une ligne par neurone, une colonne par entrée). C'est cette forme qui rend les réseaux si adaptés aux cartes graphiques : un produit matriciel est massivement parallélisable.
4 · La passe avant, en chiffres
Prenons le plus petit réseau qui illustre tout le mécanisme : deux entrées x₁ et x₂, une couche cachée de deux neurones que nous appelons h₁ et h₂ (h pour hidden, caché), une sortie o, activation sigmoïde partout. Il doit apprendre à prédire une valeur cible y à partir de x = (x₁, x₂). Nous fixons des poids de départ arbitraires — dans la réalité ils sont tirés au hasard — et suivons l'exemple x = (1 ; 0,5), cible y = 1.
| Étape | Calcul | Résultat |
|---|---|---|
| z₁ (entrée de h₁) | w₁x₁ + w₂x₂ + b₁ = 0,5×1 + (−0,3)×0,5 + 0,1 | 0,45 |
| h₁ = σ(z₁) | 1 / (1 + e^(−0,45)) | 0,611 |
| z₂ (entrée de h₂) | w₃x₁ + w₄x₂ + b₂ = 0,8×1 + 0,2×0,5 + 0,1 | 1,00 |
| h₂ = σ(z₂) | 1 / (1 + e^(−1,00)) | 0,731 |
| z₃ (entrée de o) | w₅h₁ + w₆h₂ + b₃ = 0,7×0,611 + (−0,4)×0,731 + 0,1 | 0,235 |
| o = σ(z₃) | 1 / (1 + e^(−0,235)) | 0,558 |
Le réseau prédit 0,558 là où la cible vaut 1. Il se trompe de 0,442. Toute la question de l'apprentissage est : de combien et dans quel sens faut-il modifier chacun des neuf paramètres pour réduire cette erreur ?
5 · Mesurer l'erreur : la fonction de coût
Pour corriger, il faut d'abord mesurer. La fonction de coût (ou de perte, loss) résume en un seul nombre l'écart entre ce que le réseau prédit et ce qu'il aurait dû prédire, sur un ou plusieurs exemples. Deux choix dominent.
- L'erreur quadratique moyenne (MSE) pour prédire une valeur : C = ½ (o − y)². Sur notre exemple, C = ½ (0,558 − 1)² = 0,098. Le facteur ½ est là pour simplifier la dérivée.
- L'entropie croisée pour une classification : C = −[y log o + (1 − y) log(1 − o)]. Elle pénalise beaucoup plus fortement une prédiction confiante et fausse — prédire 0,01 quand la réponse est 1 coûte log(100) ≈ 4,6, contre 0,49 en MSE. C'est la fonction utilisée pour entraîner les modèles de langage, qui prédisent un token parmi des dizaines de milliers.
Le coût est une fonction des paramètres : pour des données fixées, changer un poids change la prédiction, donc le coût. On peut imaginer le coût comme un relief au-dessus de l'espace des paramètres — 9 dimensions pour notre réseau, 175 milliards pour GPT-3 — et l'apprentissage comme la recherche du point le plus bas de ce relief. Le problème : on ne voit pas le relief. On ne connaît que l'altitude là où l'on se trouve, et la pente sous ses pieds.
6 · La descente de gradient : suivre la pente
Reprenons l'image du relief. Un randonneur dans le brouillard veut descendre au fond de la vallée. Il ne voit rien, mais il sent, sous ses pieds, dans quel sens le sol descend le plus fort : c'est ce qu'il suit. Le gradient est la formalisation de cette sensation. Pour une fonction d'une seule variable, la dérivée dit de combien la fonction monte quand on avance d'un pas dans la seule direction possible. Notre coût dépend de neuf paramètres — neuf directions dans lesquelles on peut « avancer » — et la dérivée partielle ∂C/∂w₁ est la pente du coût quand on ne bouge que w₁, tous les autres paramètres restant figés. Le symbole ∂ (« d rond ») rappelle précisément qu'on ne fait varier qu'une variable à la fois. On la calcule pour chaque paramètre, et l'on range les neuf pentes dans un vecteur : c'est le gradient, ∇C = (∂C/∂w₁, ∂C/∂w₂, …, ∂C/∂b₃).
Chaque composante répond à la question « si j'augmente ce paramètre d'un tout petit peu, le coût augmente-t-il ou diminue-t-il, et à quelle vitesse ? ». Un exemple à deux paramètres : si ∂C/∂w₁ = −0,02 et ∂C/∂w₂ = +0,08, augmenter w₁ fait légèrement baisser le coût, augmenter w₂ le fait monter quatre fois plus vite. Le gradient (−0,02 ; 0,08) pointe vers la montée la plus raide ; pour descendre, on fait un pas dans la direction opposée, (+0,02 ; −0,08) : un peu plus de w₁, nettement moins de w₂. Voilà pourquoi on a besoin de dérivées partielles : elles sont la seule information locale disponible sur le relief, et elles suffisent à choisir la direction du prochain pas.
La règle de mise à jour tient en une ligne : w ← w − η · ∂C/∂w, pour chaque poids et chaque biais. Le coefficient η est le taux d'apprentissage (learning rate), la longueur du pas. Trop petit, la descente prend des milliers d'itérations de plus ; trop grand, on saute par-dessus le creux et le coût oscille ou diverge. Des valeurs typiques vont de 10⁻⁴ à 10⁻¹, souvent réduites progressivement au fil de l'entraînement.
Les pas raccourcissent naturellement à l'approche du minimum, parce que la pente s'aplatit : le gradient est plus petit, donc η·gradient aussi. C'est ce qui fait converger la méthode sans intervention.
En pratique, on ne calcule pas le gradient sur toutes les données à chaque pas — trop coûteux — mais sur un lot (mini-batch) de quelques dizaines à quelques milliers d'exemples d'entraînement tirés au hasard — un exemple étant un couple (entrée, réponse attendue) : une fiche fournisseur et son retard constaté, une photo de pièce et son étiquette « défaut / conforme », une phrase et son mot suivant. Un lot de 64 exemples, c'est donc 64 passes avant, 64 erreurs, et un seul gradient, moyenne des 64 : c'est la descente de gradient stochastique (SGD). Le gradient d'un lot est une estimation bruitée du vrai gradient, mais ce bruit aide souvent à sortir des creux peu profonds. Un passage sur l'ensemble des données s'appelle une époque ; un entraînement en compte de quelques-unes à quelques centaines. Les variantes modernes — momentum, RMSProp, Adam (2014), la plus utilisée — accumulent les gradients passés pour lisser la trajectoire et adapter le pas à chaque paramètre.
7 · La rétropropagation : calculer le gradient sans le deviner
Reste à obtenir ∂C/∂w pour chacun des paramètres. On pourrait le faire par tâtonnement — modifier un poids, recalculer le coût, mesurer la différence — mais cela demanderait une passe avant complète par paramètre : 175 milliards de passes pour un seul pas de GPT-3. La rétropropagation (backpropagation) obtient toutes les dérivées en une seule passe arrière, pour un coût comparable à celui de la passe avant. C'est l'algorithme qui a rendu les réseaux profonds entraînables ; décrit dès 1970 (Linnainmaa) et appliqué aux réseaux en 1986 par Rumelhart, Hinton et Williams.
Son principe est la règle de dérivation en chaîne, qui n'est qu'une façon de suivre une chaîne de causes. Sur notre petit réseau, le poids w₅ n'agit pas directement sur le coût : il modifie z₃ (la somme reçue par le neurone de sortie), qui modifie o (la sortie, après la sigmoïde), qui modifie C (l'écart à la cible). Trois maillons. Pensez à un train d'engrenages : si le premier engrenage tourne d'un cran, le dernier tourne d'un nombre de crans égal au produit des rapports intermédiaires. Ici, chaque « rapport » est une pente locale, facile à lire : ∂z₃/∂w₅ = h₁ (parce que z₃ = w₅h₁ + w₆h₂ + b₃, donc augmenter w₅ d'une unité augmente z₃ de h₁), ∂o/∂z₃ = o(1 − o) (la dérivée de la sigmoïde), ∂C/∂o = o − y (la dérivée de l'erreur quadratique). L'effet de w₅ sur le coût est le produit des trois : ∂C/∂w₅ = (o − y) × o(1 − o) × h₁.
Deux observations rendent ce calcul économique. D'abord, les deux premiers facteurs, (o − y) × o(1 − o), ne dépendent pas de w₅ : ils décrivent le neurone de sortie lui-même, de combien il s'est trompé et à quel point il est sensible. On les calcule une seule fois, on note le résultat δ₃ et on l'appelle l'erreur du neurone de sortie. Le gradient de w₅ est alors δ₃ × h₁, celui de w₆ est δ₃ × h₂, celui de b₃ est δ₃ tout court. Ensuite, la même idée s'applique un cran plus haut : le neurone caché h₁ ne connaît pas la cible, mais il sait qu'il a contribué à l'erreur δ₃ via le poids w₅. Son erreur propre est donc δ₁ = δ₃ × w₅ × h₁(1 − h₁) — l'erreur d'en aval, ramenée à lui par le poids qui les relie, et pondérée par sa propre sensibilité. S'il alimentait plusieurs neurones de sortie, il additionnerait leurs erreurs. Et les gradients de w₁ et w₂ s'obtiennent comme avant : δ₁ × x₁ et δ₁ × x₂.
C'est cela, la rétropropagation : l'erreur, calculée en sortie, est renvoyée de couche en couche vers l'entrée, chaque neurone recevant la part d'erreur qui lui revient. D'où le nom — l'erreur remonte le réseau à contre-courant. Une seule passe arrière fournit l'erreur δ de chaque neurone, et donc le gradient de chaque poids.
Le gradient d'un poids est toujours le produit de deux choses : l'erreur δ du neurone d'arrivée et l'activation du neurone de départ. Un poids ne bouge que si le neurone d'arrivée s'est trompé et que le neurone de départ était actif.
Les frameworks actuels (PyTorch, JAX) n'écrivent jamais ces dérivées à la main : ils enregistrent chaque opération de la passe avant dans un graphe et le parcourent à l'envers — c'est la différentiation automatique. Le principe reste exactement celui décrit ici.
8 · Un pas d'apprentissage complet, sur notre exemple
Reprenons le réseau 2-2-1 et son erreur de 0,442, avec un coût MSE et un taux d'apprentissage η = 0,5. Toutes les dérivées sont calculées avec les valeurs de la passe avant ; la dérivée de la sigmoïde vaut σ(1 − σ).
| Quantité | Formule | Calcul | Valeur |
|---|---|---|---|
| ∂C/∂o | o − y | 0,558 − 1 | −0,442 |
| δ₃ (erreur de la sortie) | (o − y) · o(1 − o) | −0,442 × 0,558 × 0,442 | −0,109 |
| ∂C/∂w₅ | δ₃ · h₁ | −0,109 × 0,611 | −0,0665 |
| ∂C/∂w₆ | δ₃ · h₂ | −0,109 × 0,731 | −0,0796 |
| ∂C/∂b₃ | δ₃ | −0,109 | |
| δ₁ (erreur de h₁) | δ₃ · w₅ · h₁(1 − h₁) | −0,109 × 0,7 × 0,611 × 0,389 | −0,0181 |
| δ₂ (erreur de h₂) | δ₃ · w₆ · h₂(1 − h₂) | −0,109 × (−0,4) × 0,731 × 0,269 | +0,0086 |
| ∂C/∂w₁, ∂C/∂w₂ | δ₁ · x₁, δ₁ · x₂ | −0,0181 × 1 ; −0,0181 × 0,5 | −0,0181 ; −0,0091 |
| ∂C/∂w₃, ∂C/∂w₄ | δ₂ · x₁, δ₂ · x₂ | 0,0086 × 1 ; 0,0086 × 0,5 | +0,0086 ; +0,0043 |
Lecture : le gradient de w₅ est négatif, donc augmenter w₅ réduit le coût — logique : h₁, le premier neurone caché, est actif (sa sortie vaut 0,611) et il pousse la sortie o vers le haut via w₅ positif ; comme o doit monter vers la cible 1, renforcer ce lien aide. Le gradient de w₃ est positif : il faut diminuer w₃, parce que h₂ pousse la sortie vers le bas via w₆ négatif, et que réduire h₂ aide. Personne n'a raisonné ainsi ; les signes sortent de la chaîne de dérivées.
Mise à jour, w ← w − 0,5 × gradient : w₅ passe de 0,7 à 0,733 ; w₆ de −0,4 à −0,360 ; b₃ de 0,1 à 0,154 ; w₁ de 0,5 à 0,509 ; w₃ de 0,8 à 0,796 ; b₁ de 0,1 à 0,109, et ainsi de suite. Nouvelle passe avant avec ces paramètres : o = 0,585, coût 0,086 au lieu de 0,098. Le coût a baissé de 12 % en un pas. Il en faudra quelques centaines pour que la sortie approche 1 ; sur des données réelles, chaque pas est fait sur un lot d'exemples différents, et c'est la moyenne de leurs gradients qui guide la descente.
Lecture du schéma : chaque flèche porte son ancien et son nouveau poids ; les quatre liens qui poussent la sortie vers le haut (w₁, w₂, w₅, w₆) sont renforcés, les deux qui alimentent h₂ — dont l'effet sur la sortie est négatif via w₆ — sont affaiblis. Les erreurs δ, calculées pendant la passe arrière, sont indiquées à côté des neurones ; elles n'y restent pas une fois le pas terminé.
Chaque tour de boucle traite un lot d'exemples et déplace tous les paramètres d'un petit pas. Sur notre réseau, un tour a fait passer le coût de 0,098 à 0,086 ; GPT-3 a fait près de cent mille tours sur des lots de 3,2 millions de tokens (300 milliards de tokens au total).
9 · Entraîner pour de vrai : ce qui complique l'image
L'algorithme est simple ; le faire fonctionner à grande échelle a demandé trente ans d'ingénierie. Quelques difficultés et leurs remèdes.
Initialisation
Des poids tous nuls donnent des neurones identiques qui apprennent la même chose ; des poids trop grands saturent les activations. On tire donc les poids au hasard, mais pas n'importe comment : leur dispersion est calibrée sur le nombre d'entrées du neurone. La raison est arithmétique : z est la somme de n produits wᵢxᵢ ; si les entrées ont une dispersion de 1 et les poids une dispersion de 1, la somme de n termes a une dispersion de √n — avec 1 000 entrées, z vaut couramment ±30, et la sigmoïde sature. En donnant aux poids une variance de 1/n (Glorot 2010, pour sigmoïde et tanh) ou de 2/n (He 2015, pour ReLU, qui éteint la moitié des neurones), la somme garde une dispersion proche de 1, couche après couche. Concrètement, avec He : un neurone à 100 entrées reçoit des poids tirés autour de 0 avec un écart-type de √(2/100) = 0,14 ; à 10 000 entrées, 0,014 ; les 12 288 entrées d'une couche de GPT-3, environ 0,013. Les biais, eux, partent de zéro.
Gradients qui s'évanouissent ou explosent
Dans un réseau profond, le gradient est un produit de nombreuses dérivées ; s'il est en moyenne inférieur à 1, il tend vers zéro dans les premières couches. Trois idées ont levé ce verrou. ReLU : sa dérivée vaut exactement 1 pour tout z positif, là où celle de la sigmoïde plafonne à 0,25 ; multiplier des 1 ne fait pas fondre le gradient, alors que 0,25 à la puissance 20 couches vaut 10⁻¹². La normalisation par lot (batch normalization, Ioffe et Szegedy 2015) : à l'intérieur du réseau, avant chaque activation, on recentre et on remet à l'échelle les valeurs z sur le lot en cours (moyenne 0, écart-type 1), comme on l'a fait pour les entrées ; les activations restent dans la zone où les fonctions ont de la pente, quelle que soit la profondeur. Les connexions résiduelles (He et al. 2015, ResNet) : au lieu de demander à une couche de produire sa sortie de toutes pièces, on lui fait calculer une correction ajoutée à son entrée, a⁽ˡ⁾ = a⁽ˡ⁻¹⁾ + f(a⁽ˡ⁻¹⁾) ; le gradient dispose alors d'un raccourci qui traverse chaque couche sans être multiplié par quoi que ce soit. Ensemble, elles ont permis des réseaux de 150 couches en 2015, contre une dizaine auparavant ; le Transformer des modèles de langage utilise les deux dernières à chaque bloc.
Surapprentissage
Un réseau assez grand peut mémoriser ses données d'entraînement au lieu d'en tirer une règle : il devient excellent sur ce qu'il a vu et mauvais sur le reste. On le détecte en mesurant le coût sur des données mises de côté dès le départ (le jeu de validation, typiquement 10 à 20 % des exemples) : tant que ce coût baisse, le réseau généralise ; quand il remonte alors que le coût d'entraînement continue de baisser, le réseau mémorise. On le limite par la régularisation : pénalité sur les grands poids, dropout (éteindre des neurones au hasard pendant l'entraînement, pour qu'aucun ne devienne indispensable), arrêt précoce (garder les poids du meilleur point de validation), et surtout plus de données.
Après l'époque 12, le réseau continue de s'améliorer sur les exemples qu'il a vus, mais se dégrade sur ceux qu'il n'a pas vus : il apprend par cœur. L'arrêt précoce garde les poids de l'époque 12.
Données
Les entrées sont normalisées avant d'entrer dans le réseau. Une distance en kilomètres (de 10 à 5 000) et un taux de retard (de 0 à 1) n'ont pas la même échelle ; sans correction, le poids de la distance recevrait des gradients mille fois plus grands, et un même taux d'apprentissage serait trop grand pour l'un et trop petit pour l'autre. La recette standard : pour chaque variable, on calcule sa moyenne μ et son écart-type σ sur le jeu d'entraînement, puis on remplace chaque valeur x par (x − μ)/σ. Chaque variable a alors une moyenne de 0 et un écart-type de 1, et une valeur normalisée se lit directement comme « à combien d'écarts-types de la normale ».
| Variable (jeu d'entraînement) | Moyenne μ · écart-type σ | Valeur brute | Valeur normalisée |
|---|---|---|---|
| Distance du fournisseur (km) | 850 · 600 | 1 450 km | (1 450 − 850)/600 = +1,0 |
| Retards de livraison l'an passé | 2,4 · 2,0 | 0 retard | (0 − 2,4)/2,0 = −1,2 |
| Température maximale du jour (°C) | 18 · 8 | 41 °C | (41 − 18)/8 = +2,9 (canicule rare) |
| Consommation électrique du site (MWh/jour) | 120 · 35 | 85 MWh | (85 − 120)/35 = −1,0 |
| Prix de l'urée (USD/t) | 420 · 130 | 857 USD/t | (857 − 420)/130 = +3,4 (hors norme) |
| Pays d'origine (catégorie) | — | « Maroc » | codage one-hot : (0, 0, 1, 0, …), un 1 dans la colonne Maroc |
Les moyennes et écarts-types du tableau sont des ordres de grandeur illustratifs. Les μ et σ sont ceux du jeu d'entraînement et sont conservés avec le modèle : une donnée nouvelle est normalisée avec les mêmes constantes, sinon le réseau ne la lit plus dans le même repère. Le tableau montre aussi ce qu'un réseau apprend malgré nous : si les fournisseurs marocains du jeu d'entraînement ont été livrés pendant une période de blocage portuaire, le réseau associera « Maroc » à « retard » et reproduira ce biais ; si les températures ont été saisies en °F pour un site, la valeur normalisée sera aberrante et le réseau apprendra un artefact. Un réseau apprend ce que les données contiennent, y compris leurs biais et leurs erreurs.
Calcul
Chaque pas est dominé par des produits de matrices, exécutés en parallèle sur GPU. Entraîner GPT-3 a demandé de l'ordre de 3×10²³ opérations en virgule flottante ; le calcul est devenu la ressource limitante, d'où l'importance de la quantification et des architectures creuses (mixture d'experts).
Repères historiques : le perceptron de Rosenblatt (1958) est un neurone unique à activation en marche ; Minsky et Papert montrent en 1969 qu'il ne peut pas apprendre le « ou exclusif », ce qui gèle le domaine ; la rétropropagation (1986) lève la limite en rendant les couches cachées entraînables ; les réseaux convolutifs de LeCun (1989, 1998) lisent des chiffres manuscrits ; AlexNet (2012) divise par deux l'erreur sur ImageNet grâce aux GPU, ReLU et dropout, et ouvre la décennie de l'apprentissage profond ; le Transformer (2017) applique la même mécanique au langage.
10 · Ce qu'un réseau ne fait pas
Un réseau de neurones est un approximateur de fonctions : il apprend une correspondance entre des entrées et des sorties à partir d'exemples. Il n'a pas de règles explicites qu'on pourrait lire, et ses erreurs sont difficiles à expliquer autrement que par ses gradients. Il n'extrapole pas de manière fiable hors de la zone couverte par ses données. Il est sensible à des perturbations imperceptibles (exemples adverses). Et il ne mesure pas sa propre incertitude, sauf à l'y entraîner. Pour une organisation, ces limites se traduisent en règles simples : valider sur des données récentes et réalistes, garder un humain là où l'erreur coûte cher, et ne pas confondre une sortie confiante avec une sortie juste.
Comment faire la différence ? La confiance est ce que le réseau affiche — une sigmoïde à 0,95, un softmax qui met 0,95 sur une classe. La justesse ne se lit pas sur la sortie ; elle se mesure, après coup, sur des exemples dont on connaît la réponse. La méthode s'appelle la calibration : on prend un jeu de test que le réseau n'a jamais vu, on regroupe ses prédictions par niveau de confiance, et l'on compare. Parmi les 200 cas où il annonçait 90 % de confiance, combien étaient justes ? Si la réponse est 180, le réseau est calibré ; si c'est 120, sa confiance ne veut rien dire — et c'est fréquent, les réseaux modernes entraînés par entropie croisée sont souvent trop sûrs d'eux. Trois pratiques en découlent. Ne jamais mettre en production un modèle sans ce tableau confiance/justesse sur des données récentes. Fixer un seuil d'abstention : en dessous d'une confiance calibrée de, disons, 80 %, la décision revient à un humain — et vérifier que les cas rejetés ne sont pas ceux qui comptent. Surveiller la dérive : un réseau interrogé sur des situations absentes de ses données d'entraînement — un nouveau fournisseur, un été à 45 °C, un tarif douanier inédit — reste tout aussi confiant, mais n'a plus aucune raison d'être juste. Sa sortie n'est alors qu'une extrapolation, et rien dans le chiffre affiché ne le signale.
Surveiller la dérive, concrètement, revient à comparer en continu trois choses à ce qu'elles étaient au moment de l'entraînement : ce qui entre dans le modèle, ce qui en sort, et ce que l'on apprend après coup de la réalité. Les entrées d'abord : comme chaque variable a été normalisée avec la moyenne et l'écart-type du jeu d'entraînement (section 9), une valeur normalisée au-delà de ±3 est par construction une situation que le modèle n'a presque jamais vue ; on compte chaque mois la part des cas dans cette zone, et l'on compare la distribution de chaque variable à celle de l'entraînement avec un test simple (indice de stabilité de population, test de Kolmogorov-Smirnov). Les sorties ensuite : la répartition des confiances émises — si le modèle rendait 15 % de cas sous le seuil d'abstention et en rend 40 % ce mois-ci, quelque chose a changé en amont. La réalité enfin, quand elle arrive : le retard fournisseur se constate à la livraison, le défaut de la pièce au contrôle qualité ; on rapproche ces vérités des prédictions et l'on recalcule le tableau confiance/justesse sur les cas les plus récents. Un tableau de bord tient en quatre indicateurs, avec un seuil d'alerte pour chacun.
| Signal | Comment le mesurer | Exemple de seuil d'alerte |
|---|---|---|
| Entrées hors du domaine appris | Part des cas dont au moins une variable normalisée dépasse ±3 ; nouvelles catégories jamais vues (un pays, un fournisseur) | > 5 % des cas du mois, ou toute catégorie inconnue |
| Distribution des entrées | Indice de stabilité de population (PSI) par variable, entre le mois courant et le jeu d'entraînement | PSI > 0,25 sur une variable importante |
| Distribution des sorties | Part des prédictions sous le seuil d'abstention ; moyenne des confiances émises | Part d'abstention doublée par rapport à la mise en service |
| Justesse réelle | Taux d'erreur et calibration sur les cas récents dont la réponse est désormais connue | Erreur supérieure de 20 % à celle mesurée à la validation |
Quand une alerte se déclenche, la réponse n'est pas d'abord technique : on regarde ce qui a changé dans le monde (un nouveau fournisseur, une saison hors norme, un changement de procédure de saisie), puis on décide de réentraîner sur des données récentes, de restreindre le périmètre du modèle, ou de rendre la main à l'humain sur la zone concernée. Un modèle sans ce dispositif n'est pas « en production » ; il est en roue libre.
11 · LLM ou réseau spécialisé : lequel pour quel cas ?
La question revient dans chaque comité de direction, et elle est mal posée : un grand modèle de langage est un réseau de neurones — un Transformer de quelques milliards de paramètres, entraîné avec exactement les quatre gestes de cette page. La vraie alternative est entre un modèle généraliste pré-entraîné par d'autres (un LLM, qu'on utilise tel quel, avec ses documents ou après un ajustement léger) et un modèle spécialisé entraîné sur vos propres données (un réseau de quelques milliers à quelques millions de paramètres, voire un modèle statistique classique). Les deux ne coûtent pas la même chose, ne se trompent pas de la même façon et ne se surveillent pas avec les mêmes outils.
Le critère principal tient à la nature de l'entrée et de la sortie. Si l'entrée est du langage — courriels, contrats, comptes rendus, appels d'offres, code — ou si la sortie doit en être, le LLM part avec l'avantage décisif d'avoir déjà appris la langue, la syntaxe et une bonne part du monde : il fait avec dix exemples ce qu'un réseau spécialisé ne ferait pas avec dix mille. Si l'entrée est constituée de nombres, de séries de capteurs, de lignes d'ERP ou d'images de production, et la sortie d'un nombre ou d'une classe, le réseau spécialisé est plus juste, mille fois moins cher à exécuter, calibrable, et il tourne sur une machine ordinaire, voire dans la caméra. Le second critère est le volume et la latence : un LLM de 7 milliards de paramètres met de l'ordre d'une seconde et quelques joules par réponse ; un réseau spécialisé, quelques microsecondes. Sur un million de décisions par jour, ce n'est pas la même infrastructure. Le troisième est l'exigence de garantie : un réseau spécialisé se teste sur un jeu de validation et se calibre (section 10) ; un LLM produit du texte libre, dont la justesse se contrôle plus difficilement et qui peut inventer.
| Cas concret | Choix | Pourquoi |
|---|---|---|
| Trier 2 000 courriels fournisseurs par jour en « réclamation », « avis de retard », « facture », « autre » | LLM (petit, exécuté en local) | Entrée textuelle, catégories qui évoluent, peu d'exemples étiquetés ; un prompt et vingt exemples suffisent, là où un réseau spécialisé demanderait des milliers de courriels annotés. |
| Extraire des clauses (pénalités, incoterms, délais) de contrats hétérogènes | LLM, avec vérification humaine | Documents non structurés, formulations variables ; un LLM lit la clause comme un juriste débutant. Le contrôle humain reste nécessaire tant que l'erreur coûte cher. |
| Prévoir la demande hebdomadaire de 5 000 références à partir de l'historique des ventes | Réseau spécialisé, ou modèle statistique | Données numériques, sortie chiffrée, volume élevé ; un modèle entraîné sur vos séries bat un LLM en précision et coûte une fraction de centime par prévision. |
| Détecter un défaut de soudure sur une ligne à 40 pièces par minute | Réseau de vision spécialisé (YOLO) | Images, décision en 10 ms, exécution sur une carte embarquée, taux de faux positifs mesuré et garanti ; un LLM multimodal serait trop lent, trop cher et non calibré. |
| Repérer une dérive sur 300 capteurs d'une unité de production | Réseau spécialisé (autoencodeur) ou statistique | Séries temporelles, seuils d'alerte quantifiés ; le langage n'entre nulle part. |
| Estimer le risque de retard d'un fournisseur à partir de 12 variables | Réseau spécialisé, souvent un modèle plus simple encore | Données tabulaires ; un gradient boosting ou une régression logistique fait souvent aussi bien qu'un réseau, et s'explique variable par variable. |
| Répondre aux questions des équipes sur 3 000 pages de procédures internes | LLM avec RAG | Question en langage naturel, réponse en langage naturel, corpus qui change ; c'est le cas d'usage type du RAG (page dédiée). |
| Rédiger un premier jet de réponse à un appel d'offres à partir de la bibliothèque des offres passées | LLM, avec RAG et relecture | Production de texte long, à partir de textes ; aucun réseau spécialisé ne le fait. La relecture humaine est le vrai livrable. |
| Décider d'un déclassement de pièce selon trois seuils réglementaires | Ni l'un ni l'autre : des règles | Quand la règle est connue et écrite, un modèle appris n'apporte que de l'incertitude et une charge de validation. |
Deux compléments. D'abord, les deux se combinent souvent : un LLM transforme un texte en champs structurés (une date, un montant, une catégorie), puis un modèle spécialisé prend la décision chiffrée — chacun fait ce qu'il sait faire, et la partie critique reste testable. Ensuite, un LLM se spécialise aussi, par ajustement sur vos données (Entraîner un modèle sur son domaine), mais on ne le fait qu'après avoir épuisé le prompt et le RAG, parce que c'est plus coûteux et plus difficile à maintenir. Pour choisir un modèle précis selon le besoin, la taille et le matériel : Quel modèle d'IA générative pour quel besoin ?.
Aller plus loin
Les grands modèles de langage sont des réseaux de neurones d'une architecture particulière, le Transformer, entraînés à prédire le mot suivant : Comment fonctionne un grand modèle de langage. Pour choisir un modèle selon un besoin concret : Quel modèle d'IA générative pour quel besoin ?. Pour la place de l'IA dans une chaîne de valeur : Intelligence artificielle, levier autant que dépendance.
Références — Rosenblatt, The Perceptron, 1958 · Minsky & Papert, Perceptrons, 1969 · Rumelhart, Hinton & Williams, Learning representations by back-propagating errors, Nature, 1986 · Cybenko 1989, Hornik 1991 (approximation universelle) · Glorot & Bengio 2010 · Nair & Hinton 2010 (ReLU) · Krizhevsky, Sutskever & Hinton 2012 (AlexNet) · Kingma & Ba 2014 (Adam) · Ioffe & Szegedy 2015 (batch normalization) · He et al. 2015 (ResNet) · Brown et al. 2020 (GPT-3, 175 milliards de paramètres, ≈3,1×10²³ FLOP).