Huanyu Yang

Lora

Wed, 22 Jul 2026 21:00:00 +0800

技术产生原因

LoRA: Low-Rank Adaptation of Large Language Models

显存占用大
存储成本高
切换任务效率低

原理

数学表达

对于原始权重矩阵 W₀（维度为 d×k），全参数微调是直接更新为 W₀+ΔW，ΔW与W₀维度相同

LoRA的做法是冻结W₀不变，将ΔW分解为两个低秩矩阵的乘积：

1

ΔW = B × A

其中：

A 的维度为 r×k
B 的维度为 d×r
r 是秩（rank），是一个远小于d和k的超参数，常见取值为4、8、16、32、64 前向传播时的计算变为：

1

h = W₀x + ΔWx = W₀x + BAx

训练时只更新A和B这两个小矩阵，W₀始终冻结不参与梯度更新

e.g. 假设原矩阵维度为 d=k=4096（常见于大模型的注意力层），全参数微调需要更新 4096×4096 ≈ 1677万参数

若取 r=8，LoRA只需更新：

A矩阵：8×4096 = 32768
B矩阵：4096×8 = 32768
合计：65536参数参数量减少约256倍。这直接导致：
梯度计算量大幅减少
优化器状态占用大幅减少
最终保存的权重文件只需保存A、B两个小矩阵，通常几MB到几十MB

初始化方式

训练开始时，A矩阵通常用高斯随机初始化，B矩阵初始化为全零矩阵。这样保证训练刚开始时 BA=0，即ΔW=0，模型初始状态等价于原始预训练模型，不会因为随机初始化破坏原有能力，训练过程平稳

推理时的处理

训练完成后，可以将 B×A 直接加到W₀上得到新的权重矩阵 W₀+BA，这一步是简单的矩阵加法运算。这意味着推理时不会引入额外的计算延迟，因为最终使用的还是一个完整的d×k权重矩阵，结构和原模型完全一致

如果不合并，也可以保持A、B独立存在，前向传播时并行计算W₀x和BAx后相加，这样便于同一个基座模型加载不同任务的多组A、B，实现快速切换

作用位置

LoRA通常不作用于模型的全部权重矩阵，而是选择性地作用于特定层，最常见的是Transformer结构中注意力模块的权重矩阵（Query、Key、Value、Output的投影矩阵），也可以扩展到前馈网络层。作用的层数量和位置是可配置的超参数，会影响效果和训练开销的平衡

关键超参数

超参数	说明
r（秩）	决定低秩矩阵的维度，r越大表达能力越强，但参数量和计算量也越大，同时也越接近全参数微调
alpha（缩放系数）	用于控制ΔW对原始输出的影响程度，实际计算中会有一个缩放因子 alpha/r 乘在BAx上
target_modules	指定对哪些权重矩阵施加LoRA
dropout	在LoRA模块中加入的dropout比例，用于防止过拟合

常用框架与工具

PEFT（Parameter-Efficient Fine-Tuning）：由HuggingFace开发的库，是目前最主流的LoRA实现工具，支持与Transformers库无缝结合，同时支持LoRA的多个变体（如AdaLoRA、QLoRA等）。
QLoRA：在LoRA基础上结合量化技术，将基座模型量化为4-bit精度存储，同时保持LoRA部分为可训练的浮点参数，进一步降低显存占用，使得在消费级显卡上微调较大模型成为可能。
LLaMA-Factory：国内团队开发的开源训练框架，封装了包括LoRA在内的多种微调方法，提供命令行和Web界面，适合快速上手。

常见变体

QLoRA：结合4-bit量化，降低显存占用
AdaLoRA：训练过程中动态调整不同层的秩分配，而非固定统一的r值
DoRA（Weight-Decomposed Low-Rank Adaptation）：将权重分解为幅度和方向两部分分别处理，是2024年提出的改进方法

QLoRA

解决显存占用问题 QLoRA

核心思路

把基座模型压缩到4-bit存储，同时保持LoRA部分的训练精度不变

原理

NF4量化：一种专门针对正态分布权重设计的4-bit数据类型，量化区间根据正态分布的分位数划分，而不是简单等间距划分，因此在权重数值集中的区域（0附近）保留更多精度，整体量化误差更小
双重量化：量化过程中每个数据块需要存储一个32位的缩放常数，双重量化把这些缩放常数本身也压缩为8位，进一步减少显存占用

计算过程

基座权重以4-bit存储，但实际做矩阵乘法时会临时反量化为bf16精度参与计算，计算完立即释放，不常驻高精度副本。真正被训练更新的仍然只有LoRA新增的A、B矩阵，且这两个矩阵全程保持bf16精度，不参与量化

AdaLoRA

论文里明确指出它要解决的问题是：原始LoRA给所有层统一分配相同的秩r，忽略了不同权重矩阵对下游任务的重要性差异

AdaLoRA

奇异值分解（SVD）

奇异值分解（Singular Value Decomposition，简称SVD）是线性代数中的一个基本定理：任意一个矩阵，都可以分解成三个矩阵的乘积

重要性打分

敏感度(wij) = |wij × ∇wij L|

如果只用其中某一步的值来判断这个参数重不重要，结果会很不稳定

滑动平均（Exponential Moving Average, EMA）：

I(t)(wij) = β1 × I(t-1)(wij) + (1-β1) × I(t)(wij)

这个公式的意思是：新的平滑值 = 85%的历史平滑值 + 15%的这一步新值

“不确定性”，衡量的是"这一步的新值，跟历史平滑值差了多少"： U(t)(wij) = β2 × U(t-1)(wij) + (1-β2) × |I(t)(wij) - I(t)(wij)| 这个不确定性指标的作用：如果一个参数每一步的值都跟历史平滑值差得很远（U值一直很大），说明这个参数的重要性评估很不稳定，不能完全信任；如果每一步的值都很接近历史平滑值（U值很小），说明这个参数的重要性评估很稳定可靠

最终打分：两者相乘 s(t)(wij) = I(t)(wij) × U(t)(wij) 意思是：一个参数只有当它本身敏感度高（I大），同时最近又出现了明显的变化（U大，说明它的重要性正在剧烈调整、可能正处在关键的学习阶段），才会被认为是最值得关注的参数

从"单个参数打分"组合成"一个方向（triplet）的打分" Si = s(λi) + (1/d1)Σ(k=1到d1) s(Pki) + (1/d2)Σ(k=1到d2) s(Qik) 这个公式在算的是：第i个方向（也就是Λ对角线上第i个位置）的总重要性得分

把全模型所有方向的Si放在一起排序,排名靠后的方向对应的λi直接置零，实现动态裁剪

步骤

步骤	内容
1	给每个目标权重矩阵（如每层的Wq、Wk、Wv、Wo）各自初始化一组P、Λ、Q，Λ的初始秩通常偏大
2	Λ里每个对角线位置代表一个独立的"方向"，训练时每个方向单独计算敏感度分数并做滑动平均
3	把全模型所有矩阵、所有方向的分数汇总到一起统一排序
4	按照预设的全局总预算，分数最低的方向逐步置零，不区分它属于哪一层
5	训练结束后，不同层、不同矩阵保留的实际有效方向数量各不相同，重要的层保留得多，不重要的层保留得少

具体改进包含两部分：

改进点1：把ΔW参数化为SVD形式

原始LoRA：ΔW = BA（B、A没有正交约束）

AdaLoRA：ΔW = PΛQ（P、Q近似正交，Λ的对角线是"奇异值"）

相对于"直接对BA做结构化剪枝"（整组丢弃某个doublet）的优势：BA的B和A不是正交的，各个doublet之间可能存在依赖关系，如果直接丢弃一个doublet会导致矩阵变化剧烈，训练不稳定；而PΛQ形式下，只需要把不重要的奇异值置零，对应的奇异向量（P、Q的那一列/行）仍然保留着，未来如果发现这个方向其实重要，还有"复活"的可能，训练也更平稳

改进点2：重要性打分机制

不是简单用奇异值大小 |λᵢ| 判断重要性，而是把奇异值本身的大小，加上它对应的P列、Q行里每个参数的敏感度（参数值×梯度，并做了平滑+不确定性调整），三者加权组合成综合得分。消融实验证明这个组合打分比单纯用|λᵢ|或单纯用敏感度效果更好

改进点3：全局预算调度器（Global Budget Scheduler）

不是一开始就按目标预算裁剪，而是先给一个比目标预算略高的初始预算（如1.5倍），warm-up之后按三次方曲线逐渐降到目标值。让模型先探索完整参数空间，再逐步聚焦到重要权重，提高训练稳定性

IGU-LoRA —— 相对于AdaLoRA的改进

用积分梯度（Integrated Gradients, IG）替代瞬时梯度敏感度

AdaLoRA的敏感度公式：|wᵢⱼ × ∇wᵢⱼL|，只看当前这一步的梯度

敏感度(wij) = |wij × ∫₀¹ ∂L(α·ΔW)/∂wij dα|

流程

正常训练A、B（跟普通LoRA一样）
每个mini-batch训练完，顺便对AB做一次SVD，得到PΛQ
用当前这个mini-batch随机采样到的α点，算一次积分梯度的抽样估计（针对P、Q里每个参数）
一个epoch跑完后，把这个epoch内所有mini-batch的抽样估计取平均，得到这一epoch的聚合敏感度
用滑动平均+不确定性量化，算出最终的SNR打分
结合每个奇异值本身的大小，算出每个方向（每个triplet）的综合重要性得分
全局排序，挑出分数最高的前b个方向保留，其余的对应奇异值置零
把保留下来的部分重新组装回A、B两个矩阵，继续下一轮训练

Revisiting Weight Regularization

持续学习（Continual Learning）场景下怎么避免遗忘之前学过的任务的问题

维护一个Fisher信息矩阵，记录"之前的任务认为哪些位置的权重变化很重要"，在训练新任务时，往损失函数里加一个正则化项，惩罚在这些重要位置上的大幅改动

Be a good engineer

Fri, 30 Jan 2026 00:00:00 +0000

成为一个好的工程师

基本功笔记

主流并行框架（DDP/DeepSpeed/Megatron）均基于 SPMD（Single Program Multiple Data）架构：所有进程执行相同代码逻辑，通过环境变量差异自主确定行为模式，无需中心调度节点。灵活性不如single-controller模式。

计算GPU称为Worker，梯度聚合GPU称为Server

AllReduce

目前最通用的AllReduce方法：Ring-AllReduce。它由百度最先提出，非常有效地解决了数据并行中通讯负载不均的问题，使得DDP得以实现

Ring-ALLReduce(“先富带动后富"思想)则分两大步骤实现该目标：Reduce-Scatter(圆排列转一圈后所有参数都有一个位置已经都更新完成)和All-Gather(把每一部分更新完的参数更新到其他的)

Ring-AllReduce的方法，因为在之后的ZeRO，Megatron-LM中，它将频繁地出现，是分布式训练系统中重要的算子

ZeRO(DP)

图解大模型训练之：数据并行上篇(DP, DDP与ZeRO)
图解大模型训练之：数据并行下篇(DeepSpeed ZeRO，零冗余优化)

ZeRO是模型并行的形式，数据并行的实质

模型并行，是指在forward和backward的过程中，我只需要用自己维护的那块W来计算就行。即同样的输入X，每块GPU上各算模型的一部分，最后通过某些方式聚合结果。但对ZeRO来说，它做forward和backward的时候，是需要把各GPU上维护的W聚合起来的，即本质上还是用完整的W进行计算。它是不同的输入X，完整的参数W，最终再做聚合。

对activation的存储是灵活的。不像optimizer states，gradients和parameters对模型更新是必须的，activation只是起到加速梯度计算的作用。因此，在哪几层保存activation，保存哪些activation都是可以灵活设置的。

ZeRO-Offload

forward和backward计算量高，因此和它们相关的部分，例如参数W（fp16），activation，就全放入GPU。
update的部分计算量低，因此和它相关的部分，全部放入CPU中。例如W(fp32)，optimizer states（fp32）和gradients(fp16)等。

TP

图解大模型训练之：张量模型并行(TP)，Megatron-LM

在之前的内容中，已经介绍过流水线并行(PP)、数据并行(DP，DDP和ZeRO)。下面将要介绍最重要，也是目前基于Transformer做大模型预训练最基本的并行范式：来自NVIDIA的张量模型并行(TP)。它的基本思想就是把模型的参数纵向切开，放到不同的GPU上进行独立计算，然后再做聚合。

关于随机种子设定的一般结论

一般在TP/PP组内，设定不同的随机种子。而在DP组内，设定相同的随机种子。这只是一个一般结论，我们可以根据实际情况去调整

python杂谈

语言本身没有任何限制。在Python中，可以通过给对象属性名添加前缀下划线的方式来说明属性的访问可见性，例如，可以用__name表示一个私有属性，_name表示一个受保护属性。

下划线(_)开头表示Python中的私有变量, 但私有变量在Python中不存在, 只需遵循一些规范即可

除了对象方法之外，类中还可以有静态方法和类方法，这两类方法是发给类的消息，二者并没有实质性的区别

可以直接使用类名.方法名的方式来调用静态方法和类方法，二者的区别在于，类方法的第一个参数是类对象本身，而静态方法则没有这个参数

简单的总结一下，对象方法、类方法、静态方法都可以通过类名.方法名的方式来调用，区别在于方法的第一个参数到底是普通对象还是类对象，还是没有接受消息的对象。静态方法通常也可以直接写成一个独立的函数，因为它并没有跟特定的对象绑定

super().init()来调用父类初始化方法，super函数是Python内置函数中专门为获取当前对象的父类对象而设计的

子类继承父类的方法后，还可以对方法进行重写（重新实现该方法），不同的子类可以对父类的同一个方法给出不同的实现版本，这样的方法在程序运行时就会表现出多态行为（调用相同的方法，做了不同的事情）

在没有特殊处理的情况下，函数的参数都是位置参数，也就意味着传入参数的时候对号入座即可
调用函数时，如果希望函数的调用者必须以参数名=参数值的方式传参，可以用命名关键字参数（keyword-only argument）取代位置参数。所谓命名关键字参数，是在函数的参数列表中，写在*之后的参数

在函数的参数列表中可以使用可变参数*args来接收任意数量的参数
关键字参数会将传入的带参数名的参数组装成一个字典，参数名就是字典中键值对的键，而参数值就是字典中键值对的值

不带参数名的参数（位置参数）必须出现在带参数名的参数（关键字参数）之前

理论推导

语言模型（Language Model）中最经典的交叉熵损失函数（Cross-Entropy Loss）

在概率论和深度学习中，给概率 $P$ 取对数（$\log$）绝不是为了让公式看起来更高级，而是出于数学稳定性、计算效率以及优化便利性的深度考量

语言模型的目标是最大化整个序列出现的概率。假设一个序列有 $T$ 个词，其联合概率是每一个词出现的条件概率的连乘：

$$P(x_1, x_2, \dots, x_T) = \prod_{t=1}^{T} P(x_t | x_{证明:

e.g.

$P(x_1, x_2, x_3) = P(x_1, x_2) \cdot P(x_3 | x_1, x_2)$

$P(x_1, x_2) = P(x_1) \cdot P(x_2 | x_1)$

=>$P(x_1, x_2, x_3) = P(x_1) \cdot P(x_2 | x_1) \cdot P(x_3 | x_1, x_2)$
递归进行约分

$P(x_1, \dots, x_T) = P(x_1, \dots, x_{T-1}) \cdot P(x_T | x_1, \dots, x_{T-1})$

$P(x_1, \dots, x_{T-1}) = P(x_1, \dots, x_{T-2}) \cdot P(x_{T-1} | x_1, \dots, x_{T-2})$

……

直到拆到 $P(x_1)$

两边约分 => $P(x_1, \dots, x_T) = P(x_1) \cdot P(x_2|x_1) \cdot P(x_3|x_{1,2}) \dots P(x_T|x_{<T}) = \prod_{t=1}^{T} P(x_t | x_{<t})$

注：当 $t=1$ 时，$x_{<1}$ 为空集，即起始词概率 $P(x_1)$。

SFT

next token loss或者叫lm loss，这是现代语言模型最原始、最直接的训练方式：

$\mathcal{L}{lm} = -\frac{1}{T} \sum{t=1}^{T} log P(x_t | x_{<t})$

DPO

优化目标是最大化给定 $x$,$y_l$,$y_w$下，好answer优于坏answer的概率

$\mathcal{L}{DPO} = -\mathbb{E} \left[ \log \sigma \left( \beta \log \frac{\pi\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)} \right) \right]$

其中 $\pi_\theta$,$\pi_{ref}$分别表示正在训练的模型和冻住不训的参考模型， $x$,$y_l$,$y_w$分别表示prompt，较差的answer和较好的answer。

目前工业界稳定跑通的DPO，很多用的都是下面这个公式：
$\mathcal{L}{DPO} = -\mathbb{E} \left[ \log \sigma \left( \beta \log \frac{\pi\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)} \right) + \alpha \log \pi_\theta(y_w|x) \right]$

另外额外提一嘴，DPO训练的时候 $\pi(y|x)$ 是 $\sum_{t=1}^{T} P(y_t|x_{<t})$ ，而不是 $\frac{1}{T} \sum_{t=1}^{T} P(y_t|x_{<t})$ ，这个原理我没有细究，因为我用的也不多。

RST(Rejection Sampling Fine-tuning)

我们希望充分利用偏好对训练出来的 $\pi^$ 模型，但是 $\pi^$ 又是个判别模型。既然判别模型做不了生成，那就找个生成的模型来采样，判别模型负责拒绝就可以了，于是也就有了拒绝采样的训练

offline RST的一般流程如下：

用经过SFT 的模型或few shot的 pretrain 模型回答 SFT 所有训练数据的问题，得到模型answer
用奖励模型对SFT数据中原始的answer和模型生成answer进行打分
得分 top1 的answer 去替换SFT数据中的原始answer，产生新的一版训练数据
新的数据去训练1中用来生成answer的模型
重复1-4：模型回答SFT数据->打分->top1替换得到新版数据->训练模型->模型回答SFT数据->打分->….

Attention

定义

$$\mathbf{q}_i, \mathbf{k}_i, \mathbf{v}_i, \mathbf{o}_i \in \mathbb{R}^{d \times 1} $$$$\mathbf{Q} = [\mathbf{q}_1, \mathbf{q}_2, \dots, \mathbf{q}_n]^\top \in \mathbb{R}^{n \times d} $$$$\mathbf{K} = [\mathbf{k}_1, \mathbf{k}_2, \dots, \mathbf{k}_n]^\top \in \mathbb{R}^{n \times d} $$$$\mathbf{V} = [\mathbf{v}_1, \mathbf{v}_2, \dots, \mathbf{v}_n]^\top \in \mathbb{R}^{n \times d} $$$$\mathbf{O} = [\mathbf{o}_1, \mathbf{o}_2, \dots, \mathbf{o}_n]^\top \in \mathbb{R}^{n \times d}$$

Softmax Attention

Softmax Attention通常指 Attention is all you need 中的Attention机制

$$\mathbf{O} = \text{softmax}(\mathbf{Q}\mathbf{K}^\top + \log \mathbf{M})\mathbf{V}$$$$o_t = \sum_{j=1}^{t} \left( \underbrace{\frac{\exp(\boldsymbol{q}_t^\top \boldsymbol{k}_j)}{\sum_{j=1}^{t} \exp(\boldsymbol{q}_t^\top \boldsymbol{k}_j)}}_{\text{权重 } \alpha_{tj}} \right) \cdot \boldsymbol{v}_j= \frac{\sum_{j=1}^{t} \exp(\mathbf{q}_t^\top \mathbf{k}_j) \mathbf{v}_j}{\sum_{j=1}^{t} \exp(\mathbf{q}_t^\top \mathbf{k}_j)}$$

里面的分母可以提出来，每一项那部分都是常数

如果对最终输出O进行RMSNorm(Root Mean Square Layer Normalization)，分母会被消去，所以认为重点是分子部分

$$\mathbf{O} = \exp(\mathbf{Q}\mathbf{K}^\top + \log \mathbf{M})\mathbf{V} = (\exp(\mathbf{Q}\mathbf{K}^\top) \odot \mathbf{M})\mathbf{V} $$

其中⊙是hadmard积(逐元素积,相同形状的矩阵对应位置元素相乘)

Linear Attention

一开始的Linear Attention是模拟softmax attention,一种最简单的做法是去掉exp

$$\mathbf{O} = (\mathbf{Q}\mathbf{K}^\top \odot \mathbf{M})\mathbf{V}$$

对于非Causal的注意力计算(没有$\mathbf{M}$)，可以通过矩阵交换律改变计算顺序得到线性的计算

$$\mathbf{O} = \mathbf{Q}(\mathbf{K}^\top \mathbf{V})$$

原本$QK^\top$的时间复杂度是$O(n^{2}d)$，现在$K^\top V$的时间复杂度是$O(nd^{2})$，与Q相乘仍然是$O(nd^{2})$

$$ \mathbf{o}_t = \sum_{j=1}^{t} \mathbf{v}_j (\mathbf{k}_j^\top \mathbf{q}_t) = \sum_{j=1}^{t} (\mathbf{v}_j \mathbf{k}_j^\top) \mathbf{q}_t = \left( \sum_{j=1}^{t} \mathbf{v}_j \mathbf{k}_j^\top \right) \mathbf{q}_t $$

下图手证 $\mathbf{o}t = \sum{j=1}^{t} \mathbf{v}_j (\mathbf{k}_j^\top \mathbf{q}_t)$ ,记住矩阵有结合律和分配律, 没有交换律和消去律

将括号部分标记为 $S_t$ ,有

$$ \mathbf{o}_t = \mathbf{S}_t \mathbf{q}_t, \quad \mathbf{S}_t = \mathbf{S}_{t-1} + \mathbf{v}_t \mathbf{k}_t^\top $$

DeltaNet

最早的线性Attention对应的损失函数是 $-v^T(Sk)$

一个更理想更直接的损失可能是MSE/L2 Loss，即 $\frac{1}{2} |Sk - v|^2$ DeltaNet便使用了这样的损失

$$o_t = f(S_t; q_t), \quad S_t = S_{t-1} - \underbrace{\eta_t (S_{t-1} k_t - v_t) k_t^\top}_{\nabla_{S_{t-1}} \frac{1}{2} \| S_{t-1} k_t - v_t \|^2}$$

$ \eta_t $是一个常数，不妨设其为1方便分析将式子拆开可以得到

$$ \begin{aligned} S_t &= S_{t-1} - (S_{t-1}\boldsymbol{k}_t - \boldsymbol{v}_t)\boldsymbol{k}_t^\top \\ &= S_{t-1} - (S_{t-1}\boldsymbol{k}_t)\boldsymbol{k}_t^\top + \boldsymbol{v}_t\boldsymbol{k}_t^\top \\ &= S_{t-1}(\boldsymbol{I} - \boldsymbol{k}_t\boldsymbol{k}_t^\top) + \boldsymbol{v}_t\boldsymbol{k}_t^\top \end{aligned} $$

相比于一开始的状态更新，DeltaNet的状态更新之前先减去了一个 $(S_{t-1}\boldsymbol{k}_t)\boldsymbol{k}t^\top, \quad S{t-1}\boldsymbol{k}_t$ 是模型对v的预测，所以这里就有点像是去除模型的旧知识，加入正确的新知识。这个规则称为Delta Rule，也是Delta的来源

联想记忆（Associative Memory）或线性注意力机制中，如何从存储矩阵 $S$ 中通过键 $k_j$ 检索出对应值 $v_j$ 的数学原理，以及为什么会产生误差?

$$S = \sum_{i=1}^{n} v_i k_i^\top$$

$$Sk_j = \left( \sum_{i=1}^{n} v_i k_i^\top \right) k_j = \sum_{i=1}^{n} v_i (k_i^\top k_j)$$

为了看清检索结果准不准，我们将求和拆分为“目标项”（$i=j$）和“干扰项”（$i \neq j$）：当 $i = j$ 时：项为 $v_j (k_j^\top k_j)$。如果键向量是单位向量（即 $k_j^\top k_j = 1$），这一项就直接等于 $v_j$。当 $i \neq j$ 时：项为 $\sum_{i \neq j} (k_i^\top k_j) v_i$。这些是其他存储项对当前检索的干扰

$$Sk_j = v_j + \underbrace{\sum_{i \neq j} (k_i^\top k_j) v_i}_{\text{retrieval error}}$$

Gated DeltaNet

Gated DeltaNet将遗忘门加入到了DeltaNet中，它的引入方式为

$$ \boldsymbol{S}_t = \alpha_t \boldsymbol{S}_{t-1} (\boldsymbol{I} - \beta_t \boldsymbol{k}_t \boldsymbol{k}_t^\top) + \beta_t \boldsymbol{v}_t \boldsymbol{k}_t^\top $$

训练经验

个人实战经验

PEFT（Parameter-Efficient Fine-Tuning，参数高效微调）,就是我们常说的Lora

model = get_peft_model(model, config)

他人经验

LLM实践–支线：拯救Continue Pretrain的数据这里面评论区提到的

SFT确实是可以注入知识的，只不过必须全参，lora完全不行，lora训十轮也学不进去，全参训一轮就学得差不多了，之前看各种文章无脑推荐高效微调法，其实是一个很大的误区。知识在整句话中其实只占很小的一部分，属于次要奇异值，lora会把这些东西忽略掉，导致学习一些hacking，比如格式、行文。所以我也说sft注入没有不可以，多样性一定保证，也要避免hacking。平时工作我也从来不用lora，因为次要奇异值往往更重要

LLM实践–拒绝采样评论区

所有的后训练改进过程都是在解决LM LOSS不等于预期LOSS的问题，试图去稳定性量化预期LOSS，目前的所有技术都只是通过尝试来试图接近，这是token-based paradigm的必然问题。解决这个问题的终极方案是从next-token LM model转为semantic model，用semantic loss来替代Lm loss。

面向进程编程

整份脚本处理的是发生在1个进程上的事情。这样做的好处是，我们只需要维护1份脚本，然后将其发去不同机器的各张卡上执行，就能实现全局的并行。

Megatron

Megatron还是要看的
图解大模型训练之：流水线并行（Pipeline Parallelism），以Gpipe为例
 图解大模型训练之：数据并行上篇(DP, DDP与ZeRO)
图解大模型训练之：数据并行下篇(DeepSpeed ZeRO，零冗余优化)
图解大模型训练之：张量模型并行(TP)，Megatron-LM
图解大模型系列之：Megatron源码解读1，分布式环境初始化
 图解大模型训练之：Megatron源码解读2，模型并行
 图解大模型训练系列之：Megatron源码解读3，分布式混合精度训练

pretrain部分code大致流程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


def pretrain(
 train_valid_test_dataset_provider,
 model_provider,
 forward_step_func,
 valid_forward_step_func=None,
 extra_args_provider=None,
 args_defaults={},
):
 # 1.初始化分布式环境(源码解读1内容)
 initialize_megatron(
 extra_args_provider=extra_args_provider, args_defaults=args_defaults
 )
 ...
 # 2、模型并行：定义模型架构，并切割模型（本文重点）
 model, optimizer, lr_scheduler = setup_model_and_optimizer(model_provider)
 ...

 # 3、构造train/val/test数据集（下一篇将讲述）
 ... (
 train_data_iterator,
 valid_data_iterator,
 test_data_iterator,
 ) = build_train_valid_test_data_iterators(train_valid_test_dataset_provider)

 ...
 # 4、训练（下下一篇将讲述）
 iteration = train(
 forward_step_func,
 valid_forward_step_func,
 model,
 optimizer,
 lr_scheduler,
 train_data_iterator,
 valid_data_iterator,
 )

 ...

CrossEntropy

在语言模型训练中，我们需要计算预测分布与真实标签之间的交叉熵损失。对于单个样本，交叉熵损失定义为：

$$ L = -\log P(y|x) = -\log\left(\frac{e^{s_y}}{\sum_{j=1}^{V} e^{s_j}}\right) = \log\left(\sum_{j=1}^{V} e^{s_j}\right) - s_y $$

其中：

$s = [s_1, s_2, \ldots, s_V]$ 是模型输出的 logits（未归一化的对数概率）
$V$ 是词汇表大小
$y$ 是真实标签
$s_y$ 是真实类别对应的 logit

数值稳定性处理

为了数值稳定性，我们在计算 softmax 前先减去最大值：

$$ \text{logits}' = s - \max(s) $$

这样做的理由：

防止 $\exp(s)$ 溢出
不改变 softmax 结果（分子分母同时乘以 $e^{-\max(s)}$）

词汇表并行（Vocab Parallel）

在张量并行中，词汇表被切分到多个 GPU 上：

假设有 $N$ 个 GPU，词汇表大小为 $V$
每个 GPU 维护 $V/N$ 个词的 logits
需要通过通信（AllReduce）来计算全局的 softmax 和 loss

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202


class _VocabParallelCrossEntropy(torch.autograd.Function):
 @staticmethod
 def forward(ctx, vocab_parallel_logits, target):
 """
 前向传播：计算词汇表并行下的交叉熵损失

 输入：
 - vocab_parallel_logits: [batch_size, seq_len, partition_vocab_size]
 当前 GPU 上维护的部分词汇表 logits
 - target: [batch_size, seq_len]
 真实标签（词汇表索引）

 输出：
 - loss: [batch_size, seq_len]
 每个位置的交叉熵损失
 """

 # ============ 第一步：数值稳定性处理 ============
 # 在词汇表维度上找到最大值（只在当前 GPU 的分区上找）
 # logits_max: [batch_size, seq_len]
 # 数学表达：m_i = max(s_i) 其中 s_i 是第 i 个样本的 logits
 logits_max = torch.max(vocab_parallel_logits, dim=-1)[0]

 # 通过 AllReduce 获取全局最大值（跨所有 GPU）
 # 这样确保所有 GPU 使用相同的最大值进行归一化
 # 数学表达：m_global = max(m_1, m_2, ..., m_N) 其中 N 是 GPU 数量
 torch.distributed.all_reduce(
 logits_max,
 op=torch.distributed.ReduceOp.MAX,
 group=get_tensor_model_parallel_group(),
 )

 # 减去最大值，实现数值稳定
 # logits' = logits - max(logits)
 # 这样可以防止 exp(logits) 溢出，同时不改变 softmax 结果
 # 数学表达：s'_ij = s_ij - m_global
 vocab_parallel_logits.sub_(logits_max.unsqueeze(dim=-1))

 # ============ 第二步：确定当前 GPU 的词汇表范围 ============
 # 获取当前 GPU 负责的词汇表索引范围
 # 例如：V=10000, N=4, rank=0 -> [0, 2500), rank=1 -> [2500, 5000), ...
 get_vocab_range = VocabUtility.vocab_range_from_per_partition_vocab_size
 partition_vocab_size = vocab_parallel_logits.size()[-1] # 当前 GPU 的词汇表分区大小
 rank = get_tensor_model_parallel_rank() # 当前 GPU 的 rank
 world_size = get_tensor_model_parallel_world_size() # 总 GPU 数量
 vocab_start_index, vocab_end_index = get_vocab_range(
 partition_vocab_size, rank, world_size
 )

 # ============ 第三步：创建目标掩码 ============
 # 判断哪些目标在当前 GPU 的词汇表范围内
 # target_mask=True 表示目标不在当前 GPU 的词汇表范围内
 # 数学表达：mask_i = 1 if (target_i < start) or (target_i >= end), else 0
 target_mask = (target < vocab_start_index) | (target >= vocab_end_index)

 # 将全局目标索引转换为当前 GPU 的局部索引
 # 数学表达：target'_i = target_i - vocab_start_index
 masked_target = target.clone() - vocab_start_index

 # 将不在当前范围内的目标设为 0（之后会被 mask 掉）
 masked_target[target_mask] = 0

 # ============ 第四步：提取目标位置的 logit ============
 # 将 logits 展平为 2D：[batch_size * seq_len, partition_vocab_size]
 # 将 target 展平为 1D：[batch_size * seq_len]
 # 这样方便使用高级索引
 logits_2d = vocab_parallel_logits.view(-1, partition_vocab_size)
 masked_target_1d = masked_target.view(-1)

 # 创建行索引 [0, 1, 2, ..., batch_size * seq_len - 1]
 arange_1d = torch.arange(
 start=0, end=logits_2d.size()[0], device=logits_2d.device
 )

 # 提取每个样本对应目标位置的 logit
 # 数学表达：s'_target = logits[arange_1d, masked_target_1d]
 # 即取出每个样本在其目标词汇位置的 logit 值
 predicted_logits_1d = logits_2d[arange_1d, masked_target_1d]
 predicted_logits_1d = predicted_logits_1d.clone().contiguous()

 # 恢复原始形状：[batch_size, seq_len]
 predicted_logits = predicted_logits_1d.view_as(target)

 # 将不在当前 GPU 范围内的目标的 logit 设为 0
 # 这样做是因为之后会通过 AllReduce 求和，只需要贡献自己的部分
 predicted_logits[target_mask] = 0.0

 # 通过 AllReduce 从所有 GPU 收集目标的 logit
 # 每个 GPU 只贡献自己分区内的目标 logit
 # 最终得到所有目标位置的完整 logit 值
 # 数学表达：s_y = Σ(s'_y_i) 对所有 GPU 求和
 torch.distributed.all_reduce(
 predicted_logits,
 op=torch.distributed.ReduceOp.SUM,
 group=get_tensor_model_parallel_group(),
 )

 # ============ 第五步：计算归一化项（log-sum-exp）============
 # 计算 exp(logits')
 # 数学表达：e'_ij = exp(s'_ij)
 exp_logits = vocab_parallel_logits
 torch.exp(vocab_parallel_logits, out=exp_logits)

 # 在当前 GPU 的词汇表维度上求和
 # 数学表达：E'_i = Σ(e'_ij) 对当前 GPU 的词汇表维度求和
 sum_exp_logits = exp_logits.sum(dim=-1)

 # 通过 AllReduce 从所有 GPU 收集完整的指数和
 # 数学表达：E_i = Σ(E'_i) 对所有 GPU 求和
 # 这就是 softmax 的分母：Σ(exp(s_j))
 torch.distributed.all_reduce(
 sum_exp_logits,
 op=torch.distributed.ReduceOp.SUM,
 group=get_tensor_model_parallel_group(),
 )

 # ============ 第六步：计算最终损失 ============
 # 交叉熵损失：L = log(sum(exp(logits))) - predicted_logit
 # 数学表达：L = log(E_i) - s_y
 # 这对应：L = log(Σ(exp(s_j))) - s_y
 # 即：L = -log(exp(s_y) / Σ(exp(s_j))) = -softmax_y
 loss = torch.log(sum_exp_logits) - predicted_logits

 # ============ 第七步：保存反向传播所需的中间变量 ============
 # 计算 softmax 并保存，用于反向传播
 # 数学表达：softmax_ij = exp(s'_ij) / E_i
 exp_logits.div_(sum_exp_logits.unsqueeze(dim=-1))

 # 保存 softmax、target_mask 和 masked_target_1d 用于反向传播
 ctx.save_for_backward(exp_logits, target_mask, masked_target_1d)

 return loss

 @staticmethod
 def backward(ctx, grad_output):
 """
 反向传播：计算交叉熵损失对 logits 的梯度

 数学推导：
 前向传播：L = log(Σ(exp(s_j))) - s_y

 对 logits 的梯度：
 ∂L/∂s_i = softmax_i - 1_{i=y}

 其中：
 - softmax_i = exp(s_i) / Σ(exp(s_j))
 - 1_{i=y} 是指示函数，当 i=y 时为 1，否则为 0

 在词汇表并行的场景下：
 - 当前 GPU 只计算自己分区内的梯度
 - 对于目标位置：grad = softmax - 1
 - 对于非目标位置：grad = softmax
 """

 # ============ 第一步：恢复前向传播保存的中间变量 ============
 # softmax: [batch_size, seq_len, partition_vocab_size]
 # target_mask: [batch_size, seq_len] (布尔掩码)
 # masked_target_1d: [batch_size * seq_len] (局部索引)
 softmax, target_mask, masked_target_1d = ctx.saved_tensors

 # ============ 第二步：初始化梯度 ============
 # 交叉熵损失的梯度基础是 softmax 值
 # 对于所有位置，梯度从 softmax 开始
 # 数学表达：∂L/∂s_i = softmax_i （基础项）
 grad_input = softmax

 # 为了方便索引，转换为 2D 格式
 # grad_2d: [batch_size * seq_len, partition_vocab_size]
 partition_vocab_size = softmax.size()[-1]
 grad_2d = grad_input.view(-1, partition_vocab_size)

 # ============ 第三步：处理目标位置的梯度 ============
 # 对于目标位置，需要减去 1（指示函数）
 # 数学表达：∂L/∂s_y = softmax_y - 1
 # 其中 1 是真实标签的指示函数 1_{i=y}

 # 创建行索引
 arange_1d = torch.arange(start=0, end=grad_2d.size()[0], device=grad_2d.device)

 # 对目标位置的梯度进行调整：
 # 1. 如果目标在当前 GPU 的词汇表范围内（target_mask=False）：
 # grad = softmax - 1 （减 1）
 # 2. 如果目标不在当前范围内（target_mask=True）：
 # grad = softmax - 0 （不减 1，因为目标在其他 GPU 上）
 # 数学表达：
 # ∂L/∂s_y = softmax_y - (1 - mask_y)
 # 其中 mask_y = 1 表示目标不在当前 GPU，mask_y = 0 表示目标在当前 GPU
 grad_2d[arange_1d, masked_target_1d] -= 1.0 - target_mask.view(-1).float()

 # ============ 第四步：乘以上层梯度 ============
 # 根据链式法则，需要乘以损失对输出的梯度
 # 数学表达：∂L_total/∂s = (∂L/∂s) × (∂L_total/∂L)
 # 其中 grad_output 是 ∂L_total/∂L
 grad_input.mul_(grad_output.unsqueeze(dim=-1))

 # 返回梯度（第二个输入 target 不需要梯度，返回 None）
 return grad_input, None


def vocab_parallel_cross_entropy(vocab_parallel_logits, target):
 """Helper function for the cross entropy."""
 return _VocabParallelCrossEntropy.apply(vocab_parallel_logits, target)

精度问题

从占用存储角度看，fp16占据2 bytes，bf16占据2 bytes，fp32占据4 bytes
从数值表达范围来看：fp32 = bf16 > fp16
从数值表达精度来看：fp32 > fp16 > bf16

最好理解每一部分精度转换的原因和整个流程，算是基本功

老样子，放一些写的好的文章可以学一学

图解大模型训练系列之：Megatron源码解读3，分布式混合精度训练
megatron/training.py的pretrain 函数。其中，函数setup_model_and_optimizer调用了optimizer/init.py/下的get_megatron_optimizer，因此它就是混合精度训练的入口函数

分析transformer模型的参数量、计算量、中间激活、KV cache

两种做Loss Scale的方法：常量损失放大和动量损失放大

DeepSpeed

DeepSpeed官方文档👈官方文档
DeepSpeed配置JSON👈使用只需要JSON配置文件
【利用多張GPU訓練大型語言模型】 - YouTube👈李宏毅老师YouTube视频讲解（约一个小时）
The Ultra-Scale Playbook:Training LLMs on GPU Clusters👈并行训练高质参考资料

hugging face经常有高质量实验总结，可以多关注一下

一开始会有batch-size个prompt去做rollout，每个prompt rollout出n个response，之后每mini-batch-size个prompt及其rollout出来的response会去做一次梯度下降，batch-size / mini-batch-size次梯度下降之后一个step结束

Batch Size Related Parameters train_batch_size = train_micro_batch_size_per_gpu * gradient_accumulation_steps * number of GPUs
train_batch_size: [integer] 代表着one step.Example:32
train_micro_batch_size_per_gpu: [integer] 一次更新的batch_size，所以叫micro_batch_size.
gradient_accumulation_steps: [integer] 积累几次

监控平台

可以使用TensorBoard,wandb,Comet等，因为个人使用所以只介绍swanlab(wandb的国内镜像)
注册登录，设置 project_name 和 experiment_name 就可以在电脑上/手机上看了
很好用的监控平台！
swanlab官方文档👈官方文档

veRL框架使用方法/快速上手

知乎上收藏了一些轮椅教程
OpenRLHF&Verl参数转换指南

更深入的：
HybridFlow / veRL 原文浅析很干，对system理解有很大帮助

[AI Infra] VeRL 框架入门&代码带读

从零开始的verl框架解析

NLP

Mon, 19 Jan 2026 10:00:00 +0800

【生成式人工智慧與機器學習導論2025】第3講：解剖大型語言模型representation

https://www.youtube.com/watch?v=Xnil63UDW2o

Token Embedding 是在Layer 1输入的那个， Contextualized Embedding(也就是我们说的representation表征) 指的是经过Layer 1输出的那个.

Representation Engineering, Activation Engineering, Activating Steering…

Logit Lens

对每一层进行 Unembedding ,可以看每一层的思考所对应的文字，窥探语言模型的思考过程

Patchscopes

把一个向量（一个token/字）替换成一句话

Layer解读（使用Transformer架构的解读）

Layer 中还有 Layer.

首先过 Self-attention Layer (attention layer), 考虑上下文就是因为 attention layer, 输出经过几个 Feed Forward Layer

典中典，要求手撕 Attention Layer ,

自己跟自己也要进行dot product

dot product 叫 Attention weight, 要所有的 weight 过 Softmax

Positional Embedding

Llama 用 Rope , 旋转位置编码, 为了把位置的咨询加入到计算中

Multi-head Attention

每一个 head 的作用不一样

目前的语言模型大多数都是 Causal Attention, 这样计算方便(Autogressive)

实做环节

1

model.num_parameters()会告诉我们 model 的参数量

深度学习模型的参数通常以多个矩阵 (Matrix) 和向量 (Vector) 的形式存储。向量、矩阵等统称为张量(Tensor)

Llama3 有28层，Gemma4B 有44层

1

model.state_dict() 可以实际把参数拿出来看看

一文看懂大模型推理过程

内容特别简单，适合感兴趣的小白简单阅读
https://zhuanlan.zhihu.com/p/1931115470431454357

TTFT（Time To First Token）

Tokenizer + Prefill

一般是推理过程里耗时最多的一步，尤其当输入内容多、模型参数大时

TPOT（Time Per Output Token）

Decoding Loop中的每一次推理

模型每“说”一个字/词的时间
TPOT 越低，响应越流畅。
但模型越大，TPOT 越高；
GPU 负载越高、token越复杂，TPOT 也会变慢。

ITL（Inference Time Latency）

Tokenizer + Prefill + Decoding Loop + Post-processing

ITL = 从你提问到回答完整输出的总耗时。

它 = TTFT + n × TPOT

Engram

https://zhuanlan.zhihu.com/p/1994328242795090231

微调技术

https://zhuanlan.zhihu.com/p/636481171

The Big LLM Architecture Comparison

https://magazine.sebastianraschka.com/p/the-big-llm-architecture-comparison

Understanding Reasoning LLMs

https://magazine.sebastianraschka.com/p/understanding-reasoning-llms

SJTU-research-intern

Thu, 23 Oct 2025 10:00:00 +0800

2025/10/23

实习第一天

2025/10/27

周六凌晨开始跑的论文复现，当时为了图速度就没有顾虑太多。今天学姐问我一些实验过程中的指标变化等等来对比idea的实验是否正常工作，只能回去手动复制tmux里面的内容。

每跑一次实验都要记得能留日志就留日志，能上wandb/Swanlab就上，跑完的实验数据等等都要保存，留着。后续可能会用到。

千万不要一味地追求速度，图省事！

解决了submodule问题，具体的流程为删掉子仓库中的.git，移除本地缓存（觉得他是子module），从.gitmodule中移除（当然我本地没有）。

解决了关于代码冲突的问题（需要手动进行修改），在git pull中是常见问题，总结关于这种多人协作常出现的问题，注意事项及解决方案

Flash-Attention安装常见问题及其解决方案

Thu, 09 Oct 2025 10:00:00 +0800

终端/服务器挂代理百分百解决,无论是直接安装pip源还是.wheel

尝试过的解决方案👈

Ray分布式训练因进程耗尽导致SSH断开连接

Thu, 09 Oct 2025 10:00:00 +0800

问题详情 + 解决方案👈

STILL3

Thu, 02 Oct 2025 00:00:00 +0000

重新认真地读一遍STILL3(LLMs慢思维技术报告III )，补充知识点

An Empirical Study on Eliciting and Improving R1-like Reasoning Models

慢思考模型仓库

缺乏可验证问题的领域:如DeepSeek-R1,基于规则和训练的奖励模型的联合使用

随着训练的进行，可以观察到三个主要特征：增加训练奖励、增加响应长度和涌现推理模式。些因素是扩大强化学习训练成功的关键指标。

在本报告中，首先深入研究了强化学习设置对训练效果的影响。接下来，通过强化学习训练直接激励基础模型发展复杂的推理能力，观察到模型逐渐花费更多的时间“思考”并表现出高级推理行为（例如，验证或反思）。最后，为了进一步增强微调模型的推理能力，探索了强化学习和工具增强作为提高模型推理性能的策略，在小型（1.5B）和中型LLM（32B）中都取得了显著的改进。

on-policy learning strategy被证明是关键因素！
response length是RL训练成功的重要指标，这是结果，不是原因
设计专门的奖励函数来鼓励模型产生更长的响应可能会导致奖励黑客攻击等问题，这不能从本质上增强模型的推理能力
无论是短CoT还是长CoT，还是蒸馏过的模型，强化学习都可以提高能力
通过fine-tuning，LRM可以获得操纵外部工具的能力，从而提高模型的性能。这种能力只需少量高质量的训练实例即可激活。

复现点这里找资源

实验设置

训练框架

OpenRLHF和veRL

骨干模型

各种版本的QWEN2.5模型

DEEPSEK-R1-DISTILL系列的1.5B和32B QWEN2.5

在微调模型上进行实验，微调数据由自己合成。

训练数据

多样性

AIME,MATH,NuminaMath,Open Reasoner Zero

可验证性

删除了多选题，证明题，概念题，开放式问题和有多个子问题的问题
再把答案不可能的数据删掉

困难程度

基于模型的过滤，QWEN-7B-INSTRUCT正确率过高或者零通过率的题目删掉

最后剩下90k个examples

Reward Design

设计并验证了一组不同的奖励，并分析了它们对模型性能的影响，包括输出奖励、格式奖励、长度奖励和动作奖励。

输出奖励评估最终答案是否与ground truth匹配。如果答案正确，我们将奖励设置为1，否则设置为0。

如果模型未能将其最终答案放入\boxed{}中，则奖励设置为0。
使用格式奖励来指导基础模型正确构建其响应。

探索了新的辅助奖励，包括鼓励更长反应的长度奖励和激励复杂推理行为的行动奖励。

Evaluation Benchmarks

评估了各种数学推理任务的模型性能，包括MATH-OAI[13]、AIME、Omni-MATH[17]、LiveAOP[18]和HMMT。
iveAOP利用AoPS论坛的帖子创建了一个由3863个示例组成的抗污染评估集。

Compute Environment

实验主要在DataCanvas的旗舰计算编排平台Alaya NeW AI操作系统上进行。

RL Experiments on the Base Model

直接将RL应用于预训练的基础模型进行实验，而不需要任何中间的SFT阶段。这种方法旨在探索LLM是否可以通过纯粹的RL驱动的自我提升来自主发展推理能力

考察了四个关键维度

1.训练超参数的影响

2.比较不同的基础模型并将其与具有短CoT推理能力的微调模型进行对标，来分析骨干模型的效果

3.快速设计对RL训练中基础模型推理能力的影响

4.代表性推理模式（如验证或反射）的出现

Exploring the Settings of RL Training

重点分析两个关键方面的影响：超参数和训练提示。

Influence of Training Hyper-parameters

Train Batch Size(TBS)

TBS=128 v.s.1024
更大的TBS可以显著提高训练效率，使模型在早期训练阶段能够快速提高性能。此外，与较小批量相比，较大批量的训练表现出更大的稳定性，训练指标的波动显著减少

Learning Strategy: On-policy vs. Off-policy

on-policy 鼓励更多的探索；在训练过程中，模型自然快速地增加了响应长度，而更新较少的非策略学习在长度增长方面遇到了瓶颈

Rollout Parameters

主要研究两个rollout parameters（rollout times和rollout temperature）
更大的推出数量和更高的温度通常表示更大程度的探索

Coefficient of KL Penalty

动态KL退火具有很好的综合性

Effect of Backbone Models

上述实验基于QWEN2.5-7B。此外，还对较小的QWEN2.5-1.5B模型、监督微调QWEN2.5-7B-INSTRUCT模型和数学专用QWEN2.5-math-7B模型进行了实验。

在上述设置下，我们的实验表明，与QWEN2.5-1.5B相比，QWEN2.5-7B表现出更强的探索能力，并且在强化学习训练中遵循与QWEN2.5.7B-INSTRUCT类似的趋势。

Impact of the Prompt

使用两种基本模型（即QWEN2.5-1.5B和QWEN2.5-7B）和两种类型的提示进行实验
第一种是短提示，类似于DeepSeek-R1-Zero中使用的提示。此外，为了更好地引出基础模型的推理能力，我们设计了一个新的提示，其中包括关于推理过程的详细说明，称为长提示

这个新提示保留了对特定推理格式的要求，同时添加了对推理过程的全面描述。这包括在推理过程中可以应用的策略（例如，分析问题、总结发现）以及在整个过程中使用的推荐表达和词汇（例如，“等待”、“替代”）

在本实验中将learning rate、train batch size、rollout temperature和number of rollout times设置为1×10−6、128、1.0和8，并执行on-policy训练策略。我们将KL penalty和entropy loss的系数设置为0.0，有效地消除了模型上的约束。这使得可以更清楚地观察到各种提示导致的性能差异

实验结果

对于QWEN2.5-1.5B，在短提示下训练的模型在测试集上的性能高于在长提示上训练的模型。这可能是因为1.5B大小的基本模型容量相对有限，难以遵循详细提示中的复杂说明。

当在不同的提示下训练时，7B大小的模型在下游任务上显示出类似的性能。然而，在长提示上训练的模型会产生更短的响应，这表明它通过遵守提示中提供的指导方针来学习更有效的推理

因此，我们得出结论，更详细的提示可以引导模型更有效地思考，提高推理效率。然而，它们不一定能提高下游任务的性能。

LRM-RL-survey

Wed, 24 Sep 2025 00:00:00 +0000

A Survey of Reinforcement Learning for Large Reasoning Models

Background

RL在推进LLM能力的前沿方面取得了显著成功，特别是在解决数学和编码等复杂逻辑任务方面。因此，RL已成为将LLM转化为LRM的基础方法。

需要探索提高强化学习向人工超级智能（ASI）的可扩展性的策略。

回顾一下大致流程吧！

简单讲解一下RL应用到语言模型的时候，这些概念映射到了哪里

Prompt/Task（x）：对应于初始状态或环境上下文，从数据分布中提取，对应于数据集D。
Policy (πθ):表示语言模型，它根据提示生成一个长度为T的序列，表示为y=（y1，…，yT）。
State (st):定义为提示以及到目前为止生成的令牌，即st=（x，a1:t−1）。
Action (at):在步骤t从动作空间A中选择的单元。根据粒度，动作可以是整个序列y（序列级）、∈V处的令牌（令牌级）或片段
Transition Dynamics (P):在LLM的上下文中，状态转换通常是确定的，因为st+1=[st，at]，其中[·，·]表示字符串连接。当状态包含EOS令牌时，策略将转换为终端状态，这意味着轨迹结束。
Reward (R(x, y) or rt):基于动作粒度进行分配，例如，轨迹末端的序列级别R（x，y），每个令牌的令牌级别rt=R（x、a1:t），或每个分段的步长级别rk=R（x、y（1:k））。
Return (G):提示x的整个轨迹y的累积奖励（通常在有限时间内γ=1）。它通过序列级奖励简化为单个标量R（x，y），否则按每个令牌/步骤聚合奖励

Frontier Models

按时间顺序排列在三个主要方向上：LRM、agentic LRMs和多模态LRM。
一个大型推理模型，OpenAI的o1[2024]系列，建立了将训练时间RL和测试时间计算扩展到更强大的推理能力的有效性，在数学、编码和科学基准测试方面取得了领先成果。
DeepSeek的旗舰模型R1[2025a]是第一个在基准测试中与o1性能相匹配的开源模型。它采用多阶段训练管道来确保全面的模型能力，并探索了没有监督微调的纯RL路线（即Zero RL）。
其他专有模型发布紧随其后：Claude-3.7-Sonnet[2025a]以混合推理为特色，Gemini 2.0和2.5[2025]引入了更长的上下文长度，Seed Thinking 1.5[2025b]以跨领域的泛化为特色，o3[2025a]系列展示了越来越先进的推理能力。最近，OpenAI推出了他们的第一个开源推理模型gpt-oss-120b[2025a]，随后推出了GPT5[2025a]，这是他们迄今为止最强大的人工智能系统，可以在高效模型和更深入的推理模型gpt-5思维之间灵活切换。并行的开源努力继续扩大了格局。在Qwen家族中，QwQ-32B[2025g]与R1的表现相匹配，其次是Qwen3[2025a]系列，代表性型号Qwen3-235B进一步提高了基准分数。Skywork-OR1[2025d]模型套件基于R1蒸馏模型，并通过有效的数据混合和算法创新实现了可扩展的RL训练。Minimax-M1[2025a]是第一个有效地将混合注意力引入尺度RL的模型。其他作品包括Llama Nemotron Ultra[2025]，旨在平衡准确性和效率；Magistral 24B[2025]，通过RL从头开始训练，而不是从先前的模型中提炼；以及种子OSS[2025a]，强调长上下文推理能力。等等…

过去的一年发展迅速啊！

Foundational Components

Reward Design

在1.1中，我们对LRM RL中的奖励设计进行了全面的考察。从可验证的奖励开始，DeepSeek-R1的成功就是例证，它通过可验证的奖励机制证明了RL的可扩展性。

在1.2中，我们考察生成性奖励，其中模型用于验证或直接生成奖励信号。

然而，可验证和生成性奖励通常都表示为稀疏的数值反馈。一个重要的互补维度在于奖励信号的密度。

1.3相应地考察了包含密集奖励的方法。另一个分类轴涉及奖励是根据外部真实情况计算的，还是由模型直接估计的。

这一区别促使我们在1.4中讨论无监督奖励。

在这四个类别的基础上，我们在1.5中转向奖励塑造，在那里我们分析了组合或转换不同奖励信号以促进学习的策略。

Verifiable Rewards

基于规则的奖励通过利用准确性和格式检查，为RL提供可扩展和可靠的训练信号，特别是在数学和代码任务中。

Verifier定律强调，具有清晰和自动验证的任务可以实现高效的RL优化，而主观任务仍然具有挑战性。

Rule-based Rewards

Accuracy rewards:对于具有确定性结果的任务（例如数学），策略必须在规定的分隔符（通常为\boxed{…}）内产生最终解决方案。然后，自动检查器将此输出与地面实况进行比较。对于编码任务，单元测试或编译器提供通过/失败信号
Format rewards:这些奖励施加了一个结构约束，要求模型将其私有思想链放置在和之间，并在单独的字段中输出最终答案（例如…）。这提高了大规模RL中的可靠解析和验证

Rule-based Verifier

基于规则的奖励通常来自基于规则的验证器。这些依赖于大量手动编写的等价规则来确定预测的答案是否与基本事实相匹配。目前，广泛使用的数学验证器主要基于Python库Math-Verify1和SymPy2构建。此外，一些作品，如DAPO[2025d]和DeepScaleR[2025c]，也提供了开源和成熟的验证器。最近，Huang等人[2025e]强调了与基于规则和基于模型的验证器相关的独特局限性，为设计更可靠的奖励系统提供了信息。

训练人工智能系统执行任务的难易程度与任务的可验证程度成正比

Generative Rewards

这里着重说明 Generative Rewards for Non-Verifiable Tasks

Reasoning Reward Models (Learning to Think)
Rubric-based Rewards (Structuring Subjectivity)：强调细粒度奖励
Co-Evolving Systems (Unifying Policy and Reward):
- Self-Rewarding：自我奖励，一个模型既充当policy model，也充当reward model
- Co-Optimization：policy和reward模型共同训练

Dense Rewards

dense rewards 和 verifiers对于open-domain还是太难了

Scaling remains challenging for tasks like open-domain text generation due to the difficulty of defining dense rewards or using verifiers.

Granularity细粒度分为：Trajectory（整个序列），Token，Step，Turn（Agent）
这几个信号可以相互转换，比如把globa returns 转换成 localized signals，奖励的重新分配
可以理解为从每次交互中直接分配和从结果中分解得出的回合级别奖励

Unsupervised Rewards

cluster：聚类（也有集群的意思）

majority vote：多数投票

Heuristic Rewards（启发式奖励）：这种方法构成了另一种基于规则的奖励形式，采用基于输出属性（如长度或格式）的简单预定义规则作为质量的代理。由DeepSeek-R1开创。不会提高模型真正能力？（质疑）

Rewards Shaping

Rewards Shaping将稀疏信号丰富为稳定的、信息丰富的梯度，用于LLM训练

Rule-based Reward Shaping
最简单的：把rule-based verifier和reward model组合起来生成overall reward signal。通常有一个constant coefficient平衡the contributions of the reward model and the rule-based component，不是所有正确的responses都是同样的scores，这样可以把所有的responses重新排序，避免无效的学习梯度

这种启发式组合策略在开放域任务中得到了广泛的应用，提供了更多的信息和有效的奖励信号。

另一种方法是DeepSeek-R1中实现结果级奖励和格式奖励，能让LLM学习长思维链推理，用于解决LLM输出中的各种异常。
Structure-based Reward Shaping Pass@k在推导和分析优势和有效近似值时，将集合级目标分解回单个样本信用分配。

Policy Optimization

最近的研究把on-policy RL和offline datasets结合在一起来进行optimization同时使用各种regularization techniques（正则化技术）比如entropy和KL防止overfitting

environment:the context in RL for LLMs

policy:the distribution of the next-level prediction

由于LLM中的大量参数，LLM的RL策略优化算法大多是基于一阶梯度的算法

Notations（符号）

当前状态s的预期积累奖励表示为V（value）函数

当前状态动作对应的预期积累表示为Q（quality）函数

优势函数：A(s, a) = Q(s, a) − V (s).该优势衡量的是与现有政策相比，当前行动在预期总回报方面有多大改进。

优化算法的历程

PPO算法[Schulman等人，2017b]首次被提出作为TRPO算法[Schurman等人，2015a]的计算高效近似。

Critic-based Algorithms

critic需要和LLM一起run和update，这样会导致巨大的计算开销，而且对于复杂的任务来说，扩展性不好

Critic-Free Algorithms

只需要sequence-level rewards for training

对于RLVR任务可以防止reward hacking等问题，这使得Critic-Free Algorithms更具有可扩展性

最近的研究表明response-level足以用于RL的可扩展推理任务

最受欢迎的critic-free approach是GRPO，新推出的GSPO[Zheng等人，2025a]，用序列级剪切代替了逐符号剪切的重要性采样率

SPO引入了一种无组、单流策略优化，用持久的KL自适应值跟踪器和全局优势归一化来替换每组基线，从而产生比GRPO更平滑的收敛和更高的精度

Importance Sampling for Policy Optimization

TRPO引入了RL中重要性抽样的第一个版本，其中在目标中引入了令牌式重要性比wi，t
这种方法在最近的工作中被广泛采用，如GRPO。由于无法在CoT的长上下文中有效计算实际分布比率，因此这种方法仅限于token-level重要性比率

token-level重要性采样在RL算法中引入了另一种偏差，因为实际采样分布给定的策略是针对状态-动作对定义的，而token-level方法只考虑当前动作。GMPO[赵等人，2025f]通过引入几何平均来寻求缓解，以提高具有极端重要性采样率的token的训练鲁棒性

在GSPO的最新工作中[Zheng等人，2025a]，计算了序列级重要性抽样因子。GSPO添加了一个唯一的归一化因子，以确保可以计算概率比，但这种方法也是对实际重要性抽样因子的有偏估计

Off-policy Optimization

Off-policy RL通过把data collection 和 policy learning解耦，实现了从历史、异步或离线数据集进行训练，从而提高了样本效率

选择性地replay 早期的推理traces可以提高exploration for LLM reasoning

现在很多都在对数据进行处理来提升exploration

Regularization Objectives

Objective-specific regularization helps balance explration and exploitation,boosting RL effiency and policy performance.

KL,entropy and length regularization remain open questions,each affects policy optimization and scalability

Length Penalty建议应用基于问题难度的自适应长度惩罚来保持模型的能力

Sampling Hyper-parameters

Exploration and Exploitation Dynamics

一些工作提出了一种动态方法，例如分阶段提高温度(e.g., 1.40 → 1.45 → 1.50 for a 4B model, 0.7 → 1.0 → 1.1 for a 7B model)

entropy 在0.3被发现是最佳平衡

其他的工作只是倡导提高一个固定的温度（例如1.0或1.2）来鼓励初步探索，同时指出它本身不足以防止长期的熵下降

Length Budgeting and Sequence Management

几乎所有的work都在努力管理生成响应的长度，以平衡性能和成本。

This involves starting RL with a short context window (e.g., 8k) before progressively increasing it to 16k, 24k, or 32k in later stages

初始的短上下文阶段被认为是必不可少的，因为它迫使模型学习更简洁、更具令牌效率的推理模式

Foundational Problems

RL’s Role: Sharpening or Discovery

RL vs. SFT: Generalize or Memorize

发现RL擅长巩固和增强现有能力，而SFT在引入新知识或新模型能力方面更有效

Model Prior: Weak and Strong

R1-Zero：直接将大规模基于规则的RL应用于基本模型，产生新兴的长期推理
R1：包含冷启动

基础模型先验比指导模型更适合强化学习，通常会产生比从高度一致的指导模型开始时观察到的更平滑的改进轨迹，其中根深蒂固的格式和服从先验可能会干扰奖励的形成

Model Family Differences

Reward Type: Process or Outcome

Training Resources

Static Corpus

Math
Code
STEM
Agent
Mixture

RL Infrastructure & Framework

e.g.OpenRLHF/veRL/AReaL/slime/TRL

Dynamic Environment

Rule
Code
Game
Model
Ensemble

Applications

1.Agentic Tasks
2.Coding Tasks
3.Multimodal Tasks
4.Robotics Tasks
5.Multi-Agent Systems
6.Medical Tasks

Pass@k论文复现

Sun, 21 Sep 2025 16:00:00 +0800

Pass@k Training for Adptively Balancing Eplortion and Exploitation of LRMs

Pass@k论文解读

policy探索能力的指标：the natural prevention of the decrease in the entropy of policy distribution

Pass@1和Pass@k之间的主要区别在于奖励计算和优势估计过程。

vanilla：原来的
Ground Truth是正确答案（标准答案）

探索能力:

the entropy of policy distribution处在一个较高的水平
the answer diversity of the negative response处在一个较高的水平
Pass@k的entropy在RLVR procedure的200step左右开始上升

k值影响Pass@k训练

实验中从4，8，16中调整k值

无论k的值是多少，随着训练的进行，训练奖励都可以提高到相对较高的水平，这表明k的值不是帮助LLMs逃脱局部最优解的关键性因素

k值越大，训练效率越慢（k值越大，优势值越小，导致优化步骤越短，训练效率越低）

训练效率的影响因素

实验在N = 32 和 k = 8的设置下使用{1 x 10-6,2 x 10-6,4 x 10-6}learning rate

随着学习率的提高，拐点出现得更早，表明训练效率更高

最大优势值不是帮助模型表现优异的关键性因素

为更难的问题分配更大的优化强度可以有效地提高训练效率

根据the entropy of policy distribution的高低，区分high-exploration和low-exploration。

high-exploration使用Pass@1 advantage fuction来exploit prior exploration，low-exploration使用Pass@k advantage function来encourage further exploration。

Implicit reward design（隐式奖励设计）可以控制优化过程

具体地说，结合或动态调整不同形式的优势估计，可以同时提高exploration and exploitation能力

Pass@k论文复现

arxiv文章👈
github仓库👈
Datasets👈

Maze

每个迷宫由文本表示，包含n行和n列，总共n∗n个字符

四个字符“S”、“E”、“.”和“*”中的一个，分别表示起点、目的地、可用地点和不可用地点

给定迷宫，LLM可以首先生成思维或推理过程，然后生成最终答案，其中包括四个动作“U”、“D”、“L”和“R”中的一个，分别表示向上、向下、向左和向右移动

对于训练数据，我们构建了大小为9×9、11×11、13×13和15×15的迷宫，以增加训练数据的多样性

对于测试数据，为了评估RLVR过程的泛化能力，我们不仅使用训练数据集进行相同大小的迷宫，还收集了大小为7×7、17×17、19×19和21×21的迷宫

为了确保实验的有效性，我们在生成训练和测试数据后进行了严格的重复数据删除操作

Training Set 都是10,000;Test Set除了7 * 7,剩下的都是100

Implementation Details

Training

backbone model:Qwen2.5-7B-Instruct和Qwen2.5-32B Instruct

DAPO

εlow=0.2和εhigh=0.28

token-level policy gradient loss

remove other optimizations

learning rate:1 × 10−6

warmup:10

prompt batch size(BS prompt):128

Prompt Batch Size：是模型推理生成的粒度。它决定在一次性并行处理多少个独立的提示词（例如，多少个用户问题），并同时为它们生成文本

mini-batch size(BS mini):32

Mini-batch Size：是模型权重更新的粒度。它决定在计算一次梯度下降时，使用多少条训练数据

rollout times:32

positive reward Rpos = 1

negative reward Rneg = 0

do not employ any regularization methods, such as KL or Entropy regularization
temperature:1.0

Top_P:0.95

从概率最高的词开始累加它们的概率，直到累积概率达到或刚刚超过你设定的 top_p 值

For each question,we sample 32responses for Maze task and sample 8 responses for other tasks

Versions/Dependencies

Python 3.10.18
Ray 2.49.1
grpcio 1.75.0
Ubuntu 24.04.2 LTS

如何从huggingface上下载数据集和模型

从huggingface上下载文件有2种方式，一种是直接登录后在网页上下载；一种是通过huggingface-cli命令下载。

本文介绍的是第二种下载方式。

安装

对于huggingface-cli命令的下载直接通过pip命令安装即可：

pip install -U huggingface_hub[hub_transfer]

对于国内用户还可以通过设置镜像网站的方式加速下载：

#linux export HF_ENDPOINT=https://hf-mirror.com
#windows
set HF_ENDPOINT=https://hf-mirror.com

使用命令行下载

模型

huggingface-cli download –resume-download [1] –local-dir [2] –local-dir-use-symlinks False

数据集

huggingface-cli download –repo-type dataset –resume-download [3] –local-dir [4] –local-dir-use-symlinks False –token hf_***

格式为：[1]和[3]表示项目的路径，格式为用户名/项目，比如mistralai/Mistral-7B-Instruct-v0.2表示的是mistralai下的7B instruct v0.2权重。[2]和[4]表示的是本地的保存地址。

需要的注意的是有些仓库需要登录才可以下载，形如–token hf_***为huggingface的token配置。token的生成需要在huggingface个人页面生成.

ray.init()初始化挂起/失败问题的解决

Sat, 20 Sep 2025 10:00:00 +0800

Abstract

此文章发布约一周前就已经发现该问题了，但是由于专注看官方文档和仓库进行规范 + 课内事情，一直没有得到解决。

在发文前一天发现此问题需要重点解决（无法避免），询问了师兄（论文作者）并咨询了相关团队，未果，所以花了两整天才解决这一个bug。

Issue

What happened + What you expected to happen

Running the following snippet will hang indefinitely

1
2
3


>>> import ray
>>> ray.init()
2025-09-20 11:44:47,741 INFO worker.py:1538 -- Started a local Ray instance.

Sometimes it will fail instead

1

[2025-09-20 11:50:22,050 E 31652 31652] core_worker.cc:179: Failed to register worker 01000000ffffffffffffffffffffffffffffffffffffffffffffffff to Raylet. IOError: [RayletClient] Unable to register worker with raylet. No such file or directory

Versions/Dependencies

Python 3.10.18
Ray 2.49.1
grpcio 1.75.0
Ubuntu 24.04.2 LTS

Reproduction script

1
2


import ray
ray.init()

Issue Severity

High: It blocks me from completing my task.

上面全英是因为当时要提issue或者给Ray框架作者发邮件，但是后来解决了，就打算留下来了，这样后来的人可以模仿一下这个写法。

可能的问题

1.workers实际上并没有启动。（可以看一下/tmp/ray/session_latest/raylet.out,如果在/tmp/ray/session_latest/看到有前缀python-core-worker- 的可以看一下，因为这个能了解工作进程可能发生了什么）
2.系统中进程数/线程数设置错误（可以通过cat /proc/sys/kernel/threads-max查看系统中一个进程可以创建多少个线程）

可能的方法

1.在import ray之后加上ray.init(num_cpus=56, num_gpus=2)。具体参数需要根据服务器进行自定义。作者根据这个方法对自己进行了适配解决了问题。

具体操作：`/yhy/verl/trainer/config/ppo_trainer.yaml`配置文件中对`num_cpus=0`修改成`num_cpus=10`, `num_gpus=1`进行定义。

2.升级grpcio,2023年的时候安装grpcio 1.48.1 版本是有用的,相应的venv是 CentOS 7,Python 3.7.11，Ray 2.5.1,grpcio1.48.1。
但我进行升级的时候，无法解决该问题，并且会导致包之间的冲突。（是一个opencv的包，已经pip install了）
3.添加ulimit -n 65536语句，因为分布式训练一开始可能会开成千上万个进程，默认是4096，所以会导致线程创建失败。

感觉这点也是有用的，但可能不是主要因素？

4.一定要设置参数,只是用ray.init()就会崩溃。需要手动设置num_cpus。
这点和1重复了，可以说是大家实验得到的结论？（也许）

近期其他人也遇到过该问题

2024.1.16也有在Ubuntu 20.04上遇到同样的问题 venv: ray == 2.7.1,grpcio == 1.59.2,python == 3.11.5
2024.4.2有在ubuntu 22.04.3（docker内部）上遇到同样的问题，但是他只是失败，而不是挂起。在docker之外运行良好（他的M1 MacBook上）

2024.4.14，2024.4.17，2024.7.11等等太多人遇到同样的问题了

至此，问题的解决方案已经讲述完毕。

回顾解决问题的流程

刚遇到这个问题，我先看了一下是不是自己遇到过的，发现没有就交给了copilot，发现copilot无法解决，给了chatgpt5，同样无法解决，又给了Gemini看看能不能有些新意（其实这步可以忽略），上述方法都不行，问了师兄是否遇到过。

发现他们都没有遇到过，我只能去Ray官方仓库里面的issue进行查看。感觉现在人们都不怎么用StackOverflow等等论坛了，所以就只能去issue里面找了。

幸运的是发现了很多人遇到了同样的问题和报错，我就开始追根溯源，发现从17.18年就有人提出了这个问题，当时也有相应的解决办法，但是随着版本更新变得不适用。
我就开始收集所有对这个问题的理解和解决方案，逐个尝试，很幸运的是我debug成功了！

因为论文中没有常见的问题的解决方案，如果有的话应该是第一步先去看的。

这就是我整个解决这个问题的流程，大体上看似乎没有太大问题。但是还是可以优化一下，下次遇到类似比较“偏”的问题可以更快，心态更平和地解决这个问题。

看到这里了，祝你遇到像我遇到的这样比较“偏门”的问题时，也可以顺利并更快地解决！

RUC-research-intern

Tue, 16 Sep 2025 10:00:00 +0800

科研日记

用来记录我远程实习的日子

2025.07.16

成为赵老师的本科实习生，暑假跟着师兄做了一个横向

家里网好差（本来服务器就慢），还是要在学校多用功

暑假一共6周，还有各种事情，加上休息吃饭探亲balabala也做不了太多事情。确定了方向，看了一些知乎上的论文解读（后面发现如果要通透还是要看原文）。

2025.09.16

近期在搞论文复现的实验，跟上课题组的进度

今天在修改run_dapo.sh脚本的时候发现了几个常见的问题

.sh的格式十分严格
Parquet文件格式

Parquet文件格式讲解👈

vibe coding脚本是无比正确的。
不知不觉已经两个月了，但对我而言收获是颇多的。

选择一个好组是十分重要的！软院TIC，高瓴AI BOX让我深刻感受到了好的氛围，成套的培养体系！

希望自己可以平衡好课内＋科研，还有生活等等其他方面

晚上睡前简单看了一下verl官方文档里面Config Explanation的Data部分

梯度下降的三种常见形式

1.Batch Gradient Descent（批量梯度下降）
2.Stochastic Gradient Descent (SGD，随机梯度下降)
3.Mini-batch Gradient Descent（小批量梯度下降）

几个epoch就是过几次数据集，实践中把 “batch” 这个词用得比较宽：在框架/代码里 batch_size 常指 mini-batch 的大小，所以容易混淆 “batch gradient descent” 与 “mini-batch”。

prompt_key

这个不是学术上固定的术语，而是很多框架（比如 HuggingFace、VERL、LangChain 等）里常见的实现细节。

在字典 / JSON / 配置文件里，用来标记某个 prompt 的键名（key）。
这样做可以在代码里快速查找/复用不同的 prompt 模板。

1
2
3
4
5


prompts = {
 "translation": "Translate the following English text into Chinese: {text}",
 "summarization": "Summarize the following paragraph: {text}",
 "qa": "Answer the question based on the context: {context}\nQuestion: {question}"
}

这里 “translation”, “summarization”, “qa” 就是 prompt_key，而它们对应的 value 就是具体的 prompt 模板。

Prompt = 给模型的输入提示，引导它完成任务。
Prompt_key = 在程序里标记或索引 prompt 模板的“名字/键”，方便管理和调用。

RM（Reward Model，奖励模型）：在 RLHF 里给生成结果打分的模型。

如果使用基于模型的 RM，并且策略和 RM 的聊天模板不同，则需要设置data.return_raw_input_ids=True data.return_full_prompt=True 用户输入：你好，介绍一下强化学习返回：[INST] 你好，介绍一下强化学习 [/INST] data.return_raw_chat=True 用户输入：你好，介绍一下强化学习返回的就是:你好，介绍一下强化学习

2025.09.17

早晨起来去工位继续看verl

actor_rollout_ref.hybrid_engine：是否是混合引擎，目前只支持混合引擎.

Dropout 是一种正则化方法，用来防止神经网络过拟合。在训练时，随机“丢弃”一部分神经元（让它们暂时不参与计算和更新）。推理时,不再丢弃任何神经元，只是使用完整的输出。

actor_rollout_ref.model.use_remove_padding一般都选true移除<PAD>来加速推理，但是多模态或者大工程里仍有人使用false

Temperature （温度）。T = 1 → 正常分布。T > 1 → 分布更平滑，增加随机性，容易生成多样化甚至跑偏的内容。T < 1 → 分布更尖锐，模型更确定（更倾向选概率最高的 token，输出保守）。
Top-k：从 softmax 排序后的前 k 个 token 中随机抽样。
Top-p：动态选择前累计概率 ≥ p 的最小 token 集合，从里面采样。

Actor:负责更新参数
Ref (Reference Model):负责对比/约束。它是冻结的（不更新），通常是最初的预训练模型。
Rollout:负责产生输出（推理采样）

EOS = End Of Sequence（序列结束标记）。在 tokenizer 里，EOS 往往是个特殊的 </s> 或 <eos> 符号。ignore_eos=True 在训练中一般少用，除非你需要生成固定长度序列，或者想收集超过 EOS 的 rollouts 数据。

2025.09.19

一个深度学习训练任务中，nodes 指的是计算机，而 gpus-per-node 指的是每台计算机上安装的 GPU 数量。
可以把 nodes 理解为一台台服务器，每台服务器里可以插上多张显卡（GPU）。
nnodes: 1：你正在使用一台计算机来运行任务。
n_gpus_per_node: 8：这台计算机上插了 8 张 GPU。
所以，这个配置的意思是，你用一台装有 8 张 GPU 的服务器来运行你的任务。

verl官方文档看完了，嗯。。还是要去看仓库

都在赶iclr导致服务器又变得卡卡的

实验复现遇到了问题导致一直是卡住的状态

神器：

pkill -9 -u $USER -f ray

2025.09.20

ray官方仓库，试图解决Ray实例后ray.init()挂起/失败问题

import ray ray.init() 2025-09-20 11:44:47,741 INFO worker.py:1538 – Started a local Ray instance.

有时候会卡住

python import ray ray.init() 2025-09-20 11:44:47,741 INFO worker.py:1538 – Started a local Ray instance.

有时候会失败

[2025-09-20 11:50:22,050 E 31652 31652] core_worker.cc:179: Failed to register worker 01000000ffffffffffffffffffffffffffffffffffffffffffffffff to Raylet. IOError: [RayletClient] Unable to register worker with raylet. No such file or directory

Versions/Dependencies

Python 3.10 Ray grpcio OS:

Reproduction script

import ray ray.init()

Issue Severity

High:It blocks me from completing my task.

可能的原因:1.workers实际上没有启动 2.系统中一个进程可以创建多少个线程？（可以通过cat /proc/sys/kernel/threads-max查看）

可能的方法:1.在import ray后添加 ray.init(num_cpus=56, num_gpus=2) 这个方法很多人似乎有帮助，但不是一个好的解决方案 2.可以看一下/tmp/ray/session_latest/raylet.out,如果在/tmp/ray/session_latest/看到有前缀python-core-worker- 的可以看一下，因为这个能了解工作进程可能发生了什么 3.升级grpcio,2023年的时候安装grpcio 1.48.1 版本是有用的,相应的venv是 CentOS 7,Python 3.7.11，Ray 2.5.1,grpcio1.48.1 4.

#!/bin/bash ulimit -n 65536 python3 -m verl.trainer.main_ppo …

5.一定要设置参数,只是用ray.init()就会崩溃。需要手动设置num_cpus

其他人： 2024.1.16也有在Ubuntu 20.04上遇到同样的问题 venv: ray == 2.7.1,grpcio == 1.59.2,python == 3.11.5 2024.4.2有在ubuntu 22.04.3（docker内部）上遇到同样的问题，但是他只是失败，而不是挂起。在docker之外运行良好（他的M1 MacBook上）

2024.4.14，2024.4.17，2024.7.11等等太多人遇到同样的问题了

15点左右,/yhy/verl/trainer/config/ppo_trainer.yaml配置文件中进行修改

问题已解决！在import ray后添加 ray.init(num_cpus=56, num_gpus=2)

自己看issue，扒仓库源码等等解决了这个问题

2025.10.22

结束了第一段实习，收获满满！
谢谢师兄！谢谢赵老师！
期待后续再合作！

第一篇文章

Mon, 15 Sep 2025 00:00:00 +0000

欢迎你能来到我的第一篇文章！

为什么要写博客？

写博客对我来说有着特殊的意义：

对自己

记录笔记：把学到的东西都记下来，以后可以复习
积攒经验：积攒宝贵的经验
记录进步：记录自己的进步

对他人

感谢师父：感谢文聪学长的帮助，永远的师傅！
传承精神：希望后来者能够更快速地入门
分享内容：希望其他人能够更快地了解我

博客内容规划

我计划我的文章中记录以下内容：

笔记 (Notes)

可能比较杂，什么都有。但重点是关于llm的内容

理论 (Theory)

一些理论知识

日记 (Diary)

记录一些自己的日常，探讨人生

结语

写博客是一个长期的过程，也应该是一个很开心的过程！

这篇文章写于 2025年9月15日，是我博客的第一篇文章。希望它能成为一个美好的开始。

About

Wed, 01 Jan 2025 00:00:00 +0000

Hi, I’m Huanyu Yang (杨环宇), an undergraduate at Dalian University of Technology.

I work on LLM agents. My interests center on agent systems and post-training, and I spend a fair amount of time with the infrastructure that makes them run: reinforcement learning, vLLM, and vLLM-omni.

This blog is where I write up what I’m reading and building: paper notes, implementation deep-dives, and the things I wish someone had explained to me earlier.

Focus

Agent development
Post-training
Inference and RL infrastructure (vLLM / vLLM-omni)

Contact

Email: 3868850350@qq.com / yhy3868850350@gmail.com
GitHub: QingZhou-YangHY

Links

Mon, 01 Jan 0001 00:00:00 +0000

友链整理中。A collection of sites and people worth a visit is on the way.

Search

Mon, 01 Jan 0001 00:00:00 +0000