Comprendre les LLM et les réseaux de neurones

Qu'est-ce que le LLM par rapport à l'IA ?

Le LLM (Large Language Model, ou grand modèle de langage) est un type particulier d'intelligence artificielle (IA). On peut voir cela comme une relation de type ensemble / sous-ensemble :

Intelligence Artificielle (IA)
│
├── Vision par ordinateur
├── Robotique
├── Systèmes experts
├── IA pour les jeux
├── IA de recommandation
└── LLM (grands modèles de langage)
    ├── ChatGPT
    ├── Gemini
    ├── Claude
    └── Llama

Qu'est-ce que l'IA ?

L'intelligence artificielle est le domaine qui consiste à concevoir des systèmes capables d'effectuer des tâches qui demanderaient normalement de l'intelligence humaine, par exemple :

• reconnaître des images ;
• comprendre la parole ;
• traduire des langues ;
• jouer aux échecs ou au Go ;
• conduire une voiture ;
• dialoguer avec un humain.

Les LLM ne représentent donc qu'une branche de l'IA.

Qu'est-ce qu'un LLM ?

Un LLM est une IA spécialisée dans le traitement du langage naturel. Il est entraîné sur d'immenses quantités de textes afin d'apprendre les relations entre les mots, les phrases et les concepts.

Il est capable de :

• répondre à des questions ;
• rédiger des textes ;
• résumer des documents ;
• traduire des langues ;
• écrire du code ;
• expliquer des notions.

En pratique, un LLM prédit le mot (ou plus précisément le token) le plus probable à la suite d'une séquence de texte, ce qui lui permet de générer des réponses cohérentes.

Les LLM sont-ils toute l'IA ?

Non. Par exemple :

• Une IA qui détecte une tumeur sur une radiographie n'est généralement pas un LLM.
• Une IA qui pilote un drone n'est généralement pas un LLM.
• Une IA qui reconnaît un visage est souvent basée sur des modèles de vision par ordinateur, pas sur un LLM.

À l'inverse, lorsque tu discutes avec ChatGPT ou que tu demandes à une IA d'écrire un programme en PHP ou en Python, tu utilises principalement un LLM.

Une analogie

On peut comparer cela aux véhicules :

• L'IA est comme la catégorie "véhicules".
• Un LLM est comme une voiture.
• Une moto, un camion ou un bateau sont aussi des véhicules, mais ne sont pas des voitures.

De la même manière, un LLM est une forme d'IA, mais toutes les IA ne sont pas des LLM.

Aujourd'hui, de nombreuses applications combinent plusieurs types d'IA. Par exemple, ChatGPT utilise un LLM pour comprendre et générer du texte, mais peut aussi faire appel à des modèles spécialisés pour la reconnaissance d'images, la synthèse vocale ou la génération d'images.

Explique-moi un réseau de neurones classique

Un réseau de neurones artificiels est un programme informatique qui apprend à reconnaître des motifs en ajustant progressivement des paramètres appelés poids. Il s'inspire très librement du fonctionnement des neurones biologiques, mais il n'en est pas une copie fidèle.

Prenons un exemple simple : on veut créer une IA capable de distinguer un chat d'un chien.

1. Le neurone artificiel

Le neurone est la brique de base.

Il reçoit plusieurs valeurs en entrée :

Chaque entrée est multipliée par un poids. Par exemple :

0,8 × 1,2
0,6 × 0,4
0,5 × 2,1
...

On additionne ensuite tous ces résultats.

Puis on applique une fonction d'activation qui décide si le neurone "s'active" ou non.

On peut voir cela comme un vote :

« Avec ces informations, je pense à 75 % que c'est un chat. »

2. Une couche de neurones

Un seul neurone est très limité.

On en utilise donc des dizaines, des centaines, voire des millions.

Entrées

   ●
   ●
   ●
   ●

     ↓

● ● ● ● ● ● ●

Chaque neurone apprend à détecter quelque chose de différent. Par exemple :

• oreilles pointues ;
• présence de moustaches ;
• texture du pelage ;
• forme des yeux.

3. Plusieurs couches

Les réseaux deviennent puissants lorsqu'on empile plusieurs couches.

Entrée
     ↓
Couche cachée 1
     ↓
Couche cachée 2
     ↓
Couche cachée 3
     ↓
Sortie

Les premières couches détectent des éléments simples. Les couches suivantes combinent ces éléments.

Par exemple pour une image :

• couche 1 → des lignes ;
• couche 2 → des formes ;
• couche 3 → des oreilles ;
• couche 4 → une tête de chat ;
• sortie → "Chat".

Plus on monte dans les couches, plus les concepts deviennent abstraits.

4. L'apprentissage

Au départ, tous les poids sont choisis presque au hasard.

Le réseau répond donc très mal.

On lui montre ensuite des milliers ou des millions d'exemples. Par exemple :

• Image 1 → Chat
• Le réseau répond : Chien (92 %)
• Erreur !

L'algorithme calcule alors l'erreur, puis il modifie légèrement tous les poids.

Il recommence des millions de fois.

Petit à petit, le réseau devient meilleur. C'est ce qu'on appelle l'entraînement.

5. La rétropropagation (Backpropagation)

Comment le réseau sait-il quels poids modifier ?

Il utilise un algorithme appelé rétropropagation (backpropagation). Le principe est le suivant :

1. Le réseau fait une prédiction.
2. On compare cette prédiction avec la bonne réponse.
3. On calcule l'erreur.
4. On détermine quels poids sont les plus responsables de cette erreur.
5. On ajuste ces poids dans la bonne direction.

Ce processus est répété des millions, voire des milliards de fois pendant l'entraînement.

6. Une analogie

Imagine un jury qui doit décider si une photo représente un chat.

Chaque juré observe un détail différent :

« Je vois des moustaches. » « Je vois des oreilles pointues. » « Je vois une longue queue. » « Je vois un museau court. »

Puis un second groupe combine ces avis :

« Trois indices sur quatre indiquent un chat. »

Enfin, un dernier groupe prend la décision finale.

Un réseau de neurones fonctionne un peu de cette manière, sauf que les "jurés" sont des calculs mathématiques.

7. Le lien avec les LLM

Les LLM comme ChatGPT sont eux aussi des réseaux de neurones, mais d'une catégorie particulière : les Transformers.

Un réseau de neurones "classique" (appelé perceptron multicouche ou MLP, pour Multi-Layer Perceptron) fait circuler les informations de l'entrée vers la sortie, couche après couche.

Les Transformers ajoutent un mécanisme supplémentaire appelé attention, qui permet à chaque mot d'une phrase de tenir compte des autres mots avant de continuer les calculs. C'est cette capacité qui les rend particulièrement efficaces pour comprendre et générer du langage.

En résumé :

• Réseau de neurones classique (MLP) : des couches de neurones apprennent à transformer des données en une réponse.
• Transformer : un réseau de neurones plus évolué qui intègre le mécanisme d'attention, ce qui le rend particulièrement adapté au traitement du langage et explique pourquoi il est utilisé dans les LLM modernes comme ChatGPT.

Comment les LLM peuvent générer du code ?

C'est une excellente question. Beaucoup de personnes pensent qu'un LLM "comprend" la programmation comme un développeur. En réalité, il fonctionne avec les mêmes mécanismes que pour le langage naturel, mais le code source possède une structure très régulière.

Le code est aussi un langage

Pour un LLM, il n'y a pas de différence fondamentale entre :

Il fait beau aujourd'hui.

et

if ($age >= 18) {
    echo "Majeur";
}

Dans les deux cas, il voit simplement une suite de tokens. Par exemple, le code PHP peut être découpé ainsi :

if ( $age >= 18 ) { echo "Majeur" ; }

Chaque token est transformé en vecteur, exactement comme pour une phrase en français.

Pendant l'entraînement

Le modèle a lu des milliards de lignes de code provenant notamment de :

• projets open source ;
• documentations ;
• tutoriels ;
• exemples de programmation ;
• questions/réponses techniques.

À force de voir ces exemples, il apprend des régularités. Par exemple, il rencontre très souvent :

foreach ($users as $user) {

suivi de

echo $user->name;

Il apprend donc que cette suite est très probable.

Il apprend les structures

Prenons un exemple. On lui montre des millions de fois :

for i in range(10):

Très souvent, la ligne suivante est :

print(i)

ou

total += i

Il finit par apprendre que certaines suites de tokens sont beaucoup plus probables que d'autres.

Mais il apprend aussi des concepts

C'est là que les réseaux de neurones deviennent intéressants.

Après avoir vu des millions d'exemples, certaines parties du réseau apprennent implicitement des notions comme :

• une variable ;
• une boucle ;
• une condition ;
• une fonction ;
• une classe ;
• une requête SQL ;
• un appel HTTP ;
• une API REST.

Personne ne lui dit explicitement ce qu'est une boucle for. Il déduit cette notion en observant d'innombrables exemples.

Exemple concret

Si tu écris :

Écris une fonction PHP qui trie un tableau.

Le modèle commence à produire :

function

Pourquoi ? Parce que parmi tous les exemples qu'il a vus, lorsqu'une phrase ressemble à cette demande, le token function est extrêmement probable.

Ensuite :

function sortArray(

puis

function sortArray(array $items)

puis

{

puis

sort($items);

À chaque étape, il ne choisit que le prochain token, mais comme il répète ce processus des centaines de fois, il produit une fonction complète.

Pourquoi le code est plus facile que le français

Le code est :

• beaucoup plus régulier ;
• peu ambigu ;
• fortement structuré ;
• très répétitif.

Par exemple :

if (...) {

est presque toujours suivi d'un bloc :

...
}

Le LLM apprend donc très facilement ces motifs.

Pourquoi il peut écrire du code qu'il n'a jamais vu

C'est sans doute la partie la plus surprenante.

Imaginons qu'il ait vu :

• Créer un utilisateur
• Créer un produit
• Créer une facture

Il peut alors générer :

Créer un abonnement

même si cet exemple précis n'était pas dans ses données d'entraînement.

Il combine les motifs qu'il connaît pour produire quelque chose de nouveau. C'est ce qui donne l'impression qu'il "raisonne", alors qu'il généralise à partir de nombreuses régularités apprises.

Pourquoi ChatGPT est particulièrement bon en programmation

Les modèles récents ne se contentent pas d'avoir été entraînés sur du code. Ils ont aussi été spécialisés après l'entraînement général :

• ils ont vu davantage de code de qualité ;
• ils ont été évalués sur des exercices de programmation ;
• leurs réponses ont été améliorées grâce aux retours humains et à d'autres techniques de post-entraînement.

Ils apprennent également les relations entre différentes technologies. Par exemple, si tu demandes :

« Écris une API Symfony qui utilise Doctrine pour enregistrer un utilisateur en base. »

le modèle associe des concepts qui apparaissent souvent ensemble :

• contrôleurs Symfony ;
• annotations ou attributs ;
• entités Doctrine ;
• injection de dépendances ;
• requêtes SQL générées par l'ORM.

Il assemble ensuite ces éléments en respectant les conventions qu'il a apprises.

En résumé, un LLM ne possède pas un compilateur ou une base de règles intégrée sur la programmation. Il génère du code en exploitant les structures, les conventions et les relations statistiques apprises à partir d'un très grand nombre d'exemples. Grâce à l'architecture Transformer et au mécanisme d'attention, il peut aussi tenir compte du contexte (les fonctions déjà écrites, les variables définies, les commentaires, etc.) pour produire un code cohérent sur plusieurs dizaines, voire plusieurs centaines de lignes.

Petit didacticiel sur un réseau de neurones classique, avec un exemple concret

Bien sûr. Voici un petit didacticiel qui part de zéro et montre comment un réseau de neurones apprend réellement, avec un exemple très simple.

Imaginons que nous voulions créer une IA qui réponde à une seule question :

"Est-ce qu'une personne est majeure ?"

Nous allons utiliser deux informations :

• son âge ;
• son pays (pour simplifier, nous n'utiliserons que la France où la majorité est à 18 ans).

Pour commencer, ne gardons qu'une seule entrée : l'âge.

Étape 1 : le neurone

Notre réseau contient un seul neurone.

        Âge
         │
         ▼
    ┌─────────┐
    │ Neurone │
    └─────────┘
         │
         ▼
   Majeur ?

Le neurone reçoit une valeur. Par exemple : Âge = 15

Étape 2 : le poids

Le neurone possède un poids. Supposons qu'il soit de : poids = 0,2

Le neurone calcule :

15 × 0,2 = 3

Étape 3 : le biais

On ajoute ensuite un biais. Supposons : biais = -2

Le calcul devient :

15 × 0,2 − 2 = 1

Étape 4 : la fonction d'activation

Le neurone transforme ensuite cette valeur. Par exemple : résultat = 1 devient 0,73

On peut l'interpréter comme : 73 % de chances d'être majeur.

Premier essai

Pour une personne de 15 ans :

Entrée : 15
   ↓
15 × 0,2 = 3
   ↓
3 − 2 = 1
   ↓
73 %

Pourtant, la bonne réponse est : 0 %

Le réseau s'est trompé.

Deuxième essai

On lui montre : 22 ans

Le calcul donne :

22 × 0,2 = 4,4
4,4 − 2 = 2,4
   ↓
91 %

Cette fois, la réponse est correcte.

Comment apprend-il ?

Au départ : poids = 0,2. Mais il fait beaucoup d'erreurs.

On lui montre alors des milliers d'exemples :

Après chaque erreur, il modifie légèrement ses paramètres. Par exemple :

Avant : poids = 0,20
Après : poids = 0,18
Puis  : 0,17 → 0,16 → 0,15 → ...

Le biais est lui aussi ajusté.

Petit à petit, le neurone trouve les valeurs qui donnent les meilleurs résultats.

Ajouter plusieurs neurones

Un seul neurone est rarement suffisant.

Prenons maintenant un problème plus compliqué : nous voulons reconnaître un chien.

Nous disposons de quatre informations :

• Longueur des oreilles
• Longueur du museau
• Poids
• Hauteur

Notre réseau devient :

           Oreilles
               │
Museau ────────┼────────┐
               │        │
Poids ─────────┘        │
                        ▼

             Couche cachée

        ●      ●      ●      ●

                ▼

          Neurone final

                ▼

            Chien ?

Chaque neurone apprend quelque chose. Par exemple :

• Neurone 1 → Oreilles longues
• Neurone 2 → Museau long
• Neurone 3 → Animal lourd
• Neurone 4 → Animal grand

Le dernier neurone combine toutes ces informations. Il peut conclure :

« Si les oreilles sont longues, le museau est long et l'animal est grand, il y a 97 % de chances que ce soit un chien. »

Pourquoi plusieurs couches ?

Avec davantage de couches, les neurones peuvent construire des idées de plus en plus complexes.

Pour une image :

Pixels
  ↓
Lignes
  ↓
Cercles
  ↓
Yeux
  ↓
Visage
  ↓
Chat

Chaque couche transforme les informations reçues en concepts plus abstraits.

Pourquoi parle-t-on de millions de paramètres ?

Dans notre petit exemple :

4 entrées → 4 neurones → 1 sortie

nous avons seulement quelques poids.

Mais dans un vrai réseau :

Entrées   : 10 000
Couche 1  : 4 096 neurones
Couche 2  : 4 096 neurones
Couche 3  : 4 096 neurones
...

Chaque connexion possède son propre poids. On obtient alors rapidement :

• des millions ;
• des milliards ;
• voire des centaines de milliards de paramètres.

Ces paramètres représentent tout ce que le réseau a appris pendant son entraînement.

Le lien avec les LLM

Un LLM fonctionne selon le même principe général :

1. Le texte est transformé en nombres (embeddings).
2. Ces nombres traversent un immense réseau de neurones.
3. À chaque couche, les informations sont enrichies et transformées.
4. Le modèle estime quel est le prochain token le plus probable.
5. Il ajoute ce token à la réponse, puis recommence.

La grande différence est que les LLM utilisent une architecture appelée Transformer, qui ajoute un mécanisme d'attention. Au lieu de traiter les informations uniquement de couche en couche, chaque mot peut aussi "regarder" les autres mots de la phrase pour mieux comprendre le contexte.

En résumé, un réseau de neurones est un ensemble de petits calculateurs (les neurones) qui collaborent. Pris isolément, chaque neurone est très simple. C'est leur très grand nombre, leurs connexions et l'ajustement progressif de leurs poids pendant l'entraînement qui leur permettent d'apprendre des tâches complexes, comme reconnaître des images, comprendre du texte ou générer du code.

Comment génère-t-on la valeur des poids et des biais ?

C'est justement le cœur de l'apprentissage d'un réseau de neurones.

La réponse courte est : au départ, les poids et les biais sont choisis aléatoirement. Ensuite, ils sont ajustés progressivement pendant l'entraînement.

Voyons cela avec un exemple concret.

Étape 1 : Initialisation aléatoire

Imaginons un neurone qui doit déterminer si une personne est majeure. Il calcule :

sortie = âge × poids + biais

Au début, il ne sait rien. On lui attribue donc des valeurs au hasard :

poids = 0,37
biais = -1,12

Pourquoi au hasard ? Parce que si tous les neurones démarraient avec exactement les mêmes valeurs, ils apprendraient tous la même chose. L'initialisation aléatoire permet à chaque neurone d'évoluer différemment.

Étape 2 : Premier exemple

On montre : âge = 15, réponse attendue : 0 (mineur)

Le réseau calcule :

15 × 0,37 − 1,12 = 4,43

Après la fonction d'activation, il répond par exemple : 99 %

Il pense donc que la personne est majeure. Il s'est trompé.

Étape 3 : Calcul de l'erreur

Le programme compare la réponse attendue (0) avec la réponse obtenue (0,99).

Il calcule une erreur, par exemple : Erreur = 0,99

Plus l'erreur est grande, plus il faudra modifier les paramètres.

Étape 4 : Dans quel sens modifier le poids ?

Le réseau se pose une question :

"Si j'augmente légèrement le poids, est-ce que l'erreur augmente ou diminue ?" "Si je diminue légèrement le poids, est-ce que l'erreur diminue ?"

C'est exactement ce que calcule la descente de gradient (gradient descent).

Supposons qu'elle indique : le poids est trop grand. Alors on le réduit :

Avant : 0,37
Après : 0,35

Le biais est ajusté de la même manière :

Avant : -1,12
Après : -1,20

Étape 5 : Exemple suivant

Maintenant : âge = 22, réponse attendue : 1

Le réseau calcule et obtient cette fois : 0,63 → il répond 63 % majeur.

C'est mieux, mais pas parfait. Il recalcule alors une nouvelle erreur et ajuste encore ses paramètres.

Après un million d'exemples

Les valeurs deviennent :

poids = 0,18
biais = -3,25

Le neurone répond désormais :

15 ans → 1 %
22 ans → 99 %

Il a appris.

Pourquoi cela fonctionne-t-il ?

Imagine que tu règles un thermostat. Au début : 22°C, tu veux 20°C. Tu tournes un peu le bouton, tu mesures, tu ajustes encore. Petit à petit, tu atteins la bonne température.

Les poids sont réglés exactement comme cela.

Dans un LLM

Un LLM moderne possède non pas 1 poids, mais des milliards de poids. Par exemple :

Poids 1 : 0,381927
Poids 2 : −0,017324
Poids 3 : 1,893812
...

Chaque poids est ajusté des millions de fois pendant l'entraînement.

Le rôle de la rétropropagation (backpropagation)

Tu pourrais te demander :

« Avec des milliards de poids, comment le réseau sait-il exactement lesquels modifier ? »

C'est là qu'intervient l'algorithme de rétropropagation.

Après avoir calculé l'erreur sur la sortie, il "remonte" dans le réseau en déterminant la contribution de chaque poids à cette erreur. Les poids qui ont eu le plus d'influence sont davantage modifiés, ceux qui en ont eu peu sont peu modifiés.

Sans la rétropropagation, il faudrait tester les milliards de poids un par un, ce qui serait totalement impraticable.

Une analogie

Imagine une immense table de mixage avec un milliard de curseurs. Tu veux obtenir un son parfait.

1. Au début, tous les curseurs sont placés presque au hasard.
2. Tu écoutes le résultat.
3. Tu mesures l'écart avec le son souhaité.
4. Un assistant très intelligent te dit : « Monte légèrement le curseur n° 152, baisse un peu le n° 4 283, ne touche presque pas aux autres. »
5. Tu répètes cette opération des millions de fois.

À la fin, la position de tous les curseurs correspond aux poids appris par le réseau.

C'est cette combinaison de l'initialisation aléatoire, de la mesure de l'erreur, de la rétropropagation et de la descente de gradient qui permet à un réseau de neurones d'apprendre à partir des données.

Schéma

J'ai réalisé un schéma qui illustre pas à pas l'initialisation aléatoire des poids et biais, le calcul de l'erreur, la mise à jour par descente de gradient, puis l'apprentissage progressif jusqu'à la convergence, avec un petit exemple concret.

Est-ce que la descente de gradient, c'est la backpropagation ?

Non. Les deux notions sont très liées, mais elles ne désignent pas la même chose.

On peut les voir comme deux étapes successives du même processus d'apprentissage.

             Prédiction
                 │
                 ▼
         Calcul de l'erreur
                 │
                 ▼
          Backpropagation
 (calcul des corrections nécessaires)
                 │
                 ▼
        Descente de gradient
   (application des corrections)
                 │
                 ▼
      Nouveaux poids et biais

1. La backpropagation

La backpropagation (rétropropagation) répond à la question :

Quels poids sont responsables de l'erreur, et dans quelle proportion ?

Elle remonte depuis la sortie du réseau jusqu'aux premières couches.

Par exemple, si le réseau répond 99 % majeur pour une personne de 15 ans, la rétropropagation calcule :

• le poids n°1 a contribué un peu à l'erreur ;
• le poids n°2 beaucoup ;
• le poids n°3 presque pas ;
• etc.

En pratique, elle calcule pour chaque poids une quantité appelée gradient, c'est-à-dire l'influence d'une petite modification de ce poids sur l'erreur.

2. La descente de gradient

Une fois que l'on connaît ces gradients, la descente de gradient les utilise pour mettre à jour les paramètres.

Par exemple : poids actuel = 0,37

La backpropagation calcule : Gradient = +0,15

La descente de gradient décide alors :

« Puisque ce gradient est positif, je vais diminuer légèrement ce poids. »

Le nouveau poids devient : 0,37 → 0,35

Puis on fait la même chose pour tous les autres poids et biais.

Une analogie

Imagine que tu descends une montagne dans le brouillard.

La backpropagation c'est quelqu'un qui te dit :

« Le terrain descend vers la gauche et un peu vers l'avant. »

Autrement dit, elle indique la direction de la pente.

La descente de gradient c'est le fait de faire réellement un pas dans cette direction. Elle applique le mouvement.

Résumé

Une boucle complète d'entraînement

À chaque exemple d'entraînement, le réseau répète toujours les mêmes étapes :

1. Propagation avant (forward pass) : le réseau fait une prédiction.
2. Calcul de l'erreur : on compare la prédiction à la bonne réponse.
3. Backpropagation : on calcule les gradients pour tous les poids et biais.
4. Descente de gradient : on met à jour ces poids et biais.
5. On passe à l'exemple suivant.

C'est cette boucle, répétée des millions ou des milliards de fois, qui permet à un réseau de neurones — et donc à un LLM — d'apprendre progressivement.

Générer un petit code PHP sur l'exemple de l'âge

Oui. Voici un exemple très simplifié qui montre le fonctionnement d'un seul neurone. Ce n'est pas un véritable réseau de neurones entraînable, mais il permet de comprendre les calculs.

<?php

// Entrée
$age = 15;

// Paramètres du neurone
$poids = 0.18;
$biais = -3.25;

// Calcul du neurone
$z = ($age * $poids) + $biais;

// Fonction d'activation (sigmoïde)
$sortie = 1 / (1 + exp(-$z));

echo "Âge : $age\n";
echo "z = $z\n";
echo "Probabilité d'être majeur : " . round($sortie * 100, 2) . "%\n";

if ($sortie >= 0.5) {
    echo "=> Majeur\n";
} else {
    echo "=> Mineur\n";
}

Pour un âge de 15 ans, le programme affiche par exemple :

Âge : 15
z = -0.55
Probabilité d'être majeur : 36.58%
=> Mineur

Si on change l'âge ($age = 22;), on obtient :

Âge : 22
z = 0.71
Probabilité d'être majeur : 67.05%
=> Majeur

Ajouter l'apprentissage

Le code précédent ne fait que des prédictions. Les poids sont fixes.

Si on veut simuler un apprentissage, on peut ajouter une boucle très simple :

<?php

$poids = 0.37;
$biais = -1.12;

$jeuApprentissage = [
    [10, 0],
    [15, 0],
    [17, 0],
    [18, 1],
    [22, 1],
    [30, 1],
];

$tauxApprentissage = 0.01;

for ($iteration = 1; $iteration <= 1000; $iteration++) {

    foreach ($jeuApprentissage as [$age, $attendu]) {

        // Propagation avant
        $z = ($age * $poids) + $biais;
        $sortie = 1 / (1 + exp(-$z));

        // Erreur
        $erreur = $attendu - $sortie;

        // Mise à jour (version très simplifiée)
        $poids += $tauxApprentissage * $erreur * $age;
        $biais += $tauxApprentissage * $erreur;
    }
}

echo "Poids final : $poids\n";
echo "Biais final : $biais\n";

Ce n'est pas exactement l'algorithme utilisé dans les véritables réseaux de neurones (on simplifie ici le calcul du gradient), mais il montre très bien l'idée :

1. On fait une prédiction.
2. On calcule l'erreur (attendu - sortie).
3. On modifie légèrement le poids et le biais.
4. On recommence des centaines ou des milliers de fois.

Si tu souhaites comprendre les LLM en profondeur, je peux aussi te montrer comment programmer un mini réseau de neurones complet en PHP (environ 100 lignes) qui apprend réellement grâce à la backpropagation et à la descente de gradient. On verrait alors les matrices, les gradients et les mises à jour des poids exactement comme dans les vrais modèles, mais sur un exemple suffisamment simple pour rester compréhensible.

Exemple complet : un mini réseau de neurones entraînable en PHP

Avec plaisir ! Comme tu es développeur, voici un exemple qui ressemble vraiment à ce qui se passe dans un réseau de neurones, tout en restant suffisamment court pour être compréhensible.

L'objectif sera le même : apprendre automatiquement que 18 ans correspond à la majorité.

Architecture du réseau

Nous allons utiliser le plus petit réseau possible :

          âge
           │
           ▼
      [ Neurone ]
           │
           ▼
     Probabilité
      d'être majeur

Il n'y a :

• 1 entrée
• 1 neurone
• 1 sortie

Le neurone calcule :

z = âge × poids + biais

Puis applique une sigmoïde :

sortie = 1 / (1 + e^(-z))

Le code PHP

<?php

class Neurone
{
    public float $poids;
    public float $biais;
    public float $learningRate = 0.05;

    public function __construct()
    {
        // Valeurs aléatoires
        $this->poids = mt_rand(-100, 100) / 100;
        $this->biais = mt_rand(-100, 100) / 100;
    }

    private function sigmoid(float $x): float
    {
        return 1 / (1 + exp(-$x));
    }

    public function predict(float $age): float
    {
        $z = $age * $this->poids + $this->biais;

        return $this->sigmoid($z);
    }

    public function train(float $age, float $expected): float
    {
        //----------------------------------
        // Forward pass
        //----------------------------------

        $z = $age * $this->poids + $this->biais;

        $prediction = $this->sigmoid($z);

        //----------------------------------
        // Erreur
        //----------------------------------

        $error = $prediction - $expected;

        //----------------------------------
        // Dérivées
        //----------------------------------

        $sigmoidDerivative = $prediction * (1 - $prediction);

        $gradientPoids = $error * $sigmoidDerivative * $age;

        $gradientBiais = $error * $sigmoidDerivative;

        //----------------------------------
        // Descente de gradient
        //----------------------------------

        $this->poids -= $this->learningRate * $gradientPoids;

        $this->biais -= $this->learningRate * $gradientBiais;

        return abs($error);
    }
}

Jeu d'apprentissage

$dataset = [
    [10, 0],
    [12, 0],
    [15, 0],
    [16, 0],
    [17, 0],

    [18, 1],
    [19, 1],
    [21, 1],
    [25, 1],
    [35, 1],
];

Entraînement

$nn = new Neurone();

for ($epoch = 1; $epoch <= 5000; $epoch++) {
    $error = 0;

    foreach ($dataset as [$age, $expected]) {
        $error += $nn->train($age, $expected);
    }

    if ($epoch % 500 == 0) {
        echo "Epoch $epoch";
        echo " erreur = " . round($error, 3);
        echo PHP_EOL;
    }
}

Tu verras l'erreur diminuer progressivement :

Epoch 500  erreur = 1.84
Epoch 1000 erreur = 1.02
Epoch 1500 erreur = 0.54
Epoch 2000 erreur = 0.28
...

C'est exactement ce qu'on cherche : le réseau apprend.

Test

$tests = [8, 12, 15, 17, 18, 19, 22, 30];

foreach ($tests as $age) {
    $p = $nn->predict($age);

    echo str_pad($age, 3) . " ans : "
        . round($p * 100, 2)
        . " % majeur"
        . PHP_EOL;
}

Par exemple :

8 ans  : 0.03 %
12 ans : 0.27 %
15 ans : 4.8 %
17 ans : 31 %
18 ans : 62 %
19 ans : 87 %
22 ans : 99 %
30 ans : 100 %

On voit bien la transition autour de 18 ans.

Où est la backpropagation ?

C'est cette partie :

$error = $prediction - $expected;

$sigmoidDerivative = $prediction * (1 - $prediction);

$gradientPoids = $error * $sigmoidDerivative * $age;

$gradientBiais = $error * $sigmoidDerivative;

Cette partie calcule les gradients :

• dans quel sens modifier le poids ;
• dans quel sens modifier le biais.

C'est la rétropropagation (backpropagation).

Où est la descente de gradient ?

Ici :

$this->poids -= $this->learningRate * $gradientPoids;

$this->biais -= $this->learningRate * $gradientBiais;

Le gradient indique la direction à suivre, et la descente de gradient effectue un petit déplacement dans cette direction.

Pourquoi cet exemple est intéressant

Ce petit programme contient déjà les quatre étapes que l'on retrouve dans un LLM :

1. Forward pass : calcul de la prédiction.
2. Calcul de l'erreur.
3. Backpropagation : calcul des gradients.
4. Descente de gradient : mise à jour des paramètres.

La principale différence est qu'ici il n'y a qu'un seul neurone avec 2 paramètres (un poids et un biais), alors qu'un LLM moderne comporte des milliards de paramètres répartis sur des dizaines de couches. Les principes mathématiques restent toutefois les mêmes.

Je peux également te montrer l'étape suivante : un réseau avec une couche cachée (par exemple 1 entrée → 3 neurones → 1 sortie). C'est un excellent exemple pour comprendre comment la backpropagation traverse plusieurs couches, ce qui est le principe utilisé dans les grands modèles actuels.

Explique-moi la fonction sigmoïde

La fonction sigmoïde est une fonction mathématique qui transforme n'importe quel nombre en une valeur comprise entre 0 et 1.

Dans un réseau de neurones, elle sert à transformer le résultat brut d'un neurone en une valeur que l'on peut interpréter comme une probabilité.

La formule est :

σ(x) = 1 / (1 + e^(-x))

Voici son graphique :

Pourquoi a-t-on besoin d'une sigmoïde ?

Reprenons notre neurone. Il calcule d'abord :

z = âge × poids + biais

Supposons : âge = 22, poids = 0,18, biais = -3,25

Le calcul donne :

z = 22 × 0,18 - 3,25 = 0,71

Sans fonction d'activation, le neurone renverrait simplement 0,71. Mais que signifie 0,71 ? Est-ce une probabilité ? Un score ? Difficile à interpréter.

On applique donc la sigmoïde :

sigmoïde(0,71) = 0,67

On peut alors dire : 67 % de probabilité que la personne soit majeure.

Quelques exemples

On remarque une propriété importante :

• les valeurs très négatives deviennent proches de 0 ;
• les valeurs très positives deviennent proches de 1.

Pourquoi cette forme en S ?

Imagine que ton neurone calcule z = 100. Si on utilisait directement cette valeur, on obtiendrait 100, ce qui n'a pas de sens pour représenter une probabilité.

La sigmoïde "écrase" toutes les grandes valeurs :

100  →  0,999999999999999999...

Et toutes les grandes valeurs négatives :

-100 → 0,000000000000000000...

Elle garantit que le résultat reste toujours entre 0 et 1.

Pourquoi est-elle utilisée pendant l'apprentissage ?

La sigmoïde a une propriété essentielle : elle est dérivable.

Cela signifie que l'on peut calculer sa pente en chaque point.

Or, la backpropagation a précisément besoin de connaître cette pente pour savoir comment modifier les poids.

Le plus remarquable est que sa dérivée est très simple :

σ'(x) = σ(x) × (1 − σ(x))

C'est exactement ce que nous avons utilisé dans le code PHP :

$sigmoidDerivative = $prediction * (1 - $prediction);

Par exemple, si prediction = 0,80, alors :

sigmoidDerivative = 0,80 × (1 - 0,80) = 0,16

Cette valeur est utilisée pour calculer le gradient et ajuster les poids.

Une analogie

Imagine un professeur qui note un examen sur 20.

Le neurone calcule un score brut : 38. Mais la note maximale est 20.

La fonction sigmoïde joue un peu le rôle d'une conversion automatique : elle transforme ce score brut en une valeur normalisée entre 0 et 1, facile à interpréter.

Dans les LLM

Les LLM modernes utilisent rarement la sigmoïde dans leurs couches principales. Ils emploient plutôt d'autres fonctions d'activation comme GELU (Gaussian Error Linear Unit), qui offrent de meilleures performances pour les très grands réseaux.

En revanche, la sigmoïde reste un excellent point de départ pour comprendre les réseaux de neurones, car elle est simple à calculer et permet d'illustrer clairement le rôle d'une fonction d'activation et de sa dérivée dans l'apprentissage.

Exemple avec une couche cachée

Oui. C'est d'ailleurs à partir de là que les réseaux de neurones deviennent vraiment intéressants. Avec une couche cachée, on commence à voir la véritable utilité de la backpropagation.

Notre réseau

Nous allons construire un réseau très simple :

             Âge
              │
              ▼
      ┌─────────────────┐
      │  Couche cachée  │
      └─────────────────┘

        ●      ●      ●
        H1     H2     H3

          \     |     /
           \    |    /
            \   |   /
             ▼  ▼  ▼

            ● (Sortie)

        Probabilité
        d'être majeur

Il contient :

• 1 entrée (l'âge)
• 3 neurones cachés
• 1 neurone de sortie

À quoi servent les neurones cachés ?

Au début, ils ne savent rien.

Après l'entraînement, chacun peut apprendre quelque chose de différent. Par exemple :

• H1 → Détecte un âge élevé
• H2 → Détecte un âge proche de 18 ans
• H3 → Détecte un très jeune âge

Personne ne leur dit de faire cela. Ils le découvrent pendant l'apprentissage.

Les calculs

Couche cachée

Chaque neurone reçoit l'âge. Par exemple : âge = 17

Supposons les paramètres suivants :

Le calcul est :

H1 : 17 × 0,20 - 2  = 1,4   → sigmoïde → 0,80
H2 : 17 × 0,60 - 10 = 0,2   → sigmoïde → 0,55
H3 : 17 × -0,40 + 6 = -0,8  → sigmoïde → 0,31

La couche cachée produit donc : H1 = 0,80, H2 = 0,55, H3 = 0,31

Neurone de sortie

Le neurone final reçoit 0,80, 0,55, 0,31.

Supposons les poids : 0,8, 1,2, -0,4

Le calcul devient :

0,80 × 0,8 + 0,55 × 1,2 + 0,31 × (-0,4) = 1,17

Après la sigmoïde : 76 %

Le réseau répond : 76 % de chances d'être majeur.

Le code PHP

La couche cachée peut s'écrire comme ceci :

class HiddenNeuron
{
    public float $weight;
    public float $bias;

    public function __construct()
    {
        $this->weight = mt_rand(-100, 100) / 100;
        $this->bias   = mt_rand(-100, 100) / 100;
    }

    public function predict(float $age): float
    {
        $z = $age * $this->weight + $this->bias;

        return 1 / (1 + exp(-$z));
    }
}

Puis le réseau :

$hidden = [
    new HiddenNeuron(),
    new HiddenNeuron(),
    new HiddenNeuron(),
];

$values = [];

foreach ($hidden as $n) {
    $values[] = $n->predict($age);
}

À ce stade, $values contient par exemple :

Array
(
    [0] => 0.80
    [1] => 0.55
    [2] => 0.31
)

Ces trois valeurs sont ensuite envoyées au neurone de sortie.

Pourquoi la backpropagation devient compliquée ?

Dans notre premier exemple (sans couche cachée), il n'y avait qu'un seul poids :

âge → Sortie

L'erreur indiquait directement comment modifier ce poids.

Avec une couche cachée :

âge → H1, H2, H3 → Sortie

Si le réseau se trompe, il faut répondre à des questions comme :

• Est-ce la faute de H1 ?
• Ou de H2 ?
• Ou de H3 ?
• Ou des poids entre H1 et la sortie ?
• Ou des poids entre l'entrée et H2 ?

La backpropagation remonte l'erreur depuis la sortie vers la couche cachée. Elle répartit la responsabilité de l'erreur entre tous les neurones et calcule comment chaque poids doit être ajusté.

C'est exactement le principe des LLM

Dans un LLM, on retrouve la même idée, mais à une échelle gigantesque.

Au lieu d'avoir 1 entrée → 3 neurones → 1 sortie, on a des couches contenant souvent des milliers de neurones. Ces couches sont empilées plusieurs dizaines de fois :

Entrée
   │
   ▼
Couche 1 (4096 neurones)
   │
   ▼
Couche 2 (4096 neurones)
   │
   ▼
Couche 3 (4096 neurones)
   │
   ▼
...
   │
   ▼
Sortie

Les mêmes principes s'appliquent : propagation avant, calcul de l'erreur, rétropropagation et mise à jour des poids.

Je peux aussi te montrer un exemple encore plus pédagogique : un réseau avec 2 neurones cachés où l'on calcule à la main, ligne par ligne, la première étape de la backpropagation. C'est un excellent exercice pour comprendre concrètement comment l'erreur "remonte" dans le réseau.

Backpropagation calculée à la main sur un réseau à 2 neurones cachés

Excellent exercice ! C'est probablement le meilleur moyen de comprendre la backpropagation. Nous allons faire tous les calculs à la main sur un réseau minuscule.

Nous n'allons effectuer qu'une seule itération d'entraînement.

Notre réseau

          Entrée
         âge = 17
             │
             ▼

      ┌───────────────┐
      │ Couche cachée │
      └───────────────┘

         H1       H2
         ●        ●

          \      /
           \    /
            \  /
             ▼

         Neurone sortie

Nous allons utiliser la fonction sigmoïde partout.

Les poids

Entrée → couche cachée

Biais :

Couche cachée → sortie

Biais de sortie : -0.5

Étape 1 : propagation avant

Neurone H1

z1 = 17 × 0.2 − 2 = 3.4 − 2 = 1.4
H1 = σ(1.4) = 0.802

Neurone H2

z2 = 17 × 0.4 − 5 = 6.8 − 5 = 1.8
H2 = σ(1.8) = 0.858

Neurone de sortie

z = 0.802 × 0.8 + 0.858 × 0.6 − 0.5
0.802 × 0.8 = 0.6416
0.858 × 0.6 = 0.5148
Somme = 0.6564

Sortie = σ(0.6564) = 0.658

Le réseau répond donc : 65,8 % de chances que la personne soit majeure.

Réponse attendue

Pour 17 ans : Attendu = 0

Erreur : 0.658 — le réseau s'est trompé.

Première étape de la backpropagation

Nous allons commencer par le neurone de sortie uniquement.

Dérivée de la sigmoïde

Nous savons : σ'(x) = σ(x) × (1 − σ(x))

Donc : 0.658 × (1 − 0.658) = 0.225

Delta de sortie

Le delta est : δ = (sortie − attendu) × σ'

Calcul : 0.658 × 0.225 = 0.148

Le premier résultat de la backpropagation est : δ_sortie = 0.148

C'est ce nombre qui va servir à corriger les poids.

Mise à jour du poids H1 → sortie

Le gradient est : Gradient = δ × H1

Calcul : 0.148 × 0.802 = 0.119

Avec un taux d'apprentissage de 0.1, le nouveau poids devient :

0.8 − (0.1 × 0.119) = 0.7881

Le poids diminue légèrement.

Mise à jour du poids H2 → sortie

Gradient : 0.148 × 0.858 = 0.127

Nouveau poids : 0.6 − (0.1 × 0.127) = 0.5873

Et les neurones cachés ?

Jusqu'ici, nous n'avons corrigé que les poids entre la couche cachée et la sortie.

La véritable difficulté de la backpropagation est de calculer l'erreur des neurones cachés.

Pour H1, on utilise :

δ_H1 = δ_sortie × poids(H1→sortie) × σ'(H1)

Calculons :

• Le poids vaut : 0.8
• La dérivée de H1 : 0.802 × (1 − 0.802) = 0.159

Donc : 0.148 × 0.8 × 0.159 = 0.0188

On obtient : δ_H1 = 0.0188

De la même manière :

δ_H2 = 0.148 × 0.6 × 0.122 = 0.0108

Ces deux deltas servent ensuite à mettre à jour les poids reliant l'entrée aux neurones cachés.

Ce qu'il faut retenir

À chaque couche, la backpropagation suit toujours le même principe :

1. On calcule le delta de la couche de sortie.
2. On utilise ce delta pour mettre à jour les poids de sortie.
3. On "propage" ce delta vers les neurones cachés.
4. Chaque neurone caché obtient son propre delta.
5. On met à jour les poids qui arrivent sur ces neurones.
6. On recommence couche par couche jusqu'à revenir aux entrées.

C'est cette propagation de l'erreur de la sortie vers l'entrée qui a donné son nom à l'algorithme : backpropagation (rétropropagation).

Une fois que l'on comprend cet exemple à deux neurones cachés, on comprend le principe utilisé dans les très grands réseaux. La différence avec un LLM est essentiellement une question d'échelle : au lieu de 2 neurones cachés, il y en a des milliers par couche, et des dizaines de couches sont empilées. Le mécanisme mathématique reste le même.