--- layout: default title: 训练、数据与模型优化：从数据清洗到 LoRA description: Agent 训练数据、微调方法、对齐算法与底层优化的面试题拆解 eyebrow: Agent 面试通关 / 10 --- # 训练、数据与模型优化：从数据清洗到 LoRA Agent 岗位面试不只考“会不会用 Agent”，还考**“Agent 背后的模型是怎么训出来的”**。数据怎么洗、训练集怎么构造、微调用什么方法、对齐算法怎么选——这些问题考的是你对 Agent 全链路的理解深度。 --- ## 数据工程与清洗 ### Q：构造数据集遇到过什么难点，怎么解决？ > 来源：腾讯AI应用开发【CVTE AI应用工程师一面追问：合成数据集质量达不到预期怎么办】【[字节 Seed 具身数据一面](https://www.nowcoder.com/feed/main/detail/657dfac8ca5c49f28492a1110b95f7cd)追问：标注一致性与自动质检】【[Momenta 大模型算法工程师一面](https://www.nowcoder.com/feed/main/detail/f7518c865e07491cb1518d288698813c)追问：长尾样本对齐】 **新手答**：“数据不够，就多标一些。” **高手答**： 最大的问题不是数据不够，而是**数据不真实**。 人工构造的数据常常太标准——用户表达很整齐，参数给得很全，工具永远成功。结果上线之后用户一句话没说全，模型就不会了。 三个核心难点和解法： **难点一：数据不真实** → 把真实线上 query 引进来，按意图、复杂度、缺参情况、歧义情况分桶，然后做针对性补齐 **难点二：标注不一致** → 同一种问题不同人可能给出不同工具路径，所以需要**先统一 schema 和决策标准**，再开始标注 不要只用一个总一致率掩盖问题。先按标签、任务阶段和难度切片，在一部分样本上做多人重叠标注；把“口径不清”“确有多解”“标注错误”分开，再用金标样本、仲裁记录和规则版本回写标注规范。Kappa 一类指标可以辅助观察，但类别极不均衡时必须同时看分标签混淆和原始分歧样本。 **难点三：长尾样本太少** → 靠模板改写、对抗生成和人工补充边界案例，把最容易出事故的地方优先补上 长尾治理要先定义业务切片，而不是把所有低频样本简单过采样。对每个 tail slice 记录覆盖率、错误成本和来源，结合真实失败、受约束合成和人工补标扩充；训练时再比较重采样、样本权重和课程顺序。验收必须同时看整体指标与 tail-slice 指标，防止平均分上升但高风险长尾退化。 **差距在哪**：新手以为问题是“量不够”。高手知道问题是“质不真”。面试官想听的是你真实踩过的坑。 --- ### Q：预训练数据清洗方法？ > 来源：阿里 AI Agent 开发一面【[MiniMax - 大模型算法岗（后训练 / SFT / RL 方向，独角兽）](https://www.nowcoder.com/discuss/925527528259743744)追问：数据清洗时，你如何筛选低质量样本？用过哪些启发式规则或模型过滤？】【[MiniMax - 大模型算法岗（后训练 / SFT / RL）](https://www.nowcoder.com/discuss/926272883872075776)追问：低质数据筛选的启发式规则或模型过滤方法？】 **新手答**：“去重，过滤脏数据。” **高手答**： 预训练数据清洗要解决三类问题： | 类型 | 典型表现 | |------|---------| | 脏数据 | 乱码、HTML 残留、脚本片段、异常符号、错误编码 | | 重复数据 | 完全重复、近重复 | | 低质量数据 | 广告、灌水、模板文、机器翻译残片、拼接错乱文本 | 处理流程分三步递进： 1. **规则清洗**：去标签、过滤控制字符、长度约束、语言检测 2. **质量过滤**：困惑度过滤、分类器识别垃圾文本、关键词规则 3. **去重**：MinHash、SimHash、LSH 做近重复检测 真正影响模型上限的，很多时候不是模型结构，而是预训练数据质量。 **差距在哪**：新手只说了两个词。高手按“规则→统计→算法”的层次把清洗逻辑讲清楚了。面试官考的是你有没有处理过大规模数据的经验。 --- ### Q：自动标注系统的主要难点是什么？如何设计模型预标注、置信度分流和人工复核闭环？ > 来源：[字节 Seed 具身数据一面](https://www.nowcoder.com/feed/main/detail/657dfac8ca5c49f28492a1110b95f7cd)【[百度具身研发一面](https://www.nowcoder.com/feed/main/detail/258695ecdfbb464790fc8ae55c9f1661)追问：标注相关，有做过自动化标注吗？】 **新手答**：“让大模型先标，低置信度的交给人工。” **高手答**： 难点不只是准确率，而是**置信度未校准、错误具有相关性、分布持续变化**。模型可能对系统性错误非常自信，只审低置信样本会把最危险的错误直接放行。 生产闭环应这样拆： 1. 先按版本化 schema 做规则校验和模型预标注，保存模型、Prompt、输入和候选标签版本。 2. 用校准集把分数转成可解释风险；高风险或高业务成本样本强制人工，中间区间多人复核，低风险区也保留随机抽检。 3. 植入金标样本和重叠样本，区分模型错误、标注员漂移和规范歧义；分歧进入仲裁队列，不能用多数票静默覆盖。 4. 人工修正回流时保留原预测与原因码，按错误簇选下一轮主动学习样本，避免只重复采最容易的数据。 5. 上线后监控输入分布、分标签通过率、抽检错误率和下游任务指标；漂移后先降级到人工，不自动放宽阈值。 关键原则是“模型提速，人工定义事实边界”。自动标注输出是候选，不是天然 ground truth。 **差距在哪**：新手只有一个阈值，高手能设计带版本、校准、随机审计、仲裁和漂移回退的质量系统。 --- ### Q：SFT 数据字段如何映射？instruction 与 input 重叠时如何定义清洗和拼接契约？ > 来源：[大方云图研发实习一面](https://www.nowcoder.com/feed/main/detail/a9a40feb4e1e4d0ca7c3f8c3ba67d487)【[阶跃星辰（Stepfun）- 大模型算法岗（Post-train）](https://www.nowcoder.com/discuss/926273007276814336)追问：SFT 数据中指令与输入字段重叠的处理？】 **新手答**：“把 instruction、input 和 output 拼成一段文本；重复内容去掉即可。” **高手答**： 先定义一种**规范样本**，再适配外部字段。内部可以统一为 `messages`，也可以统一为 `prompt/completion`，但必须保留 `sample_id`、来源、数据版本和任务类型。字段映射是确定性 ETL，不能让训练脚本现场猜语义。 `instruction` 与 `input` 重叠时先判断角色： - `instruction` 是稳定任务要求，`input` 是本次实例数据：即使词面重复，也应保留角色边界； - `instruction` 已经完整内嵌实例数据：规范化后清空 `input`，避免重复喂两遍； - 两者局部冲突：进入隔离/人工规则，不按“后字段覆盖前字段”处理； - 多轮数据：转为带 `role` 的消息，不能把历史轮次压成一个无结构字符串。 [TRL 当前 SFTTrainer 文档](https://huggingface.co/docs/trl/sft_trainer)区分 standard/conversational、language-modeling/prompt-completion 数据，并分别支持 completion-only 与 assistant-only loss。工程上应先用目标模型的 chat template 渲染，再检查 BOS/EOS、角色标记、截断和 loss mask；`assistant_only_loss` 还依赖 chat template 正确提供 generation 标记。 Packing 不是天然的样本隔离保证。应结合 TRL 的[内存优化说明](https://huggingface.co/docs/trl/reducing_memory_usage)验证 packing strategy、样本边界和 attention/loss mask：`wrapped` 会把无关样本拼入同一序列，padding-free 模式也需要兼容的注意力实现；若边界或 mask 配错，后一个样本就可能读取前一个样本或继承错误标签区域。 发布前对固定样本做渲染快照、token 级 decode 回放和 hash 归档。否则同一份 JSONL 换 Tokenizer 或模板后，实际训练目标已经变了却无法追踪。 **差距在哪**：新手把字段映射当字符串拼接，高手把它当版本化的数据契约，并能解释角色、模板、截断和 loss 区域。 --- ### Q：Agent 工具调用怎么训练？训练集该包含什么？数据怎么来？ > 来源：阿里 AI Agent 开发一面 **新手答**：“找一些工具调用的例子做微调。” **高手答**： 训练集至少要覆盖**三类样本**： 1. **该调用工具的**——正样本 2. **不该调用工具的**——只教“会调用”不够，还得教“什么时候不要调” 3. **多工具串并联调用的**——复杂场景下的编排能力 数据来源一般有**四种**： | 来源 | 做法 | 特点 | |------|------|------| | 人工标注轨迹 | 问题 → 思考 → 工具选择 → 参数 → 结果，整合成监督样本 | 质量高，成本大 | | 线上日志回放 | 从高质量人工操作或已有系统中抽取工具调用链 | 真实，但需清洗 | | 规则合成数据 | 用模板生成标准调用样本 | 量大，但多样性差 | | 模型自举 | 用强模型生成轨迹，再人工检验修正 | 扩量快，需质检 | 真正关键的是**负样本和边界样本**——参数缺失、工具返回空、多个工具都可用但优先级不一……这些不补，模型上线很容易乱调。 **差距在哪**：新手只想到了正样本。高手覆盖了正/负/复杂三类样本和四种数据来源。面试官考的是你理不理解模型是怎么学会使用工具的。 --- ### Q：训练数据标注粒度应该越细越好还是按任务适配？如何权衡成本、信息量和泛化？ > 来源：[字节 Seed 具身数据一面](https://www.nowcoder.com/feed/main/detail/657dfac8ca5c49f28492a1110b95f7cd) **新手答**：“越细越好，细粒度标签包含的信息更多。” **高手答**： 粒度不是越细越好，而要与**模型的决策单元和评测单元**对齐。具身数据可以按 Episode、子任务、动作段或 Frame 标；客服数据可以按会话、Turn、意图或槽位标。粒度过粗会把多个决策混成一个标签，定位不了失败步骤；粒度过细则增加成本和歧义，还可能让模型只学局部动作，丢失长程目标。 我会先定义分层 schema： ```text 任务层：目标、成功条件、风险等级 阶段层：子任务、开始/结束边界、依赖关系 动作层：动作、参数、Observation、结果 帧层：时间戳、传感器状态、质量标记 ``` 然后用小规模试标比较三件事：标注员一致性、下游指标增益、单位样本成本。只有更细标签能稳定提升错误归因、策略学习或关键切片指标时才保留；否则让细粒度数据作为派生视图，而不是主事实源。[LeRobotDataset v3](https://huggingface.co/docs/lerobot/lerobot-dataset-v3)把多模态时序数据、Episode 边界和检索元数据分开，正好说明“存储粒度”和“训练采样粒度”可以解耦，但这只是公开格式示例，不是通用最优答案。 **差距在哪**：新手把标签数量当信息量，高手会从学习目标、边界歧义、标注成本和分层复用判断粒度。 --- ## 微调与对齐训练 ### Q：DPO、PPO、GRPO 的区别和优缺点？ > 来源：阿里 AI Agent 开发一面 / 腾讯 AI 应用开发 / 字节 Agent 实习二面 【阿里国际一面追问：重要性采样在策略差异大时失效 + GRPO vs PPO KL散度区别】；[快手广告大模型一面](https://www.nowcoder.com/discuss/923996140154953728)【[MiniMax - 大模型算法岗（后训练 / SFT / RL 方向，独角兽）](https://www.nowcoder.com/discuss/925527528259743744)追问：GRPO 和 DPO 在代码实现上的区别是什么？】【[阶跃星辰（Stepfun）- 大模型算法岗（Post-train）](https://www.nowcoder.com/discuss/926273007276814336)追问：PPO vs GRPO 优劣势？】【[8.13 百度一面挂 百度多模态算法工程师-北京](https://www.nowcoder.com/discuss/926467109717118976)追问：PPO 和 GRPO 的区别是什么？】 **新手答**：“都是对齐方法，PPO 用 RL，DPO 不用。” **高手答**： 先说大背景：强化学习在大模型中的核心应用是**对齐（Alignment）**——让模型从“能生成”变成“生成得好”。经典路线是 RLHF（Reinforcement Learning from Human Feedback），即先用人类偏好数据训练一个 Reward Model，再用 RL 算法（如 PPO）优化策略模型。后来 DPO、GRPO 分别从不同角度简化了这条路线。 三者都是大模型对齐的训练方法，核心区别在于**奖励信号的来源、数据形态和工程复杂度**： | 维度 | PPO | DPO | GRPO | |------|-----|-----|------| | 训练范式 | 在线强化学习 | 离线偏好优化 | 在线组相对优化 | | 是否需要 Reward Model | 是（单独训练） | 否（隐式从偏好中学） | 否（组内相对奖励） | | 是否需要 Critic | 是（Actor-Critic） | 否 | 否 | | 数据需求 | 实时采样 | 离线偏好对数据 | 实时采样 | | 训练复杂度 | 高（4 个模型） | 低（1 个模型） | 中（无 Critic） | **PPO（Proximal Policy Optimization）**： - 经典在线 RL 方法。训练时模型实时生成回答，Reward Model 打分，用打分信号更新策略 - 需要同时维护 Actor、Critic、Reward Model、Reference Model 四个模型，显存和计算开销大 - 用 clip 机制限制策略更新幅度，防止训练不稳定 - 优点：在线采样能持续探索，效果天花板高；缺点：训练复杂度高，调参困难 **DPO（Direct Preference Optimization）**： - 核心洞察：把 Reward Model 的训练和策略优化合并成一步，直接从人类偏好对（chosen vs rejected）中学习 - 数学上证明了 DPO 的最优解和 RLHF（PPO）的最优解等价，但绕过了显式的奖励建模 - 优点：训练简单，只需要一个模型，像做 SFT 一样简单；缺点：离线方法，依赖静态偏好数据，无法在线探索 **GRPO（Group Relative Policy Optimization）**： - DeepSeek 提出。每个 prompt 采样一组回答（比如 8 个），用组内相对排名作为奖励信号——不需要外部 Reward Model，也不需要 Critic - 比 PPO 轻量（去掉了 Critic），比 DPO 灵活（在线采样） - 特别适合数学、代码等有明确对错判断的场景——组内相对奖励天然支持“有标准答案”的任务 ```text PPO: query → model → output → reward model → policy update（4 个模型） DPO: query → chosen/rejected pair → 直接优化（1 个模型） GRPO: query → N 个候选 → 组内相对排序 → 优化（无 Critic） ``` **PPO vs GRPO 深度对比（高频追问）**： 以下是算法面试中围绕 PPO 和 GRPO 最常见的深度追问： **1. 重要性采样（Importance Sampling）为什么需要？** PPO 和 GRPO 都用旧策略 π_old 采样，用新策略 π_θ 更新。如果不做修正，旧策略的采样分布和新策略的目标分布不匹配，梯度估计有偏。重要性采样通过比率 r(θ) = π_θ(a|s) / π_old(a|s) 来修正这个偏差。 **追问：新旧策略差别很大时，重要性采样还有用吗？** 不行。当 π_θ 和 π_old 差别过大时，重要性权重 r(θ) 的方差会爆炸——个别样本的权重极大，梯度估计变得不稳定。这正是 PPO 引入 clip 机制的原因： ```text L_clip = min(r(θ) · A, clip(r(θ), 1-ε, 1+ε) · A) ``` 把 r(θ) 截断在 [1-ε, 1+ε] 范围内（通常 ε=0.2），防止单步更新跨度过大。GRPO 同样使用 clip，并额外加 KL 惩罚作为双重保险。 **2. GRPO 的 KL 散度和 PPO 的 KL 散度一样吗？** 不完全一样。 | 对比 | PPO | GRPO | |------|-----|------| | KL 约束方式 | 主要靠 clip 隐式约束，部分实现加 KL penalty | 显式 KL 惩罚项，直接加入 loss | | KL 参考分布 | KL(π_θ ∥ π_old) | KL(π_θ ∥ π_ref)，π_ref 通常是 SFT 后的初始策略 | | 作用 | 防止策略更新过快 | 防止策略偏离 SFT 基线太远（防止“忘记”对齐能力） | 关键区别：PPO 的 KL 是相邻迭代之间的约束（π_θ vs π_old），GRPO 的 KL 是和固定参考策略的约束（π_θ vs π_ref）。GRPO 的 KL 更像一个“锚”，始终拉着模型不要偏离初始对齐状态太远。 **3. On-policy vs Off-policy** | 方法 | 类型 | 原因 | |------|------|------| | PPO | On-policy（但有 off-policy 近似） | 用当前策略采样，重要性采样修正后可复用少量旧数据 | | GRPO | On-policy | 每次用当前策略 π_θ 采样 G 个响应，计算组内相对奖励 | | DPO | Off-policy | 直接用离线偏好数据训练，不需要在线采样 | PPO 和 GRPO 本质都是 on-policy（需要当前策略的采样），但 PPO 通过重要性采样可以在一批数据上做多个 epoch 的更新，这是一种“温和的 off-policy 近似”。GRPO 也类似。纯 off-policy 方法是 DPO——直接用预先收集的偏好数据。 **4. PPO 中 Advantages 是怎么得到的？（GAE）** PPO 用 **GAE（Generalized Advantage Estimation）** 计算 Advantages： ```text δ_t = r_t + γ · V(s_{t+1}) - V(s_t) // TD 误差 A_t^GAE = Σ_{l=0}^{T-t} (γλ)^l · δ_{t+l} // 加权求和 γ：折扣因子（通常 0.99） λ：GAE 系数（通常 0.95），控制偏差-方差权衡 ``` GAE 需要一个**价值函数 V(s)** 来计算 TD 误差——这就是 PPO 需要训练 Critic 网络的原因。GRPO 的核心创新正是**去掉了 Critic**，用组内相对排名代替，从而避免了训练一个和 Policy 同等规模的 Value Model 的巨大开销。 **差距在哪**：新手只记了“用不用 RL”这一个区别。高手从训练范式、数据形态、工程复杂度三个角度做了完整对比，且说清了每种方法的设计动机和适用场景。面试官想看的是你理解了本质差异，而不只是记了名字。 **追问：DPO 不需要在线采样的核心原因是什么？标准 DPO 训练数据长什么样？** > 来源：阿里淘天 AI应用开发一面 **为什么 DPO 不需要在线采样**： PPO 的训练循环是：模型生成回答 → 奖励模型打分 → 用打分信号更新策略。这个「模型生成回答」就是在线采样——每一步都要用当前策略跑一遍推理，成本极高。 DPO 的核心洞察：**奖励函数可以被隐式地表示为策略的函数**。Bradley-Terry 偏好模型告诉我们，如果已知人类偏好数据（哪个回答好、哪个差），可以直接优化策略使其对齐偏好，**绕过显式奖励模型**。数学上，DPO 把奖励建模和策略优化压缩成了一个 loss： ```text L_DPO = -log σ(β × (log π(y_w|x)/π_ref(y_w|x) - log π(y_l|x)/π_ref(y_l|x))) ``` 不需要奖励模型，不需要在线采样，只需要离线的偏好对数据。 **标准 DPO 训练数据格式**： | 字段 | 说明 | 示例 | |------|------|------| | prompt | 用户输入 | 「解释量子计算的基本原理」 | | chosen (y_w) | 人类偏好的好回答 | （准确、清晰的回答） | | rejected (y_l) | 人类不偏好的差回答 | （含幻觉或啰嗦的回答） | 每条数据是一个三元组 (prompt, chosen, rejected)。数据质量的关键不是数量，而是 **chosen 和 rejected 之间的差距要有意义**——如果两个回答质量差不多，模型学不到有效信号。 **追问：DPO 的 chosen/rejected 数据实际怎么生成？常见的坑？** > 来源：美团Keeta Agent开发一面 **三种生成 chosen/rejected 对的方法**： | 方法 | 流程 | 优点 | 缺点 | |------|------|------|------| | 人工标注 | 标注员对同一 prompt 的多个回答排序 | 质量最高 | 成本极高，标注一致性难保证 | | 模型自生成 + 打分 | 用模型生成 N 个回答，用奖励模型或规则打分选最好/最差 | 可大规模生产 | 打分器本身可能有偏差 | | 拒绝采样（Rejection Sampling） | 用强模型生成 chosen，用弱模型/未对齐模型生成 rejected | 差距明确 | 强弱差距太大时，模型学到的信号太浅 | **常见的坑**： 1. **chosen 和 rejected 差距太小**：两个回答都还行，只是措辞不同——模型学不到有意义的偏好信号，训练 loss 不下降 2. **chosen 和 rejected 差距太大**：一个完美一个胡说——模型只学会了「不要胡说」这种过于简单的信号，对细粒度质量提升没帮助 3. **标注不一致**：不同标注员对同一对数据的偏好判断不同，导致训练信号矛盾 4. **领域偏移**：通用偏好数据训练的 DPO 模型在垂直领域（如医疗）表现差——领域内「什么算好回答」的标准和通用场景不同 **最佳实践**：控制 chosen/rejected 的**质量梯度**——理想状态是 chosen 比 rejected 好一个明确的档次（如事实正确 vs 含一个事实错误），而非好太多或差不多。 --- ### Q：微调方法有哪些？LoRA 和全参数微调的区别？怎么选？ > 来源：阿里 AI Agent 开发一面 / 字节 Agent 实习一面【[百度正式批：一面结束第二天就约二面了](https://www.nowcoder.com/discuss/925108144831725568)追问：你微调具体微调哪一部分，不太可能是全量微调吧？】 **新手答**：“LoRA 省显存，全参数效果好。” **高手答**： 主流微调方法按参数更新范围分三类： | 方法 | 原理 | 参数量 | 显存 | 适用场景 | |------|------|--------|------|---------| | 全参数微调 | 直接更新所有参数 | 100% | 大，需要多卡 | 需要深度改变模型行为 | | LoRA | 在原始权重旁插入低秩矩阵，只训练新增参数 | 0.1%–1% | 小 | 领域适配、指令跟随、工具调用格式对齐 | | QLoRA | LoRA + 4-bit 量化基座模型 | 同 LoRA | 更小（单卡 24GB 可微调 65B） | 资源受限时的首选 | | Prefix Tuning | 在每层 Attention 前插入可训练的虚拟 token | <0.1% | 极小 | 轻量级任务适配、多租户场景 | | Adapter | 在 FFN 层后插入小型瓶颈网络 | 1%–5% | 较小 | 多任务共享基座 | **LoRA vs 全参数微调的核心对比**： | 维度 | LoRA | 全参数微调 | |------|------|-----------| | 原理 | 在原始权重旁插入低秩矩阵，只训练新增参数 | 直接更新所有参数 | | 参数量 | 通常只有原模型的 0.1%–1% | 100% | | 显存 | 小，适合消费级 GPU | 大，需要多卡 | | 训练速度 | 快 | 慢 | | 任务切换 | 方便，换 adapter 即可 | 每个任务一个完整模型 | | 适用场景 | 领域适配、指令跟随、工具调用格式对齐 | 需要深度改变模型行为的场景 | LoRA 的核心优势不只是“省显存”，而是**方便任务切换和多租户部署**——同一个基座模型挂不同 adapter，就能服务不同场景。 **怎么选**： - 数据量大（万级以上）+ 要深度改变模型行为 → 全参数微调 - 数据量中等 + 领域适配 / 格式对齐 → LoRA（当前最主流） - 资源极度受限（单卡消费级 GPU）→ QLoRA - 需要多任务快速切换 → LoRA / Adapter（换 adapter 不换基座） - 只做轻量提示适配 → Prefix Tuning **面试官追问：“你自己做过微调吗？”** 这类追问不是问“会不会写训练脚本”，而是考察你对微调全流程的工程认知。回答结构：**数据 → 方法选型 → 训练细节 → 评估**。即使没亲手做过大规模微调，也应该说清楚：用什么数据（多少条、什么格式、怎么清洗）、为什么选这个方法（LoRA vs 全参数）、训练时关注什么指标（loss 曲线、过拟合检测）、怎么评估效果（离线评测 + 在线 A/B）。 **差距在哪**：新手只知道两种方法且只说了一个维度。高手把主流微调方法按参数效率做了系统对比，并给出了场景化的选型建议。面试官考的是“你理不理解微调方法的设计动机，能不能根据资源和需求做选型”。 **追问：LoRA 的 A、B 两个矩阵分别怎么初始化？逻辑推理任务的秩该偏大还是偏小？训推一体时权重 Merge 怎么做？** > 来源：阿里淘天 AI应用开发一面（三连追问） 这三个问题串起来考的是 LoRA 从训练到部署的完整认知： **矩阵初始化**： - **A 矩阵**（降维矩阵）：随机高斯初始化（均值 0，方差小） - **B 矩阵**（升维矩阵）：**零初始化** - 为什么 B 用零初始化？因为 ΔW = BA，B=0 意味着训练开始时 ΔW=0，模型从原始预训练权重出发——保证微调初期不破坏已有能力 **秩（rank）选择**： | 任务类型 | 推荐秩 | 原因 | |---------|--------|------| | 简单对话/格式调整 | r = 4~8 | 输出模式变化小，低秩足以捕获 | | 领域知识注入 | r = 16~32 | 需要学习新知识，更新量更大 | | 逻辑推理/数学 | r = 32~64（偏大） | 推理能力依赖多层复杂交互，低秩会欠拟合 | 逻辑推理任务秩偏大的核心原因：推理链的正确性依赖于注意力头之间精细的协作模式，这种模式的参数空间维度高，低秩近似会丢失关键信息。 **权重 Merge**： 部署时把 LoRA 分支合并回主权重：W_merged = W_original + α × B × A。合并后推理路径和原始模型完全相同——**零额外延迟**，因为不再有旁路分支。α 是 LoRA 的 scaling factor（通常 α/r）。合并是不可逆的——如果需要切换多个 LoRA 适配器，保留未合并版本。 --- ### Q：给定时间序列，如何用 ML 筛选特征，再基于规则建模？ > 来源：字节一面【[OPPO 大模型算法面经](https://www.nowcoder.com/feed/main/detail/685479ec75b542bebf1156c47f1d4e88)追问：组合特征盲点】 **新手答**：“提取特征，训练模型，看 feature importance。” **高手答**： 先把原始序列变成可学习的特征： ```text 统计特征：均值、方差、最大最小值 趋势特征：移动平均、环比 波动特征：标准差、变异系数 周期特征：傅里叶分量、周期自相关 滞后特征：lag 值、rolling lag ``` 然后用 XGBoost / LightGBM / 随机森林训练，输出的关键因子整理成多条规则做线上解释。 好处是**既保留了 ML 筛特征的能力，也兼顾了规则系统的稳定和可解释**——线上跑的是规则，但因子是 ML 选出来的。 **追问：XGBoost 做特征筛选会不会漏掉组合特征？** 会。树能在后续层通过不同分裂表达交互，但单特征 importance 只是对“这个特征被怎样用于分裂”的汇总，不等于它单独有因果贡献。XGBoost [官方 API](https://xgboost.readthedocs.io/en/stable/python/python_api.html)也区分 `weight`、`gain`、`cover`、`total_gain`、`total_cover` 等口径；口径不同，排名会变，未用于分裂的特征还可能直接显示为零。 所以不能按一次 importance 排名硬删特征。我会结合领域假设构造交叉/比值/窗口组合，在按时间切分的验证集上做分组消融；再比较单特征、组合特征和原始特征组的稳定性。若某个组合只在随机切分中有效、换时间段就失效，应优先怀疑泄漏或偶然相关，而不是继续调树深。 **差距在哪**：新手只说了思路没说具体特征。高手列出了五类特征且说清了 ML 和规则如何衔接。面试官考的是你能不能把 ML 和规则系统结合起来满足可解释性要求。 --- ### Q：kernel 级别的优化，比如用 CUTE DSL 或手写 CUDA 做 fusion？ > 来源：阿里 AI Agent 开发一面 **新手答**：“就是把多个算子合成一个，减少开销。” **高手答**： kernel 级别优化的核心目标是**减少访存开销、减少 kernel launch 次数、提高并行利用率**。很多模型推理慢，不一定是算力不够，更多是 memory bound。 算子融合的思路： 1. **纵向融合**：把连续的 elementwise 操作（如 LayerNorm + Dropout + Add）合成一个 kernel，减少中间结果写回显存 2. **横向融合**：把多个独立但可以并行的小 kernel 合并，减少 launch overhead 3. **访存优化**：利用 shared memory、寄存器缓存，减少 global memory 访问 工具链选择：手写 CUDA 最灵活但成本高；Triton 降低门槛但灵活性有限；CUTE DSL 在特定场景下能兼顾性能和开发效率。选哪个取决于**场景对性能的极致要求程度和团队的工程能力**。 **差距在哪**：新手只说了“合成一个”。高手区分了纵向/横向/访存三个优化方向。面试官考的是底层技术深度。 --- ### Q：XGBoost 相比单棵决策树，在目标函数、正则和集成机制上做了什么改进？ > 来源：[OPPO 大模型算法面经](https://www.nowcoder.com/feed/main/detail/685479ec75b542bebf1156c47f1d4e88) **新手答**：“XGBoost 是很多棵树，效果比一棵树好，也不容易过拟合。” **高手答**： 单棵 CART 通过贪心分裂拟合一个分段常数函数，结构直观、推理快，但很容易高方差。XGBoost 不是“把树堆多”这么简单，而是做**加法式梯度提升**：固定已有模型，每一轮新增一棵树去优化当前目标，最终预测是多棵树分数之和。 XGBoost [官方 Boosted Trees 教程](https://xgboost.readthedocs.io/en/latest/tutorials/model.html)把目标写成： ```text Objective = Training Loss + Model Complexity Prediction = Σ tree_k(x) ``` 核心改进可以分四层： 1. **集成**：后续树针对当前误差继续修正，降低单树的偏差。 2. **目标**：对损失做二阶近似，用一阶梯度和二阶信息评估候选分裂，不只看标签纯度。 3. **正则**：对叶子数和叶子权重施加复杂度约束，并通过最小增益、最小样本权重等条件停止无价值分裂。 4. **随机化与收缩**：学习率、行/列采样降低每轮更新幅度和树之间相关性，配合早停控制过拟合。 但单树并非总是更差：规则需要人工审计、样本极少、延迟极严或必须给出单路径解释时，浅树可能更合适。比较时要在同一时间切分、同一特征和同一成本约束下验证，而不是只看训练集 AUC。 **差距在哪**：新手只知道“多棵树”，高手能从加法训练、二阶目标、复杂度正则和工程边界解释为什么会更强。 --- ## Transformer 基础 ### Q：手撕 Multi-Head Attention > 来源：腾讯 AI 应用开发【[0907 百度一面 （AI Infra）](https://www.nowcoder.com/feed/main/detail/91f5187146864de5878349a2ecf497ce)追问：你对 AI 算法或模型架构有一定了解吗？Transformer、Attention 如何计算？】 **新手答**：写了个 `softmax(QK^T)V` 但没处理 mask 和多头。 **高手答**： ```python import torch import torch.nn as nn import math import torch.nn.functional as F def scaled_dot_product_attention(query, key, value, mask=None): """ query/key/value: [batch, n_heads, seq_len, head_dim] mask: [batch, 1, 1, seq_len] or [batch, 1, seq_len, seq_len] """ d_k = query.size(-1) scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k) if mask is not None: scores = scores.masked_fill(mask == 0, float('-inf')) attention_weights = F.softmax(scores, dim=-1) output = torch.matmul(attention_weights, value) return output, attention_weights class MultiHeadAttention(nn.Module): def __init__(self, d_model, n_heads): super().__init__() assert d_model % n_heads == 0 self.d_model = d_model self.n_heads = n_heads self.head_dim = d_model // n_heads self.W_q = nn.Linear(d_model, d_model) self.W_k = nn.Linear(d_model, d_model) self.W_v = nn.Linear(d_model, d_model) self.W_o = nn.Linear(d_model, d_model) def forward(self, query, key, value, mask=None): batch_size = query.size(0) # 线性投影 Q = self.W_q(query) K = self.W_k(key) V = self.W_v(value) # 拆多头: [batch, seq, d_model] -> [batch, n_heads, seq, head_dim] Q = Q.view(batch_size, -1, self.n_heads, self.head_dim).transpose(1, 2) K = K.view(batch_size, -1, self.n_heads, self.head_dim).transpose(1, 2) V = V.view(batch_size, -1, self.n_heads, self.head_dim).transpose(1, 2) # Attention output, attn_weights = scaled_dot_product_attention(Q, K, V, mask) # 合并多头: [batch, n_heads, seq, head_dim] -> [batch, seq, d_model] output = output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model) return self.W_o(output), attn_weights ``` **面试官可能追问的细节**： 1. **为什么除以 √d_k**：d_k 越大，QK^T 点积的方差越大，softmax 输出越接近 one-hot，梯度消失。除以 √d_k 做缩放保持梯度健康 2. **多头的意义**：不同头在不同子空间学不同的 attention pattern（语法关系、语义关系、位置关系） 3. **mask 的两种用途**：padding mask（忽略填充位置）和 causal mask（自回归时防止看到未来 token） 4. **contiguous() 的作用**：transpose 后内存不连续，view 前需要 contiguous 保证内存布局正确 **差距在哪**：新手只写了核心公式。高手写出完整的多头实现（含 mask、拆头、合并、输出投影），且能解释每一步的设计动机。手撕 Attention 是 AI 岗基本功。 --- ### Q：位置编码的作用是什么？ > 来源：腾讯 AI 应用开发 【字节二面同题：QKV 机制 + 为什么引入位置编码和多头注意力】 **新手答**：“告诉模型 token 的位置。” **高手答**： Transformer 的 Self-Attention 本质上是**置换不变的（permutation invariant）**——把输入 token 打乱顺序，Attention 的计算结果完全一样。这意味着没有位置编码的 Transformer 无法区分“我喜欢你”和“你喜欢我”。 位置编码的作用是**把序列顺序信息注入到模型中**，让每个 token 不仅知道“我是什么”，还知道“我在哪”。 为什么 Attention 是置换不变的：Attention 计算 `softmax(QK^T/√d)V`，Q、K、V 都是 token embedding 的线性变换。点积只关心向量本身的值，不关心向量在序列中的位置。 注入方式有两种： 1. **加法注入**：把位置向量加到 token embedding 上（GPT、BERT 的做法） 2. **注意力偏置**：不改 embedding，在 Attention score 上加一个位置相关的偏置项（ALiBi 的做法） **差距在哪**：新手只说了“告诉位置”四个字。高手从 Attention 的置换不变性出发，解释了为什么需要位置编码、怎么注入。面试官考的是你理不理解这个设计的动机。 --- ### Q：绝对位置编码和相对位置编码的区别？应用场景有什么不同？ > 来源：腾讯 AI 应用开发 **新手答**：“绝对编码给每个位置一个固定向量，相对编码看距离。” **高手答**： | 维度 | 绝对位置编码 | 相对位置编码 | |------|-----------|-----------| | 编码内容 | 每个位置的绝对索引（第 1 个、第 2 个…） | 两个 token 之间的相对距离 | | 长度泛化 | 差，超过训练长度性能急剧下降 | 好，天然支持外推到更长序列 | | 代表方法 | Sinusoidal（原始 Transformer）、Learned（BERT/GPT） | RoPE（LLaMA）、ALiBi（BLOOM） | **绝对位置编码**： - **Sinusoidal**：用不同频率的正弦/余弦函数生成位置向量，不需要学习。理论上可推广到任意长度，但实际效果在超出训练长度后衰减明显 - **Learned**：每个位置训练一个可学习的 embedding（BERT 512、GPT-2 1024）。效果好但长度固定 **相对位置编码**： - **RoPE（Rotary Position Embedding）**：通过旋转矩阵把位置信息编码到 Q、K 向量中，两个 token 做 Attention 时旋转角度的差值反映相对距离。LLaMA、Qwen、DeepSeek 系列都用 RoPE - **ALiBi**：不修改 embedding，在 Attention score 上减去与距离成正比的惩罚项，天然支持长度外推 **场景选择**：短序列固定长度用绝对编码够用；LLM 长文本生成用 RoPE（当前主流）；极长序列且推理效率优先用 ALiBi。当前大模型几乎都用 RoPE，配合 NTK-aware scaling 或 YaRN 可进一步扩展上下文。 **差距在哪**：新手只说了区别没说应用。高手从原理到代表方法到场景选择做了完整对比。面试官考的是你能不能根据需求选择合适的位置编码方案。 --- ### Q：常用解决过拟合的方法？ > 来源：腾讯 AI 应用开发 **新手答**：“Dropout 和正则化。” **高手答**： 过拟合的本质是模型学到了训练集中的噪声模式。解决方法分三个层面： **数据层面**： 1. **数据增强**：NLP 中用同义词替换、回译、随机删除；CV 中用翻转、裁剪、颜色抖动 2. **增加数据量**：最直接有效——数据量够大，模型没机会记住噪声 **训练层面**： 3. **Early Stopping**：监控验证集 loss，连续 N 个 epoch 不下降就停止。简单但有效，几乎是标配 4. **L1/L2 正则化**：loss 中加权重范数惩罚。L2（权重衰减）让权重趋小；L1 产生稀疏权重，起特征选择作用 5. **Dropout**：训练时随机丢弃一定比例神经元输出（0.1-0.5），迫使网络不依赖单一神经元。推理时关闭，权重乘以保留概率 6. **归一化**：BatchNorm / LayerNorm 本身有轻微正则化效果 **架构层面**： 7. **降低模型复杂度**：减少层数、隐藏维度、参数量 8. **交叉验证**：K-Fold 评估泛化能力，选择多个 fold 上表现稳定的超参数 实际工程中通常组合使用——Early Stopping + Dropout + 权重衰减是最常见的三件套。 **差距在哪**：新手只背了两个方法名。高手按数据/训练/架构三层分类，每种方法说清了原理。面试官考的是你对过拟合的理解是否系统。 --- ### Q：LayerNorm 和 BatchNorm 的区别？应用场景？ > 来源：腾讯 AI 应用开发 **新手答**：“LayerNorm 用在 Transformer，BatchNorm 用在 CNN。” **高手答**： 两者都是归一化技术，核心区别在于**归一化的维度不同**： ```text 输入张量形状：[batch_size, seq_len, hidden_dim] BatchNorm：对同一个特征，在 batch 维度上归一化 LayerNorm：对同一个样本，在特征维度上归一化 ``` **BatchNorm**： - 训练时用 mini-batch 统计量，推理时用 running mean/variance - 优点：加速收敛、允许更高学习率 - 局限：依赖 batch size（太小统计量不准）；对变长序列不友好（同一位置在不同样本中语义不同） **LayerNorm**： - 对每个样本独立归一化，不依赖 batch 内其他样本 - 训练和推理行为一致，batch size 为 1 也正常 - 几乎所有 Transformer 都用 LayerNorm **为什么 Transformer 用 LayerNorm**： 1. NLP 输入是变长序列，不同样本同一位置语义完全不同——BatchNorm 在这个维度上求统计量没有意义 2. 推理时可能 batch size = 1，BatchNorm 的 running statistics 不可靠 3. LayerNorm 和序列长度、batch size 都无关 补充：RMSNorm（LLaMA 使用）去掉了均值中心化，只做方差归一化，计算更快。 **差距在哪**：新手死记了结论。高手从归一化维度的本质差异出发，推导出各自的适用场景。面试官考的是你能不能从原理推出应用。 --- ## 模型能力与部署 ### Q：RLHF 中奖励模型（RM）的训练数据如何构建？ > 来源：字节 Agent 实习一面 **新手答**：“找人标注好坏就行。” **高手答**： RM 的训练数据核心是**偏好对（preference pairs）**——同一个 prompt，两条不同回答，人类标注哪条更好。 **数据构建流程**： 1. **采样候选回答**：对同一个 prompt，用 SFT 模型采样多条回答（通常 4-8 条），用不同的 temperature 和 top-p 增加多样性 2. **人工偏好标注**：标注员对每对回答标注偏好（A 优于 B / B 优于 A / 平局）。标注维度通常包括有用性（helpfulness）、无害性（harmlessness）、诚实性（honesty） 3. **质量控制**： - 多人标注同一对，用 Fleiss' Kappa 衡量一致性，低一致性的样本审核或丢弃 - 设置金标准题（标注员已知的正确答案），筛除不合格标注员 - 对争议样本做多轮仲裁 4. **数据增强**：用强模型（如 GPT-4）批量生成候选回答并做初步排序，再交人工校验，降低标注成本 **训练数据的关键设计**： - **难度分层**：不能只有“好 vs 很差”的简单对比，需要大量“好 vs 稍好”的难样本，否则 RM 学不到细粒度区分 - **场景覆盖**：代码、数学、创意写作、事实性问答等不同场景需要分别覆盖 - **负样本多样性**：不只是“错的回答”，还要包含“部分正确但有瑕疵”、“正确但啰嗦”、“正确但不安全”等边界样本 **差距在哪**：新手以为标注就是“标好坏”。高手的回答覆盖了从采样、标注、质量控制到数据增强的完整流程，且强调了难样本和场景覆盖的重要性。面试官考的是你对 RLHF 数据管线的理解深度。 **追问：奖励函数/奖励模型的打分逻辑具体怎么设计？规则 vs 模型怎么选？** > 来源：快手大模型推荐算法一面 / 荣耀大模型算法实习一面 奖励函数的设计直接决定 RL 训练的天花板——**奖励信号错了，模型越训越歪**。 **两种奖励方案对比**： | 维度 | 规则奖励（Rule-based） | 模型奖励（Reward Model） | |------|---------------------|----------------------| | 打分逻辑 | 人工定义评分规则，确定性输出 | 训练一个模型学习人类偏好 | | 适用场景 | 有客观正确答案（数学、代码、格式遵循） | 无唯一正确答案（创意写作、对话质量） | | 优点 | 零噪声、可解释、无需训练、迭代快 | 能捕捉人类偏好中的微妙差异 | | 缺点 | 难以覆盖开放式任务 | 有偏差、可被 hack、需要持续校准 | | Reward hacking 风险 | 低（规则明确） | 高（模型可能学到捷径） | **规则奖励的设计模式**： ```text 数学/代码任务的典型评分规则： 结果正确性：answer == ground_truth → +1.0，否则 0.0 格式遵循：输出包含指定格式标签 → +0.1 推理完整性：包含中间步骤 → +0.1 长度惩罚：超过 max_tokens → -0.1 组合公式：R = w1·正确性 + w2·格式 + w3·步骤 + w4·长度惩罚 ``` 关键原则：**正确性权重必须远大于其他项**，否则模型会通过格式分和步骤分刷分而忽略正确性。 **模型奖励的校准问题**： RM 最大的风险是 **reward hacking**——模型找到 RM 的评分漏洞来刷高分，比如输出更长的回答（RM 偏好长回答）、堆砌关键词。校准手段： 1. **多维度打分**：不给一个总分，分维度（有用性/安全性/格式）独立打分再加权 2. **对抗评估**：定期用 RM 给已知差回答打分，检查是否有高分异常 3. **RM 版本迭代**：随着 Policy 变强，RM 也要重新训练——用新 Policy 的输出做标注 **实际选型建议**： ```text 有客观答案 → 规则奖励（数学/代码/SQL/格式遵循） 无客观答案但有标注数据 → Reward Model（对话/写作/摘要） 混合任务 → 规则 + 模型组合（正确性用规则，质量用模型） ``` DeepSeek-R1 的成功经验：数学和代码任务**纯用规则奖励**就够了，不需要训练 RM，大幅降低了 RL 训练的工程复杂度。 --- ### Q：大模型推理加速技术有哪些？ > 来源：字节 Agent 实习一面 **新手答**：“用量化压缩模型。” **高手答**： 推理加速从四个层面入手： **1. 模型压缩**： | 方法 | 原理 | 代表方案 | 精度损失 | |------|------|---------|---------| | 量化 | 降低权重/激活的数值精度 | GPTQ（训练后量化）、AWQ（激活感知量化）、GGUF（llama.cpp 格式） | INT4 约 1-3% | | 剪枝 | 去除冗余连接或注意力头 | 结构化剪枝（去整层/头）、非结构化剪枝 | 视剪枝比例 | | 蒸馏 | 用大模型教小模型 | DistilBERT、TinyLLaMA | 取决于师生模型差距 | 量化是当前性价比最高的方案——AWQ 在 INT4 下几乎不掉点，且推理速度提升 2-3 倍。 **2. 服务化框架**： | 框架 | 核心技术 | 适用场景 | |------|---------|---------| | vLLM | PagedAttention（KV Cache 分页管理）+ 连续批处理 | 高并发在线服务 | | TensorRT-LLM | 算子融合 + CUDA kernel 优化 | NVIDIA GPU 极致性能 | | llama.cpp | CPU/Metal 推理 + GGUF 量化 | 端侧/低资源部署 | | SGLang | RadixAttention + 前缀缓存 | 多轮对话/共享前缀场景 | **3. 解码优化**： - **推测解码（Speculative Decoding）**：用小模型快速生成候选 token，大模型只做验证。速度提升 2-3 倍，输出质量不变 - **连续批处理（Continuous Batching）**：不等一批请求全完成再处理下一批，有请求完成就立即填入新请求，GPU 利用率大幅提升 **4. KV Cache 优化**： - **PagedAttention**：把 KV Cache 分页存储（类似操作系统虚拟内存），避免预分配大块连续显存 - **GQA/MQA**：Grouped Query Attention / Multi-Query Attention，用更少的 KV Head 减少缓存量 - **KV Cache 量化**：对缓存做 INT8 量化，显存占用减半 实际部署一般是**组合方案**：AWQ 量化 + vLLM 服务 + 推测解码，综合提速 5-10 倍。 **面试官追问：“有没有自己部署过推理服务？做过哪些优化？”** 如果做过，重点讲：用的什么框架（vLLM/TensorRT-LLM/SGLang）、部署在什么硬件上、做了哪些针对性优化。如果没做过，也要能说清楚关键优化方向： - **算子融合（Operator Fusion）**：将多个小算子合并为一个大 kernel，减少 GPU 内存读写和 kernel launch 开销。典型案例：FlashAttention 把 QKV 计算和 Softmax 融合在一个 kernel 里 - **IO 瓶颈优化**：推理的主要瓶颈往往不是计算而是内存带宽（Memory-bound）。优化方向：减少 KV Cache 的内存占用（PagedAttention）、用量化降低数据搬运量、用 tensor parallelism 分摊内存压力 - **批处理优化**：continuous batching（请求到达即拼入当前 batch）比 static batching 吞吐高 2-5 倍 **差距在哪**：新手只知道量化。高手从模型压缩、服务化框架、解码策略、KV Cache 四个层面做了系统梳理，且给出了组合方案。面试官考的是你对推理优化全栈的理解。 --- ### Q：多模态是怎么实现的？图片怎么编码？消耗很大怎么缩减 token 使用？ > 来源：蚂蚁集团一面【[美团 - Agent 开发岗（场景设计方向）](https://www.nowcoder.com/discuss/926273749555376128)追问：多模态（图片）输入与文本的融合方案？】 **新手答**：“把图片转成向量，和文本一起输入模型。” **高手答**： 多模态大模型的核心架构是**视觉编码器 + 投影层 + 语言模型**，关键在于“怎么把图片变成 LLM 能理解的 token 序列”。 **图片编码流程**： ```mermaid flowchart LR A["原始图片"] --> B["Vision Encoder\n（ViT）"] B --> C["Patch Embedding\n切块 → 向量序列"] C --> D["投影层\n（MLP/Cross-Attention）"] D --> E["视觉 Token 序列"] E --> F["和文本 Token\n拼接输入 LLM"] ``` 1. **图片切块（Patch Embedding）**：把图片按固定大小（通常 14×14 或 16×16 像素）切成 patch，每个 patch 经过线性投影变成一个向量——一个 patch 就是一个“视觉 token” 2. **Vision Encoder 提取特征**：用预训练的 ViT（Vision Transformer）对 patch 序列做 self-attention，提取视觉语义特征 3. **投影对齐**：视觉特征的维度和 LLM 的 embedding 维度不同，需要投影层（MLP 或 Cross-Attention）做对齐，让 LLM 能“读懂”视觉 token 4. **拼接输入**：视觉 token 和文本 token 拼在一起，送入 LLM 做联合推理 **为什么图片消耗 token 多**： 一张 224×224 的图片，按 14×14 切块，产生 (224/14)² = 256 个视觉 token。如果是高分辨率图片（如 1344×1344），可能产生上千个视觉 token——这直接吃掉大量上下文窗口。 **缩减 token 的方案**： | 方案 | 原理 | 效果 | 代表模型 | |------|------|------|---------| | **动态分辨率** | 根据图片内容自动选择分辨率，简单图片用低分辨率 | token 数随内容复杂度弹性调整 | Qwen2.5-VL | | **视觉 Token 压缩** | 在投影层用 Perceiver/Q-Former 把数百个视觉 token 压缩成几十个 | 4-8 倍压缩 | BLIP-2、InternVL | | **自适应 Pooling** | 对视觉特征做空间池化，合并相邻的相似 patch | 2-4 倍压缩，信息损失可控 | LLaVA-1.6 | | **稀疏注意力** | 视觉 token 之间不做全连接 attention，只关注关键区域 | 计算量降低，token 数不变但推理更快 | — | | **早期退出** | 简单图片不需要 ViT 跑完所有层，中间层特征就够用 | 编码阶段省算力 | — | **工程实践中的组合策略**： ```text 输入预处理：判断图片复杂度 → 选择分辨率 编码阶段：ViT + Q-Former 压缩视觉 token 到 64-128 个 缓存优化：相同图片多轮对话中复用视觉 token，不重复编码 提示优化：如果用户只问图片的局部信息，裁剪 ROI 区域再编码 ``` **差距在哪**：新手只有“转向量”三个字。高手从 patch embedding → ViT → 投影对齐完整说清了图片编码流程，且给出了五种 token 缩减方案和工程组合策略。面试官考的是你对多模态模型实现细节的理解深度——不是“知道能处理图片”，而是“知道图片怎么变成模型输入、成本怎么控制”。 --- ### Q：你了解哪些多模态大模型？各自的特点？ > 来源：腾讯 Agent 应用开发一面 **新手答**：“GPT-4V 可以看图。” **高手答**： 多模态大模型按架构和能力分几类： | 模型 | 架构特点 | 擅长场景 | |------|---------|---------| | GPT-4o | 原生多模态，文本/图像/音频统一处理 | 通用多模态理解和生成 | | Claude 3.5 Sonnet | 视觉理解 + 长文本，图表和文档分析强 | 复杂文档理解、代码截图分析 | | Qwen2.5-VL / Qwen3-VL | 开源，支持动态分辨率和视频理解 | 中文场景、本地部署 | | LLaVA 系列 | 开源，visual encoder + LLM 两阶段训练 | 学术研究、定制微调 | | InternVL | 开源，ViT + LLM，多分辨率策略 | 细粒度视觉理解 | | Gemini | 原生多模态，长上下文（100 万 token） | 长视频理解、大规模文档处理 | 选型关键：不是“哪个最强”，而是**场景匹配**—— - 需要部署到本地 → Qwen-VL、InternVL（开源可控） - 需要文档理解 → Claude（长文本 + 图表理解） - 需要视频分析 → Gemini（长上下文）、Qwen-VL（视频理解） - 需要微调 → LLaVA、Qwen-VL（开源 + 社区活跃） **差距在哪**：新手只知道一两个。高手按架构和场景做了系统对比。面试官考的是你对多模态模型生态的广度认知。 --- ### Q：有没有了解过端侧部署的模型？ > 来源：腾讯 Agent 应用开发一面 **新手答**：“手机上跑不了大模型吧。” **高手答**： 端侧部署已经是可行的工程实践，关键是**模型够小 + 量化够狠 + 推理框架够优化**。 **端侧可部署的模型**： - **Qwen2.5-0.5B/1.5B/3B**：阿里小参数模型，INT4 量化后可在手机/边缘设备运行 - **Phi-3-mini（3.8B）**：微软小模型，专为端侧优化，ONNX Runtime 支持 - **Gemma 2B**：Google 开源小模型，TensorFlow Lite 部署 - **LLaMA 3.2 1B/3B**：Meta 专为移动端发布的小模型 **端侧推理框架**： - **llama.cpp**：C++ 实现，支持 GGUF 格式量化，跨平台（Mac/Linux/Android/iOS） - **MLC-LLM**：基于 TVM 编译优化，支持 GPU 加速 - **MediaPipe LLM**：Google 出品，Android/iOS 原生支持 - **ONNX Runtime Mobile**：微软出品，支持多种硬件后端 **量化是端侧部署的关键**：3B 模型 FP16 约 6GB，INT4 量化后约 1.5GB——手机内存可以承受。精度损失通常在 1-3% 以内，对大部分应用场景可接受。 端侧部署的价值不只是“省钱”，更重要的是**隐私保护**（数据不出设备）和**离线可用**（无需网络）。 **差距在哪**：新手认为端侧不可行。高手列出了具体可部署的模型、推理框架和量化方案。面试官考的是你对模型部署的工程认知广度。 --- ### Q：OCR、多模态模型、YOLO 与 ONNX 分别处于任务、模型和运行时哪个层次？如何组合？ > 来源：[北京金蝶二面](https://www.nowcoder.com/feed/main/detail/6edec13bc5f34f0ca137b4a4911dcb10) **新手答**：“它们都是视觉模型，YOLO 做检测，OCR 识别文字，最后可以转成 ONNX。” **高手答**： 这四个词不在同一抽象层： | 名称 | 层次 | 解决的问题 | |------|------|------------| | OCR | 任务/系统 | 从图像或文档中定位并识别文字，常包含检测、识别、版面与后处理 | | YOLO | 模型家族 | 典型能力是目标检测，也可扩展到分割、分类、姿态等；它可以检测文本区域，但不是完整 OCR | | 多模态模型 | 模型/应用 | 联合处理图像、文本、音频等输入，做理解、生成或跨模态推理 | | ONNX | 交换表示 | 用版本化计算图、数据类型和算子描述模型；它不是模型类型，也不是推理引擎 | ONNX [官方规范](https://onnx.ai/onnx/repo-docs/IR.html)把它定义为可扩展计算图 IR，具体执行仍由 ONNX Runtime、TensorRT 等 Runtime 完成。Ultralytics 的 [YOLO 导出文档](https://docs.ultralytics.com/modes/export/)也展示了同一个检测模型可以导出为 ONNX，再交给相应 Runtime 部署。这说明“YOLO”和“ONNX”分别回答**模型做什么**与**模型怎样跨工具链交付**。 一个文档理解系统可以这样组合： ```text 图像/PDF → 版面或文字区域检测（可选 YOLO/专用 Detector） → 文字识别与表格/阅读顺序恢复（OCR） → 结构化文本、坐标与置信度 → 多模态模型结合原图和 OCR 证据推理 → 将可部署的子模型导出为 ONNX，并在目标 Runtime 验证 ``` 部署验收还要锁定预处理、动态 Shape、opset、Tokenizer/词表、后处理和数值误差。导出成功只证明图能序列化，不证明目标硬件支持全部算子，也不证明端到端结果一致。 **差距在哪**：新手把四个名词并列背诵，高手能区分任务、模型、IR 和 Runtime，并画出可验证的组合链路。 --- ### Q：如何优化大模型在长文本生成中的显存占用？ > 来源：字节 Agent 实习一面 **新手答**：“用更大显存的 GPU。” **高手答**： 长文本生成的显存瓶颈主要在 **KV Cache**——它随序列长度线性增长。一个 7B 模型生成 32K token 时，KV Cache 可能占到 16GB+。优化分四个方向： **1. KV Cache 管理**： - **PagedAttention**（vLLM）：把 KV Cache 分成固定大小的 page，按需分配，避免预留大块连续显存。显存浪费从 60-80% 降到 <4% - **滑动窗口注意力**（Mistral）：只保留最近 N 个 token 的 KV Cache，超出窗口的丢弃。适合不需要完整长距离依赖的场景 - **KV Cache 量化**：对 KV 缓存做 FP8/INT8 量化，显存占用减半，精度损失微小 **2. 注意力机制优化**： - **Flash Attention**：优化 attention 计算的内存访问模式，不把完整的 attention matrix 写入 HBM，而是用 tiling 技术在 SRAM 上分块计算。显存从 O(N²) 降到 O(N) - **GQA（Grouped Query Attention）**：多个 query head 共享一组 KV head。LLaMA 3 用 8 组 GQA，KV Cache 直接缩减到 1/4 **3. 模型级优化**： - **量化部署**：INT4/INT8 量化让模型参数本身占用缩小 2-4 倍 - **梯度检查点**（训练时）：不保留所有层的中间激活值，需要时重新计算。以时间换空间，显存降 60%+ **4. 系统级优化**： - **Offloading**：把不活跃的 KV Cache 或模型层卸载到 CPU 内存/NVMe，需要时再加载回 GPU - **Tensor Parallel**：把模型参数和 KV Cache 分布到多卡上，单卡显存压力线性下降 **差距在哪**：新手只想到换硬件。高手从 KV Cache 管理、注意力优化、模型压缩、系统调度四个层面给出了具体方案，且说清了每个方案的原理和效果。面试官考的是你对 Transformer 推理过程中显存消耗细节的理解。 --- ### Q：Transformer 中梯度消失/爆炸是怎么解决的？ > 来源：字节 Agent 实习一面 **新手答**：“用 BatchNorm。” **高手答**： Transformer 架构本身就包含了多种防止梯度消失/爆炸的设计，这些不是“加上去的补丁”，而是**架构内建的稳定性保障**： **1. 残差连接（Residual Connection）**： - 每个子层（Attention、FFN）的输出都加上输入：`output = LayerNorm(x + SubLayer(x))` - 梯度可以通过残差通道直接回传，不经过非线性变换，避免深层网络梯度消失 - 这是最关键的设计——没有残差连接，Transformer 深到 6 层就很难训练 **2. Layer Normalization**： - 对每个样本的特征维度做归一化，稳定每层输入的分布 - **Pre-Norm**（GPT 系列）vs **Post-Norm**（原始 Transformer）：Pre-Norm 把 LayerNorm 放在子层之前，训练更稳定，但理论上限略低；Post-Norm 理论上限高但训练不稳定。当前大模型几乎都用 Pre-Norm - RMSNorm（LLaMA）进一步简化，去掉均值中心化，只做方差归一化 **3. 缩放点积注意力**： - `softmax(QK^T / √d_k)` 中的 `√d_k` 就是为了防止梯度消失——d_k 越大，点积值越大，softmax 输出越接近 one-hot，梯度趋近于零 **4. 权重初始化**： - Xavier / He 初始化确保前向传播和反向传播时每层的方差稳定 - GPT 系列对残差分支做特殊缩放：`1/√(2N)`（N 是层数），防止深层模型的残差累积导致梯度爆炸 **5. 梯度裁剪（Gradient Clipping）**： - 训练时设置梯度范数上限（通常 1.0），超过就按比例缩小。这是防止梯度爆炸的最后一道防线 - 大模型训练几乎必用，否则 loss spike 可能直接导致训练崩溃 **6. 学习率 Warmup**： - 训练初期用很小的学习率逐步增大，避免随机初始化阶段梯度方向不稳定时做大步更新引发爆炸 **差距在哪**：新手只知道 BatchNorm（且 Transformer 不用 BatchNorm）。高手从残差连接、归一化、缩放注意力、初始化、梯度裁剪、Warmup 六个层面系统梳理了 Transformer 的梯度稳定机制，且说清了每个设计的动机。面试官考的是你对 Transformer 架构设计“为什么这么设计”的理解深度。 --- ## 注意力机制与复杂度 ### Q：Token 过长导致的 Attention 稀释现象为什么会导致 Agent 的指令遵循能力下降？ > 来源：淘天 AI Agent 一面 **新手答**：“上下文太长模型就处理不好。” **高手答**： 这个问题的核心在于 **Softmax 注意力的概率质量守恒**——注意力分数经过 softmax 后总和恒为 1，当序列长度从 N 增长到 10N，每个 token 能分到的平均注意力权重就从 1/N 缩小到 1/10N。这就是 **Attention 稀释（Attention Dilution）**。 **Softmax 稀释的数学直觉**： ```text Attention(Q, K, V) = softmax(QK^T / √d_k) · V softmax 输出是概率分布，总和 = 1 - 4K 上下文：每个 token 平均注意力 ≈ 1/4000 = 0.025% - 100K 上下文：每个 token 平均注意力 ≈ 1/100000 = 0.001% 系统指令通常在序列开头，占比固定（比如 200 token）： - 4K 上下文：系统指令占比 200/4000 = 5% - 32K 上下文：系统指令占比 200/32000 = 0.625% - 100K 上下文：系统指令占比 200/100000 = 0.2% ``` **为什么系统指令最先“被遗忘”**： ```mermaid flowchart LR A[“系统指令\n（序列开头）”] --> B[“大量中间对话\n工具返回结果”] B --> C[“最新用户输入\n（序列末尾）”] style A fill:#f66,stroke:#333,color:#fff style B fill:#ffa,stroke:#333 style C fill:#6f6,stroke:#333 ``` 这涉及 **Lost in the Middle** 现象——研究表明模型对序列开头和末尾的关注度最高，中间部分的信息检索准确率可以下降 20% 以上。但当序列极长时，即使是开头的系统指令也会被稀释： 1. **位置编码衰减**：RoPE 等位置编码在长距离上的区分度下降，模型难以精确定位远处的指令 token 2. **KV Cache 中的竞争**：后续对话和工具结果不断注入新 token，这些新 token 在语义上与当前查询更相关，进一步抢占了系统指令的注意力份额 3. **训练分布偏移**：多数模型在中短上下文上训练更充分，超长上下文下的注意力分配模式偏离训练时的分布 **对 Agent 的具体影响**： | 影响 | 表现 | 示例 | |------|------|------| | 指令遵循退化 | 忘记角色设定和输出约束 | 系统指令要求用 JSON 输出，10 轮后开始输出自然语言 | | 工具选择混乱 | 不再按指令优先级选工具 | 应该先查数据库，却随机调了搜索引擎 | | 格式约束失效 | 输出格式逐渐偏离模板 | 前几轮严格遵循格式，后面越来越随意 | | 安全护栏松动 | 安全约束被稀释后更容易被绕过 | 前 3 轮拒绝越狱提示，20 轮后被攻破 | **工程缓解策略**： | 策略 | 原理 | 实现成本 | |------|------|---------| | **末尾重复注入** | 在每轮输入末尾重复关键指令，利用 recency bias | 低——改 prompt 模板即可 | | **结构化标记** | 用 `` 等特殊标记包裹关键指令，增强显著性 | 低 | | **上下文压缩** | 定期用模型总结历史对话，只保留关键信息，缩短序列长度 | 中——需要额外一次模型调用 | | **关键约束外置** | 把核心约束（预算、角色、格式）写入独立状态存储，每轮强制注入 | 中 | | **滑动窗口 + 锚点** | 历史消息用滑动窗口截断，但系统指令作为锚点始终保留在窗口内 | 中 | **差距在哪**：新手只说“处理不好”三个字——连症状都没描述清楚。高手从 softmax 的概率守恒出发，解释了注意力稀释的数学机制，再到 Lost in the Middle、位置编码衰减等具体成因，最后给出五种工程缓解策略。面试官考的是你对 Attention 机制的量化理解——不是“知道长了不好”，而是“知道为什么不好、不好到什么程度、怎么缓解”。 --- ### Q：在 Agent 多轮对话任务中，标准 Attention 机制的平方复杂度在工程落地上主要引发了哪些问题？ > 来源：淘天 AI Agent 一面 **新手答**：“用更大的 GPU。” **高手答**： 标准 Self-Attention 的计算和内存复杂度都是 **O(N²)**，其中 N 是序列长度。这个平方关系在 Agent 多轮对话场景下会被急剧放大，因为 Agent 的上下文增长速度远快于普通对话。 **平方复杂度的来源**： ```text Attention 矩阵 = Q × K^T → 形状 [N, N] 内存占用：N × N × 2 bytes（FP16） - 4K tokens： 4K × 4K × 2 = 32 MB ✅ 轻松 - 32K tokens： 32K × 32K × 2 = 2 GB ⚠️ 开始吃力 - 128K tokens：128K × 128K × 2 = 32 GB ❌ 超出单卡显存 计算量：2 × N² × d（d 为 head 维度） - N 翻倍 → 计算量翻 4 倍 ``` **Agent 场景为什么特别痛**： 普通对话可能 5-10 轮结束，但 Agent 任务的上下文增长有其特殊性： ```mermaid flowchart TD A[“第 1 轮\n用户指令 + 系统提示\n~1K tokens”] --> B[“第 2 轮\n+ 模型思考 + 工具调用\n~3K tokens”] B --> C[“第 3 轮\n+ 工具返回结果（可能很大）\n~8K tokens”] C --> D[“第 5 轮\n+ 多次工具调用结果\n~20K tokens”] D --> E[“第 10 轮\n累计上下文\n~50K+ tokens”] style A fill:#6f6,stroke:#333 style C fill:#ffa,stroke:#333 style E fill:#f66,stroke:#333,color:#fff ``` | Agent 特有的问题 | 具体表现 | 影响 | |-----------------|---------|------| | **上下文逐轮膨胀** | 每轮新增模型推理 + 工具调用 + 工具结果，上下文线性增长 | 第 N 轮的 Attention 计算量是第 1 轮的 N² 倍增长 | | **工具结果尺寸不可控** | 数据库查询返回几百行、网页抓取返回整页 HTML | 单次工具调用就可能让上下文暴涨数千 token | | **延迟逐步恶化** | 每生成一个新 token 都要对全量上下文做 Attention | 用户等待时间随对话轮次越来越长 | | **成本不可预测** | token 用量呈超线性增长，实际花费难以提前估算 | 一个复杂任务可能烧掉远超预算的费用 | **工程解决方案对比**： | 方案 | 原理 | 内存复杂度 | 计算复杂度 | 质量损失 | 适用场景 | |------|------|-----------|-----------|---------|---------| | **Flash Attention** | 分块计算 Attention，避免完整 N×N 矩阵写入显存 | O(N) | O(N²)（但常数小很多） | 无损 | 通用，所有场景首选 | | **KV Cache** | 缓存已计算的 K、V，新 token 只算增量 Attention | O(N) | 单 token 生成 O(N) | 无损 | 自回归生成必备 | | **GQA / MQA** | 多个 Query Head 共享 KV Head，减少 KV Cache 大小 | O(N/G) | O(N²/G) | 极小 | LLaMA 3、Gemma 等主流模型已内置 | | **滑动窗口注意力** | 每个 token 只关注最近 W 个 token | O(N×W) | O(N×W) | 丢失远距离依赖 | Mistral、对长距离依赖要求低的场景 | | **上下文压缩** | 用模型总结历史对话，只保留摘要 | O(N') | O(N'²)，N' ≪ N | 信息有损 | 超长多轮对话 | | **分层注意力** | 局部用全注意力，全局用稀疏注意力 | O(N√N) | O(N√N) | 略有损失 | 超长文档处理 | **实际工程中的组合方案**： ```text 基础层：Flash Attention + KV Cache（零损失提速，必选） 模型层：GQA（选用内置 GQA 的模型，如 LLaMA 3） 应用层：上下文管理策略 ├─ 工具结果截断：限制每次工具返回的最大 token 数 ├─ 历史压缩：每 5 轮对历史消息做摘要压缩 └─ 关键信息外置：核心状态存数据库，不占上下文空间 ``` **差距在哪**：新手只想到堆硬件——这是最贵且最不可扩展的方案。高手理解 O(N²) 的算法根因，知道 Agent 场景下上下文增长有“工具结果不可控”等特殊性，并从算法层（Flash Attention）、模型层（GQA）、应用层（上下文管理）三个层面给出了组合方案。面试官考的是你对 Attention 复杂度问题的工程化思考——不是“知道 N² 很大”，而是“知道在 Agent 场景下具体大在哪、怎么在不同层级上逐个击破”。 --- --- ## 训练策略与实践 ### Q：SFT、蒸馏、GRPO 的技术选型——什么时候用什么？ > 来源：阿里国际大模型算法一面 【腾讯金融科技一面追问：蒸馏时如何防止小模型学到大模型的错误推理链】 **新手答**：“数据多就 SFT，数据少就蒸馏。” **高手答**： 这三种方法解决的是**不同层次的问题**，不是简单的“数据多少”能决定的： | 方法 | 核心作用 | 最适合的场景 | |------|---------|------------| | **SFT（监督微调）** | 教模型特定格式、领域知识或行为模式 | 有高质量（输入, 输出）标注对，需要格式遵循或领域适配 | | **蒸馏（Distillation）** | 把大模型的能力迁移到小模型 | 有强大的教师模型，需要低成本部署 | | **GRPO/RLHF** | 对齐人类偏好，提升推理质量 | SFT 到瓶颈后，需要超越监督学习上限 | **决策框架**： | 条件 | 推荐方法 | 原因 | |------|---------|------| | 有高质量标注数据 + 格式/领域适配 | SFT | 直接学习目标分布 | | 有大模型但需要部署到小模型 | 蒸馏 | 保留能力，降低成本 | | SFT 后效果到瓶颈 + 有奖励信号 | GRPO | 超越监督学习上限 | | 需要提升推理/数学能力 | GRPO > SFT | RL 探索能发现 SFT 数据中没有的推理路径 | | 数据量少但质量高 | SFT + 蒸馏 | 先 SFT 对齐格式，再蒸馏压缩 | **为什么推理任务 GRPO 优于 SFT？** SFT 学的是**模仿**——训练数据里有什么解法，模型就学什么解法，天花板就是数据质量。GRPO 学的是**探索**——模型自己尝试多种解法，通过奖励信号强化成功路径。对于数学和代码任务，GRPO 能发现训练数据中不存在的新推理路径，这是 SFT 做不到的。 **实际工程中的标准流水线**： ```mermaid flowchart LR A["SFT\n建立基线"] --> B["GRPO\n突破 SFT 天花板"] B --> C["蒸馏\n压缩部署"] style A fill:#6f6,stroke:#333 style B fill:#ffa,stroke:#333 style C fill:#69f,stroke:#333 ``` 先 SFT 建立格式和领域基线 → 再 GRPO 推动能力突破 → 最后蒸馏压缩到部署可用的小模型。三者不是互斥的，而是流水线上的不同阶段。 **GRPO 训练过程中的关键监控指标**： | 指标 | 健康信号 | 异常信号 | |------|---------|---------| | Reward 均值/标准差 | 均值上升，标准差下降（收敛） | 均值不涨或标准差持续很大 | | KL 散度 | 保持在可控范围内 | 持续发散，说明偏离参考策略太远 | | 响应长度 | 稳定或缓慢增长 | 长度暴涨——可能是 reward hacking（模型通过拉长回答来刷分） | | Pass@k（代码/数学） | 稳步提升 | 停滞说明 reward 信号不够好 | | 组内 Advantage 方差 | 适中 | 太低说明组大小 G 可能太小，区分度不够 | **差距在哪**：新手只考虑数据量这一个维度。高手有系统的决策框架——按任务类型、能力差距和部署约束选择方法，清楚 SFT→GRPO→蒸馏的标准流水线，且知道 GRPO 训练过程中该监控什么。面试官考的是你能不能根据实际场景做技术选型，而不是背方法名。 **追问：SFT 为什么不够？什么时候必须上 RL？** > 来源：快手推荐算法二面 SFT 和 RL 的核心区别是**模仿 vs 探索**： | 维度 | SFT | RL（GRPO/PPO） | |------|-----|---------------| | 学习方式 | 模仿标注数据中的解法 | 自己探索，奖励信号引导 | | 天花板 | 训练数据的质量上限 | 可以超越训练数据 | | 适合任务 | 格式对齐、领域适配、知识注入 | 推理、创造性问题解决、偏好对齐 | **SFT 不够的三个典型场景**： 1. **训练数据中没有最优解法**：数学题的标准答案只有一种解法，但可能存在更优雅的推理路径——SFT 永远学不到数据里没有的东西，RL 能通过探索发现 2. **需要对齐人类偏好，而偏好难以显式标注**：“哪个回答更好”比“写一个完美回答”容易标注得多——这正是 RL 从偏好对中学习的优势 3. **模型已经“会”但不够“精”**：SFT 后模型能做对 60% 的题，但剩下 40% 不是“不知道”而是“推理不够严谨”——RL 通过反复尝试和奖励反馈来强化严谨推理 **判断是否需要上 RL 的决策标准**： ```text SFT 后评估 → pass@1 和 pass@k 的差距大吗？ 差距大（如 pass@1=40%, pass@k=80%）： → 模型"会"但不稳定，RL 能稳定输出质量 ✅ 上 RL 差距小（如 pass@1=40%, pass@k=45%）： → 模型根本不会，RL 也救不了 ❌ 先加数据/换模型 pass@1 已经很高（>90%）： → SFT 已经够了 ❌ 不需要 RL ``` 核心洞察：**pass@1 和 pass@k 的差距是 RL 价值的最好预测指标**——差距大说明模型有潜力但不稳定，RL 的作用就是把 pass@k 的能力稳定到 pass@1。 --- ### Q：GRPO 的 Loss 函数、Advantages 计算与信用分配机制 > 来源：阿里国际大模型算法一面 【阿里国际一面追问：GRPO训练中观测什么指标】 **新手答**：“就是 RLHF 的 loss。” **高手答**： GRPO 的 Loss 函数看起来和 PPO 类似，但每一项的计算方式都不同： ```text L_GRPO = -E[min(r(θ)·A, clip(r(θ), 1-ε, 1+ε)·A)] + β·KL(π_θ ∥ π_ref) ``` 其中 r(θ) = π_θ(o|q) / π_old(o|q) 是重要性采样比率。 **Advantages 的计算——“Group Relative”的含义**： GRPO 名字中的“Group Relative”指的就是 Advantages 的计算方式： 1. 对每个 query q，用当前策略采样 G 个响应 {o_1, ..., o_G} 2. 用奖励模型（或规则）得到每个响应的奖励 {r_1, ..., r_G} 3. **组内标准化**：A_i = (r_i - mean(r)) / std(r) ```text 举例：query = "求解 x² - 5x + 6 = 0" 采样 5 个响应，奖励分别为 [1.0, 0.0, 1.0, 0.5, 0.0] mean = 0.5, std = 0.447 A = [1.12, -1.12, 1.12, 0, -1.12] 正 Advantage → 强化（比组内平均好） 负 Advantage → 抑制（比组内平均差） 零 Advantage → 不变（刚好等于平均） ``` **为什么用 Advantages 而不是原始奖励？** | 问题 | 原始奖励 | 组内相对 Advantages | |------|---------|-------------------| | 方差 | 高——简单题高分，难题低分，梯度波动大 | 低——每组内标准化，消除题目难度差异 | | 基线 | 无——所有正奖励都强化，即使是组内最差的 | 组均值自动充当基线，只强化组内较好的 | | 方向信号 | 模糊——奖励 0.6 是好是差取决于任务难度 | 清晰——正值就是比同组平均好，负值就是差 | 组内均值本质上等价于 PPO 中 Critic 提供的基线，但**不需要训练额外的 Value Model**——这正是 GRPO 去掉 Critic 的关键。 **信用分配——从序列级奖励到 token 级学习**： GRPO 对整个响应只给一个奖励 R，但梯度更新是 token 级别的。这中间的映射是怎么做的？ 通过自回归分解，序列级的 log 概率等于每个 token 的 log 概率之和： ```text log π_θ(o|q) = Σ_{t=1}^{T} log π_θ(o_t | q, o_{ 来源：快手大模型推荐算法一面 / 美团大模型应用算法一面 **全 0 / 全 1 奖励问题——Advantages 退化**： 当同一组 G 个采样的奖励全部相同时，std(r) = 0，组内标准化公式 A_i = (r_i - mean) / std 会除零或全部为 0——梯度信号消失，这组样本对训练完全无贡献。 | 情况 | 根因 | 对训练的影响 | 解决方案 | |------|------|------------|---------| | 全 0（全错） | 题目太难，当前策略无法生成正确答案 | Advantages 全 0，无学习信号 | 课程学习：先用简单题热身，逐步增加难度 | | 全 1（全对） | 题目太简单，任何采样都能做对 | Advantages 全 0，无区分信号 | 移除已“学会”的简单题，动态调整训练集 | | 同质化 | 组大小 G 太小或 temperature 太低 | 采样多样性不够，容易全同 | 增大 G（如 16→64）+ 提高采样 temperature | **工程上的标准做法**： ```text 1. 动态题目过滤：每个 epoch 前预跑一轮评估，移除 pass rate > 0.95 和 < 0.05 的题目 2. 分桶采样：按题目难度分桶，训练时从中等难度桶多采样 3. std 兜底：当 std(r) < ε 时，跳过该组不计算梯度，避免数值不稳定 4. 混合奖励：不只看最终结果对错（0/1），加入格式分、步骤分等连续奖励，增加区分度 ``` **单步问题是否需要 GRPO？** 对于“查 x 的值”这类**单步就能判对错**的题目，GRPO 仍然有价值，但价值来源不同： - **SFT 只学一条路径**：训练数据里怎么解，模型就怎么解。如果数据里的解法对当前模型来说很难模仿，SFT 效率低 - **GRPO 探索多条路径**：采样 G 个解法，奖励高的强化、低的抑制。即使是单步问题，模型可能有多种表述/格式/中间推理方式，GRPO 能找到当前模型最容易复现的那条 但如果题目真的简单到所有采样都对（全 1 问题），那确实不需要 GRPO——这类题 SFT 就能搞定，用 GRPO 反而浪费算力。判断标准是**当前模型在该题上的 pass rate 是否在 0.1-0.9 之间**——只有在这个区间内，GRPO 的组内对比才有区分度。 --- ### Q：vLLM 的 PagedAttention 原理是什么？解决了什么问题？ > 来源：快手AI应用开发一面【[华为 - 大模型算法岗（AI Infra / 训练优化）](https://www.nowcoder.com/discuss/926272625410674688)追问：vLLM PagedAttention 如何解决碎片？】【[阿里巴巴（阿里云）- Agent Infra](https://www.nowcoder.com/discuss/926273487512113152)追问：vLLM 的 PagedAttention 如何解决显存碎片问题？】 **新手答**：“vLLM 速度快，用了一些优化。” **高手答**： PagedAttention 解决的核心问题是：**KV Cache 的内存碎片化和浪费**。 **背景问题**：LLM 推理时，每个请求需要一块连续内存存储 KV Cache（Key-Value 缓存），长度等于序列长度。传统方案预分配最大长度的连续内存块——但实际请求长度不一，导致大量内存碎片和浪费（浪费率可达 60-80%）。 **PagedAttention 的核心思想**：借鉴操作系统的虚拟内存分页机制——把 KV Cache 拆成固定大小的“页”（block），按需分配，不要求物理连续。 ```text 传统方案：每个请求预分配 max_seq_len 的连续内存 → 短请求浪费大量空间，无法服务更多并发 PagedAttention：KV Cache 分成固定大小的 block（如 16 tokens/block） → 按需分配 block，用页表映射逻辑地址到物理地址 → 不同请求的 block 可以交错存储在 GPU 显存中 ``` **具体机制**： | 组件 | 作用 | |------|------| | Block | 固定大小的 KV Cache 存储单元（如 16 tokens 的 K 和 V） | | Block Table | 每个序列维护一个页表，记录逻辑 block → 物理 block 的映射 | | Block Allocator | 管理空闲 block 池，按需分配和回收 | | Copy-on-Write | 多个序列共享相同前缀时（beam search），共享 block 直到分叉 | **解决的三个关键问题**： 1. **内存碎片**：block 固定大小，无碎片；分配回收都是整 block 操作 2. **内存浪费**：按需分配，序列结束立即回收；不预分配最大长度 3. **并发吞吐**：同样的 GPU 显存能服务 2-4 倍的并发请求（因为浪费减少了） **和操作系统虚拟内存的类比**： | OS 概念 | PagedAttention 对应 | |---------|-------------------| | 虚拟页 | 逻辑 block（序列中的第 i 个 block） | | 物理页帧 | 物理 block（GPU 显存中的实际存储位置） | | 页表 | Block Table | | 缺页中断 | 序列生成新 token 时分配新 block | **差距在哪**：新手只知道“vLLM 快”——没有触及原理。高手从 KV Cache 内存问题出发，讲清了分页思想和具体机制，且用 OS 虚拟内存做类比让面试官秒懂。面试官考的是你对推理优化底层原理的理解——不是调参，是理解为什么这个设计能提升吞吐。 --- ### Q：DP、DDP、TP、PP——分布式训练并行策略的区别与选型？ > 来源：荣耀大模型算法实习一面【[0907 百度一面 （AI Infra）](https://www.nowcoder.com/feed/main/detail/91f5187146864de5878349a2ecf497ce)追问：大模型中的大矩阵乘法，例如流水线并行或张量并行，你了解吗？】 **新手答**：“多卡就用数据并行。” **高手答**： 分布式训练的四种并行策略解决的是**不同瓶颈**，不是“多卡就行”： | 并行策略 | 全称 | 切分什么 | 解决什么瓶颈 | |---------|------|---------|------------| | **DP** | Data Parallelism | 数据 | 训练速度（单卡吞吐不够） | | **DDP** | Distributed Data Parallelism | 数据 | DP 的通信效率（AllReduce 替代 PS） | | **TP** | Tensor Parallelism | 模型层内的权重矩阵 | 单层参数太大，一张卡放不下 | | **PP** | Pipeline Parallelism | 模型的层（跨层切分） | 总参数太多，一张卡放不下 | **DP vs DDP——数据并行的两代方案**： ```text DP（PyTorch DataParallel）： 主卡聚合梯度 → 主卡更新参数 → 广播到其他卡 问题：主卡成为通信瓶颈，GPU 利用率不均衡 DDP（DistributedDataParallel）： 每张卡独立前向+反向 → AllReduce 同步梯度 → 各卡独立更新 优势：无主卡瓶颈，通信与计算可重叠（bucket gradient AllReduce） ``` 生产环境**只用 DDP，不用 DP**——DP 的主卡瓶颈在多卡场景下严重拖慢训练速度。 **TP vs PP——模型并行的两种切法**： ```text TP（层内切分）： 一个 Attention 层的 Q/K/V 权重矩阵按列切分到多张卡 → 每张卡算一部分，再 AllReduce 合并 → 通信频繁（每层都要通信），但延迟低（层内并行） PP（层间切分）： 前 N 层放卡 0，后 N 层放卡 1 → micro-batch 流水线调度，减少 bubble（空闲等待） → 通信少（只在层间边界传激活值），但有 pipeline bubble ``` **选型决策框架**： ```mermaid flowchart TB Q["模型放得下单卡吗？"] -->|"是"| A["DDP\n（数据并行加速训练）"] Q -->|"否"| Q2["单层放得下单卡吗？"] Q2 -->|"是"| B["PP + DDP\n（层间切分 + 数据并行）"] Q2 -->|"否"| C["TP + PP + DDP\n（三维并行）"] ``` **实际大模型训练的三维并行**： 训练 70B+ 的大模型时，通常三种并行同时使用： | 维度 | 策略 | 范围 | |------|------|------| | 节点内（同机多卡） | TP | 利用 NVLink 高带宽，适合频繁通信 | | 节点间（跨机） | PP | 跨机带宽低，PP 通信量小 | | 全局 | DDP | 在 TP+PP 分组上再做数据并行 | Megatron-LM 和 DeepSpeed 的 3D 并行就是这个思路：TP 在机内、PP 在机间、DDP 在全局。 **差距在哪**：新手只知道“多卡数据并行”。高手区分了四种并行策略的适用场景——DP/DDP 解决速度问题，TP/PP 解决显存问题，且知道生产环境的三维并行组合方案。面试官考的是你对大模型训练基础设施的系统性理解。 --- ### Q：深度学习网络中的「残差连接」解决了什么问题？其物理含义是什么？ > 来源：字节后端 Agent 开发二面 【淘天Agent开发同题：传统 CNN 痛点 + ResNet 核心思想】 **新手答**：“解决梯度消失问题。” **高手答**： 残差连接（Residual Connection）解决的核心问题是**网络退化问题**（degradation problem），而不仅仅是梯度消失： **网络退化 ≠ 梯度消失** | 问题 | 表现 | 残差连接怎么解决 | |------|------|-----------------| | 梯度消失 | 深层梯度趋近于 0，参数无法更新 | 提供梯度直通通道，跳过非线性层 | | 网络退化 | 网络越深，训练误差反而越高（不是过拟合） | 让网络学习「残差」而非「完整映射」 | **物理含义——从「学整体」变成「学偏差」** ```text 传统网络： 输出 = F(x) # 直接学习目标映射 残差网络： 输出 = x + F(x) # 学习与输入的差异（残差） ``` 为什么学残差更容易？如果最优解接近恒等映射（输出 ≈ 输入），传统网络需要让 F(x) ≈ x，这对非线性网络来说很难学；而残差网络只需要让 F(x) ≈ 0，把参数推向零比拟合一个恒等变换容易得多。 **在 Transformer 中的关键作用**： Transformer 的每一层都是 `LayerNorm(x + Attention(x))` 或 `LayerNorm(x + FFN(x))`，残差连接贯穿始终。没有残差连接，Transformer 深到 6 层就难以训练。具体作用： 1. **梯度高速公路**：反向传播时梯度可以通过残差连接直接回传到浅层，不经过注意力层的非线性变换 2. **特征保持**：每一层在原始特征的基础上「增量修改」，浅层学到的有用特征不会被深层覆盖 3. **训练稳定性**：即使某一层的学习效果差，残差连接保证输出不会比输入更差（最差情况 F(x) = 0，输出 = 输入） **差距在哪**：新手只记住了「解决梯度消失」这个标准答案。高手区分了梯度消失和网络退化两个不同问题，且从「学残差比学完整映射更容易」的角度解释了物理含义。面试官考的是你对深度网络核心设计的理解深度。 --- ### Q：什么是灾难性遗忘？微调时如何缓解？ > 来源：字节春招大模型测开一面【[阶跃星辰（Stepfun）- 大模型算法岗（Post-train）](https://www.nowcoder.com/discuss/926273007276814336)追问：后训练中避免灾难性遗忘的方法？】 **新手答**：“就是模型学了新东西忘了旧东西。” **高手答**： 灾难性遗忘（Catastrophic Forgetting）是神经网络的固有问题：当模型在新任务/新数据上训练时，权重更新会覆盖掉之前学到的知识，导致旧任务性能急剧下降。 **为什么会发生**： 神经网络的知识存储在权重中，且是**分布式存储**——同一组权重同时承载多个任务的知识。当新任务的梯度更新这些权重时，旧任务的“记忆”就被破坏了。这不像数据库可以增量写入，更像是在同一块画布上反复覆盖绘画。 **大模型微调中的典型表现**： - 垂直领域 SFT 后，模型在通用 benchmark 上分数暴跌 - 学会了新格式/新任务，但之前能做的基础任务（数学、代码、常识问答）退化 - 多轮 RLHF 后模型变得过度安全、回避性强，丧失有用性 **缓解方案（按成本从低到高）**： 1. **LoRA/QLoRA** — 冻结原始权重，只训练低秩增量。原始知识完整保留在冻结参数中，新知识存储在 LoRA adapter 中 2. **数据混合（Replay）** — 微调数据中混入一定比例的通用数据（如 5-10% 的 pretraining 数据），防止通用能力退化 3. **学习率控制** — 用极小的学习率（1e-5 量级）做 SFT，限制权重偏移幅度 4. **EWC（弹性权重巩固）** — 计算每个参数对旧任务的重要性，重要参数的更新幅度受约束 5. **模型合并（Model Merging）** — 分别微调多个 adapter，最后用 TIES/DARE 等方法合并权重，保留各任务能力 **实际工程中最常用的组合**：LoRA + 数据混合 + 小学习率。三者叠加基本能解决 90% 的遗忘问题。 **差距在哪**：新手只知道现象。高手能解释底层原因（权重分布式存储 + 梯度覆盖），并给出分层的缓解方案，且知道实际工程中用哪几招组合最有效。面试官考的是你对微调风险的认知和工程应对。 --- ### Q：设计一个 Text-to-SQL 训练集构建方案——500 条样本覆盖 200+ 查询模式，如何设计数据生产流？ > 来源：淘天 AI Agent 一面（场景题） **新手答**：“让标注团队写 500 条 SQL。” **高手答**： 500 条真实标注覆盖 200+ 模式，意味着**每个模式平均不到 2.5 条样本**——纯靠人工标注不可能覆盖所有模式的变体。必须用**真实标注 + 合成数据 + 质量控制**的三阶段生产流。 **整体数据生产流**： ```mermaid flowchart TB subgraph stage1["阶段一：种子数据分析"] A1["500 条真实标注"] --> A2["按查询模式分类\n（单表/多表/聚合/嵌套/...）"] A2 --> A3["统计每个模式的覆盖量\n找出覆盖不足的模式"] end subgraph stage2["阶段二：数据合成"] B1["模板化合成\n基于 SQL 模板 + 槽位替换"] B2["LLM 改写合成\n基于种子样本做多样化改写"] B3["Schema 驱动合成\n根据表结构自动生成合理 query"] end subgraph stage3["阶段三：质量控制"] C1["SQL 可执行性校验\n在真实数据库上运行"] C2["语义一致性校验\nNL-SQL 对是否语义匹配"] C3["难度标签标注\n简单/中等/困难"] end stage1 --> stage2 --> stage3 C3 --> D["最终训练集\n~2000-3000 条"] ``` **阶段一：种子数据分析** 先对 500 条真实标注做分类，理清覆盖现状： | 查询模式 | 示例 | 真实标注量 | 需合成量 | |---------|------|----------|---------| | 单表简单查询 | `SELECT name FROM users WHERE age > 30` | 80 条 | 少量 | | 多表 JOIN | `SELECT ... FROM orders JOIN products ON ...` | 60 条 | 中等 | | 聚合 + GROUP BY | `SELECT dept, COUNT(*) FROM ... GROUP BY dept HAVING ...` | 40 条 | 中等 | | 嵌套子查询 | `SELECT ... WHERE id IN (SELECT ...)` | 20 条 | 大量 | | 窗口函数 | `SELECT ..., ROW_NUMBER() OVER (PARTITION BY ...)` | 5 条 | 大量 | | 多条件组合 | `WHERE A AND (B OR C) AND D BETWEEN ...` | 30 条 | 中等 | **阶段二：合成策略（三种互补）** **策略一：模板化合成（覆盖率优先）** ```text 模板："查询 {表名} 中 {条件列} {比较符} {值} 的 {目标列}" → SQL：SELECT {目标列} FROM {表名} WHERE {条件列} {比较符} {值} 通过枚举表名、列名、比较符、值的组合，快速生成大量基础样本 优点：100% SQL 合法，生成快 缺点：自然语言表述单一，不够多样 ``` **策略二：LLM 改写合成（多样性优先）** ```text 输入：种子样本 (NL, SQL) + 指令"用 5 种不同的自然语言表述描述同一个查询意图" 输出：5 条不同表述的 NL，对应同一个 SQL 例： 原始："查询年龄大于 30 的用户姓名" 改写1："帮我找出超过 30 岁的用户叫什么" 改写2："30 岁以上的人的名字有哪些" 改写3："列出年纪在 30 以上的用户" ``` **策略三：Schema 驱动合成（复杂模式优先）** ```text 输入：数据库 Schema（表结构 + 外键关系） 过程： 1. 随机选择 2-3 张表，根据外键关系确定 JOIN 条件 2. 随机选择聚合函数、WHERE 条件、ORDER BY 3. 组装成合法 SQL 4. 用 LLM 为这条 SQL 生成自然语言描述 优点：能自动覆盖复杂模式（多表 JOIN + 聚合 + 嵌套） 缺点：生成的 NL 需要人工审核 ``` **阶段三：质量控制** ```text 三重校验： 1. SQL 可执行性 → 在真实数据库上 RUN，报错的丢弃 2. 结果合理性 → 查询结果不为空且不是全表（太宽泛的 query 无意义） 3. NL-SQL 一致性 → 用另一个 LLM 做 back-translation：SQL → NL'， 比较 NL' 和原始 NL 的语义一致性，不一致的标记人工审核 ``` **迭代优化闭环**： 训练集不是做完就结束——训完模型后还要做**错误分析驱动的迭代**： ```text 训练模型 → 在验证集上评估 → 收集错误预测 → 分析错误集中在哪些模式（如 HAVING 子句、嵌套子查询） → 针对性合成这些模式的更多样本 → 重新训练 → 验证改进 ``` **差距在哪**：新手想到的是“找人标 500 条”。高手设计了三阶段生产流——种子分析定方向、三种合成策略互补、三重质量校验兜底——且有迭代优化闭环。面试官用这个场景题考的是你面对“数据不够”时的工程化思维——不是“多标点数据”，而是“用最少的真实数据撬动最大的覆盖”。 --- ### Q：Token 和字符有什么区别？ > 来源：淘宝闪购 AI应用研发 一面 **新手答**：“Token 就是模型切分文字的最小单位，一个词就是一个 token。” **高手答**： Token 和字符是两个不同层次的概念，理解它们的关系对 Agent 开发中的成本估算、上下文管理、Prompt 设计都有直接影响。 **字符（Character）**：人类可读的最小文本单位。一个中文字是一个字符，一个英文字母也是一个字符。 **Token**：模型处理文本的最小单位。模型不直接处理字符，而是先用 **Tokenizer** 把文本切分成 token 序列，再转成数字 ID 输入模型。 **Tokenizer 的工作原理（BPE 算法）**： 主流的 Tokenizer 使用 BPE（Byte Pair Encoding）算法——从字符级别开始，统计训练语料中频繁相邻出现的字符对，逐步合并成更大的子词单元。最终形成一个词表（通常 3-10 万个 token）。 ```text 英文示例："unhappiness" → ["un", "happiness"] (常见前缀单独成 token) → 2 个 token 中文示例："人工智能" → ["人工", "智能"] 或 ["人", "工", "智", "能"] → 2-4 个 token（取决于 tokenizer） ``` **中英文的关键差异**： | 语言 | 粗略换算 | 原因 | |------|---------|------| | 英文 | 1 个词 ≈ 1-1.5 个 token | 常见词通常是完整 token | | 中文 | 1 个字 ≈ 1-2 个 token | 中文字在训练语料中出现频率较低，拆分更细 | 这意味着**同样语义的内容，中文消耗的 token 数通常比英文多 30%-50%**。 **对 Agent 开发的实际影响**： 1. **成本估算**：API 按 token 计费，中文项目成本要比英文项目预估高一些 2. **上下文窗口**：模型的上下文限制是 token 数而非字数。4K token 对英文是 ~3000 词，对中文是 ~2000-2500 字 3. **Prompt 设计**：同样的 Prompt 中文版比英文版消耗更多 token，需要更注意精简 4. **Embedding 质量**：不同 Tokenizer 对中文的切分粒度不同，影响语义表达的精度 **差距在哪**：新手停留在“token 是最小单位”的定义。高手从 BPE 编码机制、中英文差异、到对 Agent 开发的实际影响（成本、上下文、Prompt 设计）做了完整的链路分析。面试官考的是你对模型基础设施的理解深度——这直接影响你做 Agent 时的工程决策。 --- ### Q：QLoRA 的核心设计思想是什么？和标准 LoRA 有什么区别？ > 来源：阿里淘天 AI应用开发一面 **新手答**：「就是量化版的 LoRA。」 **高手答**： QLoRA 不是简单地「量化 + LoRA」，而是三项创新协同工作，让单卡消费级 GPU 也能微调 65B 大模型： **三大核心创新**： **1. 4-bit NormalFloat（NF4）量化**： - 这是一种**信息论最优**的 4-bit 数据类型。正态分布的数据（预训练权重近似正态分布），用 NF4 量化比普通 INT4 精度损失更小 - 核心思路：量化区间的划分不是均匀的，而是按正态分布的分位数划分——让数据密集区域获得更高的量化精度 **2. 双重量化（Double Quantization）**： - 量化需要存储量化常数（scaling factor），每 64 个参数一个常数。65B 模型的量化常数本身占 ~0.5GB - 双重量化：对量化常数**再做一次 8-bit 量化**，额外存储开销从 0.5GB 降到 ~0.125GB - 看起来省的不多，但在显存极度紧张的场景下，每一点都很关键 **3. 分页优化器（Paged Optimizers）**： - 训练时优化器状态（如 Adam 的一阶/二阶矩）会产生显存峰值 - 分页优化器利用 NVIDIA 统一内存（Unified Memory）机制，当 GPU 显存不足时自动把优化器状态页迁移到 CPU 内存，峰值过后再迁回 - 类似操作系统的虚拟内存分页，对用户透明 **核心思想**：基础模型权重冻结并压缩到 4-bit 存储，只训练 LoRA 的低秩适配器（仍用 BF16 精度）。前向传播时将 4-bit 权重反量化回 BF16 参与计算，反向传播只更新 LoRA 参数。 **QLoRA vs 标准 LoRA 对比**： | 维度 | 标准 LoRA | QLoRA | |------|----------|-------| | 基座权重精度 | FP16/BF16 | NF4（4-bit） | | LoRA 适配器精度 | FP16/BF16 | BF16（不量化） | | 65B 模型微调显存 | ~130GB（需多卡） | ~48GB（单卡 A100） | | 训练速度 | 较快 | 略慢（需反量化计算） | | 精度损失 | 无 | 极小（NF4 信息论最优） | | 适用场景 | 有多卡资源的团队 | 资源受限、单卡微调大模型 | **效果**：QLoRA 在 65B 模型上只需 ~48GB 显存就能微调，且在多个 benchmark 上效果接近全参数 16-bit 微调——这意味着一张 A100 就能微调最大的开源模型。 **差距在哪**：新手只知道「量化+LoRA」。高手讲清楚了 NF4 量化的信息论依据、双重量化的存储优化、分页优化器的显存管理三大创新。面试官考的是你对显存优化技术的系统理解。 --- ### Q：垂直领域指令微调后，模型通用能力出现退化，怎么解决？ > 来源：阿里淘天 AI应用开发一面 **新手答**：「多加点通用数据混着训。」 **高手答**： 这个问题叫**灾难性遗忘（Catastrophic Forgetting）**，是微调的经典难题——模型在学习新领域知识时，覆盖了原有的通用能力权重。 **五种解决方案**： | 方案 | 原理 | 优点 | 缺点 | |------|------|------|------| | **数据混合（Data Mixing）** | 领域数据 + 通用数据按比例混合训练 | 简单有效，工程成本低 | 需要高质量通用数据集，比例需调参 | | **LoRA 而非全参数微调** | 只更新少量参数，对原始能力的破坏更小 | 天然保留大部分原始能力 | 领域适配深度可能不够 | | **正则化约束（KL 散度）** | 在 loss 中加 KL 散度项，约束微调后的模型不要偏离原始模型太远 | 理论优雅，DPO/PPO 中的 reference model 就是这个作用 | 超参数敏感，约束太强会限制学习 | | **渐进式微调（Progressive Fine-tuning）** | 先通用后领域，逐步收窄训练范围 | 平滑过渡，遗忘较少 | 训练流程复杂，耗时更长 | | **模型合并（Model Merging）** | 分别训练领域模型和通用模型，用 TIES-Merging / DARE 等方法合并权重 | 各模型独立训练，灵活组合 | 合并效果不稳定，需要实验调参 | **数据混合的经验比例**：领域数据占 70%-80%，通用数据占 20%-30%。通用数据的来源通常是开源的高质量指令数据集（如 OpenHermes、SlimOrca 等）。比例不是固定的——领域和通用的差距越大，通用数据占比应该越高。 **正则化约束的具体做法**： ```text L_total = L_SFT(领域数据) + λ · KL(π_θ ∥ π_ref) π_θ：当前微调中的模型 π_ref：微调前的原始模型（冻结） λ：约束强度，越大越保守 ``` 这正是 DPO 和 PPO 中 reference model 的设计动机——不仅是对齐用的，也是防遗忘用的。 **模型合并的前沿方法**： - **TIES-Merging**：只保留变化最大的参数（trim），解决符号冲突（elect sign），再合并。比简单平均效果好很多 - **DARE**：随机丢弃大部分参数变化（类似 Dropout），只保留少量关键变化做合并。适合合并多个 LoRA 适配器 **实际工程选择**：大多数团队用「LoRA + 数据混合」组合，性价比最高——LoRA 天然限制参数更新范围，数据混合进一步补充通用能力。只有在需要极深度的领域适配时，才考虑全参数微调 + 正则化约束。 **差距在哪**：新手只知道混数据。高手给出了五种系统性方案且理解各自 trade-off。面试官考的是你对微调工程全链路的掌控力。 --- ### Q：现有的大模型性能为什么这么好？ > 来源：字节后端 Agent 开发二面 **新手答**：“参数量大、数据多。” **高手答**： 「参数大 + 数据多」是必要条件，但不是充分条件——同样规模的模型性能差异巨大。大模型性能好是**多个关键技术突破的叠加效应**： **第一层：架构层面的突破** | 设计 | 贡献 | |------|------| | **Transformer 自注意力** | 彻底解决了序列建模中的长距离依赖问题，任意两个 token 之间的信息传递不需要逐步传递 | | **残差连接 + LayerNorm** | 使超深网络（100+ 层）的训练成为可能 | | **Decoder-only 架构** | GPT 系列证明了自回归预训练的强大泛化能力 | | **位置编码演进** | RoPE 等旋转位置编码让模型能外推到训练时未见过的序列长度 | **第二层：规模效应（Scaling Laws）** Kaplan 等人（2020）和 Chinchilla（2022）的研究揭示了**幂律关系**： ```text 损失 ∝ 1/N^α + 1/D^β + 1/C^γ （N=参数量，D=数据量，C=计算量） ``` 关键发现不是「越大越好」，而是**三者需要同步增长**——单独增大参数量但数据量不够，性能提升会饱和。Chinchilla 证明了同等计算预算下，中等模型 + 更多数据 > 超大模型 + 少数据。 **第三层：训练方法的演进** | 阶段 | 方法 | 作用 | |------|------|------| | 预训练 | 自回归语言建模（next token prediction） | 学习语言的统计规律和世界知识 | | SFT | 监督微调（指令遵循数据） | 让模型学会「按指令办事」 | | RLHF/DPO | 对齐人类偏好 | 让输出更安全、更有帮助、更符合人类期望 | 这三阶段的贡献不对等：预训练提供了 90% 的能力基础，SFT 把能力「激活」，RLHF 做「精修」。 **第四层：工程层面的突破** - **混合精度训练（BF16/FP16）**：在精度损失极小的情况下，显存和计算量减半 - **FlashAttention**：将 Attention 的显存复杂度从 O(N²) 降到 O(N)，使长序列训练成为可能 - **3D 并行（DP + TP + PP）**：数据并行 + 张量并行 + 流水线并行，支撑万卡规模训练 - **高质量数据清洗**：去重、去毒、质量过滤——数据质量比数量更重要 **核心认知**：大模型的性能不是单一因素的结果，而是架构设计、规模效应、训练方法、工程优化四个维度**同时到位**的产物。缺少任何一环，同等参数量的模型性能都会大幅下降。 **差距在哪**：新手只提到参数和数据两个维度。高手从架构、规模定律、训练三阶段、工程优化四个层面系统解释，且点出了各因素的贡献不对等和协同效应。面试官考的是你对大模型技术栈的全局理解。 --- ### Q：GQA 和 MLA 的原理是什么？各自解决什么问题？ > 来源：阿里国际AI算法一面 **新手答**：“都是注意力机制的变体，用来加速推理。” **高手答**： GQA 和 MLA 解决的核心问题相同——**KV Cache 的显存开销**，但思路完全不同： **GQA（Grouped Query Attention）** 标准 MHA 中每个 Query Head 有独立的 KV Head（如 32 个 Q Head → 32 对 KV Head）。GQA 的做法是**多个 Q Head 共享一组 KV Head**： ```text MHA: 32 Q Heads → 32 KV Heads（全独立） GQA: 32 Q Heads → 8 KV Groups（每 4 个 Q 共享 1 对 KV） MQA: 32 Q Heads → 1 KV Head（极端共享） ``` 效果：KV Cache 缩小到 1/4（8 组 vs 32 组），推理时显存占用和带宽压力大幅降低。GQA 是 MHA 和 MQA 的折中——MQA 太激进导致质量下降，GQA 在速度和质量间找到平衡。Llama 2/3、Mistral 都用 GQA。 **MLA（Multi-head Latent Attention）** DeepSeek-V2 提出的方案，思路更激进：不是共享 KV Head，而是把 KV **压缩到低维隐空间**再缓存： ```text 标准 MHA: 缓存完整的 K, V 矩阵 → 显存 O(n * d_model) MLA: KV → 低秩投影 → 缓存压缩后的 latent → 推理时再解压还原 ``` 等价于对 KV Cache 做了一次有损压缩，压缩比可达 10x+。而且 MLA 兼容长上下文——即使序列很长，缓存的 latent 体积也远小于完整 KV。 **对比选型**： | 维度 | GQA | MLA | |------|-----|-----| | 核心思想 | 共享 KV Head | 压缩 KV 到低维 latent | | KV Cache 压缩比 | 4-8x | 10x+ | | 实现复杂度 | 低（改分组即可） | 高（需要额外投影层） | | 代表模型 | Llama 3, Mistral | DeepSeek-V2/V3 | | 适合场景 | 通用、工程简单 | 超长上下文、极限显存优化 | **差距在哪**：新手只知道“GQA 比 MHA 快”。高手能清晰区分两种方案的压缩思路（共享 vs 低秩投影）、压缩比差异、以及各自的工程取舍。面试官考的是你对注意力机制显存优化的理解深度。 --- ### Q：MoE 架构下为什么参数量大但单 Token 推理成本不一定高？ > 来源：字节春招大模型测开一面 **新手答**：“因为 MoE 不是所有参数都用到。” **高手答**： MoE（Mixture of Experts）的核心设计是**稀疏激活**——模型总参数量很大，但每个 Token 只激活其中一小部分专家。 **具体机制**： ```text 传统 Dense 模型（如 Llama 70B）： 每个 Token → 经过全部 70B 参数 → 计算量 = 70B FLOPs MoE 模型（如 Mixtral 8x7B，总参 47B）： 每个 Token → Router 选择 2/8 个专家 → 只经过 ~14B 参数 → 计算量 ≈ 14B FLOPs ``` 所以 Mixtral 虽然总参数 47B，但推理时每个 Token 的计算量只相当于一个 14B 的 Dense 模型。这就是“参数大但推理成本不高”的原因。 **Router 的工作方式**： 1. 每个 Token 的隐藏状态经过一个轻量的 Gate Network（通常是一个线性层 + Softmax） 2. Gate 输出每个专家的权重分数 3. 取 Top-K（通常 K=2）个分数最高的专家 4. 只将 Token 送入这 K 个专家计算，其余专家不参与 **为什么不是“完全免费”**： - **显存占用仍然大** — 所有专家的参数都要加载到显存（47B 参数都要放进去），只是计算时不全用 - **通信开销** — 分布式部署时，Token 路由到不同 GPU 上的专家需要 All-to-All 通信 - **负载不均衡** — 热门专家过载、冷门专家空闲，需要辅助 Loss 做负载均衡 **一句话总结**：MoE 用“空间换时间”的思路——花更多显存存储全部专家参数，但每次推理只激活一小部分，从而在保持模型容量大的同时控制单 Token 计算成本。 **差距在哪**：新手只说“不是所有参数都用”。高手能解释 Router 机制、Top-K 稀疏激活的具体过程，以及显存大但计算小的本质原因。还能指出 MoE 并非没有代价——显存仍然大、通信有开销。面试官考的是你对模型架构的理解是停留在结论层还是机制层。 --- ### Q：BF16 与 FP32 精度差异及训练推理选型？ > 来源：爱奇艺大模型算法岗二面 **新手答**：“BF16 精度低但快，FP32 精度高但慢。” **高手答**： BF16（Brain Float 16）和 FP32 的核心区别在于**位数分配**： ```text FP32: 1 bit 符号 + 8 bit 指数 + 23 bit 尾数 → 高精度，大动态范围 FP16: 1 bit 符号 + 5 bit 指数 + 10 bit 尾数 → 动态范围小，容易溢出 BF16: 1 bit 符号 + 8 bit 指数 + 7 bit 尾数 → 动态范围=FP32，精度有损 ``` **BF16 的设计哲学**：牺牲尾数精度（7 bit vs FP32 的 23 bit），保留完整的指数范围（8 bit）。这意味着： - 能表示和 FP32 一样大/小的数（不会溢出） - 但每个数的精度只有 FP32 的 1/65000 **为什么大模型训练优先选 BF16 而非 FP16**： FP16 的指数只有 5 bit，动态范围是 [6e-8, 65504]。大模型训练中梯度经常超出这个范围（梯度爆炸/消失），需要额外做 Loss Scaling。BF16 的动态范围和 FP32 相同，**无需 Loss Scaling**，训练稳定性大幅提升。 **选型决策**： | 场景 | 推荐精度 | 原因 | |------|---------|------| | 预训练 | BF16 混合精度 | 稳定、显存减半、速度翻倍 | | SFT 微调 | BF16 | 同上，且 LoRA 的小参数量对精度不敏感 | | 推理服务 | FP16 或 INT8/INT4 | 追求极致速度，量化后精度损失可接受 | | 科学计算/小模型 | FP32 | 精度要求高，显存不是瓶颈 | | 梯度累积的 master weights | FP32 | 确保梯度累加不丢精度 | **混合精度训练的标准做法**： ```text 前向计算：BF16（快、省显存） 反向计算：BF16（快） 梯度累积：FP32（防精度丢失） 权重更新：FP32 master copy → 转回 BF16 给下一轮 ``` **差距在哪**：新手只知道“低精度快高精度准”。高手能从位数分配角度解释 BF16 vs FP16 的本质区别（指数位相同/不同 → 动态范围差异），且知道混合精度训练中不同阶段用不同精度的原因。面试官考的是你对训练工程细节的掌握程度。 --- ### Q：模型推理慢，排查思路是什么？ > 来源：阿里国际AI算法一面 **新手答**：“加显卡，或者换小模型。” **高手答**： 推理慢的排查需要分层定位瓶颈，不能上来就加硬件。排查顺序从最常见的原因开始： **第一步：确认瓶颈是 compute-bound 还是 memory-bound** - **Prefill 阶段**（处理输入）：compute-bound，瓶颈在算力。输入越长，QKV 计算量越大 - **Decode 阶段**（逐 token 生成）：memory-bound，瓶颈在显存带宽。每生成一个 token 都要加载全部 KV Cache 大部分推理慢的问题出在 Decode 阶段——模型生成很长的输出时特别明显。 **第二步：逐项排查优化项是否开启** | 检查项 | 未开启的影响 | 解决方案 | |--------|-------------|---------| | KV Cache | 每个 token 重复计算历史 | 确认框架默认开启 | | FlashAttention | Attention 显存 O(N^2)，速度慢 | 升级到 FA2/FA3 | | 量化（INT8/INT4） | 权重读取带宽翻倍 | AWQ/GPTQ 量化后部署 | | Batching | 每个请求独占 GPU | 开启 Continuous Batching（vLLM） | | Tensor Parallel | 单卡算力不够 | 多卡 TP 切分 | **第三步：检查系统层面** - **序列长度过长** — 输入 + 输出超过 4K 后 Attention 计算量急剧增长。截断或摘要化输入 - **Batch 太大** — 单 batch 占满显存，导致 OOM 降速。调整 max_batch_size - **CPU offload** — 显存不足时 KV Cache 被卸载到 CPU，带宽断崖式下降。加显存或减序列长度 - **网络瓶颈** — 多卡 TP 时 All-Reduce 通信慢。检查 NVLink/PCIe 带宽 **第四步：Profile 定位热点** ```text PyTorch Profiler / nsys → 哪个 kernel 耗时最长？ 常见热点：Attention kernel > MLP > 通信 > 采样 ``` **一句话总结**：先判断 compute 还是 memory bound → 再查优化项是否全开 → 再看系统配置 → 最后 profile 定位具体算子。 **差距在哪**：新手直接说“换更好的 GPU”。高手有系统化的排查链路，从瓶颈类型判断开始，逐层检查优化开关、系统配置、算子热点。面试官考的是你有没有真正部署过推理服务——只用 API 的人不会碰到这些问题。 --- ## Q：超长上下文是怎么实现的？（如 Kimi 这类模型） > 来源：百度大模型实习 **新手答**：“就是把窗口开大呗，训练的时候用长文本。” **高手答**： 实现超长上下文（128K/200K+）涉及多个技术层面： 1. **位置编码外推**：标准位置编码在超出训练长度后失效。解决方案包括：ALiBi（线性注意力偏置，天然支持外推）、RoPE + NTK-Aware Scaling（对旋转频率进行插值）、YaRN（分段缩放不同频率） 2. **注意力机制优化**：标准 Attention O(n²) 在超长序列下不可行。方案：FlashAttention（IO-aware 算法减少显存搬运）、Ring Attention（分布式环形通信）、稀疏注意力（只关注局部+全局锚点） 3. **训练策略**：先短后长的渐进式训练——预训练用 4K，逐步扩展到 32K→128K，每阶段微调适应新长度 4. **推理优化**：KV Cache 分页管理（PagedAttention）、KV Cache 量化压缩、前缀缓存复用 5. **工程实现**：序列并行（Sequence Parallelism）将超长序列切分到多卡处理 **差距在哪**：面试官要看你对“长上下文不是简单开大窗口”的理解——它是位置编码、注意力机制、训练策略、推理工程四方面协同的结果。 --- ## Q：Agent 在细分场景（比如法律、医疗）落地时，微调策略和通用场景有什么不同？ > 来源：字节TikTok AI应用开发一面 **新手答**：“收集领域数据做 SFT 就行了。” **高手答**： 垂直领域微调和通用场景的核心差异在于“数据稀缺 + 风险更高 + 合规约束”三重挑战叠加。 **数据层面的差异**： 1. **数据来源受限**：法律/医疗数据有隐私法规约束（HIPAA、数据本地化），不能直接用公开爬取的数据，需要合规脱敏或使用合成数据 2. **标注成本极高**：需要领域专家（律师、医生）标注，而非众包平台。10 条高质量专家标注的数据往往比 1000 条普通标注更有价值 3. **负样本同样重要**：需要收集“模型错误输出”作为 DPO 的 rejected 样本——领域错误往往有特定模式（比如引用错法条、混淆药物剂量），需要专门构造 **训练策略差异**： 1. **优先 RAG + Prompt，慎用 SFT**：垂直领域知识更新快（新判例、新药审批），SFT 难以频繁更新，RAG 更灵活 2. **SFT 聚焦格式和推理链，而非知识注入**：让模型学会“如何推理法律条文”而不是“记住哪些法条”，后者用 RAG 解决 3. **RLHF/DPO 的 reward 设计更复杂**：通用场景用“有帮助/无害”二分，医疗场景需要“临床准确性 + 安全性 + 合规性”多维度奖励 4. **安全对齐要求更高**：需要额外的拒绝训练（模型应该说“请咨询专业医生”而不是直接给诊断） **部署差异**： - 垂直领域更依赖混合策略：小参数专用模型（领域微调 7B/13B）+ RAG + 规则过滤，而非单一大模型 - 需要“置信度输出”——让模型在不确定时明确说“我不确定，建议核实”，通用模型往往不需要这个 **差距在哪**：面试官考的是你对“微调不是万能的”的理解——垂直领域的核心挑战不是模型能力不够，而是数据稀缺、合规约束和高风险容错。高手会在 RAG vs 微调的选择上有清晰的判断标准。 --- ## 微调 vs Prompt 做代码生成 ### Q：为什么要通过微调模型来做代码生成？为什么不用纯 Prompt 或 Spec Coding？ > 来源：小米 AI Agent 一面（暑期）【字节Agent开发实习生一面追问：“spec coding/SDD 也能拆 task，为什么达不到你项目里的效果？”】 **新手答**：“微调效果更好呗。” **高手答**： Prompt 和 Spec Coding 解决的是**推理时约束**——告诉模型“这次按什么规则做”。微调解决的是**行为分布**——让模型的默认行为就符合你的工程规范。 **为什么 Prompt 不够：** | 场景 | Prompt 的局限 | |------|--------------| | 代码风格 | 每次都要在 Prompt 里塞完整的 style guide，占大量 token | | 内部框架 API | 模型不认识私有 API，Prompt 描述容易被长上下文稀释 | | 工程动作序列 | “先读测试→定位调用链→改最小范围→补回归测试”这种习惯，Prompt 能说但模型不一定遵循 | | 长任务持续性 | 多步任务中 Prompt 的约束力随上下文增长而衰减 | **为什么 Spec Coding / SDD 不够：** Spec Coding 本质是“把需求写清楚让模型按规格实现”——适合需求边界明确、上下文稳定的场景。但真实缺陷修复中： 1. 需求本身不完整（只有一个报错日志） 2. 修复路径不可预知（需要动态探索依赖关系） 3. 需要根据测试反馈持续修正（静态 spec 覆盖不了动态反馈循环） **微调的真正价值：** 不是让模型“记住业务代码”，而是让它学会稳定的**工程动作模式**： - 看到 bug 描述 → 先定位而不是直接改 - 改完代码 → 自动补测试而不是只提交 patch - 遇到不确定 → 用工具验证而不是猜测 微调让这些行为变成模型的默认倾向，不需要每次在 Prompt 里强调。 **差距在哪**：面试官考的是你对“Prompt vs 微调”边界的理解。不是“哪个好”的问题，而是它们解决不同层面——Prompt 管单次任务约束，微调管行为分布塑造。能说清 Spec Coding 的适用边界（静态任务 OK，动态反馈循环不行），说明你做过真实的代码生成系统。 --- ## 模型参数大小与 Agent 能力 ### Q：外部模型参数更大，14B 在 Agent 层面会不会不够？ > 来源：小米 AI Agent 一面（暑期） **新手答**：“参数越大越好，14B 肯定不如 70B。” **高手答**： 模型参数大小只是 Agent 系统能力的一个因素，不是唯一瓶颈。Agent 系统的最终效果 = 模型能力 × 工程补偿。 **14B 在 Agent 场景的实际表现：** - 简单工具调用、格式化输出、遵循固定 SOP：完全够用 - 复杂推理链（5+ 步逻辑推导）：能力边界明显，容易出现指令遵循漂移 - 开放式规划（给定模糊目标自行拆解）：和大模型差距最大的地方 **工程手段补偿模型能力不足：** | 瓶颈 | 工程方案 | |------|---------| | 推理能力弱 | 任务拆解为状态机，每步只需简单决策 | | 指令遵循差 | 约束解码（JSON Schema 强制格式） | | 上下文不够 | 检索+压缩，只送最相关的信息 | | 知识不足 | RAG + 工具调用获取实时信息 | | 不稳定 | 测试反馈回灌，多次重试+验证 | **什么时候 14B 真的不够：** - 需要一次性理解超长代码文件（>10K token）并给出全局重构方案 - 需要在单轮中做复杂数学/逻辑推导 - 需要理解多层嵌套的隐含意图 **选型策略：** - 不是“全用大的”或“全用小的”——而是按任务风险分级路由 - 简单任务走本地 14B（低延迟低成本），复杂/高风险任务走大模型审核 **差距在哪**：面试官不是在问“14B 好不好”——而是考你对“Agent 系统能力不等于模型能力”的理解。能说出工程补偿手段 + 分级路由策略，说明你知道怎么在成本约束下做出可用的系统。 --- ## Rerank 模型蒸馏 ### Q：对 Rerank 模型进行了蒸馏，蒸馏的数据是什么样的？训练数据大概有多少条？ > 来源：同程Agent开发实习一面 **新手答**：“用大模型打标签，然后训练小模型。” **高手答**： Rerank 蒸馏的核心是把大 Cross-Encoder（如 bge-reranker-v2-m3）的排序能力迁移到更快的小模型，兼顾精度和推理速度。 **蒸馏数据构造：** 1. **Query 收集**：从真实用户 query 日志中采样 + 人工构造的边界 case（同义改写、否定表达、多意图混合） 2. **候选文档生成**：对每个 query，用检索系统（BM25 + 向量）召回 Top 50 候选 3. **教师模型打分**：用大 Reranker 对 (query, doc) 对打相关性分数（0-1 连续分或 0/1/2 三档） 4. **构造训练对**： - Pointwise：每条 (query, doc, score) - Pairwise：同一 query 下，高分 doc vs 低分 doc 的 pair - Listwise：同一 query 下完整排序列表 **数据规模参考：** - 通用场景：5K-10K query × 每个 query 20-50 候选 = 10W-50W 训练对 - 垂直领域：2K-5K query 通常足够（领域术语覆盖比数量重要） - 关键：正负样本比例控制在 1:3 到 1:5，避免模型学到“全判正” **学生模型选择：** - 常用 bge-reranker-base（~100M 参数）或 Qwen2.5-0.5B 加 classification head - 推理速度需要比教师模型快 5-10x 才有蒸馏的意义 **训练技巧：** - Loss 用 KL 散度（对齐教师模型的 logits 分布）而非硬标签 CE - 困难负样本（教师模型打分在 0.4-0.6 的模糊区间）权重加大 - 在目标领域 eval set 上用 NDCG@5 和 MRR 监控 **差距在哪**：面试官问蒸馏数据，考的是你对“数据驱动的模型优化”的实操理解。能说出数据构造流程（query来源 → 候选召回 → 教师打分 → 对构造）和规模量级，说明你做过训练而不只是调 API。 --- ## BERT 与 GPT 架构对比 ### Q：BERT 和 GPT 架构的区别是什么？ > 来源：同程Agent开发实习一面 **新手答**：“BERT 是双向的，GPT 是单向的。” **高手答**： 核心区别不只是“方向”，而是**预训练目标不同导致能力偏好不同**。 | 维度 | BERT | GPT | |------|------|-----| | 架构 | Transformer Encoder（双向注意力） | Transformer Decoder（因果注意力/单向遮蔽） | | 预训练目标 | MLM（完形填空）+ NSP | 自回归（预测下一个 token） | | 核心能力 | 理解、分类、匹配 | 生成、推理、续写 | | 注意力模式 | 每个 token 能看到前后所有 token | 每个 token 只能看到前面的 token | | 典型应用 | 文本分类、NER、语义相似度、Rerank | 对话生成、代码生成、Agent 推理 | | 推理方式 | 一次前向得到所有位置的表示 | 逐 token 自回归生成 | **在 Agent/RAG 系统中的角色分工：** - **BERT 系列**（包括 RoBERTa、DeBERTa）→ 做 Embedding、Rerank、意图分类。因为双向注意力对“理解文本含义”更强 - **GPT 系列**（包括 LLaMA、Qwen）→ 做生成、推理、规划。因为自回归天然适合“产出新内容” **常见误区澄清：** 1. “BERT 比 GPT 弱”——不对。在分类和匹配任务上 BERT 类模型通常比同参数 GPT 更好 2. “GPT 不能做理解”——不对。足够大的 GPT 在理解任务上也很强，但用 Decoder 做 Embedding 效率更低 3. “BERT 过时了”——不对。2026 年的 Rerank 模型、Cross-Encoder、Embedding 模型大量基于 BERT 架构 **差距在哪**：面试官问这个基础题是为了看你对 Transformer 的理解是否扎实。只说“双向/单向”是背书，能说出预训练目标的差异如何决定能力偏好，以及在实际 Agent/RAG 系统中的角色分工，说明你理解的是架构设计的“为什么”而非“是什么”。 --- ## 为什么大模型都是 Decoder-only ### Q：为什么现在的大模型都是 Decoder-only 架构？ > 来源：淘天 AI Agent 暑期实习一面 **新手答**：“因为 GPT 用的就是 Decoder。” **高手答**： Decoder-only 成为主流不是巧合，而是在**生成任务上效率、扩展性和通用性的最优解**。 **三种架构对比：** | 架构 | 代表 | 核心特点 | 局限 | |------|------|---------|------| | Encoder-only | BERT | 双向注意力，擅长理解 | 不能生成，只能做分类/匹配 | | Encoder-Decoder | T5, BART | 理解+生成分离 | 参数效率低（两套注意力），预训练目标复杂 | | Decoder-only | GPT, LLaMA, Qwen | 因果注意力，自回归生成 | 单向，理解任务需要更多参数弥补 | **Decoder-only 胜出的核心原因：** 1. **统一的训练目标**：只需“预测下一个 token”，所有任务（问答、翻译、推理、代码）都能统一为自回归生成。训练简单、数据利用率高 2. **扩展性最好**：同样的参数预算下，Decoder-only 的有效参数全部用于生成，不需要分给 Encoder。Scaling Law 实验表明它在大参数量级上收益最明显 3. **KV Cache 高效**：因果注意力天然支持 KV Cache——生成新 token 时，前面的 KV 不需要重算。Encoder-Decoder 的 cross-attention 需要额外维护 Encoder 输出 4. **In-Context Learning 能力**：Decoder-only 通过超长上下文自然涌现出 few-shot 能力，不需要额外训练。这是 Encoder 架构做不到的 5. **工程简洁性**：只有一种注意力机制、一种前向计算路径，推理框架（vLLM、TGI）优化更简单 **为什么 BERT 类模型没消失？** 在特定任务上（Embedding、Rerank、分类），Encoder 架构仍然更高效——同样参数量下双向注意力对理解任务更强。所以 Agent 系统中通常是“Decoder 做生成 + Encoder 做理解”的组合。 **差距在哪**：面试官考的是你对架构选择背后的 trade-off 理解。只说“因为 GPT 用了”是循环论证。能从训练目标统一性、扩展性、KV Cache 效率三个角度解释，说明你理解架构设计的动机而非只记结论。 --- ## 训练 AI Coding Agent 的策略 ### Q：如果训练一个 AI Coding Agent，是端到端训练还是分阶段训练？ > 来源：淘天 AI Agent 暑期实习一面 **新手答**：“端到端简单，直接训就行。” **高手答**： 这是一个开放性设计题，没有标准答案，但需要展示清晰的决策框架。 **两种策略对比：** | 维度 | 端到端训练 | 分阶段训练 | |------|-----------|-----------| | 思路 | 一次性学会“看需求→写代码→跑测试→修bug”的完整链路 | 先学理解代码，再学生成代码，最后学交互修复 | | 数据需求 | 需要大量完整轨迹数据（从需求到最终通过 CI 的全过程） | 每阶段用针对性数据，总量可以更少 | | 优点 | 模型学到的是整体协作模式，各步骤自然衔接 | 每阶段目标明确，调试容易，中间产物可复用 | | 缺点 | 轨迹数据稀缺且昂贵，中间步骤出错难以定位 | 阶段衔接处可能有 gap，前阶段错误会级联 | **我的选择：分阶段训练，理由：** 1. **阶段一：代码理解 SFT**——教模型读懂代码结构、定位依赖关系。用代码问答数据 2. **阶段二：代码生成 SFT**——教模型按规范生成代码。用 instruction → code 数据 3. **阶段三：交互修复 RL（GRPO）**——让模型学会根据测试反馈修正代码。用 Agent 轨迹数据 + 测试通过率作为 reward **为什么不全端到端：** - 完整的“需求→最终代码”轨迹数据极其稀缺（需要真实的 CI 环境 + 人工标注每步决策） - 端到端训练中一个中间步骤的错误会“淹没”在整体 loss 里，定位困难 - 分阶段可以在每个阶段独立评测，快速定位瓶颈在“理解不行”还是“生成不行”还是“修复不行” **什么时候适合端到端：** - 有大量高质量的完整轨迹数据（如从 Claude Code 的使用日志中提取） - 模型已经有了分阶段预训练的基础，端到端只做最后的 fine-tuning **差距在哪**：开放题考的是决策框架而非固定答案。面试官想看你能否分析 trade-off、给出选择理由、并说出什么条件下会改变选择。 --- ## Agent 奖励函数设计 ### Q：客服 Agent 的奖励函数有 Reward Hacking、稀疏、区分度太大（只有完全正确和错误）三个问题，请设计新的 reward 解决至少两个。 > 来源：阿里暑期Agent算法二面【[百度正式批：一面结束第二天就约二面了](https://www.nowcoder.com/discuss/925108144831725568)追问：reward是如何设计的呢？；奖励函数怎么写的？；你的奖励函数具体设计是比较稀疏还是稠密的？】【[MiniMax - 大模型算法岗（后训练 / SFT / RL）](https://www.nowcoder.com/discuss/926272883872075776)追问：RL reward 曲线上升但效果变差的原因是什么？】【[阶跃星辰（Stepfun）- 大模型算法岗（Post-train）](https://www.nowcoder.com/discuss/926273007276814336)追问：Reward Hacking 的检测与纠正？】【[百度 正式批 二面 端到端决策规划控制算法工程师](https://www.nowcoder.com/feed/main/detail/af692c37e31d437292d4881b58b24e56)追问：对于DDPG项目的reward，你是如何设计的？】 **新手答**：“给正确的 1 分，错误的 0 分。” **高手答**： 这道题考的是**从单一 reward 到多维度、连续化、防作弊 reward 的设计能力**。 **三个问题的本质：** - **Reward Hacking**：模型找到了得高分但不满足真实目标的捷径（如客服 Agent 学会一味道歉来获取高满意度评分，但没解决问题） - **稀疏性**：只有完成整个对话后才有反馈，中间步骤没有信号，学习效率极低 - **区分度差**：0/1 二值奖励，成功的好回答和勉强正确的差回答得分相同 **新的 Reward 设计：** ```text R_total = w1 × R_task + w2 × R_process + w3 × R_quality - w4 × R_penalty R_task = 任务完成度（0-1连续）：是否解决了用户问题 R_process = 过程奖励：每步是否推进了问题解决（稀疏→密集） R_quality = 回答质量：信息完整度 + 专业度 + 简洁度 R_penalty = 作弊惩罚：套路化回复 + 过度道歉 + 无实质内容 ``` **解决稀疏问题：** - 引入过程奖励模型（PRM）：对每个中间步骤打分，而不只是最终结果 - 具体信号：是否正确识别了用户意图（+0.2）、是否调用了正确工具（+0.2）、是否获取到了关键信息（+0.3）、最终是否解决（+0.3） **解决 Reward Hacking：** - **多维度分解**：不用单一满意度分数，拆成“问题是否解决”+“信息是否准确”+“有无胡编”三个独立维度，每个维度独立打分 - **对抗样本注入**：训练时加入“看起来流畅但答非所问”的样本作为负例 - **红线惩罚**：发现套路化回复（连续三句包含“抱歉”但无实质操作）直接 R = -1 **解决区分度问题：** - 从 0/1 → 连续分数：按解决问题的步骤完成度给分（完成 3/5 步 = 0.6 分） - 引入偏好对比：同一 query 生成多个回答，用 pairwise 排序替代绝对打分 **差距在哪**：面试官期望你从“单一 binary reward”升级到“多维度 + 过程化 + 防作弊”的系统设计。能画出 reward 公式结构并解释每项如何对应解决一个问题，说明你理解 RL 训练中 reward 工程的实操难度。 --- ### Q：多轮对话 Agent 没有现成对话数据，如何从 UI 操作流合成 SFT 训练语料？ > 来源：海底捞大模型面经 **新手答**：“找标注团队人工写对话数据。” **高手答**： 很多业务场景（点餐、客服、表单填写）的历史数据形态是**用户行为轨迹（trajectory）**，不是对话——用户点击菜品、选规格、改数量，这些操作流需要翻译成自然语言多轮对话才能做 SFT。 **合成流水线**： 1. **行为序列提取**：从日志中抽取用户的操作序列（选锅底 → 加菜 → 改备注 → 结算） 2. **模板化对话生成**：用 LLM 把操作序列翻译成多轮对话 - 输入：`[选番茄锅底, 选牛油锅底, 加脆毛肚, 麻度1]` - 输出：Agent引导式点单的多轮对话 3. **多样性增强**：同一操作序列用不同 profile（新客/老客/过敏用户）生成不同风格的对话 4. **质量过滤**：用规则（轮次合理性、信息完整性）+ 模型打分过滤低质量样本 **SFT 关键细节**： - 只计算 Agent 回复侧的 loss——User 轮次全 mask，防止模型学会模仿用户 - 对话中的隐式反馈（翻页停留 = 犹豫）转化为 Agent 主动推荐的触发条件 - 合成几十万条后做去重 + 难度分层，确保训练集覆盖各种用户类型 **差距在哪**：新手想到人工标注，成本高且难以覆盖长尾场景。高手的思路是“把已有业务数据转化为训练数据”——从行为轨迹到对话的自动化合成流水线，兼顾规模和质量。 --- ### Q：多轮 Agent 的 RL reward 怎么设计？Turn 级信用分配怎么做？ > 来源：海底捞大模型面经 **新手答**：“每轮给一个分数，好的回复给正 reward，差的给负 reward。” **高手答**： 多轮 Agent 的 RL 比单轮难十倍——因为最终结果好坏是整个对话链的联合效果，单独某一轮很难判断贡献度。 **Reward 设计原则——全部用 Verifiable Reward**： 避免训 reward model（容易 reward hacking），直接用可验证的业务指标： - 最终结果符合目标 → +100（如点餐金额在合理区间） - 命中用户特殊需求（过敏忌口、偏好） → +120 - 推荐分量合理（荤素配比、人数匹配） → +80 - 对话轮次合理（不啰嗦也不遗漏） → +60 **Turn 级信用分配**： 整体 reward 只在对话结束时可观测，但需要分配到每一轮。常用方法： - **Shapley Value 近似**：随机剔除某一轮，看最终 reward 变化多少 → 作为该轮的贡献度 - **Temporal Discount**：越靠近结束的轮次权重越高（因为越接近最终决策） - **阶段性 reward**：在关键检查点（锅底确认、荤素确认、结算确认）给即时 reward **User 模拟器**： - 多轮 RL 没法找真人跑几万局 → 需要训一个 User 模拟器 - 输入：用户 profile（等级、偏好、过敏、消费习惯） - 输出：根据 Agent 回复生成用户反应 - 关键：profile 里塞“结束点餐” token，控制对话自然终止 **差距在哪**：新手不理解多轮 reward 的“信用分配”难题——最终结果好不代表每一轮都好。高手用 verifiable reward 避免 reward hacking，用 Shapley/阶段性 reward 做 turn 级分配，用 user 模拟器解决“没人陪跑几万局”的 rollout 问题。 --- ## Q：Agentic RL 与普通 LLM RL 的核心差异是什么？ > 来源：腾讯大模型算法岗一二面（2026-08-22）【[腾讯（WXG）- 大模型算法岗（一面）](https://www.nowcoder.com/discuss/925163074921709568)追问：智能体强化学习（Agentic RL）与传统 RL 在训练范式和信用分配上的核心差异是什么？】【[字节跳动 - 大模型算法岗（强化学习方向）](https://www.nowcoder.com/discuss/925523582761857024)追问：智能体强化学习（Agentic RL）与传统 RL 在训练范式和信用分配上的核心差异是什么？】【[腾讯（CSIG）- 大模型算法岗（RLHF 与多模态）](https://www.nowcoder.com/discuss/925526785003909120)追问：智能体强化学习（Agentic RL）与传统 RL 在训练范式和信用分配上的核心差异是什么？】【[字节跳动 - 大模型算法岗（RL/后训练方向）](https://www.nowcoder.com/discuss/926272098744438784)追问：智能体强化学习（Agentic RL）与传统 RL 在训练范式和信用分配上的核心差异？】 **新手答**：“Agentic RL 的轨迹更长，还包含工具调用。” **高手答**：Agentic RL 优化的是部分可观测环境中的多步状态转移，动作包含语言、工具和等待，奖励常来自外部终态且延迟稀疏；策略还受权限、成本和不可逆副作用约束。训练需可重置沙箱、工具版本、用户模拟器和轨迹级信用分配，并保留恢复/澄清动作。普通文本 RL 更接近单次响应偏好，环境和副作用更弱。 **差距在哪**：新手只看到长度，高手看到环境、动作空间、信用分配和安全约束都改变了。 --- ## Q：为什么 Step-level SFT 之后再进行 GRPO，通常比直接从基座模型开始做 GRPO 稳定？ > 来源：唯品会/NLP算法实习一面【[百度正式批：一面结束第二天就约二面了](https://www.nowcoder.com/discuss/925108144831725568)追问：SFT和GRPO是分两阶段的吗？】【[MiniMax - 大模型算法岗（后训练 / SFT / RL 方向，独角兽）](https://www.nowcoder.com/discuss/925527528259743744)追问：SFT 的作用是什么？为什么通常先做 SFT 再做强化学习？】【[MiniMax - 大模型算法岗（后训练 / SFT / RL）](https://www.nowcoder.com/discuss/926272883872075776)追问：SFT 的作用及为何先 SFT 后 RL？】 **新手答**：“SFT先打个基础，GRPO在上面调效果更好。” **高手答**： **根本原因**：GRPO 需要模型能生成“有区分度”的样本来计算相对奖励。 **直接从基座做GRPO的问题**： 1. **采样质量差**：基座模型在tool-use任务上几乎随机输出，生成的多个样本之间质量无明显差异 → 相对奖励方差接近0 → 梯度信号极弱 2. **格式不对齐**：基座不会输出正确的工具调用格式，所有样本的reward都是0 → GRPO的advantage全为0，等于没训练 3. **探索空间太大**：基座的策略空间极其分散，GRPO的exploration效率极低 **SFT先做的价值**： 1. **格式对齐**：模型学会了输出正确格式的工具调用 → GRPO采样时至少格式对了 2. **缩小策略空间**：模型已经大致知道“该做什么”，GRPO只需优化“怎么做得更好” 3. **提供reward区分度**：SFT后的模型能生成“质量有高有低”的轨迹 → GRPO的相对奖励有意义 ```mermaid flowchart LR subgraph bad["直接 GRPO（不稳定）"] direction LR B1["基座模型"] --> B2["采样：格式全错\nreward 全为 0"] B2 --> B3["advantage = 0\n无学习信号"] end subgraph good["SFT → GRPO（稳定）"] direction LR G1["基座模型"] --> G2["SFT：学会格式\n缩小策略空间"] G2 --> G3["GRPO：采样质量有区分\n相对奖励有意义"] end ``` **类比**：先教人走路（SFT），再教人跑得快（GRPO）。直接教婴儿跑步，反馈信号全是负的。 **工程经验**：SFT阶段用 200-500 条高质量轨迹就够，关键是覆盖常见工具组合模式。 **差距在哪**：面试官考的是对“SFT+RL”两阶段训练范式背后信息论原理的理解——为什么是两步不是一步。能说出“基座模型采样无区分度导致GRPO梯度信号消失”这个核心原因，说明你理解了GRPO的工作前提。 --- ## Q：训练后量化的完整流程是什么？粒度、校准方法和离群值如何共同影响精度？ > 来源：[摩尔线程 AI Infra 二面](https://www.nowcoder.com/feed/main/detail/e1ac5e7fccf243c5898394d80911b3c0)、[智谱 AI Infra 一面](https://www.nowcoder.com/feed/main/detail/846a09e34fea4fe9a7e14da2a88e3f72)、[百度 AI Infra 一面](https://www.nowcoder.com/feed/main/detail/e7b7f56f4f0e4752a08c6b78566324f0) **新手答**：“准备一批校准数据，统计最大最小值，再把 FP16 权重转成 INT8 或 INT4。” **高手答**： 先确定量化对象和部署约束：只量化权重，还是同时量化激活、KV Cache；目标后端是否有对应 Kernel；允许多大精度回退。然后使用与线上分布一致、覆盖长短输入和困难样本的校准集采集张量统计，按 Per-Tensor、Per-Channel 或 Per-Group 选择缩放粒度，再决定对称/非对称量化、数据格式和舍入策略。 MinMax 实现简单，但单个离群值会拉大范围；Percentile 通过裁剪尾部换取主体分辨率；KL、MSE 等方法直接搜索量化前后分布或误差的折中。激活离群明显时，可采用通道级缩放、离群通道保留高精度或权重与激活重参数化。粒度越细通常误差越小，但 Scale 元数据、反量化和 Kernel 复杂度越高。 验收不能只看权重重构误差：需要逐层定位敏感模块，对困惑度、下游任务、安全集和长上下文分层回归，同时实测 TTFT、TPOT、吞吐、显存和成本。若后端没有高效低精度 Kernel，模型虽然更小，也可能因反量化或 Shape 不合适而更慢。 **差距在哪**：新手把 PTQ 当类型转换，高手把校准分布、粒度、离群值、Kernel 支持和端到端验收串成一条决策链。 --- ## Q：GPTQ、AWQ、SmoothQuant 与 AdaQuant 的核心思路有什么不同？ > 来源：[智谱 AI Infra 一面](https://www.nowcoder.com/feed/main/detail/846a09e34fea4fe9a7e14da2a88e3f72)、[后摩智能 AI Infra 一面](https://www.nowcoder.com/feed/main/detail/9b2e184532094836bfeb0658f3c0f22a)、[AI Infra 小厂面经](https://www.nowcoder.com/feed/main/detail/c7eee5b04fb8424aa4847f0e21fab875) **新手答**：“它们都是低比特量化方法，GPTQ 和 AWQ 量权重，SmoothQuant 量激活。” **高手答**： 这些方法处理的困难不同。GPTQ 用校准数据近似二阶信息，按块逐步量化权重并补偿误差，重点是 Weight-only PTQ 的重构质量；AWQ 根据激活统计识别对输出更敏感的权重通道，通过缩放保护显著权重，再做低比特权重量化；SmoothQuant 把激活中的离群难度通过等价缩放迁移到更容易量化的权重侧，主要服务 W8A8 一类权重和激活同时量化场景。 AdaQuant 这一名称在不同论文或实现中可能指不同的自适应量化方案，不能只背缩写。回答时应先锁定具体论文或库，再说明它优化 Scale、舍入还是逐层重构。方法可以组合，但组合后的格式必须被 Serving 后端支持，否则离线误差更低也不等于线上收益更高。 选型要看模型结构、目标位宽、是否量化激活、校准数据、允许的校准成本和硬件 Kernel。最终用同一基线比较质量、模型大小、预处理时间、端到端时延和吞吐，不能引用脱离模型与硬件的固定加速倍数。 **差距在哪**：新手记方法标签，高手说清每种方法在解决哪类误差、依赖什么统计，以及算法收益如何受部署后端约束。 --- ## Q：长时序任务中的 Agent RL 为什么容易训练失稳？如何缓解？ > 来源：[字节大模型算法岗](https://www.nowcoder.com/discuss/926272098744438784)、[腾讯 CSIG 大模型算法岗](https://www.nowcoder.com/discuss/925526785003909120)、[腾讯 WXG 大模型算法岗](https://www.nowcoder.com/discuss/925163074921709568) **新手答**：“轨迹太长导致奖励稀疏，可以加过程奖励和增大 Batch。” **高手答**：长轨迹会同时放大信用分配、方差和分布漂移：终局奖励难判断哪一步有效，少数早期动作会改变后续全部状态；工具延迟、环境随机性和无效长轨迹造成回报重尾；一次 Policy 更新后，旧 Rollout 与新策略的比率在多步连乘下更容易偏离；截断还会把未完成任务误标成失败。只增大 Batch 不能修复错误奖励或环境不可复现。 治理从数据与环境开始：固定工具/环境版本并记录完整轨迹，区分超时、环境故障和策略失败；从短任务、小动作空间和可靠初始策略做 curriculum，再逐步延长 horizon。训练侧使用可验证的阶段里程碑、价值基线或分段 Advantage 降方差，对异常长轨迹和极端重要性权重做诊断性裁剪，并控制每次更新幅度与 Rollout 新鲜度；过程奖励必须做防作弊测试，不能鼓励模型刷步骤。 评测按轨迹长度切片，观察成功率、首错步骤、有效动作率、奖励方差、KL/策略漂移、工具错误、恢复率和单位成功成本。若短任务改善而长任务退化，应先检查信用分配和状态覆盖，不要用总体平均值掩盖 horizon collapse。 **差距在哪**：新手只看到奖励稀疏，高手把环境噪声、策略滞后、长尾方差、截断偏差和课程学习连成稳定训练闭环。 --- ## Q：Agentic CPT、SFT、RL 三阶段分别训练什么能力？ > 来源：字节跳动/AI Agent 秋招一面【[阶跃星辰（Stepfun）- 大模型算法岗（Post-train）](https://www.nowcoder.com/discuss/926273007276814336)追问：后训练全链路（数据→SFT→RL）详细介绍？】 **新手答**：“CPT 学领域知识，SFT 学格式，RL 提升效果。” **高手答**： 三阶段解决的问题不同： | 阶段 | 主要数据 | 核心目标 | |------|----------|----------| | Agentic CPT | 领域文档、代码、工具说明、交互日志 | 建立领域表征和环境先验 | | SFT | 高质量示范轨迹 | 学会协议、工具格式、规划和恢复范式 | | RL | 可执行环境中的在线采样轨迹 | 超越示范，优化任务成功率、成本和安全 | CPT 不能替代 RAG，它适合稳定、通用的领域模式，不适合频繁变化的事实；SFT 要覆盖成功、澄清和失败恢复轨迹，避免模型只会“顺风局”；RL 的奖励应包含任务完成、工具正确性、效率和安全，并通过 KL 约束防止破坏已有能力。 工程上不是固定三段全做：基座已懂领域且示范足够时可跳过 CPT；没有可靠可验证环境时不要贸然上 RL。每阶段都要用同一套端到端基准验收，避免局部 loss 下降却任务成功率变差。 **差距在哪**：新手只背训练名词，高手能说明每阶段的数据、能力边界、可跳过条件和统一验收标准。面试官考的是 Agent 后训练方案设计。 --- ## Q：LoRA 应该挂在哪些层？rank、alpha 和 dropout 如何共同影响效果？ > 来源：Shopee 大模型一面（2026-08-22）【[阶跃星辰（Stepfun）- 大模型算法岗（Post-train）](https://www.nowcoder.com/discuss/926273007276814336)追问：LoRA 的 rank 值越大越好吗？为什么？】 **新手答**：“通常挂 Q、V，rank 越大能力越强，dropout 防过拟合。” **高手答**： 挂载层取决于任务需要改变什么能力。只挂注意力 Q/V 参数少，适合轻量适配；需要明显改变表达、领域风格或生成能力时，常同时评估 K/O 与 MLP 的 up/down/gate 投影。不能只按经验固定层，应通过目标模块消融比较质量、显存、吞吐和合并成本。 `rank` 决定增量矩阵容量，过小欠拟合、过大增加显存并可能记忆噪声；缩放通常是 `alpha / rank`，改变 rank 时要同步理解有效更新幅度；dropout 对小数据可正则化，但过高会削弱有限的适配信号。最终按验证集与能力回归集联合选参，并记录基座、目标模块和量化配置，否则 LoRA 参数不可复现。 **差距在哪**：新手背默认配置，高手从能力目标、容量、缩放和消融实验解释选层与超参数。 --- ## Q：Agentic CFT 与 SFT、RL 的目标有何不同？为什么训练时要 Mask Observation Token？ > 来源：[Shopee Agent 开发一面](https://www.nowcoder.com/feed/main/detail/79fe3fc8f8cb4c4d9beca478f4279e3a)（2026-08-24）；[腾讯一面微调 Mask 追问](https://www.nowcoder.com/discuss/924026569318727680) **新手答**：“CFT 让模型持续学习 Agent 数据，SFT 学示范，RL 用奖励优化；Observation 不是模型生成的，所以不算 loss。” **高手答**： 这里先确认 CFT 的口径：若指 Agentic Continual Fine-Tuning，它关注的是模型在持续到来的新工具、新任务和新环境上增量吸收能力，同时控制灾难性遗忘；SFT 主要最大化固定专家示范中目标动作的似然；RL 则让策略在可交互环境中探索，直接优化任务成功、成本与安全等序列级回报。CFT 是数据和生命周期范式，不等于一种独立 loss，实践中可以使用 SFT、偏好优化或 replay/正则化组合实现。 Agent 轨迹通常交错出现 `assistant action -> environment observation -> assistant action`。Observation 是环境给定的条件，不是策略要预测的动作，因此应保留在 attention 上下文中，但将其 label 设为 ignore，只对 Assistant 的推理、工具调用和最终回答计算 loss。否则模型会花容量背诵工具返回，甚至学会“伪造环境结果”；较长 Observation 还会主导 token 平均 loss，稀释真正动作 token 的梯度。 “是否 Mask User、System、Tool”不能脱离数据契约回答。prompt-completion 目标通常只对 completion 计 loss；assistant-only 的多轮 SFT 通常只监督 Assistant span；全序列语言建模则可能对所有 token 计算 next-token loss。即使消息角色叫 Tool，也要区分 Assistant 生成的工具名/参数与环境回传的 Tool Result：前者是策略动作，通常需要监督；后者是条件信息，通常只参与 attention。User/System 是否 Mask 同样取决于要训练的是回复策略还是全序列建模，不能把“外部信息”当作无条件忽略规则。 但不能机械地按文本标签 Mask：需要可靠的 role/span 边界，工具调用参数若由模型生成必须计入 loss，工具返回和系统注入才 Mask；多模态环境 token、错误反馈也要按生产协议确定归属。训练后分别评测动作选择、参数正确率、Observation 利用率和最终任务成功率，避免模型虽然不预测 Observation，却也不读取它。 **差距在哪**：新手只记住“Observation 不算 loss”，高手能区分条件 token 与策略动作，说明错误 Mask 的训练后果，并指出 CFT 是持续适配目标而不是另一种神秘损失函数。 --- ## Q：DAPO 为什么可以不使用额外 KL 惩罚？它如何维持策略更新稳定？ > 来源：[字节大模型算法岗](https://www.nowcoder.com/discuss/926272098744438784)、[字节强化学习岗](https://www.nowcoder.com/discuss/925523582761857024) **新手答**：“DAPO 用 Clip 就能限制更新，所以不需要 KL。” **高手答**：先限定论文语境。[DAPO 论文](https://arxiv.org/abs/2503.14476)是在长链推理 RL 设置中报告移除 KL 项，并不是证明所有策略优化都不需要参考约束。它通过 asymmetric clipping 的 Clip-Higher 给低概率探索 Token 更大的上升空间，同时仍限制概率比率；Dynamic Sampling 移除组内奖励全相同、没有有效梯度的样本；Token-Level Policy Gradient、长度相关处理与稳定的数据/训练系统共同控制更新质量。 Clip 约束单样本概率比率，KL 衡量策略分布整体偏移，两者不等价。没有显式 KL 时仍要监控实际 KL、熵、Clip Fraction、重要性比率、响应长度、奖励方差和验证集能力；出现策略坍缩、语言漂移或 Reward Hacking 时，可以收紧学习率/Clip、改采样与奖励，必要时重新引入 KL 或参考模型约束。 因此正确回答是“在该算法和实验条件下，显式 KL 不是稳定性的唯一来源”，而不是“DAPO 证明 KL 无用”。复现还要核对代码版本、模型、数据、Reward 和采样配置，不能只抄论文中的一个开关。 **差距在哪**：新手把 Clip 当 KL 的替代公式，高手能区分局部更新约束与全局分布漂移，并说明 DAPO 的稳定性来自一组机制。 --- ## Q：Tool-use SFT 训练时，长轨迹采用截断、切分还是掩码？如何避免破坏工具依赖关系？ > 来源：唯品会/NLP算法实习一面 **新手答**：“按最大长度截断。” **高手答**： **三种方案对比**： | 方案 | 做法 | 核心问题 | |------|------|---------| | 截断（truncation） | 直接在 max_length 处截断 | 可能在工具调用和工具返回之间截断，导致模型学到“调了工具但看不到结果”的坏模式 | | 切分（chunking） | 按工具调用边界切分为多个训练样本 | 后续chunk丢失了前面的上下文，模型不知道为什么要做这一步 | | 掩码（masking） | 保留完整轨迹，但只对关键token计算loss | 对工具选择、参数填充、最终答案计算loss，中间的工具返回结果设为-100不计算loss | **最佳实践（组合方案）**： - 按“完整工具调用对”（call + result）为原子单位做切分 - 每个chunk保留摘要前缀（summary of previous steps）作为上下文 - 对工具返回的长文本做掩码（不让模型学习复述工具结果） **避免破坏依赖关系的具体做法**： 1. 定义“不可分割单元”：`[tool_call, tool_result, model_reasoning]` 三元组不能跨chunk分割 2. 在不可分割单元内部做 padding 到固定长度，而非跨单元截断 3. 如果轨迹太长装不下，优先丢弃中间的重复步骤（如多次相似检索），保留首尾 ```mermaid flowchart LR A["长轨迹"] --> B["识别原子单元\ntool_call + result + reasoning"] B --> C{"总长度超限？"} C -->|"否"| D["整条轨迹训练\n工具返回做掩码"] C -->|"是"| E["按原子单元边界切分\n每段加摘要前缀"] E --> F["丢弃中间重复步骤\n保留首尾关键步骤"] ``` **差距在哪**：面试官考的是对 SFT 数据工程细节的掌握——如何在有限窗口内保持轨迹完整性是核心挑战。能说出“不可分割单元”的概念和具体做法，说明你做过工具调用模型的训练数据工程。 --- ## Q：GRPO 中相对奖励是如何计算的？同一组奖励方差接近零时如何处理？ > 来源：唯品会/NLP算法实习一面 **新手答**：“奖励减去均值再除以标准差。” **高手答**： **GRPO 相对奖励计算**： - 对同一个 prompt，采样 K 条 response（如 K=8） - 计算每条的 reward：r_1, r_2, ..., r_K - 相对奖励（advantage）：A_i = (r_i - mean(r)) / std(r) - 本质：在这组样本内做 z-score 标准化——“相对同组其他样本好多少” **方差接近零的场景**： - 全部正确（全0/全1 reward）：所有样本质量一样，无法区分好坏 - 任务太简单/太难：简单任务所有样本都对了，难任务所有样本都错了 **处理方案**： | 方案 | 做法 | 原理 | |------|------|------| | 跳过该 batch | 方差 < ε（如0.01）时不计算loss | 避免用噪声梯度污染模型 | | 增大采样数K | K=8改为K=16 | 增加出现质量差异的概率 | | 温度调高 | 采样时用更高temperature（如1.0→1.2） | 增加输出多样性 | | 混合难度prompt | batch内包含不同难度的prompt | 避免整个batch方差为0 | | 细粒度reward | 不只是0/1，用连续分数（工具选对+0.3，参数对+0.3，最终答案对+0.4） | 增加区分度 | ```mermaid flowchart TB A["采样 K 条 response"] --> B["计算 rewards"] B --> C{"std(rewards) < ε？"} C -->|"是"| D["跳过该组\n不计算梯度"] C -->|"否"| E["正常计算 advantage\nA_i = (r_i - mean) / std"] E --> F["更新策略"] D --> G["诊断原因"] G --> H1["太简单 → 移除该 prompt"] G --> H2["太难 → 降低难度/增大 K"] G --> H3["多样性不够 → 提高 temperature"] ``` **工程经验**：实际训练中约5-10%的batch会遇到方差为0的情况，直接skip不会显著影响收敛。 **差距在哪**：面试官考的是对GRPO训练细节的工程经验——论文里不会写“方差为0怎么办”，但实际训练必须处理。能给出五种具体方案并说出“5-10%的batch会遇到”这样的经验数据，说明你做过RL训练而非只读过论文。 --- ## Q：Tool-use 轨迹长度与任务复杂度有什么关系？训练数据应如何分布？ > 来源：唯品会/大模型算法实习 **新手答**：“简单任务轨迹短，复杂任务轨迹长，训练时都放一些。” **高手答**： 轨迹长度不是目标，而是任务复杂度、工具依赖深度和失败恢复次数的结果。最短轨迹通常是一次工具调用：识别意图、填参数、调用、回答；最长轨迹可能包含规划、多个有依赖的工具、观察结果、重规划和失败恢复。 数据集不能按 token 长度机械配比，应按能力分桶： | 分桶 | 典型轨迹 | 训练目标 | |------|----------|----------| | 单工具短轨迹 | 1 次调用 | Schema 遵循、参数填充 | | 多工具并行 | 多个无依赖调用 | 工具选择、结果聚合 | | 多工具串行 | A 的输出作为 B 的输入 | 依赖推理、状态传递 | | 长程恢复轨迹 | 调用失败后重试或换工具 | 错误诊断、重规划 | 工程上先统计生产任务的步骤数、工具数、依赖深度和失败率，再分层采样。训练时使用长度分桶和 token-budget batch，避免少量超长样本吞掉显存；评测则按桶分别报告成功率，不能只看总体平均值。 **差距在哪**：新手只看到“长短”，高手会把轨迹长度还原为工具依赖、规划和恢复能力，并说明如何分桶采样与分层评测。面试官考的是训练数据是否真实覆盖线上任务分布。 --- ## Q：Tool-use 强化学习中的内容奖励应如何设计？ > 来源：唯品会/大模型算法实习（ToolRL 追问） **新手答**：“用另一个大模型判断最终回答好不好。” **高手答**： 内容奖励衡量的不是“调用格式正确”，而是工具结果是否被正确理解并用于完成任务。应拆成可归因的多个信号： 1. **事实一致性**：回答中的关键事实能否在工具 observation 中找到依据。 2. **任务完成度**：用户要求的约束和字段是否全部满足。 3. **答案相关性**：是否直接回答问题，避免堆砌无关工具输出。 4. **引用与计算正确性**：来源绑定是否正确，基于工具结果的计算是否可复验。 5. **安全与拒答**：工具无结果或权限不足时，不编造内容。 可验证任务优先用规则、单元测试或执行器奖励；开放问答再用校准过的 LLM-as-Judge。总奖励可写成 `R = w_f R_format + w_t R_tool + w_c R_content + w_s R_safety`，并单独监控各分量，防止模型靠冗长回答骗取内容分。 **差距在哪**：新手把内容奖励当一个主观总分，高手会把它拆成可验证、可归因的信号，并处理奖励投机。面试官考的是 reward 能否真正驱动目标行为。 --- ## Q：多工具调用存在依赖关系时，Reward 应如何做信用分配？ > 来源：唯品会/大模型算法实习 **新手答**：“最后成功就给 1 分，失败就给 0 分。” **高手答**： 只给终局 0/1 奖励会产生严重的稀疏奖励问题：模型不知道是工具选错、参数错、顺序错，还是某一步结果没有正确传递。应把工具链表示为依赖 DAG，并同时设计过程奖励和终局奖励： ```mermaid flowchart LR A[选择正确工具] --> B[参数与依赖满足] B --> C[调用顺序合法] C --> D[正确消费 observation] D --> E[任务完成] ``` - 节点奖励：工具选择、参数合法、调用成功。 - 边奖励：下游参数是否正确引用上游输出，依赖顺序是否满足。 - 终局奖励：完整任务是否完成、最终答案是否正确。 - 效率惩罚：重复调用、无效分支、过多 token 和超时。 为避免“每一步都对但整体失败”仍拿高分，过程奖励只能占较小权重，并设置终局门控：任务未完成时过程分封顶。若有步骤级标注，可训练 PRM；没有标注时可用执行日志和依赖校验器自动产生大部分奖励。 **差距在哪**：新手只有终局奖励，高手能对 DAG 的节点和边做信用分配，同时用终局门控防止局部最优。面试官考的是多步 Tool-use RL 的稀疏奖励与奖励投机问题。 --- ## Q：Agent 交互轨迹与普通语言模型语料有什么区别？如何仿真高质量轨迹？ > 来源：字节/Agent 算法实习一面 **新手答**：“Agent 数据多了工具调用和多轮对话，可以让强模型生成。” **高手答**： 普通语料主要学习下一个 token；Agent 轨迹还包含环境状态、计划、动作、工具参数、observation、奖励和终止原因。质量不仅看文本自然度，还看动作是否合法、状态是否连续、工具结果是否真实、失败恢复是否合理。 仿真流程应基于可执行环境：先从真实任务分布采样目标和约束，再让用户模拟器产生澄清、改口和中断；Agent 在沙箱中调用真实或高保真工具，记录成功与失败轨迹；验证器检查最终结果和每一步状态转移。数据集同时保留最优轨迹、可恢复失败轨迹和不可恢复负例，并按任务难度、工具依赖深度和异常类型分层采样。 强模型自举只能生成候选，不能把虚构 observation 当真值。工具结果、权限和最终状态必须由环境或规则验证，抽样再由人工审计。 **差距在哪**：新手把轨迹当“带工具标签的对话”，高手理解它是状态转移数据，并用可执行环境、用户模拟器和验证器保证真实性。 --- ## Q：多轮对话 RL 如何设计过程奖励与终局奖励，并避免用户模拟器过拟合？ > 来源：[阿里云 AI Infer 一面](https://www.nowcoder.com/discuss/921086976030150656)（2026-08-23） **新手答**：“每轮回答打一个分，任务完成再给最终奖励。” **高手答**： 终局奖励衡量任务是否完成、约束是否满足和用户目标是否达成；过程奖励只评价可验证的中间进展，例如正确澄清、合法工具调用、状态更新和避免重复动作。过程分不能盖过终局失败，可使用终局门控或较小权重，并对奖励模型做一致性和抗投机测试，防止模型学会讨好模拟器。 用户模拟器应覆盖不同目标、表达、耐心、改口、中断和异常工具反馈，并按真实线上分布分层采样。训练与评测使用不同的模拟器 Prompt、模型和场景模板，保留真人对话与可执行环境作为外部验证；若策略只在某个模拟器上提升而跨模拟器、真人集下降，应判定为过拟合。还要监控对话长度、无效澄清率和奖励组成，识别 Reward Hacking。 **追问：多轮对话 RL 如何冷启动并保证业务约束？** 先用 SFT、规则策略或可验证的专家轨迹把策略拉进有效动作分布，再逐步增加在线探索；一开始就让随机策略跑长链路，会把大部分算力浪费在无效状态。业务硬约束应由环境和程序门禁强制执行，奖励只负责优化“在合法空间里哪条路径更好”，不能用一个负分代替权限、金额上限或合规校验。冷启动阶段按任务难度做 curriculum，并用独立规则集检查约束遵循，避免策略只学会迎合用户模拟器。 **差距在哪**：新手只是把奖励拆成两段，高手处理信用分配、终局门控、模拟器分布和跨环境验证。面试官考的是 RL 指标提升是否代表真实交互能力提升。 --- ## Q：为什么 SFT 后继续做 DPO/PPO 等偏好优化可能导致基础能力退化？ > 来源：哔哩哔哩 AI 后端开发凉经（2026-08-22） **新手答**：“偏好数据太少或学习率太大，模型过拟合了。” **高手答**： 偏好数据通常覆盖窄、风格偏置强，优化会把概率质量推向少数偏好模式；奖励模型或偏好标签的系统误差会被策略放大。训练分布偏离 SFT 分布、KL 约束不足、重复离线数据导致过优化，以及长回答更易获高分等偏差，都可能让通用知识、指令遵循和多样性下降。 治理上混入高质量 SFT/通用 replay 数据，控制学习率、步数和 KL，按能力分桶监控而不是只看总 reward；在通用、领域、安全和格式评测集上设置不可回退门槛。DPO 还要检查 chosen/rejected 长度与来源偏差，PPO 要监控 reward、KL、熵和 value loss 的联动。必要时使用 adapter 隔离或回滚，而不是追求单一偏好榜分。 **差距在哪**：新手把退化归因于“过拟合”，高手说明了分布漂移、奖励偏差和策略过优化的具体机制，并给出多能力门禁。 --- ## Q：KV Cache Block 的哈希和逻辑到物理映射应该怎么设计？ > 来源：智象未来 AI Infra 一面（2026-08-20） **新手答**：“对 Token 前缀做 Hash，命中后复用对应 KV Cache。” **高手答**： 哈希键不能只有 Token 内容，还应包含模型与权重版本、Tokenizer、位置编码配置、adapter/LoRA、模态输入摘要及影响 KV 的前缀配置。通常按固定 Token Block 递归计算前缀哈希，逻辑块表记录序列的第几个块，物理块由全局分配器管理引用计数、空闲表和设备位置；请求命中最长共享前缀后，只为剩余 Token 分配新块。 写时采用 copy-on-write，避免共享块被后续生成修改。释放、换出和抢占必须更新引用计数与块表；哈希碰撞需要二次校验。模型或 Prompt 配置变化时应使用命名空间版本自然失效，不能跨不兼容请求复用。监控命中率、碎片率、复制量、换入换出和错误共享校验。 **差距在哪**：新手只有哈希表，高手说明了缓存正确性所依赖的版本键、块表、引用计数和写时复制。 --- ## Q：Agent 动作空间过大导致探索低效时，如何裁剪和分层？ > 来源：阿里千问 C 端算法实习一面（2026-08-10） **新手答**：“减少工具数量，或者让模型先做工具检索。” **高手答**：先按任务阶段、权限和前置条件形成动态可行动作集，再用分层策略让高层选择子目标、低层选择具体工具；同义动作合并为参数化能力，非法和无效动作由环境 mask。训练时采用课程学习，从短链和小动作集逐步扩展，并监控有效动作率、探索熵、无效调用和各阶段成功率。裁剪不能删除恢复动作，否则策略一旦偏离就无法回到有效状态。 **差距在哪**：新手只缩工具列表，高手同时设计层级策略、环境约束和训练分布。 --- ## Q：训练实验如何对 YAML 配置做规范化哈希，并保证单变量变化可复现？ > 来源：[大方云图研发实习一面](https://www.nowcoder.com/feed/main/detail/a9a40feb4e1e4d0ca7c3f8c3ba67d487)（2026-08-24） **新手答**：“对 YAML 文件做 SHA-256；每次只改一个字段并保存 Git commit。” **高手答**： 不能直接哈希原始文本：键顺序、注释、空白、`1` 与 `1.0`、环境变量和默认值都可能造成假差异或漏差异。正确流程是先用安全解析器读成 typed object，展开继承与默认值，解析环境变量和路径，按 Schema 规范化类型与单位，递归排序 key，再用稳定序列化生成 canonical bytes 并计算 SHA-256。运行时间、输出目录等非语义字段应明确排除，但排除清单也要版本化。 实验身份不能只有配置哈希，还应绑定代码 commit 与 dirty diff、数据集清单/切分哈希、容器或依赖 lock、基座权重与 Tokenizer 摘要、随机种子和硬件/算子确定性设置。启动器输出一份不可变的 resolved config，训练日志、checkpoint 和指标都记录同一 experiment ID。 “单变量”由机器校验：基准实验与候选实验对规范化对象做结构化 diff，除声明的实验因子外必须零差异；多 seed 重复并报告均值和方差。复跑时从 resolved config 重建环境，并校验所有摘要。即便如此，GPU 非确定性算子仍可能导致细微差异，因此要声明可复现等级：位级一致、指标容差一致，或仅统计结论一致。 **差距在哪**：新手哈希文件字节，高手哈希解析后的实验语义，并把配置、代码、数据、环境和随机性一起纳入可追溯实验身份。 --- ## Q：如何训练模型做高精度抽取式摘要？数据、目标、Loss 和评测如何设计？ > 来源：百度大模型实习 Agent 面经（2026-03-11） **新手答**：“把文档中的重要句子标成 1，其他句子标成 0，用二分类 Loss 训练，再用 ROUGE 评测。” **高手答**： 先固定任务口径：抽取式摘要是选择原文句子，还是抽取连续证据 span；输出预算按句数、字数或压缩率控制；“高精度”是要求选出的内容尽量都关键，允许低置信度时少选或拒答。三种口径对应不同标签和解码方式，不能拿生成式摘要直接当逐句真值。 数据要来自目标领域并按文档长度、结构、主题、噪声和压缩率分层。标注员先写摘要要覆盖的事实单元，再勾选最小支持句/span；多人标注并保留分歧，区分核心、可选和冗余证据。训练集加入标题党句、位置偏置、同义重复、局部相关但结论错误的困难负例；长文档按完整文档切分 train/dev/test，防止同一文档的相邻 chunk 泄漏。机器生成标签只能做弱监督，必须用人工金标集校准。 模型可用层级 Encoder：先编码 Token 和句子，再做跨句上下文建模，输出句子分数；连续 span 则用 start/end pointer 或 token tagging。Loss 不只是一项 BCE： | 目标 | 可选 Loss / 约束 | 解决的问题 | |------|-----------------|------------| | 句子相关性 | 加权 BCE 或 focal loss | 正负样本严重不平衡 | | 排序质量 | pairwise / listwise ranking loss | 核心句应排在次要句前 | | span 边界 | start/end cross-entropy 或 CRF loss | 抽取边界不精确 | | 覆盖与去冗余 | coverage reward + redundancy penalty | 重复选相似句、漏掉关键事实 | 若目标优先高精度，应在验证集上校准概率阈值，并允许 `abstain`；再在满足长度预算的候选中做去冗余选择，而不是固定 Top-K。类别权重、负采样和阈值要联合调，避免模型靠“什么都不选”获得虚假的高精度。 评测至少分四层：句/span 的 Precision、Recall、F1 和边界 Exact Match；固定预算下的 Precision@K、Recall@K 与 PR-AUC；摘要层的 ROUGE、事实单元覆盖率和重复率；人工评审关键信息、可读性、上下文完整性及是否因断章取义改变含义。结果按领域、长度、压缩率和首尾位置切片，并在真实 Agent 下游任务中 A/B 测试答案正确率、证据命中率和成本。抽取自原文不等于事实可靠，选错上下文同样会误导下游。 **差距在哪**：新手把任务简化成句子二分类，高手先明确句级/span 级目标，再把标注一致性、不平衡、排序、覆盖、阈值校准和下游效果串成闭环。面试官考的是能否真正把“高精度”变成可训练、可验收的指标。 --- ## Q：预训练与 SFT 在数据、目标函数、计算形态和基础设施上有什么区别？ > 来源：[AI Infra 小厂实习面经](https://www.nowcoder.com/feed/main/detail/166e576d5afa4a298cf9492ed51bed04) **新手答**：“预训练用海量无标注数据学习通用能力，SFT 用问答数据让模型学会对话。” **高手答**： 两者都常使用下一个 Token 预测，但数据分布和 Loss Mask 不同。预训练面对大规模连续语料，通常对绝大多数有效 Token 计算 Loss，重点是数据去重、混合比例、长序列装箱和稳定扩展；SFT 使用指令、对话或 Agent 轨迹，通常只监督 Assistant 动作，System/User/Tool Observation 作为条件输入并 Mask，重点是任务覆盖、格式正确、边界样本和防止能力遗忘。 计算侧，预训练规模大、周期长，主要追求集群 MFU、并行效率、Checkpoint 和故障恢复；SFT 数据更小、实验更频繁，常用 LoRA/QLoRA 或较小学习率，关注多版本评测、快速回滚和数据配方可追溯。SFT 也可能全参训练，预训练也不一定只有纯文本，不能用“是否微调参数”定义两者。 验收目标也不同：预训练看 Loss、Scaling 趋势和通用能力，SFT 看指令遵循、领域任务、工具调用、安全以及基础能力回归。生产中应固定基座、Tokenizer、模板、Mask 规则和数据版本，否则无法判断提升来自训练目标还是协议变化。 **差距在哪**：新手只按数据量区分，高手能连接 Loss Mask、数据管线、并行与实验迭代方式，以及两阶段不同的验收目标。 --- ## Q：Agentic RL 数据筛选为什么会排除部分学生错误轨迹？哪些可恢复错误反而值得保留？ > 来源：[阿里云 AI Infer 一面](https://www.nowcoder.com/discuss/921086976030150656) **新手答**：“错误轨迹会教坏模型，所以全部过滤，只保留成功轨迹。” **高手答**： 先挑战前提：**没有“错误轨迹一律排除”的通用规则**。要区分它在训练中扮演什么角色。 - 作为 SFT/蒸馏目标：如果把学生的错误 Action 当成 target，确实会强化错误；环境损坏、奖励错标、工具协议解析失败等脏轨迹也应隔离。 - 作为 on-policy RL 样本：失败正是当前策略分布的一部分，直接删掉会造成选择偏差，还可能让训练看不到最需要修复的状态。 - 作为恢复能力数据：`错误动作 → 真实 Observation → 识别错误 → 改计划 → 成功` 很有价值，但 loss 应监督纠正动作，不能把错误动作伪装成专家示范。 我会给轨迹记录 `policy_version`、环境/工具版本、Action 合法性、奖励可信度、首错步骤、是否可恢复和终态。筛选顺序是：先去掉环境/标签损坏数据，再把有效成功轨迹、可恢复失败和不可恢复失败分桶；SFT、偏好学习和 RL 分别消费适合自己的视图。还要保留失败率和过滤率监控，防止只训练“顺风局”。 没有主流算法规定“失败轨迹必须全部过滤”，这是数据视图和训练目标共同决定的工程选择。近期 [SENTINEL failure-driven Agent RL 论文](https://arxiv.org/abs/2606.12908)还会从失败轨迹归纳错误模式并生成针对性任务，进一步说明失败不是天然废料；但这项研究的具体收益不能外推成所有任务的通用结论。 **差距在哪**：新手按成功/失败二分数据，高手会区分错误示范、有效探索和恢复轨迹，并防止筛选改变 on-policy 分布。 --- ## Q：TTS 音频如何被离散化为 Token，语义与音色信息如何取舍？ > 来源：[MiniMax 大模型算法岗一面](https://www.nowcoder.com/discuss/926272883872075776) **新手答**：“把波形切帧后做向量量化，每个码本索引就是一个 Token。” **高手答**：典型神经音频 Codec 先把波形编码为低帧率连续表示，再用单级 VQ 或 Residual Vector Quantization 映射为离散码本索引，Decoder 从索引重建波形。码率约由“每秒帧数 × 每帧码本数 × 每个索引位数”决定；码本更多、帧率更高通常提高重建质量，但会拉长序列并增加语言模型成本。[EnCodec 官方实现](https://github.com/facebookresearch/encodec)展示了这种编码器、RVQ 和解码器路线。 通用 Codec Token 优先保真，可能把说话人、背景和语义混在一起；面向 Speech LLM 时还希望上层 Token 更偏语义、下层 Token 补音色和声学细节。[SpeechTokenizer 论文](https://arxiv.org/abs/2308.16692)采用分层 RVQ 并用语义蒸馏约束第一层，但这是一种具体实现，不代表所有 TTS Tokenizer 都按同样层次解耦。训练时还要防止码本塌缩，监控 codebook perplexity、利用率和死码。 端到端验收同时看重建质量/可懂度、说话人相似度、韵律、码率、Token 序列长度和生成延迟。只优化波形重建可能得到“声音像但语义建模难”的 Token；只优化语义又可能丢失音色，因此要按 TTS、理解或通用语音交互的目标选择表示。 **差距在哪**：新手只知道 VQ，高手能解释码率、层级语义、码本塌缩和下游生成成本之间的权衡。 --- ## Q：LLaMA-Factory 和 TRL 等 SFT / RL 工具如何对比和选型？ > 来源：[MiniMax 大模型算法岗一面](https://www.nowcoder.com/discuss/926272883872075776) **新手答**：“LLaMA-Factory 配置简单，TRL 更灵活；做 SFT 用前者，做 RL 用后者。” **高手答**：两者不是按算法阶段互斥。当前 [LLaMA-Factory 官方仓库](https://github.com/hiyouga/LlamaFactory)强调统一训练入口、模型/数据模板、参数高效微调、量化和可视化配置，适合需要快速覆盖多模型与复现实验配方的团队；[TRL 官方文档](https://huggingface.co/docs/trl/index)提供围绕 Transformers 的 SFT、偏好优化与强化学习 Trainer，适合直接扩展数据 Collator、Reward、Trainer Loop 和研究算法。具体支持列表会变化，选型必须绑定版本验证。 我会先比较数据与模板契约、目标算法是否原生支持、分布式后端、显存优化、断点恢复、评测/日志、扩展点和团队维护能力，再跑同一小数据集的 smoke test。无论选哪个，都要检查 chat template、special token、loss mask、packing、梯度累积和 checkpoint 能否一致；“命令能跑”不代表两套实现训练语义相同。 生产上可以用 LLaMA-Factory 管标准化批量配方，用 TRL 承载需要改 Trainer 的实验，但要共享数据版本、模型制品、评测集和实验追踪。若二次封装过深，升级成本和行为漂移可能超过框架带来的便利，因此还要评估退出路径。 **差距在哪**：新手按“易用 / 灵活”贴标签，高手按训练语义、扩展边界、可复现性和团队生命周期做条件化选择。 --- ## 这类题的答题模式 训练与数据题的核心是**全链路思维**： ```text 1. 数据质量 > 数据数量——"不真实"比"不够"更致命 2. 训练集不只要正样本——负样本和边界样本决定线上表现 3. 微调方法按场景选——不是"哪个好"，而是"什么场景用哪个" 4. 对齐方法看数据形态——PPO/DPO/GRPO 的核心差异在数据需求 ``` 下一篇建议继续看： - [AI 代码分析与测试：覆盖率、插桩、代码过滤](../11-ai-code-testing/index.html)