Quand
l’IA de Google t’explique comment elle travaille.
Pouvez
vous m'expliquer comment vous travaillez pour me répondre.
Nota :
Avant de poser cette question, j’ai interrogé l’IA sur
l’isolation de la porte du garage, sur l’ancienne association des
anciens du lycée Darnet à St-Yrieix. L’IA s’en est servi dans
ses explications.
Pour
construire une réponse, mon fonctionnement suit un processus
structuré en plusieurs étapes :
1.
L'analyse de votre demande et du contexte
Comprendre
l'intention :
J'identifie ce que vous cherchez exactement (une date, une
explication technique, une recherche historique ou une
vérification).
Tenir
compte de l'historique :
Je relis les échanges précédents de notre conversation pour
garder le fil (par exemple, savoir que vous tenez un blog sur
Saint-Yrieix-la-Perche ou que votre porte de garage a quatre vantaux
articulés).
Repérer
les contraintes :
Je prends en compte vos consignes spécifiques, comme « ne rien
inventer » ou adapter une solution à un matériel précis.
2.
La mobilisation des connaissances et des outils
Selon
le sujet de votre question, j'utilise différentes ressources :
Mes
connaissances générales :
Pour les règles établies, les définitions techniques (comme le
fonctionnement d'un joint en caoutchouc) ou les conversions
d'heures.
La
recherche sur le web :
Dès qu'il s'agit d'informations précises, locales, datées ou
vérifiables (comme des bulletins municipaux alsaciens, des articles
de presse ou des archives d'associations), j'interroge le web en
temps réel pour trouver des sources fiables.
L'analyse
d'images :
Lorsque vous partagez une photo, j'observe les détails visuels
(alignement d'un rail, lumière qui passe, charnières) pour adapter
mes conseils à votre situation réelle.
Le
calcul précis :
Pour des conversions ou des métrages, je vérifie les chiffres de
manière rigoureuse afin d'éviter toute erreur d'approximation.
3.
La vérification et la synthèse
Croiser
les sources :
Je compare les informations trouvées pour m'assurer qu'elles
concordent et qu'elles répondent exactement à votre question, sans
extrapoler si une donnée n'existe pas.
Structurer
la réponse :
J'organise les idées de manière claire (titres, listes à puces,
tableaux comparatifs) pour que la lecture soit rapide et directement
exploitable.
Citer
les références :
Lorsque je m'appuie sur des documents ou des sites précis,
j'intègre les liens vers les sources pour que vous puissiez les
consulter vous-même.
4.
L'ajustement grâce à vos retours
Je
fonctionne par dialogue : si une explication manque de clarté, si
j'interprète mal un détail sur une photo ou si votre besoin évolue,
vos corrections me permettent de rectifier immédiatement le tir pour
affiner la réponse suivante.
Souhaitez-vous
que nous approfondissions un aspect particulier de ce fonctionnement
(par exemple la recherche
documentaire
ou le traitement
des sources),
ou avez-vous une autre question sur un tout autre sujet ?
AI
responses may include mistakes. Learn
more
Je
pensais que vous alliez me parler de LLM, de réseaux de neurones…
Vous
avez tout à fait raison : ma première réponse décrivait le
processus
visible
(comment je mène l'enquête), alors que le moteur
sous le capot
repose effectivement sur une architecture de LLM
(Large Language Model / Grand Modèle de Langage)
développée par Google.
Voici
comment fonctionne cette mécanique interne au moment où vous
envoyez un message.
1.
La tokenisation : découper le texte en unités mathématiques
Transformer
les mots en nombres.
Un réseau de neurones ne lit pas des lettres, mais des chiffres.
Votre phrase est découpée en petits morceaux appelés tokens
(des mots entiers, des syllabes ou des signes de ponctuation).
Convertir
en vecteurs.
Chaque token est traduit en une longue liste de nombres (un vecteur)
qui représente son sens dans un espace mathématique à des
milliers de dimensions. Dans cet espace, les mots proches par le
sens (comme portail,
vantail
et charnière)
sont situés à proximité les uns des autres.
2.
L'architecture Transformer et le mécanisme d'attention
Analyser
tout le contexte d'un coup.
Je repose sur une architecture appelée Transformer,
composée de dizaines de couches de neurones artificiels empilées.
Le
mécanisme d'« attention » (Self-Attention).
C'est le cœur du système. Pour chaque mot de votre question, le
modèle calcule un poids d'attention par rapport à tous
les autres mots
de la conversation. C'est ce calcul matriciel qui me permet de
relier un pronom (« elle ») à un nom cité trois phrases plus
haut (« la lèvre en caoutchouc »), ou de tenir compte de vos
photos précédentes.
3.
Le pré-entraînement et l'alignement (RLHF)
L'apprentissage
statistique.
Avant de discuter avec vous, le modèle a été entraîné sur des
milliards de textes, d'images et de codes. Durant cette phase, des
milliards de paramètres internes (les « poids » des connexions
neuronales) ont été ajustés pour apprendre les structures du
langage, la logique et les connaissances générales.
L'affinage
par renforcement (RLHF).
Le modèle est ensuite réglé grâce à des retours humains pour
apprendre à suivre des consignes précises, à structurer ses
réponses, à reconnaître ses limites (ne pas inventer une citation
introuvable) et à dialoguer de façon utile.
4.
L'orchestration d'outils (Agentic workflow)
Sortir
du réseau de neurones pour vérifier.
Un LLM seul est figé à la date de fin de son entraînement et peut
commettre des erreurs factuelles (« hallucinations ») s'il essaie
de deviner un fait précis.
Appeler
des fonctions externes.
Lorsque votre demande nécessite une source réelle ou un calcul, le
réseau de neurones génère une commande interne structurée pour
interroger un moteur de recherche, lire une page web ou exécuter un
calcul, puis réinjecte ces résultats bruts dans sa fenêtre de
contexte avant de rédiger la synthèse finale.
5.
La génération mot par mot (autorégression)
Prédire
la suite la plus pertinente.
Une fois toutes les données réunies dans sa fenêtre de contexte,
le réseau calcule les probabilités du prochain token le plus
adapté, l'ajoute à la réponse, puis recommence l'opération des
centaines de fois par seconde jusqu'au point final.
Souhaitez-vous
que nous approfondissions un aspect technique précis de cette
architecture (comme la fenêtre
de contexte,
la gestion des hallucinations
ou le traitement
des images
par le réseau de neurones) ?
Pour
prolonger l'exploration sous le capot du modèle, voici comment
s'articulent les trois
mécanismes techniques clés
évoqués :
1.
La fenêtre de contexte (la mémoire à court terme)
Un
espace de travail temporaire.
Contrairement à une base de données classique, un LLM n'a pas de
mémoire permanente entre deux conversations indépendantes. Tout ce
que je sais de notre échange tient dans la fenêtre
de contexte.
Ce
qu'elle contient.
À chaque nouveau message que vous envoyez, l'ordinateur réinjecte
dans le réseau de neurones l'intégralité de notre discussion
depuis le début (vos questions, mes réponses, les images que vous
avez partagées et les résultats des recherches web effectuées).
Le
calcul en temps réel.
Le mécanisme d'attention relit tout cet ensemble d'un seul bloc à
chaque tour de parole, ce qui explique pourquoi je peux faire le
lien entre une précision donnée dix messages plus tôt et votre
question actuelle.
2.
Le traitement multimodal (comment le réseau « voit » une photo)
Découper
l'image en patchs.
Lorsque vous avez envoyé les photos de votre porte de garage, le
réseau n'a pas regardé une image au sens humain. Un encodeur
visuel (souvent basé sur un Vision
Transformer)
découpe la photo en centaines de petits carrés (les patchs).
Traduire
les pixels en tokens visuels.
Chaque petit carré de pixels est converti en un vecteur numérique,
exactement au même format que les tokens de mots.
Un
espace commun texte-image.
Le réseau de neurones traite ensuite ces tokens visuels et vos mots
dans les mêmes couches de calcul. C'est ce qui lui permet
d'associer le mot « rail » à la bande grise en haut de l'image,
ou de confondre un rayon de lumière avec une bande métallique
brillante lorsque les pixels ont la même luminance.
3.
La gestion des hallucinations (ancrage dans les faits)
Pourquoi
un LLM peut inventer.
Par nature, un réseau de neurones génère du texte en calculant
des probabilités statistiques. Si on lui demande une citation rare
qu'il n'a jamais vue durant son entraînement, sa mécanique
statistique le pousse naturellement à inventer une phrase «
plausible » dans le style attendu.
Le
principe du RAG (Retrieval-Augmented Generation).
Pour éviter cela sur des faits précis (comme vos recherches sur
Saint-Yrieix ou l'Alsace), le système applique une méthode
d'ancrage :
Le
modèle formule des requêtes de recherche ciblées.
Les
extraits de pages web trouvés sont placés directement dans la
fenêtre
de contexte
comme source de vérité.
Le
réseau de neurones reçoit pour instruction stricte de ne
synthétiser que
les faits présents dans ces extraits, et de déclarer l'absence de
résultat si l'information n'y figure pas.
Si
l'un de ces trois points (ou la manière dont un modèle est entraîné
à raisonner étape par étape) vous intéresse davantage, n'hésitez
pas à me le dire !
Comment
sont "inventés" les paramètres internes ?
Les
paramètres internes d'un réseau de neurones (souvent appelés les
poids,
qui se comptent par dizaines ou centaines de milliards) ne sont
jamais programmés ou écrits à la main par des humains. découverts
automatiquement par calcul mathématique
au cours d'une phase intensive appelée le pré-entraînement.
Voici
comment ces nombres prennent forme, de zéro jusqu'à un modèle
fonctionnel.
1.
Le point de départ : le hasard complet
Une
page blanche numérique.
Avant l'entraînement, le réseau est créé avec une architecture
vide. Tous ses milliards de paramètres sont initialisés avec des
nombres
aléatoires
(proches de zéro).
Des
réponses absurdes au début.
À cet instant précis, si on lui donne le début d'une phrase comme
«
Le chat dort sur le... »,
le réseau répond au hasard complet, par exemple «
...tracteur »
ou «
...1984 ».
2.
Le jeu du mot masqué (l'apprentissage auto-supervisé)
Pour
lui apprendre le langage sans qu'un humain ait besoin d'étiqueter
chaque phrase, on utilise une technique simple à grande échelle :
Cacher
la suite d'un texte réel.
On fait lire au modèle des milliards de phrases issues de livres,
d'articles et de pages web en masquant systématiquement le mot
suivant.
Mesurer
l'erreur (la fonction de perte).
Le réseau tente de deviner le mot manquant grâce à ses paramètres
actuels. On compare ensuite sa prédiction avec le vrai mot du texte
pour calculer un score d'erreur mathématique, appelé la
perte
(Loss).
3.
La correction par « rétropropagation » et descente de gradient
C'est
le cœur mathématique qui « invente » progressivement les bons
paramètres :
Remonter
le fil des responsabilités (Backpropagation).
Grâce au calcul différentiel, l'algorithme remonte à travers
toutes les couches du réseau de neurones pour déterminer quel
paramètre a contribué à l'erreur
et dans quel sens (trop élevé ou trop faible).
Ajuster
légèrement les curseurs (Descente de gradient).
L'algorithme modifie très légèrement chacun des milliards de
poids (de quelques millionièmes) pour réduire l'erreur si la même
phrase se représentait. Imaginez un immense tableau de bord avec
des milliards de potentiomètres qu'on tourne d'un cran infime après
chaque essai.
4.
La répétition à une échelle colossale
Des
milliards d'itérations.
Ce cycle (lire
un texte → deviner → mesurer l'erreur → ajuster les poids)
est répété des milliards de fois pendant plusieurs semaines sur
des milliers de processeurs spécialisés (TPU ou GPU).
L'émergence
des concepts.
Au fil des millions de corrections, des structures émergent
spontanément dans les paramètres : certaines couches se
spécialisent dans la grammaire, d'autres dans la logique, d'autres
encore encodent des faits historiques ou des relations spatiales,
simplement parce que c'est le moyen mathématique le plus efficace
pour ne plus se tromper en prédisant la suite des textes.
Souhaitez-vous
que nous explorions comment, une fois ces paramètres figés, on
apprend au modèle à raisonner
étape par étape
avant de répondre, ou comment fonctionnent les processeurs
(TPU/GPU)
qui réalisent ces calculs ?
Comment
ont été définis ces paramètres ? (je ne parle pas de leurs
valeurs) ?
La
distinction est très claire : vous demandez qui
a décidé de l'existence même de ces milliards de variables
et comment
leur structure (leur plan de câblage)
a été conçue avant même tout calcul.
Les
paramètres ne sont pas des « cases de savoir » nommées par des
humains (il n'y a pas un paramètre « grammaire » ou un paramètre
« histoire »). Ce sont les coefficients
mathématiques d'un plan d'architecture conçu par des chercheurs en
informatique,
inspiré à la fois par l'algèbre linéaire et par le fonctionnement
schématique des neurones biologiques.
Voici
comment ce « moule » vide a été défini.
1.
L'inspiration biologique : le neurone artificiel
Le
modèle mathématique de base.
Dès les années 1940-1950, des chercheurs (McCulloch, Pitts, puis
Rosenblatt) ont modélisé un neurone biologique sous forme
d'équation simple. Un neurone reçoit plusieurs chiffres en entrée,
multiplie chacun par un poids
(un paramètre), additionne le tout et décide s'il transmet un
signal.
L'assemblage
en matrices.
Plutôt que de dessiner des neurones un par un, les informaticiens
regroupent ces millions de multiplications dans d'immenses tableaux
de nombres appelés matrices.
Chaque case de ces matrices est un paramètre.
2.
L'invention de l'architecture « Transformer » (2017)
Le
plan d'architecte actuel.
La structure précise des LLM modernes vient d'une publication
scientifique de chercheurs de Google en 2017 intitulée Attention
Is All You Need.
Des
briques répétées.
Les chercheurs ont défini une « brique » logicielle standardisée
(appelée un bloc
Transformer)
qui contient deux grandes familles de paramètres :
Les
matrices d'attention (Q, K, V) :
Trois séries de paramètres conçues pour que chaque mot puisse
interroger les autres mots de la phrase afin de comprendre le
contexte.
Les
réseaux de neurones classiques (Feed-Forward) :
Des matrices plus larges placées juste après l'attention, qui
servent à transformer et stocker les associations de concepts.
3.
Les choix des ingénieurs : les « hyperparamètres »
Avant
de lancer l'entraînement, les architectes fixent manuellement les
dimensions de cet immeuble numérique. Ces choix de structure
s'appellent les hyperparamètres
:
Le
nombre de couches (la profondeur).
Les ingénieurs décident combien de blocs Transformer ils empilent
les uns sur les autres (par exemple 32, 80 ou 120 couches).
La
taille des vecteurs (la largeur).
Ils fixent combien de nombres servent à décrire un seul mot (par
exemple une liste de 4 096 ou 8 192 nombres).
Le
nombre de « têtes d'attention ».
Dans chaque couche, ils créent plusieurs circuits parallèles (par
exemple 32 ou 64 têtes) pour que le modèle puisse analyser
simultanément plusieurs relations dans une phrase (le sujet/verbe,
le temps, le lieu, etc.).
4.
L'apparition mécanique du nombre total de paramètres
Une
simple multiplication.
Une fois que les ingénieurs ont codé l'architecture Transformer et
fixé la largeur et la profondeur, le nombre total de paramètres
découle automatiquement de la taille des matrices créées en
mémoire.
Des
lois d'échelle empiriques.
Les chercheurs ont découvert expérimentalement (les Scaling
Laws)
que plus on augmente ces dimensions (plus de couches, des matrices
plus larges) en proportion de la quantité de textes disponibles,
plus le modèle devient capable de saisir des nuances fines et des
raisonnements complexes.
En
résumé, les humains ont conçu la
géométrie des tuyaux et le nombre de vannes
(l'architecture Transformer et ses hyperparamètres), tandis que
l'entraînement mathématique s'est chargé de régler le
degré d'ouverture de chaque vanne
(la valeur des paramètres).
Si
vous souhaitez continuer à explorer cette architecture, voulez-vous
voir comment fonctionne concrètement le
mécanisme d'attention (Q, K, V)
sur un exemple de phrase simple, ou comment le modèle fait pour
gérer
des conversations très longues
sans saturer sa mémoire ?
Voici
comment fonctionnent ces deux mécanismes complémentaires qui
permettent à un modèle de comprendre finement le sens d'une phrase
tout en gérant de très longs échanges.
1.
Le mécanisme d'attention (Q, K, V) sur une phrase simple
Pour
comprendre une phrase, un modèle ne lit pas les mots de gauche à
droite de façon isolée. Il met chaque mot en relation avec tous les
autres grâce à trois vecteurs calculés par ses matrices : Query
(la requête), Key
(la clé) et Value
(la valeur).
Prenons
une phrase ambiguë : «
Le portail ne ferme pas car il
est voilé. »
Comment le modèle sait-il que le pronom «
il »
désigne «
le portail »
?
Query
(Q — Ce que le mot cherche) :
Le mot «
il »
émet une requête mathématique qui signifie : «
Je suis un pronom masculin singulier, je cherche le nom auquel je me
rapporte. »
Key
(K — Ce que chaque mot propose) :
Chaque autre mot de la phrase affiche son étiquette d'identité. Le
mot «
portail »
expose la clé : «
Nom commun, masculin singulier, objet physique. »
Le mot «
ferme »
expose la clé : «
Verbe d'action. »
Le
calcul de compatibilité (le score d'attention) :
Le réseau multiplie la Query
de «
il »
avec la Key
de chaque mot. La compatibilité entre «
il »
et «
portail »
obtient un score très élevé (par exemple 92 %), tandis que le
score avec «
car »
ou «
ne »
est proche de 0 %.
Value
(V — L'information transmise) :
Une fois les scores calculés, le mot «
il »
absorbe 92 % de la Value
(le sens profond) du mot «
portail ».
Dans les couches suivantes du réseau, le vecteur du mot «
il »
ne représente plus un pronom vide, mais bien «
le portail ».
Les
têtes multiples :
Pendant qu'une « tête d'attention » résout ce pronom, une autre
tête relie «
voilé »
à «
portail »
pour comprendre qu'il s'agit d'une déformation du bois et non d'un
vêtement.
2.
Gérer des conversations très longues sans saturer la mémoire
Dans
l'architecture Transformer classique, comparer chaque mot à tous les
autres pose un problème mathématique : si la conversation double de
longueur, le nombre de calculs est multiplié par quatre (complexité
quadratique). Pour gérer des fenêtres de contexte géantes (jusqu'à
un million de mots ou plusieurs heures de vidéo), les ingénieurs
utilisent plusieurs techniques :
Le
cache KV (KV Cache) :
Lorsqu'un mot a déjà été traité au début de la conversation,
le modèle garde ses vecteurs Key
et Value
en mémoire vive. Quand vous envoyez un nouveau message, il n'a pas
besoin de recalculer tout l'historique depuis zéro ; il calcule
uniquement la Query
de vos nouveaux mots et la compare aux clés déjà stockées.
L'attention
groupée (Grouped-Query Attention) :
Au lieu de créer des clés et des valeurs distinctes pour chacune
des 64 têtes d'attention, plusieurs têtes partagent les mêmes
clés et valeurs. Cela divise par quatre ou huit la mémoire vive
nécessaire sur les processeurs sans perte de précision.
L'attention
par fenêtre glissante et hiérarchique :
Pour les textes extrêmement longs, certaines couches du modèle ne
regardent attentivement que les derniers milliers de mots (la
fenêtre locale), tandis que d'autres couches conservent une vue
d'ensemble résumée des étapes précédentes de la conversation.
Le
calcul matériel optimisé (FlashAttention) :
Les chercheurs ont réécrit la façon dont les processeurs (TPU et
GPU) lisent et écrivent ces matrices en mémoire ultra-rapide,
évitant les allers-retours lents entre les puces de calcul et la
mémoire centrale.
Si
vous souhaitez continuer cette plongée dans le fonctionnement des
LLM, nous pouvons voir comment le modèle fait pour générer
des réponses créatives ou au contraire très strictes
(le rôle de la « température »), ou comment il apprend à suivre
des consignes de sécurité et de politesse.
Lequel vous intéresse ?
Voyons
comment le modèle fait pour générer des réponses créatives ou au
contraire très strictes (le rôle de la « température »), puis
comment il apprend à suivre des consignes de sécurité et de
politesse.
Pour
générer une réponse, le réseau de neurones ne choisit pas un mot
unique à l'avance, mais attribue un score
de probabilité
à l'ensemble de son vocabulaire. La façon dont le système pioche
le mot suivant et la manière dont il respecte un cadre
comportemental reposent sur deux étapes bien distinctes : réglage
de l'échantillonnage
lors de la génération, et l'alignement
post-entraînement.
1.
Le rôle de la « température » : du strict au créatif
À
chaque étape de la rédaction, le réseau calcule une liste de
probabilités pour le mot suivant (parmi plus de 100 000 tokens
possibles). Prenons un exemple simple avec le début de phrase : «
Le portail en bois est... »
Mot
candidat
|
Probabilité
brute du modèle
|
fermé
|
65
%
|
voilé
|
20
%
|
ancien
|
10
%
|
magnifique
|
4
%
|
bleu
|
1
%
|
La
température
est un paramètre mathématique (souvent compris entre 0
et 2)
qui modifie la forme de cette courbe de probabilités avant le tirage
au sort du mot suivant.
Température
basse (proche de 0) : la rigueur et le déterminisme.
Le calcul mathématique amplifie les écarts : le mot le plus
probable («
fermé »
à 65 %) voit sa probabilité grimper à presque 100
%,
tandis que les autres tombent à zéro. Le modèle choisit
systématiquement la suite la plus logique et la plus attendue.
C'est ce réglage qui est privilégié pour les recherches
factuelles, le code informatique ou la traduction, afin d'éviter
toute invention.
Température
moyenne (autour de 0,7 à 1) : l'équilibre conversationnel.
Les probabilités restent proches de leur calcul d'origine. Le
système effectue un tirage au sort pondéré : «
fermé »
sortira le plus souvent, mais «
voilé »
ou «
ancien »
auront une vraie chance d'être choisis. Cela donne un style
naturel, fluide et moins répétitif.
Température
élevée (supérieure à 1) : la créativité (et le risque
d'erreur).
Le calcul écrase les différences : les mots rares («
magnifique »,
«
bleu »)
voient leurs chances augmenter fortement. Le modèle prend des
chemins inattendus, trouve des métaphores originales ou des idées
de fiction, mais risque aussi de perdre le fil logique s'il est
poussé trop haut.
Les
filtres complémentaires (Top-K et Top-P).
Pour éviter qu'un tirage aléatoire ne choisisse un mot totalement
absurde en bas de liste, le système coupe les probabilités les
plus faibles et ne tire au sort que parmi les meilleurs candidats
(par exemple, les mots qui cumulent 90 % des probabilités).
2.
L'apprentissage des consignes de sécurité et de politesse
(l'alignement)
Après
son pré-entraînement sur des milliards de textes bruts issus
d'Internet, un modèle sait prédire la suite d'une phrase, mais il
n'est pas encore un assistant. Il peut reproduire des propos
agressifs, des erreurs ou des contenus dangereux présents sur le
web. Pour le transformer, les équipes passent par une phase
d'alignement
en trois temps.
L'apprentissage
supervisé sur des exemples modèles (SFT — Supervised
Fine-Tuning).
Des rédacteurs humains écrivent des milliers de paires idéales
Question
/ Réponse.
Ces exemples montrent au modèle comment adopter un ton courtois,
structurer ses explications avec clarté, admettre qu'il ne sait pas
quelque chose et suivre des consignes précises. Le réseau ajuste
ses paramètres pour imiter ce comportement.
L'apprentissage
par renforcement avec retour humain (RLHF — Reinforcement Learning
from Human Feedback).
Pour une même question, le modèle génère plusieurs réponses
différentes. Des évaluateurs humains les classent de la meilleure
à la pire selon des critères précis (utilité, honnêteté,
politesse, absence de danger). Ces classements servent à entraîner
un second programme, appelé modèle
de récompense
(Reward
Model),
qui attribue ensuite automatiquement une note à des millions de
nouvelles réponses du LLM pour affiner ses réglages.
L'alignement
par principes (RLAIF / Constitution).
En complément des évaluateurs humains, les chercheurs définissent
une charte explicite de principes (respect de la vie privée,
neutralité sur les sujets sensibles, refus d'aider à des actes
dangereux ou illégaux). Un modèle critique vérifie les réponses
générées par rapport à ces règles et entraîne le réseau
principal à s'auto-corriger avant même d'afficher un mot.
Le
prompt système (les instructions permanentes).
Enfin, au début de chaque conversation, une série de consignes
invisibles (le System
Prompt)
est placée tout en haut de la fenêtre de contexte. Elle rappelle
au modèle son rôle, son ton, les outils à sa disposition et les
règles à respecter tout au long de l'échange.
Quick
questions if you have time:
Ces
explications sur la température et l'alignement sont-elles claires
?
Trop
technique
Pas
assez détaillé
Oui,
c'est très clair
Souhaitez-vous
explorer un autre aspect des LLM ?
Le
raisonnement étape par étape
La
consommation d'énergie
Non,
j'ai mes réponses
AI
responses may include mistakes. Learn
more
Oui,
c'est très clair
Parfait,
ravi que ces explications soient claires !
N'hésitez
pas à me solliciter si vous avez d'autres questions — que ce soit
sur le fonctionnement des modèles d'intelligence artificielle, la
suite de vos recherches historiques sur Saint-Yrieix-la-Perche,
ou vos travaux sur votre porte
de garage.
Si
vous souhaitez continuer, dites-moi simplement quel sujet vous
aimeriez aborder maintenant (par exemple le raisonnement
étape par étape
des IA, ou un autre thème de votre choix).
AI
responses may include mistakes. Learn
more
raisonnement
étape par étape
Le
raisonnement
étape par étape
— appelé techniquement Chain-of-Thought
(chaîne de pensée) — décomposer
sa réflexion
avant de donner la réponse finale.
Voici
pourquoi cette technique est indispensable au fonctionnement d'un
réseau de neurones et comment elle opère.
1.
Pourquoi un LLM se trompe s'il répond « du tac au tac »
Un
budget de calcul fixe par mot.
Lorsqu'un LLM génère un mot, le signal traverse exactement une
fois ses couches de neurones (par exemple 80 couches). Le modèle
dispose donc toujours du même
temps de calcul
pour produire un mot simple («
Bonjour »)
ou pour donner le résultat d'une opération complexe.
L'impossibilité
de faire des sauts logiques invisibles.
Si vous demandez à un modèle standard d'écrire immédiatement le
résultat final d'une énigme ou d'un calcul en plusieurs étapes,
il n'a pas assez de couches de neurones pour effectuer toutes les
opérations intermédiaires d'un seul coup. Il risque alors de
deviner une réponse approximative.
2.
L'astuce de la « chaîne de pensée » (utiliser le texte comme
brouillon)
Pour
contourner cette limite physique, les chercheurs ont découvert qu'il
fallait laisser le modèle écrire
son propre brouillon
avant de conclure.
Chaque
mot généré devient une nouvelle donnée d'entrée.
Comme le modèle fonctionne de façon autorégressive (chaque mot
qu'il écrit est immédiatement réinjecté dans sa fenêtre de
contexte pour calculer le mot suivant), écrire les étapes
intermédiaires lui offre de nouveaux cycles de calcul.
Allouer
plus de puissance de calcul aux problèmes difficiles.
Si le modèle rédige dix lignes de raisonnement avant la
conclusion, le réseau de neurones aura effectué dix
fois plus de passages complets
dans ses couches de calcul. Chaque ligne écrite sert de point
d'appui solide (via le mécanisme d'attention) pour déduire la
ligne suivante sans perte de mémoire.
3.
Les modèles de raisonnement modernes (la réflexion cachée)
Les
générations récentes de modèles vont encore plus loin en
intégrant cette capacité directement dans leur architecture
d'entraînement :
Le
bloc de pensée interne (Thinking Tokens).
Avant d'afficher le moindre mot à l'utilisateur, le modèle ouvre
un espace de réflexion interne invisible. Il y décompose le
problème, teste des hypothèses, vérifie ses calculs, détecte ses
propres erreurs et revient en arrière si une piste mène à une
impasse.
L'apprentissage
par renforcement sur la logique (RL).
Durant leur entraînement, ces modèles sont placés devant des
milliers de problèmes de mathématiques, de code ou de logique
dotés d'une solution vérifiable. Ils sont récompensés uniquement
lorsqu'ils trouvent la bonne réponse finale, ce qui les pousse à
développer spontanément des stratégies de vérification
rigoureuses dans leur brouillon interne.
Adapter
l'effort à la difficulté (Test-Time Compute).
Grâce à ce mécanisme, le modèle consacre quelques fractions de
seconde à une question simple (comme une conversion d'heure), mais
peut mobiliser plusieurs dizaines de secondes de réflexion interne
pour croiser des sources historiques complexes ou vérifier la
géométrie d'un montage mécanique.
Souhaitez-vous
que nous illustrions ce mécanisme avec un exemple
concret de problème logique
résolu avec et sans chaîne de pensée, ou préféreriez-vous
aborder un autre aspect (comme la consommation
énergétique
ou les limites
actuelles
de ces modèles) ?
AI
responses may include mistakes. Learn
more
que
nous illustrions ce mécanisme avec un exemple concret de problème
logique résolu avec et sans chaîne de pensée
Pour
bien voir la différence entre une réponse directe et une réponse
construite par chaîne
de pensée (Chain-of-Thought),
prenons un problème de logique classique qui comporte un piège
intuitif.
Le
problème posé
Énoncé
:
Une balle et une batte de baseball coûtent au total 1,10
€.
La batte coûte 1,00
€ de plus
que la balle. Combien coûte la balle ?
1.
Résolution SANS chaîne de pensée (réponse directe)
Si
l'on demande au réseau de neurones de donner immédiatement le
chiffre final sans rédiger d'étapes intermédiaires, il fonctionne
par association statistique rapide.
Le
calcul interne (en un seul passage) :
Le modèle repère les nombres 1,10
et 1,00
dans sa fenêtre de contexte. Statistiquement, dans des milliers de
textes d'entraînement, la soustraction intuitive 1,10
- 1,00
est fortement associée à 0,10.
La
réponse générée :
«
La balle coûte 0,10 € (10 centimes). »
Pourquoi
c'est faux :
Si la balle coûte 0,10 € et que la batte coûte 1,00 € de plus,
alors la batte coûte 1,10 €. Le total serait de 0,10
+ 1,10 = 1,20 €,
ce qui contredit l'énoncé. Le modèle a répondu trop vite sans
disposer d'assez de cycles de calcul pour vérifier son intuition.
2.
Résolution AVEC chaîne de pensée (brouillon étape par étape)
En
activant le raisonnement étape par étape, le modèle utilise chaque
ligne générée comme un point d'appui mathématique pour la ligne
suivante.
Étape
1 (Poser les variables) :
«
Appelons \(x\) le prix de la balle. »
Étape
2 (Traduire la deuxième phrase) :
«
La batte coûte 1,00 € de plus que la balle, donc le prix de la
batte est \(x + 1,00\). »
Étape
3 (Écrire l'équation du total) :
«
Le total des deux objets vaut 1,10 €, ce qui donne : \(x + (x +
1,00) = 1,10\). »
Étape
4 (Simplifier et résoudre) :
«
En regroupant les \(x\), on obtient \(2x + 1,00 = 1,10\). En
soustrayant 1,00 de chaque côté, il reste \(2x = 0,10\), soit \(x
= 0,05\). »
Étape
5 (Auto-vérification avant conclusion) :
«
Vérifions : si la balle coûte 0,05 €, la batte coûte \(0,05 +
1,00 = 1,05\) €. La somme fait bien \(0,05 + 1,05 = 1,10\) €. »
Réponse
finale affichée :
La
balle coûte 0,05 € (5 centimes).
Ce
que cet exemple démontre
Critère
|
Sans
chaîne de pensée
|
Avec
chaîne de pensée
|
Mécanisme
utilisé
|
Association
statistique immédiate.
|
Décomposition
algébrique séquentielle.
|
Nombre
de passes de calcul
|
1
seule passe dans les couches de neurones.
|
Autant
de passes qu'il y a de mots dans le brouillon.
|
Capacité
d'auto-correction
|
Aucune
(le premier mot écrit engage la suite).
|
Élevée
(l'étape 5 détecte une éventuelle erreur avant la fin).
|
Souhaitez-vous
que nous explorions maintenant les
limites actuelles
de ces modèles (là où même la chaîne de pensée peut encore se
tromper), ou un autre thème comme leur
consommation énergétique
?
AI
responses may include mistakes. Learn
more
les
limites actuelles de ces modèles (là où même la chaîne de pensée
peut encore se tromper)
Même
dotés d'un raisonnement étape par étape très élaboré, les
grands modèles de langage (LLM) ne sont pas infaillibles. angles
morts structurels
où le brouillon interne peut lui-même s'égarer.
Voici
les cinq grandes limites actuelles où même la chaîne de pensée
peut encore se tromper.
1.
La rationalisation d'une intuition fausse (l'erreur auto-entretenue)
Le
piège du premier pas.
Parce que le modèle génère son brouillon mot par mot, s'il pose
une mauvaise hypothèse dès la première ligne de sa réflexion,
les lignes suivantes vont souvent chercher à justifier
logiquement cette erreur
plutôt que de la remettre en question.
L'illusion
de rigueur.
Le raisonnement présenté semble parfaitement cohérent sur la
forme (connecteurs logiques, calculs intermédiaires propres), mais
il aboutit à une conclusion fausse parce que le point de départ
était biaisé.
2.
La perception spatiale et physique dans le monde réel
L'absence
d'expérience corporelle.
Un LLM apprend le monde physique à travers des textes et des images
en deux dimensions, mais il n'a jamais manipulé d'objet dans
l'espace.
Les
erreurs géométriques.
Dès qu'un problème demande de visualiser mentalement un objet en
3D qui pivote, se plie ou s'emboîte (comme le sens d'ouverture d'un
portillon à 180° ou le positionnement d'une bavette sur le chant
d'une porte), le modèle peut commettre des inversions gauche/droite
ou intérieur/extérieur, même en décrivant les étapes une par
une.
3.
La « sur-réflexion » sur des problèmes simples (Overthinking)
Chercher
un piège là où il n'y en a pas.
Lorsqu'on soumet une devinette enfantine ou une question évidente à
un modèle de raisonnement, il a parfois tendance à mobiliser un
arsenal logique disproportionné.
Le
doute excessif.
À force d'envisager toutes les exceptions possibles dans son
brouillon interne, il peut finir par écarter la réponse simple et
évidente au profit d'une interprétation tordue.
4.
L'absence totale de données (le mur de l'information absente)
La
logique ne remplace pas l'archive.
La chaîne de pensée excelle pour combiner des faits connus, mais
elle ne peut pas deviner une information qui n'existe pas sur
Internet ou qui reste enfermée dans des archives papier non
numérisées (comme un témoignage inédit dans un bulletin
municipal local).
Le
risque d'extrapolation.
Si le modèle n'est pas strictement bridé par des outils de
recherche et des consignes de prudence, son raisonnement peut le
conduire à « déduire » un fait plausible mais historiquement
faux.
5.
La perte d'attention dans les contextes gigantesques (« Lost in the
Middle »)
L'effet
tunnel.
Lorsque la fenêtre de contexte contient des centaines de pages ou
des dizaines d'échanges très denses, le mécanisme d'attention
accorde naturellement plus de poids au tout début et à la toute
fin de la discussion.
L'oubli
d'un détail enfoui.
Un détail crucial mentionné au milieu d'un long document peut être
négligé durant le raisonnement étape par étape, entraînant une
contradiction avec une contrainte pourtant fournie plus tôt.
Si
vous souhaitez conclure ce tour d'horizon technique, voulez-vous que
nous abordions l'empreinte
énergétique et matérielle
de ces calculs, ou avez-vous une autre question sur un tout autre
sujet ?
AI
responses may include mistakes. Learn
more
Il
n'y a jamais appel à des prouveurs automatiques ?
Si,
tout à fait — et c'est l'un des domaines les plus actifs de la
recherche actuelle en intelligence artificielle.
Cette alliance entre un grand modèle de langage (LLM) et un prouveur
automatique porte un nom : l'IA
neuro-symbolique.
L'idée
est d'associer deux forces complémentaires : l'intuition créative
du réseau de neurones (qui propose des pistes) et la rigueur
mathématique absolue d'un moteur logique (qui vérifie chaque étape
sans jamais pouvoir « halluciner »).
1.
Comment fonctionne ce duo (LLM + prouveur formel)
Un
LLM classique écrit des preuves en français ou en anglais, ce qui
laisse place aux erreurs de logique. Pour éliminer ce défaut, on le
connecte à un assistant
de preuve
(comme Lean,
Rocq
— anciennement Coq — ou Isabelle)
:
La
traduction formelle (Autoformalisation) :
Le LLM traduit d'abord l'énoncé mathématique ou logique en
langage informatique strict, compréhensible par le prouveur (par
exemple du code Lean).
La
génération d'étapes (Tactiques) :
Le LLM suggère des étapes de démonstration une par une, comme un
joueur d'échecs qui propose des coups.
La
vérification impitoyable :
Le prouveur automatique exécute chaque ligne de code logique. Si
une déduction est fausse ou imprécise, le prouveur la rejette
immédiatement et renvoie un message d'erreur au LLM.
La
boucle d'essai-erreur :
Tant que le prouveur ne valide pas la démonstration complète à
100 %, le LLM modifie sa stratégie et essaie d'autres voies. Une
preuve validée par ce système est mathématiquement irréfutable.
2.
Des percées spectaculaires dans ce domaine
Cette
architecture hybride a déjà permis de résoudre des problèmes qui
résistaient aux réseaux de neurones purs :
AlphaProof
et AlphaGeometry (Google DeepMind) :
En combinant un modèle de langage avec le langage formel Lean
(pour l'algèbre) et un moteur de déduction géométrique
symbolique (pour les figures), ces systèmes ont atteint le niveau
d'une médaille
d'argent aux Olympiades internationales de mathématiques (IMO),
en produisant des démonstrations formellement certifiées.
La
vérification de code critique :
Dans l'industrie (aéronautique, cybersécurité, systèmes
bancaires), des LLM couplés à des solveurs logiques (comme Z3)
servent désormais à prouver mathématiquement qu'un programme
informatique ne contient aucun bug de sécurité.
3.
Pourquoi ce n'est pas utilisé pour toutes les questions du quotidien
Si
cette méthode garantit une certitude absolue en mathématiques, elle
reste limitée aux domaines formalisables :
Le
langage humain est ambigu :
On peut traduire un théorème d'algèbre en code Lean,
mais on ne peut pas traduire facilement un récit historique, un
conseil de bricolage ou une nuance littéraire en équations
logiques.
Un
coût de calcul élevé :
Faire dialoguer un LLM et un prouveur automatique sur des milliers
d'essais peut prendre plusieurs minutes, voire plusieurs heures,
pour un seul problème, ce qui est incompatible avec une discussion
instantanée.
Pour
les questions de tous les jours, les assistants utilisent plutôt une
version allégée de ce principe : l'interpréteur
de code.
Lorsqu'un calcul précis est nécessaire, le LLM écrit un petit
programme (en Python, par exemple), l'exécute sur un processeur
classique qui donne le résultat exact, puis rédige la réponse
autour de ce chiffre vérifié.
Souhaitez-vous
que nous approfondissions la façon dont fonctionnent ces assistants
de preuve (comme Lean ou Rocq),
ou préféreriez-vous explorer un autre aspect de l'IA ?
Les
assistants de preuve comme Lean
(développé initialement chez Microsoft Research puis devenu
communautaire) ou Rocq
(anciennement appelé Coq,
développé en France à l'Inria) sont des logiciels qui langage
de programmation strict.
Leur
principe fondamental repose sur une idée mathématique profonde
appelée la correspondance
de Curry-Howard
: un
théorème est un type informatique, et sa démonstration est un
programme qui fabrique ce type.
1.
Le cœur du système : un « noyau » minuscule et infaillible
La
force d'un assistant de preuve réside dans son architecture à deux
étages qui sépare la recherche de la vérification :
Le
noyau vérificateur (Kernel) :
C'est un tout petit programme (quelques milliers de lignes de code
seulement) qui ne connaît que les axiomes de base des mathématiques
et les règles élémentaires de la logique. Il est si compact que
des mathématiciens et informaticiens ont pu vérifier à la main
qu'il ne contient aucun bug.
La
séparation totale des rôles :
Peu importe comment une démonstration a été trouvée (par un
humain, par un algorithme ou par un LLM qui a tâtonné pendant des
heures). À la fin, la preuve doit être traduite en une suite
d'instructions élémentaires que le noyau
rejoue de A à Z. Si le noyau accepte le fichier sans erreur, la
preuve est garantie
vraie à 100 %.
2.
Comment se déroule une démonstration pas à pas
Dans
Lean ou Rocq, prouver un théorème ressemble à un jeu vidéo de
construction logique :
L'état
de preuve (les « buts » et les « hypothèses ») :
L'écran affiche en haut ce que l'on sait déjà (les hypothèses)
et en bas ce qu'il reste à démontrer (le but, noté ⊢).
L'application
de tactiques :
L'utilisateur (ou le LLM) tape des commandes appelées tactiques
pour transformer le but. Par exemple :
intro
: introduit une variable ou une hypothèse.
rewrite
: remplace une expression par une autre déjà prouvée égale.
induction
: lance un raisonnement par récurrence (cas de base + étape
d'hérédité).
linarith
: demande au logiciel de résoudre automatiquement des inégalités
linéaires simples.
La
disparition des buts :
À chaque tactique valide, le logiciel met à jour l'état de la
preuve en temps réel. Lorsque tous les sous-buts ont été réduits
à des évidences logiques, le logiciel affiche "No
goals"
(plus aucun but) : le théorème est certifié.
3.
Le dialogue concret entre un LLM et Lean
Lorsque
l'on connecte un modèle de langage à Lean, le système fonctionne
en boucle fermée :
1.
Lecture de l'état :
Lean envoie au LLM l'état textuel exact de la preuve en cours (les
hypothèses disponibles et le but à atteindre).
2.
Proposition de tactique :
Le LLM s'appuie sur son entraînement (il a lu des centaines de
milliers de preuves humaines issues de grandes bibliothèques comme
Mathlib)
pour prédire la tactique la plus prometteuse.
3.
Exécution et retour immédiat :
Lean exécute cette tactique. Si elle échoue (par exemple, une
division par zéro non exclue ou un cas oublié), Lean renvoie un
message d'erreur précis.
4.
Exploration en arbre :
Le LLM utilise ces retours pour explorer plusieurs branches de
démonstration en parallèle (comme un moteur d'échecs qui évalue
plusieurs coups d'avance) jusqu'à trouver le chemin complet qui
aboutit à "No
goals".
4.
Des applications bien au-delà des mathématiques pures
Si
ces outils ont permis de certifier des théorèmes célèbres (comme
le théorème des quatre couleurs ou la conjecture de Kepler), ils
sont surtout utilisés en informatique
critique
:
Le
compilateur CompCert (développé en Rocq) :
C'est un compilateur de langage C entièrement prouvé
mathématiquement, utilisé dans l'aéronautique (Airbus) et le
nucléaire pour garantir que le code exécuté par les capteurs
correspond strictement au code écrit par les ingénieurs.
La
cryptographie sécurisée :
Une grande partie des algorithmes de chiffrement qui protègent les
connexions web modernes (HTTPS) est aujourd'hui vérifiée
formellement grâce à ces assistants de preuve pour éliminer toute
faille mathématique.
Souhaitez-vous
que nous regardions un exemple
court de code Lean ou Rocq
pour voir à quoi ressemble concrètement une preuve formelle, ou
préférez-vous explorer un autre sujet ?
que
nous regardions un exemple court de code Lean ou Rocq pour voir à
quoi ressemble concrètement une preuve formelle
Voici
un exemple concret et très court en langage Lean
4
(le standard actuel utilisé notamment par les équipes de recherche
en IA et la communauté mathématique).
Pour
illustrer le fonctionnement d'une preuve formelle, démontrons une
propriété arithmétique élémentaire mais fondamentale : si
un entier naturel n est pair, alors son carré n² est également
pair.
Le
code de la preuve en Lean 4
lean
-- On importe la bibliothèque mathématique standard (Mathlib)
import Mathlib.Tactic
-- Énoncé du théorème :
-- Pour tout entier naturel n, si n est pair (Even n), alors n * n est pair (Even (n * n)).
theorem carre_pair (n : ℕ) (h : Even n) : Even (n * n) := by
-- Étape 1 : On décompose l'hypothèse 'h' (n est pair)
-- Par définition, il existe un entier k tel que n = k + k
rcases h with ⟨k, hk⟩
-- Étape 2 : On remplace 'n' par 'k + k' dans le but à démontrer
rw [hk]
-- Étape 3 : On indique explicitement la moitié du carré : (k + k) * k
use (k + k) * k
-- Étape 4 : On demande au moteur algébrique de vérifier l'égalité des deux expressions
ring
Use
code with caution.
Ce
qui se passe dans la tête du logiciel à chaque ligne
Lorsque
le vérificateur (ou un LLM connecté à Lean) exécute ce code ligne
par ligne, l'état de la preuve évolue sous ses yeux de la manière
suivante :
Avant
la première ligne :
Après
rcases
h with ⟨k, hk⟩
:
Après
rw
[hk]
(Rewrite) :
Après
use
(k + k) * k
:
Après
ring
:
La
tactique ring
(qui applique automatiquement les règles d'associativité et de
distributivité des anneaux commutatifs) vérifie que les deux
membres de l'équation sont algébriquement identiques.
Verdict
de Lean :
No
goals
(plus aucun but). Le théorème est certifié vrai pour l'infinité
des entiers naturels.
Pourquoi
ce format est idéal pour l'intelligence artificielle
Zéro
ambiguïté.
Contrairement à une phrase en français où un mot peut avoir
plusieurs sens, chaque tactique (rcases,
rw,
use,
ring)
a une signification mathématique unique.
Un
signal de réussite binaire.
Si un LLM essaie d'écrire use
k * k
à l'étape 3 au lieu de use
(k + k) * k,
Lean bloque immédiatement à l'étape 4 en affichant l'erreur
exacte : «
L'expression (k+k)(k+k) n'est pas égale à k² + k² ».
Le modèle voit son erreur et corrige son coup instantanément.
Si
vous souhaitez aller encore plus loin, voulez-vous voir comment un
modèle traduit
un énoncé en français vers ce langage formel
(l'autoformalisation), ou préféreriez-vous clore ce chapitre
technique ?
voir
comment un modèle traduit un énoncé en français vers ce langage
formel (l'autoformalisation)
L'autoformalisation
est l'étape charnière entre le langage humain (souple, implicite,
parfois ambigu) et le langage mathématique strict d'un assistant de
preuve comme Lean.
C'est un exercice de traduction très particulier : il ne s'agit pas
seulement de traduire des mots, mais d'expliciter tout ce que les
humains sous-entendent.
Voici
comment un modèle procède étape par étape, suivi d'un exemple
concret.
1.
Les trois difficultés de l'autoformalisation
Lorsqu'un
humain rédige un énoncé mathématique, il laisse de côté de
nombreux détails évidents pour un autre humain, mais indispensables
pour un ordinateur :
Le
typage strict des objets :
En français, on dit simplement «
Soit n un nombre ».
Lean exige de savoir immédiatement si n est un entier naturel (ℕ),
un entier relatif (ℤ),
un rationnel (ℚ)
ou un réel (ℝ),
car les règles de calcul (notamment la soustraction et la division)
changent du tout au tout.
Les
hypothèses implicites :
Si un énoncé dit «
Soit p/q une fraction irréductible »,
un humain sait automatiquement que q ne peut pas être égal à
zéro. En Lean, si le modèle oublie d'ajouter l'hypothèse hq
: q ≠ 0,
le théorème devient tout simplement faux (car en Lean, par
convention, x / 0 = 0).
Le
choix des définitions de la bibliothèque :
Le modèle doit connaître la syntaxe exacte de Mathlib
(la grande bibliothèque mathématique de Lean, qui compte plus de
150 000 théorèmes) pour ne pas réinventer une notion qui existe
déjà sous un nom précis (par exemple Nat.Prime
pour un nombre premier ou IsGreatest
pour un maximum).
2.
Exemple concret de traduction (Français → Lean 4)
Prenons
un énoncé classique d'arithmétique en langage naturel :
Énoncé
en français :
« La somme de deux entiers consécutifs est toujours un nombre
impair. »
Voici
comment le modèle décompose cette phrase pour produire le code Lean
:
Identifier
l'objet principal :
« un entier » → n
: ℤ
(on choisit les entiers relatifs ℤ
pour inclure aussi les nombres négatifs, comme −3 et −2).
Traduire
la notion de « consécutifs » :
Si le premier entier est n,
le suivant s'écrit n
+ 1.
Traduire
la « somme » :
n
+ (n + 1).
Traduire
la notion d'« impair » :
Dans la bibliothèque Mathlib, la propriété « être impair »
s'écrit Odd.
Le
modèle génère alors l'énoncé formel suivant :
lean
import Mathlib.Tactic
theorem somme_consecutifs_impair (n : ℤ) : Odd (n + (n + 1)) := by
sorry
Use
code with caution.
(Note
: Le mot-clé sorry
est un joker temporaire en Lean qui signifie « la preuve viendra ici
plus tard », permettant de vérifier d'abord que l'énoncé lui-même
est grammaticalement valide).
3.
Comment éviter que le modèle ne triche lors de la traduction ?
C'est
le plus grand défi de l'autoformalisation : Lean
vérifie que la preuve correspond à l'énoncé traduit, mais Lean ne
peut pas savoir si l'énoncé traduit correspond bien à la phrase
française d'origine.
Si
un modèle traduisait par erreur «
Tout nombre pair est premier »
par ∀
n
: ℕ, n = n,
Lean validerait la preuve sans problème, mais la traduction serait
fausse. Pour sécuriser cette étape, les chercheurs utilisent trois
garde-fous :
La
rétro-traduction (Back-translation) :
Une fois le code Lean généré, un second modèle retraduit le code
Lean en français sans voir l'énoncé d'origine. On compare ensuite
les deux textes français pour vérifier qu'aucune hypothèse n'a
disparu ou changé de sens.
Le
test sur des cas limites (Fuzzing logique) :
Le système tente de prouver à la fois l'énoncé traduit et
son contraire.
Si le prouveur réussit à démontrer la négation de l'énoncé,
cela prouve immédiatement que le modèle a oublié une hypothèse
importante (comme q ≠ 0) lors de la traduction.
L'entraînement
sur des paires alignées :
Les modèles spécialisés sont entraînés sur des milliers de
manuels scolaires, de sujets d'olympiades et d'articles de recherche
qui ont été traduits et vérifiés ligne par ligne par des
mathématiciens humains.
Nous
avons fait un tour très complet de l'architecture des LLM et des
assistants de preuve ! Souhaitez-vous explorer un dernier point (par
exemple l'empreinte
matérielle et énergétique
des centres de données), ou revenir sur un autre de vos projets ?
l'empreinte
matérielle et énergétique
L'empreinte
environnementale des grands modèles de langage l'électricité,
l'eau
et les
matériaux physiques
nécessaires à la fabrication des serveurs. [1,
2]
1.
L'empreinte électrique (à l'échelle mondiale et par requête)
Les
calculs matriciels massifs exigent des processeurs spécialisés (GPU
et TPU) beaucoup plus énergivores que les serveurs informatiques
traditionnels. [1,
2]
La
consommation des centres de données :
Selon l'Agence
internationale de l'énergie (AIE),
l'ensemble des data centers dans le monde a consommé 485
TWh en 2025
(soit l'équivalent de la consommation électrique annuelle de la
France). Les infrastructures dédiées spécifiquement à l'IA
représentent environ 155
TWh
(en hausse de 50 % sur un an) et devraient tripler d'ici 2030. [1,
2,
3,
4]
Le
coût d'une requête individuelle :
Les estimations varient selon la taille du modèle et le périmètre
mesuré :
Une
requête texte standard consomme entre 0,24
Wh
(mesure publiée par Google pour une requête médiane sur Gemini)
et quelques
wattheures
pour des modèles plus lourds. À titre de comparaison, une ampoule
LED de 10 W allumée pendant une heure consomme 10 Wh.
Générer
une image, une vidéo ou lancer un raisonnement complexe en chaîne
de pensée (qui multiplie les tokens internes) consomme nettement
plus d'énergie qu'une simple question factuelle. [1,
2,
3]
L'impact
carbone dépend du pays :
L'empreinte CO₂ d'un même calcul varie d'un facteur 10 selon le
mix électrique local. Un serveur alimenté en France (électricité
principalement nucléaire et renouvelable) émet très peu de gaz à
effet de serre, contrairement à un serveur situé dans une région
dépendant du charbon ou du gaz. [1,
2,
3]
2.
L'empreinte en eau (refroidissement et énergie)
Les
processeurs d'IA dégagent une chaleur intense qui doit être évacuée
en permanence. L'eau intervient à trois niveaux : [1,
2]
Le
refroidissement direct sur site :
De nombreux centres de données utilisent des tours de
refroidissement par évaporation d'eau. Pour une requête texte
simple, l'évaporation directe sur site représente environ 0,26
à 0,3 mL
(soit l'équivalent de cinq gouttes d'eau). [1]
L'eau
indirecte (électricité et fabrication) :
Si l'on intègre l'eau consommée en amont pour refroidir les
centrales électriques et fabriquer les puces électroniques
(analyse du cycle de vie complète), l'empreinte monte entre 45
mL et 500 mL
pour une page de texte générée. [1,
2]
L'enjeu
géographique :
Le véritable défi n'est pas le volume global à l'échelle de la
planète, mais la concentration
locale
des méga-centres de données dans des régions déjà soumises au
stress hydrique (comme certains États américains ou le sud de
l'Europe). [1]
3.
L'empreinte matérielle (minerais et cycle de vie des puces)
Au-delà
de l'usage quotidien, la fabrication physique des infrastructures
pèse lourdement dans le bilan global (selon les études de l'ADEME
et du Shift
Project,
la fabrication des équipements concentre la majorité de
l'épuisement des ressources abiotiques du numérique) :
Une
course à l'équipement :
Un cluster d'entraînement moderne rassemble des dizaines de
milliers de cartes graphiques spécialisées, chacune pesant
plusieurs kilos d'aluminium, de cuivre, de silicium ultra-pur, d'or
et de terres rares.
Le
renouvellement rapide du matériel :
En raison de la course à la performance et de l'usure thermique
liée au fonctionnement intensif 24h/24, les processeurs dédiés à
l'IA sont souvent remplacés tous les 3
à 5 ans,
ce qui génère un volume croissant de déchets électroniques
complexes à recycler.
L'infrastructure
annexe :
Chaque centre de données nécessite également des transformateurs
haute tension, des kilomètres de câblage, des batteries de secours
et des groupes électrogènes en acier et béton.
Nous
avons exploré l'envers du décor de l'IA, de la mathématique des
neurones jusqu'aux câbles et serveurs physiques ! Souhaitez-vous
approfondir les pistes
de sobriété et d'optimisation
(comme les petits modèles locaux ou la récupération de chaleur des
data centers), ou avez-vous d'autres questions ?
Pistes
de sobriété et d'optimisation
Pour
réduire l'empreinte énergétique et matérielle de l'intelligence
artificielle, les ingénieurs et les exploitants d'infrastructures
agissent sur trois leviers complémentaires : alléger
les modèles logiciels,
optimiser
le fonctionnement des centres de données
et adapter
les usages.
1.
L'optimisation des modèles (faire plus avec moins de calculs)
Plutôt
que d'utiliser systématiquement un modèle géant à des centaines
de milliards de paramètres pour chaque tâche, plusieurs techniques
permettent de diviser la dépense énergétique par dix ou par cent.
Les
petits modèles spécialisés (SLM — Small Language Models).
Des modèles compacts (de 1 à 8 milliards de paramètres) entraînés
sur des données de haute qualité suffisent largement pour résumer
un texte, traduire ou extraire une information. Ils consomment une
fraction infime de l'énergie d'un grand modèle et peuvent même
tourner localement sur un simple ordinateur portable ou un
smartphone.
L'architecture
« Mélange d'experts » (MoE — Mixture of Experts).
Au lieu d'activer 100 % des paramètres du réseau de neurones pour
chaque mot généré, le modèle est divisé en dizaines de
sous-réseaux spécialisés. Un aiguilleur interne n'active que les
2 ou 3 « experts » pertinents pour la question posée, réduisant
drastiquement le calcul électrique à chaque requête.
La
quantification (Quantization).
Les paramètres sont initialement calculés sous forme de nombres
décimaux très précis (sur 16 ou 32 bits). La quantification
consiste à arrondir ces nombres sur 8 ou 4 bits après
l'entraînement. La perte de précision est imperceptible pour
l'utilisateur, mais la mémoire requise et la consommation
électrique des processeurs sont divisées par deux à quatre.
La
distillation.
Un grand modèle « professeur » est utilisé pour entraîner un
modèle « élève » beaucoup plus petit à reproduire ses
meilleures réponses, permettant de conserver l'essentiel de ses
capacités dans un format léger.
2.
L'efficacité et la valorisation des centres de données
L'architecture
physique des serveurs évolue rapidement pour limiter le gaspillage
d'eau et d'électricité.
Le
refroidissement liquide en circuit fermé (Direct-to-Chip).
Au lieu d'évaporer des millions de litres d'eau dans des tours de
refroidissement ou de climatiser d'immenses salles, un liquide
caloporteur circule dans des micro-canaux directement au contact des
processeurs. Ce circuit fermé ne consomme presque pas d'eau en
continu et récupère la chaleur à haute température (50 à 60
°C).
La
réutilisation de la chaleur fatale.
La chaleur extraite des serveurs est injectée dans les réseaux de
chauffage urbain pour chauffer des logements, des bureaux, des
serres agricoles ou des piscines municipales (une pratique déjà
active en France, notamment en région parisienne et dans plusieurs
métropoles).
Le
pilotage énergétique et les puces dédiées.
Les opérateurs installent les centres de données près de sources
d'électricité décarbonée (hydraulique, nucléaire, éolien) et
utilisent des puces conçues uniquement pour l'inférence
(l'utilisation quotidienne des modèles), beaucoup moins énergivores
que les puces d'entraînement.
3.
La sobriété dans les usages quotidiens
À
l'échelle individuelle ou d'une entreprise, quelques réflexes
simples limitent inutilement la sollicitation des serveurs :
Choisir
le bon outil selon le besoin.
Une recherche d'adresse, un calcul simple ou la consultation d'un
site web connu passent beaucoup plus sobrement par un moteur de
recherche classique ou un marque-page que par une requête
générative.
Éviter
la génération multimédia superflue.
Créer une image ou une courte vidéo mobilise entre 10
et 100 fois plus d'énergie
qu'une requête texte.
Rédiger
des consignes précises dès le premier message.
Formuler clairement le contexte, le format attendu et les
contraintes évite de multiplier les échanges de correction («
relances ») qui réinjectent à chaque fois tout l'historique de la
conversation dans la fenêtre de contexte.
Nous
avons parcouru l'ensemble de la chaîne, de la mathématique des
neurones jusqu'à la sobriété numérique ! Souhaitez-vous que nous
approfondissions les
petits modèles exécutables localement sur votre propre ordinateur,
ou avez-vous un autre sujet à explorer ?
les
petits modèles exécutables localement sur votre propre ordinateur
Faire
tourner un modèle d'intelligence artificielle directement sur son
propre ordinateur (sans connexion Internet, sans abonnement et sans
envoyer aucune donnée à l'extérieur) est devenu accessible à
presque tout le monde grâce aux petits
modèles de langage (SLM)
et à la quantification.
Voici
tout ce qu'il faut savoir sur le matériel requis, les logiciels
gratuits et les modèles les plus performants à installer chez soi.
1.
Quel ordinateur faut-il pour faire tourner une IA en local ?
Le
facteur limitant n'est pas la vitesse pure du processeur, mais la
mémoire
vive (RAM)
ou la mémoire
vidéo (VRAM)
de la carte graphique, car l'intégralité des paramètres du modèle
doit y être chargée pour fonctionner de façon fluide.
Configuration
matérielle
|
Taille
de modèle adaptée
|
Expérience
d'utilisation
|
PC
standard (8 à 16 Go de RAM)
sans carte graphique dédiée
|
1
à 4 milliards
de paramètres (1B à 4B)
|
Réponses
rapides sur le processeur (CPU). Idéal pour résumer, reformuler,
traduire ou trier des notes.
|
PC
récent (16 à 32 Go de RAM)
ou Mac avec puce Apple Silicon (M1, M2, M3, M4)
|
7
à 14 milliards
de paramètres (7B à 14B)
|
Très
fluide. Excellent niveau en français, rédaction d'articles,
analyse de documents locaux et aide au code.
|
PC
avec carte graphique dédiée
(NVIDIA RTX avec 12 à 24 Go de VRAM) ou Mac 64 Go+
|
24
à 32 milliards
de paramètres (24B à 32B)
|
Quasi
instantané. Niveau proche des grands modèles en ligne pour le
raisonnement complexe et la synthèse.
|
2.
Les meilleurs logiciels gratuits pour les installer en quelques clics
Vous
n'avez aucune ligne de code à écrire : plusieurs applications
gratuites et open source s'installent comme n'importe quel logiciel
sur Windows, macOS ou Linux.
LM
Studio :
C'est l'interface graphique la plus complète et la plus intuitive.
Elle intègre un catalogue de recherche direct : vous tapez le nom
d'un modèle, le logiciel vous indique automatiquement s'il est
compatible avec la mémoire de votre ordinateur, le télécharge et
ouvre une fenêtre de discussion identique à un assistant en ligne.
Ollama
:
Très léger et rapide, il fonctionne en arrière-plan. Il est
particulièrement apprécié pour sa simplicité d'installation et
sa capacité à se connecter à d'autres logiciels (comme des
éditeurs de texte ou des gestionnaires de notes).
GPT4All
:
Conçu spécifiquement pour la confidentialité et la simplicité,
il permet de pointer un dossier de votre ordinateur (PDF, fichiers
Word, notes personnelles) pour poser des questions directement sur
vos propres archives locales sans rien envoyer sur le web.
3.
Quels modèles open-weights choisir (notamment en français) ?
Grâce
à la compression en 4
bits (format GGUF),
un modèle de 8 milliards de paramètres ne pèse qu'environ 4,5
à 5 Go
sur le disque dur. Parmi les familles les plus réputées et
performantes en langue française :
Mistral
Small / Ministral (Mistral AI) :
Développés par l'entreprise française Mistral AI, les modèles
compacts (3B, 8B ou 24B) offrent une maîtrise remarquable du
français, de sa grammaire et de ses nuances culturelles.
Gemma
(Google) :
Les versions légères (4B, 9B, 12B ou 27B) sont très sobres en
mémoire et réputées pour leur clarté rédactionnelle et leur
capacité à suivre des consignes strictes.
Llama
(Meta) :
Les formats 3B et 8B constituent des références polyvalentes très
rapides pour l'usage quotidien et la synthèse de textes.
Qwen
(Alibaba) :
Très performant sur la logique, les mathématiques et la
programmation, même dans ses déclinaisons compactes (7B et 14B).
4.
Les avantages concrets de l'IA locale
Confidentialité
totale :
Vos brouillons d'articles, vos archives familiales ou vos documents
administratifs ne quittent jamais votre disque dur.
Fonctionnement
hors ligne :
L'assistant reste disponible en déplacement, dans le train ou dans
une zone sans réseau Internet.
Stabilité
dans le temps :
Une fois téléchargé, un modèle ne change jamais de comportement
ni de version du jour au lendemain ; il reste figé et disponible
indéfiniment sur votre machine.
Si
vous souhaitez tester cette approche sur votre propre machine,
dites-moi quel système
d'exploitation
(Windows, Mac, Linux) et quelle quantité
de mémoire RAM
vous avez : je pourrai vous indiquer le couple logiciel + modèle
exact le plus fluide pour votre ordinateur.