Veuillez accueillir Andrej Karpathy, chercheur en IA et membre fondateur d'OpenAI.

Bonjour à tous. Je suis ravi d'être ici pour vous parler de l'état de GPT et, plus généralement, de l'écosystème en pleine croissance des grands modèles de langage.

J'aimerais diviser cet exposé en deux parties. Dans la première partie, je voudrais vous expliquer comment nous entraînons les assistants GPT. Ensuite, dans la deuxième partie, nous verrons comment nous pouvons utiliser ces assistants de manière efficace pour vos applications.

Tout d'abord, examinons la recette émergente pour l'entraînement de ces assistants, et gardez à l'esprit que tout cela est très récent et évolue encore rapidement. Jusqu'à présent, la recette ressemble à ceci.

C'est une diapositive compliquée, je vais donc l'expliquer étape par étape. Grosso modo, nous avons quatre étapes majeures : le pré-entraînement, l'ajustement fin supervisé, la modélisation de la récompense et l'apprentissage par renforcement, et elles se succèdent en série.

À chaque étape, nous avons un ensemble de données qui alimente cette étape. Nous avons un algorithme qui, pour nos besoins, sera un objectif pour l'entraînement du réseau neuronal. Ensuite, nous avons un modèle résultant et quelques notes en bas.

La première étape par laquelle nous allons commencer est l'étape de pré-entraînement. Cette étape est spéciale dans ce diagramme, et ce diagramme n'est pas à l'échelle, car c'est à cette étape que se fait pratiquement tout le travail de calcul. Cela représente 99 % du temps de calcul et des flops de l'entraînement.

C'est ici que nous traitons des ensembles de données à l'échelle d'Internet avec des milliers de GPU dans un supercalculateur et potentiellement des mois d'entraînement. Les trois autres étapes sont des étapes d'ajustement fin qui se situent bien plus dans l'ordre d'un petit nombre de GPU et d'heures ou de jours.

Jetons un coup d'œil à l'étape de pré-entraînement pour obtenir un modèle de base.

Tout d'abord, nous allons rassembler une grande quantité de données. Voici un exemple de ce que nous appelons un mélange de données, tiré de cet article publié par Meta lors de la sortie de ce modèle de base LLaMA.

Vous pouvez voir approximativement les types d'ensembles de données qui entrent dans ces collections. Nous avons CommonCrawl, qui est une capture du Web, C4, qui est aussi CommonCrawl, puis quelques ensembles de données de haute qualité également. Par exemple, GitHub, Wikipedia, des livres, ArXiv, StackExchange, et ainsi de suite.

Tout cela est mélangé puis échantillonné selon certaines proportions données, et cela constitue l'ensemble d'entraînement pour le GPT.

Avant de pouvoir réellement nous entraîner sur ces données, nous devons passer par une étape supplémentaire de prétraitement : la tokenisation. Il s'agit d'une traduction du texte brut que nous avons récupéré sur Internet en séquences d'entiers, car c'est la représentation native sur laquelle les GPT fonctionnent.

Il s'agit d'une traduction sans perte entre des morceaux de texte et des jetons et des entiers. Il existe un certain nombre d'algorithmes pour cette étape. Typiquement, vous pourriez utiliser quelque chose comme le codage par paires d'octets (byte pair encoding), qui fusionne de manière itérative de petits morceaux de texte et les regroupe en jetons.

Ici, je montre quelques exemples de morceaux de ces jetons et la séquence d'entiers brute que nous allons réellement fournir à un transformateur.

Ici, je montre deux exemples d'hyperparamètres qui régissent cette étape. Pour GPT-4, nous n'avons pas publié beaucoup d'informations sur la façon dont il a été entraîné, j'utilise donc les chiffres de GPT-3, bien que GPT-3 ait environ trois ans maintenant. LLaMA est un modèle assez récent de Meta.

Voici en gros les ordres de grandeur auxquels nous avons affaire lors du pré-entraînement. La taille du vocabulaire est généralement de quelques dizaines de milliers de jetons. La longueur du contexte est généralement de l'ordre de 2 000, 4 000 ou, de nos jours, même 100 000. Cela régit le nombre maximum d'entiers que le GPT examinera lorsqu'il tentera de prédire l'entier suivant dans une séquence.

Vous pouvez voir que le nombre de paramètres est de 65 milliards pour LLaMA. Même si LLaMA n'a que 65 milliards de paramètres par rapport aux 175 milliards de paramètres de GPT-3, LLaMA est un modèle nettement plus puissant. Intuitivement, c'est parce que le modèle est entraîné beaucoup plus longtemps — dans ce cas, 1,4 billion de jetons au lieu de 300 milliards de jetons. Vous ne devriez pas juger la puissance d'un modèle uniquement par le nombre de paramètres qu'il contient.

Ci-dessous, je montre quelques tableaux d'hyperparamètres qui servent généralement à spécifier le réseau neuronal transformateur : le nombre de têtes, la taille de la dimension, le nombre de couches, et ainsi de suite. En bas, je montre quelques hyperparamètres d'entraînement.

Pour entraîner le modèle 65B, Meta a utilisé 2 000 GPU, environ 21 jours d'entraînement et environ plusieurs millions de dollars. Ce sont les ordres de grandeur approximatifs que vous devriez avoir à l'esprit pour l'étape de pré-entraînement.

Lors du pré-entraînement, nous allons prendre nos jetons et les disposer en lots de données (batches). Nous avons ces tableaux que nous allons fournir au transformateur, et ces tableaux sont B, la taille du lot, et ce sont tous des exemples indépendants empilés en lignes.

B par T, T étant la longueur maximale du contexte. Dans mon illustration, je n'en ai que 10, mais c'est la longueur du contexte, donc cela pourrait être 2 000, 4 000, etc. Ce sont des lignes extrêmement longues. Nous prenons ces documents, nous les emballons dans des lignes et nous les délimitons avec ces jetons spéciaux de fin de texte, indiquant en gros au transformateur où commence un nouveau document.

Ici, j'ai quelques exemples de documents et je les ai étirés dans cette entrée.

Nous allons injecter tous ces nombres dans le transformateur. Permettez-moi de me concentrer sur une seule cellule, mais la même chose se produira pour chaque cellule de ce diagramme. Regardons la cellule verte.

La cellule verte va examiner tous les jetons qui la précèdent — tous les jetons en jaune — et nous allons injecter tout ce contexte dans le réseau neuronal transformateur. Le transformateur va essayer de prédire le jeton suivant dans une séquence, dans ce cas en rouge.

Le transformateur n'est qu'un gros amas de composants de réseau neuronal pour nos besoins et il possède généralement plusieurs dizaines de milliards de paramètres. À mesure que vous ajustez ces paramètres, vous obtenez des distributions prédites légèrement différentes pour chacune de ces cellules.

Si la taille de notre vocabulaire est de 50 257 jetons, alors nous allons avoir autant de nombres because nous devons spécifier une distribution de probabilité pour ce qui vient ensuite. En gros, nous avons une probabilité pour tout ce qui peut suivre.

Dans cet exemple spécifique pour cette cellule, 513 viendra ensuite, et nous pouvons donc utiliser cela comme source de supervision pour mettre à jour les poids de notre transformateur. Nous appliquons cela fondamentalement sur chaque cellule en parallèle et nous continuons à échanger des lots et à essayer d'amener le transformateur à faire les prédictions correctes sur le jeton qui suit dans une séquence.

Laissez-moi vous montrer plus concrètement à quoi cela ressemble quand on entraîne l'un de ces modèles. Cela vient du New York Times, et ils ont entraîné un petit GPT sur du Shakespeare. Voici un petit extrait de Shakespeare et ils ont entraîné un GPT dessus.

Au début, lors de l'initialisation, le GPT commence avec des poids complètement aléatoires, donc vous obtenez des résultats complètement aléatoires. Au fil du temps, à mesure que vous entraînez le GPT plus longtemps, vous obtenez des échantillons plus cohérents et constants du modèle.

La façon dont vous échantillonnez est la suivante : vous prédisez ce qui vient ensuite, vous échantillonnez à partir de cette distribution et vous réinjectez cela dans le processus. Vous pouvez ainsi échantillonner de longues séquences. À la fin, vous voyez que le transformateur a appris les mots, où mettre des espaces et des virgules, et ainsi de suite. Nous faisons des prédictions de plus en plus cohérentes au fil du temps.

Voici le genre de graphiques que vous examinez lors du pré-entraînement d'un modèle. En fait, nous regardons la fonction de perte (loss) au fil du temps pendant l'entraînement, et une perte faible signifie que notre transformateur donne une probabilité plus élevée au jeton entier correct suivant dans une séquence.

Qu'allons-nous faire de ce modèle une fois entraîné ? La première chose que le domaine a remarquée est que ces modèles apprennent des représentations générales très puissantes, et qu'il est possible de les ajuster très efficacement pour n'importe quelle tâche en aval arbitraire qui pourrait vous intéresser.

Par exemple, si vous vous intéressez à la classification de sentiments, l'approche habituelle consistait à collecter un tas de positifs et de négatifs, puis à entraîner un modèle de TAL (NLP) pour cela. La nouvelle approche est : ignorez la classification de sentiments, faites un pré-entraînement de grand modèle de langage, entraînez un grand transformateur, puis vous n'aurez peut-être besoin que de quelques exemples pour ajuster très efficacement votre modèle pour cette tâche.

Cela fonctionne très bien en pratique. La raison en est que le transformateur est forcé de réaliser une multitude de tâches simultanément dans la tâche de modélisation du langage car, rien qu'en termes de prédiction du jeton suivant, il est obligé de comprendre beaucoup de choses sur la structure du texte et tous les différents concepts qu'il contient.

C'était GPT-1. Vers l'époque de GPT-2, on a remarqué que, mieux encore que l'ajustement fin, on peut en fait solliciter ces modèles très efficacement. Ce sont des modèles de langage et ils veulent compléter des documents. Vous pouvez en fait les inciter à accomplir des tâches simplement en organisant ces faux documents.

Dans cet exemple, nous avons un passage, puis nous faisons QA, QA, QA. C'est ce qu'on appelle le prompting en quelques exemples (few-shot prompting). Ensuite, nous posons Q, et comme le transformateur essaie de compléter le document, il répond en fait à notre question. C'est un exemple d'ingénierie d'incitation (prompt engineering) sur un modèle de base, en lui faisant croire qu'il imite un document pour lui faire accomplir une tâche.

C'est ainsi qu'a commencé l'ère du prompting plutôt que de l'ajustement fin, montrant que cela peut réellement fonctionner extrêmement bien sur de nombreux problèmes, even sans entraîner de réseaux neuronaux ni faire d'ajustement fin.

Depuis lors, nous avons vu tout un arbre généalogique de modèles de base que tout le monde a entraînés. Tous ces modèles ne sont pas disponibles. Par exemple, le modèle de base de GPT-4 n'a jamais été publié. Le modèle GPT-4 avec lequel vous interagissez via l'API n'est pas un modèle de base ; c'est un modèle assistant, et nous allons voir comment les obtenir dans un instant.

Le modèle de base GPT-3 est disponible via l'API sous le nom DaVinci, et le modèle de base GPT-2 est disponible même sous forme de poids sur notre dépôt GitHub. Actuellement, le meilleur modèle de base disponible est probablement la série LLaMA de Meta, bien qu'il ne soit pas sous licence commerciale.

Une chose à souligner est que les modèles de base ne sont pas des assistants. Ils ne veulent pas répondre aux questions ; ils veulent simplement compléter des documents. Si vous leur demandez d'écrire un poème sur le pain et le fromage, ils répondront aux questions par d'autres questions. Ils ne font que compléter ce qu'ils pensent être un document.

Cependant, vous pouvez les solliciter d'une manière spécifique pour les modèles de base qui a plus de chances de fonctionner. Par exemple : voici un poème sur le pain et le fromage. Dans ce cas, il complétera correctement.

On peut même inciter des modèles de base à devenir des assistants. Pour ce faire, vous créeriez une incitation spécifique en quelques exemples qui donne l'impression d'un document entre un humain et un assistant échangeant des informations. En bas, vous mettez votre requête à la fin et le modèle de base se conditionnera pour devenir un assistant utile et répondra.

Mais ce n'est pas très fiable et cela ne fonctionne pas super bien en pratique, même si c'est faisable. Au lieu de cela, nous avons une voie différente pour créer de réels assistants GPT, et pas seulement des compléteurs de documents de type modèle de base.

Cela nous mène à l'ajustement fin supervisé (SFT). Dans l'étape d'ajustement fin supervisé, nous allons collecter des ensembles de données petits mais de haute qualité. Dans ce cas, nous allons demander à des prestataires humains de rassembler des données sous la forme d'une incitation (prompt) et d'une réponse idéale. Nous allons en collecter des dizaines de milliers.

Nous allons toujours faire de la modélisation de langage sur ces données, donc rien n'a changé sur le plan algorithmique ; nous changeons simplement l'ensemble d'entraînement. Auparavant, il s'agissait de documents Internet, de grande quantité mais de faible qualité, pour passer à des données de type incitation-réponse, de faible quantité mais de haute qualité.

Nous faisons toujours de la modélisation de langage et, après l'entraînement, nous obtenons un modèle SFT. Vous pouvez réellement déployer ces modèles et ce sont de véritables assistants qui fonctionnent dans une certaine mesure. Laissez-moi vous montrer à quoi pourrait ressembler un exemple de démonstration.

Voici quelque chose qu'un prestataire humain pourrait proposer. Voici une incitation aléatoire : pouvez-vous écrire une brève introduction sur la pertinence du terme monopsonie ou quelque chose comme ça ? Et puis le prestataire écrit également une réponse idéale.

Lorsqu'ils rédigent ces réponses, ils suivent une documentation d'étiquetage exhaustive et on leur demande d'être utiles, véridiques et inoffensifs. Ces instructions d'étiquetage sont longues et il s'agit simplement de personnes suivant des instructions et essayant de compléter ces incitations.

C'est à cela que ressemble l'ensemble de données et vous pouvez entraîner ces modèles, ce qui fonctionne dans une certaine mesure.

Vous pouvez en fait poursuivre le processus à partir de là et passer au RLHF, l'apprentissage par renforcement à partir de rétroactions humaines, qui consiste à la fois en une modélisation de la récompense et un apprentissage par renforcement.

Laissez-moi aborder cela, puis je reviendrai sur les raisons pour lesquelles vous pourriez vouloir passer par ces étapes supplémentaires et comment cela se compare aux simples modèles SFT. Dans l'étape de modélisation de la récompense, ce que nous allons faire, c'est orienter notre collecte de données vers des comparaisons.

Voici un exemple de ce à quoi ressemblera notre ensemble de données. J'ai la même incitation en haut, demandant à l'assistant d'écrire un programme ou une fonction qui vérifie si une chaîne de caractères donnée est un palindrome.

Ensuite, ce que nous faisons, c'est prendre le modèle SFT, que nous avons déjà entraîné, et nous créons plusieurs complétions. Dans ce cas, nous avons trois complétions créées par le modèle. Ensuite, nous demandons à des personnes de classer ces complétions.

Ce sont des choses très difficiles à faire que de comparer certaines de ces prédictions et cela peut prendre des heures pour une seule paire incitation-complétion, mais disons que nous avons décidé que l'une d'elles est bien meilleure que les autres et nous les classons.

Ensuite, we pouvons faire suivre cela de quelque chose qui ressemble à une classification binaire sur toutes les paires possibles entre ces complétions. Ce que nous faisons maintenant, c'est disposer notre incitation en lignes, l'incitation étant identique sur les trois lignes ici, mais les complétions varient.

Les jetons jaunes proviennent du modèle SFT. Ensuite, nous ajoutons un autre jeton spécial de lecture de récompense à la fin et nous ne supervisons pratiquement le transformateur que sur ce seul jeton vert. Le transformateur prédira une certaine récompense pour la qualité de cette complétion pour cette incitation.

En gros, il fait une estimation sur la qualité de chaque complétion et une fois qu'il a fait une estimation pour chacune d'elles, nous avons aussi la vérité terrain, qui nous donne le classement. Nous pouvons imposer que certains de ces nombres soient beaucoup plus élevés que d'autres.

Nous formulons cela dans une fonction de perte et nous entraînons notre modèle à faire des prédictions de récompense cohérentes avec la vérité terrain provenant des comparaisons de tous ces prestataires. C'est ainsi que nous entraînons un modèle de récompense, ce qui nous permet de noter la qualité d'une complétion pour une incitation donnée.

Une fois que nous avons un modèle de récompense, nous ne pouvons pas le déployer car il n'est pas utile en tant qu'assistant par lui-même, mais il est très utile pour l'étape d'apprentissage par renforcement qui suit. Comme nous avons un modèle de récompense, nous pouvons noter la qualité de n'importe quelle complétion arbitraire pour n'importe quelle incitation donnée.

Ce que nous faisons pendant l'apprentissage par renforcement consiste essentiellement à obtenir une large collection d'incitations et maintenant nous effectuons un apprentissage par renforcement par rapport au modèle de récompense. Nous prenons une seule incitation, la disposons en lignes, et utilisons le modèle que nous aimerions entraîner, qui est initialisé au modèle SFT, pour créer des complétions en jaune.

Ensuite, nous ajoutons à nouveau le jeton de récompense et nous lisons la récompense selon le modèle de récompense, qui est maintenant maintenu fixe. Le modèle de récompense nous indique la qualité de chaque complétion pour chaque incitation.

Ce que nous pouvons faire maintenant, c'est simplement appliquer la même fonction de perte de modélisation de langage, mais nous nous entraînons actuellement sur les jetons jaunes et nous pondérons l'objectif de modélisation de langage par les récompenses indiquées par le modèle de récompense.

Par exemple, sur la première ligne, le modèle de récompense a dit que c'était une complétion avec un score assez élevé, et donc tous les jetons que nous avons échantillonnés sur la première ligne vont être renforcés et auront des probabilités plus élevées pour le futur.

À l'inverse, sur la deuxième ligne, le modèle de récompense n'a vraiment pas aimé cette complétion, -1,2, et par conséquent chaque jeton que nous avons échantillonnés dans cette deuxième ligne va avoir une probabilité légèrement plus élevée pour le futur. Nous faisons cela maintes et maintes fois sur de nombreuses incitations et lots, et nous obtenons fondamentalement une politique qui crée des jetons jaunes obtenant un score élevé selon le modèle de récompense que nous avons entraîné à l'étape précédente.

C'est ainsi que nous entraînons — c'est ce qu'est le pipeline RLHF. À la fin, vous obtenez un modèle que vous pouvez déployer. Par exemple, ChatGPT est un modèle RLHF. Mais certains autres modèles que vous pourriez rencontrer, comme Vicuna 13B, sont des modèles SFT.

Nous avons donc des modèles de base, des modèles SFT et des modèles RLHF, et c'est l'état actuel des choses. Pourquoi voudriez-vous faire du RLHF ? Une réponse qui n'est pas très excitante est que cela fonctionne simplement mieux. Cela vient de l'article InstructGPT.

Selon ces expériences, ces modèles PPO sont du RLHF et nous voyons qu'ils sont préférés dans de nombreuses comparaisons lorsque nous les soumettons à des humains. Les humains préfèrent simplement les jetons provenant des modèles RLHF par rapport aux modèles SFT, par rapport à un modèle de base incité à être un assistant.

Cela fonctionne tout simplement mieux. Mais on peut se demander pourquoi ? Je ne pense pas qu'il y ait une seule réponse géniale sur laquelle la communauté se soit accordée, mais je vais proposer une raison potentielle. Cela a trait à l'asymétrie entre la facilité informatique de comparaison par rapport à la génération.

Prenez l'exemple de la génération d'un haïku. Supposons que je demande à un modèle d'écrire un haïku sur les trombones. Si vous êtes un prestataire essayant de fournir des données d'entraînement pour l'étape SFT, comment êtes-vous censé créer un joli haïku pour un trombone ? Vous n'êtes peut-être pas très doué pour cela.

Mais si je vous donne quelques exemples de haïkus, vous pourriez être en mesure d'en apprécier certains beaucoup plus que d'autres. Juger lequel est bon est une tâche beaucoup plus facile. Cette asymétrie fait des comparaisons un meilleur moyen de tirer potentiellement parti de votre jugement en tant qu'humain pour créer un meilleur modèle.

Les modèles RLHF ne sont pas strictement une amélioration des modèles de base dans certains cas. En particulier, nous avons remarqué par exemple qu'ils perdent un peu d'entropie. Cela signifie qu'ils donnent des résultats plus tranchés. Ils peuvent produire des échantillons avec moins de variation qu'un modèle de base.

Un modèle de base a beaucoup d'entropie et donnera des résultats diversifiés. Par exemple, un cas où je préfère encore utiliser un modèle de base est une configuration où vous avez N choses et que vous voulez générer d'autres choses similaires.

Voici un exemple que j'ai concocté. Je veux générer des noms de Pokémon sympas. J'ai donné sept noms de Pokémon et j'ai demandé au modèle de base de compléter le document, et il m'a donné beaucoup plus de noms de Pokémon. Ceux-ci sont fictifs ; je ne pense pas que ce soient de vrais Pokémon.

C'est le genre de tâche pour laquelle un modèle de base serait bon car il a encore beaucoup d'entropie et vous donnera des choses diverses et cool qui ressemblent à ce que vous lui avez donné auparavant.

Ceci dit, ce sont les modèles assistants qui sont probablement à votre disposition en ce moment. Il y a une équipe à Berkeley qui a classé un grand nombre de modèles assistants disponibles et leur a attribué des notes ELO.

Actuellement, certains des meilleurs modèles sont GPT-4 de loin, suivi par Claude, GPT-3.5, puis un certain nombre de modèles dont certains pourraient être disponibles sous forme de poids comme Vicuna, Koala, etc. Les trois premières lignes ici sont toutes des modèles RLHF et tous les autres modèles, à ma connaissance, sont des modèles SFT.

C'est ainsi que nous entraînons ces modèles à un haut niveau. Maintenant, je vais changer de sujet et examiner comment nous pouvons appliquer au mieux un modèle assistant GPT à vos problèmes. Travaillons avec un exemple concret.

Disons que vous travaillez sur un article ou un billet de blog et que vous allez écrire cette phrase à la fin : La population de la Californie est 53 fois supérieure à celle de l'Alaska. Pour une raison quelconque, vous voulez comparer les populations de ces deux États.

Pensez au riche monologue interne, à l'utilisation d'outils et à la quantité de travail qui se passe réellement par calcul dans votre cerveau pour générer cette seule phrase finale. Voici peut-être à quoi cela pourrait ressembler dans votre cerveau. D'accord, pour cette prochaine étape de mon blog, comparons ces deux populations.

Tout d'abord, je vais devoir obtenir ces deux populations. Je sais que je ne connais probablement pas ces populations par cœur, donc je suis conscient de ce que je sais ou ne sais pas — mes connaissances personnelles. J'utilise un outil, je vais sur Wikipédia et je cherche la population de la Californie et celle de l'Alaska.

Je devrais diviser les deux, mais je sais que diviser 39,2 par 0,74 a très peu de chances de réussir. Ce n'est pas le genre de chose que je peux faire de tête. Par conséquent, je vais m'appuyer sur une calculatrice. Je vais utiliser une calculatrice, taper les chiffres et voir que le résultat est d'environ 53.

Ensuite, je fais peut-être une réflexion et des vérifications de cohérence dans mon cerveau. Est-ce que 53 a du sens ? Eh bien, c'est une fraction assez importante, mais après tout, la Californie est l'État le plus peuplé, donc cela semble correct. Ensuite, j'ai toutes les informations dont je pourrais avoir besoin et je passe maintenant à la partie créative de l'écriture.

Je pourrais commencer à écrire quelque chose comme La Californie a 53X fois plus, puis je me dis que c'est une formulation vraiment maladroite. Laissez-moi effacer cela et essayer à nouveau. Pendant que j'écris, j'ai ce processus séparé qui inspecte presque ce que j'écris et juge si c'est bon ou non.

Ensuite, je l'efface peut-être et je le reformule, puis je suis peut-être satisfait de ce qui en ressort. Des tonnes de choses se passent sous le capot en termes de monologue interne lorsque vous créez des phrases comme celle-ci. Mais à quoi ressemble une phrase comme celle-ci lorsque nous entraînons un GPT dessus ?

Du point de vue du GPT, ce n'est qu'une séquence de jetons. Un GPT, lorsqu'il lit ou génère ces jetons, avance bloc par bloc. Chaque bloc représente à peu près la même quantité de travail de calcul pour chaque jeton.

Ces transformateurs ne sont pas des réseaux superficiels ; ils ont environ 80 couches de raisonnement, mais 80, ce n'est pas encore énorme. Ce transformateur va faire de son mieux pour imiter, mais bien sûr, le processus ici semble très différent du processus que vous avez suivi.

Dans nos artefacts finaux, dans les ensembles de données que nous créons et que nous finissons par fournir aux LLM, tout ce dialogue interne est complètement supprimé. Contrairement à vous, le GPT examinera chaque jeton et consacrera la même quantité de calcul à chacun d'eux.

Vous ne pouvez pas attendre de lui qu'il fasse trop de travail par jeton. De plus, en particulier, ces transformateurs ne sont que des simulateurs de jetons. Ils ne savent pas ce qu'ils ne savent pas ; ils imitent simplement le jeton suivant.

Ils ne savent pas en quoi ils sont bons ou non ; ils font juste de leur mieux pour imiter le jeton suivant. Ils ne réfléchissent pas en boucle, ils ne vérifient pas la cohérence de quoi que ce soit, ils ne corrigent pas leurs erreurs en cours de route par défaut ; ils échantillonnent simplement des séquences de jetons. Ils n'ont pas de flux de monologues internes séparés dans leur tête évaluant ce qui se passe.

Ils ont tout de même certains avantages cognitifs : ils possèdent une très grande connaissance factuelle dans un vaste nombre de domaines car ils ont plusieurs dizaines de milliards de paramètres, ce qui représente beaucoup de stockage pour les faits.

Et ils ont aussi une mémoire de travail relativement grande et parfaite. Tout ce qui tient dans la fenêtre de contexte est immédiatement disponible pour le transformateur via son mécanisme d'auto-attention interne. C'est comme une mémoire parfaite mais de taille finie. Le transformateur y a un accès direct et peut se souvenir sans perte de tout ce qui se trouve à l'intérieur de sa fenêtre de contexte.

C'est ainsi que je comparerais les deux. La raison pour laquelle j'aborde tout cela est que je pense que, dans une large mesure, le prompting consiste simplement à compenser cette différence cognitive entre ces deux architectures — nos cerveaux et les cerveaux des LLM.

Voici une chose que les gens ont trouvée et qui fonctionne assez bien en pratique. Surtout si vos tâches nécessitent du raisonnement, vous ne pouvez pas vous attendre à ce que le transformateur fasse trop de raisonnement par jeton. Vous devez vraiment étaler le raisonnement sur davantage de jetons.

Par exemple, vous ne pouvez pas poser une question très compliquée à un transformateur et vous attendre à ce qu'il trouve la réponse en un seul jeton ; il n'y a tout simplement pas assez de temps pour cela. Ces transformateurs ont besoin de jetons pour réfléchir. Voici quelques-unes des choses qui fonctionnent bien.

Vous pouvez avoir une incitation en quelques exemples qui montre au transformateur qu'il doit détailler son travail lorsqu'il répond à une question. Si vous donnez quelques exemples, le transformateur imitera ce modèle et cela finira par mieux fonctionner en termes d'évaluation.

De plus, vous pouvez susciter ce genre de comportement de la part du transformateur en disant « réfléchissons étape par étape », car cela conditionne le transformateur à détailler son travail. Comme il passe en mode détail de son travail, il va faire moins de travail de calcul par jeton et a plus de chances de réussir car il effectue un raisonnement plus lent au fil du temps.

Voici un autre exemple appelé auto-cohérence (self-consistency). Nous avons vu que nous avions la capacité de commencer à écrire et si cela ne fonctionnait pas, je peux essayer plusieurs fois et sélectionner celle qui a le mieux fonctionné.

Dans ce genre d'approches, vous pouvez échantillonner plusieurs fois, puis avoir un processus pour trouver celles qui sont bonnes et ne conserver que ces échantillons ou effectuer un vote à la majorité.

Fondamentalement, ces transformateurs, lorsqu'ils prédisent le jeton suivant, tout comme vous, peuvent ne pas avoir de chance et échantillonner un jeton pas très bon et s'engager dans une impasse en termes de raisonnement. Contrairement à vous, ils ne peuvent pas s'en remettre. Ils sont coincés avec chaque jeton qu'ils échantillonnent et continueront la séquence même s'ils savent que cette séquence ne va pas aboutir.

Donnez-leur la capacité de regarder en arrière, d'inspecter ou d'essayer d'échantillonner autour.

Voici une technique également : il s'avère que les LLM savent quand ils se sont trompés. Par exemple, supposons que vous demandiez au modèle de générer un poème qui ne rime pas et qu'il vous donne un poème mais qu'il rime réellement.

Il s'avère que, surtout pour les modèles plus volumineux comme GPT-4, vous pouvez simplement lui demander : « as-tu respecté la consigne ? ». GPT-4 sait très bien qu'il n'a pas respecté la consigne ; il a juste manqué de chance dans son échantillonnage. Il vous dira : « no, je n'ai pas vraiment respecté la consigne, laisse-moi essayer encore ».

Sans que vous ne l'incitiez, il ne sait même pas qu'il doit réexaminer. Vous devez compenser cela dans vos incitations. Vous devez l'amener à vérifier. Si vous ne lui demandez pas de vérifier, il ne vérifiera pas de lui-même ; c'est juste un simulateur de jetons.

Je pense que plus généralement, beaucoup de ces techniques entrent dans la catégorie de la recréation de notre système 2. Vous connaissez peut-être la pensée système 1 / système 2 pour les humains. Le système 1 est un processus automatique rapide et correspond à un LLM qui échantillonne simplement des jetons.

Le système 2 est la partie de planification délibérée plus lente de votre cerveau. C'est un article de la semaine dernière intitulé Tree of Thought (Arbre de pensée). Dans Tree of Thought, les auteurs ont proposé de maintenir plusieurs complétions pour toute incitation donnée.

Ils les notent également en cours de route et gardent celles qui se passent bien. Beaucoup de gens s'amusent avec le prompt engineering pour ramener fondamentalement certaines de ces capacités que nous avons dans notre cerveau pour les LLM.

Une chose que j'aimerais noter est que ce n'est pas seulement une incitation. Ce sont des incitations utilisées avec du code de liaison Python car vous devez réellement maintenir plusieurs incitations et utiliser un algorithme de recherche arborescente pour déterminer quelle incitation développer.

C'est une symbiose de code de liaison Python et d'incitations individuelles qui sont appelées dans une boucle while ou dans un algorithme plus vaste. Je pense aussi qu'il y a un parallèle vraiment cool ici avec AlphaGo. AlphaGo a une politique pour placer la pierre suivante lorsqu'il joue au Go et cette politique a été entraînée à l'origine en imitant les humains.

En plus de cette politique, il effectue également une recherche arborescente de Monte-Carlo et joue un certain nombre de possibilités dans sa tête, les évalue toutes et ne garde que celles qui fonctionnent bien. Je pense que c'est un équivalent d'AlphaGo mais pour le texte.

Tout comme Tree of Thought, plus généralement, les gens commencent à explorer des techniques plus générales qui ne sont pas de simples incitations de type question-réponse, mais quelque chose qui ressemble beaucoup plus à du code de liaison Python enchaînant de nombreuses incitations.

À droite, j'ai un exemple tiré de cet article appelé ReAct où ils structurent la réponse à une incitation comme une séquence de pensée, action, observation, pensée, action, observation, et c'est un processus de réflexion complet pour répondre à la requête. Dans ces actions, le modèle est également autorisé à utiliser des outils.

À gauche, j'ai un exemple d'AutoGPT. AutoGPT est un projet qui a fait l'objet de beaucoup de battage médiatique récemment, mais je le trouve toujours intéressant sur le plan de l'inspiration. C'est un projet qui permet à un LLM de tenir en quelque sorte une liste de tâches et de décomposer récursivement les tâches.

Je ne pense pas que cela fonctionne très bien actuellement et je ne conseillerais pas aux gens de l'utiliser dans des applications pratiques. Je pense simplement que c'est une source d'inspiration générale en termes de direction que cela prend au fil du temps.

C'est donner à notre modèle une pensée de type système 2.

La chose suivante que je trouve intéressante est cette particularité psychologique suivante des LLM : les LLM ne veulent pas réussir ; ils veulent imiter. Vous, vous voulez réussir et vous devriez le demander.

Ce que je veux dire par là, c'est que lorsque les transformateurs sont entraînés, ils ont des ensembles d'entraînement. Il peut y avoir tout un spectre de qualités de performance dans leurs données d'entraînement. Par exemple, il pourrait y avoir une solution d'étudiant à une question de physique qui est complètement fausse.

Mais il peut aussi y avoir une réponse d'expert qui est extrêmement juste. Les transformateurs ne peuvent pas faire la différence — ils connaissent les solutions de basse qualité et les solutions de haute qualité, mais par défaut, ils veulent tout imiter parce qu'ils sont juste entraînés à la modélisation du langage.

Au moment du test, vous devez en fait demander une bonne performance. Dans cet exemple, ils ont essayé diverses incitations, et « réfléchissons étape par étape » a été très puissant car cela a étalé le raisonnement sur de nombreux jetons, mais ce qui a encore mieux fonctionné est « résolvons cela étape par étape pour être sûrs d'avoir la bonne réponse ».

Cela conditionne l'obtention d'une bonne réponse et cela permet réellement au transformateur de mieux fonctionner car il n'a plus besoin de disperser sa masse de probabilité sur des solutions de basse qualité, aussi ridicule que cela puisse paraître. En gros, n'ayez pas peur de demander une solution solide.

Dites quelque chose comme : « tu es un expert de premier plan sur ce sujet, fais comme si tu avais un QI de 120 », etc. Mais n'essayez pas de demander trop de QI car si vous demandez un QI de 400, vous pourriez sortir de la distribution des données ou, pire encore, vous retrouver dans la distribution de données de science-fiction et il commencera à adopter un jeu de rôle de science-fiction. Vous devez trouver la bonne dose de QI.

Ensuite, comme nous l'avons vu, lorsque nous essayons de résoudre des problèmes, nous savons en quoi nous sommes bons et en quoi nous ne le sommes pas et nous nous appuyons sur des outils de calcul. Vous voulez faire de même avec vos LLM. En particulier, nous pourrions vouloir leur donner des calculatrices, des interpréteurs de code, et ainsi de suite, la capacité d'effectuer des recherches.

Il existe de nombreuses techniques pour cela. Une chose à garder à l'esprit est que ces transformateurs, par défaut, peuvent ne pas savoir ce qu'ils ne savent pas. Vous pouvez même dire au transformateur dans une incitation : « tu n'es pas très bon en calcul mental. Chaque fois que tu as besoin de faire une addition de très grands nombres, une multiplication ou autre, utilise plutôt cette calculatrice ».

Voici comment utiliser la calculatrice, utilise cette combinaison de jetons, et ainsi de suite. Vous devez réellement l'expliquer car le modèle, par défaut, ne sait pas en quoi il est bon ou non, tout comme vous et moi.

Ensuite, je pense que quelque chose de très intéressant est que nous sommes passés d'un monde qui n'était que de la récupération à l'autre extrême où il n'y a que de la mémoire dans les LLM. Mais en fait, il y a tout cet espace entre les deux de ces modèles augmentés par récupération et cela fonctionne extrêmement bien en pratique.

Comme je l'ai mentionné, la fenêtre de contexte d'un transformateur est sa mémoire de travail. Si vous pouvez charger la mémoire de travail avec n'importe quelle information pertinente pour la tâche, le modèle fonctionnera extrêmement bien car il peut accéder immédiatement à toute cette mémoire. Je pense que beaucoup de gens sont vraiment intéressés par la génération augmentée par récupération.

En bas, j'ai un exemple de LlamaIndex, qui est un connecteur de données vers de nombreux types de données différents, et vous pouvez indexer toutes ces données et les rendre accessibles aux LLM. La recette émergente est la suivante : vous prenez les documents pertinents, vous les divisez en morceaux, vous les intégrez (embed) tous et vous obtenez fondamentalement des vecteurs d'intégration qui représentent ces données.

Vous stockez cela dans une base de données vectorielle, puis, au moment du test, vous effectuez une sorte de requête dans votre base vectorielle et vous récupérez des morceaux qui pourraient être pertinents pour votre tâche, vous les insérez dans l'incitation, puis vous générez. Cela peut très bien fonctionner en pratique. C'est similaire à la façon dont vous et moi résolvons des problèmes.

Vous pouvez tout faire de mémoire et les transformateurs ont une mémoire étendue, mais cela aide vraiment de se référer à des documents originaux. Chaque fois que vous retournez à un manuel ou à la documentation d'une bibliothèque pour chercher quelque chose, les transformateurs veulent absolument le faire aussi.

Vous avez un souvenir du fonctionnement de la documentation d'une bibliothèque, mais il est bien mieux de vérifier. La même chose s'applique ici.

Ensuite, je voulais brièvement parler du prompting contraint. Je trouve cela aussi très intéressant. Ce sont fondamentalement des techniques pour forcer un certain modèle dans les sorties des LLM. Guidance est un exemple de Microsoft. Ici, nous imposons que la sortie du LLM soit du JSON.

Cela garantira réellement que la sortie prendra cette forme car ils manipulent les probabilités des différents jetons qui sortent du transformateur et ils bloquent ces jetons. Le transformateur ne fait que remplir les blancs. Vous pouvez imposer des restrictions supplémentaires sur ce qui pourrait aller dans ces blancs.

Cela pourrait être vraiment utile et je pense que ce genre d'échantillonnage contraint est également extrêmement intéressant.

Je voulais aussi dire quelques mots sur l'ajustement fin. Il est vrai que l'on peut aller très loin avec le prompt engineering, mais il est également possible de penser à ajuster finement vos modèles. Ajuster finement les modèles signifie que vous allez réellement modifier les poids du modèle. Il devient beaucoup plus accessible de le faire en pratique.

Et c'est grâce à un certain nombre de techniques qui ont été développées récemment. Par exemple, les techniques d'ajustement fin efficaces en paramètres comme LoRA garantissent que vous n'entraînez que de petits morceaux clairsemés de votre modèle. La majeure partie du modèle est maintenue fixée au modèle de base et certains morceaux sont autorisés à changer, et cela fonctionne toujours assez bien de manière empirique.

Cela signifie également que, puisque la majeure partie de votre modèle est fixée, vous pouvez utiliser une inférence de très basse précision pour calculer ces parties car elles ne seront pas mises à jour par la descente de gradient, ce qui rend tout beaucoup plus efficace également.

De plus, we avons un certain nombre de modèles de base de haute qualité en open source. Actuellement, je pense que LLaMA est assez bien, bien qu'il ne soit pas sous licence commerciale pour le moment. Une chose à garder à l'esprit est que l'ajustement fin est beaucoup plus complexe techniquement. Cela nécessite plus d'expertise technique pour être bien fait.

Cela nécessite des prestataires de données humains pour les ensembles de données ou des pipelines de données synthétiques qui peuvent être assez compliqués. Cela ralentira certainement beaucoup votre cycle d'itération. À un haut niveau, le SFT est réalisable car il s'agit simplement de poursuivre la tâche de modélisation du langage ; c'est relativement simple.

Mais le RLHF relève tout à fait du domaine de la recherche et est encore beaucoup plus difficile à faire fonctionner. Je ne conseillerais probablement pas à quelqu'un d'essayer de lancer sa propre implémentation de RLHF. Ces choses sont assez instables, très difficiles à entraîner et ce n'est pas quelque chose de très accessible aux débutants pour le moment ; cela risque également de changer encore assez rapidement.

Je pense que ce sont mes recommandations par défaut pour le moment. Je diviserais votre tâche en deux parties majeures : Premièrement, atteindre votre performance maximale et deuxièmement, optimiser votre performance, dans cet ordre. La meilleure performance proviendra actuellement du modèle GPT-4 ; c'est le modèle le plus capable de loin.

Utilisez des incitations très détaillées, elles ont beaucoup de contexte sur la tâche, des informations et des instructions pertinentes. Pensez à ce que vous diriez à un prestataire de tâches s'il ne pouvait pas vous répondre par e-mail. Gardez à l'esprit qu'un prestataire de tâches est un humain, qu'il a un monologue interne et qu'il est très intelligent. Les LLM ne possèdent pas ces qualités.

Assurez-vous donc de réfléchir à la psychologie du LLM et d'adapter les incitations en conséquence. Récupérez et ajoutez tout contexte et information pertinents à ces incitations. En gros, référez-vous aux techniques de prompt engineering. J'en ai souligné quelques-unes dans les diapositives ci-dessus, mais c'est aussi un domaine très vaste et je vous conseillerais simplement de chercher des techniques de prompt engineering en ligne.

Il y a beaucoup de choses à couvrir. Expérimentez avec des exemples en quelques exemples. Vous ne voulez pas seulement dire, vous voulez montrer chaque fois que c'est possible. Donnez-lui des exemples de tout ; cela l'aide vraiment à comprendre ce que vous voulez dire. Expérimentez avec des outils et des plugins pour décharger les tâches qui sont difficiles nativement pour les LLM.

Ne pensez pas seulement à une seule incitation et une réponse, pensez à des chaînes potentielles, à la réflexion, à la façon dont vous les liez ensemble et à la façon dont vous pourriez potentiellement faire plusieurs échantillons.

Enfin, si vous pensez avoir épuisé le prompt engineering, avec lequel vous devriez rester pendant un certain temps, envisagez éventuellement d'ajuster finement un modèle pour votre application.

Mais attendez-vous à ce que ce soit plus lent et plus complexe. Il y a une zone de recherche fragile d'experts ici, qui est le RLHF, qui fonctionne actuellement un peu mieux que le SFT si vous arrivez à le faire fonctionner, mais encore une fois, c'est assez complexe. Pour optimiser vos coûts, essayez d'explorer des modèles de moindre capacité ou des incitations plus courtes.

Je voulais aussi dire quelques mots sur les cas d'utilisation pour lesquels les LLM sont actuellement bien adaptés. Notez en particulier qu'il existe un grand nombre de limitations aux LLM à ce jour, je garderais donc cela définitivement à l'esprit pour toutes vos applications. Cela pourrait faire l'objet d'un exposé entier, je n'ai donc pas le temps de le couvrir en détail.

Les modèles peuvent être biaisés, ils peuvent fabriquer des informations, ils peuvent faire des erreurs de raisonnement, ils peuvent éprouver des difficultés dans des catégories entières d'applications, ils ont des dates de coupure de connaissances, ils peuvent donc ne connaître aucune information postérieure à septembre 2021. Ils sont sensibles à un large éventail d'attaques, notamment l'injection d'incitation, les attaques de type jailbreak, les attaques par empoisonnement des données, etc.

Ma recommandation actuelle est d'utiliser les LLM dans des applications à faibles enjeux, combinez-les toujours avec une supervision humaine, utilisez-les comme source d'inspiration et de suggestions, et pensez copilotes au lieu d'agents complètement autonomes effectuant une tâche quelque part. Il n'est tout simplement pas certain que les modèles en soient là pour le moment.

Je voulais conclure en disant que GPT-4 est un artefact incroyable. Je suis très reconnaissant qu'il existe. Il possède une tonne de connaissances dans tant de domaines. Il peut faire des maths, du code, et ainsi de suite.

De plus, il y a cet écosystème florissant de tout le reste qui est construit et incorporé dans l'écosystème ; j'ai parlé de certaines de ces choses.

Toute cette puissance est accessible au bout de vos doigts. Voici tout ce qui est nécessaire en termes de code pour poser une question à GPT-4, pour l'inciter et obtenir une réponse.

Dans ce cas, j'ai dit : « Peux-tu dire quelque chose pour inspirer le public du Microsoft Build 2023 ? » Et j'ai juste tapé cela en Python et mot pour mot, GPT-4 a répondu ce qui suit.

Je ne savais pas qu'ils utilisaient cette astuce dans la conférence d'ouverture, donc je pensais être malin, mais il est vraiment doué pour ça.

Il dit : « Mesdames et messieurs, innovateurs et pionniers de Microsoft Build 2023, bienvenue à un rassemblement d'esprits brillants sans pareil. Vous êtes les architectes du futur, les visionnaires qui façonnent le domaine numérique dans lequel l'humanité s'épanouit. Embrassez les possibilités illimitées de la technologie et laissez vos idées s'envoler aussi haut que votre imagination. Ensemble, créons un monde plus connecté, remarquable et inclusif pour les générations à venir. Préparez-vous à libérer votre créativité, à explorer l'inconnu et à transformer les rêves en réalité. Votre voyage commence aujourd'hui. »

Merci.