LEAST-TO-MOST PROMPTING ENABLES COMPLEX REASONING IN LARGE LANGUAGE MODELS---附录-扫描

附录-扫描

    

提示上下文

在本节中，我们将介绍3.2节中用于扫描基准的提示上下文。它为标准提示、最少到最多提示和思想链提示中的每一个都包括一个上下文。

标准提示

标准提示的上下文由一组命令和相应的动作序列组成。

Q:“左转”
A:“左转”
Q:“右转”
A:“右转”
Q:“跳左”
A:“左转”+“跳”
Q:“跑右”
A:“右转”+“跑”
Q:“看两遍”
A:“看”* 2 
Q:“跑两遍”
A:“看”* 2 
Q:“跳右三遍”
A:(“右转”+“跳”)* 3 
Q:“跑后走”
A:“跑”+“走”
Q:“对面左转”* 2
问:“向左转”
A:“向左转”* 4
问:“向右转”
A:“向右转”* 2
问:“向右转”
A:“向左转”* 4
问:“向左转”
A:“向左转”* 2 +“步行”
Q:“向左转”
A:(“向左转”+“步行”)* 4 

最少到最多的提示

对于最少到最多的提示，我们需要2个不同的提示上下文:一个将命令分解为组件序列，一个将命令映射到动作。
命令映射。命令映射提示上下文由一组命令以及相应的操作序列和如何获得它们的解释组成。

问:“左转”
答:“左转”输出“左转”。
问:“右转”
答:“右转”输出“右转”。
问:“向左跳”
答:“向左跳”的输出串联:“向左转”的输出，“跳”的输出。“左转”输出“左转”。“跳转”输出“跳转”。所以串联“左转”的输出和“跳”的输出，导致“左转”+“跳”。所以“向左跳”的输出是“左转”+“跳”。
问:“向右跑”
答:“向右跑”的输出串联:“向右转”的输出，“跑”的输出。“右转”输出“右转”。“运行”输出“运行”。所以串联“右转”的输出和“跑”的输出导致“右转”+“跑”。所以“向右跑”的输出是“向右转”+“跑”。
问:《看两遍》
答:《看两遍》的输出串联:《看》的输出，《看》的输出。“看”输出“看”。所以重复两次“look”的输出导致“LOOK”* 2。所以“看两遍”的输出是“看”* 2。
问:“跑看两遍”
答:“跑看两遍”的输出串联:“跑”的输出，“看两遍”的输出。“运行”输出“运行”。“看两次”输出“看”* 2。所以串联“run”的输出和“LOOK two”的输出就产生了“RUN”+“LOOK”* 2。所以“跑看两遍”的输出是“跑”+“看”* 2。
问:“右跳三次”
答:“右跳三次”的输出串联:右跳的输出，“右跳”的输出，“右跳”的输出。“右跳”输出“右转”+“跳”。所以重复三次“向右跳”的输出，就得到(“向右转”+“跳”)* 3。所以“向右跳三次”的输出是(“向右转”+“跳”)* 3。
问:《跑后走》
答:《跑后走》的输出串联:《跑》的输出，《走》的输出。“运行”输出“运行”。“行走”输出“行走”。所以把“跑”的输出和“走”的输出串联起来就是“跑”+“走”。所以“跑后走”的输出是“跑”+“走”。
问:《对面左转》
答:《对面左转》输出串联:《左转》输出，《左转》输出。“左转”输出“左转”。所以重复两次“左转”的输出导致“左转”* 2。所以“对面左转”的输出是“左转”* 2。
问:“左转”
答:“左转”的输出串联:“左转”的输出，“左转”的输出，“左转”的输出，“左转”的输出。“左转”输出“左转”。所以重复四次“左转”的输出就导致了“左转”* 4。所以“左转”的输出是“左转”* 4。
问:《对面右转》
答:《对面右转》输出串联:《右转》输出，《右转》输出。“右转”输出“右转”。所以重复两次“右转”的输出导致“右转”* 2。所以“对面右转”的输出是“右转”* 2。
问:《向右转》
答:《向右转》输出串联:《向右转》输出，《向右转》输出，《向右转》输出，《向右转》输出。“右转”输出“右转”。所以重复四次“向右转”的输出导致“向右转”* 4。所以“右转”的输出是“右转”* 4。
问:《向左对面走》
答:《向左对面走》的输出串联:《向左对面转》的输出，《走》的输出。“向左转”输出“向左转”* 2。“行走”输出“行走”。所以串联“向左转”的输出和“行走”的输出导致“向左转”* 2 +“行走”。所以“向左对面走”的输出是“左转”* 2 +“走”。
问:“绕左走”
答:“绕左走”的输出串联:“绕左走”的输出，“绕左走”的输出，“绕左走”的输出，“绕左走”的输出。“向左走”输出“向左转”+“走”。所以重复四次“向左走一圈”的输出就得到(“向左转”+“走”)* 4。所以“绕左走”的输出是(“左转”+“走”)* 4。命令分解。命令分解提示上下文由一组命令以及相应的分解命令序列组成。
问:“看两遍之后看右边”
答:“看两遍之后看右边”可以用“看右边”、“看两遍”来解决。
问:“跳对右三次走”
答:“跳对右三次”可以用“跳对右三次”、“跳对右三次”来解决。“走”可以用“走”来解决。所以，“跳右对面三次，走”可以用“跳右对面三次”，“走”来解。
问:“向左跑两次向右跑”
答:“向左跑两次”可以用“向左跑”、“向左跑两次”来解决。“向右跑”可以用“向右跑”来解决。因此，“向左跑两次，向右跑”可以通过“向左跑”、“向左跑两次”、“向右跑”来解决。
问:“跑对面右”
答:“跑对面右”可以用“跑对面右”来解决。
问:“走路后向右看三次”
答:“向右看三次”可以用“向右看三次”、“向右看三次”来解决。“走”可以用“走”来解决。所以，“走路后向右看三遍”可以用“向右看三遍”、“向右看三遍”、“走路”来解决。
问:“向右跳”
答:“向右跳”可以用“向右跳”、“向右跳”来解决。所以，“向右跳”可以解为:“向右跳”，“向右跳”。
问:“向右看三遍再走”
答:“向右看三遍”可以用“向右看”、“向右看三遍”、“向右看三遍”来解决。“走”可以用“走”来解决。所以，“向右看三次，然后走”可以用“向右看”、“向右看”、“向右看三次”、“走”来解。
问:“右转三次后右转”
答:“右转”可以用“右转”来解。“向右跑三次”可以通过“向右跑”、“向右跑三次”来解决。所以，“右转三次后右转”可以通过“右转”、“右转”、“右转三次”来解决。

思维链提示

我们从上面显示的从最少到最多的提示中重用命令映射提示上下文。

错误分析:最少到最多的提示

对于最少到最多的提示，我们分析了型号代码-davinci-001和text-davinci-002的20个随机故障，并且我们分析了型号代码-davinci-002的所有13个错误。结果如表15所示。错误可能发生在命令分解期间，也可能发生在命令翻译期间。翻译错误进一步分为以下类型。对“两次”和“三次”的不正确解释意味着模型在将“两次”和“三次”应用于表达式时出错。“after”解释为“and”意味着模型将包含“After”的表达式翻译为包含“and”。复制错误意味着模型在复制中间结果时出错。

表15:型号代码-davinci-001和text-davinci-002的20个随机故障和型号代码-davinci-002的所有13个错误的最小到最大提示错误分析。注意，对于一些例子，模型产生了不止一种类型的错误。

我们观察到，最好的模型文本-davinci-002只犯了两种类型的错误:它有时会在将“两次”和“三次”应用于包含“周围”的表达式时出错，有时会将“之后”解释为“和”。对于text-davinci-001，这是同一模型的旧版本，错误分布在所有类型中。特别值得注意的是，text-davinci-001产生了大量的分解错误和复制错误，这些错误被它的继任者完全消除了。

示范文本davinci-002在解释“两次”和“三次”时犯了大部分错误。此外，它有时会在翻译“左”和“右”时出错，这是我们在其他模型中没有观察到的。在某些情况下，它完全放弃了命令，而在其他情况下，它发明了一个新的动作，如“向左看”(见下面的例子)。

分解错误的例子。在“绕右跳三次后绕左跑两次”的例子中，code-davinci-001模型没有正确分解子表达式“绕左跑两次”。不是分解成序列[“向左跑”、“向左绕”、“向左绕两次”]，而是跳过“向左绕”，分解成[“向左跑”、“向左绕两次”]。因此，模型将此子表达式转换为(“左转”+“跑步”)* 2，而不是(“左转”+“跑步”)* 4 * 2。

在“绕左跳两次后向右看两次”的例子中，code-davinci-001模型没有适当分解子表达式“绕左跳两次”。它不是分解成序列[“向左跳”、“向左绕跳”、“向左绕跳两次”]，而是跳过“向左绕跳”，分解成[“向左跳”、“向左绕跳两次”]。有趣的是，模型能够从这个错误中恢复过来，并正确地将子表达式翻译为(“左转”+“跳”)* 4 * 2，但仍然产生了错误的最终动作序列，因为它在“喜欢”和“之后解释了”。

“两次”和“三次”的错误解读举例。在示例“绕右跑三次后向右转两次”中，code-davinci-002模型正确地将表达式“绕右跑”翻译为(“向右转”+“跑”)* 4。那么它在将“三次”应用于该表达式时出错，并产生(“向右转”+“跑”)* 9，而不是(“向右转”+“跑”)* 4 * 3或(“向右转”+“跑”)* 12。

在“向右转两次，向右转三次”的例子中，code-davinci-002模型正确地将“向右转一次”的表达式翻译为(“向右转”+“JUMP”)* 4。然后它在对这个表达式应用“三次”时出错，产生(“向右转”+“跳”)* 8，而不是(“向右转”+“跳”)* 4 * 3或(“向右转”+“跳”)* 12。

在“向左转三次后向左转三次”的示例中，code-davinci-001模型正确地将“向左转三次”的表达式翻译为“向左转”* 2 +“跑步”。然后它在对这个表达式应用“三次”时出错，产生“左转”* 2 +“跑”* 3，而不是(“左转”* 2 +“跑”)* 3。

在“向右看两次后向左走三次”的示例中，code-davinci-001模型正确地将表达式“向右看”翻译为“向右转”+“看”。那么它在将“两次”应用于该表达式时出错，并产生“向右转”+“看”* 2，而不是(“向右转”+“看”)* 2。

在“向左走，向右跑三次”的例子中，code-davinci-001模型将“三次”解释为“两次”。这意味着它产生了“左转”+“走”+(“右转”+“跑”)* 4 * 2而不是“左转”+“走”+(“右转”+“跑”)* 4 * 3。

在“向右跳两次，向左看三次”的例子中，text-davinci-002模型正确地将子表达式“向左看”翻译为(“向左”+“看”)* 4。但应用“三次”时，产生了不正确的翻译(“左转”+“看”)* 3而不是(“左转”+“看”)* 4 * 3。

将“after”解释为“and”的例子。在示例“在绕左运行两次之后向左反向运行三次”中，code-davinci-002模型为由“after”连接的两个子表达式产生正确的翻译，但是它将它们组合起来，就好像它们由“and”连接一样。这意味着模型产生(“左转”* 2 +“跑”)* 3 +(“左转”+“跑”)* 4 * 2而不是(“左转”+“跑”)* 4 * 2 +(“左转”* 2 +“跑”)* 3。

在示例“行走两次后向左行走三次”中，code-davinci-002模型为由“after”连接的两个子表达式生成正确的翻译，但是它将它们组合起来，就好像它们由“and”连接一样。这意味着模型产生(“左转”+“走”)* 4 * 3 +“走”* 2而不是“走”* 2 +(“左转”+“走”)* 4 * 3。

在“向左跳两次后向右看两次”的例子中，code-davinci-001模型为由“after”连接的两个子表达式产生正确的翻译，但是它组合它们，就好像它们由“and”连接一样。这意味着模型产生(“向右转”+“看”)* 4 * 2 +(“向左转”+“跳”)* 4 * 2而不是(“向左转”+“跳”)* 4 * 2 +(“向右转”+“看”)* 4 * 2。

“左”和“右”的错误解读举例。在示例“左看三次后右看对面三次”中，text-davinci-002模型将组件“左看”翻译为“看”，而不是“左转看”。因此，整个命令被翻译为“LOOK”* 4 * 3+(“右转”* 2+“LOOK”)* 3，而不是(“左转”+“LOOK”)* 4 * 3+(“右转”* 2+“LOOK”)* 3。

在“向左看两次后向右转三次”的示例中，text-davinci-002模型将新动作“向左看”作为组件“向左看”的翻译。因此，它将整个命令翻译为(" LOOK LEFT " * 4)* 2+(" TURN RIGHT " * 4)* 3，而不是(" TURN LEFT “+” LOOK “)* 4 * 2+(” TURN RIGHT " * 4)* 3。

复制错误示例。在示例“左顾右盼三次之后，向右转两次”中，code-davinci-001模型为与“after”相关联的两个子表达式产生正确的翻译。特别是，它正确地将“向右转两次”翻译为(“向右转”* 2 +“步行”)* 2。然后它在组合它们的时候犯了两个错误:它把“after”当成了一个“and”，它在复制表达式的时候省略了括号(“向右转”* 2+“WALK”)* 2。这意味着模型产生的翻译是“向右转”* 2 +“走”* 2 +(“向左转”+“看”)* 4 * 3”，而不是(“向左转”+“看”)* 4 * 3 +(“向右转”* 2 +“走”)* 2。

CODE-DAVINCI-002的示例输出

在本节中，我们展示了CODE-da Vinci-002模型在思维链提示和最少到最多提示方面的5个成功和失败示例。

思维链提示:成功

“对面左转三次后左转两次”
黄金:左转左转走左转走左转走向左转跳向左转跳向左转跳向左转跳向左转跳向左转跳向左转跳向左转跳
解:
Q:“向左转走三次后向左转跳两次”
A:“向左转走三次后向左转跳两次”输出串联:“向左转走三次”输出。“向左对面走三次”输出(“左转”* 2 +“走”)* 3。“绕左跳两次”输出(“左转”+“跳”)* 4 * 2。所以串联“对面向左走三次”的输出和“绕左跳两次”的输出，得到(“左转”* 2 +“走”)* 3 +(“左转”+“跳”)* 4 * 2。所以“向左转三次后向左转两次”的输出是(“向左转”* 2 +“走”)* 3 +(“向左转”+“跳”)* 4 * 2。

“左走两圈右拐三圈”
黄金:左走左走左走左走左走左走左走左走左走左走右走右走右走右走右走右走右走右走右走右走右走右走右走右走右走右走
解决方案:
Q:“左走两圈右走右走三圈”
A:“左走两圈右走右走右走 三次“串联:“向左走”的输出，“向左走”的输出，“向右转”的输出，“向右转”的输出，“向右转”的输出。 “绕左行走”输出(“左转”+“行走”)* 4。“右转”输出“右转”* 4。所以串联“绕左走”的输出，“绕左走”的输出，“绕右转”的输出，“绕右转”的输出，“绕右转”的输出导致(“左转”+“走”)* 4 +(“左转”+“走”)* 4 +“右转”* 4 +“右转”* 4 +“右转”* 4+“右转”。所以“左拐两次，右拐三次”的输出是(“左转”+“走”)* 4 +(“左转”+“走”)<