复杂推理、自我一致性与 ReAct

通过思维链、自我一致性、提示词链和 ReAct 提升复杂任务推理与执行能力。

5.复杂推理增强技术

>chain of thought 逐步推理  （大部分大模型已经实现了）
>Self-Consistency 自我一致性

# 自我一致性
# 导包
from openai import OpenAI
# 创建连接
client = OpenAI(base_url="https://dashscope.aliyuncs.com/compatible-mode/v1")
# 创建函数
def clm(up):
    response=client.chat.completions.create(
                    model="qwen3.7-plus",
                    messages=[{"role":"user","content":up}])
    return response.choices[0].message.content

# 调用函数提出一个问题，让大模型给出三种解决思路
ques = input("请提出一个问题：")
think=clm(f"""你是一个问题解决方案专家，你将会给用户提出的问题生成三种解决思路，按照python列表的格式输出:
             示例1：['解决思路1'，'解决思路2','解决思路3']
             示例2：['解决方案1'，'解决方案2','解决方案3']
             我的问题是{ques}
        """)
# print(think)

# 将生成的三个解决思路，传入三个大模型进行实现
text_list=[]
for i in eval(think):
   text=clm(f"""你是一个解决方案执行专家，请执行用户提出的解决方案，并给出一个结果。
             我的问题是{ques}
             我的思路是{i}
   """)
   text_list.append(text)

# 给三个结果投票，并输出一个最优的解决思路
res=clm(f"""你是一个结果投票专家，请对用户提出的问题，按照投票的规则进行投票，并给出一个最优的结果和对应的解决方案及思路。
             我的问题是{ques}
             我的三个结果是{text_list}
   """)
print(res)

6.多步任务执行技术

> prompt chain 分布执行
> react

6.1 ReAct

ReAct 推理与行动流程

############################# 实现思路######################
#1.调包
#2.创建连接
#3.封装大模型对话函数
   #与大模型创建对话
   #书写健壮的提示词:
      #（限制大模型使用ReAct范式输出：
         <thought> <action> <action_input）
   #返回大模型输出的结果
#4.封装处理文本函数
   #将大模型输出的结果进行处理，提取出：
    thought，action，action_input
   #将thought放进上下文{context}
#5.封装ReAct函数
   #循环执行
     #调用大模型对话函数获得res
     #调用文本处理函数得到action和action_input
     #判断action在不在功能列表loops里
        #在的话执行功能列表
        #不在的话报错
        #把action执行的结果放进上下文{context}
     #判断action是不是Final Answer
        #是的话结束循环
        #输出最终结果
#6.调用ReAct函数
################################################################

# 调包
import re
from openai import OpenAI
from small_tools import tools_dict

# 定义全局变量
context=[]

# 连接大模型
client = OpenAI(base_url="https://dashscope.aliyuncs.com/compatible-mode/v1")

# 封装大模型对话函数
def llm (ques):
    response = client.chat.completions.create(
        model="qwen3.7-plus",
        messages=[{"role": "user", "content":f"""
         你是一个使用ReAct范式的智能代理，必须按以下格式输出：
                        Thought: <你的思考，如果上下文已经有了问题的答案，不需要再验证了，调用下一个工具，如果所有问题都有答案了就停止思考。直接给Action里面写Final Answer>
                        Action: <要执行的动作，从 [{tools_dict.keys()}] 中选择，如果没有要调用的工具了就输出Final Answer>
                        Action Input: <如果工具需要参数，就把参数写在这里，如果没有参数，就什么都不要输出，
                                        如果不再思考就把问题最终的结果放在这里>
                        当前上下文：{context}
                        问题：{ques}
                      【工具列表】：{tools_dict.keys()}          
                      【工具1】get_month
                      【工具使用说明】
                            工具名称：get_month
                            工具作用：显示当前的月份
                            参数：无
                            返回值：具体月份，如：5月、6月、7月  
                     【工具2】get_year
                      【工具使用说明】
                            工具名称：get_year
                            工具作用：显示当前的年份
                            参数：无
                            返回值：具体月份，如：2025年、2026年
                     【工具3】get_weather
                     【工具使用说明】
                            工具名称：get_weather
                            工具作用：显示当前的天气
                            参数：无
                            返回值：具体天气，如：晴天、雨天、多云      
        """ }])
    # print(response.choices[0].message.content)
    return response.choices[0].message.content

# 封装数据处理函数
def process_data(text):
    # 用正则匹配格式
    thought_match = re.search(r"Thought:(.*)", text)
    action_match = re.search(r"Action:(.*)", text)
    action_input_match = re.search(r"Action Input:(.*)", text)
    # 提取文本
    thought = thought_match.group(1).strip()
    action = action_match.group(1).strip()
    action_input = action_input_match.group(1).strip() if action_input_match else ""
    # print(f"Thought: {thought}")
    # print(f"Action: {action}")
    # print(f"Action Input: {action_input}")
    # 将thought添加到上下文
    context.append(f"Thought: {thought}")
    return thought, action, action_input

# 封装ReAct函数
def ReAct(que,loop):
    # 循环
    for i in range(loop):
        # 调用大模型，得到回复文本
        res = llm(que)
        # 调用文本处理函数，得到参数
        thought, action, action_input = process_data(res)
        # 判断动作
        if action in tools_dict:
            # 调用工具
            res2 = tools_dict[action](action_input) if action_input else tools_dict[action]()
            # 将结果添加到上下文
            context.append(f"Observation: {res2}")
        elif action == "Final Answer":
            # 输出最终结果
            return (f"Final Answer: {action_input}")
    # 如果循环结束没有结果输出
    return "Final Answer: I don't know"

# 调用函数
if __name__ == '__main__':
    ask = input("请输入你要提问的问题：")
    print(ReAct(ask,5))