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. Les entrées et la sortie sont des activations : ce qui circule.
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.
Chaque fonction a une dérivée simple, et c'est ce qui compte pour la suite : la dérivée de la sigmoïde vaut σ(z)·(1 − σ(z)), celle de ReLU vaut 1 si z > 0 et 0 sinon. En sortie d'un réseau, on choisit l'activation selon la question posée : sigmoïde pour une probabilité (oui/non), softmax pour un choix entre plusieurs classes (les sorties deviennent positives et somment à 1), aucune activation pour prédire une valeur continue.
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, une couche cachée de deux neurones, une sortie, 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
Le gradient du coût est le vecteur de ses dérivées partielles par rapport à chaque paramètre : ∂C/∂w₁, ∂C/∂w₂, … Chaque composante répond à la question « si j'augmente ce poids d'un tout petit peu, le coût augmente-t-il ou diminue-t-il, et à quelle vitesse ? ». Le gradient pointe dans la direction où le coût augmente le plus vite ; on fait donc un pas dans la direction opposée.
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 tirés au hasard : 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. Le coût dépend de la sortie o, qui dépend de z₃, qui dépend de w₅ : donc ∂C/∂w₅ = ∂C/∂o × ∂o/∂z₃ × ∂z₃/∂w₅. Chaque facteur est une dérivée locale, simple à calculer. Et le facteur commun ∂C/∂o × ∂o/∂z₃ — qu'on note δ₃, l'« erreur » du neurone de sortie — sert aussi pour w₆ et b₃. On le calcule une fois, puis on le propage vers l'arrière : l'erreur d'un neurone caché est la somme des erreurs des neurones qu'il alimente, pondérée par les poids qui les relient, multipliée par la dérivée de sa propre activation. D'où le nom : l'erreur remonte le réseau à contre-courant, de la sortie vers l'entrée.
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₁ est actif et la sortie doit monter. 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.
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 les poids au hasard avec une variance calibrée à la taille de la couche (Glorot 2010, He 2015).
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. ReLU, la normalisation par lot (2015) et les connexions résiduelles (2015) ont levé ce verrou et permis des réseaux de centaines de couches.
Surapprentissage
Un réseau assez grand peut mémoriser ses données d'entraînement au lieu d'en tirer une règle. On le détecte en mesurant le coût sur des données mises de côté (validation), et on le limite par la régularisation : pénalité sur les grands poids, dropout (éteindre des neurones au hasard pendant l'entraînement), arrêt précoce, plus de données.
Données
Les entrées sont normalisées (moyenne nulle, écart-type 1) pour que les gradients aient des échelles comparables. 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.
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).