Self-Refine让大模型自我迭代改进输出

可视化演示

展示Self-Refine的Generate-Feedback-Refine迭代循环、质量随迭代次数提升曲线及多任务应用效果对比，动态演示大模型自我改进机制。

概念认知

主厨的价值不只在于会颠勺，更在于会品尝。一位新来的学徒总把菜直接端上桌，老师傅却一定先试味再调整。Self-Refine（自我精炼）就是把这个“试味”动作写进大模型的工作流：让模型先输出一版草稿，然后对自己说“这版哪里不好、该怎么改”，再据此重写。这个思路由 Madaan 等人在 2023 年提出，在情感分析、代码优化、数学推理等多个任务上验证了效果。

过去想提升模型输出质量，最常见的手段是微调——相当于把厨师送回烹饪学校重新训练，既贵又慢。Self-Refine 走的是另一条路：同一个厨师、同一套手艺，只是在出品前多了一道“自我品控”工序。它属于推理时技巧，不需要更新任何参数，因此可以即插即用地套在任何大模型上。

Self-Refine 的核心假设是：大模型在预训练阶段已经积累了足够的评价能力，只是生成时未必发挥出来。让模型先“发散”地生成，再“收敛”地审查，就能把隐藏的判断力激发出来。它与微调互补：微调改变能力，Self-Refine 释放已有能力。

$$\displaystyle y^{(t+1)} = \text{Refine}\Big(y^{(t)},\ \text{Feedback}\big(x,\ y^{(t)}\big)\Big)$$

1. 当前草稿：y^(t) 表示第 t 轮迭代后的输出版本，t 等于 0 时就是最初的草稿。

$$y^{(t)}$$

2. 反馈生成：Feedback(x, y^(t)) 是模型对照任务 x 审查草稿，输出具体问题与修改建议。

$$\text{Feedback}\big(x,\ y^{(t)}\big)$$

3. 修正动作：Refine 把旧草稿和反馈一起交给模型重写，得到更新的一版。

$$\displaystyle y^{(t+1)} = \text{Refine}\Big(y^{(t)},\ \text{Feedback}\big(x,\ y^{(t)}\big)\Big)$$

正因为不需要回烹饪学校，Self-Refine 的启动成本几乎为零——你只需要写好“尝菜”的提示词，剩下的交给模型自己转起来。

核心流程

试菜从来不是一次性的动作，而是“端盘—尝味—调味—再端盘”的循环。Self-Refine 也由三个固定工序组成：初始生成、反馈生成、修正迭代，循环往复直到满足终止条件，构成一轮完整的“自我精炼”。

第一道工序是初始生成：把任务描述（比如“写一段产品卖点”）直接丢给模型，得到初稿。第二道工序是反馈生成：把任务、当前草稿和反馈提示词拼接起来，让模型输出评审意见。第三道工序是修正迭代：把草稿与反馈一起交回给模型重写。三个动作合起来就是一轮迭代，迭代之间彼此衔接、层层递进。

值得注意的是，反馈与修正可以由同一个模型用两段不同的提示词完成，也可以设计成“先自评、再自查”的多步反馈。实际工程中，还有人把反馈阶段再接一条思维链，让模型先分析问题再给建议，反馈质量会明显提升。

$$\displaystyle y^{(0)} = \text{Gen}(x), \qquad f^{(t)} = \text{FB}\big(x,\ y^{(t)}\big), \qquad y^{(t+1)} = \text{Rev}\big(y^{(t)},\ f^{(t)}\big)$$

1. 初始生成：Gen(x) 表示根据任务 x 生成第一版输出，是整个循环的起点。

$$y^{(0)} = \text{Gen}(x)$$

2. 反馈生成：FB(x, y^(t)) 让模型同时看到任务与当前版本，产出反馈意见 f。

$$f^{(t)} = \text{FB}\big(x,\ y^{(t)}\big)$$

3. 修正更新：Rev(y^(t), f^(t)) 把旧版与反馈合并，重写为新的版本。

$$\displaystyle y^{(t+1)} = \text{Rev}\big(y^{(t)},\ f^{(t)}\big)$$

4. 循环变量：t 从 0 开始递增，表示已经试了几轮菜。

$$t = 0,\ 1,\ 2,\ \dots$$

循环每天都发生在后厨：第一版端出、尝一口、调整，再端出。模型就像一位不厌其烦的主厨，一遍遍靠近理想的味道。

反馈设计

同样是尝菜，有人只尝出“不太对”，有人能说出“盐放多了、蒜味抢了主味、收汁不够浓”——后者才能把菜真正改好。反馈提示词就是模型的味蕾：反馈越具体，修正越到位，改进上限越高。

反馈生成的质量直接决定 Self-Refine 的天花板。实验发现，笼统的“请改进”几乎无效，而结构化的反馈提示（指出问题、给出建议、按严重程度排序）效果显著。工程实践常按任务定制反馈维度：文案看吸引力和逻辑，代码看正确性和效率，摘要看事实性和覆盖度。

通用的反馈框架可以写成：“你是严格的评审专家。请阅读任务与当前输出，列举 3 个最需要改进的问题，并为每个问题给出具体修改建议。若已无重大问题，请回复'合格'。”对于复杂任务，还可以让模型先输出一段推理再给结论，也就是用思维链增强反馈的准确性。

$$\displaystyle f^{(t)} = \text{LLM}\big(P_{\text{fb}} \oplus x \oplus y^{(t)}\big)$$

1. 反馈提示词：P_fb 是精心编写的评审指令模板，决定反馈的维度与格式。

$$P_{\text{fb}}$$

2. 信息拼接：⊕ 符号表示把任务 x 与当前草稿 y^(t) 拼接进提示词，让模型带着上下文评审。

$$x \oplus y^{(t)}$$

3. 同一模型生成：LLM(·) 与生成草稿用的是同一个模型，只是切换成了评审人格。

$$\displaystyle f^{(t)} = \text{LLM}\big(P_{\text{fb}} \oplus x \oplus y^{(t)}\big)$$

味蕾越敏锐，回锅越精准。给模型写好“评审人格”，等于在它心里安了一位挑剔的老食客。

终止设定

老主厨最懂得“该上菜了”：菜反复回锅，反而越炒越糊。Self-Refine 同样需要刹车——迭代不是越多越好，每一次循环都要消耗 token 和时间，盲目追求轮数会拖垮成本和响应速度。

实践中常用的终止条件有三种：第一，固定最大迭代次数 K，预算可控、行为可预测；第二，质量阈值，当反馈判定“合格”或质量评分超过阈值时提前停止；第三，无新意停止，当连续两轮反馈内容相似，说明改进空间已经用完，再循环也是原地打转。

选择终止条件本质是在质量与成本之间做权衡。设一次生成平均消耗 C_gen 个 token，一次反馈消耗 C_fb 个 token，总成本约等于 (K+1) 次生成加 K 次反馈。简单任务迭代 1 次就够，复杂代码或长文案可以迭代 2 到 3 次，超过 5 次后边际收益通常趋近于零。

$$\displaystyle T^{(t)} = \mathbb{1}\big\{t \geq K \ \text{或}\ \text{合格}\big(f^{(t)}\big)\big\}$$

1. 指示函数：1{·} 在括号内条件成立时取 1，表示“可以停止”，否则取 0。

$$\mathbb{1}\{\cdots\}$$

2. 预算上限：t ≥ K 表示达到最大迭代轮次，强制停止以保护成本。

$$t \geq K$$

3. 质量通过：合格(f^(t)) 表示反馈认为无需再改，可以提前结束。

$$\text{合格}\big(f^{(t)}\big)$$

4. 停止判定：两个条件满足其一，循环即终止。

$$T^{(t)} = 1 \Rightarrow \text{停止}$$

上菜的时机，就是质量的“火候”与成本的“翻台率”之间的平衡点。懂得何时收手，才是一位成熟的主厨。

任务效果

试菜改良到底有没有用，要看客人的反应。Self-Refine 的原论文在 7 个任务上做了系统性测试，平均绝对提升约 20%——翻译成后厨的话：同样的食材和厨师，多了“自我试菜”这道工序，好评率明显上涨。

分任务看：对话回复生成提升约 5 个百分点；情感分析提升约 4 个百分点；代码优化任务中通过率提升最高可达约 20 个百分点；数学推理（GSM8K）提升约 15 个百分点；摘要生成在关键质量指标上也获得显著改善。任务越复杂、越需要多轮推敲，收益越明显。

这些数据还揭示了一个规律：像情感分类这类本身就较简单的任务，提升空间有限；而代码、数学、长文写作等任务则能吃满“自我精炼”的红利。改进幅度随迭代轮数递减，呈现典型的收益递减曲线。

$$\displaystyle Q^{(K)} \approx Q^{\ast}\big(1 - e^{-\lambda K}\big), \qquad \Delta = Q^{(K)} - Q^{(0)}$$

1. 质量上限：Q* 表示该任务上模型能逼近的最好质量，是曲线的天花板。

$$Q^{\ast}$$

2. 收益递减：1 − e^(−λK) 随轮数 K 增加而趋向 1，但增长速度越来越慢。

$$1 - e^{-\lambda K}$$

3. 绝对提升：Δ 是最终质量减去初稿质量，论文中平均约为 20 个百分点。

$$\Delta = Q^{(K)} - Q^{(0)}$$

收益递减曲线就像试菜：前几口调整立竿见影，后面再尝也只是锦上添花。聪明的后厨，把力气花在前三轮。

局限风险

试菜不是免费的：食材会消耗，时间会流逝，厨师也会味觉疲劳。Self-Refine 有三大代价——推理成本、过度修正、长上下文开销，用之前必须心里有数。

第一，成本成倍增加。每迭代一轮就要多一次反馈和一次重写，总 token 消耗随轮数线性上升。第二，过度修正。模型可能把原本不错的部分改坏，或者把反馈中的错误意见当真，越改越差。第三，长上下文开销。每轮都要把任务、草稿、反馈拼接进提示词，输入越来越长，费用和延迟同步上涨。

更根本的限制是反馈质量上限：模型的自我评价能力是有限的，它无法发现超出自己知识边界的问题，甚至可能把正确内容当成错误来“修正”，导致错误自我强化。这也是为什么 Self-Refine 不能完全替代人工评审，关键业务仍需留一道人工兜底。

$$\displaystyle \text{Token}_{\text{总}} = \text{Token}(x) + \sum_{t=0}^{K}\Big(\text{Token}\big(y^{(t)}\big) + \text{Token}\big(f^{(t)}\big)\Big)$$

1. 任务消耗：Token(x) 是任务描述本身的固定开销，与迭代轮数无关。

$$\text{Token}(x)$$

2. 逐轮消耗：求和符号从 t 等于 0 累加到 K，把每一轮草稿与反馈的 token 数加总。

$$\sum_{t=0}^{K}\Big(\text{Token}\big(y^{(t)}\big) + \text{Token}\big(f^{(t)}\big)\Big)$$

3. 总账计算：两者相加得到总消耗，随轮数近似线性增长，是成本控制的核心依据。

$$\displaystyle \text{Token}_{\text{总}} = \text{Token}(x) + \sum_{t=0}^{K}\Big(\text{Token}\big(y^{(t)}\big) + \text{Token}\big(f^{(t)}\big)\Big)$$

聪明的后厨不会无限试菜：备好预算、设好上限、盯紧火候，才能既保住口碑，又不亏本。

实践方法

把“自我试菜”从灵光一现变成稳定出品，靠的是把它沉淀成一套标准流程。实践中，Self-Refine 通常被封装为三段式提示词链，并配合评估与终止机制一起使用。

三段式提示词链包括：第一段是生成提示词，写明任务与输出格式要求；第二段是反馈提示词，设定评审角色、审核维度与“合格”信号；第三段是修正提示词，要求重写时保留优点、修正问题。在代码里用一个循环把它们串起来，直到反馈返回“合格”或达到上限。

落地时还有几个实用技巧：与思维链结合，让反馈先推理再给结论；为不同任务准备不同的反馈模板；用人工抽查校准“合格”信号的可信度；对关键业务场景保留人工审批兜底。

$$\displaystyle y^{(K)} = \underbrace{\text{Rev}\circ\text{Rev}\circ\cdots\circ\text{Rev}}_{K\ \text{次}}\big(\text{Gen}(x)\big)$$

1. 初始生成：Gen(x) 产出第一版草稿，是整个链条的起点。

$$\text{Gen}(x)$$

2. 函数复合：Rev∘Rev∘⋯∘Rev 表示把修正动作反复施加 K 次，每次输入都是上一轮输出。

$$\text{Rev}\circ\text{Rev}\circ\cdots\circ\text{Rev}$$

3. 最终输出：y^(K) 是 K 轮修正后的成品，也就是交给用户的版本。

$$y^{(K)}$$

把试菜制度写进菜谱，餐厅才能稳定出品；把 Self-Refine 变成标准流水线，AI 应用才能稳定提质。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-# Self-Refine minimal demo: generate -> feedback -> refine -> loop# 依赖: pip install openai ; 环境变量: OPENAI_API_KEYimport osfrom openai import OpenAI client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))  def call_llm(system_prompt, user_prompt, temperature=0.7):    # 封装一次对话补全调用, 返回纯文本结果    resp = client.chat.completions.create(        model=os.getenv("SELF_REFINE_MODEL", "gpt-4o-mini"),        temperature=temperature,        messages=[            {"role": "system", "content": system_prompt},            {"role": "user", "content": user_prompt},        ],    )    return resp.choices[0].message.content.strip()  def generate(task):    # 工序一: 初始生成第一版草稿    return call_llm(        "You are a senior copywriter. Output the full plan directly.",        "Task: " + task,    )  def get_feedback(task, draft):    # 工序二: 让模型扮演评审, 给出具体反馈; 无问题则回复 qualified    return call_llm(        "You are a strict editor. List the top 3 problems that must be "        "fixed and give a concrete suggestion for each. If the draft is "        "already good enough, reply with only: qualified",        "Task: " + task + "\n\nDraft:\n" + draft,    )  def refine(draft, feedback):    # 工序三: 根据反馈重写草稿, 保留优点, 修正问题    return call_llm(        "You are a senior copywriter. Rewrite the draft following the "        "feedback. Keep its strengths and fix every reported problem.",        "Draft:\n" + draft + "\n\nFeedback:\n" + feedback,    )  def self_refine(task, max_iter=3):    # 主循环: 生成 -> 反馈 -> 修正, 直到合格或达到迭代上限    draft = generate(task)    for i in range(max_iter + 1):        print("===== round %d =====" % i)        print("draft:\n%s\n" % draft)        if i == max_iter:            print("max iterations reached, stop.")            break        feedback = get_feedback(task, draft)        if "qualified" in feedback:            print("qualified, early stop.")            break        print("feedback:\n%s\n" % feedback)        draft = refine(draft, feedback)    return draft  if __name__ == "__main__":    task = "Write a 60-word Amazon product copy for a smart insulated cup."    result = self_refine(task, max_iter=2)    print("===== final =====\n" + result)

1. def self_refine(task, max_iter=3):主循环入口，把生成、反馈、修正三道工序串成一条流水线。
2. draft = generate(task)初始生成：先产出第一版草稿，相当于把菜端上砧板。
3. feedback = get_feedback(task, draft)反馈生成：让同一个模型切换成“评审人格”挑毛病。
4. if "qualified" in feedback:终止条件：评审通过就提前刹车，省下后面的迭代开销。
5. draft = refine(draft, feedback)修正迭代：按建议重写草稿，完成一轮完整循环。
6. for i in range(max_iter + 1):循环骨架：用最大轮数兜底，防止成本失控。
7. return resp.choices[0].message.content.strip()取出对话补全的首选答案并清理空白字符。

常见误区

面试题