Le texte intégral compte au total plus de 9 000 mots et le temps de lecture prévu est d'environ 18 à 30 minutes | Plein de produits secs (avec reproduction papier), il est recommandé de les collecter !
Le but de cet article : présenter la méthode de base de l'ingénierie d'incitation, la méthode d'incitation de la chaîne de pensée et la méthode d'incitation de LtM, et reproduire et résoudre les quatre problèmes de raisonnement classiques dans l'article .
Téléchargement du code cliquez ici
La majeure partie du contenu est constituée de résultats de recherche scientifique dans le domaine LLM au cours des deux dernières années, mais les conclusions sont pour la plupart des solutions dans le contexte anglais. Par conséquent, ces résultats de recherche scientifique de grande valeur seront systématiquement triés et la logique du contenu chinois sera proposée en combinaison avec la situation réelle du contexte chinois.
1. Introduction
La capacité émergente du grand modèle (LLM) fait référence à la capacité du modèle à résoudre des problèmes dans certains domaines avec certains moyens techniques sans formation pour des tâches spécifiques (données).
Exemple : Pour jouer au jeu « compter trois et en arrêter un » , supposons qu'il existe un jeu appelé « compter trois et en arrêter un ». Les règles du jeu sont les suivantes : les gens forment un cercle, commencent par une personne et comptent une par une dans l'ordre. Chaque personne qui compte jusqu'à 3 doit quitter le jeu. Ce processus se poursuit jusqu'à ce qu'il ne reste que la dernière personne. Maintenant, sans indiquer explicitement à GPT-3 ou GPT-4 comment jouer à ce jeu, ni fournir un algorithme spécifique, voyez comment il répond :
Invite : S'il y a 10 personnes qui jouent au jeu consistant à compter trois, un, qui est la dernière personne restante ?
Regardez la réponse de ChatGPT :
Sur la base du processus de raisonnement ci-dessus, on peut dire que le grand modèle de langage ne sait même pas ce que représente la véritable signification des nombres. Ce n'est qu'après avoir appris d'innombrables corpus et découvert la relation de probabilité potentielle entre les nombres que les opérations mathématiques ou complexes Le la capacité de raisonner est une capacité très forte.
Les grands modèles mentionnés ci-dessus peuvent résoudre des problèmes dans certains domaines spécifiques grâce à certains moyens techniques, et ces moyens techniques peuvent être divisés en deux catégories en termes de recherche actuelle : l'ingénierie des conseils et le réglage fin. L'ingénierie et le réglage fin des indices sont à la fois des méthodes de guidage et d'optimisation pour les capacités émergentes du modèle, mais par rapport au réglage fin, l'ingénierie des indices est moins chère, plus flexible à utiliser et a un meilleur effet sur l'amélioration de la compréhension sémantique complexe du modèle dans un petit espace sémantique .
L'ingénierie rapide peut être comprise de cette manière simple : un processus d'interaction complet entre un utilisateur et un grand modèle de langage est l'ingénierie rapide d'un grand modèle de langage (LLM). Différentes méthodes d'invite obtiendront des résultats de qualité complètement différents.
2. Quatre problèmes de raisonnement classiques
Pour l'ingénierie des indices, son objectif est de résoudre des problèmes complexes de compréhension sémantique et de vérifier si le modèle a cette capacité. Vous pouvez observer si le modèle peut résoudre des problèmes de raisonnement logique complexes.
Si le modèle peut résoudre les problèmes d'inférence qui ne peuvent pas être résolus dans l'état d'origine sous la direction de l'ingénierie des indices, cela signifie que l'ingénierie des indices peut améliorer la capacité de raisonnement du modèle, et plus l'ingénierie des indices est efficace, plus la capacité de raisonnement du modèle est grande. amélioration de la capacité de raisonnement du modèle. Cela peut être vérifié en posant des problèmes de raisonnement de complexité différente.
Considérez les quatre problèmes de raisonnement classiques suivants :
Les questions de raisonnement 1 et 2 proviennent de l'article : L'invite de chaîne de pensée suscite le raisonnement dans de grands modèles de langage
Passons au contexte chinois :
- question de raisonnement 1
prompt1 = 'Roger a cinq balles de tennis, il a acheté deux autres boîtes de balles de tennis, chaque boîte contient 3 balles de tennis, combien de balles de tennis a-t-il au total maintenant ? '
le code s'affiche comme ci-dessous :
import os
import openai
openai.api_key = os.getenv("OPENAI_API_KEY")
prompt1 = '罗杰有五个网球，他又买了两盒网球，每盒有3个网球，请问他现在总共有多少个网球？'
response1 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt1,
max_tokens=1000,
)
response1["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
- Question de raisonnement 2
prompt2 = "Il y a un total de 23 pommes dans la cafétéria. S'ils utilisent 20 pommes et achètent ensuite 6 pommes, combien de pommes y a-t-il maintenant dans la cafétéria ?" '
Regardez le code :
prompt2 = '食堂总共有23个苹果，如果他们用掉20个苹果，然后又买了6个苹果，请问现在食堂总共有多少个苹果？'
response2 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt2,
max_tokens=1000,
)
response2["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
Cette question de raisonnement est un peu plus compliquée, c'est-à-dire que la cafétéria non seulement ajoute 6 pommes, mais consomme également 20 pommes. S'il y a une augmentation ou une diminution, le grand modèle ne peut pas porter un jugement correct. La bonne réponse devrait être qu’il reste 23-20+6=9 pommes dans la cafétéria.
La question de raisonnement 3 provient de l'article : Les grands modèles de langage sont des raisonneurs zéro-shot
Passons au contexte chinois :
- question de raisonnement 3
prompt3 = 'Le jongleur peut jongler avec 16 balles. La moitié des balles sont des balles de golf et la moitié des balles de golf sont bleues. Combien y a-t-il de balles de golf bleues au total ? '
Regardez le code :
prompt3 = '杂耍者可以杂耍16个球。一半的球是高尔夫球，一半的高尔夫球是蓝色的。请问总共有多少个蓝色高尔夫球？'
response3 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt3,
max_tokens=1000,
)
response3["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
Le processus de calcul mathématique du troisième problème logique n'est pas compliqué, mais un piège linguistique est conçu, c'est-à-dire ce qui représente la moitié de la moitié. On peut constater que le modèle ne peut pas porter de jugement précis sur cette question et que la bonne réponse devrait être 16*0,5*0,5=4 balles de golf bleues.
La question de raisonnement 4 est tirée de l'article LE MOINS AU PLUS PROMPTING PERMET UN RAISONNEMENT COMPLEXE DANS DE GRANDS MODÈLES DE LANGAGE
- question de raisonnement 4
prompt4 = 'Il a fallu à Amy 4 minutes pour monter au sommet du toboggan, il lui a fallu 1 minute pour glisser vers le bas, le toboggan se fermera dans 15 minutes, combien de fois peut-elle glisser avant de se fermer ? '
Regardez le code :
prompt4 = '艾米需要4分钟能爬到滑梯顶部，然后需要花费1分钟滑下来，现在水滑梯将在15分钟后关闭，请问在关闭之前她能滑多少次？'
response4 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt4,
max_tokens=1000,
)
response4["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
Le processus de calcul de cette question est le plus compliqué parmi les quatre questions de raisonnement classiques, impliquant des calculs en plusieurs étapes et des opérations de division. Le processus de calcul correct devrait consister d'abord à calculer qu'il faut à Amy un total de 5 minutes pour monter et descendre, puis le toboggan se fermera dans 15 minutes, de sorte qu'il puisse glisser 15/5 = 3 fois avant de se fermer.
D'après les résultats ci-dessus, dans le cas de Zero-shot, 'text-davinci-003' a une faible capacité de raisonnement logique et ne peut résoudre que des problèmes de raisonnement relativement simples qui n'ont qu'un processus opérationnel linéaire. Pour ces quatre Pour une question de raisonnement, le modèle n'a répondu correctement qu'à la première question et les autres questions ont reçu une réponse erronée.On peut dire que la capacité de raisonnement du modèle est très faible.
L'étape suivante consiste à montrer les prouesses du projet d'invite. Ensuite, nous résoudrons ces problèmes en reproduisant différentes méthodes d'invite pour renforcer la capacité de traitement logique du modèle.
3. Méthode d'apprentissage rapide en un seul coup et en quelques coups
Le moyen le plus simple de lancer le projet est de saisir des questions similaires et les réponses aux questions, de laisser le modèle en tirer des leçons et de poser de nouvelles questions à la fin de la même invite, afin d'améliorer la capacité de raisonnement du modèle. Cette méthode est également connue sous le nom de méthode d'invite One-shot ou Few-shot.
One-shot et Few-shot ont été proposés pour la première fois par l'équipe de recherche d'OpenAI dans l'article "Language Models are Few-Shot Learners" . Cet article est également à l'origine de la méthode d'ingénierie des indices. Il présente non seulement les deux méthodes de base de l'indice. ingénierie, mais aussi décrire en détail les raisons spécifiques derrière cela.
En termes d'applications spécifiques, la méthode d'invite Few-shot n'est pas compliquée : il suffit de saisir les questions + réponses de certaines questions similaires dans le cadre de l'invite .
Faites une expérience : saisissez d'abord le premier exemple auquel le modèle peut répondre correctement comme mot d'invite, et vérifiez si la deuxième question peut être déduite facilement :
Le format d’écriture de Few-shot :
Lorsque vous devez saisir plusieurs questions et réponses comme mots d'invite, commencez la question par Q et commencez la réponse par A (vous pouvez également la remplacer par « question » et « réponse »), et différents dialogues de questions et réponses doivent être enveloppés. pour un affichage plus clair.La méthode spécifique consiste à compléter par un caractère d'échappement + une nouvelle ligne.
le code s'affiche comme ci-dessous :
prompt_Few_shot1 = 'Q：“罗杰有五个网球，他又买了两盒网球，每盒有3个网球，请问他现在总共有多少个网球？” \
A：“现在罗杰总共有11个网球。” \
Q：“食堂总共有23个苹果，如果他们用掉20个苹果，然后又买了6个苹果，请问现在食堂总共有多少个苹果？” \
A：'
response_Few_shot1 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Few_shot1,
max_tokens=1000,
)
response_Few_shot1["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
Bien qu'il soit impossible de déterminer comment le processus de prédiction du modèle a changé, après avoir appris le premier exemple, le modèle est effectivement capable de porter un jugement précis sur la deuxième question. On peut constater que Few-shot peut jouer un certain rôle dans l'amélioration de la capacité de raisonnement logique du modèle.
Testez à nouveau en saisissant les questions et les réponses des deux exemples sous forme de mots d'invite pour voir si le modèle peut répondre correctement à la troisième question. le code s'affiche comme ci-dessous :
prompt_Few_shot2 = 'Q：“罗杰有五个网球，他又买了两盒网球，每盒有3个网球，请问他现在总共有多少个网球？” \
A：“现在罗杰总共有11个网球。” \
Q：“食堂总共有23个苹果，如果他们用掉20个苹果，然后又买了6个苹果，请问现在食堂总共有多少个苹果？” \
A：“现在食堂总共有9个苹果。” \
Q：“杂耍者可以杂耍16个球。一半的球是高尔夫球，一半的高尔夫球是蓝色的。请问总共有多少个蓝色高尔夫球？” \
A：'
response_Few_shot2 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Few_shot2,
max_tokens=1000,
)
response_Few_shot2["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
Le modèle a toujours répondu incorrectement à la troisième question. Ensuite, essayez d'utiliser les deux premières questions dans le cadre des mots d'invite, et laissez le modèle répondre à la quatrième question, regardez le code :
prompt_Few_shot3 = 'Q：“罗杰有五个网球，他又买了两盒网球，每盒有3个网球，请问他现在总共有多少个网球？” \
A：“现在罗杰总共有11个网球。” \
Q：“食堂总共有23个苹果，如果他们用掉20个苹果，然后又买了6个苹果，请问现在食堂总共有多少个苹果？” \
A：“现在食堂总共有9个苹果。” \
Q：“艾米需要4分钟能爬到滑梯顶部，然后需要花费1分钟滑下来，现在水滑梯将在15分钟后关闭，请问在关闭之前她能滑多少次？” \
A：'
response_Few_shot3 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Few_shot3,
max_tokens=1000,
)
response_Few_shot3["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
La quatrième question a également reçu une réponse incorrecte. Cela montre également que la méthode des indices en quelques coups peut améliorer la capacité de raisonnement du modèle dans une certaine mesure, mais l'amélioration est limitée.Pour des questions de raisonnement légèrement plus complexes, le modèle ne peut toujours pas donner de réponses précises .
L'utilisation de Few-shot est relativement simple, mais en fait il existe de nombreuses variantes de Few-shot. L'une des variantes très importantes consiste à modifier les exemples autour des invites, c'est-à-dire non seulement fournir des questions + réponses dans les exemples, mais aussi quelques « indices » pour aider à la réflexion et au jugement seront ajoutés.
4. Méthode d'invite de chaîne de réflexion
4.1 Méthode d'invite Zero-shot-CoT
Zero-shot-CoT est une meilleure méthode d'indice sous l'idée de Few-shot. Il utilise la méthode d’indice de chaîne de pensée (également connue sous le nom de chaîne de pensée, CoT) pour résoudre ce problème. Un moyen très simple et efficace consiste à ajouter une phrase « Pensons étape par étape » à la fin du mot d'invite, ce qui peut grandement améliorer la capacité de raisonnement du modèle.
Cette méthode a été proposée pour la première fois par l'Université de Tokyo et Google dans l'article « Large Language Models are Zero-Shot Reasoners » . Cette approche est également appelée Zero-shot-CoT car seuls les mots d'invite doivent être modifiés sans écrire manuellement des exemples de dérivation réussis (pas besoin d'écrire des échantillons de chaîne de pensée) .
Selon la description de l'article original, l'auteur a essayé de nombreux groupes différents de suffixes de mots d'invite lors du test de la méthode Zero_shot_CoT, et a testé sur un ensemble de données d'instructions de robot, et a finalement découvert que « Pensons étape par étape » fonctionne mieux, d'autres instructions et divers Le classement de l'exactitude des instructions est le suivant :
Si vous passez au contexte chinois et traduisez la commande « Réfléchissons étape par étape » en chinois, après avoir fait de nombreux tests, vous pouvez conclure que « Veuillez raisonner étape par étape et tirer une conclusion » est bien meilleur que « S'il vous plaît, réfléchissons pas à pas ». pensez étape par étape" et d'autres mots et phrases similaires , cette situation a également donné une inspiration très profonde, c'est-à-dire que le "processus de réflexion" du grand modèle est un modèle de boîte noire, même si les mots rapides avec des significations similaires sont réalistes pour le modèle L'influence peut avoir une très grande différence , vous pouvez le tester vous-même, l'effet est très différent.
Utilisez la commande "Veuillez raisonner étape par étape et tirer une conclusion" pour tester dans le contexte chinois,
- question de raisonnement 1
regarde le code
prompt_Zero_shot_CoT1 = '罗杰有五个网球，他又买了两盒网球，每盒有3个网球，请问他现在总共有多少个网球？请一步步进行推理并得出结论。'
response_Zero_shot_CoT1 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Zero_shot_CoT1,
max_tokens=1000,
)
response_Zero_shot_CoT1["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
- Question de raisonnement 2
Regardez le code :
prompt_Zero_shot_CoT2 = '食堂总共有23个苹果，如果他们用掉20个苹果，然后又买了6个苹果，请问现在食堂总共有多少个苹果？请一步步进行推理并得出结论。'
response_Zero_shot_CoT2 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Zero_shot_CoT2,
max_tokens=1000,
)
response_Zero_shot_CoT2["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
- question de raisonnement 3
Regardez le code :
prompt_Zero_shot_CoT3 = '杂耍者可以杂耍16个球。一半的球是高尔夫球，一半的高尔夫球是蓝色的。请问总共有多少个蓝色高尔夫球？请一步步进行推理并得出结论。'
response_Zero_shot_CoT3 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Zero_shot_CoT3,
max_tokens=1000,
)
response_Zero_shot_CoT3["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
- question de raisonnement 4
Regardez le code :
prompt_Zero_shot_CoT4 = '艾米需要4分钟能爬到滑梯顶部，然后需要花费1分钟滑下来，现在水滑梯将在15分钟后关闭，请问在关闭之前她能滑多少次？请一步步进行推理并得出结论。'
response_Zero_shot_CoT4 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Zero_shot_CoT4,
max_tokens=1000,
)
response_Zero_shot_CoT4["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
En fait, la quatrième question reçoit toujours une réponse incorrecte.
Après la vérification de quatre questions de dérivation logique, il est vrai que Zero-shot-CoT est plus efficace que Few-shot, c'est-à-dire qu'il peut considérablement améliorer la capacité de raisonnement du modèle grâce à des invites plus concises.
Deux autres conclusions importantes de l’article :
La deuxième conclusion sur laquelle il faut se concentrer est la suivante : dans cet article, pour la première fois, l'idée d'utiliser un grand modèle pour un raisonnement en deux étapes est proposée, c'est-à-dire que la première étape divise d'abord le problème et résout le problème en sections (Reasoning Extraction), puis dans la deuxième étape, l'extraction de réponse (Answer Extraction) sera effectuée , ce qui donnera une grande inspiration à la méthode d'invite LtM ultérieure.
Troisième conclusion importante de cet article : l'auteur a vérifié par des tests qu'en utilisation réelle, Zero-shot-CoT est légèrement plus faible que la méthode Few-shot-CoT.
Le document indique clairement que plus le modèle est grand, plus l'effet du CoT est important. En d'autres termes, plus le modèle est grand, plus l'effet du CoT sur la « capacité d'émergence » du modèle est important. Et GPT-3 peut atteindre un taux de précision d’environ 55 % sur l’ensemble de données GSM8K.
GSM8K est un ensemble de données très connu composé de problèmes de mathématiques à l'école primaire, qui est souvent utilisé pour tester la capacité de raisonnement du modèle.
4.2 Méthode d'indice de quelques coups-CoT
En termes d'heure de naissance, Few-shot-CoT est né plus tôt que Zero-shot-CoT. La différence entre eux est la suivante : Zero-shot-CoT stimule la réflexion du modèle en modifiant le suffixe du mot d'invite dans le cas de chaîne d'invites à tir zéro, et Few-shot-CoT consiste à écrire l'échantillon de chaîne de pensée sous forme de mot d'invite, à laisser le modèle apprendre la méthode de dérivation de la chaîne de réflexion, afin de mieux terminer la tâche de dérivation .
Cette méthode a été proposée pour la première fois par l'équipe Google Brain dans l'article "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models" . C'est également dans cet article que le concept de chaîne de pensée a été proposé pour la première fois, donc cet article peut On peut dire qu'il est le premier de la chaîne de pensée, l'initiateur de la montagne.
Comparé à Few-shot, Few-shot-CoT n'est différent que dans le sens où il doit donner non seulement la réponse à la question dans l'échantillon d'invite, mais également le processus de dérivation de la question (c'est-à-dire la chaîne de pensée). Pour que le modèle puisse apprendre le processus de dérivation de la chaîne de pensée et l'appliquer à de nouveaux problèmes . Une série de conclusions sont données dans l'article pour démontrer la validité de l'application de la chaîne de pensée dans ces domaines.
Par exemple, autour du raisonnement 1, écrivez manuellement une chaîne de pensées à titre d'exemple :
'Q : "Roger a cinq balles de tennis et il a acheté deux autres boîtes de balles de tennis, chacune contenant 3 balles de tennis. Combien de balles de tennis a-t-il au total maintenant ?" A : " Roger avait cinq balles de tennis au début
, et il en a acheté une autre. Il a acheté deux boîtes de balles de tennis, chaque boîte de 3 balles de tennis, et a acheté un total de 6 balles de tennis, donc maintenant le total est de 5+6=11 balles de tennis. La réponse est donc 11."'
Après avoir obtenu un exemple de chaîne de pensée, vous pouvez l'utiliser comme exemple pour effectuer Few-shot-CoT afin de résoudre le deuxième problème de raisonnement. Regardez le code :
prompt_Few_shot_CoT2 = 'Q：“罗杰有五个网球，他又买了两盒网球，每盒有3个网球，请问他现在总共有多少个网球？” \
A：“罗杰起初有五个网球，又买了两盒网球，每盒3个，所以，他总共买了2×3=6个网球，将起始的数量和购买的数量相加，可以得到他现在总共的网球数量：5+6=11，所以罗杰现在总共有11个网球” \
Q：“食堂总共有23个苹果，如果他们用掉20个苹果，然后又买了6个苹果，请问现在食堂总共有多少个苹果？” \
A：'
response_Few_shot_CoT2 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Few_shot_CoT2,
max_tokens=1000,
)
response_Few_shot_CoT2["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
À partir des résultats, le modèle peut très bien répondre à la deuxième question. Ensuite, saisissez la chaîne de pensée des deux premières questions comme mots d'invite pour guider le modèle dans la résolution de la troisième question. Regardez le code :
prompt_Few_shot_CoT3 = 'Q：“罗杰有五个网球，他又买了两盒网球，每盒有3个网球，请问他现在总共有多少个网球？” \
A：“罗杰一开始有五个网球，又购买了两盒网球，每盒3个，共购买了6个网球，因此现在总共由5+6=11个网球。因此答案是11。” \
Q：“食堂总共有23个苹果，如果他们用掉20个苹果，然后又买了6个苹果，请问现在食堂总共有多少个苹果？” \
A：“食堂起初有23个苹果，用掉20个，又买了6个，将苹果的减少量减去使用量，加上购买的数量，可以得到现在食堂总共的苹果数量：23-20+6=9，所以现在食堂总共有9个苹果。” \
Q：“杂耍者可以杂耍16个球。一半的球是高尔夫球，一半的高尔夫球是蓝色的。请问总共有多少个蓝色高尔夫球？” \
A：'
response_Few_shot_CoT3 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Few_shot_CoT3,
max_tokens=1000,
)
response_Few_shot_CoT3["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
Continuez à superposer, regardez la dernière question, le code est le suivant :
prompt_Few_shot_CoT4 = 'Q：“罗杰有五个网球，他又买了两盒网球，每盒有3个网球，请问他现在总共有多少个网球？” \
A：“罗杰一开始有五个网球，又购买了两盒网球，每盒3个，共购买了6个网球，因此现在总共由5+6=11个网球。因此答案是11。” \
Q：“食堂总共有23个苹果，如果他们用掉20个苹果，然后又买了6个苹果，请问现在食堂总共有多少个苹果？” \
A：“食堂最初有23个苹果，用掉20个，然后又买了6个，总共有23-20+6=9个苹果，答案是9。” \
Q：“杂耍者可以杂耍16个球。一半的球是高尔夫球，一半的高尔夫球是蓝色的。请问总共有多少个蓝色高尔夫球？” \
A：“杂耍者总共能杂耍16个球，并且一半是高尔夫球，而且高尔夫球有一半是蓝色的。所以蓝色高尔夫球的数量是 8 ÷ 2 = 4，也就是说总共有4个蓝色的高尔夫球。” \
Q：“艾米需要4分钟能爬到滑梯顶部，然后需要花费1分钟滑下来，现在水滑梯将在15分钟后关闭，请问在关闭之前她能滑多少次？” \
A：'
response_Few_shot_CoT4 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Few_shot_CoT4,
max_tokens=1000,
)
response_Few_shot_CoT4["choices"][0]["text"].strip()
Regardez les résultats :
La chaîne de pensée des trois premières questions a été saisie sous forme d’échantillon de mots rapides, et la quatrième question a également pu recevoir une réponse correcte. Mais il y a un problème : j'ai testé 10 fois, et 3 d'entre eux étaient de mauvaises réponses. C'est-à-dire que même si la méthode Few-shot-CoT est efficace, elle n'est pas très stable. Si vous voulez obtenir une réponse correcte et stable , Une méthode d'indication plus avancée est nécessaire .
Selon la conclusion de l'article "Les grands modèles de langage sont des raisonneurs Zero-Shot", à partir des résultats de tests de données massives, Few-shot-CoT est plus précis que Zero-shot-CoT .
L'accent est mis sur la relation entre la taille du modèle et l'effet de la chaîne de pensée : en bref, plus le modèle est grand, meilleur est l'effet d'application Few-shot-CoT. Comme indiqué ci-dessous:
En prenant également l'ensemble de données GSM8K comme exemple, on peut voir que l'effet de modèle LaMDA (137B) < GPT-3 (175B) < PaLM (540B). Semblable au Zero-shot-CoT, plus le modèle est grand, meilleur est l'effet du CoT sur la stimulation des capacités potentielles du modèle.
4.3 Méthode d'amélioration du CoT : MOINS À PLUS D'INVITES (méthode d'invite LtM)
Peu de temps après que le CoT proposé par Google Brain ait été effectivement vérifié comme améliorant considérablement la capacité de raisonnement des grands modèles de langage, une autre équipe de Google Brain a publié un autre article de poids "LEAST-TO-MOST PROMPTING ENABLES COMPLEX RAISONING IN" sur cette base . ", dans lequel une méthode d'indice appelée Least-to-Most (LtM) est proposée pour améliorer encore la capacité de raisonnement du grand modèle de langage. Cette méthode d'indice appelée LtM peut non seulement améliorer les performances du modèle sur GSM8K jusqu'à 62 %, mais même atteindre 3 fois l'effet du CoT dans certains scénarios d'interprétation sémantique spéciaux.
Cette méthode est de loin la méthode d’apprentissage d’indices la plus efficace pour améliorer la capacité de raisonnement du modèle.
L'intention initiale de la méthode d'invite LtM est de résoudre le problème de la capacité de généralisation insuffisante de la méthode d'invite CoT, c'est-à-dire que les échantillons d'invite de chaîne de pensée écrits manuellement peuvent ne pas être en mesure de bien migrer vers d'autres problèmes. est La capacité de migration du processus de résolution de problèmes est insuffisante, c'est-à-dire que la capacité de généralisation est insuffisante. Et ce manque de capacité de généralisation conduira à de « nouveaux problèmes » qui ne peuvent être résolus à l’aide d’« anciens modèles » .
Une idée est donc la suivante : laissez le grand modèle trouver la chaîne de réflexion pour résoudre le problème actuel par lui-même . Sur la base de cette idée, Google Brain a développé un nouveau processus d'incitation, c'est-à-dire, grâce au processus d'incitation, laisser le modèle découvrir étape par étape quels problèmes doivent être résolus pour résoudre le problème, puis résoudre les problèmes les plus originaux en résolvant ces problèmes en séquence .
L'ensemble du processus d'incitation sera divisé en deux étapes, la première étape est une décomposition descendante (Décomposer la question en sous-question), la deuxième étape est une résolution ascendante du problème de manière séquentielle (Résoudre séquentiellement la sous-question), l'ensemble Le processus de réponse aux questions un par un peut en fait être considéré comme un processus CoT, mais LtM nécessitera que le modèle génère individuellement un lien pour résoudre le problème en fonction de chaque problème différent, afin que les problèmes de raisonnement complexes puissent être résolus avec plus de précision . Le passage du moins au plus dans l’ensemble du processus est à l’origine du mot MOINS AU PLUS.
L'image ci-dessus est un exemple du processus de compréhension des invites LtM proposé dans l'article. L'exemple ici est le quatrième problème de raisonnement que l'on tente de résoudre.
Dans l'article, le modèle d'invite "Pour résoudre __, nous devons d'abord résoudre :" est utilisé pour guider le modèle pour créer des sous-questions . Le modèle posera la sous-question "Combien de temps faut-il à Amy pour gravir le faites glisser + faites glisser la diapositive une fois" selon la question d'origine, puis résolvez d'abord ce sous-problème, puis résolvez le problème d'origine. Il n'est pas difficile de constater qu'il s'agit en fait d'un processus de résolution de problème en deux étapes très simple -la première étape décompose uniquement un sous-problème supplémentaire (c'est-à-dire un total de deux questions auxquelles répondre).
Selon les résultats donnés dans l'article, le modèle de première étape peut répondre très facilement "combien de temps faut-il à Amy pour monter le toboggan + glisser sur le toboggan à la fois" - 5 minutes, puis répondre avec succès au temps d'Amy avant la fermeture du toboggan. Des conclusions précises qui peuvent être jouées trois fois.
Dans la deuxième étape, c'est-à-dire que la résolution séquentielle de la sous-question ne consiste pas simplement à résoudre deux problèmes en séquence, mais après avoir résolu les sous-questions, la question d'origine, la sous-question, la question et la réponse sont toutes entrées dans le grand modèle de langage sous forme d'invite. , Laissez-le répondre à la question initiale.
Par conséquent, le cœur de LtM n'est pas seulement de guider le modèle pour diviser le problème, mais aussi de renvoyer les questions et réponses des sous-questions au modèle dans le temps, afin de mieux répondre à la question d'origine.
Théoriquement, il y aura trois appels au grand modèle dans l'ensemble du processus, et le processus de questions et réponses est le suivant :
Essayez de cette façon, regardez le code :
prompt_Zero_shot_LtM4 = 'Q：“艾米需要4分钟能爬到滑梯顶部，然后需要花费1分钟滑下来，现在水滑梯将在15分钟后关闭，请问在关闭之前她能滑多少次？”\
A：为了解决“在关闭之前她能滑多少次？”这个问题，首先需要解决的问题是'
response_Zero_shot_LtM4 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Zero_shot_LtM4,
max_tokens=1000,
)
response_Zero_shot_LtM4["choices"][0]["text"].strip()
Les résultats d'inférence du modèle sont les suivants :
Le processus d'invite LtM peut très bien résoudre ce problème de raisonnement. De plus, dans le processus de test réel, le modèle peut non seulement démonter la tâche, mais également répondre automatiquement à la question d'origine en fonction des réponses aux sous-questions démontées, et enfin répondre avec précision à la question d'origine dans une phrase rapide.
"Afin de résoudre le problème de "__", le premier problème que nous devons résoudre est __" est également un modèle Word d'invite éprouvé qui est le plus approprié et auquel on peut répondre le plus précisément. Il est recommandé de l'utiliser fréquemment et de vérifier sa fonction.
De même, lorsque vous utilisez LtM pour tester les trois autres questions :
- question de raisonnement 1
le code s'affiche comme ci-dessous :
prompt_Zero_shot_LtM1 = 'Q：“罗杰有五个网球，他又买了两盒网球，每盒有3个网球，请问他现在总共有多少个网球？”\
A：为了解决“罗杰总共又多少个网球？”这个问题，首先要解决的问题是'
prompt_Zero_shot_LtM1 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Zero_shot_LtM1,
max_tokens=1000,
)
prompt_Zero_shot_LtM1["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
- Question de raisonnement 2
le code s'affiche comme ci-dessous :
prompt_Zero_shot_LtM2 = 'Q：“食堂总共有23个苹果，如果他们用掉20个苹果，然后又买了6个苹果，请问现在食堂总共有多少个苹果？”\
A：为了解决“现在食堂总共有多少个苹果”这个问题，首先要解决的问题是'
prompt_Zero_shot_LtM2 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Zero_shot_LtM2,
max_tokens=1000,
)
prompt_Zero_shot_LtM2["choices"][0]["text"].strip()
Regardez les résultats de l'inférence :
- question de raisonnement 3
le code s'affiche comme ci-dessous :
prompt_Zero_shot_LtM3 = 'Q：“杂耍者可以杂耍16个球。一半的球是高尔夫球，一半的高尔夫球是蓝色的。请问总共有多少个蓝色高尔夫球？”\
A：为了解决“总共有多少个蓝色高尔夫球”这个问题，首先要解决的问题是'
prompt_Zero_shot_LtM3 = openai.Completion.create(
model="text-davinci-003",
prompt=prompt_Zero_shot_LtM3,
max_tokens=1000,
)
prompt_Zero_shot_LtM3["choices"][0]["text"].strip()
Les résultats du raisonnement sont les suivants :
Grâce à un grand nombre de tests, le processus d'invite LtM peut très bien aider le modèle à résoudre les problèmes ci-dessus, ce qui montre également que LtM a un effet très significatif sur l'amélioration de la capacité de raisonnement des grands modèles de langage. essayé jusqu'à présent (en termes de résolution de problèmes de raisonnement) est le type de méthode d'incitation le plus efficace, mais il convient de noter que même si l'effet est très bon, il existe encore des cas d'erreurs de calcul du modèle, qui ne peuvent être évitées. Ce qu'il faut faire à l'heure actuelle est d'explorer continuellement les méthodes d'incitation qui peuvent stabiliser au maximum la sortie correcte.
V. Résumé
Cet article présente d'abord quatre problèmes de raisonnement classiques, puis explique en détail les méthodes d'apprentissage rapide One-shot et Few-shot. La partie centrale est la méthode d'invite de la chaîne de pensée, y compris la méthode d'invite Zero-shot-CoT, la méthode d'invite Few-shot-CoT et la méthode CoT améliorée LEAST-TO-MOST PROMPTING (méthode d'invite LtM). Ces contenus approfondis sont conçus pour aider à comprendre et à maîtriser des techniques d’ingénierie d’indices plus avancées pour une application et une optimisation plus efficaces dans le développement de grands modèles.
Documents de référence :
- Référence technique en quelques étapes : « Les modèles linguistiques sont des apprenants en quelques étapes »
- Zero-shot-CoT参考文献 : 《Les grands modèles de langage sont des raisonneurs Zero-Shot》
- Few-shot-CoT参考文献 : 《L'incitation à la chaîne de pensée suscite le raisonnement dans de grands modèles de langage》
- Référence de la méthode LtM : 《UNE INVITE DU MOINS AU PLUS PERMET UN RAISONNEMENT COMPLEXE DANS DE GRANDS MODÈLES DE LANGAGE》
Enfin, merci d’avoir lu cet article ! Si vous sentez que vous avez gagné quelque chose, n'oubliez pas d'aimer, de mettre en signet et de me suivre, c'est la motivation de ma création continue. Si vous avez des questions ou des suggestions, vous pouvez laisser un message dans la zone de commentaires, je ferai de mon mieux pour répondre et accepter vos commentaires. S'il y a un sujet particulier que vous aimeriez connaître, n'hésitez pas à me le faire savoir et je serai ravi d'écrire un article à ce sujet. Merci pour votre soutien et au plaisir de grandir avec vous !