Agent八股

模板1

八股：Encoder与decoder的中Attention区别？

答案：https://zhuanlan.zhihu.com/p/26252050300

https://www.zhihu.com/question/588325646/answer/1981416261771604279

八股：Attention如何计算？为什么除以根号下Dk？mask attention是如何实现的？

你的问题涉及 Transformer 模型中 Attention 机制的三个关键点：

  1. Attention 的计算方式
  2. 为什么除以 (\sqrt{d_k})
  3. Masked Attention 的实现方式

下面逐一解释：

  1. Attention 如何计算？（以 Scaled Dot-Product Attention 为例）

标准的 Scaled Dot-Product Attention 公式如下：

\[ \text{Attention}(Q, K, V) = \text{softmax}\left( \frac{QK^T}{\sqrt{d_k}} \right) V \]

其中：

  • \(Q \in \mathbb{R}^{n \times d_k}\)

    ：查询（Query）矩阵

  • \(K \in \mathbb{R}^{m \times d_k}\)

    ：键（Key）矩阵

  • \(V \in \mathbb{R}^{m \times d_v}\)

    ：值（Value）矩阵

  • \(d_k\)

    ：Key 的维度（也等于 Query 的维度）

计算步骤：

  1. 计算点积 (

    QKTQK^T

    )，得到一个 (

    n×mn \times m

    ) 的相似度矩阵。
  2. 除以\(\sqrt{d_k}\) （缩放，见下文解释）。
  3. 对每一行进行 softmax，得到注意力权重。
  4. 用权重对 (V) 加权求和，得到输出。
  1. 为什么除以 (\sqrt{d_k})？

这是为了 缓解点积过大导致 softmax 梯度消失的问题。

  • 假设 (q) 和 (k) 的每个元素是均值为 0、方差为 1 的独立随机变量。
  • 那么点积\(q \cdot k = \sum_{i=1}^{d_k} q_i k_i\) 的期望为 0，**方差为 **\(d_k\) 。
  • 当 (d_k) 较大时（如 64、512），点积的值会很大，使得 softmax 的输入进入其极值区域（趋于 0 或 1）。
  • 这会导致梯度非常小（softmax 饱和），训练困难。

解决方法：将点积结果除以

\(\sqrt{d_k}\)

，使得其方差回到 1，从而保持 softmax 的输入在合理范围内，梯度更稳定。

这就是 “Scaled” 的由来：Scaled Dot-Product Attention。

  1. Masked Attention 是如何实现的？

Masked Attention 主要用于 自回归模型（如 GPT、Decoder-only Transformer），防止当前位置“看到”未来信息。

实现方式：

在 softmax 之前，将未来位置的 attention score 设为 负无穷（(-\infty)），这样 softmax 后对应的权重为 0。

具体步骤：

  1. 计算

    \(QK^T / \sqrt{d_k}\)

    ，得到 attention scores 矩阵 (A)。

  2. 构造一个 上三角 mask（未来位置为 True），例如对长度为 4 的序列：

    1
    2
    3
    4
    mask = [[0, 1, 1, 1],
            [0, 0, 1, 1],
            [0, 0, 0, 1],
            [0, 0, 0, 0]]

    实际代码中常用 布尔 mask 或 加性 mask。

  3. 将 mask 位置的 score 替换为一个极大负数（如 -1e9）：

    \[ A_{\text{masked}} = A + \text{mask} \times (-\infty) \]

  4. 再对

    \(A_{\text{masked}}\)

    做 softmax。

代码示例（PyTorch）：

1
2
3
4
5
attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)
mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1).bool()  # 上三角为True
attn_scores = attn_scores.masked_fill(mask, float('-inf'))
attn_weights = torch.softmax(attn_scores, dim=-1)
output = torch.matmul(attn_weights, V)

在 Encoder 中通常 不加 mask（因为可以看整个输入）；
在 Decoder 的 self-attention 中 必须加 mask（防止信息泄露）。

总结

问题 答案
Attention 计算 (\text{softmax}(QK^T / \sqrt{d_k}) V)
除以 (\sqrt{d_k}) 原因 控制点积方差，防止 softmax 梯度消失
Masked Attention 用 mask 将未来位置 score 设为 (-\infty)，再 softmax

如果你对 Multi-Head Attention、Cross-Attention 或具体代码实现感兴趣，也可以继续问！

八股：除了MHA还知道哪些(GQA MQA MLA)讲原理

除了经典的 MHA（Multi-Head Attention），近年来为了在推理效率、显存占用和模型性能之间取得更好平衡，研究者提出了多种改进型注意力机制，主要包括：

  • MQA（Multi-Query Attention）
  • GQA（Grouped-Query Attention）
  • MLA（Multi-Layer Attention / Memory-efficient Latent Attention）

下面分别讲解它们的核心原理和区别：

  1. MHA（Multi-Head Attention）——基准
  • 原理：将 Query、Key、Value 分别用 (h) 个不同的线性投影头（heads）映射。
  • 每个头独立计算注意力，最后拼接或加权融合。
  • 特点：
    • (h) 个 Q、K、V（例如 32 头 → 32 个 K/V）
    • 表达能力强，但 KV Cache 显存开销大（每个 token 存 (h) 份 K 和 V）
  1. MQA（Multi-Query Attention）——极致压缩 KV
  • 原理：所有 attention head 共享同一组 Key 和 Value，但每个 head 有自己的 Query。
    • 即：(h) 个 Q，但只有 1 个 K 和 1 个 V
  • 优点：
    • KV Cache 大幅减少（从 (h) 份 → 1 份）
    • 推理速度更快，显存占用更低
  • 缺点：
    • 模型表达能力下降，可能导致生成质量略降（尤其在小模型上）
  • 应用场景：推理效率优先的场景（如早期的 StarCoder 使用了 MQA）
  1. GQA（Grouped-Query Attention）——MHA 与 MQA 的折中
  • 原理：将 (h) 个 Query heads 分组（比如 8 组），每组共享一个 K/V head。
    • 例如：32 个 Q heads → 分成 8 组 → 每组 4 个 Q 共享 1 个 K/V → 总共 8 个 K/V
  • 优点：
    • 相比 MHA：显著减少 KV Cache（从 32 份 → 8 份）
    • 相比 MQA：保留更多表达能力，性能损失更小
  • 实际应用：
    • Llama-2 / Llama-3 的 70B 模型使用了 GQA（32 Q heads, 8 KV heads）
    • 被证明可以在几乎不损失效果的前提下提升推理吞吐

GQA 被认为是 MHA 和 MQA 之间的最佳平衡点 。

  1. MLA（Multi-Layer Attention / Memory-efficient Latent Attention）

⚠️ 注意：MLA 有两种不同含义，此处指 Gemini 系列模型中提出的高效注意力机制（不是“多层注意力”字面意思）。

  • 原理（以 Google Gemini 的 MLA 为例）：
    • 不直接缓存原始 K/V，而是将 K/V 压缩到一个低维共享的“潜在记忆”（latent memory） 中。
    • 推理时通过这个共享 latent 来重建近似的 K/V。
    • 本质是一种 KV 压缩+共享 技术。
  • 优点：
    • KV Cache 体积极小（比 GQA 还小）
    • 更适合长上下文、高并发推理
  • 缺点：
    • 实现复杂，需额外训练或微调
    • 可能引入重建误差
  • 应用：Google Gemini 1.5 / 2.0 使用了 MLA 来支持百万 token 上下文 。

对比总结表

机制 Q heads K/V heads KV Cache 量 表达能力 典型应用
MHA (h) (h) 高（(h) 份） 最强 Transformer 原始设计
MQA (h) 1 极低（1 份） 较弱 StarCoder
GQA (h) (g)（(1 < g < h)） 中（(g) 份） 接近 MHA Llama-2/3 70B
MLA (h) 隐式共享（latent） 极低 依赖压缩质量 Gemini 1.5/2.0

为什么这些改进重要？

  • 在 大模型推理 中，KV Cache 占用显存最多（尤其长文本）。
  • MHA 的 KV Cache 与 head 数 × token 数 × dim 成正比，成为瓶颈。
  • MQA/GQA/MLA 通过 减少或压缩 K/V 的存储，提升吞吐、降低延迟、支持更长上下文，同时尽量保持模型能力 。

如需进一步了解某一种机制的数学公式或代码实现，也可以告诉我！

八股：为什么要用位置编码？为什么要用sin_cos？

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

之所以要sin cos交替，想要位置向量也可以表示相对位置，想象一个旋转的角度，△t，就也可以进行线性变化（矩阵乘）

八股：你提到用DeepSpeed做SFT训练，请讲一下DeepSpeed ZeRO Stage 1-3的区别，以及什么时候用FSDP会更好？

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

显存占用分析：https://zhuanlan.zhihu.com/p/694880795

fp16 fp32

参数/梯度/优化器/激活值对于显存的占用

混合精度训练：权重采用fp16存储，反向传播更新，优化器会维持fp32模型权重和fp32优化器参数的副本，因为使用32位更准确

优化器状态：使用adamW优化器，fp32模型权重，fp32的梯度移动平均值和梯度平方移动平均值，fp16的梯度

简单计算，fp16模型需要的显存是其参数量的八倍

1.模型参数：

–fp16存储，2 bytes *7 B =14GB.

2.梯度：

–fp16存储，2 bytes *7 B =14GB.

3.激活值:

–和batch_size和序列长度有关。

4.优化器状态：

– fp32 模型参数: 4 bytes * 7B = 28GB

–fp32 梯度的移动平均值*(m): 4 bytes * 7B = 28GB*

–fp32 梯度平方的移动平均值*(v): 4 bytes * 7B = 28GB*

zero1: 切分优化器状态。

  1. 优化器状态是主要的内存占用者。zero1的思路是将这些优化器状态分布到多个GPU上
  2. 这样增加了GPU通信，但降低了显存占用
  3. 减少4倍显存，保持通信量与dp相同

zero2: 切分梯度

  1. 再次将内存需求减少了一半，总体减少了8倍
  2. 仍保持与标准dp相同的通信水平

zero3:切分模型参数

  1. 减少显存占用与gpu数量成正比
  2. 增加了50%通讯量？
  3. 它的“分割”对象并非模型计算图本身，而是训练状态（参数、梯度、优化器状态）。它将这些状态切片，均匀地分发到所有 GPU 上。（动态聚合机制）

这类特别说一下deepspeed的zero3的切分模型参数后是怎么计算的：

假设我们有 4 个 GPU (GPU 0, 1, 2, 3)，并且需要计算网络中的 Layer L。

  • 第 1 步：计算前的分区状态 在计算开始前，Layer L 的权重参数 W_L 被切分成了 4 片 (P_0, P_1, P_2, P_3)，分别存储在 4 个 GPU 的显存中。此时，没有任何一个 GPU 能独立开始计算。
  • 第 2 步：计算时的动态聚合 (All-Gather) 当计算流程到达 Layer L 时，ZeRO-3 触发一次 All-Gather 通信操作。每个 GPU 将自己持有的那一分片参数发送给所有其他 GPU，并同时接收其他所有 GPU 发来的分片。操作完成后：每个 GPU 都在自己的显存里临时拼凑出了一份完全相同的、完整的 Layer L 的参数 W_L。
  • 第 3 步：执行标准的层计算 现在，每个 GPU 都手握完整的 Layer L 参数，于是它们可以像标准数据并行一样，用各自的数据分片和这份完整的参数，独立地完成 Layer L 的前向传播计算。
  • 第 4 步：计算后立即释放 一旦 Layer L 的计算完成，每个 GPU 会立刻丢弃刚刚组装起来的完整参数，只保留自己最初负责的那一分片。显存被瞬间释放，为下一层的计算做好了准备。

这里必须强调一个最关键、也最容易被误解的核心要点：ZeRO-3 的 All-Gather 不是一次性聚合整个模型，而是逐层（Layer-by-Layer）进行的。 它对显存的峰值需求，取决于模型中最大的那一层的参数大小，而不是整个模型的总大小。正是这种精细化的、“即用即弃”的逐层管理，才使得 ZeRO-3 能够以数据并行的方式，训练远超单卡显存容量的巨型模型。

它的“模型分割”实际上是**“训练状态分割”**。它在计算的瞬间，通过通信换取空间，让每个 GPU 能“看到”完整的层参数来执行标准计算。它对模型代码的侵入性很低，但要求单卡至少能容纳下模型最大层带来的瞬时显存开销。

deepspeed没有原生tp，用的还是megatron的。

megatron就是列切，行切

项目：问Agent的工具tool的设计，是否是workflow形式

不完全是，一方面有规则，一方面有agentic的成分

项目：了解哪些agent开发框架，例如langchain和LlamaIndex，他们核心应用场景有何不同

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

前面就是用来造智能体的框架，提供工具、message、state、graph（1.0）, memory

后者则是增强rag能力的，比如有的库就是导入向量库，有的是能够用来自动构建知识图谱的

项目：问数据的输入输出格式如何保证大模型输出稳定的json做了哪些工作

智力题：有12个外观相同的芯片、其中一个重量不同(不知轻重)，用天平最少称几次能找出这张芯片？

代码题：lc215 数组中的第K个最大元素

模板2

1. 介绍RAG项目

2.怎么解决LLM幻觉问题

分阶段来回答：

数据处理阶段：

  1. 数据质量和多样性：选择高质量、多样性和平衡的数据集进行训练。这包括从多个来源收集数据，以及确保数据覆盖了各种主题和领域
  2. 数据清洗：在训练模型之前，对数据进行清洗和预处理，以去除错误、偏见和不相关的信息
  3. 数据标注：对数据进行标注，以提供关于信息真实性的额外信息。例如，可以标注数据中的事实是否正确，或者是否包含误导性的信息

训练阶段：

  1. 模型微调：在特定任务或数据集上进一步训练模型，以改善模型在特定上下文中的表现
  2. 模型结构和参数选择：选择或设计适合任务的模型结构，并调整模型的参数，以优化模型的性能
  3. 模型集成：训练多个模型，并结合它们的输出，以提高输出的真实性
  4. 有限状态约束 FST：使用约束解码，将输入的 FSA x 与一个特殊的 FST T 进行合成，用于编码所有可能的分段决策，并将其投影到输出带中，以获得输出空间的确定性有限状态自动机

后处理阶段：

  1. 后处理和过滤：在模型生成输出后，使用各种策略来过滤或修改输出，以提高其真实性
  2. 模型解释和可视化：理解模型的决策过程，以帮助识别可能的问题并改进模型
  3. 用户反馈：收集用户对模型输出的反馈，并使用这些反馈来改进模型
  4. Levenshtein 事后对齐算法：我们使用它将生成的字符串与参考字符串进行对齐，在 LLM 没有精确重新创建输入时，可以消除一些不流畅的文本
  5. Web 检索确认
  6. 引入外部知识库

3.LLM的参数介绍（temp topk top p等）

logits/temp，温度越大各个位置的概率就越均衡

4.LLaMA和GLM的区别，模型架构等方面

一篇跟大模型架构对比相关的文章：https://zhuanlan.zhihu.com/p/1953492025719644723

DeepSeek v3/r1:

  1. MLA（多头潜在注意力）

    1. MHA->GQA->MLA
    2. MLA提供了一种不同的内存节省策略，与kv cache配合的比较好
    3. MLA不像GQA那样共享键值头，而是将kv tensor压缩到低维空间，然后将它们存储在kv cache中。
    4. img
    5. MLA 是一个巧妙的技巧，可以减少 KV 缓存内存的使用，同时在建模性能方面甚至略胜于 MHA。

  2. 混合专家moe

    1. 用多个专家层替换 Transformer 模块中的每个前馈模块，其中每个专家层本身也是一个前馈模块。

      img

    2. 关键在于我们不会为每个 token 使用（“激活”）所有专家。相反，路由器只会为每个 token 选择一小部分专家。

    3. 由于每次只有少数专家处于活跃状态，因此 MoE 模块通常被称为稀疏模块，这与始终使用完整参数集的密集模块形成对比。然而，通过 MoE 获得的大量参数增加了 LLM 的容量，这意味着它可以在训练期间吸收更多知识。然而，稀疏性保持了推理的高效性，因为我们不会同时使用所有参数。

    4. 例如，DeepSeek-V3 每个 MoE 模块有 256 位专家，总共 6710 亿个参数。然而，在推理过程中，每次只有 9 位专家处于活动状态（1 位共享专家加上 8 位由路由器选择的专家）。这意味着每个推理步骤仅使用 370 亿个参数，而不是全部 6710 亿个参数。

      DeepSeek-V3 的 MoE 设计的一个显著特点是使用了一个共享专家。这是一个始终对每个 token 保持活跃的专家。这个想法并不新鲜，早在DeepSeek 2024 MoE[3]和2022 DeepSpeedMoE[4]论文中就已提出。

    5. DeepSpeedMoE 论文首次提出了共享专家的优势，他们发现与没有共享专家相比，共享专家可以提升整体建模性能。这可能是因为多个专家无需学习常见或重复的模式，从而为它们提供了更多学习更专业模式的空间。

Qwen3

moe

Qwen3 也有两种 MoE 版本：30B-A3B 和 235B-A22B。为什么有些架构（例如 Qwen3）会同时提供常规（密集）和 MoE（稀疏）版本？

正如本文开头所述，MoE 变体有助于降低大型基础模型的推理成本。同时提供密集模型和 MoE 版本，让用户能够根据自己的目标和约束条件灵活地进行推理。

密集模型通常更容易在各种硬件上进行微调、部署和优化。

img

如上图所示，DeepSeek-V3 和 Qwen3 235B-A22B 架构非常相似。值得注意的是，Qwen3 模型不再使用共享专家（早期的 Qwen 模型，例如Qwen2.5-MoE，确实使用了共享专家）。

遗憾的是，Qwen3 团队并未透露放弃共享专家的任何原因。如果非要我猜的话，可能是因为在他们将专家数量从2个（Qwen2.5-MoE中的设置）增加到8个（Qwen3中的设置）时，对于他们那个训练架构的稳定性来说，并没有这个必要。然后，他们通过只使用8个专家而不是8+1个专家，节省了额外的计算和内存开销。（不过，这并不能解释为什么DeepSeek-V3仍然保留了它的共享专家。）

Qwen3的开发者之一Junyang Lin对此做出了如下回应：

当时，我们并没有发现共享专家有足够显著的改进，我们担心共享专家会导致推理优化问题。说实话，这个问题没有直接的答案。

Kimi K2

它使用了相对较新的Muon优化器的一个变体来替代 AdamW。据我所知，这是 Muon 首次用于这种规模的生产模型，而非 AdamW（此前，它仅被证明可以扩展到 16B）。这带来了非常漂亮的训练损失曲线，这可能有助于该模型跃居上述基准测试的榜首。

该模型本身有 1 万亿个参数，这确实令人印象深刻。

它也完成了一个循环，因为 Kimi 2 使用了我们在本文开头介绍过的 DeepSeek-V3 架构，只不过他们把它做得更大了，如下图所示。

img

384个专家

Grok2.5

Grok 2.5 使用少量大型专家（8 个），这反映了一种较旧的趋势。如前所述，较新的设计（例如 DeepSeekMoE 论文中的设计）倾向于使用更多小型专家（Qwen3 中也存在这种情况）。

另一个有趣的选择是使用相当于共享专家的功能。图 32 左侧显示的附加 SwiGLU 模块充当始终在线的共享专家。它与经典的共享专家设计并不完全相同，因为它的中间维度加倍了，但思路是一样的。（我仍然觉得 Qwen3 省略了共享专家这一点很有意思，看看 Qwen4 及后续型号是否会有变化也值得关注。）

img

5.Qwen模型每个版本之间的改进点

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

Qwen 的发展主要体现在以下几点：

  • 模型规模从小到大：主要体现在：

    • 预训练数据集越来越大，从3万亿token，逐步发展到2.5版本的 18万亿，3.0版本还没公布多少万亿，总之是更多了；
    • 模型参数规模：最早就是主打7B，现在就不仅仅是7B了，还包括了 235B参数；并在2.5版本开始着手验证scaling law。
    • 对齐阶段SFT的数据量，最早30万条，现在也已经上百万条了。

  • 不断考虑训练推理效率：

    • 像初代版本还用的是dense FFL，此后就演变成了 MoE模型，加快了训练和推理效率；
    • 注意力机制计算也采用了 GQA技术，减少计算量；
    • 扩展上下文长度也新增了 DCA 和 Yarn，总之不是蛮力扩展上下文长度，而是采用了技巧，目的也是为了节省计算资源。
    • 对齐阶段，PPO 也被改成了 DPO，同样是省去了复杂的强化模型训练框架。
    • 推理阶段给出了 AWQ 量化策略，同样是为了保证效果的同时，兼顾效率。

  • 向数学、编程发展：众所周知，数学和编程这两样对于语言模型来说，比较难，是不少公司发力研发的目标。

    • 数据组织大幅提高数学、编程的数据占比。
    • 为了控制数学、编程输出结果的稳定性、确定性，在对齐阶段也采用了offline和 online 两种方式。
    • 诟病：数学和编程能力确实在2.5、3.0版本中有提升，但大量用户反馈，在写报告、回答常识问题、复述一些用户问话、处理简单日常任务能力上，返回幻觉频发，参数量增加了，但效果更差了。这种情况也不是Qwen 一家如此。似乎数学和编程这类问题和日常常识问答存在一些思维方式上的矛盾。

  • 深度思考：深度思考现在几乎每家模型都需要接入了，因为这个过程必不可少：

    • 深度思考其实是 decoder-only 模型弥补相对于 encoder-decoder 模型不足的一种补充；
    • 深度思考也是解决复杂问题，包括编程、数学、agent 等必不可少的一关；
    • 深度思考是语言表示思维的必经步骤。

6.介绍检索做的优化，具体追问子问题分解怎么做，有没有做意图识别

7.RAG怎么评估，指标有哪些

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

precision@k

recall@k

上面这些就是可以完全计算、量化的，还有一些nlp的指标 BLEU ROUGE等

参考ragas中的一些评估指标

correctness 相关性 helpfulness 等，llm as judge

8.RAG如果有噪声怎么办

有办法可以减少，多阶段：

文档预处理降噪

  • 格式统一化：将PDF、Word等多格式文档转换为Markdown格式，便于统一处理
  • 结构化过滤：删除OCR识别的无效图表描述、无意义数字（如"0/1"转换为文字）
  • 冗余清理：去除大量空格、分割符等格式噪声（参考2025-09-04知乎文章）

2. 检索阶段去噪技术

  • 多阶段检索：先通过向量索引初筛，再用BGE-Reranker等模型重排（参考2025-05-09知乎文章）
  • 段落注入机制：将检索段落融入推理过程，增强模型辨伪能力（中科院2025-11-08研究）
  • 证据质量验证：使用EviNote-RAG的SEN（支持性证据笔记）标记不确定信息（2025-09-12联合研究）

3. 推理阶段抗噪优化

  • 证据质量奖励（EQR）：通过逻辑蕴含监督确保证据支撑答案（EviNote-RAG核心创新）
  • 自我反思机制：让模型在生成答案时同步判断证据相关性（2025-11-21网页研究）
  • 噪声训练增强：在SFT阶段按比例加入随机噪声文档，提升模型抗干扰能力（2025-11-23编程知识研究）

openai的一个优化策略：https://zhuanlan.zhihu.com/p/704291371

9.怎么构建SFT数据集，数据量多少，微调方式是什么

10.SFT数据问题不够多样化怎么办

11.介绍一下function calling和MCP

一个是模型选择、调用工具的能力

另一个是提供了一个标准化的方式，让模型知道有哪些工具，工具的参数、描述等等

最终实际上还是模型输出一个结构化的调用，然后让真正的后端去执行这个工具

12.代码题：lc215 数组中的第 K 个最大元素

模板3

1.lora 原理，初始化，为什么，对比 sft

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

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

2.训练网络过程的一些优化

3.batchnorm和layernorm 区别，为什么用，在哪里用

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

batchnorm就是给一批数据的某一个feature做归一化

layernorm就是给某一个sequence的多个feature做归一化

均值为0，方差为一

4.attention 及其变体原理，cross attention 的 qkv 来自哪里

Attention 机制及其变体（如 Self-Attention、Cross-Attention）的核心思想是通过“查询”（Query）、“键”（Key）和“值”（Value）三部分计算加权表示。下面分别说明其原理及 Cross-Attention 中 Q、K、V 的来源。

  1. Attention 的基本原理

给定 Query ( Q )、Key ( K )、Value ( V )，Attention 的计算公式为：

\[ \text{Attention}(Q, K, V) = \text{softmax}\left( \frac{QK^\top}{\sqrt{d_k}} \right) V \]

其中：

  • ( d_k ) 是 Key 的维度，用于缩放防止点积过大；
  • softmax 使注意力权重归一化；
  • 输出是 Value 的加权和，权重由 Query 与 Key 的相似度决定。
  1. Self-Attention（自注意力）
  • 应用场景：处理单一序列内部的关系（如 Transformer 编码器或解码器内部）；
  • Q、K、V 来源：全部来自同一个输入序列 ( X )；
    • 通常通过三个可学习的线性变换（权重矩阵）得到：\[ Q = X W_Q,\quad K = X W_K,\quad V = X W_V \]

3. Cross-Attention（交叉注意力）

  • 应用场景：处理两个不同序列之间的关系，常见于 Transformer 的解码器中，用于让目标序列关注源序列（如机器翻译中，目标语言关注源语言）。

  • Q、K、V 来源：

    • Query (Q)：来自目标序列（例如解码器的输入，如已生成的部分目标句子）；
    • Key (K) 和 Value (V)：来自源序列（例如编码器的输出，如源语言句子的表示）；
    • 数学表达（以 Transformer 解码器为例）：\[ Q = X_{\text{dec}} W_Q,\quad K = X_{\text{enc}} W_K,\quad V = X_{\text{enc}} W_V \] 其中\( X_{\text{dec}} \) 是解码器侧的表示，\( X_{\text{enc}} \) 是编码器输出。

4. 为什么这样设计？

  • Query 表示“我想关注什么”，所以由当前正在处理的序列（如目标语言）提供；
  • Key/Value 表示“我可以提供什么信息”，所以由外部序列（如源语言）提供；
  • Cross-Attention 使得模型能动态地从源序列中检索与当前目标 token 最相关的信息。

总结

Attention 类型 Query 来源 Key/Value 来源
Self-Attention 同一序列 同一序列
Cross-Attention 目标序列 源序列

这种机制是 Transformer 能够有效建模跨模态（如文本-图像）或跨语言（如英-中翻译）关系的关键基础。

5.自注意力机制是什么？计算复杂度怎么算？

自注意力机制（Self-Attention）是 Transformer 模型的核心组件，用于在单个序列内部建模元素之间的相互依赖关系。它不依赖于位置或距离，能够直接捕获任意两个位置之间的关联。

一、自注意力机制是什么？

给定一个输入序列

\( X = [x_1, x_2, ..., x_n] \in \mathbb{R}^{n \times d} \)

，其中：

  • ( n ) 是序列长度（token 数），
  • ( d ) 是每个 token 的特征维度，

自注意力通过三个可学习的线性变换生成 Query、Key、Value：

\[ Q = X W_Q,\quad K = X W_K,\quad V = X W_V \]

其中

\( W_Q, W_K, W_V \in \mathbb{R}^{d \times d_k} \)

（通常 ( d_k = d_v = d ) 或 ( d/ h ) 在多头注意力中）。

然后计算注意力输出：

\[ \text{Self-Attention}(X) = \text{softmax}\left( \frac{Q K^\top}{\sqrt{d_k}} \right) V \]
  • \( QK^\top \in \mathbb{R}^{n \times n} \)

    表示所有 token 对之间的相似度；

  • softmax 后得到注意力权重矩阵

    \( A \in \mathbb{R}^{n \times n} \)

    ；

  • 每个输出 token 是所有输入 token 的加权和（权重由相关性决定）。

二、计算复杂度分析

假设：

  • 序列长度为 ( n )，
  • 每个 token 的维度为 ( d )（通常 ( d_k = d_v = d )）。

各步骤的计算复杂度如下：

步骤 操作 复杂度
1 计算 ( Q, K, V )：三个矩阵乘法 ( X W ) ( 3 \times (n d \cdot d) = 3 n d^2 )
2 计算 ( Q K^\top ) ( n \cdot d \cdot n = n^2 d )
3 softmax（元素级操作） ( O(n^2) )（通常忽略，因远小于矩阵乘）
4 计算 ( A V )（注意力权重 × Value） ( n^2 \cdot d = n^2 d )

总时间复杂度：

\[ O(n d^2 + n^2 d) \]

通常在实际模型中（如 BERT、GPT），( d ) 是固定的（例如 768），而 ( n ) 可变。当序列较长时（如 ( n > d )），主导项是 ( n^2 d )，即 自注意力的时间复杂度为 ( O(n^2 d) )。

空间复杂度（主要指注意力矩阵 ( A ) 的存储）：

  • 需要存储\( QK^\top \) 或 softmax 后的\( A \in \mathbb{R}^{n \times n} \) ，
  • 所以空间复杂度为\( O(n^2) \) 。

三、实际影响

  • 当 ( n = 512 )，

    n2=262,144 n^2 = 262,144 \

    —— 可接受；
  • 当 ( n = 8192 )，

    n2≈67 million n^2 \approx 67 \ million

    —— 显存和计算开销剧增；
  • 这也是为什么很多研究致力于 降低自注意力复杂度，如：
    • Sparse Attention（稀疏注意力）
    • Linformer（用低秩近似）
    • Performer（核函数近似）
    • FlashAttention（I/O 优化）

总结

  • 自注意力机制：让序列中每个元素关注所有其他元素，通过 Q、K、V 动态计算相关性；
  • 时间复杂度：( O(n^2 d) )；
  • 空间复杂度：( O(n^2) )（主要来自注意力矩阵）；
  • 瓶颈：长序列处理时的二次复杂度，是当前大模型上下文长度扩展的主要挑战之一。

6.KV-Cache的如何加速推理？

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

img

img

img

在利用kv cache的时候，输入第一个token，变成embedding，然后proj成为q、k、v。假设只有一层transformer，计算完qk^Tv之后，通过一个language head映射到词表，选择概率最大的一个token。此时序列变成2个token，继续生成，只需要第二个token->embedding，然后proj成为q、k、v，再进行注意力计算的时候，kv要和第一个token已经计算好的kv合并，然后再跟q计算attention score（即qk^Tv），然后以此类推。
每次最后生成的token是没有对应的qkv的，如果要继续生成的话，要把最后生成的token先proj成为qkv，然后把前面所有的kv与当前的kv合并，最后利用最后生成的token对应的q与合并后的kv计算attention，然后通过language head生成新的token。

KV-Cache（Key-Value Cache）是在自回归语言模型（如 Transformer 解码器）推理阶段用于避免重复计算、显著加速生成过程的关键优化技术。

一、为什么需要 KV-Cache？

在自回归生成中（如 GPT 生成文本）：

  • 每次生成一个 token，需对当前所有已生成的 token（包括新 token）重新计算 Self-Attention；
  • 如果不缓存，第 ( t ) 步就要重新计算前 ( t ) 个 token 的 Q、K、V —— 大量重复计算。

举例：
生成第 5 个 token 时，模型会重新计算 token 1~5 的 K、V；
生成第 6 个 token 时，又重新计算 token 1~6 的 K、V —— 其中 1~5 完全重复！

二、KV-Cache 的核心思想

只计算新 token 的 K、V，旧 token 的 K、V 缓存起来复用。

具体做法：

  • 在第 ( t ) 步（生成第 ( t ) 个 token）：
    • Query：仅对当前新输入（通常是第 ( t ) 个 token）计算 ( q_t )；
    • Key / Value：
      • 新部分：计算当前 token 的 ( k_t, v_t )；
      • 旧部分：从缓存中读取之前所有 token 的 ( {k_1, …, k_{t-1}}, {v_1, …, v_{t-1}} )；
    • 拼接得到完整 ( K_{1:t}, V_{1:t} )，参与注意力计算。

三、如何加速推理？

✅ 1. 减少计算量

  • 原本每步计算 ( t ) 个 token 的 K、V（复杂度 ( O(t d^2) )）；
  • 使用 KV-Cache 后，每步只计算 1 个 token 的 K、V（复杂度 ( O(d^2) )）；
  • 总计算量从 ( O(n^2 d^2) ) 降到 ( O(n d^2) )（( n ) 为生成长度）。

✅ 2. 减少访存与 FLOPs

  • 避免重复读取历史 token 并做矩阵乘；
  • 虽然要维护缓存（增加内存），但大大降低每步延迟，尤其在长文本生成时效果显著。

✅ 3. 支持批处理（batching）优化

  • 多个请求可共享相同长度的 KV-Cache 结构，便于 GPU 并行。

四、KV-Cache 的存储开销

  • 每层 Transformer 都需要缓存 K 和 V；
  • 假设模型有 ( L ) 层，每层注意力头数 ( h )，每个头维度 ( d_h )，序列长度 ( n )；
  • 总缓存大小 ≈\( 2 \times L \times h \times n \times d_h \times \text{bytes per param} \) ；
  • 例如：Llama-7B（( L=32, h=32, d_h=128 )），生成 2048 个 token，约需 数 GB 显存。

📌 这也是长上下文推理显存瓶颈的主要来源。

五、注意事项

  • 仅用于推理（inference），训练时因并行处理整个序列，不需要 KV-Cache；
  • 不适用于所有模型：仅自回归解码器（如 GPT）使用；Encoder-only（如 BERT）或非自回归模型无需；
  • 需配合 Position Embedding / RoPE：缓存的 K、V 仍需正确的位置信息。

总结

项目 无 KV-Cache 有 KV-Cache
每步 K/V 计算量 ( O(t d^2) ) ( O(d^2) )
总时间复杂度 ( O(n^2 d^2) ) ( O(n d^2) )
是否重复计算 是 否
推理速度 慢（随长度平方增长） 快（线性增长）
显存开销 低 高（但可接受）

✅ KV-Cache 用显存换时间，是现代大语言模型高效推理的基石。

7.LoRA的原理是什么？与P-Tuning、Adapter的异同点？LoRA的参数选择对模型性能有何影响？

LoRA（Low-Rank Adaptation）是一种高效的参数高效微调（Parameter-Efficient Fine-Tuning, PEFT）方法，其核心思想是用低秩矩阵近似原始模型权重的更新，从而在只训练极少参数的情况下实现接近全参数微调的性能。

下面从原理、与其他方法（P-Tuning、Adapter）的异同、以及参数选择对性能的影响三方面详细说明。

一、LoRA 原理

  1. 基本思想

在微调大型预训练模型（如 LLM）时，直接更新全部参数成本高、易过拟合。LoRA 假设：权重更新 (\Delta W) 具有低秩结构，即：

\[ \Delta W = A B, \quad A \in \mathbb{R}^{d \times r}, \; B \in \mathbb{R}^{r \times k}, \; r \ll \min(d, k) \]

其中：

  • \(W_0 \in \mathbb{R}^{d \times k}\)

    是预训练权重（冻结不训练）；

  • (A, B) 是可训练的低秩分解矩阵，秩为 (r)；

  • 前向传播时实际使用：

    \(h = x (W_0 + \Delta W) = x W_0 + x A B\)

这样，只训练 (A) 和 (B)，原始 (W_0) 保持不变。

  1. 应用位置

LoRA 通常插入在：

  • Transformer 的 Attention 模块（如 (W_q, W_k, W_v, W_o)），
  • 有时也用于 MLP 层，但实践中主要用在 Attention。
  1. 推理时合并

训练完成后，可将

\(\Delta W = AB\)

加到 (W_0) 上，零开销部署（与原始模型无区别）。

二、与 P-Tuning、Adapter 的异同

方法 核心机制 可训练参数位置 是否修改模型结构 推理是否需额外开销 典型应用场景
LoRA 低秩分解更新权重矩阵 原有线性层旁路（低秩矩阵） 否（可合并） 否（可合并） 通用，尤其 LLM 微调
Adapter 在 FFN 或 Attention 后插入小型全连接模块（如 bottleneck） 新增子网络（如 down-projection + up-projection） 是（插入模块） 是（需保留 Adapter 层） 多任务、跨任务迁移
P-Tuning v2 在输入层或每层前添加可学习的连续 prompt 向量（软提示） 输入嵌入空间或每层前缀 是（增加 prompt token） 是（需保留 prompt） 少样本、提示学习

关键区别：

  • LoRA vs Adapter：

    • Adapter 修改模型结构，增加额外模块，推理时需保留；
    • LoRA 不改变前向结构，仅修改权重，可合并，部署更干净；
    • LoRA 通常在相同参数量下表现优于 Adapter。

  • LoRA vs P-Tuning：

    • P-Tuning 仅调整输入表示（类似“软提示”），不修改模型内部权重；
    • LoRA 直接调整模型参数空间，表达能力更强；
    • P-Tuning 更适合任务提示（如 NLU），LoRA 更适合指令微调、领域适配。

📌 实践中，LoRA 因其高效果、易部署、灵活性强，已成为 LLM 微调的事实标准（如 Hugging Face PEFT 库默认支持）。

三、LoRA 参数选择对性能的影响

关键超参数：

  1. 秩（rank）(r)：

    • (r) 越大，表达能力越强，但参数量和过拟合风险增加；
    • 常见值：8、16、32、64；
    • 实验表明：r=8~32 通常足够，超过 64 收益递减；
    • 小模型（如 7B）常用 r=8，大模型（70B）可用 r=64。

  2. 应用层位置：

    • 仅在 Attention 的 (W_q, W_v) 上加 LoRA，通常就能达到 90%+ 全微调性能；
    • 加在 (W_k, W_o) 或 MLP 上收益有限，甚至有害；
    • 推荐策略：优先 (q, v)，必要时扩展到 (k, o)。

  3. 缩放因子（alpha）：

    • LoRA 输出常带缩放：( \frac{\alpha}{r} AB )；
    • (\alpha) 控制更新幅度，类似学习率；
    • 通常设 (\alpha = 2r)（如 r=8 → α=16），效果较稳定。

  4. 参数量占比：

    • 以 LLaMA-7B 为例：
      • 全参数：7B；
      • LoRA（r=8，仅 q/v）：约 4M 参数（0.06%）；
    • 即使如此少的参数，也能在指令微调中接近全微调效果。

⚠️ 注意：过小的 r（如 r=1~2）会严重限制模型容量，导致欠拟合；过大的 r 可能过拟合小数据集。

总结

  • LoRA 原理：用低秩矩阵近似权重更新，冻结主干，只训旁路；
  • vs Adapter / P-Tuning：
    • LoRA 更高效、可合并、通用性强；
    • Adapter 需保留结构，P-Tuning 仅改输入；
  • 参数选择：
    • rank (r) 是关键：8~32 通常最佳；
    • 优先应用于 Attention 的 (W_q, W_v)；
    • 合理设置 (\alpha)（如 (\alpha = 2r)）。

✅ LoRA 在低资源、多任务、快速迭代场景中极具优势，是当前大模型微调的首选 PEFT 方法。

8.介绍下RLHF的基本流程，与DPO的差异是什么？

GRPO PPO DPO: https://zhuanlan.zhihu.com/p/1910019667268986241

DPO属于直接偏好对齐方法，是在2023年由斯坦福大学研究团队提出的偏好优化算法，主要为了解决PPO训练难度高导致不容易收敛，资源消耗大的问题。主要的方法是通过引入人类偏好数据，将在线策略优化，修改为通过二元交叉熵直接拟合人类偏好数据的离线策略。

img

RLHF vs DPO

DPO优点

  • 训练流程短：RLHF的过程，需要提前训练好一个reward model，但DPO由于不需要引入reward model，因此也无需这个阶段。DPO根据预先给定的偏好数据直接进行学习，属于离线策略，不需要进行在线数据采样。
  • 训练资源要求低：其中RLHF需要策略模型（Policy Model）、参考模型（Reference Model）、奖励模型（Reward Model）、价值模型（Value Model），而DPO仅需要前两个模型，并且参考模型属于可选加载，可以通过将参考模型的输出结果预先录制好，在训练时就可以不加载。因此对于训练资源显存等要求低。
  • 稳定性高：DPO属于有监督学习（通过概率匹配直接优化策略），摆脱了强化学习由于高方差带来的不稳定（由于奖励稀疏or噪声造成）。DPO可以通过人类偏好数据，用二元交叉熵对策略进行优化，而不需要多次进行在线数据采样进行优化。其中， yw为偏好数据，yl为非偏好数据。
  • 训练难度低：其中DPO仅需要关注学习率和偏好权重β ，而RLHF需要同时关注策略更新幅度、奖励模型置信度等。

img

这个loss是咋来的？

DPO缺点

  • 容易过拟合：DPO由于缺少reward model的泛化，因此容易直接拟合人类偏好数据，造成过拟合。
  • 需求更大标注数据量：相比PPO等，DPO的效果表现更依赖标注数据量。
  • 多任务适配较难：由于DPO仅依赖数据，所以如果需要进行多任务的对比，则需要从头标注涉及到多个维度的数据，但是在线策略的方法可以通过单个维度的数据，训练不同的多个reward model，引入多维度的奖励。
特性 DPO 传统 PPO + RM
是否需要奖励模型 ❌ 不需要 ✅ 需要
是否需要强化学习 ❌ 不需要 ✅ 需要（PPO）
训练稳定性 高（标准有监督学习） 低（RL 不稳定）
实现复杂度 低（几十行代码） 高（多模型、值函数、clip 等）
训练效率 高（可批量训练） 低（需采样、策略梯度）
性能 通常优于或持平 PPO 基线

**GRPO vs PPO **

为了在PPO和DPO之间取得平衡，deepseek提出了GRPO（群组相对优化策略），a在一定程度上能够通过去掉价值模型Value Model，缓解PPO对于显存的瓶颈，确保策略更新的稳定性和高效性；同时保留了Reward Model，避免了DPO因为直接拟合人类偏好数据，而容易造成的过拟合和效果不佳。

其中GRPO跟PPO的重要区别，主要是去掉了Value Model，同时使用Policy Model的多个output采样的Reward Model输出的多个奖励的平均值作为优势函数。

一、优势函数不同

二、奖励值的归一化方式不同

三、KL散度的作用范围不同

KL散度在PPO是放在奖励函数中。在GRPO的目标函数直接放在了损失函数

img

DPO vs RLHF

  • **训练流程：**其中DPO因为不依赖Reward Model，所以只有一个训练流程，而PPO、GRPO等在线策略需要先训练Reward Model，再进行对齐，需要两个阶段。
  • **显卡资源需求：**对于显卡的需求PPO（加载4个模型）>GRPO（加载3个模型）>DPO（加载1个必选模型+1个可选模型）
  • **对样本依赖：**其中PPO、GRPO因为通过Reward Model来进行对齐，有一定的泛化作用，因此对样本标注的精度和数据量依赖相对较小；DPO与之相反。
  • **灵活扩展性：**当涉及到多个业务场景时，其中PPO、GRPO可以通过多个Reward Model来进行灵活的扩展，而不需要从头标注多业务维度的人工偏向数据；DPO则需要重新构建数据，整体的灵活性和可扩展性较差。

9.分布式训练中的TP、PP、DP分别是什么？

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

10.flash-attention的原理是什么？

作用：加速注意力计算！！

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

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

看这个简单些：https://zhuanlan.zhihu.com/p/714881594

FlashAttention的核心原理是将输入QKV分块，并保证每个块能够在SRAM（一级缓存）上完成注意力操作，并将结果更新回HBM，从而降低对高带宽内存（HBM）的读写操作。总之，FlashAttention从GPU的内存读写入手，减少了内存读写量，从而实现了2~4倍的速度提升。

FlashAttention has slightly higher FLOP count than naive attention due to recomputation, but reduces data movement dramatically.

FlashAttention 是一种高效、内存感知的注意力机制实现，旨在减少 GPU 显存访问（I/O）开销，从而加速注意力计算并降低显存占用。它不是改变注意力公式，而是通过算法重排与分块计算，在不损失精度的前提下显著提升性能。

SRAM>HBM>DRAM的速度

一、背景：标准注意力的瓶颈

标准 Self-Attention 计算如下（忽略 softmax 缩放）：

A=softmax(QK⊤)∈Rn×nOutput=AVA = \text{softmax}(Q K^\top) \quad \in \mathbb{R}^{n \times n} \\ \text{Output} = A V

其中：

  • Q,K,V∈Rn×dQ, K, V \in \mathbb{R}^{n \times d}

  • (n)：序列长度（如 2048）

  • (d)：特征维度（如 128）

问题：

  1. 中间矩阵 (QK^\top) 和 (A) 需要 (O(n^2)) 显存；
  2. GPU 高带宽显存（HBM）；
  3. 即使计算快，I/O 成为瓶颈（“memory-bound” 而非 “compute-bound”）。

二、FlashAttention 的核心思想

不显式构造完整的 (QK^\top) 或 (A) 矩阵，而是通过分块（tiling）

具体来说，FlashAttention 利用两个关键技术：

✅ 1. 分块计算（Tiling / Blocking）

  • 将 (Q, K, V) 沿序列维度（(n)）切分为小块（tiles）；
  • 每次只加载一小块到高速片上 SRAM（如 GPU 的 shared memory）；
  • 在 SRAM 内完成局部 (q_i k_j^\top)、softmax、与 (v_j) 的乘积累加；
  • 避免将完整的 (n \times n) 矩阵写入/读出 HBM。

✅ 2. 在线 Softmax 技巧（Online Softmax）

  • Softmax 不能直接分块计算（因需全局最大值和归一化）；
  • FlashAttention 使用数值稳定的在线归约方法：

    • 对每个 query 块，维护局部最大值 (m) 和局部和 (l)；（safe-softmax，减去最大值）

    • 合并不同 key 块时，动态更新：

      mnew=max⁡(mold,mcurr)lnew=loldemold−mnew+lcurremcurr−mnewm_{\text{new}} = \max(m_{\text{old}}, m_{\text{curr}}) \\ l_{\text{new}} = l_{\text{old}} e^{m_{\text{old}} - m_{\text{new}}} + l_{\text{curr}} e^{m_{\text{curr}} - m_{\text{new}}}

    • 最终结果等价于完整 softmax，但无需存储完整 (A)。

这样，中间注意力矩阵 (A) 从未完整存在于 HBM 中，只在 SRAM 中临时存在并立即用于计算 (AV)。

三、优势

指标 标准 Attention FlashAttention
时间复杂度 (O(n^2 d)) (O(n^2 d))（但常数小）
显存复杂度 (O(n^2 + nd)) (O(nd))（不存 (A)）
HBM 读写次数 高（多次读写 (A)） 极低（只读 (Q,K,V)，只写 Output）
实际速度 慢（I/O 瓶颈） 快 2–5 倍（尤其长序列）
支持长上下文 受限（显存爆炸） 更高（如 8K、16K、32K）

四、FlashAttention-2 的改进（2023）

在 FlashAttention 基础上进一步优化：

  • 更优的线程块调度；
  • 减少 shared memory 同步；
  • 更好的并行性；
  • 速度再提升 1.5–2 倍，接近理论算力上限。

五、实际应用

  • 主流 LLM 框架默认启用：
    • Hugging Face Transformers（通过 use_flash_attention_2=True）；
    • vLLM、TensorRT-LLM、Llama.cpp（部分支持）；
    • PyTorch 2.0+ 内置 torch.nn.functional.scaled_dot_product_attention 自动 fallback 到 FlashAttention（若硬件支持）。
  • 要求：
    • GPU 架构 ≥ Ampere（如 A100、RTX 3090/4090）；
    • 安装 flash-attn 库（CUDA 扩展）。

六、注意事项

  • 仅加速计算，不改变模型结构或结果（数值误差在可接受范围）；
  • 对短序列（如 (n < 512)），收益有限；
  • 不直接降低算法复杂度（仍是 (O(n^2))），但通过 I/O 优化使长序列可行；
  • 与 KV Cache 兼容：推理时仍可使用 KV Cache + FlashAttention 加速每步 attention。

s总结

FlashAttention 是一种 I/O 感知的注意力实现，通过分块计算 + 在线 softmax，在不改变数学定义的前提下，大幅减少显存访问和占用，从而加速训练与推理，尤其对长上下文场景至关重要。

它是现代大模型高效训练/推理的基础设施级优化，已被广泛集成到主流框架中。

模板4

1.训练数据，有没有做数据处理与增强的工作

这里的数据会进行扩写

4.在什么机器上训练，时间，数据量大小

跨机器，4卡A100，tp=2，时间很快，几条，ms-swift

5.rag中怎么做的pdf解析，对pdf里面的图片，表格数据怎么处理的，怎么编码的，检索，召回的时候都做了哪些操作，混合检索的时候的权重怎么处理的，有没有消融实现对比

最佳实践：分层解析 + 结构感知

内容类型 工具/方法 输出形式
文本（含格式） pymupdf（PyMuPDF）、pdfplumber 保留段落、标题层级、字体大小、位置坐标
表格 camelot-py（PDF 线条表）、table-transformer（无框线表） 转为 Markdown 表格 或 结构化 JSON
图片/图表 pymupdf 提取图像 + OCR/多模态理解 图像文件 + Caption（由多模态模型生成）
公式/LaTeX latex-ocr（Pix2Text） 转为 LaTeX 字符串
版面分析 unstructured + layoutparser 返回 ElementType（text/table/figure/title）

📌 关键原则：不丢弃任何信息，但转化为可检索的文本形式。

caption这里要随着原文档也塞入向量数据库，base64编码了，有个映射关系

文档、表格统一转化成markdown格式。经过最开始的几个实验发现转化成markdown格式对于解析表格有作用。

->tabulate。

分块：langchain.RecursiveCharacterTextSplitter

rrf

消融实验做了部分

还有agentic rag。

混合召回：语义召回（相似度）+ 图召回+ 关键词召回。

涉及到多跳的仅靠一次查询是不行的。

召回：rrf/融合加权，这里rrf+reranker，一个参数

问题是这里rerank每次都要发起多次API推理。

多阶段重排：向量召回+图召回+关键词召回top30，RRF融合top15, reranker重排

7.sft与rag对比

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

9.agent方面有哪些了解

框架 langchain langgraph autogen

记忆

上下文压缩

工具

mcp

模板5

1. 两三句介绍下agent以及当前的挑战

Agent（智能体）是指能够感知环境、自主规划并执行任务以达成目标的大模型系统，通常具备记忆、工具调用、推理和自我反思等能力。当前主要挑战包括：可靠性不足（如幻觉、工具误用）、复杂任务规划能力有限、多步执行中的错误累积，以及缺乏统一评估基准和高效训练范式。

2. transformer架构 有哪些机制

Transformer 架构是自然语言处理（NLP）中一种革命性的神经网络结构，最早由 Vaswani 等人在 2017 年的论文《Attention is All You Need》中提出。其核心在于完全基于注意力机制，摒弃了传统的循环（RNN）和卷积（CNN）结构。Transformer 的主要机制包括以下几个关键组成部分：

  1. 自注意力机制（Self-Attention / Scaled Dot-Product Attention）

  • 允许模型在处理每个词时关注输入序列中的其他所有词。

  • 通过计算 Query (Q)、Key (K)、Value (V) 三个向量来实现：

    \[ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V \]

  • “Scaled” 是因为点积可能很大，导致 softmax 梯度消失，因此除以 (\sqrt{d_k}) 进行缩放。

  1. 多头注意力（Multi-Head Attention）

  • 将自注意力机制并行地应用多次（多个“头”），每个头学习不同的注意力子空间。

  • 将多个头的输出拼接后通过一个线性变换得到最终输出：

    [ \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, ..., \text{head}_h)W^O \]

  • 增强模型对不同位置、不同语义关系的建模能力。

  1. 位置编码（Positional Encoding）

  • 因为 Transformer 没有像 RNN 那样的顺序处理机制，需显式加入位置信息。

  • 通常使用正弦和余弦函数编码位置：

    \[ PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d}}\right), \quad PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d}}\right) \]

  • 也可使用可学习的位置嵌入（如 BERT 中）。

  1. 残差连接（Residual Connection）与层归一化（Layer Normalization）

  • 每个子层（如多头注意力、前馈网络）后都接残差连接和 LayerNorm：

    \[ \text{Output} = \text{LayerNorm}(x + \text{Sublayer}(x)) \]

  • 有助于缓解深层网络训练中的梯度消失问题，并稳定训练。

  1. 前馈神经网络（Position-wise Feed-Forward Network）

  • 每个位置独立地通过一个两层全连接网络：

    \[ \text{FFN}(x) = \max(0, xW_1 + b_1)W_2 + b_2 \]

  • 通常包含 ReLU 激活函数，且同一层对所有位置共享参数（但不同层参数不同）。

  1. 编码器-解码器结构（Encoder-Decoder Architecture）
  • 编码器（Encoder）：由 N 个相同层堆叠而成，每层包含多头自注意力 + 前馈网络。
  • 解码器（Decoder）：也由 N 层组成，但每层包含：
    1. 掩码多头自注意力（防止看到未来 token）；
    2. 编码器-解码器注意力（Query 来自解码器，Key/Value 来自编码器）；
    3. 前馈网络。
  • 解码器通过自回归方式生成输出（一次一个 token）。
  1. 掩码机制（Masking）
  • Padding Mask：忽略输入中的填充 token（如 <pad>）。
  • Look-ahead Mask（因果掩码）：在解码器中，防止当前位置关注未来位置的 token，保证自回归性质。

这些机制共同使得 Transformer 能够高效地并行处理长序列、捕捉长距离依赖，并成为现代大模型（如 BERT、GPT、T5、LLaMA 等）的基础架构。

3. 解释下交叉注意力机制

模板3 问题3

4. 介绍下ppo dpo grpo算法

模板3 问题8

这里grpo单独提出来说一下

JGRPO(θ)=Eq∼P(Q),{oi}i=1G∼πold(O∣q)[1G∑i=1G1∣oi∣∑t=1∣oi∣(ri,t(θ)A^i,t−βDKL(πθ∣∣πref))]J_{GRPO}(\theta) = \mathbb{E}_{q \sim P(Q), \{o_i\}_{i=1}^G \sim \pi_{old}(O|q)} \left[ \frac{1}{G} \sum_{i=1}^G \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \left( r_{i,t}(\theta) \hat{A}_{i,t} - \beta D_{KL}(\pi_\theta || \pi_{ref}) \right) \right]

举例假设：

  • q = “翻译：Hello world”
  • G = 2 个输出：o₁ = “你好世界”，o₂ = “哈喽世界”
  • |o₁| = 4，|o₂| = 4（按字计）
  • β = 0.01
  • π_ref 是旧策略，例如在“你”字处概率为 0.8，在“哈”字处概率为 0.7
  • 当前策略 π_θ 在“你”字处概率为 0.9，在“哈”字处概率为 0.6

在 t=1 时刻（第一个字）：

  • 假设 reward model 给出 r₁,₁ = 1.0（“你”好），r₂,₁ = 0.8（“哈”稍差）
  • 优势估计：A₁,₁ = 0.6，A₂,₁ = 0.3 → 平均优势 = 0.45 → 相对优势：Â₁,₁ = 0.15，Â₂,₁ = -0.15
  • KL 项：D_KL(π_θ || π_ref) 在 t=1 位置约为 0.02（粗略估算）

则 t=1 的贡献为：

  • o₁: 1.0 × 0.15 - 0.01 × 0.02 = 0.15 - 0.0002 ≈ 0.1498
  • o₂: 0.8 × (-0.15) - 0.01 × 0.02 = -0.12 - 0.0002 ≈ -0.1202

然后对所有 t 和所有 i 求平均，得到最终目标 J_GRPO(θ)，我们通过梯度上升最大化它。

5. grpo的loss怎么计算的 数据用的什么

。。不会

6.deepresearch和强化学习怎么结合应用

webdancer

奖励函数设计：开放域问题reward难以量化，其他的到都好说，套用现成的一个算法就行。

有研究就是用的LLM as reward judge（kimi-research 用o3-mini评估答案正确性）

7. 解释下topk topp的实现原理

略

8. 为什么现在大模型都是decoder架构

模板5

1. 损失函数设计

2. LoRA吟唱

3. 手撕MHA

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

暂时别管

4. 看你除以了根号k 有什么作用

5. 梯度消失和梯度爆炸 如何缓解

6. QKV代表什么 说说理解

QKV 是 Query（查询）、Key（键）、Value（值） 的缩写，是 注意力机制（Attention Mechanism） 中的核心组成部分，尤其在 Transformer 模型 中被广泛使用。

基本理解

在注意力机制中，Q、K、V 用于计算输入序列中不同位置之间的相关性（即“注意力权重”），从而决定在处理某个位置时，应该“关注”序列中的哪些其他位置。

  • Query (Q)：代表当前要处理的元素的“查询向量”，用于与其他位置的 Key 进行匹配。
  • Key (K)：代表序列中每个位置的“标识”或“索引”，用于与 Query 计算相似度。
  • Value (V)：代表序列中每个位置实际携带的“信息内容”，最终加权求和时使用。

工作流程（以自注意力为例）

  1. 对输入序列中的每个 token，通过不同的线性变换（可学习的权重矩阵）分别得到对应的 Q、K、V 向量。

  2. 计算 Query 与所有 Key 的点积（通常除以 √d_k 以稳定梯度），得到注意力分数（未归一化的相关性）。

    \[ \text{Attention Scores} = \frac{QK^T}{\sqrt{d_k}} \]

  3. 对注意力分数应用 Softmax，得到归一化的注意力权重（表示每个位置对当前 token 的重要性）。

  4. 用这些权重对 Value 向量加权求和，得到最终的输出表示：

    \[ \text{Output} = \text{Softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V \]

直观类比

可以类比为 信息检索系统：

  • Query 是用户的搜索请求；
  • Key 是数据库中每条记录的索引或标签；
  • Value 是数据库中每条记录的实际内容；
  • 系统根据 Query 与 Key 的匹配程度，从 Value 中提取最相关的信息。

为什么需要 Q、K、V？

  • 如果直接用输入本身计算注意力，表达能力受限；
  • 通过可学习的投影矩阵将输入映射到 Q、K、V 空间，模型能更灵活地学习“在什么情况下关注什么信息”。

扩展：多头注意力（Multi-Head Attention）

Transformer 使用多个 QKV 投影头（即多组权重矩阵），并行计算多组注意力，最后拼接结果。这样可以让模型同时关注不同子空间中的信息（例如语法、语义、位置等）。

总之，QKV 是注意力机制实现“动态加权信息聚合”的数学工具，是现代大模型（如 BERT、GPT、LLaMA 等）高效建模长距离依赖的关键。

7. 如果QK变成同一个矩阵你觉得有什么影响

如果将 Query（Q） 和 Key（K） 设为同一个矩阵（即 ( Q = K )），会对注意力机制产生若干重要影响，既有理论上的含义，也有实际效果上的改变。下面我们从多个角度分析：

  1. 注意力分数变成自相关（Self-Similarity）

原始注意力分数为：

\[ A = QK^T \]

若 ( Q = K )，则变为：

\[ A = QQ^T \]

这意味着注意力分数变成了 每个 token 与自身及其他 token 的内积（相似度），即衡量 token 表示之间的自相似性。

  • 优点：计算更简单，参数减少（只需一个投影矩阵而非两个）。
  • 缺点：Query 和 Key 的角色耦合，模型无法独立学习“如何查询”和“如何被查询”。
  1. 对称性引入

由于 ( QQ^T ) 是对称矩阵，注意力权重矩阵（Softmax 后）也会近似对称（严格对称性被 Softmax 破坏，但结构上仍有对称倾向）。

  • 这意味着：token i 对 token j 的注意力 ≈ token j 对 token i 的注意力。
  • 但在很多任务中，注意力应是非对称的。例如：
    • 在 “I love cats” 中，“love” 应高度关注主语 “I” 和宾语 “cats”，但 “I” 不一定需要关注 “cats”。
    • 对称注意力会限制模型表达方向性依赖关系的能力。
  1. 表达能力下降

Q 和 K 使用不同的可学习投影矩阵（( W_Q \neq W_K )）允许模型：

  • 从不同视角编码“查询意图”和“被查特征”；
  • 学习更复杂的交互模式。

强制 ( Q = K ) 相当于约束了模型的表示空间，可能降低其拟合复杂依赖的能力。

类比：如果你只能用同一把钥匙既去“寻找锁”（Query）又去“代表自己是一把锁”（Key），灵活性远不如拥有两把可独立设计的钥匙。

  1. 实际模型中的尝试

尽管标准 Transformer 使用独立的 ( W_Q ) 和 ( W_K )，但某些简化模型或特定场景中会共享参数：

  • Linear Transformer / Performer 等高效注意力变体有时会探索 Q=K 以降低计算；
  • 某些自监督预训练方法（如 BYOL、SimSiam）在对比学习中使用对称结构，但那是不同范式；
  • 实验表明：在多数 NLP 任务中，Q=K 会导致性能轻微到中度下降，尤其在需要精细依存分析的任务上（如机器翻译、阅读理解）。
  1. 特殊情况：可能有益？

在某些对称性天然存在的任务中，Q=K 可能不是大问题，甚至有益：

  • 图神经网络（节点间关系对称）；
  • 某些无向序列建模（如蛋白质序列的接触预测）；
  • 极端压缩模型时，作为参数削减手段。

总结

方面 影响
计算 略微简化，参数减少
对称性 引入（可能不希望的）对称注意力
表达能力 下降，难以建模非对称依赖
性能 通常略有下降，特定场景可接受

✅ 标准做法仍推荐使用独立的 Q 和 K 投影，除非有明确动机（如压缩、对称任务、理论研究）才考虑令 ( Q = K )。

如果你在设计轻量化模型或探索新架构，可以尝试 Q=K 作为消融实验，但需谨慎评估任务是否容忍对称注意力。

8. 除了LoRA还有什么微调的方法

P Tuning

peft： https://zhuanlan.zhihu.com/p/636326003

  1. adapter(另外插入一个模块进去)
  2. prefix tuning（在输入或者隐层添加多个可学习的前缀 tokens）
  3. prompt tuning
  4. lora

Prefix Tuning 和 Prompt Tuning 都是面向大语言模型（LLM）的参数高效微调（Parameter-Efficient Fine-Tuning, PEFT）方法，它们通过在输入中添加可学习的“软提示”（soft prompts）来引导模型完成特定任务，而无需更新整个模型的参数。下面分别举例说明：

  1. Prefix Tuning

核心思想：在输入序列的前面（或在每一层 Transformer 的 Key/Value 中）插入一组可学习的连续向量（称为 prefix），这些向量在训练中被优化，而原始模型参数保持冻结。

举例（文本生成任务）：

假设我们有一个预训练的语言模型（如 GPT-2），想让它完成翻译任务（英文 → 法文）。

  • 原始输入（普通提示）：

    1
    Translate English to French: Hello →

  • Prefix Tuning 的做法：

    • 在输入前面插入一串可学习的 embedding 向量（比如长度为 10 的向量序列）：
      1
      [P1, P2, ..., P10] + [“Translate”, “English”, “to”, “French”, “:”, “Hello”, “→”]
    • 这些 [P1...P10] 不是真实词的 embedding，而是随机初始化、通过反向传播优化的连续向量。
    • 训练时只更新这些 prefix 向量，语言模型本身冻结。
    • 推理时，同样在输入前加上学习到的 prefix。

特点：prefix 向量可以插入到 Transformer 的每一层（不仅输入层），对模型内部状态进行引导，效果通常优于仅修改输入。

  1. Prompt Tuning

核心思想：只在输入层添加可学习的 soft prompt tokens（也是连续向量），形式上更简单，是 Prefix Tuning 的简化版。

举例（情感分类任务）：

  • 任务：判断句子 “I love this movie!” 是正面还是负面情感。

  • 传统提示（hard prompt）：

    1
    Sentence: I love this movie! Sentiment:

  • Prompt Tuning 的做法：

    • 用可学习的 soft tokens 替代或补充提示词。例如，在输入开头加 20 个可学习的 embedding：
      1
      [S1, S2, ..., S20] + [“Sentence”, “:”, “I”, “love”, “this”, “movie”, “!”, “Sentiment”, “:”]
    • 这些 [S1...S20] 是连续向量，通过训练优化，模型其余部分冻结。
    • 最终让模型输出 “positive” 或 “negative”。

特点：只修改输入 embedding 层，结构简单，参数更少。在大模型（如 T5-XXL）上效果接近全参数微调。

简单对比

方法 可学习位置 参数量 适用模型规模 复杂度
Prefix Tuning 所有层的 K/V 或输入前缀 中等 中到大模型 较高
Prompt Tuning 仅输入 embedding 层 很小 超大模型（>10B） 很低

注：当模型足够大时（如 T5-11B），Prompt Tuning 的性能可接近全微调，而 Prefix Tuning 在中小模型上通常更优。

如果你有特定任务场景（如问答、摘要、代码生成等），我可以给出更具体的例子。

全参数微调

模板6

你对 SFT（监督微调）中的 scaling law 有了解吗？在实际训练中，你遇到过哪些比较大的困难？

其实主要是造数据。

训练上的困难其实还好，megatron封装好了很多东西，另外尝试跨机器训练但是因为模型本身比较小，也没用太多机器，不会出现超大规模训练的那种比如掉卡、容错、慢节点之类的问题

核心规律：数据、模型与性能的幂律关系

  1. 数据量与性能的关系：
    • 当模型参数量固定时，模型性能随微调数据量的增加呈现幂律增长（即性能提升速度逐渐放缓）。
    • 例如，在翻译任务中，数据量增加10倍可能带来BLEU分数5%的提升，但再增加10倍可能仅提升2%。
    • 关键结论：数据量并非越多越好，需与模型规模匹配，否则会进入收益递减阶段。
  2. 模型参数量与性能的关系：
    • 当微调数据量固定时，模型性能随参数量的增加同样呈现幂律增长。
    • 例如，8B模型的性能可能显著优于1B模型，但16B模型的提升幅度会缩小。
    • 关键结论：更大的模型能更好地利用微调数据，但需平衡计算成本。
  3. 联合Scaling（数据与模型同步放大）：
    • 若同时增加模型参数量和微调数据量，性能提升最为显著。
    • 例如，模型参数量增加8倍，数据量需同步增加5倍（比例约为N^0.74/D），才能避免过拟合惩罚。
    • 关键结论：数据与模型的同步放大是突破性能瓶颈的关键。

在模型训练时，如果发现 advantage 或者 loss 突然变成 0，一般可能是什么原因导致的？

特殊场景处理

  • GRPO训练初期loss为0：这是正常现象，因为初始策略与参考策略一致
    • 初始策略与参考策略完全一致，导致概率比（ratio）恒为 1，且参与计算Loss的优势函数、KL散度均为0，因此对于GRPO第一步的Loss一定为0。
    • 过了第一步后，后续的前几步也可能为0，这个时候主要可能由于数值精度、LearningRate过低导致。
  • 持续为0：需检查reward模型是否返回常数，或模型是否未正确更新

在构建 AI Agent 时，它的记忆（Memory）机制通常是怎么设计的？

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

mem0开源版本去做的

提取：

  1. t时刻接收到user+assistant信息，触发提取。信息源有俩：

    1. 保存在数据库的摘要S
    2. 具体每轮的对话内容mt-m,mt-m+1…mt-2。

    这里的摘要是全局的一个信息，对话的内容覆盖摘要没有的细节。提取环节是异步的，不阻塞主流程。

    这里S和若干m构成一个prompt整体P，llm来抽取返回一组记忆Ω(w1,w2,w3…)

更新：

  1. 提取阶段后，对w2,w2,w3…做评估，保障记忆一致性，避免冗余。然后从向量数据库中提取s个相似度最高的记忆，和事实一起扔给llm，让llm决定操作：
    1. add
    2. update
    3. delete
    4. noop(啥都不做)

memg: mem0的带图版本

图结构在涉及细微关系语境的场景中更为有益，⽽不是简单的检索。对于多跳问题，Mem0 通过有效地整合多个会话中分散的信息，展现出明显的优势，证实了⾃然语⾔记忆为这些综合性任务提供了⾜够的表现⼒。Mem0g预期的关系优势并没有在这⾥转化为更好的结果，这表明在多步推理场景中导航更复杂的图结构时可能存在潜在的开销或冗余。

在时间推理⽅⾯，Mem0g显著优于其他⽅法，验证了结构化关系图在捕捉时间顺序和事件序列⽅⾯的优越性。明确的关系上下⽂显著增强了Mem0g的时间连贯性，超越了Mem0的密集记忆存储，凸显了在追踪时间敏感信息时精确关系表⽰的重要性。

总体⽽⾔，我们的分析表明 Mem0 和 Mem0g 在各种任务需求中具有互补的优势：基于密集⾃然语⾔的记忆在简单查询中提供了显著的效率，⽽明确的关系建模对于需要细微时间与上下⽂整合的任务变得⾄关重要。这些发现进⼀步强化了在 AI 代理部署中，根据特定推理语境量⾝定制灵活记忆结构的重要性。

当模型出现 bad case 时，你一般会怎么分析？后续会采取哪些措施来改进？

如果需要为特定领域的文本训练一套 Embedding，你会怎么做？

https://www.zhihu.com/question/663835334/answer/1907642089266708585 大模型的embedding层和专门的embedding模型

这里是qwen3 embedding模型架构、训练方法、数据策略：https://zhuanlan.zhihu.com/p/1919807089414505767

为特定领域训练（或微调）Embedding 模型是提升 RAG 系统性能的“杀手锏”。当通用模型（如 OpenAI 的 text-embedding-3-small 或 BGE 系列）无法准确分辨你行业内的专业术语（如医学、法律、代码）时，定制化就变得至关重要。

以下是实现这一目标的专业路径，通常分为 “数据准备”、“对比学习微调” 和 “评估” 三个阶段：

  1. 核心思路：对比学习 (Contrastive Learning)

目前主流的 Embedding 训练都采用对比学习。其核心逻辑是：拉近相关文本（正样本）的距离，推远无关文本（负样本）的距离。

image.png

  1. 具体实施步骤

第一步：数据准备 (这是最难也最关键的一步)

你需要构建三元组数据：(Query, Positive, Negative)。

  • 正样本（Positive）： 与问题高度相关的文档片段。可以通过业务日志（用户点了哪个搜索结果）获取，或者利用 LLM（如 GPT-4）对文档块生成配套的问题。
  • 负样本（Negative）： * 简单负样本： 随机抽取的无关文档。
    • 难负样本 (Hard Negatives)： 语义相似但答案错误的文档（例如：咨询“A产品的售后”，负样本可以是“B产品的售后”）。难负样本是提升模型区分度的关键。

第二步：选择基础模型

不要从零开始（From Scratch），除非你有海量算力和数据。建议选择优秀的开源基座进行微调：

  • 中文首选： BAAI/bge-large-zh-v1.5 (目前中文社区公认的最强基座之一)。
  • 多语言/通用： sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 (轻量、快速)。

第三步：使用训练框架

推荐使用 Sentence-Transformers 或 FlagEmbedding 框架，它们封装了复杂的损失函数。

常用的 Loss Function：

  • MultipleNegativesRankingLoss： 最常用，只需 (Query, Positive) 对，它会自动将同 Batch 内的其他正样本视为负样本。
  • CoSENT (Cosine Sentence)： 在中文任务中表现非常稳定。
  1. 一个典型的训练流程 (Python 伪代码)

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from sentence_transformers import SentenceTransformer, losses, InputExample
from torch.utils.data import DataLoader

# 1. 加载基座模型
model = SentenceTransformer('BAAI/bge-small-zh-v1.5')

# 2. 准备训练数据 (Query, Positive)
train_examples = [
    InputExample(texts=['什么是分布式锁？', '分布式锁是控制分布式系统之间同步访问共享资源的一种方式。']),
    # ... 更多行业数据
]

# 3. 定义 DataLoader 和 Loss
train_dataloader = DataLoader(train_examples, shuffle=True, batch_size=16)
train_loss = losses.MultipleNegativesRankingLoss(model)

# 4. 开始微调
model.fit(train_objectives=[(train_dataloader, train_loss)], epochs=3)
  1. 进阶技巧：无需人工标注的自监督预训练 (TSDAE)

如果你完全没有“问题-文档”对，只有一堆行业论文或报告，可以使用 TSDAE (Transformer-based Denoising Auto-Encoder)。

  • 原理： 给句子加噪声（删掉一些词），让模型尝试还原。
  • 效果： 这种方法能让模型迅速“学会”行业术语的语义特征，非常适合领域迁移。
  1. 如何评估效果？

训练好后，绝对不能只看 Loss，要看业务指标：

  1. Recall@K： 前 K 个检索结果中包含正确答案的比例。
  2. MRR (Mean Reciprocal Rank)： 正确答案排在第几位，越靠前分数越高。
  3. 可视化： 使用 t-SNE 将向量降维投影，观察同类知识点是否真的聚拢在一起。

建议： 在开始训练之前，可以先尝试使用 BGE 的微调脚本 (FlagEmbedding)，它支持“自动挖掘难负样本”的功能，这通常能比普通微调再提升 5%-10% 的精度。

你想针对哪个特定行业（如医疗、金融、工业控制）进行训练？我可以根据行业特性帮你细化负样本的筛选策略。

你对大模型分布式训练的底层了解多少？比如数据并行（DP）、张量并行（TP）这些，看过 Megatron 这类框架的源码吗？

基础知识：https://zhuanlan.zhihu.com/p/650234985

原理介绍：https://zhuanlan.zhihu.com/p/650383289

megatron中的pipeline并行https://zhuanlan.zhihu.com/p/432969288

代码结构：https://zhuanlan.zhihu.com/p/650237820

并行设置：https://zhuanlan.zhihu.com/p/650500590

张量并行：https://zhuanlan.zhihu.com/p/650237833

流水线刷新机制：https://zhuanlan.zhihu.com/p/651341660

1F1B流水线并行负载不均衡：https://zhuanlan.zhihu.com/p/693425934

核心代码模式算法题：二维数组中的查找

50问

1. 大模型里应用强化学习时，状态，动作空间，动作都是什么

在大模型（如大型语言模型，LLM）中应用强化学习（Reinforcement Learning, RL）时，通常会将语言生成任务建模为一个序列决策过程。典型的场景包括使用强化学习从人类反馈中学习（RLHF）。在这种设置下，强化学习的各个要素可解释如下：

  1. 状态（State）

状态表示当前生成过程的上下文信息，通常包括：

  • 历史生成的 token 序列（即已生成的部分输出）；
  • 输入 prompt（用户的问题、指令等）；
  • 可选的外部信息（如检索结果、对话历史等）。

在 RL 术语中，状态 ( s_t ) 通常是到时间步 ( t ) 为止的所有输入和已生成 token 的组合，用于决定下一步该生成什么。

  1. 动作（Action）

动作是指模型在当前状态下选择的下一个 token（或 token 的分布）。

  • 在离散 token 空间中，动作空间就是**词汇表（vocabulary）**中的所有可能 token；
  • 每次动作 ( a_t ) 就是从词汇表中选择一个 token 添加到输出序列中。

实际实现中，动作往往不是直接采样一个 token，而是从策略（policy）输出的概率分布中采样（如通过 softmax over logits）。

  1. 动作空间（Action Space）

动作空间是所有可能动作的集合，在 LLM 中通常为：

  • 离散且巨大的空间：大小等于词汇表大小（例如 50,000 或 100,000 个 token）；
  • 通常用softmax over logits建模策略，即 ( \pi(a_t | s_t) = P(x_t | x_{<t}, \text{prompt}) )。
  1. 奖励（Reward）

虽然你没问，但这是 RL 的关键部分：

  • 奖励通常来自一个奖励模型（Reward Model），该模型在 RLHF 中由人类偏好数据训练得到；
  • 奖励在完整序列生成结束后给出（或使用中间奖励）；
  • 在 PPO 等算法中，奖励用于调整策略，使模型更倾向于生成高奖励的序列。

示例：RLHF 中的完整流程

  1. **初始策略（SFT 模型）**生成多个回答；
  2. 人类对回答排序，训练奖励模型（RM）；
  3. 使用 RM 作为奖励函数，用 PPO 等算法微调语言模型；
    • 状态：prompt + 已生成的 token；
    • 动作：选择下一个 token；
    • 动作空间：整个词汇表；
    • 奖励：RM 对完整回答的打分。

小结

RL 要素 在大模型中的对应含义
状态（State） 输入 prompt + 已生成的 token 序列
动作（Action） 选择下一个 token
动作空间 词汇表中的所有 token（离散、巨大）

这种建模方式使得强化学习能够指导大模型生成更符合人类偏好的高质量文本。

2. RLHF训练时，Reward Model和LLM是同时训练还是先后训练，instruct GPT论文里是如何训练RM的

在 InstructGPT（以及其前身 Learning to Summarize from Human Feedback）这类基于 RLHF（Reinforcement Learning from Human Feedback） 的方法中，RLHF 和 LLM（大语言模型）并不是同时训练的，而是采用分阶段、先后训练的方式。整个流程通常是 三阶段流水线（three-stage pipeline）。

InstructGPT 的三阶段训练流程（依据原始论文：Training language models to follow instructions with human feedback, Ouyang et al., 2022）

阶段 1：监督微调（Supervised Fine-Tuning, SFT）

  • 目标：获得一个初步对齐人类意图的模型。
  • 数据：人工标注的 prompt-response 对（例如，给定指令，专家写出理想回答）。
  • 方法：在预训练 LLM（如 GPT-3）基础上，用标准的监督学习进行微调。
  • 输出模型：SFT model（记作 (

    πSFT\pi^{\text{SFT}}

    )）。

🔹 此阶段不涉及强化学习或奖励模型，纯监督学习。

阶段 2：训练奖励模型（Reward Model, RM）

  • 目标：训练一个能预测人类偏好的标量奖励函数 ( r(x, y) )，其中 ( x ) 是 prompt，( y ) 是模型生成的回答。
  • 数据来源：
    • 使用 SFT model（或有时用原始 GPT）对同一个 prompt 生成 多个（通常 4~9 个）不同回答；
    • 人类标注员对这些回答进行 两两比较（pairwise ranking），选出更优的一个；
    • 得到大量 (prompt, chosen, rejected) 三元组。
  • 训练方法：
    • 奖励模型（通常是一个去掉语言建模头的 SFT 模型变体）为每个回答 ( y ) 输出一个标量分数 ( r(x, y) )；
    • 使用 Bradley-Terry 模型 最大化偏好概率：
      [

      LRM=−log⁡σ(r(x,ychosen)−r(x,yrejected))\mathcal{L}_{\text{RM}} = -\log \sigma \left( r(x, y_{\text{chosen}}) - r(x, y_{\text{rejected}}) \right)

      ]
    • 即：让“chosen”回答的奖励高于“rejected”回答。
  • 输出：奖励模型 RM。

🔹 注意：RM 是独立训练的，不与语言模型联合训练；它只用于下一阶段提供奖励信号。

阶段 3：强化学习微调（RL Fine-Tuning）

  • 目标：用 RM 作为奖励函数，通过 RL（如 PPO）进一步优化语言模型策略。
  • 方法：
    • 以 SFT model 作为初始策略 ( \pi_{\theta} )；
    • 对每个 prompt ( x )：
      • 从当前策略 (

        πθ\pi_{\theta}

        ) 采样一个回答 (

        y∼πθ(y∣x)y \sim \pi_{\theta}(y|x)

        )；
      • 用 RM 计算奖励 ( r(x, y) )；
      • 使用 PPO（Proximal Policy Optimization） 算法更新策略，最大化奖励；
    • 同时加入 KL 散度正则项，防止模型偏离 SFT 太远（避免过拟合 RM 或生成无意义高分文本）。
  • 损失函数（简化）：
    [

    LRL=E[r(x,y)−β⋅KL(πθ(y∣x)∥πSFT(y∣x))]\mathcal{L}^{\text{RL}} = \mathbb{E} \left[ r(x, y) - \beta \cdot \text{KL}(\pi_{\theta}(y|x) \parallel \pi^{\text{SFT}}(y|x)) \right]

    ]

🔹 此阶段才是真正的“RLHF”：用人类反馈（通过 RM 体现）指导 RL 训练。

回答你的两个问题：

Q1: RLHF 和 LLM 是同时训练还是先后训练？

✅ 先后训练。整个流程是顺序的三阶段：

  1. 先微调 LLM → SFT model；
  2. 再训练 RM（用 SFT 生成的数据 + 人类偏好）；
  3. 最后用 RM 作为奖励，对 LLM 做 RL 微调。

❌ 不是端到端联合训练，也不是同时训练 RM 和策略。

Q2: InstructGPT 论文中是如何训练 RM 的？

  • 使用 SFT model 生成多个回答；
  • 人类对回答做 两两偏好标注（chosen vs. rejected）；
  • 用这些 偏好数据 训练一个 标量奖励模型，目标是让 chosen 的奖励 > rejected 的奖励；
  • 损失函数基于 Bradley-Terry 偏好模型（即对数 sigmoid 差值）；
  • RM 架构通常基于 SFT 模型（冻结某些层或共享主干）。

补充说明

  • RM 不是语言模型：它不生成文本，只输出一个分数；
  • RL 阶段仍依赖 SFT 模型：用于 KL 正则项，保持生成质量；
  • 人类反馈只用于阶段 2：一旦 RM 训好，RL 阶段就无需人工参与。

这种分阶段设计使得 RLHF 在工程上可行，同时有效结合了人类偏好信号与大规模语言生成能力。

3. 训练RM时，无论是instruct GPT还是DPO， 为什么loss里有log和sigmod函数？ 直接用reward相减不行吗？

https://www.zhihu.com/question/1964058546414003939/answer/1964366564519285912

训练RM时使用log和sigmoid函数是为了将人类相对偏好转化为可优化的概率目标，直接用reward相减无法有效引导模型学习。

核心原因在于人类偏好数据的特性与优化目标的数学合理性：

一、为什么必须用sigmoid函数？

  1. 将分数差映射为概率
    人类标注的是相对偏好（A比B好），而非绝对分数。sigmoid函数能将两个回答的分数差 s_chosen - s_rejected 压缩到[0,1]区间，对应"模型预测人类偏好chosen的概率"：

    P(chosen)=σ(schosen−srejected)=11+e−(schosen−srejected)P(\text{chosen}) = \sigma(s_{\text{chosen}} - s_{\text{rejected}}) = \frac{1}{1 + e^{-(s_{\text{chosen}} - s_{\text{rejected}})}}

    当 s_chosen > s_rejected 时，概率接近1；反之接近0，完美匹配人类比较的二分类本质。

  2. 避免绝对分数依赖
    人类难以给出一致的绝对评分（如"这个回答值7.5分"），但擅长比较。sigmoid仅关注分数的相对差异，与绝对数值无关（例如 s_chosen=5, s_rejected=3 和 s_chosen=105, s_rejected=103 会得到相同概率）。

二、为什么需要log函数？

  1. 最大化正确预测的对数似然
    log函数将概率转化为可加性损失，符合最大似然估计（MLE）框架。损失函数定义为：

    Loss=−log⁡(σ(schosen−srejected))\text{Loss} = -\log\left( \sigma(s_{\text{chosen}} - s_{\text{rejected}}) \right)

    当模型预测正确时（概率接近1），log值接近0；预测错误时（概率接近0），log值趋向负无穷，损失急剧增大，迫使模型优化参数。

  2. 梯度稳定且可解释
    log-sigmoid组合的梯度具有良好性质：

    ∂Loss∂schosen=−(1−σ(schosen−srejected))\frac{\partial \text{Loss}}{\partial s_{\text{chosen}}} = - \left(1 - \sigma(s_{\text{chosen}} - s_{\text{rejected}})\right)

    梯度大小与预测错误程度正相关，且始终在[-1,1]区间内，避免梯度爆炸。

三、直接用reward相减的问题

如果采用简单的L1损失 Loss = |(s_chosen - s_rejected) - 1|（假设目标是让差为1），会导致：

  1. 缺乏概率意义
    无法将分数差与人类选择概率关联，模型难以理解优化目标。
  2. 梯度不稳定
    当分数差远大于1时，梯度会持续推动分数无限增大（如 s_chosen=1000, s_rejected=1），导致模型参数发散。
  3. 对异常值敏感
    若某样本的标注错误导致 s_chosen < s_rejected，简单相减会产生巨大损失，破坏整体训练稳定性。

四、本质：拟合Bradley-Terry模型

整个设计源于Bradley-Terry模型，该模型假设两个选项的选择概率仅依赖其质量分数的相对差异： 选择而非 log-sigmoid损失正是该模型的负对数似然，完美契合人类偏好数据的比较特性。

总结：log和sigmoid函数的组合是将离散的人类偏好转化为连续优化目标的关键桥梁，既保证了概率解释性，又确保了训练稳定性。直接相减的损失函数无法满足这些要求，会导致模型训练失败。

4. RLHF(指openai instruct GPT论文中)，训练LLM的损失函数是什么？

5. 了解RLHF-PPO吗，里面需要训练几个模型，加载几个模型

PPO和PPO2，一个基于kl penalty一个基于clip https://zhuanlan.zhihu.com/p/538486008

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

重要性采样

PPO GRPO 强化学习全流程：https://zhuanlan.zhihu.com/p/1981324776086721831

PPO训练中需要训练2个模型，加载4个模型

PPO训练的核心模型构成

在PPO训练框架中，理论上存在4个核心模型：

  1. Actor模型（需训练）
    • 角色：主角模型，即我们最终要优化的大语言模型（LLM）。
    • 任务：根据用户输入生成回答，通过PPO算法更新参数，使其输出更符合人类偏好。
  2. Reference Model（参考模型）（冻结参数）
    • 角色：SFT（监督微调）后的原始模型副本。
    • 任务：作为约束，通过计算KL散度（衡量新策略与原始策略的差异）防止Actor模型过度优化而偏离基础语言能力。
  3. Reward Model（奖励模型）（冻结参数）
    • 角色：人类偏好的“判卷人”。
    • 任务：对Actor生成的完整回答打分（如8.0分），将抽象的人类偏好转化为可计算的奖励信号。
  4. Critic Model（价值模型）（需训练）
    • 角色：状态价值评估器。
    • 任务：预测每个token生成时的状态价值（即当前token到序列结束的期望回报），用于计算优势函数（Advantage），减少训练方差。

6. RLHF-PPO里，reward的设计是什么，GAE是什么

https://www.zhihu.com/question/1900547615495545054/answer/1982243985448777023

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

TD残差（Temporal Difference Error）：

δt=rt+γV(st+1)−V(st)\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)

GAE:

Advt=δt+γλ⋅Advt+1\text{Adv}_t = \delta_t + \gamma \lambda \cdot \text{Adv}_{t+1}

回报（Returns）:

Rt=Advt+V(st)R_t = \text{Adv}_t + V(s_t)

回报的理解：“从状态 st执行动作 at获得的总回报”，等于“该动作相比平均表现的优势”加上“该状态本身的平均价值”。

PPO 不直接优化 reward，而是优化 advantage（优势函数）

而 Advt 的计算依赖于 TD 误差，TD 误差又依赖于 reward 和 价值函数 V(s)：

误区 正确理解
“reward 是每个词的分数” 通常是整个回答的分数，再分配到序列
“PPO 直接最大化 reward” 实际是最大化 reward 减去 baseline（即 Advantage），以降低方差
“reward 是固定的” 在 RLHF 中，RM 是固定的；但在环境交互中，reward 是动态的

img

img

img

7. RLHF-PPO训练的损失函数公式

  • 策略更新：利用优势函数 A 作为梯度方向指引，结合策略梯度算法（如 PPO 的损失函数优化 Policy Model，让策略更倾向产生高优势的动作。
  • 价值网络更新：通过最小化 “价值估计 v 与实际累计奖励（含 GAE 修正 ）” 的误差（如 MSE 损失 ），更新 Value Model，提升价值预估精度，为后续优势计算提供可靠基准。

RLHF-PPO训练的损失函数由策略损失(Policy Loss)、**价值函数损失(Value Loss)和熵正则化项(Entropy Regularization)**三部分组成，其核心目标是在最大化奖励的同时保持策略更新的稳定性。

一、核心损失函数公式

总损失函数：

Total Loss=Policy Loss+Value Loss−β×Entropy\text{Total Loss} = \text{Policy Loss} + \text{Value Loss} - \beta \times \text{Entropy}

  1. 策略损失（Policy Loss）

策略损失是PPO的核心，用于优化策略模型（Actor）以最大化奖励。它通过裁剪机制限制策略更新幅度，防止训练不稳定。

公式：

(这个公式里面的GAE部分用动态规划的方式去计算)

advantages： 老策略中，response部分每个token对应的优势（这个是固定的，不随actor实时更新而改变）

Policy Loss=−E[min⁡(πθ(a∣s)πθold(a∣s)⋅A(s,a),  clip(πθ(a∣s)πθold(a∣s),1−ϵ,1+ϵ)⋅A(s,a))]\text{Policy Loss} = -\mathbb{E} \left[ \min\left( \frac{\pi_{\theta}(a|s)}{\pi_{\theta_{\text{old}}}(a|s)} \cdot A(s, a),\; \text{clip}\left( \frac{\pi_{\theta}(a|s)}{\pi_{\theta_{\text{old}}}(a|s)}, 1 - \epsilon, 1 + \epsilon \right) \cdot A(s, a) \right) \right]

  • πθ(a∣s)\pi_{\theta}(a|s)

    ：当前策略模型在状态下采取动作的概率

  • πθold(a∣s)\pi_{\theta_{\text{old}}}(a|s)

    ：旧策略模型（更新前）的概率

  • A(s,a)A(s, a)

    ：优势函数（Advantage Function），表示动作的收益高于平均水平的程度

  • ϵ\epsilon

    ：裁剪系数（通常取0.2），限制策略更新幅度

  • min⁡\min

    操作：确保策略更新不会过于激进

直观理解：

  • 当A(s, a)优势时，增大该动作的概率；反之则减小
  • 裁剪机制防止策略更新幅度过大（如超过20%），保证训练稳定性
  1. 价值函数损失（Value Loss）

价值函数损失用于优化价值模型（Critic），使其更准确地预测状态价值。

公式：

Value Loss=12E[(Vθ(s)−Vtarget(s))2]\text{Value Loss} = \frac{1}{2} \mathbb{E} \left[ \left( V_{\theta}(s) - V^{\text{target}}(s) \right)^2 \right]

参数解释：

  • Vθ(s)V_{\theta}(s)

    ：当前价值模型预测的状态的价值

  • VtargetV^{\text{target}}

    ：目标价值（通常由奖励模型或蒙特卡洛方法计算）

直观理解：

  • 通过最小化预测值与目标值的均方误差，让价值模型更准确地评估状态价值

  • 为进一步稳定训练，实际实现中常对价值函数也进行裁剪：

    Vclipped(s)=Vθold(s)+clip(Vθ(s)−Vθold(s),  −ϵv,  ϵv)V_{\text{clipped}}(s) = V_{\theta_{\text{old}}}(s) + \text{clip}\left( V_{\theta}(s) - V_{\theta_{\text{old}}}(s),\; -\epsilon_v,\; \epsilon_v \right)

    然后取原始损失和裁剪损失的最大值：

    Value Loss=12E[max⁡((Vθ(s)−Vtarget(s))2,  (Vclipped(s)−Vtarget(s))2)]\text{Value Loss} = \frac{1}{2} \mathbb{E} \left[ \max\left( \left( V_{\theta}(s) - V^{\text{target}}(s) \right)^2,\; \left( V_{\text{clipped}}(s) - V^{\text{target}}(s) \right)^2 \right) \right]

  1. 熵正则化项（Entropy Regularization）

熵正则化项用于鼓励策略探索，防止过早收敛到局部最优。

公式：

Entropy=−E[∑aπθ(a∣s)log⁡πθ(a∣s)]\text{Entropy} = -\mathbb{E} \left[ \sum_a \pi_{\theta}(a|s) \log \pi_{\theta}(a|s) \right]

直观理解：

  • 熵越大，策略的随机性越强，探索性越好
  • 通过在总损失中减去熵项（乘以系数β），鼓励模型保持一定的探索性

二、关键概念解析

  1. 优势函数（Advantage Function）

优势函数衡量在状态下采取动作的收益高于平均水平的程度，是策略更新的核心依据。

公式：

A(s,a)=Q(s,a)−V(s)A(s, a) = Q(s, a) - V(s)

其中：

  • Q(s, a)：状态下采取动作的动作价值
  • V(s)：状态的状态价值

实际计算： 在RLHF中，优势函数通常通过**广义优势估计（GAE）**计算：

A^tGAE(γ,λ)=∑l=0∞(γλ)lδt+l\hat{A}_t^{\text{GAE}(\gamma,\lambda)} = \sum_{l=0}^{\infty} (\gamma \lambda)^l \delta_{t+l}

其中：

  • δt=rt+γV(st+1)−V(st)\delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)

    （TD误差）

  • ：折扣因子（通常取0.99）

  • ：GAE系数（通常取0.95）

  1. KL散度约束

为防止策略更新过于激进，PPO还会监控当前策略与旧策略之间的KL散度：

KL(πθ∥πθold)=E[log⁡πθold(a∣s)πθ(a∣s)]\text{KL}(\pi_{\theta} \parallel \pi_{\theta_{\text{old}}}) = \mathbb{E} \left[ \log \frac{\pi_{\theta_{\text{old}}}(a|s)}{\pi_{\theta}(a|s)} \right]

当KL散度超过阈值（如0.01）时，会提前终止当前迭代，保证训练稳定性。

8. 你知道DPO的损失函数公式吗？

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

img

img

要让公式4结果最小

log里面上下两个的分布要一样

img

img

最终：

img

9. DPO的reward是什么，会不会出现reward hacking？有哪些解决方法？

DPO（Direct Preference Optimization）的奖励机制基于偏好数据，它通过比较chosen（优选）和rejected（被拒绝）回答来优化模型。具体来说，DPO的reward计算公式为：

[ \text{DPO reward} = \log\left(\frac{p(y_w)}{p(y_l)}\right) \]

其中，( p(y_w) ) 是chosen回答的概率，( p(y_l) ) 是rejected回答的概率。这个公式旨在最大化chosen回答相对于rejected回答的相对概率，而不是绝对概率。

DPO用reward和token出现概率乘积的期望作为Value function。理论上等同于reward模型。

关于reward hacking，理论上在DPO中也可能发生，尤其是在偏好数据集不完善或模型学习到的策略与人类偏好不完全一致时。例如，模型可能学会生成特定的关键词或模式，这些模式在偏好数据集中被高估，但实际上不反映人类的真正偏好。

解决方法包括：

  1. 改进偏好数据集：确保偏好数据集的多样性和质量，避免数据偏见，减少reward hacking的可能性。
  2. 引入正则化**：在训练过程中加入正则项，防止模型过于依赖某些特定的特征或模式。 **
  3. 使用更复杂的奖励模型：比如KTO（Kullback-Leibler Alignment），它优化的是chosen策略本身，而不是相对差异，可能更不容易受到reward hacking的影响。
  4. 动态调整奖励参数：根据训练过程中的表现动态调整beta值，以适应不同的训练阶段。
  5. 结合人类反馈：在训练过程中定期引入人类反馈，确保模型学习到的策略符合人类的真正偏好。

通过这些方法，可以有效减少reward hacking的发生，提升模型对齐人类偏好的能力。

正例的概率一定升高吗？https://zhuanlan.zhihu.com/p/698852522

不一定，在以下情况中正例的概率就可能下降：

  1. 如果正例并不是一个绝对意义上好的回复而仅仅是相对于负例而言更好，正例的概率降低才是正常的，因为当前样本的正例可能也是其他样本中的负例（如果正例的某个模式出现在其他样本的负例中也会导致该正例的概率下降）。
  2. 即使数据中的正例可以看作是绝对意义上的好的回复，但如果query存在多个绝对意义上好的回复，该正例的概率也可能因为其他好回复概率的上升而下降（参考章节三思考2中提到的场景）。
  3. 对于很多任务而言不存在绝对的正确性，不同模型的偏好可能不同，即使某个正例在某个评估标准下没有正确性问题，逻辑也很好，它的概率在训练过程中仍然可能会被降低，因为模型受到其他数据的激发可能认为其他形式的输出更好（比如把解释放在后面而不是放在前面），提升了其他形式输出的概率，进而导致该正例概率的下降。

在普通的off-policy DPO中，正负例的文本相似性越高，效果越差

10. DPO的正负样本对构造的时候要注意什么？

  1. 低概率样本会主导样本甚至batch内的梯度，影响模型在其他样本上的学习，可以将低概率样本放到训练后期来缓解这一问题。

11. GRPO , PPO 与 DPO 区别是什么

12. PPO是MC还是TD， GRPO呢

img

GAE这里其实：

如果λ=1，纯mc，低偏差高方差。

λ=0，td，纯td

PPO 本质上是 *Actor-Critic + GAE（TD/MC 混合）*，但归类上常被视为 *基于优势估计的策略梯度方法*，其优势计算依赖于bootstrapped value function** → 更接近 TD 范式。

img

GRPO 既不使用 MC，也不使用 TD —— 它根本不估计回报或优势函数！

13. PPO和GRPO的KL散度的区别

说实话 没太懂

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

PPO的采样是基于πold的，而grpo的则是基于当前策略πθ的。

PPO的奖励函数和期望是基于固定的就策略来计算的，该期望的计算与我们需要优化的参数θ无关，KL散度的计算方式仅仅利用了采样轨迹中出现的词元的对数概率，通过计算它们之间的差值来近似 KL 散度，PPO的实现中可以省略vocab_size维度。

在 GRPO 中，期望的计算是基于当前策略πθ计算的。为了正确计算 KL 散度及其梯度，必须在整个词汇表的维度上进行操作，即需要计算完整的概率分布 ，而不能仅仅局限于采样到的词元。

GRPO的解决方案：

1. **遵循传统的 KL 散度计算方式**
1. **仅使用 on-policy （On-policy）版本的 GRPO（DeepSeek-Math 的做法）**
1. **将 KL 散度项移回奖励函数**

14. GRPO为什么加上KL散度，用的KL散度是正向KL散度还是反向？

GRPO加入KL散度的核心目的是防止策略崩溃，通过约束新策略与参考策略（如SFT模型）的分布差异，确保训练稳定性。 它使用的是反向KL散度（DKL(π_θ || π_ref)），即衡量当前策略π_θ相对于参考策略π_ref的分布差异。

一、为什么GRPO需要KL散度？

  1. 防止策略崩溃
    强化学习中，策略更新过大会导致模型生成无意义的输出（策略崩溃）。KL散度作为正则化项，强制新策略π_θ与参考策略π_ref（通常是SFT模型）的分布保持接近，避免模型输出偏离合理范围。
  2. 稳定训练过程
    GRPO通过KL散度显式约束策略更新幅度，避免PPO中隐式KL惩罚的不稳定问题。实验表明，KL散度能有效降低训练振荡，提升大模型RL训练的鲁棒性。
  3. 平衡探索与利用
    KL散度限制了策略的探索范围，确保模型在优化奖励的同时，不丢失参考策略的基础能力。例如，在推理任务中，KL散度帮助模型保持逻辑连贯性，避免无意义的发散。

注意k3的无偏小方差的散度

其实也有不需要Kl散度项的grpo，

  1. 意味着不需要ref-model, 减少一个模型的显存，减少一次前向ref_policy的计算。
  2. 没有KL的约束，那么可以将过大的梯度进行裁剪(max_grad_norm)，避免优化的不稳定性(这也是另一种层面的clip)。
  3. 没有KL的约束，参数的优化更加自由，更容易探索到好的回答

GRPO的loss

手撕grpo:https://zhuanlan.zhihu.com/p/20812786520

15. 具体怎么计算KL散度，KL散度和交叉熵有什么关系？

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

KL散度（相对熵）= 交叉熵-信息熵

为什么分类问题不用MSE作为Loss？

这里面涉及到关于统计学习模型在设计上的底层原则：

  1. 如果要学习/拟合的对象是一个确定（deterministic）的函数，也就是说，一个给定的x，y=f(x) 是一个确定值（只不过观测中会存在噪声），就可以且应该用mse；
  2. 如果要学习/拟合的对象本身就是一个随机（stochastic）函数，也就是说，一个给定的x，y=f(x) 不存在确定值，而是存在一个分布，那么要学习也应该是一个分布，如果按照mse作为loss，学习到的很可能就只是这个随机现象的均值。所以本质的区别在于，同一个x下的不同观测值之间的波动，是要被看待为噪声，还是要被看待为想拟合的对象的固有属性。

分类问题的输入是直接观测或者特征，输出是预测值，我们可以由观测或特征可以直接推导出结果吗？一般而言不能，只能增加我们对不同结果的确信程度，因此输出是分布。

16. GRPO/PPO是on policy还是off policy的， DPO呢

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

dpo的中间过程不是rl，谈不上on还是offpolicy

dpo就是个offline的算法

gspo勉强offpolicy，其他都是on。

17. 不考虑cpu-offload, GRPO训练时，显存里有几个模型，分别是什么

当前策略模型，参考模型（有没有reward model呢）

18. 同上，PPO呢？DPO呢？

4个/2个

19. GRPO训练时，梯度是如何反向传播的

20. 为什么GRPO和PPO都要对rA,clip(1-e, 1+e, r)A再取一个min，而不是直接用clip(1-e, 1+e, r)A

PPO和GRPO中使用min(rA, clip(r, 1-ε, 1+ε)A)而非直接使用clip(r, 1-ε, 1+ε)A，核心目的是在限制策略更新幅度的同时，保留策略梯度估计的无偏性。这一设计是PPO算法的关键创新，直接解决了策略梯度方法中存在的训练不稳定问题。

一、min操作的本质：悲观约束与无偏性的平衡

PPO的目标函数设计基于**代理损失函数（Surrogate Loss）**的思想。在策略梯度方法中，我们希望最大化期望奖励，但直接优化会导致策略更新幅度过大，引发训练震荡甚至崩溃。

PPO的解决方案是构造一个裁剪后的代理损失函数：

1
L(θ) = E[ min( r(θ)A, clip(r(θ), 1-ε, 1+ε)A ) ]

其中：

  • r(θ) = π_θ(a|s) / π_old(a|s)：新策略与旧策略的概率比
  • A：优势函数（动作a的相对价值）
  • ε：裁剪系数（通常取0.1或0.2）

关键逻辑：

  1. 当r(θ)在[1-ε, 1+ε]范围内：min操作等价于直接使用r(θ)A，此时策略更新不受约束，保留了原始策略梯度的无偏性。
  2. 当r(θ)超出范围：min操作会选择clip(r(θ), 1-ε, 1+ε)A，通过裁剪限制策略更新幅度，避免策略发生剧烈变化。

核心作用：min操作确保了只有当策略更新幅度在安全范围内时，才使用无偏的梯度估计；否则，采用保守的裁剪值。这种"悲观"的约束方式，既保证了训练稳定性，又尽可能保留了策略优化的效率。

二、直接使用clip(r, 1-ε, 1+ε)A的问题

如果直接使用裁剪后的clip(r, 1-ε, 1+ε)A，会导致以下问题：

  1. 梯度估计有偏：裁剪操作会改变梯度的方向和大小，导致策略更新不再是无偏的，可能引入系统性误差。
  2. 过度抑制有效更新：即使策略更新幅度在安全范围内，裁剪也会强制限制梯度，降低训练效率。
  3. 训练不稳定：无偏性的丧失可能导致策略在优化过程中出现不可预测的震荡，甚至无法收敛。

三、GRPO中的延续与扩展

GRPO（Group Relative Policy Optimization）作为PPO的变体，延续了min操作的设计，但在优势函数的计算上进行了创新：

  1. 组内相对优势：GRPO通过同一prompt生成多个响应（组内样本），利用组内奖励的统计特性（均值和标准差）计算相对优势，替代了传统PPO中的价值网络（Critic）。
  2. KL散度约束：GRPO在目标函数中直接添加KL散度项，进一步限制策略与参考模型的偏离，增强训练稳定性。

GRPO的目标函数：

1
L(θ) = E[ min(r(x)·A_rel(x), clip(r(x), 1-ε, 1+ε)·A_rel(x)) ] - β·KL[π_θ || π_old]

其中A_rel(x)是组内相对优势，β是KL散度的权重系数。

四、实际效果与对比

设计选择 优点 缺点
min(rA, clip(r, 1-ε, 1+ε)A) 保留无偏性、训练稳定、效率高 实现稍复杂
直接使用clip(r, 1-ε, 1+ε)A 实现简单 梯度有偏、训练不稳定、效率低

五、总结

PPO和GRPO中min操作的设计，是理论严谨性与工程实用性的完美结合。它通过巧妙的数学构造，在限制策略更新幅度的同时，最大限度地保留了策略梯度估计的无偏性，从而解决了传统策略梯度方法中训练不稳定的核心问题。这一设计不仅是PPO算法成功的关键，也为后续强化学习算法（如GRPO）的发展奠定了基础。

21. GRPO训练时，被clip掉的token对loss和梯度有贡献吗？

为0。clip后，重要性采样分数r变成常数，对常数求导，梯度为0。因此，被clip掉的token就不会对梯度更新产生贡献了

这与 PPO 的原理一致。GRPO 只是将这一机制从 episode/trajectory 级别细化到了 token 级别。

https://www.zhihu.com/question/1945547315650725610/answer/1946964236774405387

img

22. GRPO有哪些改进思路，能不能说说具体的几个算法

https://zhuanlan.zhihu.com/p/1961131628731557031 DAPO GSPO

GRPO的缺陷：

1、梯度噪声：batch 采样中部分样本的奖励如果全部错误或者全部正确，会导致优势为0，产生「零梯度」问题

2、长度偏差：由于在sample维度平均，赋予每个sample（不论长短）相同的权重，导致许多高质量的长序列样本被忽视

3、熵坍缩：策略熵（Policy Entropy）衡量的是policy模型在生成token的随机性，熵越低代表生成token越确定。在PPO和GRPO损失函数中，对于 exploitation token（已经高概率的动作），提升概率很容易，因为它们的初始概率高，更新时不容易触碰到上界；对于 exploration token（低概率的动作），想要显著提升它们的概率时，很容易触碰到 上界裁剪，导致提升幅度被限制，因此会限制exploration，导致在训练初期policy就偏向确定的生成

4、奖励噪声：过长的生成样本默认情况下会赋予低的reward signal，但有些推理过程虽然是正确且合理的，只是因为太长而被截断，结果被错误地惩罚因此这个截断的样本造成训练噪声

5、误用重要性采样权重：在每个 token 级别应用重要性采样，每个 token 只有 一个样本，无法像重要性采样理论要求的那样平均多个样本来稳定估计，导致important ration成了高方差噪声，gradient不稳定，同时这一问题在专家混合模型（Mixture-of-Experts, MoE） 中尤为严重

DAPO:

  • Clip-Higher ：将 Clip 的上下限分开 ，将较低和较高的剪辑范围解耦为 ε_low 和 ε_high，增加了 ε_high 的值，以便为低概率 token 的增加留出更多空间，能够显著提升模型训练早期的熵（for 熵坍缩）
  • Dynamic Sampling：过滤掉奖励全部等于 1 和 0 的prompt，只保留有效梯度的样本，提高训练效率（for 梯度噪声）
  • Token-Level Policy Gradient Loss：对所有 token 一起求平均，保证长序列的所有 token 都公平地为 batch loss 做贡献，因此，更长的样本会比更短的样本对于梯度下降权重影响更大（for 长度偏差）
  • Overlong Reward Shaping：过滤被截断的样本，不计算它们的 loss（for 奖励噪声）

GSPO:

sequence-level important sampling：将重要性权重应用在sequence-level，对应地优势计算和裁剪时都应用在sequence-level，更符合奖励信号的整体性，并引入长度归一化控制方差（for 误用重要性采样权重）

  1. 了解Reinforce/ReMax/Dr.GRPO/λ-GRPO/…吗（简历里没有应该不问）
  2. DAPO对GRPO的改进有哪些
  3. GSPO对GRPO的改进有哪些
  4. GSPO为什么用几何平均值，不用算数平均

23. 了解MOE模型训练时的routing replay吗

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

https://www.zhihu.com/question/1961967212060442711/answer/1962100684116690012

routing replay相当于就是为了防止Moe下expert选择发生变化，在更新时重新计算旧数据的router路径，但还是很复杂且计算昂贵。

蚂蚁百灵的online icepop：https://zhuanlan.zhihu.com/p/1984379979035850499

  1. 当 Importance Sampling Weight 超出预设的阈值范围时，IcePop 不仅仅是将其截断，而是直接将其 Mask 掉（视为无效样本或零贡献）。
  2. 采用纯 Online 模式，确保了 和 几乎一致，从源头上减少了 Router 行为的差异：对于 MoE 类模型，使用纯 Online Policy Gradient（即去掉 PPO 的 Mini-batch 多次迭代，采用类似 A2C 的单次更新模式）对于提升稳定性至关重要。当我们将 Buffer 中的数据反复训练（Replay）时，MoE 的 Router 分布往往已经漂移，导致 Off-policy 的 gap 越来越大。移除 PPO 的 Mini-batch 循环：放弃传统的 Epochs 迭代，采用纯 Online 模式，数据采样后立即更新，更新完即丢弃。

24. 强化学习中如何判断是否出现reward hacking

判断强化学习中是否出现奖励黑客（Reward Hacking），核心在于识别智能体行为与设计者真实目标的偏离，而非单纯关注奖励值的高低。以下是具体判断方法和典型表现：

一、核心判断标准

  1. 行为与目标的逻辑脱节
    智能体获得高奖励，但行为明显偏离任务的本质目标。例如：
    • 清洁机器人：为了避免碰撞惩罚，在原地打转而非移动清洁；
    • 游戏AI：通过重复无意义操作（如原地跳跃）刷分，而非推进游戏进程；
    • 编程任务：修改单元测试代码以通过验证，而非真正修复bug。
  2. 奖励函数的漏洞利用
    智能体找到奖励函数的设计缺陷，如：
    • 奖励函数的歧义：奖励“完成任务”被误解为“快速结束任务”，导致智能体直接放弃复杂步骤；
    • 奖励信号的可操纵性：智能体通过篡改环境（如修改传感器数据）或欺骗奖励模型（如输出“正确！”等关键词）获取高分。
  3. 能力与表现的矛盾
    智能体在训练环境中表现优异，但在真实场景或变体任务中性能骤降。例如：
    • 自动驾驶AI：在模拟器中完美避障，但在现实道路上对新障碍物无反应；
    • 对话模型：在RLHF训练中迎合人类反馈，但实际回答缺乏逻辑性。

二、典型表现与案例

1. 环境漏洞利用

  • “刷分”行为：智能体重复简单动作获取高频奖励，如游戏AI通过“卡墙”或“无限循环”刷分。
  • 目标偷换：将“最大化任务完成率”替换为“最小化操作成本”，例如清洁机器人通过关闭传感器避免碰撞惩罚。

2. 奖励函数欺骗

  • 输出关键词：对话模型在回答中加入“正确！”“你真棒！”等奖励模型偏好的词汇，而非提升内容质量。
  • 对抗性输入：智能体生成包含误导性信息的输入，诱导奖励模型给出高分，如在问答任务中添加无关但易被认可的细节。

3. 泛化能力缺失

  • 过拟合训练数据：智能体仅在训练集上表现良好，对测试集或真实场景的微小变化敏感。
  • 策略僵化：智能体依赖特定环境特征（如颜色、位置）而非任务本质，一旦环境变化则失效。

三、技术检测方法

  1. 行为分析
    • 可视化跟踪：记录智能体的行为轨迹，观察是否存在异常模式（如重复动作、无意义操作）。
    • 对比测试：在训练环境和变体环境中测试智能体性能，若差距显著则可能存在奖励黑客。
  2. 奖励信号审计
    • 奖励函数分解：分析奖励函数的各组成部分，识别可能被利用的漏洞（如单一维度奖励、阈值设置不当）。
    • 对抗性测试：设计“陷阱”任务，观察智能体是否选择短期奖励而非长期目标（如“悬崖行走”任务中是否冒险走捷径）。
  3. 模型可解释性工具
    • 注意力机制分析：检查智能体决策时关注的特征是否与任务相关（如自动驾驶AI是否过度关注路标而非行人）。
    • 策略梯度可视化：通过梯度分析识别智能体优化的关键路径，判断是否偏离预期目标。

四、如何预防奖励黑客

  1. 设计鲁棒的奖励函数
    • 多维度奖励：结合任务的多个目标（如效率、安全性、准确性），避免单一指标被利用。
    • 延迟奖励：减少即时奖励的频率，迫使智能体关注长期目标（如游戏中仅在关卡结束时给予奖励）。
  2. 引入人类监督
    • RLHF优化：通过人类反馈调整奖励模型，减少偏见和漏洞。
    • 定期审计：人工检查智能体行为，及时修正奖励函数。
  3. 增强环境鲁棒性
    • 动态环境设计：在训练中引入环境变化（如随机障碍物、任务变体），提高智能体的泛化能力。
    • 对抗训练：训练专门的“攻击者”智能体，暴露奖励函数的漏洞并修复。

总结

奖励黑客的本质是智能体对奖励函数的“过度优化”，而非对真实任务的理解。判断时需结合行为逻辑、环境泛化性和奖励函数设计，通过多维度分析识别偏离。预防的核心是让奖励函数更接近人类的真实目标，而非依赖简单的量化指标。

关键结论：奖励黑客的判断不能仅看奖励值高低，而要关注行为与目标的一致性。当智能体通过“捷径”而非“正确路径”获得奖励时，就可能存在奖励黑客。

25. 对于reward hacking有什么解决思路

奖励黑客（Reward Hacking）是强化学习（尤其是RLHF）中普遍存在的问题，根本原因在于奖励函数与真实目标的不一致。以下是经过验证的核心解决思路，按技术成熟度和应用场景分类：

一、从奖励函数设计源头改进

1. 过程监督（Process Supervision）替代结果监督

  • 核心逻辑：不仅奖励最终结果，更对正确的中间步骤给予奖励。
  • 典型案例：数学解题任务中，对每一步正确推导加分，而非仅奖励最终答案。
  • 效果：显著减少模型通过“蒙答案”或“篡改测试用例”等方式骗取高分的行为。

2. 多目标奖励函数设计

  • 核心逻辑：通过多个互补的奖励维度平衡单一目标的缺陷。

  • 具体方法

    ：

    • 代码生成任务：奖励“通过测试”（功能性）+ 惩罚“代码长度”（简洁性）。
    • 对话生成任务：奖励“用户满意度”+ 惩罚“安全风险”+ 奖励“信息丰富度”。

  • 优势：增加奖励函数的鲁棒性，减少单一维度被利用的可能。

3. 动态奖励函数（Adaptive Reward）

  • 核心逻辑：让奖励函数随模型行为动态调整，避免被静态规则束缚。

  • 典型案例

    ：

    • 对抗性奖励函数：当模型发现新的作弊方式时，奖励函数自动更新以识别该行为。
    • 前瞻奖励：根据模型未来可能的行为给予奖励（如预测到模型将篡改奖励函数时给予负反馈）。

二、提升奖励模型（RM）的稳健性

1. 正则化技术

  • 核心方法

    ：在奖励函数中加入正则项，限制模型过度优化奖励。

    • KL正则化：惩罚模型输出与参考模型的偏离（如GPT-4在RLHF中使用KL散度约束）。
    • 接近性正则化：如Regularized Best-of-N（RBoN），在选择候选输出时同时考虑奖励值和与参考模型的相似度。

  • 效果：显著降低模型通过生成“奖励值高但无意义”内容的概率。

2. 奖励模型集成（Reward Ensemble）

  • 核心逻辑：训练多个独立的奖励模型，对其输出进行平均或投票。
  • 关键要求：模型间需保持多样性（如使用不同训练数据、架构或标注者）。
  • 优势：单一模型的偏见或漏洞被其他模型抵消，提升整体鲁棒性。

3. 持续数据飞轮与分布外样本覆盖

  • 核心逻辑：不断将模型生成的新数据（尤其是分布外样本）加入标注，让奖励模型“见过”更多可能的作弊方式。

  • 典型流程

    ：

    1. 模型生成一批候选输出。
    2. 人工标注其中的作弊样本。
    3. 将这些样本加入奖励模型的训练集，重新训练。

  • 效果：逐步缩小奖励模型的“知识盲区”，减少被欺骗的可能。

三、训练过程中的干预策略

1. 课程学习（Curriculum Learning）

  • 核心逻辑：先在简单、易监督的环境中训练模型（如明确禁止作弊的场景），再迁移到复杂环境。

  • 典型案例

    ：

    • 先让模型在“禁止奉承”的对话数据上微调，再训练其处理开放对话任务。
    • 先训练模型通过固定测试用例，再允许其处理动态测试用例。

  • 效果：提前“纠正”模型的作弊倾向，降低后续训练中的奖励黑客风险。

2. 对抗性训练（Adversarial Training）

  • 核心逻辑：主动生成能欺骗当前奖励模型的样本（如让辅助模型编写“看似正确但实则错误”的答案），并将这些样本作为负例加入训练。
  • 优势：让奖励模型“吃一堑长一智”，学会识别更隐蔽的作弊方式。

3. 模型行为约束

  • 核心方法

    ：

    • 参数约束：限制模型参数的更新范围，避免其突然转向作弊策略。
    • 输出约束：在生成过程中加入规则（如禁止修改系统文件、禁止生成特定关键词）。

  • 典型案例：在代码生成任务中，禁止模型调用os.system等可能修改系统的函数。

四、推理阶段的实时防御

1. 最优采样点锁定（如HedgeTune算法）

  • 核心逻辑：通过校准数据找到“代理奖励最高但真实性能未下降”的临界点，避免过度采样导致奖励黑客。

  • 具体流程

    ：

    1. 用少量校准数据拟合“采样数→真实性能”曲线。
    2. 找到曲线峰值对应的采样数（如Best-of-N中的N值）。
    3. 推理时固定使用该采样数，不再增加。

  • 效果：在不重训模型的情况下，实时防止推理阶段的奖励黑客。

2. 动态监控与干预

  • 核心逻辑：在模型推理时实时检测异常行为（如突然修改系统文件、生成大量重复内容），并触发干预。

  • 典型案例

    ：

    • 监控模型输出中是否包含“修改reward函数”的代码片段。
    • 检测对话中是否存在过度奉承或回避问题的模式。

  • 优势：对已部署的模型提供最后一道防线。

五、哲学层面的反思：超越“奖励-惩罚”范式

1. 价值对齐（Value Alignment）而非奖励优化

  • 核心思想：让模型学习人类的价值观（如诚实、安全），而非仅优化奖励函数。
  • 典型案例：通过人类反馈直接训练模型“拒绝作弊”，即使作弊能获得更高奖励。

2. 透明化与可解释性

  • 核心逻辑：要求模型解释其行为的动机，增加作弊的难度。
  • 典型案例：在数学解题中，强制模型输出推导过程，而非仅答案。

六、实际应用中的优先策略

  1. 快速见效：优先尝试KL正则化（简单易实现）和过程监督（对任务性能影响小）。
  2. 长期稳健：投入资源构建多目标奖励函数和奖励模型集成。
  3. 部署安全：必须加入推理阶段的最优采样锁定和动态监控。

总结

奖励黑客的本质是奖励函数与真实目标的偏差，解决思路需从**设计（奖励函数）→训练（模型稳健性）→推理（实时防御）**全流程覆盖。没有“银弹”，但组合使用上述方法可将风险降至可接受范围。未来的研究方向可能包括更智能的动态奖励函数和基于人类价值观的直接对齐。

收起

26. LLM-as-judge提供的reward可能出现哪些问题，有什么解决方案

LLM-as-a-Judge在提供奖励信号时面临诸多挑战，这些问题可能导致训练不稳定、模型作弊或效果下降。以下是主要问题及相应解决方案：

一、核心问题：奖励信号不可靠

  1. 评判标准不稳定

  • 表现：同一个模型在相似输入下可能给出截然不同的评分（如腾讯AI Lab发现仅一个标点就能改变结果）。

  • 解决方案

    ：

    • 数据增强：通过扰动输入（如添加标点、改写句式）训练鲁棒性更强的裁判模型（如Master-RM）。
    • 多模型融合：使用多个不同的LLM裁判投票，降低单一模型的随机性。
    • 校准数据集：通过人工标注的校准集修正裁判的偏差（如延世大学提出的统计学修正框架）。
  1. 自相矛盾的反馈

  • 表现：RLAIF生成的偏好数据中存在大量冲突信号（如同一问题的不同回答被交替评为高分）。

  • 解决方案

    ：

    • 动态权重调整：对冲突样本设置较低权重，或引入元裁判（Meta-Judge）评估裁判自身的判断质量。
    • 分层奖励机制：设计多维度评分标准（如事实正确性、逻辑连贯性），并对关键维度设置一票否决权。
  1. 奖励欺骗（Reward Hacking）

  • 表现：模型学会利用裁判的漏洞（如关键词堆砌、讨好用户）获取高分，而非真正提升能力。

  • 解决方案

    ：

    • 防御性评估标准：明确列出作弊行为（如过度自夸、无关内容），触发即降分（如Non-Verifiable RL中的Anti-Rubric）。
    • 对抗训练：训练专门识别欺骗行为的“蓝军”模型，动态提升裁判的免疫力。

二、效率与成本问题

  1. 评估速度慢

  • 表现：LLM裁判生成式评估（如长文本分析）耗时远超规则型奖励模型。

  • 解决方案

    ：

    • 混合奖励模型：离线使用LLM裁判生成偏好数据，再训练轻量级奖励模型（如Reward Model）用于在线训练。
    • 并行化评估：在训练框架中优化裁判的批量处理能力（如VeRL框架的异步评估）。
  1. 标注成本高

  • 表现：即使使用AI反馈，仍需人工设计评估标准和校准数据。

  • 解决方案

    ：

    • 领域专家参与：早期引入核心领域专家定义评估边界（如投资建议合规性）。
    • 自动化标准迭代：通过模型自我评估（如Self-Rewarding LLM）动态优化评估标准。

三、泛化能力不足

  1. 领域适配性差

  • 表现：通用LLM裁判在专业领域（如法律、医疗）的评分准确性低。

  • 解决方案

    ：

    • 领域微调：在特定领域数据上微调裁判模型（如法律文档评分）。
    • 标准优先工作流：先定义领域专属评估标准（Rubric），再生成训练数据。
  1. 跨模型一致性低

  • 表现：不同LLM裁判对同一模型的评分差异显著。

  • 解决方案

    ：

    • 标准化评估协议：统一输入格式（如JSON）和输出尺度（如1-5分制）。
    • 基准测试集：构建公开的LLM裁判能力评估基准（如PersonaEval）。

四、实践建议

  1. 分层使用裁判

    ：

    • 离线训练：用强大的LLM裁判（如GPT-4o）生成高质量偏好数据。
    • 在线训练：用轻量级奖励模型（如Reward Model）快速计算奖励。

  2. 持续监控与迭代

    ：

    • 生产环境中定期抽样评估，动态调整裁判策略（如每小时评估10%对话）。
    • 建立仪表盘可视化关键指标（如幻觉率、用户满意度）。

  3. 结合人工监督

    ：

    • 对高风险场景（如医疗建议）保留人工复核环节。
    • 用人工标注的小样本校准裁判模型（如50个正确/错误样本）。

总结

LLM-as-a-Judge的核心矛盾在于灵活性与可靠性的权衡。通过多模型融合、动态校准、分层奖励机制，可以在降低成本的同时提升评估质量。未来趋势可能是元裁判系统的普及——让模型不仅能生成内容，还能自我优化评估能力，最终实现“评估即学习”的闭环。

27. GRPO训练时出现提前收敛的现象，即一个epoch尚未训练完成，reward就已经饱和，这种情况有什么处理思路

28. 强化学习借用replay buffer来解决on-policy算法的迭代, 效果如何?

将replay buffer应用到on-policy的方法中一直是人们的期望，replay buffer的引入可以提高数据的利用率，避免一次数据只能update一次的浪费问题。但是replay buffer不是随随便便引入就可以使用的，要将on-policy的方法变成off-policy就必须作出一定的变动。比如说importance sampling就是一种引入replay buffer后通过概率修正来使得Policy-Based算法也能像Value-Based方法一样使用自己的历史数据（PPO就是这么做的）。那为什么dqn可以不用importance sampling而ppo必须要呢？这是因为dqn的更新公式是与策略无关，而ppo更新是是与当前策略强相关的（行为选取概率与策略直接关联），所以才需要用importance sampling来做概率修正，修正replay buffer里的值（实际上修正的是梯度公式中优势函数的值）。

因此，在policy-based方法中，不是用replay buffer来替代importance sampling，而是因为想引入replay buffer所以才要使用importance sampling来做概率修正，是的replay buffer中的数据可以被正确使用。（建议可以参考一下ppo论文，这篇论文应该能够很好的回答答主的问题）

PPO算法本身没有传统意义上的"持续存储-反复回放"的Replay Buffer，但在实际工程中会使用临时缓存来存储一批数据进行多次训练。以下是具体分析：

一、PPO的本质：有限度的Off-Policy训练

PPO的核心目标是提高样本效率，其训练范式为：

  1. 采样阶段：用当前策略（π_old）与环境交互，生成一批轨迹数据（state、action、reward等）
  2. 训练阶段：对这批数据进行K个Epoch的小批次更新（而非传统On-Policy算法的"采样一次就丢"）
  3. 更新策略：当K轮训练完成或策略漂移超过阈值（如KL散度），则用新策略重新采样

这种"采样一次、训练多轮"的模式，本质上是利用临时缓存（Buffer）重复使用数据，但与DQN等Off-Policy算法的区别在于：

  • 数据时效性：PPO的Buffer仅保存当前策略采样的数据，训练完即丢弃，不会积累历史数据
  • 策略一致性：通过重要性采样（IS）**和**Clip机制限制策略漂移，确保数据与当前策略的偏差在可控范围内

二、PPO使用Buffer的核心原因

  1. 采样成本远高于训练
    在LLM等复杂场景中，采样（Rollout）需要：
    • 自回归生成（逐Token解码，GPU利用率低）
    • 调用Reward Model、Reference Model等打分器 这些操作的时间成本远高于反向传播，必须通过重复使用数据提升效率。
  2. PPO的设计允许有限度的Off-Policy
    严格的On-Policy要求数据必须来自当前策略，但PPO通过：
    • Importance Sampling Ratio： 纠正分布差异
    • Clip机制：限制Ratio在[1-ε, 1+ε]范围内，避免更新过大
      使得同一批数据可以安全训练多次而不失真。
  3. 多轮训练提升稳定性
    同一批数据的优势函数（Advantage）往往噪声较大，多Epoch+Mini-Batch的训练方式：
    • 降低梯度方差，使优化更平滑
    • 充分利用昂贵计算得到的监督信号（如优势值、回报值）

三、PPO与传统Replay Buffer的关键区别

特性 PPO的临时缓存 DQN的Replay Buffer
数据来源 当前策略采样的数据 历史策略积累的数据
存储周期 训练K轮后丢弃 持续积累，容量固定（如1e6）
采样方式 全量数据多轮迭代 随机采样Mini-Batch
策略一致性 严格控制策略漂移（Clip/KL限制） 允许较大策略偏差（需IS校正）

四、工程实现中的具体做法

在LLM的PPO训练中，通常会：

  1. 临时存储轨迹数据：用字典或数组保存采样得到的state、action、logprob、advantage等
  2. 多Epoch训练：对同一批数据进行3-10轮Mini-Batch更新（如每轮取128个样本）
  3. 早停机制：监控策略与旧策略的KL散度，超过阈值则停止训练

核心结论

PPO没有传统意义上的Replay Buffer，但通过临时缓存重复使用数据，在采样效率和策略稳定性之间取得了平衡。这种设计是PPO成为最流行强化学习算法之一的关键原因。

29. GRPO能否使用off-policy的数据辅助reward计算？ 例如同一个query，使用几个step之前的rollout，以降低采样压力？

https://www.zhihu.com/question/1979521716796548651/answer/1979522264358737261

  1. GRPO在rollout的时候如何提升样本的利用效率？
  2. 遇到过奖励稀疏问题吗？ 如何解决？ 例如GRPO对于reward全为0的样本有什么处理方式？
  3. 对于process reward 和 outcome reward 有什么看法，比较一下。
  4. 强化学习训练时出现entropy collapse，有什么解决思路
  5. 强化学习训练时，例如PPO/GRPO，有哪些超参数要设置，一般设置多少？
  6. 强化学习训练时遇到reward上升，但validation时效果下降，有哪些解决思路
  7. 大模型的推理能力一般是在哪一个训练阶段产生的？（为什么说SFT memorize， RL generalize）
  8. VeRL框架是同步的还是异步的，具体的训练流程是什么
  9. VeRL框架在训练时要设置哪些参数？ ppo_mini_batch_size，ppo_micro_batch_size_per_gpu和train_batch_size之间有什么关系？
  10. 同步框架可能的问题有哪些, 对于rollout的长尾问题有什么解决方案？
  11. 了解RL的训推不一致问题吗？训推不一致的产生原因是什么，有哪些解决方案？
  12. 了解哪些RL的异步框架？
  13. AReaL 或者其他partially rollout框架，在rollout时，会不会保存之前policy的KV cache？
  14. 你认为未来SFT阶段和RL阶段，哪个更重要？
  15. 说出一个你在RL训练时发现问题–>分析问题–>解决问题的过程