Skip to content

rdagent fin_factor 中大模型生成代码的定义位置与执行流程

这份文档是对 tutorial_fin_factor_cli_flow.md 的补充,专门回答一个更细的问题:

当执行 rdagent fin_factor 时,系统会调用大模型自动生成 factor.py。这部分“代码生成规划”和 prompt 到底定义在哪里?实际调用流程是什么样的?

结论先说:

fin_factor 的“生成代码”核心不在 CLI 层,
而在 FactorCoSTEER -> CoSTEER -> RAGEvoAgent -> FactorMultiProcessEvolvingStrategy
这一条链上。

真正让大模型写出 factor.py 的 prompt,主要定义在:

rdagent/components/coder/factor_coder/prompts.yaml

1. 从 fin_factor 命令走到代码生成模块

命令入口仍然是:

rdagent
  -> rdagent/app/cli.py
  -> fin_factor
  -> rdagent/app/qlib_rd_loop/factor.py: main()
  -> FactorRDLoop(FACTOR_PROP_SETTING)

在 FACTOR_PROP_SETTING 中,coding 阶段被配置为:

coder = "rdagent.scenarios.qlib.developer.factor_coder.QlibFactorCoSTEER"

而这个类只是别名:

from rdagent.components.coder.factor_coder import FactorCoSTEER

QlibFactorCoSTEER = FactorCoSTEER

所以 fin_factor 的代码生成主链是:

FactorRDLoop.coding()
  -> QlibFactorCoSTEER.develop(exp)
  -> FactorCoSTEER.develop(exp)
  -> CoSTEER.develop(exp)
  -> RAGEvoAgent.multistep_evolve(...)
  -> FactorMultiProcessEvolvingStrategy.implement_one_task(...)
  -> LLM 生成 factor.py

2. 代码生成逻辑的核心类在哪里

2.1 FactorCoSTEER

定义在:

rdagent/components/coder/factor_coder/__init__.py

核心装配代码:

class FactorCoSTEER(CoSTEER):
    def __init__(self, scen, *args, **kwargs):
        setting = FACTOR_COSTEER_SETTINGS
        eva = CoSTEERMultiEvaluator(FactorEvaluatorForCoder(scen=scen), scen=scen)
        es = FactorMultiProcessEvolvingStrategy(scen=scen, settings=FACTOR_COSTEER_SETTINGS)

        super().__init__(*args, settings=setting, eva=eva, es=es, evolving_version=2, scen=scen, **kwargs)

这段代码说明:

  • 代码生成策略是 FactorMultiProcessEvolvingStrategy
  • 代码评估器是 FactorEvaluatorForCoder
  • 通用演化框架是 CoSTEER

也就是说,FactorCoSTEER 本身不是 prompt 文件;它是“把生成策略、评估策略、知识检索策略装配起来”的入口类。

2.2 FactorMultiProcessEvolvingStrategy

定义在:

rdagent/components/coder/factor_coder/evolving_strategy.py

这个类里最关键的方法是:

def implement_one_task(...)

真正调用大模型生成代码的逻辑就在这个方法里。

3. prompt 模板定义在哪里

3.1 主代码生成 prompt

factor.py 生成的主要 prompt 在:

rdagent/components/coder/factor_coder/prompts.yaml

最关键的两个模板键是:

  • evolving_strategy_factor_implementation_v1_system
  • evolving_strategy_factor_implementation_v2_user

对应含义:

  • system prompt:定义角色、目标、约束、输出 JSON 格式
  • user prompt:注入当前 factor task、相似成功案例、历史失败案例、错误总结等上下文

3.2 错误总结 prompt

同一个文件里还有两组与错误回顾相关的模板:

  • evolving_strategy_error_summary_v2_system
  • evolving_strategy_error_summary_v2_user

这组 prompt 不是直接拿来产代码,而是先让模型基于“类似错误 -> 修复示例”产出一份短批注,再把这份批注作为额外上下文塞回代码生成 prompt。

3.3 评估相关 prompt

仍然在同一个 prompts.yaml 中,还定义了:

  • evaluator_code_feedback_v1_system
  • evaluator_code_feedback_v1_user
  • evaluator_output_format_system
  • evaluator_final_decision_v1_system
  • evaluator_final_decision_v1_user

这些 prompt 不负责写代码,而负责在每轮实现之后评价代码:

  • 代码是否符合 factor 描述
  • 输出 dataframe 是否合规
  • 是否可以给出最终通过结论

4. prompt 是怎么被加载和渲染的

模板加载工具在:

rdagent/utils/agent/tpl.py

核心类是 T,实际上是 RDAT 的别名:

T = RDAT

调用形式例如:

system_prompt = T(".prompts:evolving_strategy_factor_implementation_v1_system").r(...)
user_prompt = T(".prompts:evolving_strategy_factor_implementation_v2_user").r(...)

这里的规则是:

  • .prompts 表示从当前 Python 文件所在目录读取 prompts.yaml
  • : 后面是 YAML 中的键
  • .r(**context) 使用 Jinja2 渲染模板

因此:

T(".prompts:evolving_strategy_factor_implementation_v1_system")

会自动去加载:

rdagent/components/coder/factor_coder/prompts.yaml

中的 evolving_strategy_factor_implementation_v1_system。

5. 真正调用大模型写 factor.py 的源码位置

关键代码在:

rdagent/components/coder/factor_coder/evolving_strategy.py

5.1 先构造 system prompt

implement_one_task() 中:

system_prompt = T(".prompts:evolving_strategy_factor_implementation_v1_system").r(
    scenario=self.scen.get_scenario_all_desc(target_task, filtered_tag="feature"),
    queried_former_failed_knowledge=queried_former_failed_knowledge_to_render,
)

这里注入了:

  • 当前场景描述
  • 当前任务相关的历史失败实现

5.2 再构造 user prompt

user_prompt = T(".prompts:evolving_strategy_factor_implementation_v2_user").r(
    factor_information_str=target_factor_task_information,
    queried_similar_successful_knowledge=queried_similar_successful_knowledge_to_render,
    queried_similar_error_knowledge=queried_similar_error_knowledge_to_render,
    error_summary_critics=error_summary_critics,
    latest_attempt_to_latest_successful_execution=latest_attempt_to_latest_successful_execution,
)

这里注入了 5 类关键信息:

  1. 当前因子任务本身
  2. 相似成功任务的实现代码
  3. 相似错误案例及其修复代码
  4. 可选的错误总结批注
  5. 当前任务最近一次失败尝试及其反馈

5.3 再调用大模型

真正的 LLM 调用:

response = APIBackend(...).build_messages_and_create_chat_completion(
    user_prompt=user_prompt,
    system_prompt=system_prompt,
    json_mode=True,
    json_target_type=Dict[str, str],
)

然后期望模型返回:

{
  "code": "..."
}

如果 JSON 解析失败,代码还会尝试从 markdown 代码块中提取:

match = re.search(r"```python(.*?)```", response, re.DOTALL)

因此系统对输出格式的要求是:

  • 优先返回 JSON
  • 失败时退化为从 ```python 代码块抽取

5.4 最终写回 workspace

生成好的代码不会直接执行,而是先写进对应的 task workspace:

evo.sub_workspace_list[index].inject_files(**{"factor.py": code_list[index]})

对应工作区类是:

rdagent/components/coder/factor_coder/factor.py -> FactorFBWorkspace

6. prompt 里到底要求模型做什么

从 evolving_strategy_factor_implementation_v1_system 可以概括出 4 个核心要求:

  1. 代码要符合场景接口和目标 factor 定义
  2. 可以参考相似成功代码
  3. 必须认真对待自己上一轮失败实现和反馈
  4. 输出必须是 JSON,且只返回代码

其中一句很关键:

you should read the former attempt carefully and must not modify the right part of your former code

这说明它不是每轮“从零生成”,而是要求模型在上一版基础上做局部修正。

从 evolving_strategy_factor_implementation_v2_user 可以看出它给模型的上下文是高度面向“修复与迁移”的:

  • 当前目标 factor 信息
  • 相似错误的错代码与正确代码对照
  • 相似成功 factor 的完整代码
  • 最新失败尝试与反馈

所以这更像:

基于经验和反馈做定向修复

而不是:

纯一次性代码生成

7. “规划”部分体现在哪里

这里没有单独一个叫 planner 的类来写 factor 代码计划,但“规划”实际分散在三层。

7.1 experiment generation 层

在进入 coding 前,QlibFactorHypothesis2Experiment 已经把 hypothesis 变成了结构化 FactorTask,其中包括:

  • factor_name
  • factor_description
  • factor_formulation
  • variables

这一步已经完成了“要实现什么”的任务规划。

7.2 evolving strategy 层

FactorMultiProcessEvolvingStrategy 决定:

  • 当前 task 要用哪些历史知识
  • 哪些失败案例需要作为上下文
  • 是否先做错误总结
  • 超长 prompt 时先裁剪哪部分上下文

这一步承担了“给模型喂什么信息”的提示规划。

7.3 evaluator 层

FactorEvaluatorForCoder 决定:

  • 这轮代码哪里错
  • 是否需要继续迭代
  • 哪些反馈要回流到下一轮

这一步承担了“下一轮修什么”的反馈规划。

因此,fin_factor 的代码生成规划不是一份静态计划文档,而是:

任务结构化
  + 检索上下文
  + 错误归纳
  + 评估反馈
  -> 驱动下一轮提示

8. CoSTEER 的通用演化循环是什么样的

通用闭环在:

rdagent/components/coder/CoSTEER/__init__.py
rdagent/core/evolving_agent.py

8.1 CoSTEER.develop()

CoSTEER.develop() 会:

  1. 把 Experiment 转成 EvolvingItem
  2. 创建 RAGEvoAgent
  3. 反复调用 multistep_evolve()
  4. 维护 fallback 版本
  5. 选择一个可接受的最终实现

8.2 RAGEvoAgent.multistep_evolve()

每轮演化都走下面的顺序:

1. RAG query
2. evolving_strategy.evolve()
3. evaluator.evaluate()
4. 记录 feedback
5. 更新 knowledge base
6. 判断是否 finished

这意味着 prompt 不是只调用一次,而是可能被多轮重复调用。

9. RAG 上下文是怎么进入 prompt 的

RAG 相关逻辑在:

rdagent/components/coder/CoSTEER/knowledge_management.py

queried_knowledge 里会包含:

  • task_to_similar_task_successful_knowledge
  • task_to_former_failed_traces
  • task_to_similar_error_successful_knowledge

这些对象本质上保存的是:

  • 任务描述
  • 以前生成过的代码
  • 以前的反馈

而 implement_one_task() 会把它们变成 prompt 上下文。

因此,这套系统不是“只靠当前任务描述裸生成代码”,而是带着历史经验做实现。

10. 生成出来的代码如何被执行

生成的 factor.py 写入 FactorFBWorkspace 后,会在 evaluator 阶段真实执行。

FactorFBWorkspace.execute() 的关键步骤:

  1. 创建工作目录
  2. 把 factor.py 写入工作区
  3. 软链接 source data
  4. 用 FACTOR_COSTEER_SETTINGS.python_bin 运行 factor.py
  5. 检查是否生成 result.h5
  6. 读取 factor dataframe

因此 prompt 生成出来的代码不是只做静态检查,而是立即进入真实执行。

11. 失败反馈如何回流进下一轮 prompt

评估链的入口是:

rdagent/components/coder/factor_coder/evaluators.py

其中 FactorEvaluatorForCoder.evaluate() 会依次做:

  1. 执行代码
  2. 检查 factor value
  3. 做 code feedback
  4. 做 final decision

11.1 code feedback prompt

代码批评 prompt 定义在:

  • evaluator_code_feedback_v1_system
  • evaluator_code_feedback_v1_user

它会结合:

  • factor 信息
  • 当前代码
  • 执行反馈
  • value feedback
  • 可选的 ground truth code

给出简短、面向 agent 的 critic,而不是面向人类的调试说明。

11.2 final decision prompt

最终是否通过,使用:

  • evaluator_final_decision_v1_system
  • evaluator_final_decision_v1_user

如果 value 对齐或高相关,可以直接判定为成功;否则再结合 execution/code/value feedback 让 LLM 做最终裁决。

11.3 feedback 回到下一轮

这些 feedback 会进入:

  • evolving_trace
  • knowledge base
  • queried_knowledge

然后在下一轮 implement_one_task() 中重新被渲染进 prompt。

这就是完整闭环:

生成代码
  -> 执行
  -> 评价
  -> 保存经验
  -> 下一轮 prompt 带上这些经验

12. 哪些配置会影响这部分行为

相关配置主要在两个文件中:

rdagent/components/coder/CoSTEER/config.py
rdagent/components/coder/factor_coder/config.py

重要项包括:

  • coder_use_cache
  • 是否对代码生成调用启用 chat cache
  • max_loop
  • 最多进行多少轮实现演化
  • v2_error_summary
  • 是否启用“相似错误先总结再生成”的辅助步骤
  • file_based_execution_timeout
  • 每次执行 factor.py 的超时时间
  • python_bin
  • 实际执行 factor.py 的 Python 解释器

所以 prompt 本身定义在 YAML,但它的调用频率、是否缓存、是否带错误总结、每轮是否容易超时,都受配置影响。

13. 一张图看完整代码生成链

rdagent fin_factor
  -> FactorRDLoop.coding()
  -> QlibFactorCoSTEER / FactorCoSTEER
  -> CoSTEER.develop()
  -> RAGEvoAgent.multistep_evolve()
       -> RAG query 历史成功/失败知识
       -> FactorMultiProcessEvolvingStrategy.implement_one_task()
            -> T(".prompts:evolving_strategy_factor_implementation_v1_system")
            -> T(".prompts:evolving_strategy_factor_implementation_v2_user")
            -> APIBackend(...).build_messages_and_create_chat_completion()
            -> 得到 {"code": "..."}
            -> 写入 FactorFBWorkspace.factor.py
       -> FactorEvaluatorForCoder.evaluate()
            -> 执行 factor.py
            -> value 检查
            -> code feedback
            -> final decision
       -> feedback 写入 evolving_trace / knowledge base
       -> 下一轮继续
  -> 选取 fallback 或最终可接受版本

14. 总结

如果只问“fin_factor 的代码生成 prompt 在哪里”,最短答案是:

主要在 rdagent/components/coder/factor_coder/prompts.yaml

如果问“这部分流程是什么”,更完整的答案是:

FactorTask 先由 proposal 阶段生成
  -> FactorCoSTEER 启动 CoSTEER 演化
  -> FactorMultiProcessEvolvingStrategy 用 prompts.yaml 渲染 prompt
  -> APIBackend 调用大模型生成 factor.py
  -> evaluator 执行并打分
  -> 失败反馈和相似成功经验回流到下一轮 prompt
  -> 多轮迭代直到通过或达到上限

因此,fin_factor 的自动代码生成并不是一个单点 prompt,而是一套:

模板定义 + 知识检索 + 多轮执行反馈 + 迭代修复

组合起来的代码生成闭环。