Home
À propos
À propos
Projets
Blog
🇺🇸🇧🇷🇫🇷
🇺🇸🇧🇷🇫🇷
Blog

Intelligence Artificielle : Des Premiers Principes aux Agents

February 20, 2026

Nous suivons un chemin

Une carte mentale guidée L'Intelligence Artificielle est un territoire vaste et bruyant. Si vous ouvrez les réseaux sociaux, vous entendrez parler d'agents, d'AGI, d'ingénierie de prompts, de multimodalité, d'alignement, de fine-tuning, d'embeddings, de lois d'échelle, de modèles de raisonnement et d'une douzaine d'autres termes souvent utilisés de manière interchangeable, fréquemment sans contexte. Le résultat est un enchevêtrement conceptuel. Dans ce post, je n'essaierai pas de cartographier tout le territoire de l'IA. Au lieu de cela, nous suivrons une direction prédéterminée, pointant les chemins qui se ramifient au fil du parcours, mais gardant toujours le focus sur notre trajectoire : des concepts de base de l'apprentissage à partir des données jusqu'aux agents d'IA modernes. L’objectif est d’offrir un modèle mental clair :
  • Quels types de problèmes les systèmes d’IA résolvent
  • Comment le Machine Learning (ML) moderne s’organise
  • Où s’inscrit le Deep Learning
  • Pourquoi les transformers sont essentiels
  • Ce que sont réellement les LLM
  • Et comment les systèmes du monde réel se construisent autour d’eux
Nous suivrons cela étape par étape, utilisant quelques jalons de recherche comme guides. Il ne s'agit pas d'une revue bibliographique, mais d'une carte tracée pour montrer comment les idées ont évolué au fil du temps.

1. Le tournant statistique : Apprendre au lieu de programmer

Une grande partie de l'IA initiale s'est concentrée sur les systèmes basés sur des règles. Les chercheurs croyaient que l'intelligence pouvait être construite explicitement, c’est-à-dire :
  • Représenter le monde sous forme symbolique (objets, faits, relations)
  • Formaliser des règles de type « SI X ALORS Y »
  • Appliquer des mécanismes d’inférence logique pour dériver de nouvelles connaissances
Cette approche, souvent appelée IA symbolique, a été profondément influencée par la logique formelle et la philosophie. L'intelligence était vue comme un raisonnement structuré sur des symboles. Il est important de noter que ce n'était pas simplement une collection d'instructions if. L'IA symbolique dépendait typiquement de formes plus riches de logique (ex: logique du premier ordre) où les systèmes représentaient :
  • Des objets (ex: Jean)
  • Des propriétés (ex: a_fievre(Jean))
  • Des règles générales (ex: "pour tous les patients, fièvre ET toux impliquent une possible grippe")
Un moteur d'inférence séparé appliquerait ces règles pour tirer de nouvelles conclusions. La connaissance et le raisonnement étaient explicitement codés et mécaniquement appliqués. Dans des applications restreintes, cela a remarquablement bien fonctionné. Des systèmes ont été construits pour :
  • Jouer aux échecs
  • Prouver des théorèmes
  • Planifier dans des domaines bien définis
  • Réaliser des diagnostics médicaux expertisés
Mais les limitations sont apparues lorsque l'IA a commencé à être utilisée dans d'autres domaines moins restreints. La perception, le langage et le raisonnement "humain" se sont révélés être des problèmes complexes, avec des défis d'ambiguïté et de haute dimensionnalité. Écrire des règles explicites pour reconnaître l'image d'un chat dans différentes conditions ou gérer la variabilité du langage naturel est rapidement devenu intraitable. Le problème n'était pas la logique elle-même. Le problème était l'échelle. Coder l'intelligence manuellement ne passe pas bien à l'échelle pour des données bruitées et non structurées. Le grand changement, souvent appelé le tournant statistique, était conceptuellement simple :
Au lieu d'écrire les règles, laissons le système les apprendre à partir des données.
Cette idée est le fondement du ML moderne. À son cœur, le ML définit un modèle paramétré et ajuste ses paramètres pour optimiser la performance à partir des données. Dans le cas supervisé le plus simple, cela équivaut à ajuster une fonction : fθ(x)≈yf_\theta(x) \approx y Vous ne codez pas explicitement la correspondance entre l'entrée et la sortie. Vous définissez une fonction flexible avec des paramètres θ\theta, et ajustez ces paramètres pendant la phase d'entraînement pour que la fonction fonctionne bien sur les exemples. Cette façon de penser — modèles comme fonctions paramétrées optimisées à partir de données — n'est pas apparue du jour au lendemain. Elle a émergé graduellement de la théorie de décision statistique, de la théorie de l'apprentissage et de la recherche en réseaux de neurones à la fin du XXe siècle. Au fur et à mesure que les chercheurs ont commencé à formaliser des concepts comme la généralisation, la capacité du modèle et la minimisation du risque, l'optimisation est devenue la lentille unificatrice à travers laquelle l'apprentissage était compris. Dans les années 1990 et début des années 2000, cette formulation est devenue standard dans la littérature du ML et a été consolidée dans des livres influents comme Pattern Recognition and Machine Learning (Bishop, 2006). Mais nous n'avons pas besoin des mathématiques pour garder l'idée centrale :
Un système d'apprentissage est une fonction optimisée.
C'est le premier jalon.

Une petite mais importante clarification

Avant d'aller plus loin, il est important de séparer les idées souvent confondues dans les discussions informelles sur l'IA. Quand les gens disent "entraîner un modèle", ils peuvent se référer à des choix de design très différents. Les systèmes d'IA modernes impliquent au moins quatre couches distinctes :
  1. Signal d'apprentissage — D'où vient le feedback ? (Labels ? Structure ? Récompenses ?)
  2. Architecture du modèle — Quel type de fonction utilisons-nous ? (Modèle linéaire ? Réseau de neurones ? Transformer ?)
  3. Fonction objectif — Qu'optimisons-nous ? (Erreur de prédiction ? Vraisemblance ? Récompense ?)
  4. Méthode d'optimisation — Comment mettons-nous à jour les paramètres ? (Descente de gradient ? Backpropagation ?)
Garder ces couches séparées évite les confusions conceptuelles plus tard, surtout quand nous arriverons au Deep Learning et aux modèles de langage. Nous passerons par ces couches graduellement, mais les garder distinctes rendra le reste du voyage plus clair.

2. Trois façons d'apprendre

À un haut niveau, le ML diffère principalement par le type de signal de feedback disponible à l'apprenant. Au fil de décennies de recherche, trois grands paradigmes d'apprentissage ont émergé. Ils ne sont pas distingués par l'architecture, mais par la manière dont l'information circule de l'environnement vers le modèle.

2.1 Apprentissage supervisé

Dans l'apprentissage supervisé, le système reçoit des paires entrée–sortie :
  • Image → Label
  • Texte → Sentiment
  • Features → Prix
Le modèle ajuste ses paramètres pour minimiser l'erreur de prédiction, typiquement formalisé comme minimiser la perte attendue sur un ensemble de données. Ce paradigme a été façonné par la théorie de décision statistique et ensuite formalisé à travers la théorie de l'apprentissage statistique. Les travaux de Vapnik et d'autres sur des concepts comme la dimension VC (cf. post de blog d'Andy Jones), la minimisation du risque structurel, et les bornes de généralisation ont aidé à clarifier quand et pourquoi les modèles entraînés sur des données finies peuvent généraliser à des exemples non vus. La plupart des systèmes de ML industriels sont dans cette catégorie. Modèle mental :
L'apprentissage supervisé concerne l'approximation de fonctions avec des exemples.

2.2 Apprentissage non supervisé

Dans l'apprentissage non supervisé, il n'y a pas de labels explicites. Au lieu de cela, le système essaie de modéliser la structure ou la distribution des données elles-mêmes. Historiquement, cela inclut :
  • Méthodes de clustering
  • Techniques de réduction de dimensionalité comme l'analyse en composantes principales (ACP)
  • Modèles génératifs probabilistes comme les modèles de mélange et les modèles de variables latentes
Au lieu de travailler avec des prédictions définies extérieurement, le système découvre des structures intrinsèques : comprimant l'information, modélisant des distributions, ou organisant les entrées en représentations internes significatives. Modèle mental :
L'apprentissage non supervisé concerne la découverte de structures dans les données.
Cette perspective devient cruciale plus tard quand nous discuterons des embeddings et de l'apprentissage de représentation.

2.3 Apprentissage par renforcement

Dans l'apprentissage par renforcement (RL), l'apprenant est inséré dans un environnement.
  • Il prend des actions
  • Il reçoit des récompenses
  • Il met à jour une politique pour maximiser la récompense cumulative à long terme
Les fondements mathématiques du RL dérivent en grande partie de la théorie du contrôle et de la programmation dynamique — particulièrement la formulation de Bellman pour le contrôle optimal — et ont été ensuite étendus à travers l'apprentissage par différence temporelle, le Q-learning et les méthodes de gradient de politique (policy gradient methods). Au lieu de labels directs, le feedback est différé et est seulement évaluatif. Modèle mental :
L'apprentissage par renforcement concerne l'optimisation à travers l'interaction.
Le RL réapparaîtra plus tard quand nous discuterons de comment les grands modèles de langage sont alignés avec les préférences humaines.

3. La représentation est le véritable saut

Jusqu'ici, nous avons décrit comment les systèmes apprennent, incluant le type de feedback qu'ils reçoivent et les objectifs qu'ils optimisent. Mais cela laisse une question importante sans réponse :
Qu'est-ce qui est exactement appris ?
Un modèle ne mémorise pas simplement des mappings d'entrée–sortie. Pour généraliser au-delà de ses données d'entraînement, il doit construire des représentations internes ; c'est-à-dire des codages structurés du monde qui capturent des patterns, des régularités et des abstractions. L'apprentissage, c'est l'optimisation. Mais la généralisation dépend de la représentation. Et c'est là où l'IA moderne a pris un tournant décisif.

3.1 De l'ingénierie de features vers les représentations apprises

Avant le Deep Learning, la plupart des systèmes de ML dépendaient lourdement de l'ingénierie de features. Le flux de travail consistait souvent en :
  1. Les humains conçoivent des features.
  2. Le modèle apprend comment les combiner.
En vision par ordinateur, les ingénieurs concevaient manuellement :
  • Détecteurs de bords
  • Features d'histogramme de gradients orientés (HOG)
  • Descripteurs SIFT
En traitement du langage naturel, les modèles dépendaient de :
  • Vecteurs bag-of-words
  • N-grammes
  • Features linguistiques manuellement sélectionnées
L'algorithme d'apprentissage lui-même était souvent relativement simple — régression logistique, SVMs, réseaux de neurones peu profonds. L'intelligence réelle résidait dans le design des features. Cela a créé un goulot d'étranglement. La performance ne s'améliorait qu'à mesure que les humains pouvaient inventer de meilleures représentations.

3.2 Le changement : Laissez le modèle apprendre les features

L'avancée du Deep Learning n'était pas simplement des réseaux de neurones plus profonds ou une meilleure optimisation. C'était l'automatisation systématique de l'apprentissage de features. Au lieu d'alimenter les modèles avec des abstractions construites manuellement, les chercheurs ont commencé à entraîner des réseaux de neurones directement sur des entrées brutes :
  • Pixels au lieu de descripteurs de bords
  • Séquences de mots au lieu de features linguistiques pré-calculées
Les réseaux de neurones profonds ont appris automatiquement des couches intermédiaires de représentation. Les couches inférieures capturaient des patterns locaux. Les couches supérieures capturaient une structure de plus en plus abstraite. Cet apprentissage hiérarchique de représentation est devenu l'avantage définitif des réseaux de neurones profonds. Le point de bascule est devenu visible en 2012 avec le succès des réseaux convolutifs profonds sur ImageNet, rendu célèbre par ImageNet Classification with Deep Convolutional Neural Networks (Krizhevsky et al., 2012). Le résultat clé n'était pas seulement une meilleure précision. C'était que le réseau a appris sa propre hiérarchie de features à partir de données brutes, à l'échelle.

3.3 La représentation comme structure

Que signifie "apprendre une représentation" ? Cela signifie transformer des entrées brutes en une forme interne où la tâche devient plus simple. Dans beaucoup de cas, cette forme interne est géométrique : des vecteurs de haute dimensionnalité. Mais l'idée importante n'est pas le vecteur lui-même. C'est la structure que le vecteur capture. Une bonne représentation :
  • Place des entrées similaires proches les unes des autres.
  • Sépare des concepts distincts.
  • Encode des invariances pertinentes.
  • Élimine la variation non pertinente.
En ce sens, l'apprentissage de représentation concerne la découverte du "système de coordonnées" (ou plus précisément un hyperespace, en langage plus technique) correct pour un problème. Une fois que les entrées sont exprimées dans les bonnes coordonnées, la prédiction devient beaucoup plus facile.

3.4 Le sens devient géométrie

Cette intuition géométrique est devenue particulièrement claire en traitement du langage naturel avec des travaux comme Efficient Estimation of Word Representations in Vector Space (Mikolov et al., 2013). Les embeddings de mots ont démontré que des relations sémantiques pouvaient émerger comme des relations spatiales :
  • Des mots similaires se regroupent.
  • Des analogies correspondent à des déplacements vectoriels.
Le modèle n'a pas été explicitement programmé avec des définitions de "roi" ou "reine".
Il a appris une structure statistique à partir de grands corpus, et cette structure s'est manifestée géométriquement. À ce point, un nouveau modèle mental devient utile :
Les systèmes d'IA modernes convertissent une réalité désordonnée en géométrie structurée.
Et une fois que le sens est codé géométriquement, faire passer les modèles à l'échelle devient une question d'apprendre des représentations plus riches et de plus haute dimensionnalité. Ce changement, de features dessinées à la main vers des représentations apprises, est le véritable point d'inflexion qui a préparé le terrain pour l'IA moderne. La prochaine étape a été d'apprendre comment représenter efficacement des séquences. C'est là que les transformers entrent dans l'histoire.

Une petite digression personnelle

Cette idée que la représentation est souvent le véritable goulot d'étranglement n'est pas seulement théorique. Dans mon travail de doctorat, le problème central n'était pas vraiment "quel algorithme devrions-nous utiliser ?". C'était : comment représentons-nous le comportement de programmes d'une manière qu'un modèle de ML puisse vraiment utiliser ? La recherche s'est concentrée sur la modélisation de fichiers binaires comme des graphes structurés — spécifiquement, des Graphes de Dépendance d'Appels Système (SCDGs). La partie difficile n'était pas la classification elle-même. C'était de transformer ces objets complexes et structurés en quelque chose qui préserve l'information comportementale et qui, en même temps, soit amical à l'apprentissage. En pratique, cela signifiait constamment poser des questions comme :
  • Quelle structure doit être gardée ?
  • Quel détail peut être écarté ?
  • Qu'est-ce qui rend deux binaires "proches" ou "similaires" dans un sens significatif ?
  • Comment évaluons-nous si la représentation capture ce qui compte ?
À l'époque, cela semblait être un défi d'ingénierie très spécifique à mon domaine. Rétrospectivement, cependant, il est clair que le travail s'inscrivait dans un changement plus large en IA : la prise de conscience croissante que la représentation est souvent le problème central. Tout cela était avant que les transformers et les grands modèles de langage ne fassent partie du quotidien. Pourtant, la question sous-jacente était déjà la même : comment construisons-nous des représentations qui rendent l'apprentissage possible ? Avant l'obsession de l'échelle, avant les LLMs, avant la vague actuelle d'IA générative, il y a la question de la représentation. Et dans beaucoup de systèmes, c'est là que réside la majeure partie du travail intellectuel.

4. Le changement des transformers

Au milieu des années 2010, le Deep Learning s'était établi comme un cadre puissant pour l'apprentissage de représentation, surtout en vision. Le langage, cependant, a exposé une faiblesse structurelle. Contrairement aux images, le langage est séquentiel. Le sens d'un mot dépend des mots autour de lui, parfois distants dans la phrase. Modéliser ces dépendances de longue portée s'est révélé plus difficile qu'il n'y paraissait. Les approches précédentes dépendaient de réseaux de neurones récurrents (RNNs) et ensuite de réseaux Long Short-Term Memory (LSTMs). Ces architectures traitaient les séquences pas à pas, gardant un état caché qui évoluait au fil du temps. Elles fonctionnaient, mais imparfaitement : Le traitement séquentiel limitait la parallélisation ; Les dépendances de longue portée étaient difficiles à préserver ; L'entraînement devenait instable pour des contextes très longs. Conceptuellement, le modèle comprime tout ce qu'il a vu jusqu'à un certain point en un seul vecteur en évolution. Ce vecteur devient effectivement la mémoire du modèle. Cela crée deux contraintes :
  1. Goulot d'étranglement d'information — tout le contexte préalable doit tenir dans un seul état.
  2. Dépendance séquentielle — les tokens doivent être traités dans l'ordre, limitant la parallélisation.
Pour des séquences courtes, cela fonctionne bien. Pour des contextes longs, l'information se dégrade et l'entraînement devient difficile. Une idée différente a commencé à prendre forme :
Et si, au lieu de traiter les tokens un à la fois, le modèle pouvait regarder la séquence entière d'un seul coup ?
C'était l'intuition clé derrière le papier de 2017 Attention Is All You Need (Vaswani et al., 2017), qui a introduit l'architecture transformer. L'innovation centrale a été le mécanisme d'attention. Au lieu de forcer toute l'information préalable à travers un seul état en évolution, l'attention permet à chaque token de calculer sa représentation en pondérant directement la pertinence de chaque autre token dans la séquence. En termes pratiques :
  • Chaque mot peut directement "regarder" chaque autre mot.
  • Le contexte est modélisé à travers des relations pondérées.
  • Les calculs peuvent être parallélisés efficacement.
En d'autres mots :
Chaque mot décide dynamiquement quels autres mots comptent pour le comprendre.
Le modèle ne dépend plus d'une seule mémoire comprimée. Il construit le contexte dynamiquement, à travers des relations pondérées. Dans les modèles basés sur l'attention, chaque token peut interagir avec les autres tokens au sein d'une seule couche. Cela permet des représentations de séquence plus riches et flexibles, ce qui rend l'entraînement à grande échelle réalisable. Sous le capot, ces poids de pertinence sont des mesures de similarité apprises entre des représentations de tokens, permettant au modèle de découvrir quelles relations comptent pour la tâche.
Ce changement modifie fondamentalement trois choses : 1. Flux d'Information Le contexte n'est plus contraint de traverser un canal séquentiel étroit. Les relations sont modélisées explicitement et directement. 2. Parallélisation Parce que les tokens sont traités simultanément au lieu de pas à pas, l'entraînement peut exploiter le matériel moderne beaucoup plus efficacement. 3. Flexibilité de Représentation Le mécanisme d'attention construit des représentations sensibles au contexte. L'embedding d'un mot n'est pas fixe ; il change en fonction des tokens autour. Fait important, ce changement était architectural, pas conceptuel.
  • Le modèle optimise toujours un objectif prédictif.
  • Il apprend toujours des représentations.
  • Il opère toujours dans un espace de haute dimensionnalité.
Mais la capacité représentationnelle de l'architecture devient beaucoup plus expressive. Et surtout, l'architecture est stable et scalable. Cette combinaison, attention plus échelle, a préparé le terrain pour l'essor des grands modèles de langage.

5. L'échelle change le comportement

À elle seule, l'architecture transformer n'a pas immédiatement produit le type de systèmes que nous associons maintenant aux grands modèles de langage. Le facteur décisif a été l'échelle :
  • Des modèles plus grands.
  • Plus de données.
  • Plus de puissance de calcul.
Pendant des années, augmenter la taille du modèle a produit des améliorations incrémentales. Mais vers la fin des années 2010, les chercheurs ont commencé à remarquer quelque chose de plus systématique. La performance ne s'améliorait pas aléatoirement. Elle s'améliorait de manière prévisible. Cette observation a été formalisée dans Scaling Laws for Neural Language Models (Kaplan et al., 2020), qui a montré que la performance du modèle suit des relations douces de loi de puissance par rapport à la taille du modèle, la taille de l'ensemble de données et la capacité de calcul. En termes simples :
Si vous rendez le modèle plus grand, le nourrissez avec plus de données et l'entraînez plus longtemps, la performance s'améliore de manière étonnamment régulière.
Il n'y a pas de point de saturation évident. Pas d'effondrement soudain. Juste une amélioration constante et mesurable. Cela a eu une implication importante : Améliorer les modèles de langage n'était plus principalement une question d'inventer de nouvelles architectures. C'était une question de faire passer les existantes à l'échelle efficacement.

5.1 Quand la quantité devient qualité

La prochaine surprise est venue avec Language Models are Few-Shot Learners (Brown et al., 2020), qui a introduit GPT-3. Au fur et à mesure que les modèles franchissaient certains seuils de taille, de nouvelles capacités apparaissaient :
  • Effectuer des tâches sans entraînement spécifique pour cette tâche
  • Suivre des instructions à partir de prompts
  • Traduire, résumer, répondre à des questions avec des exemples minimaux
Ces capacités n'ont pas été explicitement programmées. Elles ont émergé de la prédiction du prochain token à l'échelle. Ce phénomène est devenu connu sous le nom d'apprentissage in-context. Au lieu de mettre à jour les poids, le modèle pouvait adapter son comportement sur la base d'exemples fournis dans le prompt. L'architecture n'avait pas fondamentalement changé. L'objectif n'avait pas fondamentalement changé. La procédure d'entraînement était toujours la prédiction du prochain token. Ce qui a changé, c'était l'échelle. Et l'échelle a altéré le comportement.

5.2 Pourquoi l'échelle compte ?

Pourquoi augmenter la taille produit-il un comportement qualitativement différent ? Plusieurs facteurs contribuent :
  1. Des modèles plus grands peuvent stocker une structure statistique plus fine.
  2. Des réseaux de neurones plus profonds peuvent construire des représentations plus abstraites.
  3. Des ensembles de données massifs exposent les modèles à des patterns plus larges d'usage du langage.
  4. L'optimisation à l'échelle lisse le comportement à travers de nombreuses tâches.
Au fur et à mesure que la capacité augmente, la géométrie interne du modèle devient plus riche. Des patterns qui étaient auparavant trop subtils pour être capturés deviennent représentables. Cela ne signifie pas que le modèle "comprend" dans un sens humain. Cela signifie que l'espace de représentation devient suffisamment expressif pour simuler une large gamme de comportements linguistiques. Et une fois que cela arrive, une nouvelle classe de systèmes devient possible. Les grands modèles de langage ne sont pas définis par un nouveau paradigme d'apprentissage. Ce sont des transformers entraînés à une échelle sans précédent. C'est le changement crucial.

6. Que sont vraiment les grands modèles de langage ?

À ce point, nous pouvons enfin définir ce qu'est un grand modèle de langage (LLM) (sans aucun mysticisme). Un grand modèle de langage est un réseau de neurones basé sur transformer entraîné pour prédire le prochain token dans une séquence. C'est tout. Plus précisément, il apprend une distribution de probabilité conditionnelle : P(τN∣τ1,…,τN−1)P(\tau_N \mid \tau_1, \dots, \tau_{N-1}) Étant donné une séquence de texte, le modèle attribue des probabilités à tous les tokens possibles suivants et en sélectionne un selon cette distribution. Cette formulation est la version moderne à l'échelle de la modélisation classique du langage : estimer la probabilité de séquences à partir de données (voir, par exemple, A Neural Probabilistic Language Model (Bengio et al., 2003)). Tout le reste est issu de cet objectif.

6.1 Apprentissage auto-supervisé à l'échelle

Les LLMs sont entraînés en utilisant l'apprentissage auto-supervisé. Au lieu de nécessiter des ensembles de données labellisés, ils utilisent du texte brut et traitent le prochain token comme cible. L'apprentissage auto-supervisé peut être compris comme une forme structurée d'apprentissage non supervisé, où le signal de supervision est dérivé de la structure même des données au lieu de labels externes. Par exemple :
Entrée : "La capitale de la France est"
Cible : "Paris"
Aucune annotation humaine n'est nécessaire. Les données elles-mêmes fournissent la supervision. En répétant cet objectif à travers des milliards (ou trillions) de tokens, le modèle apprend :
  • La syntaxe
  • La grammaire
  • Des régularités statistiques
  • Des faits communs
  • Des patterns de raisonnement présents dans le texte
L'objectif d'entraînement reste simple. Ce qui change, c'est l'échelle.

6.2 Représentation, pas des règles

Contrairement à ce qu’affirme Luc Julia 😜 : Un LLM ne stocke pas de règles symboliques explicites. Il ne contient pas de base de données de déclarations logiques. Il n'exécute pas de moteur de raisonnement formel. Au lieu de cela, la connaissance est codée implicitement dans ses paramètres, distribuée à travers un espace vectoriel de haute dimensionnalité. Quand le modèle produit un texte qui semble raisonner, ce qu'il fait, c'est générer des séquences qui statistiquement ressemblent à des patterns de raisonnement qu'il a appris des données. Cette distinction est subtile mais importante :
  • La fluidité n'est pas la même chose que la compréhension.
  • La cohérence n'est pas la même chose que la vérité.
Le modèle optimise la probabilité, pas la précision factuelle.

6.3 Pourquoi les hallucinations arrivent-elles ?

Parce que l'objectif est la prédiction probabiliste du prochain token, le modèle vise à produire un texte qui soit plausible étant donné le contexte — pas un texte qui soit vérifié ou fondé. Si les données d'entraînement contiennent des informations inconsistantes ou incomplètes, le modèle peut avec confiance générer des sorties incorrectes. Par exemple, interrogé sur un papier de recherche fictif, un LLM pourrait fabriquer un titre plausible, une liste d'auteurs et un résumé — fluide mais entièrement inventé. Ce n'est pas un bug dans la logique de raisonnement. C'est une conséquence directe de l'objectif d'entraînement. Cette tension de fluidité sans fondation est une des raisons pour lesquelles les hallucinations apparaissent en pratique. Cela a été étudié sous le parapluie plus large de facticité et fidélité dans la génération (ex: On the Dangers of Stochastic Parrots (Bender et al., 2021); et dans des travaux sur la cohérence factuelle comme TruthfulQA (Lin et al., 2022)).

6.4 Pourquoi ils semblent différents ?

Malgré la simplicité de leur objectif, les LLMs semblent qualitativement différents des modèles précédents. Cette perception vient de trois facteurs :
  1. Échelle — de grandes quantités de paramètres permettent des représentations internes riches.
  2. Pré-entraînement — exposition à des corpus massifs et divers.
  3. Apprentissage in-context — la capacité de conditionner le comportement sur des prompts sans mises à jour de poids.
Combinés, ils produisent des systèmes qui peuvent simuler beaucoup de comportements linguistiques au sein d'un seul modèle unifié. Mais sous le capot, le mécanisme reste le même : Un transformer prédisant le prochain token.

7. De modèle à système

Si les Sections 1–6 concernaient comment les modèles apprennent, cette section concerne comment nous les rendons utiles et fiables dans le monde réel. Un grand modèle de langage est un composant. Une application d'IA est un système. Cette distinction est facile à manquer, et une grande partie de la confusion autour de l'IA moderne vient de traiter des choses différentes comme si elles étaient identiques. Un LLM est un modèle de séquence probabiliste entraîné pour prédire le prochain token. À lui seul, il n'a :
  • Aucune mémoire persistante au-delà de sa fenêtre de contexte
  • Aucun accès direct à des bases de données externes
  • Aucune capacité d'exécuter du code
  • Aucun mécanisme intégré pour la vérification des faits
Ce qui rend les systèmes d'IA modernes puissants n'est pas seulement le modèle, mais l'architecture construite autour de lui.

7.1 Fine-tuning et alignement

Le développement moderne de LLMs suit typiquement un paradigme en deux phases : pré-entraînement sur des corpus massifs pour la prédiction du prochain token, suivi de post-entraînement pour l'alignement et le comportement spécifique à la tâche. Une façon d'adapter un modèle de base est le fine-tuning. Au lieu d'entraîner à partir de zéro, les paramètres du modèle sont ajustés sur des ensembles de données plus spécifiques :
  • Corpus de suivi d'instructions
  • Documents spécifiques à un domaine
  • Exemples conversationnels
Le Reinforcement Learning from Human Feedback (RLHF) va plus loin. Au lieu d'optimiser purement selon la probabilité du prochain token, le modèle est ajusté pour produire des sorties que les humains évaluent comme utiles, sûres ou alignées (cf. Training language models to follow instructions with human feedback (Ouyang et al., 2022)). Cela ne change pas la structure de l'objectif sous-jacent. Cela affine le comportement du même modèle probabiliste. L'architecture reste un transformer. L'optimisation reste basée sur le gradient.

7.2 Prompting comme programmation soft

Toute adaptation ne nécessite pas forcément de mises à jour de poids. Comme les LLMs exhibent un apprentissage in-context, le comportement peut être façonné directement à travers le prompt. Fournir des exemples à l'intérieur de la fenêtre de contexte conditionne effectivement le modèle à continuer dans un pattern particulier. En ce sens, le prompting est une forme de programmation soft :
  • Vous ne changez pas le code.
  • Vous façonnez les conditions sous lesquelles il tourne.
Cette capacité a été une des conséquences les plus surprenantes de l'entraînement à grande échelle.

7.3 Ajouter de la connaissance externe

Une limitation centrale des LLMs est qu'ils génèrent du texte plausible, mais pas nécessairement fondé. Le Retrieval-Augmented Generation (RAG) aborde cela en insérant de l'information externe dans le contexte du modèle. Le système :
  1. Cherche des informations dans une base de connaissance.
  2. Sélectionne des documents pertinents.
  3. Les injecte dans le prompt.
  4. Laisse le modèle générer une réponse basée sur ces documents.
Effectivement, le modèle lui-même reste inchangé. Ce qui change, c'est l'architecture autour de lui. Le RAG n'est donc pas un nouveau paradigme d'apprentissage, mais un pattern de systèmes : "récupère, ensuite génère". Cette idée a été formalisée dans des travaux comme Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (Lewis et al., 2020). En fondant la génération sur des sources externes, le système améliore la fiabilité factuelle sans modifier le prédicteur de prochain token sous-jacent (c.-à-d. le modèle LLM).

7.4 Appel de fonctions : Du langage à l'action

Peut-être l'avènement le plus important des systèmes modernes de LLM est l'usage d'outils, souvent implémenté à travers l'appel de fonctions. Ici, le modèle ne génère pas simplement du texte, il peut produire des sorties structurées qui spécifient :
  • Quel outil appeler
  • Avec quels arguments
Par exemple :
  • Invoquer une calculatrice
  • Consulter une base de données
  • Envoyer une requête d'API
  • Démarrer l'exécution de code
Le rôle du LLM devient celui d'un orchestrateur :
  1. Interpréter l'intention de l'utilisateur
  2. Décider quelle fonction est appropriée
  3. Produire des paramètres structurés
  4. Intégrer le résultat retourné dans la réponse finale
C'est ce qui permet un comportement similaire à celui d'un agent (autonome). Ce pattern "langage-vers-action" a été exploré dans des recherches comme ReAct: Synergizing Reasoning and Acting in Language Models (Yao et al., 2022), qui intercale des séquences de raisonnement avec l'usage d'outils, et Toolformer: Language Models Can Teach Themselves to Use Tools (Schick et al., 2023), où les modèles apprennent quand appeler des outils à partir de données. Un bref aparté : le ReAct touche à un domaine plus large et actif de recherche souvent décrit comme le raisonnement (reasoning) dans les grands modèles de langage. Les travaux dans cette direction investiguent comment les modèles peuvent générer des étapes intermédiaires, décomposer des problèmes et structurer des solutions multi-étapes de manière plus fiable. Nous n'explorerons pas les méthodes de raisonnement plus en profondeur ici, car ce sujet mérite sa propre discussion. Pour nos objectifs, le point clé est architectural : le modèle lui-même prédit toujours des tokens, mais ces tokens décrivent maintenant des actions. Le système autour exécute ces actions. Le modèle continue ensuite la génération basée sur les résultats. De cette façon :
Le modèle de langage devient une interface de raisonnement sur des outils.
C'est un changement crucial. L'intelligence n'est plus confinée à la représentation interne. Elle est distribuée à travers le modèle, les outils et la logique de contrôle.

7.5 Agents et boucles de contrôle

Quand les appels de fonctions sont combinés à du prompting itératif et de la mémoire, ce système commence à ressembler à un agent. Il peut :
  • Planifier des actions multi-étapes
  • Appeler des outils de manière répétée
  • Évaluer des résultats intermédiaires
  • Ajuster le comportement dynamiquement
Cependant, même ici, le mécanisme sous-jacent reste le même : Un transformer prédisant le prochain token. L'apparence d'autonomie ("agence") émerge de boucles d'interaction structurées construites autour de la génération probabiliste.

7.6 La séparation qui compte

Le modèle de base fournit :
  • L'apprentissage de représentation à grande échelle
  • La fluidité linguistique
  • La généralisation de patterns
Le système fournit :
  • Le fondement
  • L'accès aux outils
  • La mémoire
  • La vérification
  • Le contrôle itératif
Comprendre cette séparation réduit beaucoup du hype. Les grands modèles de langage sont des composants puissants. Les systèmes d'IA modernes sont des architectures qui organisent ces composants en une seule structure. La différence entre les deux est où se trouve la majeure partie du travail d'ingénierie.

8. Une carte mentale claire et structurée

Nous avons exploré l’IA moderne selon une trajectoire délibérément construite.
  1. Nous avons commencé avec le tournant statistique : le passage d'écrire des règles à apprendre à partir de données.
  2. Nous avons séparé les signaux d'apprentissage des architectures, objectifs et méthodes d'optimisation.
  3. Nous avons vu comment l'apprentissage de la représentation est devenu une avancée importante, déplaçant le goulot d'étranglement des features artisanales vers des structures internes apprises.
  4. Nous avons examiné comment les transformers ont reformulé la modélisation de séquences en remplaçant la compression séquentielle par l'attention.
  5. Nous avons vu que l'échelle a changé le comportement ; sans altérer les objectifs sous-jacents, mais en étendant ses capacités représentationnelles.
Et nous avons clarifié ce que les grands modèles de langage sont vraiment :
Des prédicteurs de prochain token basés sur transformer entraînés à une échelle massive.
Rien de plus. Rien de moins.
Si vous comprimez tout le territoire de l'IA en quelques idées durables, cela donne :
  • Les modèles d'IA apprennent comme des fonctions optimisées.
  • La performance est étroitement liée à la représentation.
  • Les transformers permettent des représentations de séquences scalables.
  • L'échelle altère le comportement qualitatif.
  • Les LLMs sont des composants, pas des systèmes complets.
La majeure partie de la confusion sur l'IA vient de mélanger ces couches. Quand les architectures sont confondues avec des paradigmes d'apprentissage. Quand la fluidité probabiliste est confondue avec le raisonnement. Quand les modèles sont confondus avec des systèmes. Quand l'échelle est confondue avec un nouveau type d'intelligence. Dépouillés du hype, l'IA moderne est remarquablement cohérente :
C'est l'optimisation de grands modèles paramétrés qui apprennent des représentations structurées à partir de données.
L'intelligence apparente émerge de la géométrie, de l'échelle et du design du système. Comprendre cette hiérarchie facilite le raisonnement sur ce que les systèmes d'IA actuels peuvent faire et où sont leurs limites. Les mêmes principes s'étendent naturellement aux systèmes d'IA multimodaux, où des représentations de texte, d'images et d'audio sont apprises et combinées au sein d'une architecture unifiée. Et cela, plus que tout outil ou modèle individuel, est une carte durable.
L'IA peut sembler chaotique de l'extérieur. En interne, sa structure est étonnamment disciplinée.