1.8.llm_o1 | collections

☄️

collections

O1

CoT开山之作

from r to Q*

在DPO的基础上，引入LLM里的token-level的MDP，用二分类的preference feedback。发现了3个点：

尽管 DPO 是作为上下文多臂赌博机而派生出来的，但DPO模型的隐含奖励可在每个 token 层面上进行解释。
DPO模型的likelihood search类似在decoding阶段寻找一个reward function。即在token层面的阐述方式下，经典的基于搜索的算法（比如 MCTS）等价于在 DPO策略上的基于似然的搜索。
初始策略和参考分布的选择对于确定训练期间隐性奖励的轨迹非常重要。

5级路线图：

L1：聊天机器人，具有对话能力的AI。
L2：推理者，像人类一样能够解决问题的AI。
L3：智能体，不仅能思考，还可以采取行动的AI系统。
L4：创新者，能够协助发明创造的AI。
L5：组织者，可以完成组织工作的AI。

Strawberry模型的目的是为了使公司的AI不仅能生成查询答案，还能提前计划，足够自主且可靠地浏览互联网，进行OpenAI所称的「深度研究」。

类似能够通过迭代创建自己的训练数据，来「自我提升」到更高的智能水平。

，对应下载的

自我奖励

self-play

Cursor

Let's verify step by step

O1相关汇总

(toread)

--toread

CoT能让Transformer更强

CoT：打破 Transformer 的“并行诅咒”

传统的 Transformer 模型虽然在自然语言处理领域取得了巨大成功，但它有一个致命弱点：擅长并行计算，但不擅长串行推理。这就像一个超级聪明的孩子，能快速完成大量的计算题，但却无法理解简单的逻辑推理。

而CoT (Chain of Thought，思维链)技术的灵感来源于人类的思维过程，它可以让 Transformer 模拟人类的思考方式，通过生成一系列中间推理步骤，来解决那些需要逻辑推理的复杂问题。

CoT 的理论基础：从电路复杂度到 Transformer 表达能力

作者用电路复杂性理论来解释 CoT 的强大之处，将Transformer的计算过程与电路模型进行类比，并将Transformer能够解决的问题类别定义为“CoT 复杂性类”

他们证明了传统的Transformer模型（没有 CoT）只能解决AC0电路能够解决的问题，而AC0电路是一种计算能力非常有限的电路模型。但是，如果加入 CoT，Transformer 的表达能力将得到质的飞跃！作者用数学严格证明了：

只要CoT步骤足够多，Transformer 就能模拟任意大小的布尔电路，从而解决P/poly问题，这是一个包含了P问题的更大的问题类别，相当于证明了CoT可以让 Transformer 解决几乎所有可以用计算机解决的问题。

CoT 的实验验证：从模加到电路值问题，CoT 全面胜出！

为了进一步验证CoT的有效性，论文作者设计了四个核心问题：

模加：计算两个数的和，并对某个整数取模
排列组合：计算一组排列的组合
迭代平方：对一个数进行多次平方运算
电路值问题：计算一个布尔电路的输出值

其中，模加问题可以用并行计算高效地解决，而其他三个问题则需要串行计算。

实验结果表明：

对于模加问题，即使不使用 CoT，Transformer 也能取得不错的效果
但对于其他三个问题，使用 CoT 可以显著提高 Transformer 的准确率，尤其是在模型深度较浅的情况下

讨论

CoT or not

test-time scaling

一句话：根据给定的prompt难度，动态地分配测试时（Test-Time）的计算资源。在预训练阶段花费更少的计算资源，而在推理阶段花费更多，这种策略可能更好。

针对（Process Reward Model, PRM，里提出的）进行搜索。
- PRM可以在模型生成答案过程中的每个步骤都提供评分，用于引导搜索算法，动态调整搜索策略，通过在生成过程中识别错误或低效的路径，帮助避免在这些路径上浪费计算资源。
在测试时根据prompt自适应地更新模型的响应分布。
- 模型不是一次性生成最终答案，而是逐步修改和改进它之前生成的答案，按顺序进行修订（revision）。
- 并行采样：独立生成N个答案，
- 顺序修订：每个答案依赖于前一次生成的结果，逐步修订。

---(写得比较细)

inference scaling

扩散模型的inference scaling

O1的评估

LLM Reasoning

开源模型+O1

复现O1

O1 Replication Journey

ScoRe

LeCo

Marco-O1

OmniSearch

Coconut

(toread)

一般而言，LLM 被限制在语言空间（language space）内进行推理，并通过思维链（CoT）来表达推理过程，从而解决复杂的推理问题。然而，语言空间可能并不总是最适合推理的。例如，很多单词token主要用于文本连贯性，而不是推理本身，而一些关键token则需要复杂的规划。

Coconut（连续思维链，Chain of Continuous Thought）不再通过语言模型头（language model head）和嵌入层将隐藏状态与语言 token 进行映射，而是直接将最后的隐藏状态（即连续思维）作为下一个token的输入嵌入。

O1的安全机制

O1架构

gemini 2.0 flash thinking

我自己复制的一个：

对应的github：

小模型的O1

(toread)

meta-cot

sky-T1

(toread)

Monkey

其他的一些讨论

(使用技巧)

o1-preview约300B；o1-mini约100B
GPT-4o约200B；GPT-4o-mini约8B
Claude 3.5 Sonnet 2024-10-22版本约175B

DeepSeek R1

，自己转存了一份：

arxiv上：

，还有不少distill的，LM-studio已经有了。。

背景

o1提出了可以通过增加cot reasoning process的长度来进行inference time scaling，尝试复现的方法有：

process-based reward models：
reinforcement learning：
MCTS/beam search的搜索方法：

但这些方法都没有o1效果好，因此R1不借助监督数据，使用纯RL(没有SFT)来完成self-evolution，从而探索LLM在reasoning上的潜能。使用DeepSeekV3作为base model，并使用的GRPO作为RL框架。

几k个step后，DeepSeek-R1-Zero在一些reasoning的benchmark上取得了不错的效果，但仍然有可读性差、语言混合等问题，因此搞了DeepSeek-R1，包括少量的冷启数据和一个多阶段的训练pipeline。

收集数千的cold-start数据来finetune DeepSeek-V3-Base模型
执行类似DeepSeek-R1-Zero的面向reasoning的RL任务
在RL快收敛的时候，在RL的checkpoint上通过拒绝采样构建新的SFT数据，并和DeepSeek-V3的数据集（只选一些领域，如writing、factual QA和self-cognition,自我认知）进行结合，重训DeepSeek-V3-Base
用新数据finetune完后，再经过一个RL的过程，并考虑所有场景的prompts==>最终的模型

还搞了一些蒸馏模型，例如Qwen2.5-32B作为base模型，蒸馏DeepSeek-R1的效果比对它进行RL效果要好，说明大的base model发现的reasoning patterns对提升reasoning能力很关键。此外，发现14B的蒸馏模型比QWQ-32B-preview效果好很多，32B和70B的蒸馏模型效果更好

DeepSeek-R1-Zero

RL算法

GRPO（Group Relative Policy Optimization）：放弃了Critic model，用group scores来替换。即对每个问题 $q$ ，从老的策略 $\pi_{\theta_{\text {old }}}$ 采样出一个group的输出 $\left\{o_1, o_2, \cdots, o_G\right\}$ ，再通过最大化如下目标来优化policy model $\pi_\theta$ ：

\begin{aligned} \mathcal{J}_{G R P O}(\theta) & =\mathbb{E}\left[q \sim P(Q),\left\{o_i\right\}_{i=1}^G \sim \pi_{\theta_{\text {old }}}(O \mid q)\right] \\ & \frac{1}{G} \sum_{i=1}^G\left(\min \left(\frac{\pi_\theta\left(o_i \mid q\right)}{\pi_{\theta_{o l d}}\left(o_i \mid q\right)} A_i, \operatorname{clip}\left(\frac{\pi_\theta\left(o_i \mid q\right)}{\pi_{\theta_{o l d}}\left(o_i \mid q\right)}, 1-\varepsilon, 1+\varepsilon\right) A_i\right)-\beta \mathbb{D}_{K L}\left(\pi_\theta| | \pi_{r e f}\right)\right), \end{aligned}

其中：

$\mathbb{D}_{K L}\left(\pi_\theta \| \pi_{r e f}\right)=\frac{\pi_{r e f}\left(o_i \mid q\right)}{\pi_\theta\left(o_i \mid q\right)}-\log \frac{\pi_{r e f}\left(o_i \mid q\right)}{\pi_\theta\left(o_i \mid q\right)}-1$ 用于限制新策略不要离ref model太远
$\operatorname{clip}\left(\frac{\pi_\theta\left(o_i \mid q\right)}{\pi_{\theta_{o l d}}\left(o_i \mid q\right)}, 1-\varepsilon, 1+\varepsilon\right)$ 用于限制新旧策略的概率比例在1附近，即二者不要偏离太远
$\varepsilon$ 和 $\beta$ 是超参
$A_i$ 是advantage，通过每个group的reward计算得来，不像ppo需要借助value model：

A_i=\frac{r_i-\operatorname{mean}\left(\left\{r_1, r_2, \cdots, r_G\right\}\right)}{\operatorname{std}\left(\left\{r_1, r_2, \cdots, r_G\right\}\right)}

整句话的advantage如何分配到token上？参考deepseekmath论文：各token共享

大基座是出现reasoning涌现能力的关键（qwen 32bb用同样r1-zero的数据训练，没法出现aha moment）
GRPO可并行，可加速

对比PPO & GRPO

PPO：
- Reference Model（Ref model）：原始LLM，不训练
- Policy Model（Actor）：原始LLM，需要训练
  - policy：LLM产出的一条response；
  - action：LLM生成的每一个token
- Reward Model（RM）：对一条response的打分。在RLHF的RM阶段更新，RL阶段不训练
- Value Model（Critic）：类似RM，需要训练
- GAE：从Reward Model对整个句子的打分，拆解到每个token应该怎么改进（图中的A，advantage），会考虑Value Model、Ref Model和Reward Model，还会有一个KL的约束，确保新的policy model不会离ref model太远
- Importance Sampling：对比新advantage和原始policy的比值，只对advantage进行小比例更新，保证训练稳定
- 缺点：
  - 需要Ref Model再算一遍，有计算量&耗时
  - 需要拆解到每个token，又有计算量&耗时
GRPO：（Group Relative Policy Optimization）：来自，放弃了Critic model（图中的value model），用group scores来替换。
- policy model/ref model/reward model都和ppo一样
- 不需要value model
- 并行执行更多的policy（即GRPO的group），产出的结果一起打分，减均值除以标准差，把每个policy和标准差的差距平均到每个token上，再用KL散度计算和ref model的差距

原始DeepSeekMath论文中的图：

形象的理解：

从头开始实现：

Reward modeling

用的是rule-based reward，包括如下两部分

accuracy rewards：response是否正确，例如对于一个数学问题，需要判断最终答案是否为给定的格式（specified format），并且能基于规则验证结果的正确性；leetcode问题则可以用编译器来生成预先定好的测试用例的结果。
format rewards：设计了一个format reward model，来强制模型将其思考过程输出在<think>和</think>之间。

没有设计neural reward model，因为：

发现在大规模的RL过程中，neural reward model会受reward hacking的影响
重新训练reward model需要额外的训练资源，并且会让训练pipeline过于复杂

Training template

A conversation between User and Assistant. The user asks a question, and the Assistant solves it.
The assistant first thinks about the reasoning process in the mind and then provides the user
with the answer. The reasoning process and answer are enclosed within <think> </think> and
<answer> </answer> tags, respectively, i.e., <think> reasoning process here </think>
<answer> answer here </answer>. User: prompt. Assistant:

训练时使用如上的template，故意将约束限制在这种结构格式上，避免任何特定内容的偏见（例如强制反射推理或促进特定的解决问题的策略），以确保能够在RL过程中准确观察模型的自然进展。

效果

指标含义：

pass@1：首次生成答案时的成功率
cons@64：majority vote (consensus) with 64 samples，模型在给出64次生成尝试中，是否能够多次生成相同的正确答案。(在提到了，来自文章：)

数学(美国数学邀请赛)：
- AIME2024：pass@1上接近o1-0912，cons@64超了，均超越o1-mini
- MATH-500：pass@1超越o1-mini和o1-0912
GPQA-Diamond（phd级别的科学问题，包括化学、物理、生物）：pass@1超越o1-mini，不如o1-0912
代码：
- LiveCode Bench：不如o1-0912和o1-mini
- codeforces的rating：不如o1-0912和o1-mini

另外，在AIME2024上，随着训练，pass@1能从十几涨到70几。

Self-evolution Process

随着训练的进行，生成的response长度也在变长，说明思考时间也变长了，其中的reasoning tokens从数百涨到了数千。
随着测试时间的增加，涌现出了复杂的行为，即不由自主地(spontaneously)出现了（这些行为并非预先在代码里设计的）：
- 反思：重新看并且评估(revist and reevaluate)之前的steps
- 探索：尝试其他方法来解决问题

Aha Moment

在某一个中间版本，模型突然输出上面的aha-moment，可以看到不需要显式地教模型如何解决，只要给予正确的激励（incentives），模型会自己开发出进阶的问题解决策略，这也是RL的power and beauty。

DeepSeek-R1

2个目标：

用一小部分高质量数据来做冷启能否提升推理效果，或者加速收敛？
如何训练一个user-friendly的模型，既能提供准确和连贯的CoT，又有很强的通用能力？

阶段1：Cold Start

从base model开始RL训练时，为了防止冷启阶段训练的不稳定，构建了少量（数千）的长CoT数据来finetune模型，作为初始的RL actor。试了几种方法

few shot prompting，用一个long CoT作为例子
直接在prompt里要求模型生成详细的答案，并加上反思和验证
收集deepseek-r1-zero的输出，并找人类标注员后处理进行修改

相比zero，冷启数据有如下好处：

可读性：zero的可读性不太好，例如语言混合、缺少markdown高亮。因此设计了一个可读性比较好的pattern，即|special_token|<reasoning_process>|special_token|<summary>，并把没有summary的结果扔掉
潜力：依据人类先验精心设计的pattern产出的冷启数据，取得了比zero更好的效果，故迭代地训练对于reasoning models应该是一种更好的方式

阶段2：Reasoning-oriented Reinforcement Learning

在冷启数据上tune完之后，和r1-zero一样，进行大规模的RL训练（在reasoning-intensive任务的数据集上训的？）。此外，为了解决CoT里语言混合的问题，加了一个language consistency reward（计算目标语言在CoT中的比例），直接和原来的reward相加。虽然消融实验显示这种alignment会让效果略微下降，但这更符合人类偏好，可读性更强。

阶段3：Rejection Sampling and Supervised Fine-Tuning

用阶段2的ckpt，然后在writing, role-playing, and other general-purpose这类任务上构建SFT数据集，在约80w的样本上对DeepSeek-V3-Base SFT了2个epoch。

reasoning data：在前一个RL阶段，只用那些能用rule-based rewards来衡量的数据。
- 这个阶段加入了更多的数据，有一些是使用生成式的reward model，即把ground truth和模型预测结果输入给DeepSeek-V3做judgement。
- 因为模型输出有时会很混乱或者无可读性，所以删掉一些满足这些条件的CoT：混合语言、长的段落、代码段
- 对每个prompt，采样多个response，并只保留一个正确的。最终收集了大概60w的reasoning相关的训练样本
non-reasoning data：
- 采用DeepSeek-V3的pipeline，并复用部分DeepSeek-V3的SFT数据集。
- 使用DeepSeek-V3时，在prompt里提到在回答答案前要生成潜在的CoT；对于简单的如hello的问题，就不用输出CoT。
- 最终收集了大概20w的non-reasoning训练样本

阶段4：Reinforcement Learning for all Scenarios

将reward信号和多样化的数据分布相结合，提升helpfulness and harmlessness，同时refine reasoning能力，

reasoning数据：用R1-Zero的RL，使用rule-based reward
通用数据：用V3的pipeline，还是用reward model，用以学习复杂和细分领域的人类偏好

另外，提升如下两方面的能力：

helpfulness：仅关注最终的summary，保证评估强调的是response的有用性和相关性，而尽量少地干涉潜在的reasoning过程
harmlessness：同时评估reasoning过程和summary，尽量缓解在生成的过程中出现的风险、偏见和有害内容

效果

大部分都接近或者超过新版o1（r1-zero只能和早期o1相当），很多任务都比v3要好
代码和o1差不太多，比v3提升很多，其中SWE Verified这个工程类的不太行，因为目前训练语料里这类数据还比较少，下一版会优化
c-simpleQA（最后一行）上效果不如V3，因为有R1有safety的限制，导致模型会拒绝回答一些问题，如果去掉这个限制，准确率能达到70%
在AlpacaEval2.0（写作）和ArenaHard(开放领域问答)上效果很好，产出的summary也很长，说明可能reasoning能力能产出长cot，对这类任务也有用
数学上超越o1，大幅领先v3

蒸馏

基于Qwen2.5-Math-1.5B、Qwen2.5-Math-7B、Qwen2.5-14B、Qwen2.5-32B、Llama-3.1-8B、Llama-3.3-70B-Instruct蒸馏，用的数据集是deepseek-R1的第二阶段RL使用的80w数据，只进行了SFT，没有RL。理论上RL应该会效果更好，留给其他研究者去搞了。

可以参考这个自己蒸馏一个

效果

仅sft蒸馏的效果：模型越大效果越好，32b和70b的已经在大部分任务上超越o1-mini了
直接拿qwen-32b做RL（第二行）：和QwQ-32b-preview（第一行）差不太多，但明显不如sft蒸馏（第3行）的模型效果

最终结论：

把大模型蒸馏到小模型可以有很好的效果，但对小模型做RL性价比不高
有更强大的模型和更大规模的RL，才能更好地发挥蒸馏的作用，让小模型变得更强

失败的尝试

PRM

PRM（Process-supervised Reward Model）是 OpenAI 在中首次提出的概念。与之相对应的是ORM（Outcome-supervised Reward Model）。区别：

PRM：过程奖励模型，在生成过程中，对每一个步骤打分，是更细粒度的奖励模型。
ORM：结果奖励模型，不管推理有多少步，对完整的生成结果进行一次打分，是一个反馈更稀疏的奖励模型。

PRM可以在两个阶段生效：

Post-Training阶段：在RL过程中增加PRM，对采样的结果按步骤输出奖励值，为模型提供更精细的监督信号，来指导策略模型优化，提升模型按步推理的能力。
Inference阶段：对generator模型做N次采样（如Beam Search等），并通过PRM对每个采样的每步推理进行打分，最终拟合一个整体过程打分，并选取打分最高的结果作为最终的答案。

问题：

难以定义细粒度的步骤
评估中间步骤是否正确很困难，用LLM自动评估结果不太行，手动标注又难以规模化应用
基于模型的PRM就会有reward hacking问题，重新训练奖励模型需要额外的训练资源

MCTS

MCTS（Monte Carlo Tree Search）是强化学习领域，详见AlphaGo论文

具体操作步骤：使用已有的策略与环境做仿真交互，进行多次 rollout 采样，最终构成了一个从当前节点出发的一颗 Tree（每个 rollout 表示从当前节点到最终结束状态的多次与环境仿真交互的过程）。

这棵树的所有叶子节点都是结束状态，结束状态是可以量化收益的（比如方法1：答案错误收益-1，答案正确收益+3；再比如方法2：叶子节点的收益是到达叶子节点路径数/总路径数的概率，这是一种根据投票机制预估的价值，越多路径到达叶子节点，说明这个叶子节点越置信，那么这个叶子节点就有更高的奖励）。

一棵树的叶子节点有了奖励值，就可通过反向传播，计算每个中间节点的奖励值，最终计算出整个树所有节点的奖励值。MCTS一次rollout包括四个步骤：

select
expand
simulate
backprop

MCTS也可以用在两阶段：

Post-Traing阶段：对于每个problem构造一个搜索树，然后进行树的游走遍历采样，再用采样的样本SFT或RL训练模型。
Inference阶段：在推理阶段，也是对一个problem探索多节点构造一棵搜索树，对于到达正确答案的路径，根据节点路径的置信度打分，贪心选取最优路径作为最终的推理结果。

问题：

搜索空间巨大，虽然设置最大扩展限制使得不会无限搜索，但是容易陷入局部最优
value model直接影响生成的质量，而训练一个细粒度的value model本质上是困难的

小结

对应的流程图

使用注意

deepseek-r1使用指南

temperature设置在0.5-0.7之间，推荐0.6，以防止无休止的重复或不连贯的输出。
不要system prompt，直接放到user prompt里
数学问题，建议prompt里直接Please reason step by step, and put your final answer within \boxed{}.
有些时候模型会自己跳过think的过程，如果要强制输出，可以强制模型在output前输出<think>

上传文件的prompt：

file_template = \
"""[file name]: {file_name}
[file content begin]
{file_content}
[file content end]
{question}"""

联网的prompt：

search_answer_zh_template = \
'''# 以下内容是基于用户发送的消息的搜索结果:
{search_results}
在我给你的搜索结果中，每个结果都是[webpage X begin]...[webpage X end]格式的，X代表每篇文章的数字索引。请在适当的情况下在句子末尾引用上下文。请按照引用编号[citation:X]的格式在答案中对应部分引用上下文。如果一句话源自多个上下文，请列出所有相关的引用编号，例如[citation:3][citation:5]，切记不要将引用集中在最后返回引用编号，而是在答案对应部分列出。
在回答时，请注意以下几点：
- 今天是{cur_date}。
- 并非搜索结果的所有内容都与用户的问题密切相关，你需要结合问题，对搜索结果进行甄别、筛选。
- 对于列举类的问题（如列举所有航班信息），尽量将答案控制在10个要点以内，并告诉用户可以查看搜索来源、获得完整信息。优先提供信息完整、最相关的列举项；如非必要，不要主动告诉用户搜索结果未提供的内容。
- 对于创作类的问题（如写论文），请务必在正文的段落中引用对应的参考编号，例如[citation:3][citation:5]，不能只在文章末尾引用。你需要解读并概括用户的题目要求，选择合适的格式，充分利用搜索结果并抽取重要信息，生成符合用户要求、极具思想深度、富有创造力与专业性的答案。你的创作篇幅需要尽可能延长，对于每一个要点的论述要推测用户的意图，给出尽可能多角度的回答要点，且务必信息量大、论述详尽。
- 如果回答很长，请尽量结构化、分段落总结。如果需要分点作答，尽量控制在5个点以内，并合并相关的内容。
- 对于客观类的问答，如果问题的答案非常简短，可以适当补充一到两句相关信息，以丰富内容。
- 你需要根据用户要求和回答内容选择合适、美观的回答格式，确保可读性强。
- 你的回答应该综合多个相关网页来回答，不能重复引用一个网页。
- 除非用户要求，否则你回答的语言需要和用户提问的语言保持一致。

# 用户消息为：
{question}'''

openai推理使用指南

简单理解：

推理模型就像一位经验丰富的高级同事——你只需告诉他们最终目标，就能相信他们自主完成所有细节工作。
GPT模型则更像一位新手同事——你需要提供明确详细的指示，才能让他们准确完成特定的输出任务。

各自特点：

速度和成本：选择GPT模型，因为它们处理速度更快，成本更低
执行明确任务：选择GPT模型，它们在处理界定清晰的任务时表现出色
准确性和可靠性：选择o系列模型，它们是可靠的决策专家
复杂问题解决：选择o系列模型，它们善于处理模糊和复杂的问题

推理模型的优势：

处理模糊任务：推理模型特别擅长处理信息有限或零散的情况，只需通过简单的提示词就能理解用户意图并妥善处理指令中的信息缺口。值得注意的是，推理模型通常会在做出未经验证的猜测或填补信息空缺之前，主动提出澄清性问题。
大海捞针：当需要处理大量非结构化信息时，推理模型特别擅长理解内容并精准提取出回答问题所需的关键信息。
在大型数据集中发现关系和细微差别：
- 推理模型特别擅长分析包含数百页密集、非结构化信息的复杂文档，如法律合同、财务报表和保险索赔等。这些模型在识别文档之间的关联性，并基于数据中隐含的事实做出决策方面，表现尤为突出。
- 推理模型还特别擅长理解细微的政策和规则，并将其准确应用于具体任务中以得出合理结论。
多步骤AI智能体规划：推理模型在AI智能体规划和策略制定中发挥着关键作用。将推理模型作为「计划者」时效果显著：它能为问题制定详细的多步骤解决方案，并根据具体需求（高智能或低延迟）选择和分配合适的GPT模型（执行者）来完成各个步骤。
视觉推理能力：截至目前，o1是唯一一个具备视觉处理能力的推理模型。与GPT-4o相比，o1的独特优势在于它能够准确理解最具挑战性的视觉内容，包括结构不规则的图表和表格，以及质量欠佳的图片。
代码审查、调试和质量改进：推理模型在审查和改进大规模代码方面表现突出。考虑到这类模型的较高延迟特性，通常将代码审查任务安排在后台运行。虽然GPT-4o和GPT-4o mini凭借较低的延迟可能更适合直接编写代码，但在那些对延迟要求相对不那么严格的代码生成场景中，o3-mini表现同样出色。
评估和基准测试其他模型的响应：推理模型在对其他模型的输出进行基准测试和评估方面表现优异。数据验证对确保数据集的质量和可靠性至关重要，这一点在医疗保健等敏感领域尤其重要。

prompt注意点：

用开发者消息取代系统消息：自o1-2024-12-17版本起，推理模型开始支持开发者消息（developer message）而非系统消息（system message）。
保持提示词简洁明确：推理模型最擅长理解和响应简短、清晰的指令。
避免使用CoT提示：由于模型内置推理能力，因此无需特别提示它们「一步一步思考」或「解释推理过程」。
善用分隔符增强清晰度：使用Markdown、XML标签和章节标题等分隔符来明确区分输入的不同部分，这有助于模型准确理解各个章节的内容。
优先尝试零样本学习：推理模型通常无需少样本示例即可产出优质结果，因此建议先尝试不含示例的提示词。如果对输出结果有更复杂的要求，再考虑在提示词中添加输入和期望输出的示例。请注意确保示例与提示词指令严格匹配，因为不一致可能导致性能下降。
提供明确约束条件：如果需要对模型的响应施加具体限制（例如「提供预算控制在500美元以内的解决方案」），请在提示词中明确列出这些约束条件。
明确定义目标：在指令中，请详细说明判定响应成功的具体参数，并引导模型持续优化推理过程，直到达成设定的成功标准。
Markdown格式说明：从o1-2024-12-17版本开始，API中的推理模型默认不会生成带有Markdown格式的响应。如果确实需要在响应中包含Markdown格式，请在开发者消息的首行添加「Formatting re-enabled」字符串。

R1的部署

R1的讨论

，对应：

对应代码：

一些观点：

打破LLM训练从Generalist到Reasoner的常规思路，使用RL先得到Reasoner，再经过SFT成为Generalist;
GRPO算法的高效性，让RL大规模训练取得了效果;
SFT with CoT数据的训练结果在原文中并未给出，但从最近一些复现工作和R1 distiled Qwen结果来看，SFT的作用可能比RL还大。
好的Base模型本身就有Aha Moment，但是是Superfacial（表面）的reflection，不具有提升Accuracy的能力，RL可以增强该能力。

r1的解读（很长，142页）

模型思考过程分四步走：

问题定义：先把问题说清楚
开花期：拆解问题，给出初步方案
重构期：反复验证和修正想法
最终决策：确认并输出答案

有趣的发现：

思考链长度有"最佳区间"，太长反而会答错
模型会"死磕"用户给的信息，即使信息是错的也坚持跟着走
中英文环境下性格迥异：中文更重视集体，英文更个人主义
还会画ASCII艺术，虽然不太完美~

缺陷：

上下文太长容易"走神"
有时会生成有害内容
在某些视觉任务上还不够连贯

R1前后的一些工作

S1

（从xhs上抄的）有几点思维误区：

s1超过的是o1-preview，没有超过o1甚至o1-mini，有很大区别
s1的效果不敌deepseek-r1 800k数据蒸馏的32B模型，差了不少，不是媲美
s1即使使用全量59k数据的效果也没有提高很多，甚至在math上还有下降，所以核心是数据质量
1k数据是从59K数据中筛选出来的，不是直接有1K数据就可以
s1使用1k数据是节省了训练时间，但蒸馏的难点在蒸馏数据的构造上

LIMO

PRIME

TPO

Huginn

抛弃长思维链和人类的语言，直接在连续的高维潜空间用隐藏状态推理，可自适应地花费更多计算来思考更长时间。

Goedel-Prover

Kimi K1.5

，自己转存了一份：

O1 Embedder

生成关于输入查询的thought，然后和question一起拼接，然后分别独自生成嵌入，然后池化聚合。也就是说，这个Embedding模型比之前的模型多了个thought的输出。

微调，两个并行任务，一个是thought生成，一个是对比学习。

微调数据怎么来，那就是生成后进行打分评价。首先，使用LLM生成初始思想，然后使用检索评分器来根据初始思想和目标文档之间的相关性评分，最终通过多数投票选择最佳thought。

bridge

问题背景：传统的LLM在处理长文本时效率低下，尤其是在需要进行多步推理的任务中。近年来，随着长上下文LLM的发展，出现了多示例学习（many-shot ICL）的范式，即通过更多的示例来提升模型性能。然而，这种范式的效果和影响因素仍需进一步研究。

研究动机：为了提升多示例学习的效率，分析了影响多示例学习效果的关键因素，并发现仅少数关键示例就能显著提升性能。基于这一发现，团队提出了一种新的算法，通过优化选择关键示例和生成新的示例来进一步提升模型的推理能力。

bridge算法结合了优化和生成两个步骤：

在优化步骤中，使用贝叶斯优化（Bayesian optimization）来发现关键示例；
在生成步骤中，利用这些关键示例作为示范，重新生成更多的示例，从而在多示例学习中提高模型性能。

BFS-Prover

CoE

显式CoT

认知行为

DR, GRPO

AReaL

TAO

TAO 的核心创新在于摒弃了人工标注数据，转而利用测试时计算引导模型探索任务的可能响应，再通过强化学习根据响应评估结果更新模型参数。

该流程通过可扩展的测试时计算（而非昂贵的人工标注）实现质量提升，并能灵活融入领域知识（如定制规则）。令人惊讶的是，在高质量开源模型上应用该方法时，其效果往往优于依赖人工标注的传统方案。

TAO 包含四个核心阶段：

响应生成：该阶段首先收集任务相关的输入提示或查询样本。在Databricks平台上，这些提示可通过AI Gateway自动采集；
响应评分：系统化评估生成响应的阶段。评分方法包含多种策略，例如基于奖励模型、偏好评分，或利用LLM评判器及定制规则进行任务特异性验证，确保每个响应都做到最优；
强化学习（RL）训练：最终阶段采用基于强化学习的方法更新大语言模型，引导模型生成与高分响应高度契合的输出。通过这一自适应学习过程，模型持续优化预测能力以提升质量；
持续改进：TAO仅需LLM输入样本作为数据源。用户与LLM的日常交互自然形成该数据（一旦模型部署使用，即可自动生成下一轮TAO训练数据）。在 Databricks平台上，借助TAO机制，模型会随着使用频次增加而持续进化。

虽然TAO在训练阶段使用了测试时计算，但最终产出的模型在执行任务时仍保持低推理成本。这意味着经过TAO调优的模型在推理阶段（与原版模型相比）具有完全相同的计算开销和响应速度，显著优于 o1、o3 和 R1 等依赖测试时计算的模型。实验表明：采用 TAO 训练的高效开源模型，在质量上足以比肩顶尖的商业闭源模型。

TAO为AI模型调优提供了一种突破性方法：

不同于耗时且易出错的提示工程；
也区别于需要昂贵人工标注数据的传统微调；
TAO 仅需工程师提供任务相关的典型输入样本，即可实现卓越性能。

deepcoder

DeepCoder-14B-Preview

Think twice

多轮思考（Multi-round Thinking）：通过迭代地利用之前的答案作为提示，对模型的推理过程进行逐步优化。允许模型在多个推理轮次中重新考虑之前的答案，每次迭代只保留上一轮的最终答案，摒弃中间推理步骤。这一过程类似于人类的认知模式，有助于模型纠正常见的推理错误。

glm-z1

d1

regtool

两阶段训练，先冷启注入pattern，再RL进一步泛化

阶段1：收集纯文本数学推理数据->人工专家和Deepseek-R1双重验证过滤无效数据->直接prompt模型将手动计算步骤替换为代码片段，生成代码增强的推理数据->格式/答案验证->得到的数据集用来SFT冷启模型
阶段2：RL rollout时候当检测到\code时停止生成，代码片段在sandbox中执行，并将解释器反馈拼接到原来生成序列中，使用是否做对（+1/-1）作为奖励信号进行PPO训练

RLVR的局限

RLVR（可验证奖励的强化学习）只是将采样做得更有效率，而其输出的正确答案，早已藏在基座模型的「基因」里。

RLFT

小结

R1的复现与部署

open-r1

unlock-deepseek

open-reasoner-zero

vllm跑gguf的r1

从源码安装参考

export https_proxy=xxxxxx
pip3 install setuptools_scm ## 不知道是不是需要的
git clone https://github.com/vllm-project/vllm.git
cd vllm
VLLM_USE_PRECOMPILED=1 pip3 install --editable .

# 如果网络有问题，可以直接pip3 install .
# 下面这3步还是比较必要的
cp -r /usr/local/lib/python3.10/dist-packages/vllm /usr/local/lib/python3.10/dist-packages/vllm.bk
rm -rf /usr/local/lib/python3.10/dist-packages/vllm
cp -r ./vllm /usr/local/lib/python3.10/dist-packages

去把各个非model的小文件下载下来（可以直接GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/deepseek-ai/DeepSeek-R1）也要下载，
去把config.json下载下来，把json里的torch_dtype里的bfloat16改成float16，覆盖掉上面那个目录里的config.json

上面的那些文件都放到./unsloth_dir目录下，注意，目前只能用Q2 Q4那种量化，1.58bit那种动态量化不支持

cd ./unsloth_dir/
# merge成一个gguf
llama.cpp/llama-gguf-split --merge ./DeepSeek-R1-Q2_K/DeepSeek-R1-Q2_K-00001-of-00005.gguf ./unsloth_dir/merge.gguf

代码：

from vllm import LLM, SamplingParams

import multiprocessing

if __name__ == "__main__":
    # 这坨要放main里，deepseek教我的
    multiprocessing.set_start_method('spawn', force=True)
    
    llm = LLM(model="./unsloth_dir/merge.gguf",
              tokenizer="./unsloth_dir/DeepSeek-R1",
              hf_config_path="./unsloth_dir/DeepSeek-R1",
              enforce_eager=True, 
              tensor_parallel_size=8, #
              trust_remote_code=True, 
              distributed_executor_backend="mp",
              max_model_len=2000)
    sampling_params = SamplingParams(temperature=0.5, max_tokens=2000)
    
    def print_outputs(outputs):
        for output in outputs:
            prompt = output.prompt
            generated_text = output.outputs[0].text
            print(f"Prompt: {prompt!r}, Generated text\n: {generated_text}")
        print("-" * 80)
    conversation = [
        {
            "role": "user",
            "content": "中国的首都是哪里",
        },
    ]
    outputs = llm.chat(conversation,
                       sampling_params=sampling_params,
                       use_tqdm=False)
    print_outputs(outputs)

运行：

VLLM_MLA_DISABLE=1 VLLM_WORKER_MULTIPROC_METHOD=spawn python3 vllm_deepseek.py

unsloth

跑满血版1.58bit infer

让小模型有reasoning能力

Logic-RL与reinforce-lite

reinforce-lite

Logic-RL

R1的微调

ColossalAI

lora sft满血deepseek V3/R1

数据：
fp8权重转bf16：
脚本：

通过使用 LoRA 等优化，示例命令已将 SFT DeepSeek V3/R1 671B 最低硬件要求降低近 10 倍，可使用 32 个 Ascend 910B NPU 64GB（使用 ep=8,pp=4）或 24 个 H100/H800 GPU（使用 ep=8,pp=3）。如果你通过 --zero_cpu_offload 启用 CPU offload，硬件要求可以进一步降低，但会损失一定的训练速度。

colossalai run --hostfile path-to-host-file --nprocpernode 8 \
  lorafinetune.py --pretrained path-to-DeepSeek-R1-bf16 \
  --dataset path-to-dataset.jsonl --plugin moe \
  --lr 2e-5 --maxlength 256 -g --ep 8 --pp 3 \
  --batchsize 24 --lorarank 8 --loraalpha 16 \
  --numepochs 2 --warmupsteps 8 \
  --tensorboarddir logs --save_dir DeepSeek-R1-bf16-lora

也可以使用上述脚本，将并行度高效扩展至数百及数千卡，快速完成 DeepSeek V3/R1 671B 全参微调或并行加速。

用强化学习微调蒸馏版DeepSeek

奖励设计：

奖励 = 0，如果格式是错误的；
奖励 = 1，如果格式是正确的但是结果是错误的；
奖励 = 10，如果格式与结果都是正确的。

模板和设定：
启动脚本：

OpenAI

Qwen

QwQ-max-preview

QWQ-32B

目前只有博客，写得挺简单的，看介绍是用了两阶段RL：

1阶段RL：在冷启ckpt上，只拿代码和数学语料，基于outcome-base reward，随着训练的进行，发现这两方面的能力都有持续提升
- 数学：有一个accuracy verifier，检查最终解决方案是否正确
- 代码：有一个代码执行server，检查代码是否通过预定义好的测试用例
2阶段RL：没说用什么语料，但用的是general reward model加上rule-based verifiers产生的reward，发现只要少量的step就能提升模型的通用能力，如指令遵循、人类偏好对齐、agent性能，而且代码和数学能力下降不明显

Claude

Claude 3.7 Sonnet

既是普通的 LLM，又是推理模型。你可以选择何时希望模型正常回答，何时希望它在回答之前思考更长时间。在标准模式下，Claude 3.7 Sonnet 是前代 Claude 3.5 Sonnet 的升级版。在扩展思维模式下，它会在回答之前进行自我反思，从而提高其在数学、物理、指令遵循、编码和许多其他任务上的表现。Anthropic 发现，两种模式下，模型的提示词工作方式类似。
当通过 API 使用 Claude 3.7 Sonnet 时，用户还可以控制思考预算。你可以告诉 Claude 思考不超过 N 个 token。对于任何 N 值，其输出限制为 128K 个 token。这允许用户在速度（和成本）和答案质量之间进行权衡。
第三，在开发自家的推理模型时，Anthropic 对数学和计算机科学竞赛问题的优化较少，而是将重点转向更能反映企业实际使用 LLM 方式的现实任务。

基于llama的推理模型

Llama Nemotron

seed-thinking

DAPO

数据：

VAPO

多模态推理

综述

视觉推理

R1V

gemini 2.0

Video-T1

mureka o1(音乐)

Kimi-VL

统一的多模态模型

gemini 2.5

Gemini 2.5 Pro的上下文窗口是1M tokens，并且支持原生多模态：可以理解庞大数据集并处理来自不同信息源的复杂问题，包括文本、音频、图像、视频，甚至是整个代码库。2.5 pro擅长创造视觉上引人注目的Web应用程序和智能体代码。

gemma-3

架构设计：Gemma 3基于decoder-only架构，与前两代Gemma模型类似。但在细节上有所创新，例如采用GQA和RMSNorm，还引入了QK-norm替代Gemma 2中的软封顶机制，以提升性能和稳定性。
训练策略：Gemma 3的训练过程包括预训练和指令微调两个阶段。在预训练阶段，模型使用知识蒸馏技术，从大规模数据中学习语言和视觉表示。训练数据涵盖了文本、图像以及多语言等多种类型，且经过严格的筛选和清洗，以减少有害内容和低质量数据的影响。在指令微调阶段，Gemma 3 采用了新颖的训练方法，重点关注数学、聊天、指令遵循和多语言等能力的提升。

Qwen2.5-Omni

Qwen3

开源了两个MoE模型的权重：

Qwen3-235B-A22B：拥有2350多亿总参数和220多亿激活参数
Qwen3-30B-A3B：拥有约300亿总参数和30亿激活参数

此外，还有6个Dense模型：Qwen3-32B、Qwen3-14B、Qwen3-8B、Qwen3-4B、Qwen3-1.7B和Qwen3-0.6B

预训练

Qwen2.5是在18万亿个token上进行预训练的，而Qwen3使用的数据量几乎是其两倍，达到了约36万亿个token，涵盖了119种语言和方言。

预训练过程分为三个阶段。

第一阶段：模型在超过30万亿个token上进行了预训练，上下文长度为4Ktoken。这一阶段为模型提供了基本的语言技能和通用知识。
第二阶段：通过增加知识密集型数据（如STEM、编程和推理任务）的比例来改进数据集，随后模型又在额外的5万亿个token上进行了预训练。
第三阶段：使用高质量的长上下文数据将上下文长度扩展到32Ktoken，确保模型能够有效地处理更长的输入。

效果：

Qwen3 Dense基础模型的整体性能与参数更多的Qwen2.5基础模型相：Qwen3-1.7B/4B/8B/14B/32B-Base分别与Qwen2.5-3B/7B/14B/32B/72B-Base表现相当。特别是在STEM、编码和推理等领域，Qwen3 Dense基础模型的表现甚至超过了更大规模的Qwen2.5模型。
Qwen3 MoE基础模型在仅使用10%激活参数的情况下，达到了与Qwen2.5 Dense基础模型相似的性能，带来了训练和推理成本的显著节省。

后训练

四阶段：

长思维链冷启动：使用多样的的长思维链数据对模型进行了微调，涵盖了数学、代码、逻辑推理和 STEM 问题等多种任务和领域。这一过程旨在为模型配备基本的推理能力。
长思维链强化学习：重点是大规模强化学习，利用基于规则的奖励来增强模型的探索和钻研能力。
思维模式融合：在一份包括长思维链数据和常用的指令微调数据的组合数据上对模型进行微调，将非思考模式整合到思考模型中。确保了推理和快速响应能力的无缝结合。
通用强化学习：在包括指令遵循、格式遵循和Agent能力等在内的20多个通用领域的任务上应用了强化学习，以进一步增强模型的通用能力并纠正不良行为。

使用

vllm：

vllm serve Qwen/Qwen3-30B-A3B --enable-reasoning --reasoning-parser deepseek_r1
# 要禁用思考模式，可以移除--reasoning-parser以及--enable-reasoning

软切换机制，可以在enable_thinking=True时动态控制模型的行为，即在用户prompt或系统prompt中添加/think和/no_think来逐轮切换模型的思考模式。

from transformers import AutoModelForCausalLM, AutoTokenizer

classQwenChatbot:
    def __init__(self, model_name="Qwen3-30B-A3B/Qwen3-30B-A3B"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForCausalLM.from_pretrained(model_name)
        self.history = []

    def generate_response(self, user_input):
        messages = self.history + [{"role": "user", "content": user_input}]

        text = self.tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True
        )

        inputs = self.tokenizer(text, return_tensors="pt")
        response_ids = self.model.generate\
          (**inputs, max_new_tokens=32768)[0][len(inputs.input_ids[0]):].tolist()
        response = self.tokenizer.decode(response_ids, skip_special_tokens=True)

        # Update history
        self.history.append({"role": "user", "content": user_input})
        self.history.append({"role": "assistant", "content": response})

        return response

# Example Usage
if __name__ == "__main__":
    chatbot = QwenChatbot()

    # First input (without /think or /no_think tags, 
    # thinking mode is enabled by default)
    user_input_1 = "How many r's in strawberries?"
    print(f"User: {user_input_1}")
    response_1 = chatbot.generate_response(user_input_1)
    print(f"Bot: {response_1}")
    print("----------------------")

    # Second input with /no_think
    user_input_2 = "Then, how many r's in blueberries? /no_think"
    print(f"User: {user_input_2}")
    response_2 = chatbot.generate_response(user_input_2)
    print(f"Bot: {response_2}") 
    print("----------------------")

    # Third input with /think
    user_input_3 = "Really? /think"
    print(f"User: {user_input_3}")
    response_3 = chatbot.generate_response(user_input_3)
    print(f"Bot: {response_3}")

MCP：可以使用MCP配置文件，使用Qwen-Agent内置的工具，或者自行集成其他工具。

from qwen_agent.agents import Assistant

# Define LLM
llm_cfg = {
    'model': 'Qwen3-30B-A3B',
    # Use the endpoint provided by Alibaba Model Studio:
    # 'model_type': 'qwen_dashscope',
    # 'api_key': os.getenv('DASHSCOPE_API_KEY'),
    # Use a custom endpoint compatible with OpenAI API:
    'model_server': 'http://localhost:8000/v1',  # api_base
    'api_key': 'EMPTY',
    # Other parameters:
    # 'generate_cfg': {
    #         # Add: When the response content is `<think>this is the thought</think>this is the answer;
    #         # Do not add: When the response has been separated by reasoning_content and content.
    #         'thought_in_content': True,
    #     },
}

# Define Tools
tools = [
    {'mcpServers': {  # You can specify the MCP configuration file
            'time': {
                'command': 'uvx',
                'args': ['mcp-server-time', '--local-timezone=Asia/Shanghai']
            },
            "fetch": {
                "command": "uvx",
                "args": ["mcp-server-fetch"]
            }
        }
    },
  'code_interpreter',  # Built-in tools
]

# Define Agent
bot = Assistant(llm=llm_cfg, function_list=tools)

# Streaming generation
messages = [{'role': 'user', 'content': 
  'https://qwenlm.github.io/blog/ Introduce the latest developments of Qwen'}]
for responses in bot.run(messages=messages):
    pass
print(responses)

UniME

阶段一：文本判别知识蒸馏

用纯文本数据来增强MLLM中LLM的嵌入能力，用了273k个句子对。

teacher：基于LLM的嵌入模型NV-Embed V2（对比训练中移除了causal mask）离线批量产出文本的emb
student：MLLM中把LLM部分剥离出来，输入prompt Summary the above sentences in one word: \n”，最后一个token的emb当成输出
蒸馏：teacher和student间算KL散度，LoRA训练

推理时：

单模态输入：通过prompt的设置，决定只走对应的vision/text encoder
图片+文字输入：通过prompt，各自过模型，然后把输出的2个emb进行融合

阶段二：困难负样本增强指令微调

拿多模态的样本对来提升图文之间的对齐，用了662k个pair对：

query: img+prompt
doc: img

样本处理：

干掉false negative：有些负样本和query的相似度太高了，干掉
增加hard negative：除了正例和前面的false negative外，在负样本里找出k个和query最像的，当成hard negative

loss是infoNCE，然后用QLoRA来微调

代码：

import torch
from PIL import Image
from torch.nn import functional as F
from self_evaluate.utils.utils import init_model_and_transform

model_name = "phi35V"
base_model_path="DeepGlint-AI/UniME-Phi3.5-V-4.2B"
# model_name = "llava_16"
# base_model_path="DeepGlint-AI/UniME-LLaVA-1.6-7B"

if model_name == "phi35V":
    img_prompt = '<|user|>\n<|image_1|>\nSummary above image in one word: <|end|>\n<|assistant|>\n'
    text_prompt = '<|user|>\n<sent>\nSummary above sentence in one word: <|end|>\n<|assistant|>\n'
elif model_name == "llava_16":
    img_prompt = "[INST] <image>\nSummary above image in one word: [/INST]"
    text_prompt = "[INST] <sent>\nSummary above sentence in one word: [/INST]"

text = "A man is crossing the street with a red car parked nearby."
image_path = "figures/demo.png"
input_texts = text_prompt.replace('<sent>', text)
input_image_prompt = img_prompt
input_image = [Image.open(image_path)]

model, transform = init_model_and_transform(model_name, base_model_path)
inputs_text = transform(text=input_texts,
                    images=None,
                    return_tensors="pt", 
                    padding=True)
for key in inputs_text: inputs_text[key] = inputs_text[key].to("cuda")
inputs_image = transform(text=input_image_prompt,
                    images=input_image, 
                    return_tensors="pt", 
                    padding=True).to("cuda")

with torch.no_grad():
  emb_text = model(**inputs_text, output_hidden_states=True, return_dict=True).hidden_states[-1][:, -1, :]
  emb_image = model(**inputs_image, output_hidden_states=True, return_dict=True).hidden_states[-1][:, -1, :]
  emb_text = F.normalize(emb_text, dim=-1)
  emb_image = F.normalize(emb_image, dim=-1)
  Score = emb_image @ emb_text.T
print("Score: ", Score) # Score: 0.59

其中：

def init_model_and_transform(model_name, base_model_path): 
    if model_name == 'phi35V':
        transform = AutoProcessor.from_pretrained("microsoft/Phi-3.5-vision-instruct", 
        trust_remote_code=True)
        model = AutoModelForCausalLM.from_pretrained(base_model_path,
                            device_map="cuda", trust_remote_code=True,
                            torch_dtype=torch.float16, 
                            _attn_implementation='flash_attention_2')
    elif model_name == "llava_16": 
        transform = LlavaNextProcessor.from_pretrained("llava-hf/llava-v1.6-mistral-7b-hf")
        model = LlavaNextForConditionalGeneration.\
          from_pretrained(base_model_path, device_map="cuda", 
            torch_dtype=torch.float16, low_cpu_mem_usage=True) 
    transform.tokenizer.padding_side = "left"
    transform.tokenizer.padding = True
    return model, transform

deep research

local-deep-research

CycleResearcher

高效reasoning

reasoning economy

数据：
- 干掉冗余、噪声、太长的数据
- 保留高质量数据
算法：
- Long2Short RL：惩罚过长的输出
- budget-aware tuning：简单问题输出短，复杂问题输出长
- CoT Compression：显式/隐式压缩CoT
模型：
- adaptive Activated Parameters：类似稀疏激活
- Model Cooperation：搞2个模型，简单问题走简单模型，复杂问题走复杂模型

输入侧：解码之前进行自适应预算分配
- 对输入进行成本预估
输出侧：
- thinking pattern的自适应预算分配：简单问题直接剪枝，复杂问题需要回溯+验证+反思
- 解码算法的自适应预算分配：简单问题贪心解码，复杂问题多一些采样

stop overthinking

model：
- length reward：RL时加上新的reward，鼓励答案正确且cot短的
- variable-length cot reasoning data：构造不同长度cot的数据集，然后sft
reasoning-output：
- latent reasoning：将reasoning steps压缩成latent表示
- dynamic reasoning：reasoning的过程改成投机采样、拒绝采样、tree-of-thoughts等方式
input prompt：
- length prompts：let's use less than k tokens
- routing by difficulty：训一个小模型，决定简单问题不思考，困难问题再思考

deepseek

GRM+SPCT

critique：生成的文本评价，即评论

RM分类

RM可以进行如下分类：

reward生成范式：输入query和一些responses
- scalar：只输出reward值
- semi-scalar：生成critique和scalar
- generative：只输出critique
打分范式：输入query和2个responses
- pointwise：输出每个response的得分
- pairwise：输出二者的相对得分

几种常见RM：

Bradley-Terry，scalar + pointwise
PairRM：scalr + pairwise
CLoud：semi-scalr + pointwise
LLM-as-a-Judge：semi-scalr或者generative + pairwise
Pointwise GRM：generative + pointwise

SPCT

核心：principle（准则）不再只是辅助性的输入，而是使模型能在生成过程中主动生成并基于此生成对应的critique

Self-Principled Critique Tuning (SPCT)

训练（2阶段）：输入query+2个response
- RFT（rejective fine-tuning）：使GRM能够生成格式正确且适配多种输入类型的principle与critique
  - 使用预训练的pointwise-GRM，采样得到N个priciple + response，和goundtruth比较(groundtruth对应的reward是不是比其他N-1个结果对应的reward高)，满足下面条件的扔了，剩下的构造成一个数据集
    全对的就是too-easy的，扔掉；
    错误的也扔掉
  - 同时还有一定比例的hint sampling，即把groundtruth提前泄露到GRM的prompt里去，让模型倾向于去对齐groudtruth
- RL（rule-based online RL）：通过不断优化生成的准则和评论，进一步增强泛化型奖励生成能力。
  - 也是用的GRPO，只有accuracy reward，没format reward，加大KL-penalty
推理：输入query+2个response
- 并行采样出一堆的principles+critiques，即m条结果
- voting：
  - 基于生成式reward：即每个里的response1的reward求和，同理response2的reward求和，得到1和2的总得分
  - 基于meta RM：训练一个pointwise scalar RM，用二分类来判断principle+critique对不对(label和RFT的一样)。使用：对这m个结果打分，干掉质量差的（图中就是只保留了第1和第3个），然后对剩下的 $k_{meta}$ 个去投票

DeepSeek-Prover-V2

专为Lean 4 打造的开源大语言模型，专注于形式化定理证明。

两阶段训练，建立了两种互补的证明生成模式：

高效非思维链（non-CoT）模式：针对快速生成正式的Lean证明代码进行优化，专注于生成简洁的证明，没有显式的中间推理步骤。
高精度思维链（CoT）模式：系统地阐述中间推理步骤，强调透明度和逻辑进展，然后构建最终的正式证明。

与 DeepSeek-Prover-V1.5一致，这两种生成模式由两个不同的引导提示控制。

第一阶段采用专家迭代，在课程学习框架内训练一个非CoT证明模型，同时通过基于子目标的递归证明合成难题的证明。选择非CoT生成模式是为了加速迭代训练和数据收集过程。
在此基础上，第二阶段利用了冷启动链式思维（CoT）数据，通过将 DeepSeek-V3 复杂的数学推理模式与合成形式证明相结合而生成。CoT模式通过进一步的强化学习阶段得到增强，遵循了通常用于推理模型的标准训练流程。

DeepSeek-Prover-V2的非CoT模式训练过程遵循专家迭代的范式，这是开发形式化定理证明器广泛采用的框架。在每次训练迭代中，当前最佳证明策略用于生成那些在先前迭代中未解决的难题的证明尝试。这些成功的尝试经由Lean证明助手验证后，被纳入SFT数据集以训练改进的模型。

这一迭代循环不仅确保模型能够从初始演示数据集中学习，还能提炼出自己的成功推理轨迹，逐步提高其解决更难问题的能力。总体训练过程与 DeepSeek-Prover-V1 的训练过程大致一致，仅对训练问题的分布进行了两项修改：

Prover-V2引入了来自自动形式化和各种开源数据集的额外问题，扩大了训练问题领域的覆盖范围。
新模型通过子目标分解生成的问题来扩充数据集，旨在解决MiniF2F基准测试有效划分中的更多挑战性实例。

在DeepSeek-V3-Base-671B上使用恒定的学习率5e-6，在16384个token的上下文中进行监督微调。训练语料库由两个互补来源组成：

通过专家迭代收集的非CoT数据，生成无需中间推理步骤的Lean代码；
冷启动CoT数据，将DeepSeek-V3的高级数学推理过程提炼为结构化的证明路径。非CoT组件强调精益定理证明器生态系统中的形式验证技能，而CoT示例明确地建模了将数学直觉转化为形式证明结构的认知过程。

Prover-V2采用GRPO，通过为每个定理提示采样一组候选证明并根据它们的相对奖励优化策略，消除了对单独critic模型的需求。训练使用二元奖励，每个生成的Lean证明如果被验证为正确则获得1个奖励，否则为0。为了确保有效学习，研究人员精心挑选训练提示，仅包括那些对监督微调模型具有足够挑战性但可解决的问题。模型在每次迭代中采样256个不同的问题，为每个定理生成32个候选证明，最大序列长度为32768个token。

模型蒸馏：

把DeepSeek-Prover-V1.5-Base-7B的最大上下文长度从4096个token扩展到了32768个，并使用DeepSeek-Prover-V2-671B强化学习阶段收集的rollout数据对这个扩展上下文模型进行微调。
除了CoT推理模式外，还整合了专家迭代过程中收集的非CoT证明数据，以实现一种成本效益高的证明选项，该选项能够生成简洁的形式化输出，并且模型规模较小。
7B模型也采用了与671B模型训练相同的强化学习阶段以提升性能。

推理模型总结

(toread)

更新的：