Comment pense une machine ?

Il y a un moment singulier que connaît presque toute personne qui passe suffisamment de temps avec un bon modèle d’IA.

Au début, vous savez parfaitement que vous utilisez un logiciel.

Vous tapez dans une case. Un ordinateur effectue des calculs. Des mots apparaissent.

Puis, peut-être vingt minutes plus tard, vous posez une question compliquée. La machine remarque un détail mentionné dix minutes auparavant, le relie à autre chose, repère une contradiction dans votre raisonnement et produit une réponse non seulement grammaticale, mais apparemment pertinente.

Et à un moment arrive la question évidente :

Que s’est-il exactement passé dans la machine entre ma question et cette réponse ?

Pas philosophiquement.

Mécaniquement.

Qu’a réellement fait l’ordinateur ?

Suivons une question tout au long de son parcours dans la machine.

Supposons que vous écriviez :

Mon chien a volé un poulet entier sur la table de la cuisine. Dois-je appeler le vétérinaire ?

Pour vous, la phrase est déjà enveloppée de sens.

Il y a un chien.

Il y avait un poulet.

Le poulet a apparemment changé de propriétaire sans autorisation.

Il y a peut-être des os dans l’histoire.

Vous êtes inquiet.

Le chien, on le soupçonne, n’a aucun regret.

Un grand modèle de langage (Large Language Model, LLM) ne reçoit rien de cela sous forme d’image ou d’expérience. Il n’imagine pas un labrador devant une assiette vide. Il n’a jamais senti l’odeur du poulet rôti. Il n’a jamais conduit un animal aux urgences vétérinaires à onze heures du soir.

Il reçoit des symboles.

Et la première chose qu’il doit faire est de transformer ces symboles en nombres.

Première étape : la tokenisation — découper le langage en morceaux à la taille de la machine

Le modèle ne peut pas traiter directement votre phrase comme du langage ordinaire.

Avant que le réseau neuronal ne la voie, un logiciel appelé tokeniseur la découpe en unités plus petites appelées tokens.

Un token peut être un mot entier.

Il peut être une partie de mot.

Il peut être un signe de ponctuation.

Il peut être un nombre, une espace ou une partie d’un nom inconnu.

Ainsi :

My dog stole a whole chicken.

pourrait devenir, dans l’idée, quelque chose comme :

My | dog | stole | a | whole | chicken | .

Cet exemple est simplifié ; différentes familles de modèles utilisent différents tokeniseurs.

Chaque token reçoit ensuite un identifiant numérique appelé identifiant de token.

Le mot dog ne traverse pas le modèle sous la forme des lettres D-O-G.

Il pourrait y entrer sous une forme telle que :

Identifiant de token 8 214

Ce nombre précis ne signifie rien pour nous. C’est simplement une adresse dans le vocabulaire du modèle.

À ce stade, la machine a converti votre phrase en une suite de nombres entiers.

Cela ne ressemble à un progrès qu’en donnant au mot un sens très généreux.

Car le nombre 8 214 n’explique pas ce qu’est un chien.

Il nous faut pour cela une autre transformation.

Des identifiants de tokens aux plongements vectoriels

Le modèle convertit chaque identifiant de token en un plongement vectoriel, ou embedding.

Un embedding est une liste de nombres représentant le token dans un espace mathématique.

Un autre mot utile ici est vecteur.

Dans ce contexte, un vecteur est simplement une collection ordonnée de nombres.

Au lieu de représenter dog par un seul entier sans signification, le modèle peut le représenter par des centaines ou des milliers de valeurs numériques.

Très approximativement :

dog → [0.17, −0.42, 0.08, 1.31, …]

Ce vecteur peut contenir des milliers de nombres.

N’essayez pas d’attribuer une signification humaine à chaque position.

Le premier nombre ne signifie pas « a des poils ».

Le deuxième ne signifie pas « détruit parfois des meubles ».

Le sens émerge de l’ensemble du motif.

Vous pouvez imaginer les embeddings comme des coordonnées sur une immense carte.

Mais ce n’est pas une carte normale avec un nord, un sud, un est et un ouest.

Elle peut comporter plusieurs milliers de dimensions mathématiques.

Ce qui la rend désastreuse pour les voyages en voiture, mais très utile pour l’apprentissage automatique.

Sur cette étrange carte mathématique, les concepts apparentés tendent à développer des représentations apparentées.

Chien peut se trouver plus près de chiot que d’hypothèque.

Vétérinaire peut avoir des relations avec animal, médecine, clinique et traitement.

Poulet peut être relié à nourriture, oiseau, os, cuisine et des milliers d’autres contextes.

Personne n’a saisi toutes ces relations à la main dans le modèle.

Elles ont émergé parce que l’entraînement a ajusté les poids du modèle à répétition, jusqu’à faire apparaître des relations utiles.

Mais nous n’avons pas terminé.

Il y a un autre problème.

Le mot anglais bank peut désigner un établissement financier.

Ou la rive d’un cours d’eau.

L’embedding du mot seul ne permet pas de savoir lequel vous voulez dire.

Le sens dépend du contexte.

Et c’est avec le contexte que le Transformer commence à mériter son salaire.

Le bloc Transformer : là où commence le véritable traitement

Les grands modèles de langage modernes sont généralement constitués de nombreuses étapes de traitement répétées, appelées blocs Transformer.

Vous pouvez imaginer chaque bloc comme un étage d’un immeuble très haut.

Les représentations de vos tokens entrent au premier étage.

Elles sont transformées.

Elles montent.

L’étage suivant reçoit les représentations modifiées et les transforme à nouveau.

Un modèle moderne peut contenir des dizaines, voire plus d’une centaine de couches Transformer.

Quand l’information arrive tout en haut, la représentation de la phrase est bien plus riche qu’à son entrée.

Chaque bloc Transformer contient plusieurs mécanismes importants.

Le plus célèbre s’appelle :

l’auto-attention (self-attention).

Et c’est ici que nous avons besoin de trois des noms les plus étranges de l’IA moderne :

Query, Key et Value — requête, clé et valeur.

Habituellement abrégés en :

Q, K et V.

Query, Key, Value — des noms terribles, une idée utile

La terminologie vient en partie des systèmes de recherche d’information et, malheureusement, personne ne s’est demandé si les gens ordinaires devraient un jour l’apprendre.

Mais l’idée reste accessible.

Imaginez un cocktail.

Chaque personne porte un badge contenant des informations sur elle.

L’une d’elles cherche actuellement :

« Quelqu’un qui connaît la médecine vétérinaire. »

Cela ressemble à une Query, une requête.

Le badge de chaque autre personne décrit ce qu’elle représente.

Cela ressemble, dans une certaine mesure, à une Key, une clé.

Quand la requête correspond fortement à une clé particulière, nous accordons davantage d’attention aux informations détenues par cette personne.

Ces informations constituent la Value, la valeur.

Dans un Transformer, chaque token crée ses propres vecteurs Query, Key et Value.

Pas métaphoriquement : de véritables vecteurs numériques sont calculés à l’aide de matrices de poids apprises.

Le mot dog crée des représentations Q, K et V.

Chicken aussi.

Vet aussi.

Tous les autres tokens aussi.

Le modèle compare ensuite les requêtes aux clés pour calculer :

À quels autres tokens ce token doit-il prêter attention, et dans quelle mesure ?

Les scores d’attention : décider de ce qui compte

Revenons à notre malheureux poulet.

Le modèle arrive à la phrase :

Dois-je appeler le vétérinaire ?

La représentation associée à vétérinaire peut développer des relations fortes avec des tokens précédents comme :

chien
poulet
volé
entier

et des relations plus faibles avec des éléments moins importants, comme :

le

Cette relation est représentée mathématiquement par un score d’attention.

Techniquement, le modèle calcule ce qu’on appelle un produit scalaire entre les vecteurs Query et Key.

Un produit scalaire est simplement une façon mathématique de mesurer à quel point deux vecteurs sont alignés.

Vous n’avez pas besoin de connaître le détail du calcul.

Dans l’idée :

Forte correspondance → score plus élevé
Faible correspondance → score plus faible

Les scores passent ensuite par une opération mathématique appelée softmax.

Softmax transforme un ensemble de scores bruts en poids normalisés.

En langage courant :

Elle transforme « qui semble important ? » en « quelle part d’attention dois-je réellement accorder à chacun ? »

Peut-être, uniquement pour illustrer :

chien → 35% d’attention
poulet → 28%
vétérinaire → 21%
table → 6%
le → presque rien

L’attention réelle est beaucoup plus complexe, et plusieurs têtes d’attention fonctionnent simultanément, mais cette intuition est utile.

Le modèle combine alors les vecteurs Value correspondants selon ces poids d’attention.

Il produit ainsi une nouvelle représentation contenant des informations recueillies dans les parties pertinentes du contexte.

Le token ne représente plus seulement lui-même.

Il porte désormais des informations sur ses relations avec les autres tokens.

L’équation des ingénieurs

Un ingénieur écrit souvent l’auto-attention ainsi :

Attention(Q, K, V) = softmax(QKᵀ / √d) V

À première vue, on dirait que quelqu’un a fait dégringoler une calculatrice dans l’escalier.

Mais nous pouvons maintenant traduire cette formule.

Q = ce que cherche ce token.

K = ce que les autres tokens annoncent à leur sujet.

QKᵀ = comparer ce qui est recherché avec ce qui est disponible.

√d = un ajustement d’échelle pour que les nombres se comportent correctement sur le plan mathématique.

softmax = convertir les scores de comparaison en poids d’attention.

V = recueillir les informations des tokens selon ces poids.

Cette équation intimidante dit essentiellement :

Regardez autour de vous, décidez de ce qui compte et combinez les informations pertinentes.

Tout à coup, elle fait un peu moins peur.

L’attention multi-têtes : regarder la même phrase de plusieurs façons

Un Transformer ne réalise généralement pas un seul calcul d’attention.

Il utilise l’attention multi-têtes (Multi-Head Attention).

Une tête d’attention est un mécanisme d’attention indépendant.

Pourquoi en avoir plusieurs ?

Parce qu’une même phrase contient plusieurs types de relations à la fois.

Prenons :

Le chien qui a volé le poulet dort maintenant paisiblement parce qu’il n’a aucune conscience.

Une tête d’attention peut devenir utile pour les relations grammaticales.

Une autre peut se concentrer sur le nom auquel renvoie il.

Une autre peut suivre le sujet principal.

Une autre peut capter des relations sémantiques plus éloignées.

Évitons d’imaginer que chaque tête possède une tâche bien définie et compréhensible par un humain, telle que :

Tête numéro 17 = Service des vols de poulets.

La spécialisation n’est pas forcément aussi nette.

Mais plusieurs têtes permettent au réseau d’examiner simultanément le même contexte selon différents motifs de relations appris.

C’est pourquoi le modèle ne se contente pas de lire les mots de gauche à droite.

Il construit un réseau de relations entre eux.

L’état caché : ce que le modèle « sait » actuellement du token

Après l’attention, chaque token possède une représentation interne plus riche.

Cette représentation est généralement appelée état caché.

Le mot caché signifie simplement que ces nombres existent à l’intérieur du réseau neuronal, plutôt que d’être directement visibles par l’utilisateur.

C’est une idée importante.

Le modèle commence avec :

« chien »

sous forme de token.

Quelques couches plus tard, son état caché peut représenter implicitement quelque chose ressemblant davantage à :

le chien de l’utilisateur, qui vient de manger un poulet entier et suscite une possible inquiétude médicale

Aucune phrase française ne dit cela à l’intérieur du modèle.

L’état caché reste un vecteur de nombres.

Mais, mathématiquement, il porte maintenant beaucoup plus d’informations contextuelles.

Il entre ensuite dans le bloc Transformer suivant.

Encore de l’attention.

Encore une transformation.

Un autre état caché.

Encore.

Et encore.

Couche après couche.

Le réseau à propagation avant : réfléchir à ce que l’attention a trouvé

L’attention attire presque toute la publicité, mais les blocs Transformer contiennent un autre composant majeur : le réseau à propagation avant (Feed-Forward Network, FFN).

On peut voir l’attention comme la collecte des informations pertinentes.

Le réseau à propagation avant effectue ensuite des transformations supplémentaires sur ces informations.

Si l’attention est la rédaction d’un journal qui dit :

« Ces faits sont liés »,

le réseau à propagation avant dit plutôt :

« Très bien. Que faut-il en tirer ? »

Techniquement, cela implique de grandes multiplications de matrices.

Une matrice est essentiellement un tableau rectangulaire de nombres.

Les réseaux neuronaux modernes passent un temps extraordinaire à multiplier d’immenses matrices entre elles.

Cela peut sembler banal.

C’est aussi la raison pour laquelle les GPU sont si utiles.

Les processeurs graphiques (Graphics Processing Units, GPUs) ont été conçus pour effectuer de nombreuses opérations mathématiques simultanément.

Afficher des millions de pixels et traiter les matrices des réseaux neuronaux exigent des caractéristiques matérielles étonnamment compatibles.

L’humanité a passé des décennies à construire des cartes graphiques plus rapides pour rendre les explosions des jeux vidéo plus réalistes.

Puis des chercheurs ont découvert que ce même matériel était remarquablement doué pour l’intelligence artificielle.

La technologie emprunte rarement le chemin annoncé dans la brochure initiale.

Les fonctions d’activation : introduire la non-linéarité

À l’intérieur du réseau à propagation avant, nous rencontrons un autre terme :

fonction d’activation.

Sans fonctions d’activation, empiler de nombreuses couches neuronales serait bien moins puissant.

Une fonction d’activation introduit de la non-linéarité.

Cette expression mérite une traduction.

Si tout le réseau ne faisait que de simples combinaisons linéaires, de nombreuses couches se ramèneraient mathématiquement à l’équivalent d’une seule grande transformation linéaire.

Les fonctions d’activation non linéaires permettent au réseau de représenter des relations bien plus complexes.

Les Transformer modernes utilisent souvent des fonctions telles que GELU, SiLU ou des variantes proches.

Vous n’avez absolument pas besoin de mémoriser ces noms pour utiliser un LLM.

L’idée importante est la suivante :

Les fonctions d’activation permettent au réseau de courber, de filtrer et de remodeler l’information au lieu de simplement la mettre à l’échelle et l’additionner.

Pensez à la différence entre une règle et une boîte de Lego.

Les opérations linéaires vous donnent d’excellentes règles.

La non-linéarité vous permet de commencer à construire.

Les connexions résiduelles : ne jetez pas ce que vous saviez déjà

Les blocs Transformer utilisent aussi ce qu’on appelle une connexion résiduelle.

C’est une idée merveilleusement raisonnable dissimulée derrière un autre terme technique.

Au lieu de remplacer complètement la représentation précédente par une nouvelle transformation, le modèle réajoute une bonne partie des informations d’origine.

Dans l’idée :

nouvelle représentation = ancienne représentation + nouvelles informations

Pourquoi ?

Imaginez que vous corrigez un document.

Normalement, vous ne réécririez pas tout le document de mémoire chaque fois que vous corrigez un paragraphe.

Vous conservez ce qui fonctionnait déjà et ajoutez l’amélioration.

Les connexions résiduelles aident l’information à traverser des réseaux neuronaux très profonds sans être continuellement détruite ou déformée.

Elles font partie des innovations importantes qui ont rendu ces réseaux très profonds utilisables en pratique.

La normalisation de couche : garder les mathématiques sous contrôle

Il existe aussi la normalisation de couche (Layer Normalization).

Lorsque les valeurs traversent des dizaines de couches, leurs échelles numériques peuvent devenir difficiles à gérer.

La normalisation de couche remet les valeurs internes à une échelle plus stable.

Imaginez un ingénieur du son qui reçoit des pistes enregistrées à des volumes radicalement différents.

Un microphone murmure.

Un autre semble avoir été placé dans un réacteur d’avion.

Avant de mixer la musique, l’ingénieur a besoin de niveaux raisonnables.

La normalisation de couche effectue un travail analogue de rangement mathématique.

Elle n’apporte pas d’intelligence.

Mais sans un bon rangement, la partie intelligente devient beaucoup plus difficile à entraîner.

Apparemment, même l’intelligence artificielle a besoin que quelqu’un range la chambre.

Et cela se produit couche après couche

Faisons maintenant une pause.

Votre phrase d’origine :

Mon chien a volé un poulet entier sur la table de la cuisine. Dois-je appeler le vétérinaire ?

est passée par :

La tokenisation

→ conversion en identifiants de tokens

→ conversion en embeddings

→ transformation en vecteurs

→ entrée dans un bloc Transformer

→ traitement par auto-attention

→ comparaison des requêtes aux clés

→ calcul des poids d’attention avec softmax

→ combinaison des valeurs

→ transformation par un réseau à propagation avant

→ passage par des fonctions d’activation

→ préservation par des connexions résiduelles

→ stabilisation par la normalisation de couche

→ conversion en états cachés plus riches

Puis tout le processus recommence dans une autre couche Transformer.

Et une autre.

Et encore une autre.

Voilà qui est bien plus proche de ce qui se passe physiquement quand nous disons sans y penser :

« Le modèle réfléchit. »

Mais il reste un détail facile à manquer quand nous décrivons lentement ce processus sur une page.

L’ordinateur fait tout cela à une vitesse extraordinaire.

Quelque part, un centre de données vient de se réveiller

Si vous utilisez un service d’IA dans le cloud, votre question peut traverser internet jusqu’à un centre de données rempli de baies d’ordinateurs.

Dans ces baies se trouvent de puissants processeurs graphiques (Graphics Processing Units, GPUs) conçus pour effectuer d’énormes quantités d’opérations mathématiques en parallèle.

Les poids appris du modèle sont déjà chargés dans la mémoire de ces machines.

Ils ne sont pas créés au moment où vous posez votre question.

Ils ont été créés auparavant, pendant l’entraînement.

Vous pouvez voir ces poids comme la structure mathématique permanente acquise par le modèle au cours de son éducation.

Votre question ne s’y inscrit pas.

Elle passe à travers eux.

Cette distinction est importante.

Lorsque vous tapez :

Mon chien a volé un poulet. Dois-je appeler le vétérinaire ?

le modèle ne s’arrête pas pour se réentraîner.

Ses milliards de poids appris sont déjà là, à attendre.

Votre entrée arrive.

Elle devient des tokens.

Les tokens deviennent des embeddings.

Les embeddings deviennent des états cachés.

Ces états cachés traversent des couches successives de matrices de poids apprises.

L’attention compare les relations.

Les réseaux à propagation avant les transforment.

Les connexions résiduelles préservent les informations utiles.

La normalisation maintient la stabilité de toute l’opération numérique.

Le texte entrant se transforme progressivement en représentations internes de plus en plus riches.

On pourrait dire, assez librement, que la phrase d’origine est condensée en signification mathématique, bien que cette « condensation » ne signifie pas que l’information est réenregistrée dans les poids.

Les poids restent en grande partie fixes.

Ce qui change, c’est l’état interne temporaire produit en faisant passer votre question à travers ces poids.

Et tout cela peut impliquer des milliards et des milliards de multiplications et d’additions.

Pourtant, sur du matériel moderne, le début de la réponse peut apparaître en une fraction de seconde ou en quelques secondes, selon le modèle, le matériel, la charge du système et la taille de votre demande.

Pensez-y un instant.

Vous appuyez sur Entrée.

Votre phrase quitte votre ordinateur.

Quelque part, peut-être à des centaines ou des milliers de kilomètres, des GPU commencent à multiplier d’immenses matrices.

La phrase est découpée, transformée en vecteurs, comparée par des têtes d’attention, transformée à travers des dizaines de couches, réduite à des probabilités de tokens suivants possibles…

Puis une réponse commence à revenir.

Pour vous, cela ressemble à :

« Si votre chien a mangé un poulet entier, la question importante est de savoir s’il contenait des os cuits… »

On dirait une conversation.

Dans le centre de données, une énorme usine mathématique vient de se mettre au travail.

Et si vous exécutez le modèle localement, le même processus général se déroule sur le GPU de votre propre ordinateur.

Pas de centre de données lointain.

Pas de cloud mystérieux.

Simplement votre carte graphique accomplissant discrètement une quantité absurde de calculs pendant que ses ventilateurs reconsidèrent leurs choix de vie.

Mais le modèle doit finir par dire quelque chose

Après toutes ces couches, le modèle a construit une riche représentation cachée du contexte actuel.

Il doit maintenant reconvertir cet état interne en langage.

Le dernier état caché est transformé en une grande liste de nombres appelés logits.

Un logit est essentiellement un score brut pour un token suivant possible.

Supposons que la réponse soit sur le point de commencer.

Le modèle pourrait produire quelque chose comme :

Si → 8.4
Parce → 7.9
Votre → 6.7
Poulet → 2.1
Volkswagen → −3.8

Là encore, ces nombres sont inventés pour l’illustration.

Le modèle n’a pas encore choisi le mot.

Il a produit des scores.

Ces logits sont ensuite convertis en probabilités, généralement avec softmax, une fois de plus.

Maintenant, peut-être :

Si → 31%
Parce → 22%
Votre → 14%
Puisque → 11%
des centaines d’autres tokens → la probabilité restante

Le système doit décider quel token générer.

Température et échantillonnage : pourquoi le modèle ne dit pas toujours la même chose

Si le modèle choisissait toujours le token le plus probable, ses réponses pourraient devenir répétitives et rigides.

Les systèmes de génération utilisent donc souvent l’échantillonnage.

Échantillonner signifie choisir parmi les tokens probables selon leur distribution de probabilité.

Un réglage appelé température modifie le degré d’audace de ce choix.

À basse température, le modèle favorise fortement les tokens les plus probables.

Il se montre plus prudent.

À température plus élevée, les alternatives moins probables deviennent plus compétitives.

L’écriture peut devenir plus variée ou créative.

Elle peut aussi devenir plus excentrique.

Voyez la température comme la différence entre embaucher :

un comptable prudent

Et :

le même comptable après trois expressos et un cours d’improvisation.

Les deux peuvent être utiles.

Pas forcément pour la même mission.

D’autres réglages de génération comprennent l’échantillonnage top-k et l’échantillonnage top-p, qui restreignent les tokens candidats autorisés à entrer dans la sélection.

Les détails sont configurables, mais l’idée centrale est simple :

Le réseau neuronal produit des possibilités.

La stratégie de décodage choisit parmi elles.

Génération autorégressive : un token change le suivant

Le modèle sélectionne maintenant son premier token de sortie.

Peut-être :

Si

Ce token est ajouté au contexte.

Le modèle fonctionne à nouveau.

Il traite désormais :

Mon chien a volé un poulet entier sur la table de la cuisine. Dois-je appeler le vétérinaire ?
Si

Il prédit le token suivant.

Peut-être :

votre

Puis :

chien

Puis :

mange

Et ainsi de suite.

C’est ce qu’on appelle la génération autorégressive.

Auto signifie que le système réintroduit sa propre sortie générée dans la prédiction suivante.

Régressive, dans ce contexte, signifie que la valeur suivante dépend des valeurs précédentes de la séquence.

La réponse n’est donc pas écrite d’un seul coup.

Elle grandit.

Token après token.

Chaque token généré modifie légèrement le contexte à partir duquel le suivant sera prédit.

Voilà pourquoi l’analogie avec le jazz fonctionne si bien.

Un musicien joue une note.

Cette note change ce qui a du sens musicalement ensuite.

La note suivante change à nouveau les possibilités.

Un modèle de langage fait cela avec des tokens.

Existe-t-il donc un moment où le modèle « a la réponse » ?

C’est une question intéressante.

Généralement, pas comme un humain l’imagine.

Il n’y a pas d’instant précis où le modèle écrit intérieurement :

RÉPONSE COMPLÈTE TROUVÉE. IMPRIMER MAINTENANT.

Il y a plutôt un état interne en évolution continue.

Chaque couche affine les représentations.

Chaque token généré modifie le contexte.

La réponse émerge séquentiellement.

Cela aide à expliquer certains comportements étranges.

Un modèle peut commencer une réponse avec assurance puis constater, à travers le contexte qu’il vient lui-même de générer, qu’une autre direction aurait davantage de sens.

Il peut se corriger.

Ou se contredire.

Ou parfois foncer tout droit dans un fossé conceptuel tout en conservant une excellente grammaire.

La génération est un processus, pas la récupération d’un objet terminé.

Quelle place le cache de clés et de valeurs occupe-t-il dans tout cela ?

Nous pouvons enfin comprendre correctement le cache de clés et de valeurs (Key-Value Cache, KV cache).

Vous vous souvenez de Query, Key et Value ?

Chaque couche Transformer calcule des clés et des valeurs pour les tokens qu’elle traite.

Lors de la génération du token suivant, la plupart des clés et des valeurs précédentes n’ont pas besoin d’être recalculées.

Elles l’ont déjà été.

Le logiciel d’inférence les conserve donc dans le cache KV.

Le cache KV n’est ainsi pas une mystérieuse fonction supplémentaire collée au modèle.

Il est directement lié au mécanisme d’attention que nous venons de décrire.

Le cache dit :

« Nous avons déjà calculé les clés et les valeurs des tokens précédents. Gardons-les à portée de main pour ne pas refaire le même travail. »

À mesure que la conversation s’allonge, les tokens précédents deviennent plus nombreux.

Plus de tokens signifie plus de clés et de valeurs en cache.

Le cache KV grandit donc.

Et puisqu’il occupe de la VRAM, un contexte plus long exige davantage de mémoire GPU.

La relation devient logique, plutôt qu’une chose à simplement mémoriser :

Plus de contexte → plus d’informations K/V stockées → cache KV plus grand → davantage de VRAM utilisée.

C’est précisément ce genre de relation que Green Zone cherche à rendre visible.

Alors, finalement : comment la machine pense-t-elle ?

Revenons une dernière fois au chien et au poulet volé.

Vous avez tapé une phrase.

L’ordinateur ne l’a pas comprise de la manière immédiate et sans effort qui était la vôtre.

Il a dû construire cette compréhension.

Il a d’abord découpé votre langage en tokens.

Puis il a transformé ces tokens en vecteurs.

Ces vecteurs sont entrés dans un réseau contenant des milliards de poids appris.

L’auto-attention a permis aux différentes parties de la phrase d’interagir.

Les vecteurs Query, Key et Value ont aidé le modèle à décider quelles relations comptaient.

L’attention multi-têtes a permis d’examiner plusieurs motifs de relations différents en même temps.

Les réseaux à propagation avant ont transformé les informations obtenues.

Les fonctions d’activation ont permis des relations non linéaires complexes.

Les connexions résiduelles ont transmis les informations antérieures utiles.

La normalisation de couche a maintenu la stabilité du système numérique.

Et chaque couche Transformer a produit des états cachés plus riches que la précédente.

Quand l’information a atteint les dernières couches, la représentation mathématique interne ne correspondait plus simplement à des mots isolés comme :

chien
poulet
vétérinaire

Le réseau avait construit quelque chose de bien plus proche d’une représentation de la situation :

Une personne s’inquiète parce qu’un chien a mangé quelque chose qui peut contenir des os dangereux, et elle veut savoir si une intervention médicale pourrait être nécessaire.

Aucune phrase française ne dit cela à l’intérieur du modèle.

Aucun minuscule médecin n’examine le chien.

Il y a un état complexe composé de nombres.

Mais ces nombres encodent désormais des relations assez riches pour que le modèle puisse générer une suite appropriée.

Le dernier état caché est transformé en logits.

Les logits deviennent des probabilités.

Un algorithme de décodage choisit un token.

Ce token devient une partie de l’entrée suivante.

Un autre token est généré.

Puis un autre.

Pendant ce temps, les clés et les valeurs calculées auparavant restent disponibles dans le cache KV, ce qui permet au modèle de poursuivre la conversation sans recommencer chaque calcul depuis le début.

Et tout cela — tokenisation, embeddings, attention, multiplication de matrices, transformation des états cachés, calcul de probabilités, décodage et mise en cache — peut se dérouler assez vite pour que la réponse commence à apparaître presque immédiatement.

Il n’existe pas dans la machine une opération unique appelée pensée.

Il n’existe pas d’« équation de l’intelligence » particulière.

Il se passe quelque chose de plus intéressant.

Des milliers d’opérations mathématiques relativement simples sont répétées sur des milliards de paramètres appris, encore et encore, couche après couche, jusqu’à l’émergence d’une représentation complexe.

Pensez à un piano.

Un marteau seul n’est pas de la musique.

Une corde n’est pas de la musique.

Une touche en bois n’est pas de la musique.

La pédale n’est certainement pas de la musique.

Vous pouvez démonter tout l’instrument et examiner chaque pièce sans trouver Beethoven caché sous la table d’harmonie.

La musique apparaît lorsque les pièces sont correctement agencées et mises en mouvement.

Un réseau neuronal lui ressemble sur un point important.

Un poids isolé n’est pas intelligent.

Une multiplication de matrices n’est pas intelligente.

Un token n’est pas intelligent.

Même une tête d’attention, prise seule, n’est pas intelligente.

Le comportement remarquable apparaît grâce à l’interaction de l’ensemble du système.

Et c’est peut-être le plus étrange dans l’intelligence artificielle moderne.

Nous n’avons pas découvert un symbole mathématique signifiant :

intelligence = 42.

Nous avons appris à construire d’immenses systèmes dans lesquels de simples opérations mathématiques, soigneusement structurées et entraînées sur de vastes quantités de données, peuvent produire un comportement d’une sophistication étonnante.

Vous tapez :

Dois-je appeler le vétérinaire ?

Quelque part, des milliards de nombres se mettent au travail.

Et un instant plus tard, la machine répond.

Ce qui nous laisse avec la prochaine question évidente :

D’où viennent ces milliards de poids utiles ?

Car au moment où le modèle a été créé, ces poids ne savaient rien des chiens.

Ni des poulets.

Ni des vétérinaires.

Ni de Python.

Ni de la France.

Ni de Shakespeare.

Ils ont dû apprendre.

Et c’est là que commence la prochaine histoire.