Des neurones biologiques aux LLM

Une petite histoire du deep learning

Auteur·rice

Augustin Chevallier

Un réseau de neurones n’est jamais qu’une fonction, construite en empilant un très grand nombre de blocs très simples. Rien dans cette phrase ne laisse deviner pourquoi il aura fallu près de soixante-dix ans, deux hivers académiques et l’arrivée massive des cartes graphiques pour que cette idée porte ses fruits. C’est cette histoire que cet article retrace : des premiers neurones artificiels des années 1940 aux grands modèles de langage d’aujourd’hui, en passant par un problème de logique qui a bien failli enterrer le domaine.

1 Du neurone biologique au perceptron

1.1 Une inspiration biologique

Un neurone biologique reçoit des signaux par ses dendrites, chacune reliée à un autre neurone par une synapse. Le corps cellulaire combine ces signaux, et si le total dépasse un certain seuil, le neurone transmet à son tour un signal en sortie, le long de son axone. C’est un mécanisme d’une simplicité trompeuse : un neurone isolé ne fait presque rien d’intéressant, mais des milliards d’entre eux, connectés en réseau, suffisent à faire fonctionner un cerveau.

Le neurone artificiel copie ce principe, en beaucoup plus simple. L’analogie s’arrête d’ailleurs là : un neurone artificiel ne « pense » pas comme un neurone biologique, il ne fait qu’en imiter la structure de calcul la plus élémentaire.

1.2 Le neurone artificiel

Formellement, un neurone artificiel reçoit des entrées \(x_1, \dots, x_n\), chacune associée à un poids \(w_i\). Il calcule une somme pondérée de ces entrées, y ajoute un biais \(b\), puis applique une fonction d’activation \(h\) — l’équivalent du seuil biologique, mais rendu continu et différentiable. La sortie du neurone s’écrit donc :

\[y = h\left(\sum_i w_i x_i + b\right)\]

1.3 McCulloch & Pitts (1943)

La première formalisation mathématique de ce modèle remonte à 1943, avec les travaux de Warren McCulloch et Walter Pitts. Leur neurone artificiel suffit déjà à calculer des fonctions logiques simples comme ET ou OU — à condition de choisir les bons poids. Il n’y a encore aucun apprentissage : les poids sont fixés à la main par le concepteur du réseau, pas ajustés automatiquement à partir de données.

Le code ci-dessous illustre cette idée sur un neurone unique : en choisissant des poids et un biais adéquats, la même formule permet d’implémenter ET et OU.

Afficher le code

def neuron(x1, x2, w1, w2, b):
    return 1 if w1 * x1 + w2 * x2 + b > 0 else 0

print("ET (AND), poids=(1,1), biais=-1.5:")
for x1 in [0, 1]:
    for x2 in [0, 1]:
        print(f"  {x1} ET {x2} = {neuron(x1, x2, 1, 1, -1.5)}")

print("OU (OR), poids=(1,1), biais=-0.5:")
for x1 in [0, 1]:
    for x2 in [0, 1]:
        print(f"  {x1} OU {x2} = {neuron(x1, x2, 1, 1, -0.5)}")

ET (AND), poids=(1,1), biais=-1.5:
  0 ET 0 = 0
  0 ET 1 = 0
  1 ET 0 = 0
  1 ET 1 = 1
OU (OR), poids=(1,1), biais=-0.5:
  0 OU 0 = 0
  0 OU 1 = 1
  1 OU 0 = 1
  1 OU 1 = 1

1.4 Le perceptron de Rosenblatt (1958)

L’étape suivante est franchie par Frank Rosenblatt en 1958. Sa contribution majeure n’est pas tant le modèle du neurone — resté proche de celui de McCulloch et Pitts — que la manière de le régler : les poids sont désormais appris automatiquement, à partir d’exemples, plutôt que fixés à la main. Rosenblatt construit une machine physique, le Mark I Perceptron, équipée de 400 capteurs de lumière, capable d’apprendre à reconnaître des formes simples.

L’annonce fait grand bruit. Le New York Times rapporte en 1958 que la marine américaine dévoile une machine qui saura bientôt « marcher, parler, voir, écrire, se reproduire et être consciente ». Avec le recul, on sait ce qu’il en est : mais l’enthousiasme de l’époque, aussi excessif fût-il, dit quelque chose de l’espoir que ce simple mécanisme d’apprentissage automatique venait de faire naître.

2 XOR et le premier hiver de l’IA

2.1 Un problème très simple

Le perceptron de Rosenblatt, dans sa forme la plus simple, revient à tracer une droite qui sépare le plan en deux régions. C’est suffisant pour apprendre ET ou OU. Est-ce suffisant pour tout ?

Considérons le problème XOR (« ou exclusif »), défini par la table de vérité suivante :

\(x_1\)	\(x_2\)	XOR
0	0	0
0	1	1
1	0	1
1	1	0

En plaçant ces quatre points dans le plan, une chose saute aux yeux : les deux points étiquetés 0 sont sur une diagonale, les deux points étiquetés 1 sur l’autre. Aucune droite ne peut séparer les deux classes.

Afficher le code

import matplotlib.pyplot as plt
import torch

X = torch.tensor([[0., 0.], [0., 1.], [1., 0.], [1., 1.]])
y = torch.tensor([[0.], [1.], [1.], [0.]])

plt.figure(figsize=(5, 5))
plt.scatter(X[:, 0], X[:, 1], c=y.squeeze(), cmap="RdBu", edgecolor="black", s=300, vmin=0, vmax=1)
for (x1, x2), label in zip(X.tolist(), y.squeeze().tolist()):
    plt.annotate(f"{int(label)}", (x1, x2), ha="center", va="center", fontweight="bold", color="white")
plt.xlim(-0.5, 1.5)
plt.ylim(-0.5, 1.5)
plt.title("Une seule droite peut-elle séparer les 0 des 1 ?")
plt.xlabel("$x_1$")
plt.ylabel("$x_2$")
plt.show()

2.2 Le coup d’arrêt de 1969

C’est très exactement ce que démontrent Marvin Minsky et Seymour Papert dans leur livre Perceptrons, publié en 1969 : un perceptron à une seule couche ne peut pas apprendre XOR, ni plus généralement aucune fonction qui ne soit pas linéairement séparable.

Il faut insister sur un point souvent perdu de vue : c’est un résultat mathématique précis et limité, qui s’applique aux perceptrons à une seule couche. Il ne dit rien contre les réseaux de neurones en général — un réseau à plusieurs couches, on le verra, résout XOR sans difficulté. Mais à l’époque, la nuance se perd, et le livre de Minsky et Papert est largement interprété comme une condamnation de l’approche tout entière.

D’autres promesses de la décennie précédente restent également lettre morte. Un rapport américain, le rapport ALPAC de 1966, juge sévèrement décevants les résultats de la traduction automatique, un des grands espoirs de l’intelligence artificielle naissante. Entre les limites démontrées du perceptron et les promesses non tenues sur la traduction, les financements se tarissent : c’est le premier hiver de l’IA.

L’histoire retient aussi un détail plus personnel. Walter Pitts, coauteur du modèle de neurone de 1943, aurait fini par brûler sa thèse non publiée, convaincu que ses travaux étaient devenus obsolètes.

3 On empile plusieurs couches

3.1 Un perceptron ne suffit pas, une couche cachée si

On vient de le voir géométriquement : aucune droite ne sépare les deux classes de XOR. Un perceptron à une seule couche ne peut donc pas faire mieux que deviner au hasard sur ce problème.

La solution, avec le recul, paraît presque évidente : il suffit d’ajouter une couche intermédiaire. En insérant une seule couche cachée, dotée d’une non-linéarité, le réseau peut tracer une frontière de décision courbe plutôt qu’une simple droite — largement suffisant pour séparer parfaitement les quatre points de XOR. Reste un problème bien réel : comment entraîner efficacement un réseau qui compte désormais plusieurs couches ?

3.2 Généraliser : des couches de neurones

Rien n’empêche, en principe, d’empiler encore plus de neurones, organisés en encore plus de couches. C’est là l’architecture de base de tout réseau de neurones moderne : une couche d’entrée, une ou plusieurs couches cachées, une couche de sortie — chaque neurone d’une couche connecté à tous les neurones de la couche suivante.

Afficher le code

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 5))
layer_sizes = [3, 4, 4, 2]
layer_x = [0, 1, 2, 3]
positions = {}
for l, (px, n) in enumerate(zip(layer_x, layer_sizes)):
    ys = [(i - (n - 1) / 2) for i in range(n)]
    for i, py in enumerate(ys):
        positions[(l, i)] = (px, py)

for l in range(len(layer_sizes) - 1):
    for i in range(layer_sizes[l]):
        for j in range(layer_sizes[l + 1]):
            x1, y1 = positions[(l, i)]
            x2, y2 = positions[(l + 1, j)]
            ax.plot([x1, x2], [y1, y2], color="lightgray", zorder=1, linewidth=0.8)

for (l, i), (px, py) in positions.items():
    color = "tab:blue" if l == 0 else ("tab:green" if l == len(layer_sizes) - 1 else "tab:orange")
    ax.scatter([px], [py], s=400, color=color, zorder=2, edgecolor="black")

ax.text(layer_x[0], max(layer_sizes) / 2 + 0.8, "Entrée", ha="center")
ax.text(layer_x[-1], max(layer_sizes) / 2 + 0.8, "Sortie", ha="center")
ax.text((layer_x[1] + layer_x[2]) / 2, max(layer_sizes) / 2 + 0.8, "Couches cachées", ha="center")
ax.axis("off")
plt.title("Un réseau de neurones : des couches reliées entre elles")
plt.show()

Chaque trait du schéma ci-dessus porte un poids ; chaque neurone effectue une somme pondérée de ce qu’il reçoit, suivie d’une non-linéarité. L’ensemble de ces poids constitue les paramètres du réseau — souvent plusieurs millions, parfois plusieurs milliards.

Au départ, ces poids sont initialisés aléatoirement : le réseau ne sait rien faire d’utile. Apprendre, c’est précisément ajuster ces poids pour que la sortie du réseau corresponde à ce qu’on souhaite obtenir — un sujet à part entière, qui dépasse le cadre de cet article.

3.3 La rétropropagation (1986)

Reste donc la question laissée en suspens : comment entraîner efficacement un réseau à plusieurs couches ? La réponse est publiée en 1986 par David Rumelhart, Geoffrey Hinton et Ronald Williams, sous le nom de rétropropagation du gradient. L’algorithme permet, pour la première fois de façon pratique, d’entraîner des réseaux multi-couches — et résout donc, dix-sept ans plus tard, le problème posé par Minsky et Papert.

L’histoire mérite une précision honnête : il s’agit moins d’une invention que d’une redécouverte. La technique mathématique sous-jacente, la différentiation automatique en mode inverse, était déjà connue depuis les travaux de Seppo Linnainmaa en 1970, et Paul Werbos avait déjà proposé de l’appliquer aux réseaux de neurones dès 1974. Ce qui change véritablement en 1986, c’est que l’algorithme est popularisé et appliqué avec un succès suffisant pour relancer l’intérêt de toute une communauté.

4 1990-2010 : une traversée du désert

4.1 LeNet : lire l’écriture manuscrite

La rétropropagation ouvre la voie à des applications concrètes. Yann LeCun applique ces couches empilées à un problème réel : lire des chiffres, puis des lettres, écrits à la main. Il ajoute au passage deux ingrédients qui deviendront centraux dans les décennies suivantes : la convolution, qui détecte des motifs locaux comme un bord ou une courbe, et le pooling, qui réduit progressivement la résolution de l’image. Entraîné sur des chiffres manuscrits — les codes postaux américains, en particulier — le système, baptisé LeNet, est déployé en production dès les années 1990 pour la lecture automatique de chèques bancaires. Avec ses couches de convolution et de pooling, LeNet ressemble déjà, en miniature, aux architectures de type CNN utilisées aujourd’hui.

4.2 Le calme avant la tempête

Malgré cette réussite, la décennie qui suit reste étonnamment calme pour les réseaux de neurones. Ce n’est pas un second hiver aussi net que celui de 1969 — il n’y a pas ici de résultat théorique qui ferme brutalement une porte — mais plutôt un manque persistant de données et de puissance de calcul pour exploiter des réseaux plus profonds. D’autres familles de modèles, les machines à vecteurs de support (SVM) et les forêts aléatoires en tête, prennent le dessus dans la recherche en apprentissage automatique : plus faciles à entraîner, plus faciles à justifier théoriquement, avec moins de données. Les réseaux de neurones passent tout simplement de mode.

5 2010 à aujourd’hui : l’explosion

5.1 Le rôle du GPU

Il faut attendre le tournant des années 2010 pour que la situation change du tout au tout. Vers 2012, AlexNet — entraîné sur GPU, avec beaucoup plus de données grâce à la base ImageNet — remporte le concours de classification d’images ImageNet avec une marge écrasante sur ses concurrents. Le GPU, conçu à l’origine pour les jeux vidéo, devient l’outil clé du deep learning : il permet de paralléliser massivement les calculs matriciels au cœur de l’entraînement des réseaux de neurones, une opération pour laquelle il est, par construction, particulièrement bien adapté.

5.2 Une décennie d’architectures

Les années qui suivent voient une explosion d’architectures nouvelles. VGG (2014) mise sur la simplicité : empiler beaucoup de couches, sans autre astuce. ResNet (2015) introduit les connexions résiduelles, un raccourci qui laisse le signal sauter des couches et permet d’entraîner des réseaux de plusieurs centaines de couches — un sujet développé plus en détail dans le cours consacré aux architectures profondes. En 2017, les Transformers, présentés dans l’article Attention Is All You Need, abandonnent la récurrence au profit d’un mécanisme d’attention appliqué à toute la séquence à la fois. BERT puis GPT appliquent ces mêmes idées à des textes toujours plus grands, jusqu’à ChatGPT, qui rend ces modèles accessibles au grand public fin 2022.

5.3 Les LLM : une croissance qui s’accélère

Depuis, la progression des capacités des grands modèles de langage ne montre aucun signe de ralentissement. Le site metr.org mesure, de façon systématique, la durée des tâches informatiques que les meilleurs modèles réussissent à accomplir seuls, avec un taux de succès de 50 %. Cette durée double environ tous les sept mois depuis 2019 — et tous les trois à quatre mois depuis 2023.

6 Conclusion

De la biologie du neurone à l’échelle des modèles actuels, cette histoire est aussi celle d’une idée simple — empiler des unités de calcul élémentaires — qui a mis des décennies à trouver les conditions de son succès : suffisamment de données, suffisamment de calcul, et les bons algorithmes pour l’entraîner. Les cours qui suivent reprennent chacun de ces fils : comment un réseau déjà entraîné produit une prédiction, comment on l’entraîne, pourquoi les réseaux profonds sont difficiles à optimiser, et comment ces mêmes principes, appliqués au texte, ont donné naissance aux grands modèles de langage.