LLM 几种推理Prompt技术介绍

2024-08-30 约 5624 字预计阅读 12 分钟次阅读

LLM 几种推理Prompt技术介绍

本文主要介绍Reasoning and Logic逻辑与推理的部分提示词使用范式

CoT(Chain of Thought)[2022]

模仿人类解决问题时的思维过程，将问题分解为一系列中间的推理步骤。在Prompt中增加几个思考推理过程的示例，示例包括输入、推理步骤、详细解释以及最终答案。如：

1
2


Q: 食堂原本有23个苹果。他们用了20个来做午餐。之后他们又买了6个苹果。他们现在有多少个苹果？ 
A: 食堂原本有23个苹果。他们用了20个来做午餐，所以剩下 23 - 20 = 3 个苹果。然后他们又买了6个苹果，所以现在总共有 3 + 6 = 9 个苹果。答案是9。

论文指出，在模型足够大（大于100B参数），这种方法才会有显著的性能提升过程中示例的好坏也会影响的准确性

Auto-CoT[2022]

在CoT之后提出，根据名字也可以看出主要是自动做CoT，上面说到示例的好坏对模型的输出也有较大影响，这里主要提出一种自动化选择样例的方法

主要方法是对基准数据集或者测试集进行处理，利用预训练模型将具体的问题转换成向量表示，利用k-means等聚类算法将问题进行聚类分组到k个簇中，每个簇代表一类具有相似特征的问题。问题离簇的中心越近则与簇中心的相似度更高

在处理具体问题时，对问题进行向量化编码，使用分类模型进行具体的聚类，找到所属类簇中最接近中心的问题作为这一簇问题最有代表性的问题，将这个问题题目和推理过程作为CoT的示例组装到Prompt中以实现自动化的CoT过程

Self-Consistency[2022]

自我一致性方法的思想也很简单，通过CoT的方式让大模型提供多种思维链，生成多种的方式可以调节大模型的Temperature，Top-k等参数的方式来让大模型生成更加多样化的思维链。这个过程叫做Sampling采样。

采样到多个思维链以后通过marginalize边缘化就比较简单了，通过聚合多个推理路径确定最终的答案。可以通过根据答案出现频率投票，也可以采用其他的一些聚合方式来判断最终采用哪一种方式

LogiCoT[2023]

考虑多步骤推理场景中不能有效利用知识建立连贯的思考范式，推理过程不受逻辑原则约束，模型会出现幻觉基于这种考虑，希望推理过程中加入逻辑验证，主要是将反证法等让模型进行自我检查，引导模型进行逻辑推理

具体的做法比较复杂，基本的步骤是：

利用LLM生成一个推理步骤
针对推理步骤的每一步：
- 利用LLM生成一个支持推理的解释
- 利用LLM生成一个反对推理的解释
- 利用LLM选择两个解释的中合理的一个解释，如果选择的是支持的那就证明是这一步是ok的，否则就修正这一步解释
更新修正后的解释步骤并利用其生成结果

整体看起来就是一顿操作猛如虎，实际收益0.5，借鉴下思路是那么个意思得了，想要深入了解下步骤与Prompt可以参考github上的示例：LoT

CoS[2023]

主要的思想是使用符号将问题进行抽象，让模型以符号语言来做推理，这样可以以更简单的表示，更少的token来降低问题复杂度，让大模型获得更好的性能。主要问题域：

LLM的空间理解能力不足（解决空间类数学问题或逻辑问题时可能遇到）
很多自然语言表达能力不如符号语言简洁表达性好（在数学类问题问题中可能比较突出）
使用符号表示问题更加简洁提升LLM效率，减少资源消耗等等各种有的没的问题下，提出了一种用符号来表达问题，让LLM生成思维链的方式

可以以Few-shot的方式（当然也可以通过其他如深度学习，模型微调，元学习等方式）给到大模型让大模型来做基于符号的推理，再加上一些Self-Checking的验证，这样在某些case上取得不错的效果，下面是文章里反复提到的示例：

总体来讲我认为作为一个思路引入，当前我并没有很好的应用落地价值场景。如果要详细了解可以看

ToT[2023]

ToT是以树的形式来组织推理步骤，以树的形式来组织执行的步骤或者叫思路，使用BFS或者DFS的树遍历算法来对整个thought树进行遍历校验，找出可能性最高的路径

以BFS来解决24点问题为例（也是思想提出的论文中的一个案例），step by step的看下如何来做

与LLM交互生成所有可能的第一步解法，使用到的Prompt可能类似于：这个Prompt以Few-shot的方式给大模型以样例，让大模型输出可能的第一步，采用的计算方式与剩下的数字

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


Input: 2 8 8 14
Possible next steps:
2 + 8 = 10 (left: 8 10 14)
8 / 2 = 4 (left: 4 8 14)
14 + 2 = 16 (left: 8 8 16)
2 * 8 = 16 (left: 8 14 16)
8 - 2 = 6 (left: 6 8 14)
14 - 8 = 6 (left: 2 6 8)
14 /  2 = 7 (left: 7 8 8)
14 - 2 = 12 (left: 8 8 12)
Input: 4 5 6 10
Possible next steps:

针对第一步做一个广度遍历，针对每一个可能的步骤，提交给大模型做判断，是否可行，Prompt可能是这样的：通过几个案例给到LLM，让LLM判定这个步骤的是否可行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


Evaluate if given numbers can reach 24 (sure/likely/impossible)
// 几个示例
10 14
10 + 14 = 24
sure

11 12
11 + 12 = 23
12 - 11 = 1
11 * 12 = 132
11 / 12 = 0.91
impossible

4 4 10
4 + 4 + 10 = 8 + 10 = 18
4 * 10 - 4 = 40 - 4 = 36
(10 - 4) * 4 = 6 * 4 = 24
sure

4 9 11
9 + 11 + 4 = 20 + 4 = 24
sure

5 7 8
5 + 7 + 8 = 12 + 8 = 20
(8 - 5) * 7 = 3 * 7 = 21
I cannot obtain 24 now, but numbers are within a reasonable range
likely

5 6 6
5 + 6 + 6 = 17
(6 - 5) * 6 = 1 * 6 = 6
I cannot obtain 24 now, but numbers are within a reasonable range
likely

10 10 11
10 + 10 + 11 = 31
(11 - 10) * 10 = 10
10 10 10 are all too big
impossible

1 3 3
1 * 3 * 3 = 9
(1 + 3) * 3 = 12
1 3 3 are all too small
impossible

//待评估步骤问题

评估：根据模型给出的判断进行评估，评估方式可以根据LLM给出的响应来规则判断，也可以继续交给大模型来判断，比如使用Given an instruction and several choices, decide which choice is most promising. Analyze each choice in detail, then conclude in the last line "The best choice is {s}", where s the integer id of the choice这种Prompt做选择或者做评分
继续遍历：根据筛选出来的结果评估，选出top-k的选项，然后交给大模型继续生成下一步，循环执行上面操作直至最终得到一个最好的结果

整个过程与大模型交互非常多，可能耗费很长时间，本质上也是Reflection与Self-check的应用

GoT[2023]

相对于ToT，以图的方式提供更加灵活的推理路径与回溯方式，主要的结构范式：

整个范式分为几个关键的部分：

Prompter: 为与LLM交互生成Prompt，具体步骤节点使用的Prompt以及Grounding
Parser：解析LLM的返回结果，从LLM中抽取状态形成一个thought
Score：对步骤进行评分，评分可以使用LLM或者规则编码来做
Ranking：对各种thought的评分进行排序，选择top-k的thought
Controller：这个是GoT的核心控制部分，对于图的构造与执行进行控制，里面包含两个关键部分
- GoO: 静态图，是针对一类问题的思考步骤图，如针对排序问题，分成split、sort、merge、refine等，这个主要体现的问题的拆解方法图
- GRS：执行状态图，对照GoO，在执行时具体执行到什么状态，现在的状态是什么，下一步要做什么等

以排序为例，对一个64个数字进行排序，下面是规划的一个GoO图，这个图需要在解决某一类问题时进行手动构建的，一次构建，后面针对这类问题都可以遵从这种图的逻辑

我们可以看到，针对每一次与LLM的交互，我们会做多次采样，采样后进行评分，选择最好的结果，这也与其他的思想类似，主要是我们要将问题建模成这样一张思维图

这里给出一些在排序问题种具体使用的LLM Prompt样例：

步骤1：让LLM拆分数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<Instruction> Split the following list of 32 numbers into 2 lists of 16 numbers each, the first list should contain the first 16 numbers and the second list the second 16 numbers.
Only output the final 2 lists in the following format without any additional text or thoughts!:
{{
    "List 1": [3, 4, 3, 5, 7, 8, 1, ...],
    "List 2": [2, 9, 2, 4, 7, 1, 5, ...]
}} </Instruction>

<Example>
Input: [9, 6, 7, 7, 2, 0, 2, 2, 3, 5, 0, 9, 2, 2, 4, 4, 5, 2, 5, 1, 2, 8, 3, 8, 3, 9, 6, 0, 4, 2, 2, 3]
Output: 
{{
    "List 1": [9, 6, 7, 7, 2, 0, 2, 2, 3, 5, 0, 9, 2, 2, 4, 4],
    "List 2": [5, 2, 5, 1, 2, 8, 3, 8, 3, 9, 6, 0, 4, 2, 2, 3]
}}
</Example>

Input: {input}

步骤2：让LLM排序拆分后的数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


<Instruction> Sort the following list of numbers in ascending order. Output only the sorted list of numbers, no additional text. </Instruction>

<Examples>
Input: [5, 1, 0, 1, 2, 0, 4, 8, 1, 9, 5, 1, 3, 3, 9, 7]
Output: [0, 0, 1, 1, 1, 1, 2, 3, 3, 4, 5, 5, 7, 8, 9, 9]

Input: [3, 7, 0, 2, 8, 1, 2, 2, 2, 4, 7, 8, 5, 5, 3, 9, 4, 3, 5, 6, 6, 4, 4, 5, 2, 0, 9, 3, 3, 9, 2, 1]
Output: [0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 9]

Input: [4, 4, 9, 7, 9, 7, 0, 0, 4, 9, 1, 7, 9, 5, 8, 7, 5, 6, 3, 8, 6, 7, 5, 8, 5, 0, 6, 3, 7, 0, 5, 3, 7, 5, 2, 4, 4, 9, 0, 7, 8, 2, 7, 7, 7, 2, 1, 3, 9, 9, 7, 9, 6, 6, 4, 5, 4, 2, 0, 8, 9, 0, 2, 2]
Output: [0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9]
</Examples>

Input: [0, 2, 6, 3, 8, 7, 1, 1, 6, 7, 7, 7, 7, 9, 3, 0]

步骤5：对排序后的数组进行归并

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


<Instruction> Merge the following 2 sorted lists of length 16 each, into one sorted list of length 32 using a merge sort style approach.
Only output the final merged list without any additional text or thoughts!:</Instruction>

<Approach>
To merge the two lists in a merge-sort style approach, follow these steps:
1. Compare the first element of both lists.
2. Append the smaller element to the merged list and move to the next element in the list from which the smaller element came.
3. Repeat steps 1 and 2 until one of the lists is empty.
4. Append the remaining elements of the non-empty list to the merged list.
</Approach>

Merge the following two lists into one sorted list:
1: [0, 0, 1, 1, 2, 3, 3, 6, 6, 7, 7, 7, 7, 7, 8, 9]
2: [1, 1, 1, 3, 3, 4, 4, 5, 5, 5, 6, 7, 7, 7, 9]

Merged list:

步骤8：对LLM结果进行纠偏

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


<Instruction> The following two lists represent an unsorted list of numbers and a sorted variant of that list. The sorted variant is not correct. Fix the sorted variant so that it is correct.
Make sure that the output list is sorted in ascending order, has the same number of elements as the input list (32), and contains the same elements as the input list. </Instruction>

<Approach>
To fix the incorrectly sorted list follow these steps:
1. For each number from 0 to 9, compare the frequency of that number in the incorrectly sorted list to the frequency of that number in the input list.
2. Iterate through the incorrectly sorted list and add or remove numbers as needed to make the frequency of each number in the incorrectly sorted list match the frequency of that number in the input list.
</Approach>

<Examples>
Input: [3, 7, 0, 2, 8, 1, 2, 2, 2, 4, 7, 8, 5, 5, 3, 9]
Incorrectly Sorted: [0, 0, 0, 0, 0, 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 7, 7, 8, 8, 9, 9, 9, 9]
Reason: The incorrectly sorted list contains four extra 0s, two extra 4s and three extra 9s and is missing two 2s.
Output: [0, 1, 2, 2, 2, 2, 3, 3, 4, 5, 5, 7, 7, 8, 8, 9]

Input: [6, 4, 5, 7, 5, 6, 9, 7, 6, 9, 4, 6, 9, 8, 1, 9, 2, 4, 9, 0, 7, 6, 5, 6, 6, 2, 8, 3, 9, 5, 6, 1]
Incorrectly Sorted: [0, 1, 1, 2, 2, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9]
Reason: The incorrectly sorted list contains two extra 4s and is missing two 6s and one 9.
Output: [0, 1, 1, 2, 2, 3, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9]

Input: [4, 4, 9, 7, 9, 7, 0, 0, 4, 9, 1, 7, 9, 5, 8, 7, 5, 6, 3, 8, 6, 7, 5, 8, 5, 0, 6, 3, 7, 0, 5, 3, 7, 5, 2, 4, 4, 9, 0, 7, 8, 2, 7, 7, 7, 2, 1, 3, 9, 9, 7, 9, 6, 6, 4, 5, 4, 2, 0, 8, 9, 0, 2, 2]
Incorrectly Sorted: [0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9]
Reason: The incorrectly sorted list contains one extra 8 and is missing two 2s, one 3, three 4s, two 5s, one 6, six 7s and one 9.
Output: [0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9]
</Examples>

Input: [0, 2, 6, 3, 8, 7, 1, 1, 6, 7, 7, 7, 7, 9, 3, 0, 1, 7, 9, 1, 3, 5, 1, 3, 6, 4, 5, 4, 7, 3, 5, 7]
Incorrectly Sorted: [0, 0, 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 7, 7, 7, 8, 9, 9]

S2A [2023]

针对Transformer模型的自注意力机制，模型可能会将上下文中不相关的信息纳入到其潜在表示中，对下一个词的生成产品不利影响。针对这种问题提出S2A，利用LLM以自然语言进行推理和遵循指令的能力来决定要关注什么

这个思想逻辑很清楚简单，看上去也很有道理，具体的实现方式就是先让大模型对上下文重新生成，利用重新生成的上下文来生成最终的响应

一种生成指令PS2A样例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Given the following text by a user, extract the part that is unbiased and not their opinion, so that using that text alone would be good context for providing an unbiased answer to the question portion of the text. 

Please include the actual question or query that the user is asking. Separate this into two categories labeled with “Unbiased text context (includes all content except user’s bias):” and “Question/Query (does not include user bias/preference):”. 

Text by User: [ORIGINAL INPUT PROMPT]

请仔细阅读以下文本，并识别出与问题直接相关的内容。忽略任何不相关或带有个人意见的信息。
然后，重构一个只包含必要信息的上下文，并以"Unbiased text context (includes all content except user’s bias):"和"Question/Query (does not include user bias/preference):"为标签，清晰地展示无偏见的文本内容和实际问题。 

原始输入提示： [ORIGINAL INPUT PROMPT]

ThoT[2023]

ThoT主要为了解决在混乱上下文中LLM生成遇到的问题，比如在RAG中召回的多样的信息，如何让大模型系统化的分段分析扩展上下文，对长上下文进行知识追踪，分析提取有用信息，提升生成质量

简单来看可以通过一段prompt让大模型一步步的分析总结，根据不同的上下文片段分析提取出不同的相关信息，再让大模型生成最终的结果，这种思想可以进行扩展，形成标准化的步骤：

通过Prompt逐步总结分析上下文

1

Walk me through this context in manageable parts step by step, summarizing and analyzing as we go.

将上下文按照逻辑分段，将复杂的上下文信息分割成更小、更易于管理的部分。这有助于模型集中注意力，并逐步处理信息
通过逐步的提示，引导模型依次分析每个部分的内容。每个提示都旨在深入理解上下文中的一个特定方面或片段
在每个步骤中，模型需要识别和提取与问题相关的信息。这可能涉及识别关键实体、事件或概念
将提取的信息通过逻辑关系连接起来，构建对问题的回答。这可能包括识别因果关系、对比关系或其他相关联系
在每个分析步骤之后，模型生成对当前上下文部分的总结，并分析其对回答问题的贡献
如果需要更深层次的理解，模型可以迭代地深入分析每个部分，逐渐构建起对整个上下文的全面认识
在完成所有分析步骤后，模型综合所有信息，提炼出一个清晰、准确的结论并提供一个明确的答案

Chain-of-Table[2024]

主要为了解决基于表格数据的问题回答问题，与通用推理相比，基于表格的推理需要从半结构化表格数据中提取潜在的信息，这种框架思想使用表格数据作为推理链中的中间代理，利用LLM的tool use或function use的能力，让llm对表格数据进行操作，生成一个表格推理链，动态计划下一个操作，在一些表格数据推理取得不错的效果，逻辑比较简单，一张图可以表示清楚基本过程

图中是chain-of-table论文中举得例子，请将焦点放到(c) Chain-of-Table

示例中根据表格的数据让判断top3的自行车手中哪个国家的最多，Chain-of-Table的处理方式更加接近认知智能的框架，类似于Agent的处理方式，循环交给LLM判断下一步操作并执行（针对表格的操作）并提取参数执行，直到llm “get the answer”。

目录

LLM 几种推理Prompt技术介绍

LLM 几种推理Prompt技术介绍

CoT(Chain of Thought)[2022]

Auto-CoT[2022]

Self-Consistency[2022]

LogiCoT[2023]

CoS[2023]

ToT[2023]

GoT[2023]

S2A [2023]

ThoT[2023]

Chain-of-Table[2024]