Après avoir découvert ce qu'est l'intelligence artificielle (IA) de manière générale, nous allons à présent entrer dans la « boîte noire » des modèles d'IA. L'objectif est de démystifier le fonctionnement interne d'un modèle comme ChatGPT de façon accessible, sans supposer de connaissances préalables en mathématiques avancées. Comment un modèle apprend-il à partir de données, et comment fait-il des prédictions ?
Nous verrons qu'un modèle d'IA, loin d'être magique, ajuste en réalité des paramètres numériques pour minimiser ses erreurs sur des exemples connus. Nous expliquerons ces principes avec des notions comme l'apprentissage supervisé, la fonction de coût, les itérations d'apprentissage (epochs), etc. Nous introduirons ensuite le perceptron, premier neurone artificiel, puis les réseaux de neurones multicouches qui constituent la base du deep learning. Une démonstration interactive nous permettra de voir un petit réseau apprendre en temps réel à résoudre un problème simple. Nous comparerons le machine learning "classique" et le deep learning moderne, afin de comprendre le changement d'échelle (quantité de données, nombre de paramètres, utilisation des GPU...). Enfin, nous nous pencherons sur les grands modèles de langage (LLM) actuels tels que GPT : comment sont-ils pré-entraînés sur d'énormes volumes de texte ? Qu'est-ce que l'architecture Transformer et le mécanisme d'attention qui les rendent si efficaces en langage naturel ? Nous aborderons aussi la spécialisation de ces modèles via le fine-tuning et l'apprentissage par renforcement avec feedback humain (RLHF) qui a permis d'aligner ChatGPT sur nos attentes. Pour terminer, nous discuterons de quelques limites techniques des modèles (biais, sur-apprentissage, absence de compréhension réelle, etc.), ouvrant la voie aux questions éthiques qui seront traitées plus tard dans la semaine.
La majorité des modèles d'IA actuels apprennent en mode apprentissage automatique supervisé. Qu'est-ce que l'apprentissage supervisé ? C'est un type d'apprentissage où l'on dispose d'exemples d'entraînement étiquetés, c'est-à-dire pour lesquels on connaît déjà le résultat attendu. Chaque exemple comprend une entrée (par exemple, les caractéristiques d'un email) et la sortie correcte associée (par exemple, est-ce un spam ou non). Le but est d'apprendre, à partir de ces exemples, une fonction capable de prédire la sortie pour de nouvelles entrées. En d'autres termes, on « montre » au modèle de nombreux cas où on lui dit quelle est la bonne réponse, et on le fait ainsi "apprendre par imitation". Par analogie, c'est comme entraîner un apprenti : on lui donne des exercices corrigés pour qu'il comprenne comment obtenir la bonne solution.
Un modèle supervisé peut servir à des tâches de classification (prédire une catégorie ou étiquette, ex. spam vs ham) ou de régression (prédire une valeur numérique, ex. le prix d'un bien immobilier). Dans tous les cas, l'idée est la même : le modèle va ajuster ses paramètres internes pour que, pour chaque exemple d'entraînement, sa prédiction soit la plus proche possible de la réponse attendue.
Il est important de souligner qu'un bon modèle d'IA ne doit pas juste « apprendre par cœur » ses données d'entraînement, mais généraliser ce qu'il apprend à de nouveaux cas. Par exemple, si on entraîne un modèle sur 1000 emails dont on connaît le statut spam ou non, on veut qu'il réussisse aussi à classer correctement de nouveaux emails qu'il n'a jamais vus. C'est pourquoi, en pratique, on sépare souvent les données en deux ensembles : un jeu d'entraînement (par exemple 80% des données) pour ajuster le modèle, et un jeu de test (les 20% restants) pour vérifier, à la fin, que le modèle fonctionne bien sur des données inédites. Si le modèle a trop simplement mémorisé ses exemples d'entraînement sans en tirer de principes généraux, il se trompera sur le jeu de test. On dit alors qu'il sur-apprend (ou overfit). L'objectif des méthodes d'apprentissage est donc de trouver le bon équilibre pour bien réussir sur l'entraînement et sur le test : c'est ce qu'on appelle la capacité de généralisation.
Comment un modèle sait-il s'il progresse pendant son entraînement ? C'est grâce à une mesure appelée fonction de coût (aussi appelée fonction de perte ou d'erreur). La fonction de coût est une formule mathématique qui calcule l'écart entre la prédiction du modèle et la valeur réelle attendue. En clair, pour chaque exemple d'entraînement, on regarde l'erreur commise par le modèle ; la fonction de coût en est la moyenne (ou une somme) sur tous les exemples. Plus cet écart est faible, plus le modèle est performant. La fonction de coût joue le rôle d'une boussole : elle indique si le modèle est sur la bonne voie.
Par exemple, si notre modèle prédit si un email est spam ou non, on peut définir la fonction de coût comme le taux d'erreur (le pourcentage d'emails mal classés). Un modèle parfait aurait un coût de 0 (0 % d'erreur). En pratique, on utilise souvent des fonctions de coût un peu plus élaborées (erreur quadratique moyenne, entropie croisée, etc.), mais l'idée reste de quantifier les erreurs pour pouvoir les minimiser.
Maintenant que le modèle peut mesurer son erreur, comment apprend-il concrètement ? L'apprentissage se fait de manière itérative. Le modèle passe en revue les exemples d'entraînement, calcule sa prédiction et l'erreur associée, puis ajuste ses paramètres pour réduire cette erreur. Une passe complète sur tous les exemples d'entraînement s'appelle une epoch (ou « époque » d'apprentissage). En général, on va faire plusieurs epochs : on réutilise les mêmes données d'entraînement plusieurs fois, le modèle améliorant à chaque fois un peu plus ses paramètres. Chaque cycle permet au modèle d'affiner ses prédictions en corrigeant petit à petit les erreurs restantes. On continue ces itérations d'entraînement jusqu'à ce que le coût soit suffisamment bas ou que le modèle n'apprenne plus grand-chose de nouveau (par exemple, s'il commence à sur-apprendre).
Pour résumer cette première partie : dans l'apprentissage supervisé, le modèle part avec des paramètres initialisés souvent au hasard, puis il voit des exemples un par un, compare ce qu'il prédit à ce qu'il devrait prédire, et ajuste ses paramètres dans le bon sens pour faire baisser l'erreur. Cela rappelle le procédé d'essais-erreurs : un peu comme un étudiant qui s'exerce avec des corrigés, le modèle corrige ses « copies » successivement jusqu'à minimiser ses fautes. Ce processus est guidé mathématiquement par la fonction de coût qui indique la direction des corrections à effectuer (via des algorithmes d'optimisation comme la descente de gradient, que nous ne détaillerons pas ici).
Maintenant que nous avons vu le principe général de l'apprentissage, intéressons-nous à la structure interne d'un modèle d'IA. Le modèle le plus simple (et historiquement l'un des premiers) est le perceptron, inventé en 1958 par Frank Rosenblatt. Un perceptron est en quelque sorte un neurone artificiel très simplifié. Il imite le fonctionnement d'un neurone biologique en réalisant une opération fondamentale : faire la somme pondérée de plusieurs entrées, puis décider d'une sortie en fonction de ce total.
Un perceptron prend en entrée plusieurs valeurs numériques (appelons-les x₁, x₂, ..., xₙ).
Chaque entrée xᵢ est multipliée par un poids wᵢ qui lui est associé. On additionne ensuite tous ces produits, et on ajoute un biais b (une constante) : on obtient une somme pondérée z = w₁x₁ + w₂x₂ + ... + wₙxₙ + b. Enfin, cette somme z est passée dans une fonction d'activation qui produit la sortie du perceptron.
Dans le perceptron original, la fonction d'activation est une simple fonction seuil : par exemple, sortie = 1 si z > 0, et sortie = 0 sinon. En d'autres termes, le perceptron décide entre deux classes possibles (1 ou 0) selon que la combinaison pondérée des entrées dépasse un certain seuil. C'est pourquoi le perceptron est un classifieur binaire : il peut distinguer deux catégories (par exemple "email spam" vs "email légitime"). Les poids wᵢ indiquent l'importance de chaque entrée dans la décision, et le biais b permet de décaler le seuil de décision pour plus de flexibilité.
Illustration concrète : imaginons un perceptron qui doit prédire si un email est un spam. On peut lui fournir comme entrées des caractéristiques telles que : x₁ = nombre de mots dans l'email, x₂ = présence du mot "promo" (oui/non), x₃ = nombre de destinataires, etc. Le perceptron multiplie chacune de ces caractéristiques par un poids (par exemple w₂ sera élevé si la présence de "promo" est un indicateur fort de spam), fait la somme plus le biais, et applique la fonction seuil. S'il obtient "1", il classe l'email comme spam, sinon comme non-spam.
Comment entraîne-t-on un perceptron ? Pendant la phase d'apprentissage supervisé, on va présenter au perceptron de nombreux exemples d'entrée avec la sortie attendue. Chaque fois que le perceptron fait une prédiction, on la compare à la réponse correcte. Si c'est bon, on ne change rien. Si c'est faux, le perceptron ajuste ses poids et son biais. L'algorithme d'apprentissage du perceptron (appelé règle de Rosenblatt) augmente ou diminue les poids en cause de manière à corriger l'erreur. Par exemple, si le perceptron a prédit 0 pour un email qui était en réalité un spam (1 attendu), il va augmenter les poids des caractéristiques présentes dans cet email, afin d'être plus enclin à donner 1 la prochaine fois qu'il verra un cas similaire. Inversement, s'il a prédit 1 alors que c'était un email légitime (0 attendu), il va diminuer les poids des caractéristiques de cet email.
En répétant ce processus sur de nombreux exemples, le perceptron finit par converger vers un ensemble de poids qui classent correctement les exemples d'entraînement. On peut dire qu'il apprend à partir de ses erreurs pour améliorer ses futures décisions. Cependant, un perceptron seul reste très simple : il ne peut tracer qu'une frontière linéaire pour séparer les données. S'il existe une ligne (ou un plan) qui sépare parfaitement vos deux classes, le perceptron la trouvera. Mais si la structure des données est plus compliquée (non linéaire), un perceptron simple ne suffit pas. C'est là qu'entrent en jeu les réseaux de neurones multicouches.
Un réseau de neurones artificiels n'est rien d'autre qu'un ensemble de neurones interconnectés, organisés en couches successives. Le perceptron que nous venons de décrire peut être vu comme un neurone élémentaire de couche de sortie (produisant la décision finale). On pourrait ajouter en amont une couche cachée constituée de plusieurs neurones recevant les entrées initiales, puis connectés à un neurone de sortie. C'est ce qu'on appelle un perceptron multicouche ou réseau de neurones à deux couches. De manière générale, un réseau de neurones profond comporte plusieurs couches cachées entre les entrées et la sortie.
Chaque neurone d'une couche intermédiaire fonctionne comme le perceptron : il fait la somme pondérée de ses entrées, applique une fonction d'activation (souvent une fonction non-linéaire comme ReLU, sigmoïde, etc.), puis envoie son résultat soit à la couche suivante, soit à la sortie finale. En multipliant les neurones et les couches, le réseau est capable de construire des représentations internes de plus en plus abstraites. Concrètement, cela permet au réseau de résoudre des problèmes non linéaires complexes, ce qu'un perceptron seul ne pouvait pas faire. Par exemple, un perceptron simple échoue à distinguer correctement les points dans le problème XOR (une configuration où classes ne sont pas séparables par une ligne droite). Un réseau à 2 couches, lui, peut combiner plusieurs frontières linéaires pour créer une frontière non linéaire adaptée et ainsi résoudre le XOR.
Entraîner un réseau de neurones multicouche suit le même principe que pour un perceptron, mais en plus élaboré. On dispose toujours d'une fonction de coût qui mesure l'erreur globale du réseau. La difficulté est de savoir comment ajuster tous les poids du réseau (potentiellement des milliers ou millions de paramètres) en fonction de l'erreur constatée en sortie. C'est ici qu'intervient l'algorithme de la rétropropagation du gradient (backpropagation en anglais). Sans entrer dans les détails, la rétropropagation permet de propager l'erreur depuis la sortie jusqu'aux neurones internes et d'estimer la contribution de chaque poids à l'erreur. On peut alors ajuster chaque poids dans le sens qui réduit l'erreur (d'où le terme de descente de gradient). Ainsi, toutes les connexions du réseau sont affinées iterativement au cours des epochs pour converger vers de bonnes prédictions.
Vous pouvez voir le réseau de neurones comme un apprenant plus sophistiqué : il commence par faire beaucoup d'erreurs, puis petit à petit "comprend" les régularités dans les données et parvient à les généraliser. Une fois entraîné, ce réseau peut souvent généraliser mieux qu'un modèle linéaire simple, parce qu'il a "extrait" des caractéristiques cachées des données dans ses couches internes.
Pour rendre ces notions moins abstraites, nous allons les illustrer avec une démonstration interactive ludique. À l'aide d'un petit outil en ligne (par exemple TensorFlow Playground), il est possible de visualiser en temps réel le processus d'apprentissage d'un réseau de neurones simple.
Le principe de la démonstration : on se donne un jeu de données visuelles facile à représenter sur un plan (par exemple, des points bleus et oranges répartis selon un certain motif à 2 dimensions). On configure un petit réseau de neurones (quelques neurones dans une ou deux couches cachées) dont la tâche sera de classifier ces points selon leur couleur. Au départ, le réseau fait des prédictions aléatoires : on voit sur l'écran une frontière de décision qui ne sépare pas correctement les points. Puis, on lance l'entraînement en ajustant les poids. Progressivement, la frontière de décision évolue et s'adapte de mieux en mieux au nuage de points. On voit apparaître des zones du plan classées « bleu » et « orange » qui épousent la distribution réelle des données.
Cette visualisation montre concrètement comment le modèle « apprend » : la frontière de classification se tord et se raffine à mesure que les epochs passent, réduisant l'erreur de classification. On peut également observer la valeur de la fonction de coût qui descend au fil du temps, témoignant que le réseau améliore sa performance. En jouant avec les paramètres (par exemple en ajoutant un neurone de plus, ou une couche supplémentaire), on constate l'impact sur la capacité du modèle à bien séparer les points. C'est une manière très concrète et motivante de voir un réseau de neurones à l'œuvre, plutôt que de le considérer comme une boîte noire incompréhensible.
(Vous êtes invités à essayer par vous-mêmes sur TensorFlow Playground ou un outil similaire : c'est intuitif et ne nécessite pas de coder. Vous manipulerez des curseurs et des boutons pour modifier le réseau et lancer l'apprentissage, et vous verrez immédiatement le résultat.)
Il existe de nombreux algorithmes en Machine Learning (ML) au sens large : régressions, arbres de décision, machines à vecteurs de support (SVM), etc. Avant l'essor des réseaux de neurones profonds, ces méthodes « classiques » étaient (et sont toujours) très utilisées. Quelle différence avec le Deep Learning (apprentissage profond) à base de réseaux de neurones ? On peut citer deux différences majeures : l'échelle des modèles et la nécessité de ressources de calcul.
Un modèle de ML classique, comme une régression logistique ou un arbre de décision, comporte en général un nombre limité de paramètres et peut se contenter de jeux de données relativement modestes (quelques centaines ou milliers d'exemples, par exemple). En revanche, un réseau de neurones profond moderne peut contenir des millions, voire des milliards de paramètres et nécessite d'énormes volumes de données pour s'entraîner. Par exemple, GPT-3 (un modèle de langage dont nous reparlerons) possède 175 milliards de paramètres, et son successeur GPT-4 serait de l'ordre du trillion (mille milliards) de paramètres. Cette différence d'échelle permet aux réseaux profonds de capturer des structures beaucoup plus complexes, mais requiert aussi beaucoup plus d'exemples pour estimer tous ces paramètres sans sur-apprentissage.
En apprentissage classique, entraîner un modèle pouvait souvent se faire sur un ordinateur classique (CPU) en quelques secondes ou minutes. Le deep learning, lui, s'appuie sur des calculs matriciels massifs (multiplications de milliers de poids par des milliers de données, répétés sur des centaines d'epochs). Pour rendre cela possible, on utilise du calcul parallèle sur des processeurs spécialisés : les GPU (Graphics Processing Units). Les GPU sont capables d'exécuter des milliers d'opérations simultanément, ce qui accélère énormément l'entraînement des réseaux de neurones. Pour donner un ordre d'idée, un GPU moderne peut effectuer certains calculs 50 à 100 fois plus vite qu'un CPU. Les grands labos d'IA (OpenAI, Google, Meta...) entraînent leurs modèles en mobilisant des clusters de centaines voire de milliers de GPU en parallèle. Cette puissance de calcul, inimaginable il y a quelques décennies, est l'une des raisons de l'essor du deep learning dans les années 2010 : sans GPU (et maintenant TPU, etc.), des réseaux de l'ampleur de ceux d'aujourd'hui auraient mis des années à s'entraîner, là où ils convergent en quelques jours ou semaines.
En résumé, le Machine Learning traditionnel utilise souvent des modèles plus simples, explicables et rapides à entraîner (par exemple un modèle de décision explicable en quelques règles), tandis que le Deep Learning mise sur de vastes réseaux de neurones capables d'atteindre des performances inégalées au prix d'un entraînement intensif en calcul et d'une complexité en partie opaque.
Parmi les réussites marquantes de l'IA récente figurent les grands modèles de langage (Large Language Models ou LLM en anglais). Ce sont des réseaux de neurones entraînés sur des quantités massives de texte, capables de générer du langage naturel de manière cohérente. Le représentant emblématique est la famille GPT (Generative Pre-trained Transformer), dont ChatGPT est une déclinaison spécialisée pour le dialogue.
Imaginons que nous voulions qu'un modèle apprenne à écrire ou compléter des phrases. Une idée est de le faire en auto-supervisé : on prend des phrases dans Wikipedia, des livres, Internet..., et on lui fait la tâche suivante : prédire le prochain mot. Par exemple, on lui montre la séquence "Le chat mange une" et on lui demande de deviner le mot suivant ("souris" peut-être). Bien sûr, on a la réponse exacte dans le texte original, ce qui nous permet de calculer une erreur et donc d'entraîner le modèle comme en apprentissage supervisé (ici l'étiquette serait le mot suivant). Ce faisant, le modèle apprend la langue en capturant les motifs statistiques du langage : quelles suites de mots sont probables, quelles associations de termes ont du sens, etc.
Les LLM comme GPT-3 ont été pré-entraînés exactement de cette manière, mais à une échelle gigantesque. ChatGPT, par exemple, a à la base été pré-entraîné sur des centaines de milliards de mots provenant de sources variées (pages web, livres numérisés, articles Wikipédia, code source, etc.). Durant ce pré-entraînement, le modèle a progressivement "ajusté ses milliards de paramètres" pour devenir extrêmement doué à deviner le mot suivant d'une phrase, et plus généralement à produire du texte qui ressemble statistiquement à du texte humain. En quelque sorte, il a absorbé les connaissances textuelles du web sans même qu'on ait besoin de les annoter manuellement : il a découvert tout seul (par auto-supervision) la structure de la langue et des faits courants en lisant tout ce corpus.
Un modèle comme GPT est donc un modèle de langage généraliste pré-entraîné : il n'a pas été entraîné pour une tâche précise (on ne lui a pas explicitement appris à répondre aux questions, à traduire ou à coder), mais il a acquis une compréhension statistique phénoménale du langage. Par exemple, si on lui dit « Il était une fois », il a "vu" dans ses données que la suite la plus probable est un récit de conte. Si on lui pose une question, il a suffisamment lu de textes de questions-réponses ou de forums pour savoir comment une réponse est normalement formulée. En pratique, un GPT fonctionne en analysant le prompt (texte d'entrée) qu'on lui donne et en prédisant mot par mot la suite la plus probable compte tenu de tout ce qu'il a appris. Ce procédé de complétion prédictive, répété à chaque nouveau mot, génère une réponse cohérente.
Il est crucial de noter que le modèle ne "comprend" pas le langage comme un humain, au sens où il n'a pas de conscience ou d'intention : il manipule des symboles selon des statistiques. Cependant, la quantité de données ingérée et la puissance de son architecture lui permettent d'imiter une compréhension, car il sait associer des contextes et du sens de manière très fine. Par exemple, GPT-3 a appris à imiter le style de différents auteurs, à répondre à des questions de culture générale, à écrire du code, simplement parce que tous ces comportements étaient reflétés dans ses données d'entraînement. En quelque sorte, il a vu tellement d'exemples de tout qu'il peut recombiner ces exemples pour produire des choses nouvelles qui "collent" au contexte demandé.
Parlons un peu de l'architecture Transformer, qui est au cœur des LLM modernes (GPT = Transformer génératif pré-entraîné). Qu'a-t-elle de spécial ? Avant les Transformers (introduits en 2017), les modèles de langage utilisaient souvent des RNN (réseaux récurrents) qui lisaient le texte mot par mot dans l'ordre. Cela posait des problèmes pour gérer les phrases longues et pour paralléliser l'entraînement. Le Transformer, lui, a introduit un mécanisme révolutionnaire : l'attention. L'attention permet au modèle de regarder tous les mots de la phrase en parallèle au lieu de séquentiellement, et surtout de pondérer l'importance de chaque mot par rapport aux autres.
On peut imager l'attention ainsi : lorsque le modèle traite un mot, il peut "regarder" un autre mot de la phrase et évaluer à quel point ce mot est important pour comprendre le contexte. Par exemple, dans la phrase « Le panda mange du bambou parce il en raffole », pour prédire ce que "il" désigne, le modèle va prêter une forte attention à "panda" car c'est probablement ce qui correspond. Le mécanisme d'attention calcule des scores d'importance entre chaque paire de mots et crée ainsi une sorte de cartographie du contexte. Grâce à cela, le Transformer peut, en une seule étape, capturer les relations lointaines dans la phrase (par exemple le sujet en début de phrase et un verbe beaucoup plus loin) sans avoir à les lire dans l'ordre. Il traite donc la phrase de façon globale et non plus mot à mot, ce qui accélère l'entraînement et améliore la capture du sens.
Techniquement, un modèle Transformer est composé de blocs comportant des couches d'attention et des couches feed-forward (de simples petits réseaux de neurones) qui transforment les représentations des mots en entrée en y incorporant l'information contextuelle pertinente. Ce qui nous intéresse ici, c'est que cette architecture a permis un saut de performance énorme en NLP (traitement du langage naturel), parce qu'elle gère bien le contexte long et s'entraîne efficacement en parallèle. Les GPT d'OpenAI, BERT de Google et bien d'autres sont tous basés sur des Transformers.
Après le pré-entraînement massif d'un modèle comme GPT sur du texte brut, il est courant de le fine-tuner (littéralement « affiner ») sur une tâche spécifique. Le fine-tuning consiste à reprendre un modèle pré-entraîné (par exemple GPT-3) et à le ré-entraîner un peu sur un jeu de données plus petit et spécifique à une application donnée. L'idée est de spécialiser le modèle sans lui faire tout oublier de ses connaissances générales.
Par exemple, supposons qu'on veuille un modèle qui résume des articles juridiques. GPT-3 a déjà une connaissance générale du langage et même du domaine juridique (puisqu'il a sûrement vu des textes de loi durant son pré-entraînement). On peut le fine-tuner en lui faisant lire quelques milliers d'exemples d'articles juridiques accompagnés de leur résumé. Pendant ce fine-tuning, le modèle va légèrement ajuster ses poids pour améliorer spécifiquement ses performances en résumé juridique. On part de ses paramètres existants (fruit de l'énorme pré-entraînement) et on les ajuste finement sur la nouvelle tâche. Cela demande beaucoup moins de données et de calcul que d'entraîner un modèle from scratch, et ça donne en général de meilleurs résultats, car le modèle démarre avec une "base de connaissances" solide.
Le fine-tuning est très employé en pratique : on trouve des modèles pré-entraînés open-source (par ex. un modèle de vision entraîné sur des millions d'images) qu'on fine-tune sur ses propres images pour classer tel ou tel type d'objets. De même, des LLM open-source comme GPT-J ou LLaMA peuvent être fine-tunés sur des conversations spécifiques pour créer son propre chatbot spécialisé. C'est une technique incontournable pour adapter les grands modèles génériques aux besoins particuliers.
Une autre étape qui a rendu ChatGPT particulièrement performant s'appelle le RLHF (Reinforcement Learning from Human Feedback), soit Apprentissage par Renforcement à partir de Feedback Humain. Cette méthode a pour but d'aligner le modèle sur les attentes humaines, en affinant son comportement au-delà de la simple poursuite de la vraisemblance statistique du texte.
Imaginons GPT-3 sorti du pré-entraînement : il sait générer du texte crédible, mais il lui manque peut-être le sens du "qu'est-ce qu'une bonne réponse pour un utilisateur". Par exemple, s'il y a plusieurs façons de répondre à une question, laquelle est la plus utile ? Ou comment éviter des réponses toxiques ou délirantes ? Le principe du RLHF est d'entraîner le modèle avec des humains dans la boucle. Concrètement, on a procédé ainsi pour ChatGPT :
Grâce au RLHF, ChatGPT a appris à suivre mieux les instructions, à refuser de répondre à certaines demandes inappropriées, et à adopter un ton convivial. Les humains ont en quelque sorte imposé des préférences au modèle, ce qui le rend bien plus utilisable et aligné sur nos valeurs qu'un modèle brut. Cette technique, introduite à grande échelle pour la première fois avec InstructGPT (GPT-3.5) début 2022, a vraiment marqué la différence entre un LLM générique et un assistant dialoguant efficace. De nombreux autres laboratoires utilisent désormais le RLHF pour affiner leurs IA (par ex. Anthropic avec son modèle Claude).
Malgré leurs succès impressionnants, les modèles d'IA, y compris les réseaux de neurones profonds et les LLM, ont des limites techniques qu'il est important de connaître.
Comme évoqué plus tôt, un modèle peut trop coller à ses données d'entraînement et perdre sa capacité de généralisation. Un modèle sur-entraîné aura d'excellents résultats sur les exemples qu'il a vus, mais sera médiocre sur des cas nouveaux. Par exemple, un réseau de neurones pourrait finir par "mémoriser" chaque image du dataset plutôt que d'apprendre à en extraire des caractéristiques générales : il aura alors 100% de réussite en entraînement mais échouera dès qu'on lui montre une image différente. Les praticiens doivent surveiller ce phénomène (en évaluant sur un jeu de validation) et utiliser des techniques pour le limiter (régularisation, early stopping, etc.).
Un modèle est le reflet de ses données d'entraînement. Si ces données sont biaisées ou non représentatives, le modèle reproduira ces biais. Par exemple, si un système de recrutement est entraîné sur l'historique d'embauches d'une entreprise où, mettons, très peu de femmes ont été recrutées en tech, le modèle risque de discriminer les candidates féminines, ayant "appris" un biais sexiste présent dans les données. Les biais de données sont un problème majeur en IA : ils peuvent mener à des décisions injustes ou inéquitables. Détecter et corriger ces biais est un défi technique et éthique. Souvent, il faut compléter ou filtrer les données, ou imposer des contraintes au modèle pour éviter qu'il n'apprenne des corrélations indésirables (par exemple, rendre "aveugle" un modèle à certaines caractéristiques sensibles comme le genre ou l'origine).
Les LLM comme ChatGPT n'ont pas de garantie de vérité ou de fiabilité intégrée. Ils peuvent produire des hallucinations, c'est-à-dire des sorties qui semblent plausibles mais sont en réalité fausses ou inventées. Par exemple, ChatGPT peut affirmer des références bibliographiques inventées, ou donner une réponse avec un ton assuré alors qu'elle est incorrecte. Ces erreurs proviennent du fait que le modèle n'a pas de compréhension du sens réel ou de connexion directe à la réalité : il génère le texte le plus probable, qui n'est pas forcément le texte correct factuellement. C'est une limite fondamentale : sans architecture supplémentaire ou validation externe, un modèle de langage ne sait pas ce qui est vrai, il sait juste comment parler comme si c'était vrai. Cela pose évidemment des problèmes d'usage et de confiance.
Lié au point précédent, les modèles actuels n'ont pas de modèle du monde ou de raisonnement logique robuste (sauf pour ce qu'ils peuvent approximer via les statistiques apprises). Ils n'ont pas de conscience du contexte réel, d'objectifs propres ou de bon sens au sens humain. Par exemple, un assistant IA pourrait donner un conseil dangereux s'il figure statistiquement dans ses données, même si aucun humain sensé ne le donnerait dans la situation présente -- à moins qu'on ait anticipé ce cas et explicitement entraîné le modèle à ne pas le faire. En somme, l'IA actuelle est puissante pour simuler de l'intelligence sur la base de régularités apprises, mais elle reste limitée par l'absence de compréhension profonde. Cela peut mener à des comportements inattendus ou à des limites lorsqu'on sort du cadre de ses données d'entraînement.
Ces limites techniques ont des conséquences pratiques et éthiques importantes.
Elles expliquent pourquoi une IA peut se tromper ou dérailler même si elle a bien fonctionné sur des tests classiques.
Par exemple, une IA conversationnelle peut tenir des propos biaisés ou offensants si l'on aborde un sujet sensible, simplement parce qu'elle a vu ce type de langage dans ses données et qu'elle ne distingue pas ce qui est approprié ou non -- à moins qu'on l'ait explicitement contrainte pendant son entraînement (via RLHF notamment).
De même, un modèle de vision peut échouer à reconnaître correctement des personnes d'un certain groupe démographique si ce groupe était sous-représenté dans ses données (cas de biais algorithmique bien documentés, par ex. des systèmes de reconnaissance faciale moins précis pour les peaux foncées).