Une IA ne réfléchit jamais. Voici ce qu'elle fait vraiment quand vous lui parlez.

Vous tapez une question. Vous appuyez sur Entrée. Le texte se met à apparaître, mot après mot, presque sans délai. Ce moment ressemble tellement à de la réflexion qu'on lui prête volontiers une conscience, une compréhension, presque une intention.

Ce n'est rien de tout ça. Ce qui se passe entre votre clic et le premier mot affiché tient en quatre mécanismes précis, qu'on va animer un par un pour que vous les voyiez plutôt que de devoir nous croire sur parole.

Étape 1 : votre phrase n'existe déjà plus

Avant même d'être lue, votre phrase est découpée en fragments appelés tokens. Un token peut être un mot entier, une syllabe, ou parfois un simple groupe de lettres. Le mot « intelligence » peut ainsi devenir deux ou trois morceaux distincts selon le découpage du modèle. Pour la machine, les mots tels que vous les lisez n'ont jamais existé.

from manim import *

class Tokenisation(Scene):
    def construct(self):
        phrase = Text("Le chat dort", font_size=44, color="#E8EDF5")
        self.play(Write(phrase))
        self.wait(0.6)
        tokens = VGroup(*[
            Text(mot, font_size=36, color="#000000")
            .add_background_rectangle(color="#0d1120", buff=0.15)
            for mot in ["Le", "chat", "dor", "t"]
        ]).arrange(RIGHT, buff=0.4)
        self.play(Transform(phrase, tokens), run_time=1.2)
        self.wait(1)

Étape 2 : un mot devient un point dans l'espace

Chaque token est ensuite transformé en une longue suite de nombres, un vecteur, qui le place comme un point dans un espace à plusieurs centaines de dimensions. Ce n'est pas une image, c'est un calcul, mais la logique est simple à visualiser en deux dimensions : les mots au sens proche se retrouvent voisins dans cet espace. « Roi » se rapproche de « reine » à peu près comme « chat » se rapproche de « chien ». Cette idée d'espace vectoriel de mots a été popularisée en 2013 par une équipe de chercheurs de Google autour de Tomas Mikolov, avec un système nommé Word2Vec. Les modèles actuels utilisent des espaces bien plus vastes, mais le principe de fond n'a pas changé.

from manim import *

class Embeddings(Scene):
    def construct(self):
        plan = NumberPlane(x_range=[-4,4], y_range=[-3,3])
        self.play(Create(plan))
        mots = {"roi": (1.2,1.6), "reine": (1.6,1.1),
                 "chat": (-2,-1), "chien": (-1.5,-1.4)}
        for mot, pos in mots.items():
            point = Dot(plan.c2p(*pos), color="#000000")
            label = Text(mot, font_size=28, color="#E8EDF5").next_to(point, UP, buff=0.15)
            self.play(FadeIn(point), Write(label), run_time=0.5)
        self.wait(1.5)

Étape 3 : pourquoi certains mots comptent plus que d'autres

Dans la phrase « la banque a refusé mon prêt », le mot « banque » doit être compris à la lumière de « prêt », pas de « rivière ». Le modèle règle ce problème avec un mécanisme appelé attention : pour chaque mot, il calcule à quel point tous les autres mots de la phrase sont pertinents pour l'interpréter, puis il pondère son interprétation en fonction de ce poids. Ce mécanisme a été formalisé en 2017 par une équipe de chercheurs Google dans un article resté célèbre sous le nom « Attention Is All You Need ». Il reste, huit ans plus tard, la base de pratiquement tous les modèles de langage en usage, de Claude à GPT.

from manim import *

class Attention(Scene):
    def construct(self):
        mots = ["la", "banque", "a", "refusé", "mon", "prêt"]
        groupe = VGroup(*[Text(m, font_size=32, color="#C8D3E8") for m in mots])
        groupe.arrange(RIGHT, buff=0.5)
        self.play(Write(groupe))
        cible = groupe[1]  # "banque"
        lien = Line(cible.get_bottom(), groupe[5].get_bottom(), color="#000000", stroke_width=4)
        self.play(cible.animate.set_color("#000000"), Create(lien), run_time=1)
        self.wait(1.2)

Le vrai twist : il ne choisit jamais, il tire au sort

Voici l'endroit où l'intuition la plus répandue se trompe. On imagine le modèle en train de sélectionner « le bon mot suivant », comme s'il savait ce qu'il voulait dire. Ce n'est pas ce qui se passe. À chaque étape, le modèle calcule une liste de tous les tokens possibles, chacun avec un pourcentage de probabilité, puis un tirage pondéré choisit le suivant parmi cette liste. Le mot le plus probable n'est même pas toujours celui qui sort. C'est ce tirage, réglé par un paramètre appelé température, qui explique pourquoi deux réponses à la même question ne sont jamais identiques.

from manim import *

class Sampling(Scene):
    def construct(self):
        candidats = [("dort", 0.52), ("mange", 0.21), ("joue", 0.14), ("miaule", 0.08), ("fuit", 0.05)]
        barres = VGroup()
        for mot, p in candidats:
            barre = Rectangle(width=p*6, height=0.4, fill_color="#000000", fill_opacity=0.8)
            label = Text(f"{mot} : {int(p*100)}%", font_size=24, color="#E8EDF5").next_to(barre, RIGHT)
            ligne = VGroup(barre, label)
            barres.add(ligne)
        barres.arrange(DOWN, buff=0.3, aligned_edge=LEFT)
        self.play(LaggedStart(*[GrowFromEdge(b[0], LEFT) for b in barres], lag_ratio=0.15))
        self.play(Write(VGroup(*[b[1] for b in barres])))
        self.wait(1.5)

Alors pourquoi ça semble parler, et pas juste bafouiller ?

Une fois le token tiré, il est ajouté à la phrase, et tout le processus recommence : tokenisation implicite, embeddings, attention, nouveau tirage. Le modèle relit sa propre réponse à chaque mot généré. C'est une boucle, répétée token après token jusqu'à un signal d'arrêt. Ce qui donne l'illusion d'un raisonnement continu n'est en réalité qu'une répétition extrêmement rapide de ce même cycle, à l'échelle de centaines de milliards de paramètres ajustés sur des quantités de texte largement supérieures à ce qu'un humain pourrait lire en plusieurs vies.

Comment on a fait ces animations. Toutes les scènes de cet article sont générées avec Manim, décrit dans un précédent article du Lab : créer des animations mathématiques avec Claude et Manim, ou en connectant directement Claude à un serveur qui génère les vidéos pour vous : le serveur MCP Manim.

La prochaine fois que le texte se mettra à défiler à l'écran, vous saurez ce qui se cache réellement derrière : ni magie, ni conscience, mais quatre mécanismes enchaînés à une vitesse qui donne l'illusion de la pensée.