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

fp16 fp32

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

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

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

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

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

损失函数设计

LoRA吟唱

手撕MHA

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

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

QKV代表什么 说说理解

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

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

模板6

先做个自我介绍吧，可以结合你之前的工作经历聊聊。

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

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

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

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

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

聊聊你实习时团队的组成和分工吧，大家是怎么协作的？

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

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