Chain-of-Experts: When LLMs Meet Complex Operation Research Problems代码解读

同样以main模块为主线逐行解析代码结构，以下为main模块总体代码（带注释）：

import os
import json
import numpy as np
from comment import Comment
from conductor import Conductor
from reducer import Reducer
from evaluator import Evaluator
from experts import (
    ModelingExpert, 
    ProgrammingExpert,
    LPFileGenerator,
    ModelingKnowledgeSupplementExpert,
    ParameterExtractor,
    CodeReviewer,
    ProgrammingExampleProvider,
    TerminologyInterpreter,
)
from comment_pool import CommentPool
from utils import extract_code_from_string


def chain_of_experts(problem,
                     max_collaborate_nums, 
                     model_name, 
                     enable_reflection,
                     max_trials):
    """Run Chain of Experts pipeline
    
    Args:
        problem: a dict of problem_description and code_example.
    
    Return:
        code: code of problem
    """
    all_experts = [                # 初始化所有专家
        TerminologyInterpreter(model_name),
        ParameterExtractor(model_name),
        ModelingExpert(model_name),
        ProgrammingExampleProvider(model_name),
        ProgrammingExpert(model_name),
        # LPFileGenerator(model_name),
        ModelingKnowledgeSupplementExpert(model_name),
        CodeReviewer(model_name),
    ]
    num_experts = len(all_experts)# 计算专家数量
    reducer = Reducer(model_name)# 初始化Reducer
    comment_pool = CommentPool(all_experts, visible_matrix=np.ones((num_experts, num_experts)))# 初始化评论池
    conductor = Conductor(model_name)# 初始化Conductor
    evaluator = Evaluator(model_name)# 初始化Evaluator
    expert_stack = []# 初始化专家栈
#进行多轮尝试，每轮选择一个专家，直到达到最大协作专家数。
#指挥者通过前向推理选择下一个专家，专家进行前向推理并给出评论，并将评论和专家加入评论池和专家栈。
    for _ in range(max_trials):
        for _ in range(max_collaborate_nums):
            next_expert = conductor.forward(problem, comment_pool, max_collaborate_nums)# Conductor选择下一个专家
            print(f'Choose next expert: {next_expert.name}')
            comment_text = next_expert.forward(problem, comment_pool)# 获取专家的评论
            print(f'Given comment:\n{comment_text}')
            comment_pool.add_comment(Comment(next_expert, comment_text))# 将评论加入评论池
            expert_stack.append(next_expert)
        answer = reducer.forward(problem, comment_pool)# Reducer汇总评论生成最终答案

        code = extract_code_from_string(answer)# 提取答案中的代码
        with open('generated_code.py', 'w') as f:
            f.write(code)

        if enable_reflection:# 是否启用反思机制
            test_sample = evaluator.forward(problem)# 评估器获取测试样本
            print(f'Generate test sample:\n{test_sample}')
            test_samples = [test_sample]
            feedback = evaluator.evaluate(test_samples)# 获取评估结果
            feedback_pool = CommentPool(all_experts, visible_matrix=np.ones((num_experts, num_experts)))# 初始化反馈评论池
            feedback_pool.add_comment(Comment(evaluator, feedback))
            if feedback is not None:
                while expert_stack:# 反思专家栈中的专家
                    previous_expert = expert_stack.pop()
                    previous_comment = comment_pool.pop_comment()
                    result = previous_expert.backward(feedback_pool)
                    result = json.loads(result)
                    if result['is_caused_by_you']:# 如果错误由当前专家引起
                        # 更新评论内容
                        previous_comment.comment_text = result['refined_result']
                        expert_stack.append(previous_expert)
                        comment_pool.add_comment(previous_comment)
                        break