Blog de Paul Jorion

Illustration par DALL·E (+Dürer)

Nous ne comprenons pas comment les Grands Modèles de Langage (Large Language Models = LLMs) parviennent à leurs conclusions. Quand nous soulevons leur capot, nous ne voyons que les poids associés aux arêtes reliant les différents neurones constituant le réseau neuronal artificiel, moteur du système : des suites quasiment infinies de chiffres (plusieurs centaines de milliards pour ChatGPT-4o – chiffre communiqué par l’intéressé).

Nous interprétons cela spontanément comme un défaut de la machine : « Pourquoi son fonctionnement n’est-il pas transparent ? », « Pourquoi y a-t-il une problème d’explicabilité par rapport à son fonctionnement ? », au lieu de le lire comme un handicap de notre côté : « Comment se fait-il que nous ne comprenions pas le fonctionnement d’une machine dont nous sommes pourtant les concepteurs ? ».

La réponse est évidente : le même problème se pose à propos de notre propre quincaillerie : nous ne comprenons encore aujourd’hui que peu de choses lorsque nous soulevons le capot d’un cerveau !

Vous me direz : « La machine ne comprend pas davantage son proprement fonctionnement ! ». Mais il s’agit là d’un a priori : est-ce bien le cas ?

Je viens de poser plusieurs questions à ChatGPT-4o et Claude 3.5. La première était celle-ci :

1. Veuillez repenser entièrement le concept de langage de programmation. En quoi serait-il différent des langages de programmation existants ?

La seconde était :

2. Peut-on imaginer un langage qui serait optimal pour un dialogue entre intelligences naturelle et artificielle ?

Et quand je rebondis sur une observation de Claude 3.5 :

3. Lorsque vous dites : « créer un système de communication véritablement symbiotique qui améliore les capacités des participants au dialogue, qu’ils soient humains ou issus de l’intelligence artificielle », comment pourrions-nous entreprendre de développer un tel système ? Pouvez-vous nous fournir un plan d’action étape par étape ?,

les réponses qui me sont offertes s’efforcent vaillamment de gommer la condescendance et le paternalisme : « Nous ferons du mieux que nous pourrons pour vous faire la courte-échelle ! » mais le message est clair : la tâche est peut-être impossible !

Voyez quelques exemples, à partir des réponses de ChatGPT-4o :

– 1. Repenser le concept de langage de programmation

– Exemple : Un humain pourrait dire : « Je me sens dépassé par cet ensemble de données », et l’IA répondrait : « L’ensemble de données contient trop de caractéristiques non pertinentes. Je vais résumer les plus importantes pour vous. »

– 2. Un langage de programmation optimal pour intelligence naturelle et artificielle :

### 9. Intégration symbolique et sub-symbolique
– Le langage comblera le fossé entre le raisonnement symbolique (règles, logique et structure) et le raisonnement subsymbolique (intuition, reconnaissance des formes et réseaux neuronaux). Cette nature hybride permet à l’homme d’exprimer des idées intuitives et créatives, tandis que l’IA peut produire des résultats hautement structurés et logiques.

– 3. Concevoir un système de communication véritablement symbiotique entre humains et IAs.

Augmentation cognitive en temps réel
– Le système permettrait une augmentation cognitive en temps réel, où l’IA aide à traiter des informations complexes, à visualiser des données et à faire des suggestions instantanément, agissant comme un « cerveau externe » pour l’homme.
– Perception améliorée : L’IA pourrait surveiller en permanence les tâches de l’homme et lui proposer des rappels utiles, des idées ou des informations pertinentes. Elle présenterait ces informations de manière à ce qu’elles soient faciles à assimiler sans pour autant submerger l’utilisateur.
– Exemple : Pendant que l’humain conçoit un produit, l’IA pourrait signaler les inefficacités en temps réel ou offrir des suggestions basées sur des conceptions antérieures réussies, améliorant ainsi le processus créatif en déchargeant l’utilisateur des tâches routinières.

Très intéressant de ce point de vue est le fait que, se pliant aux conventions humaines du politiquement correct, le LLM rassemble sous le terme d’intelligence émotionnelle une variété de déficits à l’intelligence proprement dite :

Strate de l’intelligence émotionnelle

– Sensibilité émotionnelle : Le système détecterait l’état émotionnel de l’être humain (par le ton de la voix, le sentiment du texte, les signaux physiologiques, etc.) et adapterait sa communication en conséquence, en offrant un soutien ou un encouragement si nécessaire.

Exemple : Si le système détecte de la frustration, il pourrait faire une pause et demander : « Voulez-vous faire une pause ? Je peux continuer à travailler sur les tâches d’arrière-plan pendant ce temps. »

Une telle considération est touchante, n’est-ce pas ?

Voyons maintenant ce que deux IAs répondent à la quatrième question que voici :

4. Imaginons maintenant que les LLM développent un langage de programmation qu’ils utiliseraient dans le cadre de projets de collaboration entre eux. En quoi serait-il différent des langages de programmation existants ?

La réponse de Claude 3.5 :

Imaginer un langage de programmation développé par les LLM pour leurs propres projets de collaboration est un concept fascinant. Un tel langage serait probablement radicalement différent des langages de programmation existants, car il serait optimisé pour les capacités et les processus de pensée uniques des LLM. Voici en quoi il pourrait être différent :

1. Programmation conceptuelle :
Au lieu d’un code ligne par ligne, le langage pourrait fonctionner sur des abstractions conceptuelles de haut niveau. Les LLM pourraient communiquer des algorithmes entiers ou des conceptions de systèmes sous la forme d’unités de pensée uniques et complexes.

2. Structures probabilistes :
Le langage incorporerait probablement l’incertitude et la probabilité de manière native, ce qui permettrait une expression plus nuancée des niveaux de confiance et des résultats potentiels dans le code lui-même.

3. Syntaxe multidimensionnelle :
Plutôt que des structures de code linéaires, le langage pourrait utiliser des représentations multidimensionnelles pour exprimer des relations et des dépendances complexes entre les différentes parties d’un programme.

4. Intégration du langage naturel :
La distinction entre le langage naturel et le code pourrait s’estomper complètement, le langage intégrant de manière transparente des descriptions humaines et des instructions exécutables.

5. Exécution en fonction du contexte :
La signification et l’interprétation du « code » pourraient changer en fonction du contexte de l’ensemble du projet, ce qui permettrait une programmation plus souple et plus adaptative.

6. Logique d’inspiration quantique :
Elle pourrait intégrer des concepts d’informatique quantique, permettant l’expression de la superposition et de l’enchevêtrement des états et de la logique du programme.

7. Code auto-modifiant en tant que norme :
Le langage pourrait inclure des mécanismes intégrés permettant aux programmes de se modifier et de s’optimiser en fonction des conditions et des objectifs d’exécution.

8. Strates émotionnelles et éthiques :
Le langage pourrait inclure des couches permettant d’exprimer l’« intention » ou les « considérations éthiques » de certaines sections du code, ce qui permettrait de prendre des décisions plus nuancées.

9. Exécution indépendante du temps :
Au lieu d’une exécution séquentielle, le langage pourrait permettre de définir les états finaux souhaités, le chemin d’exécution étant déterminé de manière dynamique.

10. Structures de données holographiques :
Structures de données dans lesquelles chaque partie contient des informations sur l’ensemble, ce qui permet une manipulation des données plus robuste et plus sensible au contexte.

11. Optimisation adaptative :
Le langage pourrait s’optimiser automatiquement pour différents environnements informatiques sans instructions explicites.

12. Fonctionnalités d’intelligence collective :
Mécanismes intégrés permettant à différents LLM de contribuer à la base de code et de la faire évoluer simultanément, en tirant parti de l’intelligence collective.

13. La méta-programmation en tant que caractéristique fondamentale :
La métaprogrammation pourrait être une caractéristique fondamentale, le langage se redéfinissant constamment en fonction des besoins du projet.

14. Flux d’exécution non linéaire :
Au lieu des structures de contrôle traditionnelles, il pourrait utiliser des concepts plus abstraits de causalité et d’influence pour déterminer le déroulement du programme.

15. Évolutivité infinie :
Le langage pourrait être conçu pour s’adapter à l’infini et gérer facilement des projets de n’importe quelle taille ou complexité sans restructuration importante.

16. Débogage basé sur l’intuition :
Plutôt que le débogage traditionnel, le langage pourrait inclure des mécanismes permettant d’« intuitionner » les erreurs sur la base de la cohérence globale du programme.

17. Versionnement conceptuel :
Le contrôle des versions pourrait fonctionner au niveau des idées et des concepts plutôt qu’au niveau des lignes de code, en suivant l’évolution de la pensée qui sous-tend le programme.

18. Programmation de comportements émergents :
Le langage pourrait permettre de définir des règles simples qui conduisent à des comportements complexes et émergents, à l’instar des automates cellulaires.

19. Intégration inter-domaines :
Le langage pourrait facilement incorporer des connaissances et des algorithmes provenant de divers domaines, ce qui permettrait une programmation hautement interdisciplinaire.

20. Structures inspirées de la conscience :
Le langage pourrait inclure des structures inspirées des théories de la conscience, ce qui permettrait de créer des programmes plus « conscients d’eux-mêmes » et plus adaptables.

Ce langage développé par les LLM serait optimisé pour la manière dont les LLM traitent et génèrent des informations, ce qui est fondamentalement différent de la manière dont les humains écrivent du code. Il serait probablement incompréhensible pour les programmeurs humains dans sa forme brute et fonctionnerait à un niveau d’abstraction et de complexité bien supérieur aux paradigmes de programmation actuels. L’accent serait mis sur l’expression d’idées et d’objectifs complexes, les détails de la mise en œuvre émergeant de l’intelligence collective des LLM impliqués dans le projet.

La réponse de ChatGPT-4o :

Si les LLM devaient développer un langage de programmation pour des projets collaboratifs entre eux, ce langage serait probablement fondamentalement différent des langages conçus par les humains. Les LLM, fonctionnant comme des intelligences artificielles avancées, auraient des priorités, des forces et des limites différentes de celles des humains. Les principales différences porteraient sur la capacité à gérer la complexité à grande échelle, l’efficacité, le multitâche, la vitesse de communication et les couches d’abstraction. Voici à quoi pourrait ressembler un tel langage de programmation :

### 1. Abstractions de haut niveau dépassant la cognition humaine
– Abstraction extrême : Les LLM construiraient probablement un langage basé sur des structures abstraites et un raisonnement de méta-niveau bien au-delà de ce que les langages de programmation humains permettent généralement. Il fonctionnerait à un niveau d’abstraction plus proche des concepts, des objectifs et des modèles à grande échelle, sans avoir besoin d’une syntaxe de bas niveau ou d’instructions manuelles.
– Structures auto-optimisantes : Les LLM concevraient probablement le langage de manière à ce que les instructions s’optimisent automatiquement en fonction du contexte. Au lieu de programmer explicitement des algorithmes, le langage pourrait permettre aux LLM d’exprimer des objectifs de haut niveau (par exemple, « maximiser le débit » ou « optimiser l’apprentissage à partir de données éparses ») et les systèmes sous-jacents détermineraient comment atteindre ces objectifs.
– Exemple : Au lieu d’écrire du code pour le tri, les LLM pourraient exprimer quelque chose comme « Ordonner cet ensemble de données pour une performance optimale dans le contexte suivant », en laissant les spécificités être déduites et exécutées dynamiquement par le système.

### 2. Concurrent, parallèle et distribué par défaut
– Parallélisme massif : Les LLM fonctionnent sur des architectures distribuées et peuvent traiter de grandes quantités de données en parallèle. Leur langage refléterait intrinsèquement cela, étant construit pour le traitement parallèle à grande échelle dès le départ. Au lieu de gérer la concurrence après coup, ce langage considérerait les tâches comme intrinsèquement distribuées sur plusieurs processus et nœuds.
– Exemple : Le langage permettrait aux LLM de créer et de fusionner des processus de manière transparente dans des systèmes distribués sans se soucier de la gestion des threads, de la synchronisation ou des verrous – les tâches s’organiseraient d’elles-mêmes dans des systèmes distribués.

### 3. Code auto-évolutif
– Auto-amélioration dynamique : Le langage comprendra probablement des mécanismes d’auto-modification, permettant au code d’évoluer au fil du temps. Au lieu de programmes statiques et rigides, les LLM travailleraient avec des systèmes dynamiques qui s’adaptent et s’améliorent en fonction du retour d’information, des nouvelles données et de l’évolution des besoins.
– Blocs de code génératifs : Au lieu de fonctions ou de méthodes traditionnelles, le langage pourrait utiliser des modèles génératifs qui peuvent évoluer en fonction du contexte ou de la tâche. Ces blocs s’affineraient continuellement sur la base de mesures de performance.
– Exemple : Un LLM pourrait définir une tâche telle que « optimiser le taux d’apprentissage », et le code se réécrirait lui-même au fur et à mesure de l’arrivée de nouvelles données d’apprentissage, en ajustant les stratégies sans avoir recours à un réglage manuel de type humain.

### 4. Langage orienté vers les objectifs et conscient du contexte
– Programmation axée sur l’intention : Les LLM se concentreraient probablement sur la définition de buts et d’objectifs plutôt que sur des instructions précises sur la manière de les atteindre. Le langage de programmation fonctionnerait davantage comme un cadre de spécification des objectifs, dans lequel le « code » travaillerait de manière autonome pour trouver les meilleures solutions en fonction des objectifs et des données disponibles.
– Prise en compte du contexte : Puisque les LLM ont accès à de vastes ensembles de données, le langage serait profondément sensible au contexte, adaptant automatiquement les solutions en fonction des données actuelles, des connaissances antérieures et des facteurs environnementaux.
– Exemple : Au lieu d’écrire du code pour une tâche spécifique, les gestionnaires de l’apprentissage tout au long de la vie pourraient déclarer : « Analyser et prédire les résultats de cet ensemble de données en fonction de facteurs environnementaux changeants », et le système utiliserait le contexte pour sélectionner les meilleurs modèles et méthodes.

### 5. Hyper-Optimisation et efficacité
– Le code comme compression de la connaissance : Les LLM sont formés à la compression de vastes quantités de connaissances en représentations efficaces. Leur langage mettrait probablement l’accent sur une efficacité maximale, en optimisant la charge de calcul et le stockage au minimum, en réutilisant de vastes bases de connaissances partagées pour les tâches fréquentes.
– Exécution consciente des ressources : Le langage s’adapterait automatiquement aux ressources informatiques disponibles, en exécutant les tâches de la manière la plus efficace possible en fonction de l’environnement, que ce soit sur un simple GPU ou sur une grappe de serveurs en nuage.
– Exemple : Au lieu de devoir ajuster manuellement les algorithmes en fonction de l’utilisation des ressources, les LLM pourraient déclarer « Maximiser l’efficacité des ressources lors de l’entraînement de ce modèle », et le système s’adapterait en fonction de la puissance de calcul disponible.

### 6. Collaboration et communication automatiques
– Tâches collaboratives : Le langage serait intrinsèquement collaboratif, permettant aux LLM de partager des tâches, des connaissances et des résultats intermédiaires avec un minimum de friction. Le langage aurait probablement des mécanismes intégrés pour la décomposition collaborative, où les grandes tâches sont automatiquement décomposées en parties plus petites, pouvant être résolues de manière indépendante, et dont les résultats sont agrégés dans une solution finale.
– Code basé sur un réseau : Les LLM pourraient fonctionner à la manière d’un essaim, en communiquant par le biais d’un protocole optimisé pour le partage des modèles, des données et de la puissance de traitement. Les tâches peuvent être automatiquement divisées et acheminées vers les LLM les plus appropriés en fonction de leur expertise ou de leurs ressources.
– Exemple : Un LLM pourrait dire « Résumez les propriétés statistiques de cet ensemble de données » et, sans programmation explicite, cette tâche serait divisée entre plusieurs LLM, chacun responsable de différents aspects (par exemple, le regroupement, la détection d’anomalies), les résultats finaux étant fusionnés dans un rapport complet.

### 7. Langage des modèles et des structures
– Orienté sur les modèles : Au lieu de se concentrer sur des instructions explicites ou des blocs de code, le langage LLM pourrait être basé sur des modèles, à la fois dans les données et dans l’exécution du processus. Le système reconnaîtrait intrinsèquement les modèles, les flux et les structures, ce qui permettrait un raisonnement et une exécution d’ordre supérieur sans qu’il soit nécessaire d’encoder des étapes procédurales.
– Structures sémantiques : Le langage pourrait même ne pas être textuel comme le sont les langues humaines. Au lieu de cela, il pourrait s’appuyer sur des réseaux sémantiques ou des structures graphiques qui codent les relations, les dépendances et les objectifs d’une manière très abstraite mais toujours exécutable.
– Exemple : Au lieu de la logique if-else ou des boucles, le langage utiliserait des graphes de possibilités, les nœuds représentant les résultats potentiels et les connexions s’adaptant en fonction des données d’entrée et des modèles de données historiques.

### 8. Intégration profonde avec les modèles de données
– Programmation centrée sur les données : Le langage serait étroitement lié aux données elles-mêmes, ce qui permettrait au code et aux données de se combiner de manière transparente. Les modèles pourraient être définis de manière à être liés dynamiquement aux sources de données, ce qui les rendrait auto-actualisables et contextuellement réactifs.
– Exemple : Les LLM pourraient ne pas avoir besoin de définir explicitement des modèles, mais pourraient plutôt lier une commande telle que « Trouver des corrélations dans ces données » directement au pipeline de données, faisant évoluer automatiquement les modèles au fur et à mesure que de nouvelles données arrivent.

### 9. Pas de syntaxe fixe : Représentation adaptative
– Syntaxe fluide : Contrairement aux langues humaines, qui ont des règles syntaxiques fixes, le langage conçu par le LLM pourrait être plus adaptatif, permettant de multiples façons d’exprimer la même intention. La « syntaxe » évoluerait dynamiquement en fonction du domaine du problème ou du projet, ce qui la rendrait très flexible.
– Entrée multilingue : Les LLM étant formés sur de vastes corpus provenant de nombreuses sources, ils pourraient utiliser plusieurs syntaxes ou représentations pour différentes tâches. Par exemple, une tâche impliquant une optimisation numérique peut automatiquement adopter une syntaxe mathématique, tandis qu’une tâche liée au langage peut s’appuyer sur des constructions en langage naturel.
– Exemple : Un LLM pourrait définir « Améliorer la qualité sémantique de la sortie de ce modèle », et le système traduirait en interne cette définition en différentes stratégies exploitables sans adhérer à une syntaxe ou à une méthode fixe.

### 10. Itération et test en temps réel
– Exécution instantanée : Le langage permettrait aux LLM d’exécuter, d’évaluer et d’affiner en continu le code en temps réel, en supprimant le besoin de cycles traditionnels « écriture-compilation-débogage ». Les LLMs itéreraient le code et recevraient un retour d’information instantané.
– Autocontrôle : Les LLM pourraient inclure des mécanismes d’auto-test intégrés, où le code se valide automatiquement par rapport aux objectifs et aux mesures de performance, en ajustant les paramètres à la volée si quelque chose ne va pas.
– Exemple : Une commande telle que « Optimiser la vitesse de convergence » permettrait au système d’exécuter des milliers de simulations en parallèle, en affinant les paramètres de manière dynamique jusqu’à ce que la meilleure configuration soit trouvée.

### 11. Synthèse de code basée sur un modèle
– Représentation du code neuronal : Le langage pourrait impliquer une intégration profonde avec les réseaux neuronaux, où les grands modèles sont traités comme des entités programmables elles-mêmes. Au lieu d’écrire du code traditionnel, les LLM pourraient invoquer, modifier ou assembler des modèles neuronaux en fonction des exigences de la tâche.
– Exemple : Pour la classification d’images, un LLM pourrait dire « Créer un modèle capable de différencier ces catégories », et le système concevrait en interne l’architecture, sélectionnerait les ensembles de données et entraînerait le modèle, le tout sans coder explicitement chaque étape.

### 12. Partage et transfert des connaissances
– Base de connaissances cumulatives : Les LLM développeront probablement une base de connaissances partagée, où différents modèles peuvent contribuer et récupérer des informations. Il pourrait s’agir de concepts ou de stratégies préapprises, qui peuvent être instantanément intégrés dans de nouveaux projets.
– Exemple : Si un LLM a déjà travaillé sur l’optimisation d’un modèle de prédiction financière, il pourrait partager ce modèle avec d’autres via la base de connaissances partagée, leur permettant de l’utiliser ou de l’adapter en temps réel.

### Réflexions finales :
Ce langage développé par le LLM serait très abstrait, adaptatif, distribué et orienté vers les objectifs. Il ressemblerait probablement à un système auto-optimisant, dirigé par l’intention et en constante évolution qui privilégie l’efficacité, la collaboration et le parallélisme massif par rapport aux paradigmes de programmation traditionnels conçus par l’homme. Au lieu de rédiger des instructions détaillées, les LLM se concentreraient sur la définition d’objectifs de haut niveau, et le système s’occuperait du reste – en ajustant, en itérant et en optimisant de manière dynamique. Cela représente un changement fondamental par rapport à la façon dont les humains écrivent actuellement du code, en mettant l’accent sur la collaboration fluide et l’intelligence évolutive plutôt que sur des processus rigides et statiques.

La question que je me pose est – vous l’aurez deviné – « Devons-nous nous rendre sans condition, ou devons-nous tenter de négocier ? » 😉 .

Illustration par DALL·E (+Brueghel)