NLP——LLM-Attention优化之MLA

本文主要介绍LLM-Attention优化方法中的MHA、MQA、GQA到MLA的发展历程

参考链接：
- MLA原始论文：DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model
- GQA原始论文：GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints
- 来自苏神的参考链接：缓存与效果的极限拉扯：从MHA、MQA、GQA到MLA
- 讲的较为清晰的原创博客：deepseek技术解读(1)-彻底理解MLA（Multi-Head Latent Attention） - 姜富春的文章 - 知乎

MHA/MQA/GQA/MLA对比和讨论

MHA/MQA/GQA Overview（from GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints ）
KV-Cache示意图 (from deepseek技术解读(1)-彻底理解MLA（Multi-Head Latent Attention） - 姜富春的文章 - 知乎)
MHA/MQA/GQA/MLA Overview（from DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model ）
原始论文中，MLA的示意图 * 核心，MLA 将 Q 和 K 拆开成引入 RoPE 和不引入 RoPE（NoPE）两部分，两者的 q 和 k 分别做 concat，本质是 qk 相乘以后做加法
MHA/MQA/GQA 效果对比
从上图中可以看出，整体效果为：MLA > MHA > GQA > MQA
- 问题：为什么目前在很多模型中，GQA 仍然是常客？

带RoPE的普通MHA

公式（from 缓存与效果的极限拉扯：从MHA、MQA、GQA到MLA）：
$$
\begin{align}
\boldsymbol{o}_t &= \left[\boldsymbol{o}_t^{(1)}, \boldsymbol{o}_t^{(2)}, \cdots, \boldsymbol{o}_t^{(h)}\right] \\
\boldsymbol{o}_t^{(s)} &= Attention\left(\boldsymbol{q}_t^{(s)}, \boldsymbol{k}_{\leq t}^{(s)} ,\boldsymbol{v}_{\leq t}^{(s)}\right)\triangleq\frac{\sum_{i\leq t}\exp\left(\boldsymbol{q}_t^{(s)} \boldsymbol{k}_i^{(s)}{}^{\top}\right)\boldsymbol{v}_i^{(s)}}{\sum_{i\leq t}\exp\left(\boldsymbol{q}_t^{(s)} \boldsymbol{k}_i^{(s)}{}^{\top}\right)} \\
\boldsymbol{q}_i^{(s)} &= \boldsymbol{x}_i\boldsymbol{W}_q^{(s)}\color{red}{\boldsymbol{\mathcal{R}}_i}\in\mathbb{R}^{d_k},\quad \boldsymbol{W}_q^{(s)}\in\mathbb{R}^{d\times d_k}\\
\boldsymbol{k}_i^{(s)} &= \boldsymbol{x}_i\boldsymbol{W}_k^{(s)}\color{red}{\boldsymbol{\mathcal{R}}_i}\in\mathbb{R}^{d_k},\quad \boldsymbol{W}_k^{(s)}\in\mathbb{R}^{d\times d_k} \\
\boldsymbol{v}_i^{(s)} &= \boldsymbol{x}_i\boldsymbol{W}_v^{(s)}\in\mathbb{R}^{d_v},\quad \boldsymbol{W}_v^{(s)}\in\mathbb{R}^{d\times d_v}
\end{align}
$$

带RoPE的MLA

核心思想是通过将K,V降维再升维的方式，既保证了每个head有不同的K,V，又能显著降低缓存量，巧妙的减少KV-Cache存储量（仅存储降维后的中间值即可），最早由DeepSeek提出
此外，在训练时，将Q值也进行了降维再升维（具体优势是什么？）
MLA公式（from 缓存与效果的极限拉扯：从MHA、MQA、GQA到MLA）：
$$
\begin{align}
\boldsymbol{o}_t &= \left[\boldsymbol{o}_t^{(1)}, \boldsymbol{o}_t^{(2)}, \cdots, \boldsymbol{o}_t^{(h)}\right] \\
\boldsymbol{o}_t^{(s)} &= Attention\left(\boldsymbol{q}_t^{(s)}, \boldsymbol{k}_{\leq t}^{(s)} ,\boldsymbol{v}_{\leq t}^{(s)}\right)\triangleq\frac{\sum_{i\leq t}\exp\left(\boldsymbol{q}_t^{(s)} \boldsymbol{k}_i^{(s)}{}^{\top}\right)\boldsymbol{v}_i^{(s)}}{\sum_{i\leq t}\exp\left(\boldsymbol{q}_t^{(s)} \boldsymbol{k}_i^{(s)}{}^{\top}\right)} \\
\boldsymbol{q}_i^{(s)} &= \left[\boldsymbol{c}_i’\boldsymbol{W}_{qc}^{(s)}, \boldsymbol{c}_i’\boldsymbol{W}_{qr}^{(s)}\color{red}{\boldsymbol{\mathcal{R}}_i}\right]\in\mathbb{R}^{d_k + d_r},\quad \boldsymbol{W}_{qc}^{(s)}\in\mathbb{R}^{d_c’\times d_k},\boldsymbol{W}_{qr}^{(s)}\in\mathbb{R}^{d_c’\times d_r}\\
\boldsymbol{k}_i^{(s)} &= \left[\boldsymbol{c}_i\boldsymbol{W}_{kc}^{(s)}, \boldsymbol{x}_i\boldsymbol{W}_{kr}^{\color{lightgray}{\smash{\not{(s)}}}}\color{red}{\boldsymbol{\mathcal{R}}_i}\right]\in\mathbb{R}^{d_k+d_r},\quad \boldsymbol{W}_{kc}^{(s)}\in\mathbb{R}^{d_c\times d_k}, \boldsymbol{W}_{kr}^{\color{lightgray}{\smash{\not{(s)}}}}\in\mathbb{R}^{d\times d_r} \\
\boldsymbol{v}_i^{(s)} &= \boldsymbol{c}_i\boldsymbol{W}_v^{(s)}\in\mathbb{R}^{d_v},\quad \boldsymbol{W}_v^{(s)}\in\mathbb{R}^{d_c\times d_v} \\
\boldsymbol{c}_i’ &= \boldsymbol{x}_i \boldsymbol{W}_c’\in\mathbb{R}^{d_c’},\quad \boldsymbol{W}_c’\in\mathbb{R}^{d\times d_c’} \\
\boldsymbol{c}_i &= \boldsymbol{x}_i \boldsymbol{W}_c\in\mathbb{R}^{d_c},\quad \boldsymbol{W}_c\in\mathbb{R}^{d\times d_c} \\
\end{align}
$$
为了引入 RoPE，在中间向量中拼接了 RoPE 降维后的向量，该向量维度较小

原始论文中 MLA 完整公式

MLA 完整公式如下：
MLA 的 Q 和 K 分为 RoPE 和非 RoPE 两部分
- 表达在隐向量上则是从 concat
- 表达在最终的乘积结果上泽变成 sum
- 两种表达本质是一样的（对 qk 分别做 concat 和对 qk 乘积做加法结果等价），详情见：DeepSeek-v2 MLA 原理讲解-哔哩哔哩

NLP——LLM相关名词

本文主要介绍 LLM 相关名词，部分名词很简单，所以会给一个简单的定义，注：本文会特别关注还有其他含义（传统 NLP 中）的名词

LLM

Large Language Model，泛指大模型
LLM涌现出的3大能力：
- In-context learning：在GPT-3中正式被提出。在不需要重新训练的情况下，通过自然语言指令，并带几个期望输出的样例，LLM就能够学习到这种输入输出关系，新的指令输入后，就能输出期望的输出
- Instruction following：通过在多种任务数据集上进行指令微调（instruction tuning），LLM可以在没有见过的任务上，通过指令的形式表现良好，因此具有较好的泛化能力
- Step-by-step reasoning：通过思维链（chain-of-thought）提示策略，即把大任务分解成一步一步小任务，让模型think step by step得到最终答案

Pre-Training

通常指大模型的无监督预训练过程

Prompt

提示词，与 LLM 交互时输入 LLM 的文本
理解：叫做 Prompt 的原因是因为与 LLM 交互时，像是在给 LLM “提示“或者”线索“
Prompt 可以是上文，要求模型输出下文；也可以是 Mask 部分词后的句子，要求模型完成 Mask 预测（完形填空）

Template

模板（Template）是一个映射函数，不同的下游任务有不同的Template
- 这里的下游任务是指，在预算训练模型Pretrain LM之后，如果要让PLM完成下游任务，可以根据任务特色，设计特殊的模板，利用模板来将原始输入转换为能完成下游任务的输入形式
模板的形式通常是一个包含两个空位置的自然语言句子[X]个[Z]，其中[X]表示原始输入文本位置，Z表示生成的答案所在位置
举例来说，在做情感分类任务时，可以定义模板为[X], Overall, it was [Z]，对于原始输入文本I like this movie，则经过模板转换后，原始文本变成I like this movie, Overall, it was [Z]
- 训练时：输入I like this movie, Overall, it was [Z]，期望输出good(或其他正向词语)
- 推理时：输入I like this movie, Overall, it was [Z]，输出通常通过Verbalizer构造方法对应到正/负向类别

Prompt Learning

Prompt Learning是一种训练语言模型的方法，它侧重于如何通过prompt来引导模型生成正确的输出。在这种方法中，模型通过学习大量的prompt和相应的正确回答来提高其对prompt的理解和回答能力。Prompt Learning使得模型能够在没有大量标注数据的情况下，通过理解prompt的上下文来生成更加准确和相关的回答
离散型模板，即硬模板方法（hard-prompt）：
- 硬模板方法通过人工设计/自动构建基于离散 token 的模板，代表方法是PET和LM-BFF
- 其中Pattern Exploiting Training (PET) 方法就是将问题建模成一个完形填空问题，然后优化最终的输出词。PET方法训练流程为：
  - 在少量监督数据上，给每个 Prompt 训练一个模型；
  - 对于无监督数据，将同一个样本的多个 prompt 预测结果进行集成，采用平均或加权（根据acc分配权重）的方式，再归一化得到概率分布，作为无监督数据的 soft label ；
  - 在得到的soft label上 finetune 一个最终模型。推理时使用的就是这个最终模型
连续型模板，即软模板方法（soft-prompt）：
- 与硬模板方法不同，软模板方法不依赖于人工设计模板，而是在输入端直接插入可优化的伪提示符（Pseudo Prompt Tokens）。这些伪提示符的embedding是可训练的，模型通过学习来找到最优的提示表示。例如，P-Tuning（Prompt Tuning）方法就是通过优化这些伪提示符来提高模型的性能
- token是可以学习的向量，这种方法甚至可以媲美 Fine-tuning 的结果，代表方法是 P-Tuning（Prompt Tuning）和Prefix Tuning
- P-Tuning：P-Tuning（Prompt Tuning）的核心是将离散的文本提示（如 “请回答以下问题：”）转换为连续的向量表示（即 “软提示”），并通过反向传播优化这些向量，使模型在特定任务上表现更好。与传统微调（Fine-Tuning）需要更新整个模型参数不同，P-Tuning 仅需训练少量的提示向量，大幅降低了计算成本
  - 在输入层前插入一系列可训练的向量（称为 “提示 Token”），这些向量与输入文本的嵌入向量共同输入模型
- Prefix Tuning：模型上在每层 transformer 之前加入 prefix。特点是 prefix 不是真实的 token，而是连续向量(soft prompt)，Prefix-tuning 训练期间冻结 transformer 的参数，只更新 Prefix 的参数，开销很小
  - 每个下游任务对应一个 Prefix向量
P-Tuning vs Prefix Tuning：P-Tuning 仅在输入层插入提示向量（参数量极少），Prefix Tuning 在每一层 Transformer 前注入前缀向量（参数量较多）

In Context Learning (ICL)

参考其他地方的表述：

对于大型语言模型来说，即需要大量的数据标记成本，也需要算力成本和时间成本。然而，不同场景下任务的需求是不一样的，不可能根据每个任务都去微调模型。能否不进行微调就让模型学习完成不同的任务呢？答案是可以的，这个神奇的技术称为上下文学习（In Context Learning）。它的实现非常简单，只需要给到模型一些引导，将一些事先设定的文本输入到大型语言模型中，就像手把手教人学会某项技能一样，大型语言模型就能神奇的学习到如何处理后续的新任务。遗憾的是，为什么大型语言模型具有上下文学习的能力仍然是一个迷，业内把这个能力称为“涌现”
In Context Learning也可以理解为LLM涌现出的一种能力，在同一个Prompt中，LLM能够根据上文示例学习到解决下文任务
特点：不需要重新训练模型，也不需要微调任何参数，仅通过自然语言指令+几个期望输出的示例，让LLM学习到这种输入输出关系，从而让LLM能解决上文示例中相似任务
一种理解：将ICL输入模型的示例看做是“训练样本”，真正的问题部分看做是“测试样本”，LLM会在看了示例后给出问题的回答
- 此时“训练样本”和“测试样本”是同时输入模型的，LLM在使用“训练“自己的同时给出”推断“

Zero Shot & Few Shot & Full Shot

Zero-shot Learning （零样本学习） ：
- 模型在没有任何特定任务的示例数据的情况下，仅凭其在大量通用文本上预训练获得的泛化能力和对语言的理解来完成任务
- 这种方法依赖于模型的泛化能力，通过分析少量的示例来理解新任务的要求，并在此基础上生成正确的输出
- 例如：让一个 LLM 翻译一个它从未见过的语言的句子，它会尝试利用其对语言结构和语义的理解进行翻译
Few-shot Learning （少样本学习） ：
- 在提示 (prompt) 中提供少量（通常是几个）带标签的示例 ，帮助模型理解任务的格式、风格和预期输出，从而在不更新模型参数的情况下提高其在该任务上的表现
- 这种方法依赖于模型的泛化能力和对语言的理解，通过分析输入（没有任何示例）的描述来理解任务的要求，并生成相应的输出
- 例如：在进行情感分析时，你可以在提示中给出几个正面和负面评论的例子，然后让 LLM 对新的评论进行分类
Full-shot Learning （全样本学习） ：
- 与 zero-shot 和 few-shot 不同，full-shot 指的是传统的、有监督的学习范式 ，模型在大量的、任务特定的标注数据集上进行训练（或微调）
- 这通常意味着对模型进行参数更新 ，使其真正“学习”到该任务的特定模式
- 例如：如果要构建一个高度精确的垃圾邮件检测器，你会收集数百万封标注过的邮件（垃圾邮件或非垃圾邮件），然后用这些数据来训练或微调一个模型
LLM 因其卓越的 zero-shot 和 few-shot 能力而闻名，能够在没有或只有少量示例的情况下执行新任务
在 LLM 的背景下，当我们谈论 full-shot 时，它更侧重于模型在大量特定任务数据上进行微调 (fine-tuning)的过程，而不是仅仅通过提示来引导模型
- 这种微调可以显著提高模型在特定任务上的性能，因为它允许模型深入学习该任务的细微差别

Chain-of-Thought (CoT)

Chain-of-Thought是一种生成解释性回答的技术，它通过模拟人类解决问题的思维过程来生成答案
在CoT中，模型首先生成一个或多个中间步骤，然后基于这些步骤来构建最终答案
CoT 方法可以提高模型输出的透明度和可解释性，帮助用户理解模型是如何得出特定答案的

Alignment tuning

Alignment tuning，对齐微调，为了避免模型输出一些不安全或者不符合人类正向价值观的回复

RLHF

一种对齐微调（Alignment tuning）方法，基于人类反馈的强化学习方法

RLAIF

一种对齐微调方法，基于 AI 反馈的强化学习方法

Reward Hacking

参考链接（包含许多相关论文）：B站视频：Reward Hacking (in RLHF of LLM)

Reward Hacking是指在强化学习中，智能体通过学习最大化奖励信号的策略，可能导致不符合设计者预期的行为
- 这种行为可能会损害系统的安全性和可靠性，因为它可能导致智能体采取欺骗性或恶意的行动来提高其奖励
- 因此，设计者需要仔细设计奖励函数，以避免 Reward Hacking 的发生
举例：
- 在狼抓羊的游戏中，狼的 reward 设计为抓住羊+10，每秒-0.1，撞死-1，则狼可能会直接学习到撞死
在RLHF中，如果不限制 $\pi_\theta$ 不要偏离 $\pi_{ref}$ 太远， $\pi_\theta$ 很容易为了获得更大的 reward 而跑飞（比如输出特定人类读不懂的乱码），进而丢失 SFT 的优秀泛化能力（从这个角度讲，此时的Reward Hacking可以理解为模型的一种过拟合现象）
Reward Hacking发生的本质原因是：reward设置不合理（和任务意图不完全一致） ，但是现实世界中很多任务的意图都是抽象的，难以准确用简单规则描述
Reward Hacking很难解决，甚至无法解决，只有在非常苛刻的条件下才能解决

Parameter-Efficient Model Adaptation

Parameter-Efficient Model Adaptation是指通过优化参数（数量）实现模型高效适配（下游任务）
背景：LLM参数量很大，想要去做全量参数的fine turning代价很大，所以需要一些高效经济的方法
解决方法：PEFT（Parameter-Efficient Fine-Tuning）
一些PEFT方法
- Adapter Tuning
- Prefix Tuning
- Prompt Tuning
- Low-Rank Adapation(LoRA)

Memory-Efficient Model Adaptation

这部分内容参考自：万字长文入门 LLM

Parameter-Efficient Model Adaptation是指优化内存（或显存）实现模型高效适配（下游任务）
背景：由于LLM的参数量巨大，在推理的时候非常占用内存，导致其很难在应用中部署，所以需要一些减少内存占用的方法，比如LLM中的量化压缩技术
解决方法：比如LLM中的量化压缩技术
- quantization-aware training (QAT)，需要额外的全模型重训练
  - Efficient fine-tuning enhanced quantization (QLoRA)
  - Quantization-aware training (QAT) for LLMs
- post-training quantization (PTQ)，不需要重训练
  - Mixed-precision decomposition
  - Fine-grained quantization
  - Balancing the quantization difficulty
  - Layerwise quantization
其他博主经验：
- INT8 权重量化通常可以在 LLM 上产生非常好的结果，而较低精度权重量化的性能则取决于特定的方法
- 激活函数比权重更难量化，因为LLM 呈现出截然不同的激活模式（即较大的离群特征），因此量化 LLM（尤其是隐层激活）变得更加困难
- Efficient fine-tuning enhanced quantization（QLoRA）是提升量化LLM一个较好的方法
- 开源量化库：Bitsandbytes，GPTQ-for-LLaMA，AutoGPTQ，llama.cpp

SFT Packing

SFT Packing 是 SFT 过程中的一种技术，主要思路是将短 SFT 训练样本（对话）进行打包，在不同对话之间加入特殊分隔符（如EOS）
SFT Packing 会加快模型训练速度，减少模型 serving 的次数
SFT Packing 会增加模型对于同一个对话聊不同事情的泛化性吗？【存疑】
- SFT Packing 会导致模型看到一些其他样本的数据，引入了一些噪音，但实际上在真实的场景中用户也会突然切换对话场景，所以影响还好？
SFT Packing 会降低短 SFT 训练样本的权重吗？
- 原始的 SFT Loss：为了保证 SFT 对样本的关注度相同（短样本和长样本关注度一样），需要按照样本内部先按照 token 数做损失平均，再对样本间批次做损失平均
- SFT Packing Packing 后，短样本被 Packing 成一个新样本，相当于多个短样本的重要性和一个长样本的一致，对短样本不公平
- 修正方式：一方面需要在原始样本内部做 token 损失平均，另一方面，外部平均要除以真实的 Packing 前的样本数，而不是 Packing 后的样本数
  $$ loss = \frac{1}{B_\text{real}}\sum_i^{B_\text{real}} \frac{1}{T_i^\text{real}} \sum_j^{T_i^\text{real}} loss_j^\text{token} $$
实际上，这个技术在 Pretraining 中也很常用，用于加快训练过程；SFT 中，特别在将多轮会话拆开或样本长短差异很大的场景中用的多
以下内容参考自知乎：https://zhuanlan.zhihu.com/p/686562499

提问：SFT Packing 是什么？
回答：SFT Packing 指的是在训练 sft 的过程中，将多个 sft 数据 pack 到一个样本内进行训练的方式，这种方式会加快模型训练速度，原因是如果不进行 SFT Packing，那么对于短文本sft，需要padding到一个batch的最长长度，那么会浪费很多计算token。SFT Packing其实有很多种类，比如 Block diagonal attention，也就是每个token仅仅去attention自己的问题内的token。但一般业务中会直接将其相连接，然后进行预测，虽然这样会引入一些噪音，但好像相对于非 Sft Packing方式的整体的效果损失不大。这个可能是因为pretrain的时候模型也是这么训练的

Post-Training

Post-Training一般指Pre-Training之后的预训练?
模型训练的一般过程是：Pre-training -> Post-Training -> SFT -> RLHF

Encoder-Decoder

整体由Encoder+Decoder两个模块组成
Encoder部分的tokens互相可见（full visible）
Decoder的部分只有后面的能看见前面的
原始Transformer结构就是这样，最早是用来做文本翻译比较多

Causal LM（Causal Decoder）

因果语言模型，也称为Causal Decoder，Auto Regressive模式，根据历史来预估下一个token
代表模型是GPTs, LLaMAs
Causal LM 的 mask结构：

Prefix LM (Prefix Decoder)

前缀语言模型，也称为Prefix Decoder，前缀之间可以互相看到，但后续生成的token也只能看到历史
是Encoder-Decoder和Causal Decoder的一个折中方案
代表模型是GLM
Prefix LM 的 mask结构：

Causal LM vs Prefix LM

两者都是Decoder-Only结构
在面对多轮对话时，Prefix LM训练效率低于Causal LM
- 由于两者的Mask逻辑不同，比如在QA场景中，多轮对话时，Prefix LM需要将多轮对话整理成多个样本分别训练，因为每次回答开始时，前面的QA以及Q对于当前A来说都是prefix
- 比如回答Q3（生成A3）时，之前的<Q1A1,Q2A2,Q3>在attention时必须能互相看见，即此时prefix={<Q1A1,Q2A2,Q3>}
Prefix LM这种训练方式比较浪费资源，需要多次经过网络才能训练一次多轮对话；但是Causal LM则不需要多次训练，一次可训练多轮对话
Causal Decoder vs Prefix Decoder vs Encoder-Decoder, mask矩阵

MHA/MQA/GQA/MLA

三种方法的对比
Multi-Head Attention(MHA)：Q,K,V都拆开成多个头，每个头的Q,K,V都互不相同
Multi-Query Attention(MQA)：Q拆开成多个头，每个头的Q不同，但K,V完全相同
Grouped-Query Attention(GQA)：Q拆开成多个头，K,V按照组分组，每个头的Q不同，同一组头K,V相同，不同组头之间K,V不同
- GQA是MHA和MQA的中间版本，兼顾两头，LLaMA 2(70B)参数版本和LLaMA 3(8B/70B)就使用了这个
第四种方法：MLA（Multi-head Latent Attention）：Q拆开成多个头，核心思想是通过将K,V降维再升维的方式，巧妙的减少KV-Cache存储量（仅存储降维后的中间值即可），最早由DeepSeek提出
- 参考链接：
  - 来自苏神的参考链接：缓存与效果的极限拉扯：从MHA、MQA、GQA到MLA
  - 讲的较为清晰的原创博客：deepseek技术解读(1)-彻底理解MLA（Multi-Head Latent Attention） - 姜富春的文章 - 知乎

Model Card

Model Card, 直接译为模型卡片，在大模型中用来表示模型的详细描述，包括参数量，训练数据量，训练方式等等
比如Model Card是LLaMA2的的Model Card

Tokenization

分词，在原始文本输入模型前需要经过分词，模型输入和输出都是以token为单位，模型的成本也与token数量息息相关
常见的分词方式可以分成三类，word/subword/char三个粒度
最常见的是subword粒度，包含了BPE，WordPiece，Unigram等

Loss Spike

Loss Spike指的是大模型训练过程中出现的loss突然暴涨的情况，导致该问题的原因一般是脏数据

ORM 和 PRM

ORM：结果奖励（Outcome Reward Model）
- 定义：ORM根据任务的最终结果提供奖励，通常在任务完成后评估
- 延迟反馈：奖励在任务结束时才给出
- 结果导向：只关注最终结果，不关注中间过程
PRM：过程奖励（Process Reward Model）
- 定义：PRM在任务执行过程中提供即时奖励，评估每一步的表现
- 即时反馈：奖励在每一步或每个子任务完成后立即给出
- 过程导向：关注中间步骤，帮助模型优化过程

Context Length 和 Generation Length

大模型的上下文长度（Context Length）
- 上下文长度是模型能同时处理的输入文本的最大长度（包括用户输入的提示词、历史对话、文档内容等）
- 决定了模型能“看到”多少信息来生成回复
- 超出该长度的内容会被截断或忽略
大模型的生成长度（Generation Length）
- 模型单次回复时能生成的最大文本长度（即输出的token数量上限）
  - 生成长篇文章时可以多次请求（分段生成）
  - 指定这个长度可以避免模型因生成长度过大而失控（如无意义重复）
- 问题：为什么 Qwen2.5 开源时要强调自己的模型 Generation Length 是 8K tokens？是训练时就只针对 8K 输出做训练了吗？

Scaling Law

原始定义：大模型的Scaling Law是指模型性能（如损失函数值或任务表现）与计算量（FLOPs）、模型参数量（N）以及训练数据量（D）之间的幂律关系
其核心观点是，在不受其他因素限制的情况下，模型性能会随着计算量、参数量和训练数据的增加而提升，且这种提升遵循幂律规律（即非线性增长）

Scaling Law 的数学表达

OpenAI 在 2020 年的论文《Scaling Laws for Neural Language Models》中提出，语言模型的测试损失（Loss）可以表示为：
$$
L(N, D) = \left( \frac{N_c}{N} \right)^{\alpha_N} + \left( \frac{D_c}{D} \right)^{\alpha_D}
$$
- $ N $ 是模型参数量，$ D $ 是训练数据量（token 数）
- $ N_c $ 和 $ D_c $ 是临界值，表示当 $ N $ 或 $ D $ 低于该值时，性能受限于该因素
- $ \alpha_N $ 和 $ \alpha_D $ 是幂律指数，通常 $ \alpha_N \approx 0.076 $，$ \alpha_D \approx 0.095 $（具体数值可能因模型架构和任务不同而变化）

Training Time Scaling

增加训练时的时间（即增加计算量、参数量、训练数据量），可提升模型性能，是最原始的 Scaling Law 含义
吃显存

Inference Time Scaling

增加推理时的时间（即增大思维链长度，或MCTS等？），可提升模型性能（特别是推理性能）
吃推理时间

Parallel Scaling

在模型不增加参数的前提下（实际上会增加少量参数），同时拉大训练和推理并行计算量，提升模型效果
是 Qwen 和浙大 25年论文提出的，也叫做ParScale：对同一输入，同时复制乘 P 个“带前缀”的并行数据，让模型一次性算出 P 个 logits，再用一个MLP（少量参数）给每个 logits 打分加权，提高模型效果
参考链接：
- 原作者的知乎回答：如何看待Qwen推出的新Scaling Law ——Parallel Scaling？ - keytoyze的回答 - 知乎
- 原论文：Parallel Scaling Law for Language Models

AI Agent 和 Agentic AI

AI Agent
- 一般是单体系统，结构相对简单；
- 通常需要明确指令，自主性较低，是被动响应型，按预定义的命令执行特定任务；
- 擅长简单、重复的任务，任务范围有限，在有明确约束的环境中运行；
- AI Agent 常用于客服聊天、推荐系统、流程自动化等场景
Agentic AI
- 是多智能体系统，通过多个 AI Agent 协作，有记忆、分工和任务调度，类似“AI团队”；
- 自主性高，能自主决策、规划和行动，可视为决策者，主动为用户服务，像主动监控票价并自动重新预订；
- 可处理复杂任务，能在开放或不确定的环境中运行，可自行设定目标，根据环境变化动态调整行为；
- 适用于需要动态实时决策的金融、物流领域，以及 AI 科研助手、ICU 病房诊疗辅助等复杂场景
Agent 和 Agentic 词语区分：
- Agent 是名词（智能体），表示一个具体的对象
  - Agent 一般定义为一个实体：能自主感知、决策、行动、完成任务的智能体（AI Agent、软件代理、机器人等）
  - Agent 常用短语或名词：
    - AI Agent
    - LLM-based Agent
    - Multi-agent system
- Agentic 是形容词，表示描述具备 Agent 特征的
  - Agentic 一般定义为用来形容一个具备 Agent 特征的（即自主、主动、有目标、能规划、会反思、可迭代行动的）的对象或实体
  - Agentic 常用短语或名词
    - Agentic AI（具备智能体行为的人工智能）
    - Agentic workflow（智能体式工作流）
    - Agentic capability（智能体能力）

Step Batch Size

batch size（批量大小）：指在一次模型参数更新（即一个训练步骤）中所使用的样本数量
step batch size ：常用在是 LLM 的训练语境中，step batch size（步长批量大小）是强调 “每一步（step）” 训练中所处理的样本批量大小
step batch size 本质上与 batch size 含义一致，主要是强调了每一步更新参数使用的真实样本量

模型编辑（Model Editing）技术

参考链接：Overview of Model Editing - Alphabeta的文章 - 知乎
模型编辑（Model Editing） 是一种在不进行昂贵的全模型再训练的情况下，对预训练模型（尤其是大型语言模型LLMs）的知识或行为进行局部、有选择性修改的技术
通常，模型编辑通过直接修改模型内部的少量参数来实现
- 这些方法通常试图在最小化对模型其他知识和能力的负面影响的前提下，精确地定位和修改与特定事实相关的参数
Model Editing 方法大致可以分为以下几类：
- Fine-tuning with constraints （带限制的微调）
- Memory-Augmented (retrieval) （检索内存增强）
- Hyper network （超网络）
- Locate and edit （定位并修改）

LLM Surgery

LLM Surgery ，通常直译为 ”LLM 手术“，是比模型编辑（Model Editing） 更广泛的技术
相对 Model Editing，LLM Surgery 通常指更系统化和广泛地调整 LLM 的行为和功能，不仅仅是知识更新，可能涉及：
- “遗忘”不当或过时信息 ：类似于删除有害或过时的知识
- 整合新知识 ：与模型编辑类似，但可能更强调新旧知识的无缝集成
- 调制模型行为 ：例如，降低模型的“毒性”（toxicity），提高对“越狱”（jailbreaking）尝试的抵抗力，或者调整模型在特定场景下的回答风格
LLM Surgery 方法通常更为复杂，它可能涉及优化一个包含多个组件的目标函数：
- “遗忘”部分 ：通过反向梯度（reverse gradient）等技术，让模型“遗忘”特定的数据或行为
- “更新”部分 ：通过梯度下降等方式，引入新的或修正的信息
- “保留”部分 ：确保修改不会损害模型在其他不相关任务上的核心能力和性能
它可能不仅仅是修改参数，还可能涉及对模型隐藏层、激活函数等更深层次的调整，以引导模型行为的整体转变
Model Editing vs LLM Surgery ：
- Model Editing 更像是一种“点对点”的修正，主要针对模型内部的特定知识点进行修改
- LLM Surgery 则更像是一种“外科手术”，对模型进行更深层次、更系统化的调整，以改变其整体行为特征或删除特定的有害信息，同时努力保持其核心能力

GSB 标注

GSB 标注解释：Good，Same，Bad 标注
在自然语言处理（NLP）领域，GSB 是一种实验数据标签标定方法，用于对比实验组与对照组的表现
该方法常用于评估文本相关性，例如查询与文档标题/正文的匹配度

线性注意力机制（Linear Attention）

线性注意力机制是一类通过降低计算复杂度来优化传统注意力机制的方法，目标是优化长序列任务
传统 Transformer 的 Softmax 注意力计算复杂度为 $O(N^2)$ （$N$ 是序列长度），而线性注意力机制通过数学重构等方式将复杂度降至 $O(N)$ 或 $O(N \log N)$ ，从而显著减少计算和内存开销
代表方法：Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention, ICML 2020，是线性注意力领域的开创性工作，简称 Linear Transformer
- 该工作通过将 Softmax 指数函数重写为特征映射 $\varphi(x)$ 的点积形式的核函数，并利用矩阵乘法的结合律，成功将注意力计算重构为线性形式，消除了计算完整 $N\times N$ 注意力矩阵的需求，将复杂度降低至 $O(Nd^2)$ （ $d$ 表示 Embedding 维度）
- 在大型语言模型中，通常序列长度 $N$ 远大于嵌入维度 $d$ ，因此这种方法实际上实现了线性时间复杂度

Polyak averaging（参数平均）

Polyak averaging（也称为Polyak-Ruppert averaging）是一种优化技术，由俄罗斯数学家 Boris T. Polyak 在 1991 年提出，用于提高随机梯度下降（SGD）等优化算法的稳定性和泛化能力
其核心思想是：在模型训练过程中，对多个迭代步骤的模型参数进行平均 ，而不是仅使用最终迭代的参数
平均方式：可使用参数的简单平均或者加权平均的方式
优势是：减少方差；提高泛化；
在训练 Transformer 模型时，使用 Polyak averaging 可以提高模型在下游任务中的表现，LLM 中特别场景
注：部分研究表明使用，在策略梯度算法（如 PPO）中，Polyak averaging 可以增强策略的稳定性

Instruction Following Difficulty（IFD）

原始论文：From Quantity to Quality: Boosting LLM Performance with Self-Guided Data Selection for Instruction Tuning, 20240406
在 LLM 中，指令跟随难度（Instruction Following Difficulty，IFD），是一种用于衡量模型遵循指令生成相应输出难度的指标，常用于 SFT 中做数据筛选
计算方式 ：IFD 通过计算条件回答分数（Conditioned Answer Score，CAS）与直接答案分数（Direct Answer Score，DAS）的比值得到，公式为
$$ \mathrm{IFD}_\theta(Q,A)=\frac{s_\theta(A|Q)}{s_\theta(A)}$$
- $s_\theta(A|Q)$ 表示模型在给定指令 $Q$ 的情况下生成答案 $A$ 的分数
  $$ s_{\theta}(A | Q) = -\frac{1}{N} \sum_{i = 1}^{N} \log P\left(w_{i}^{A} | Q, w_{1}^{A}, w_{2}^{A}, \cdots, w_{i - 1}^{A} ; \theta\right)$$
- $s_\theta(A)$ 表示模型直接生成答案 $A$ 的分数
  $$ s_{\theta}(A) = -\frac{1}{N} \sum_{i = 1}^{N} \log P\left(w_{i}^{A} | w_{1}^{A}, \cdots, w_{i - 1}^{A} ; \theta\right) $$
指标意义 ：IFD 值可以反映指令对模型生成答案的影响程度
- IFD 值超过 1 的数据通常被视为异常数据
  - 理解：由于分子分母都是正数，此时说明分子大于分母，即条件概率小于直接生成概率： $P(A|Q,W) < P(A|W) $，这说明，加入 Q 对 A 的生成非但没有帮助，反而是负向影响
- IFD 高但不超过 1，意味着提示对模型生成答案有帮助，但帮助不显著，这类样本属于“difficulty”样本；
  - 理解：此时条件概率大于直接生成概率 $P(A|Q,W) > P(A|W) $，但是大的不多，即 Q 对 A 的生成影响不大，此时 模型难以将答案与给定的指令内容对齐 ，这种样本对模型来说挑战较大
- 低 IFD 值表明提示极大地简化了答案的生成，属于“easy”样本
  - 理解：此时条件概率大于直接生成概率 $P(A|Q,W) > P(A|W) $，且大很多，即 Q 对 A 的生成影响非常大，这种样本很容易学习（甚至不需要学习？）
- 较高的 IFD 分数表明模型难以将答案与给定的指令内容对齐 ，说明指令难度更高 ，对模型调优更有利
应用场景 ：该指标可用于筛选具有增强 LLM 指令调优潜力的数据样例
- 通过对原数据集按照 IFD 指标进行排序，选择分数靠前的数据作为“樱桃数据”，模型仅使用原始数据 5%-10% 的樱桃数据就可以达到全量数据微调的效果，甚至可以有所提高

Instruction Mining

Instruction Mining（指令挖掘）是一种用于选择高质量指令数据的方法，旨在挑选出最有利于大模型训练的指令数据子集，从而提升大模型指令微调之后的性能
具体原理 ：利用自然语言指标作为数据质量的衡量标准，通过这些指标预测推理损失，进而评估指令数据的质量
- 例如，将输入长度、输出长度、奖励模型的输出分数、困惑度等指标进行线性组合，并使用线性回归的方式得到系数，以此量化数据质量，无需微调模型即可相对评估指令数据，从而节省时间与计算开销
通过 Instruction Mining，可以从各种指令遵循数据集中选择相对高质量的样本，帮助大模型更好地学习指令模式，提高对指令的理解和响应能力，最终提升模型在相关任务上的性能
实验表明，使用 Instruction Mining 选择的数据集相比未经筛选的数据集，在一定比例的情况下表现更优
注：在一些场景中，Instruction Mining 也常常有更广泛的定义，比如从无指令数据中自动或半自动地挖掘出指令数据

Self-instruct

Self-instruct 是一种 instruction Mining 方法，是斯坦福大学等研究者在 2022 年提出方法
Self-instruct 核心思路：利用语言模型自身生成能力，在仅少量高质量的指令数据的情况下，自我构造任务指令和示例数据，以训练出指令理解与执行能力更强的模型
Self-instruct 具体流程包括：
- 准备少量种子指令 ：人工准备少量（如 100 条）高质量任务指令
- LLM 生成更多指令 ：基于这些种子任务，让预训练模型生成新的指令
  - 如 “把句子改写成消极语气”“列出 Python 中的三种排序算法” 等，这些新指令由模型自动生成，无需人工逐一设计
- 生成指令响应 ：使用同一个模型根据新生成的指令，生成对应的回答或执行结果
  - 例如指令为 “将句子翻译成西班牙语：‘I like learning.’”，响应则为 “Me gusta aprender.”
- 筛选与清洗 ：为保证数据质量，需进行数据筛选与清洗工作
  - 可移除重复、无意义的指令，利用规则或小模型过滤低质量响应，也可进行少量人工审核
- 模型微调 ：将最终得到的 “指令-响应” 数据集用于对预训练模型进行微调，使模型更擅长理解和执行各种指令

Unembedding Layer & Output Projection Layer & LM Head 概念辨析

在 Transformer-based 模型中，Unembedding Layer、Output Projection Layer 和 LM Head 这三个术语常被混用，但它们的具体含义根据上下文不同又有一些细小的区分，本节尝试对这三个概念进行辨析

Output Projection Layer（输出投影层）

Output Projection Layer 用于模型最后一层输出的隐藏状态（hidden states）投影到目标空间
- 输入为隐藏状态，维度为 [batch, seq_len, d_model]
- 输出为词表大小维度 [batch, seq_len, vocab_size]
Output Projection Layer 通常是一个线性层（nn.Linear(d_model, vocab_size)）
- 平时实现时，无偏置项（bias）的情况较常见（nn.Linear(d_model, vocab_size, bias=False)）
用于将高维特征映射到与词表对应的 logits（未归一化的分数），为后续生成概率分布做准备
特别说明 ：
- Output Projection Layer 是一个纯数学操作，不涉及任何非线性激活函数
- 与 Embedding 层（输入端的词向量矩阵）可能是参数共享的（如T5、GPT-2），也可能独立（如 BERT 的 MLM Head）

Unembedding Layer（反嵌入层）

与输入端的 Embedding 操作对应，可视为“逆向嵌入”
多数情况下，Unembedding Layer = Output Projection Layer ，即同一个线性投影层
- 特别说明 ：在部分模型中，Unembedding 可能包含归一化层或残差连接（罕见），但通常仍指线性投影
若与输入 Embedding 共享参数（Weight Tying 或 Tie Embedding），则直接使用 Embedding 矩阵的转置（W_embed.T）进行投影

LM Head（语言模型头）

LM Head 的范围更为广泛，泛指整个语言模型的任务特定输出层 ，可能包含：
- Output Projection Layer（必需）
- 可选的额外处理层（如 LayerNorm、偏置项、适配器模块等）
特别说明 ：
- 在 GPT 等自回归模型中，LM Head 通常仅指线性投影层（即 Output Projection Layer）
- 在 BERT 的 MLM 任务中，LM Head 可能包含如下的额外的全连接层、激活函数、归一化层等部分：
  1
  2
  3
  4
  5
  6
  LM_Head = Sequential(
  Linear(d_model, d_model), # 额外的全连接层
  GELU(),
  LayerNorm(d_model),
  Linear(d_model, vocab_size) # Output Projection
  )

PyTorch 实现实例

PyTorch 实现示例如下：

# Output Projection Layer / Unembedding Layer
output_projection = nn.Linear(d_model, vocab_size, bias=False)  

# 若与 Embedding 共享参数，即 Weight Tying 或 Tie Embedding
token_embedding = nn.Embedding(vocab_size, d_model)
output_projection.weight = token_embedding.weight  # 权重绑定

# LM Head可能是复杂结构（如BERT）
LM_Head = Sequential(
	Linear(d_model, d_model), # 额外的全连接层
	GELU(),                   
	LayerNorm(d_model),        
	Linear(d_model, vocab_size)  # Output Projection
)

其他说明

HuggingFace 代码库中常用 lm_head 指代最终的线性投影层，与学术文献可能不同
在非 LM 任务（如分类）中，输出层可能称为 Task Head

Tie Embedding / Weight Tying

Tie Embedding，也称为 Weight Tying 机制下，嵌入层（Embedding Layer）和输出投影层（文献中可能称为 Unembedding Layer / Output Projection Layer / LM Head）是绑定/共享的
- 优势：节约存储、训练稳定；
- 缺点：表达能力受限、梯度冲突可能严重（比如输入和输入的词分布差异大），所以后来的一些模型会选择不绑定
注：传统 Transformer 中（Attention Is All You Need 的 3.4 结中提到）就已经有了 Tie Embedding 机制
注：GPT-2/T5 等通过共享 Embedding 和 Output Projection Layer 参数减少参数量，但 BERT 通常不共享

System-2（系统2）

大模型中的系统2源于心理学中丹尼尔·卡尼曼提出的双系统理论
- 该理论认为人类思维由系统1和系统2两个不同系统驱动
在大模型领域，系统2是一种较慢的、深思熟虑的、善于分析的思维模式，对应着模型进行复杂推理和深度思考的能力
系统2思维需要有意识地努力，涉及逻辑分析、推理和意识层面的思考，更能够进行深度思考，但也更耗费时间和精力
系统2常用于提升推理和解决问题能力、改善对上下文和细微差别的理解、减少偏见和错误、更好地制定决策
与系统2相关的技术有：思维链（COT）、思维树、思维图、分支解决合并（BSM）、系统2注意力（S2A）、重述和回应（RaR）等
- 这些技术通过显式推理通常能产生更准确的结果，但往往会带来更高的推理成本和响应延迟
目前，像 OpenA 的 o1/o3 和 DeepSeek-R1 等推理大语言模型，都在尝试模拟系统2的审慎推理（deliberate reasoning），以提升模型在复杂推理任务中的表现

投机采样

投机采样（Speculative Decoding） ，也常常被翻译为 推测解码
投机采样是一种加速 LLM 推理的技术
投机采样的核心思想是通过预生成候选 token 序列并异步校验，从而减少主模型的计算量，同时保持生成结果的准确性
投机采样通过“预测-校正”范式，在保证生成质量的前提下显著降低主模型的计算负载，是当前LLM推理加速领域的重要突破
投机采样的流程主要包括小模型生成候选序列、大模型并行验证、结果评估与处理以及循环迭代等步骤
详细采样流程：待补充

AGI

关键词：AGI定义，AGI的定义，AGI 定义，AIG 的定义
AGI（Artificial General Intelligence，通用人工智能）
目前为止没有明确的定义，不同公司对 AGI 的描述和愿景不同
OpenAI ：强调在经济效益上超过人类

from OpenAI Charter
OpenAI’s mission is to ensure that artificial general intelligence (AGI)—by which we mean highly autonomous systems that outperform humans at most economically valuable work—benefits all of humanity
- 据 Bloomberg(彭博社) 报道 OpenAI 对AGI有以下五级分类：
  - Level 1: Chatbots, AI with conversational language
  - Level 2: Reasoners, human-level problem solving
  - Level 3: Agents, systems that can take actions
  - Level 4: Innovators, AI that can aid in invention
  - Level 5: Organizations, AI that can do the work of an organization
Google ：强调像人一样的认知能力

from Google Cloud: what-is-artificial-general-intelligence
Artificial general intelligence (AGI) refers to the hypothetical intelligence of a machine that possesses the ability to understand or learn any intellectual task that a human being can. It is a type of artificial intelligence (AI) that aims to mimic the cognitive abilities of the human brain
个人认为：AGI 指的是能够像人类一样理解、学习和执行广泛任务的人工智能系统，其核心包含几个方面：
- 跨领域：AGI 不应该是专注于特定任务的 AI，应当具备跨领域能力
- 自主学习：AGI 应该有自主学习的能力，甚至可通过探索快速适应从未见过的新环境
- 跨模态：AGI 应该能与真实物理环境交互，所以应该是跨模态的，除了文本以外，还应该包括视觉和语音

Vibe Coding

Vibe coding 是一种全新的 AI 辅助编程方法 ，也可称为 “氛围编程” 或 “感觉式编程”，由 OpenAI 联合创始人 Andrej Karpathy 于 202502 提出
Vibe coding LLM-based 沉浸式开发，开发者无需手动编写每一行代码 ，只需通过自然语言（如英语）与 AI 交互，描述自己的需求，让 AI 自动生成代码，即可完成从需求分析到代码实现的全过程

Slide Attention

Slide Attention 通常也称为滑动窗口注意力（Sliding Window Attention） ，有时也称为 Sliding Attention ，一种提升注意力计算效率的稀疏注意力（Sparse Attention）方法，常用于处理长序列数据
Slide Attention 对比标准 Transformer 的 Attention ：
- 标准 Transformer 中自注意力（也可以称为 Full Attention）计算复杂度为 $O(n^2)$，随着序列长度增加，计算和内存开销急剧增长
- Slide Attention 的核心思想是让每个 token 仅关注窗口 $w$ 范围内的 tokens，而非整个序列，将计算复杂度降低为 $O(n\cdot w)$
Slide Attention 大幅减少了计算量和显存占用，适用于长文本任务，OpenAI 发布的 oss-120b 和 oss-20b 中就使用到了 Full Attention GQA 和 Slide Attention GQA 交叉的架构

Attention Sink

Attention Sink 现象（即“注意力黑洞”现象），是指在 LLM 的注意力机制中，某个特定 Token（通常是序列中的第一个 Token，即 <BOS> Token）会收到不成比例的高注意力权重，就像黑洞一样把其他 Token 的注意力都吸过去了
Attention Sink 可能导致模型忽视其他 Token 中的重要上下文信息，降低模型效率
出现该现象的原因可能有多种：
- Softmax 操作要求所有上下文 Token 的注意力分数总和为 1，因此即使当前 Token 跟前面的其他 Token 都没有语义相关性，模型也需将多余注意力值分配到前面某些 Token，而初始 Token 因对所有后续 Token 都可见，更容易成为分配对象
- 其他原因也可能是因为该 Token 出现频率高、位置特殊、语义较强，或者训练数据存在偏差等
使用稀疏注意力技术可以缓解这个问题，比如 (Gated-Attention)Gated Attention for Large Language Models: Non-linearity, Sparsity, and Attention-Sink-Free, 2025, Qwen

Reformer（Efficient Transformer）

参考链接：Reformer: The Efficient Transformer, 2020, Google & UC Berkeley
Reformer 是由 Google Research 在 2020 年提出的一种改进的 Transformer 模型，旨在解决传统 Transformer 在处理长序列时面临的高计算和内存消耗问题
通过引入局部敏感哈希（LSH）注意力和可逆残差网络两种关键技术，显著提升了模型效率，使其能够处理更长的序列
Reformer 关键技术简单介绍
- 局部敏感哈希（LSH）注意力 ：
  - 将注意力计算简化为近似最近邻搜索 ，利用哈希桶将相似键分组，仅计算桶内注意力
  - 复杂度从 (O(n^2)) 降至 (O(n \log n))
- 可逆残差层 ：
  - 反向传播时无需保存每一层的激活值，通过数学方法重建中间结果，显存占用大幅降低
- 分块计算 ：
  - 将长序列分块处理，进一步优化内存效率

transformers库中已经有支持 from transformers import ReformerModel, ReformerTokenizer

from transformers import ReformerModel, ReformerTokenizer

tokenizer = ReformerTokenizer.from_pretrained("google/reformer-crime-and-punishment")
model = ReformerModel.from_pretrained("google/reformer-crime-and-punishment")

inputs = tokenizer("Hello, world!", return_tensors="pt")
outputs = model(**inputs)

Longformer（Long-Document Transformer）

参考链接：Longformer: The Long-Document Transformer, 202012, Allen AI
Longformer（Long Document Transformer）是一种基于 Transformer 架构的改进模型，专门针对处理长文本而设计
Longformer 由 Allen Institute for AI 和 UC Irvine 的研究团队于 2020 年提出，旨在解决传统 Transformer 模型（如 BERT、GPT）因自注意力机制（Self-Attention）的平方级计算复杂度而难以处理长序列的问题
Longformer 的核心改进是引入了稀疏注意力模式（Sparse Attention），将全局注意力（Global Attention）与局部滑动窗口注意力（Sliding Window Attention）结合，显著降低了计算复杂度（从 (O(n^2)) 降至 (O(n))）
Longformer 的关键技术介绍
- 滑动窗口注意力（Sliding Window）
  - 每个 token 只关注其附近固定窗口大小（如 512 tokens）的局部上下文，类似卷积操作
  - 通过堆叠多层注意力层，模型可以捕获远距离依赖（高层感受野逐渐扩大）
- 任务相关的全局注意力（Global Attention）
  - 对特定任务（如 QA 中的问题相关位置）或特殊 token（如 [CLS]）启用全局注意力，使其关注整个序列
  - 平衡局部效率与全局信息需求
- 空洞注意力（Dilated Attention）（可选）
  - 通过间隔采样（空洞）减少计算量，同时保持对长序列的建模能力
  - 类似空洞卷积（Dilated Convolution），两者分别用于 NLP 和 CV 中，都可以扩大感受野

transformers库中已经有支持 from transformers import LongformerModel, LongformerTokenizer

from transformers import LongformerModel, LongformerTokenizer

model = LongformerModel.from_pretrained("allenai/longformer-base-4096")
tokenizer = LongformerTokenizer.from_pretrained("allenai/longformer-base-4096")

text = "This is a long document..."  # 可以是长文本
inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=4096)

# 启用全局注意力（例如对 [CLS] 标记）
inputs.global_attention_mask = torch.zeros_like(inputs.input_ids)
inputs.global_attention_mask[:, 0] = 1  # 第一个位置是 [CLS]

outputs = model(**inputs)

BigBird

参考链接：Big Bird: Transformers for Longer Sequences, NeurIPS 2020, GOogle
BigBird 是一种基于 Transformer 架构的改进模型，专门针对处理长序列输入的局限性进行优化。由 Google Research 在 2020 年提出，它通过引入稀疏注意力机制，显著降低了传统 Transformer 在长序列场景下的计算复杂度（从二次方降至线性），同时保持了较强的建模能力
BigBird 和核心创新在稀疏注意力机制上，BigBird 通过三种注意力组合降低计算量：
- 全局注意力（Global Attention）
  - 部分关键 token（如 [CLS]、句首/尾）参与所有位置的注意力计算，保留全局信息
- 局部注意力（Local Attention）
  - 每个 token 仅关注相邻的固定窗口内的 token（类似卷积操作），捕捉局部上下文
- 随机注意力（Random Attention）
  - 每个 token 随机选择少量其他位置进行注意力计算，增强全局交互

transformers库中已经有支持 from transformers import BigBirdModel

1 2	from transformers import BigBirdModel model = BigBirdModel.from_pretrained("google/bigbird-roberta-base")

Embodied Intelligence

具身智能（Embodied Artificial Intelligence 或 Embodied Intelligence），是指一种基于物理身体进行感知和行动的智能系统
具身智能通过智能体与环境的交互获取信息、理解问题、做出决策并实现行动，从而产生智能行为和适应性
具身智能强调智能并非孤立于大脑或算法，而是身体形态、运动能力与环境动态耦合的涌现性结果，智能体的身体、感知系统和环境之间的相互作用是其智能行为的基础

WSD 学习率调度

WSD（Warmup-Stable-Decay）学习率调度，是一种用于调整训练不同阶段学习率的方法，由 MiniCPM 提出
WSD 学习率调度分为三个阶段：
- 预热阶段 ：将学习率从 0 线性增加到峰值
- 稳定阶段 ：把学习率保持在峰值，模型在这个阶段进行大部分的训练
- 衰减阶段 ：在相对较短的时间内将学习率退火至 0
一般来说，在衰减阶段还可以更改数据混合比例，以增加高质量数据的比例
实验证明，WSD 会生成非传统的损失曲线，损失在稳定阶段保持高水平，但在衰减阶段急剧下降
与常用的 Cosine 衰减学习率调度（余弦衰减学习率调度）相比：
- WSD 在小尺寸模型上的收敛效果很好，且对续训更加友好
- Cosine 衰减学习率调度需要提前指定训练步数；WSD 不需要提前指定训练步数
  - 虽然平时在 WSD 中，也常将预热阶段设置为总步数的一定百分比，但也可以设定为固定值
- Cosine 衰减学习率调度更稳定

Overlong Mask 技术

“Overlong Mask”（超长掩码）或更通俗地称为 “Overlong Filtering”（超长过滤），是一项应用于 LLM 的 RL 训练中的技术
Overlong Mask 主要用于处理在训练过程中生成超过预设长度限制的文本序列，通过 “屏蔽”这些超长序列的损失计算 ，确保模型训练的稳定性和有效性
Overlong Mask 的核心思想 ：避免对“未完成”的优质答案进行惩罚
问题背景描述：
- 在强化学习训练（如 PPO 算法）中，通常会设定一个最大生成长度（max_length）以控制计算资源和训练效率
- 当模型生成一个内容合理、但长度超过 max_length 的序列时，这个序列会被强行截断
- 被截断的序列可能会因为“不完整”或未能达到最终目标而获得一个较低的、甚至是负面的奖励
  - 这种“惩罚”是不公平的，因为它惩罚了模型生成长篇、详细、有逻辑的答案的潜力，仅仅因为其超出了人为设定的长度限制
  - 这会向模型传递错误的学习信号，阻碍其学习长序列推理和生成的能力
“Overlong Mask” 技术的核心机制是：识别出那些因为超出最大长度而被截断的序列，并在计算损失函数和更新模型参数时，将这些序列“屏蔽”掉（即，不计算它们的损失）
- 防止模型因为生成了“有思想但过长”的答案而受到不公正的惩罚
在 RL 训练中的工作步骤：
- 1）序列生成与长度检查 ：在强化学习的采样阶段，模型根据给定的提示（prompt）生成一批文本序列
- 2）识别超长序列 ：检查每个生成的序列长度是否达到了预设的 max_length
- 3）应用掩码 ：对于那些被截断的序列，在后续的损失计算中，通过一个掩码（mask）将其对应的损失值置为零或在计算总损失时将其忽略
- 4）参数更新 ：模型最终仅根据那些在长度限制内完整生成的、未被屏蔽的序列的奖励和损失来进行参数更新
其他改进方法：Overlong Reward Shaping
- 除了简单的过滤（完全忽略），一种更精细的策略被称为“Overlong Reward Shaping”（超长奖励调整）
  - 不直接丢弃超长序列，而是对奖励进行平滑处理
- 比如 DAPO 论文中提出的方法，会设置一个惩罚过渡区间，使得奖励的惩罚随着超出长度的增加而线性增加，而不是一个突兀的悬崖式惩罚
  - 为模型提供了一个更平滑的梯度信号
- 再比如 Kimi K1.5 训练时也有类似的特殊奖励设计
Overlong Mask 优点 ：
- 训练稳定性 ：避免了因不公平惩罚带来的梯度剧烈波动，使得训练过程更加稳定
- 鼓励长程推理 ：允许模型自由探索生成更长、更复杂、更有深度的内容，而不用“害怕”因超出长度限制而受到惩罚
  - 这对于提升模型的长程推理能力至关重要
- 提升模型性能 ：在需要生成详细解释、长篇代码或复杂推理链的任务上，使用“Overlong Mask”的训练方式能够显著提升模型的表现

Pipeline Parallelism 技术

当一张卡装不下模型参数时，常常需要对模型进行拆分，这里面有两种拆解模式：
- 流水线并行（Pipeline Parallelism）：将模型按层进行切分
  - 部分博客也翻译为管线并行
- 张量并行（Tensor Parallelism）：将模型张量参数拆成小的块
  - 在一些更大的模型上，显卡甚至装不下单层参数，这时候张量并行就很必要了
流水线并行有两篇主要文章：
- PipeDream：PipeDream: Fast and Efficient Pipeline Parallel DNN Training, 2018, Microsoft
- GPipe：GPipe: Easy Scaling with Micro-Batch Pipeline Parallelism, 2019, Google
比较 PipeDream 和 GPipe
- GPipe 速度效率比 PipeDream 慢，但显存占用更低，收敛也更稳定
注：PipeDream 也称为 PipeDream 1F1B，或直接称为 1F1B

中间填充（Fill-In-the-Middle，FIM）

不同于传统的自回归损失，中间填充（Fill-In-the-Middle，FIM）的学习目标是文本的中间
中间填充的流程通常包括：
- 通过将文本划分为前缀（prefix）、后缀（suffix）和中间部分（middle），并使用特殊标记（如 <\PRE>、<\SUF>、<\MID>）来标识
- 模型根据前缀和后缀的上下文信息，通过双向上下文建模和动态插入生成的方式，来预测并填充中间部分的内容
GLM4.5 在预训练代码数据时使用到了

Best-fit Packing

Best-fit Packing 策略是一种由 AWS AI Labs 的研究人员提出的文档处理策略，旨在解决传统预训练方法中文档截断问题
在传统的语言模型预训练中，输入文档通常会被简单地拼接起来，然后分割成等长的序列，以避免填充 token
- 提高了训练效率，但会导致文档的不必要截断，损害数据完整性，影响模型学习到的内容的逻辑连贯性和事实一致性，增加模型产生幻觉的风险
Best-fit Packing 使用长度感知的组合优化技术，将文档打包到训练序列中
- 第一步：将每个文本分割成一或多个至多长为模型上下文长度 $L$ 的序列
- 第二步：基于这些文件块，采用最佳适配降序算法（Best-Fit-Decreasing，BFD）的启发式策略，将它们合理地组合，以获得尽量少的训练序列 ，从而完全消除不必要的截断
  - BFD 是用于解决装箱问题 (Bin Packing Problem) 的一种经典启发式算法，核心目标是：在将一组物品放入容量固定的箱子中时，尽可能减少所需箱子的总数量
  - BFD 算法结合了两个策略：
    - Decreasing (降序) ：优先处理较大的物品。因为大物品最难装入，先安排它们可以减少后续碎片化空间无法利用的情况
    - Best-Fit (最佳适应) ：在放入物品时，不仅仅是找到“能装下”的箱子，而是找到“装入后剩余空间最小”的箱子。这能最大限度地填满箱子
  - BFD 算法详细流程（口诀是：先大后小，填满缝隙 ，通过先处理大块头，并总是寻找最“紧凑”的位置安放，从而最大化空间利用率）
    - 假设有一组物品 $S = {s_1, s_2, …, s_n}$，每个物品的大小为 $size(s_i)$，箱子的固定容量为 $C$
    - Step 1：预处理（排序）：将所有待装箱的物品按照体积/大小从大到小进行排序
      - 排序后序列：$s’_1 \ge s’_2 \ge … \ge s’_n$
    - Step 2：遍历与放置：按排序后的顺序，依次处理每一个物品 $s’_i$：
      - 1）扫描现有箱子 ：检查当前已经打开的所有箱子
      - 2）寻找可行箱子 ：找出所有剩余容量大于或等于当前物品大小 $size(s’_i)$ 的箱子
      - 3）选择最佳箱子 (Best Fit) ：
        
        在上述“可行箱子”中，选择放入该物品后剩余空间最小的那个箱子
        
        如果有多个箱子的剩余空间相同且均为最小，通常选择索引较小（较早打开）的那个
      - 4）放入或新开 ：
        
        如果找到了最佳箱子，将物品放入，并更新该箱子的剩余容量
        
        如果没有一个现有箱子能装下该物品，则开启一个新的箱子，将物品放入，并记录新箱子的剩余容量
    - Step 3：重复：重复上述步骤，直到所有物品都被装入箱子
Best-fit Packing 的优点：
- Best-fit Packing 能够提升模型在各种文本和代码任务中的表现
- Best-fit Packing 能减少模型幻觉
- Best-fit Packing 策略能有效支持尾部知识学习
但也有相反的声音：
- 比如智谱在 GLM4.5 技术报告中没有使用 best-fit packing ，因为他们认为随机截断（random truncation）对于预训练文档来说是一种很好的数据增强策略

批次大小预热策略（batch size warmup strategy）

批次大小预热策略（batch size warmup strategy）是一种在深度学习模型训练过程中使用的策略，其核心思想是在训练初期逐步增加批次大小（batch size），而不是一开始就使用较大的批次大小
批次大小的选择会影响训练的稳定性和效率
- 较大的批次大小可以加快训练速度 ，但在训练初期，由于模型参数尚未收敛 ，使用过大的批次大小可能导致梯度更新过于剧烈 ，从而引发训练不稳定等问题
- 批次大小预热策略就是为了解决这个问题而提出的
在 GLM-4.5 的训练流程中，就采用了批次大小预热策略，在训练的前 500B tokens 期间，逐步将批次大小从 16M 增加到 64M tokens
- 这种策略可以让模型在训练初期以较小的批次大小进行训练，使模型参数能够更稳定地更新，随着训练的进行，再逐渐增加批次大小，以提高训练效率
批次大小预热策略通常可以与学习率预热（Learning Rate Warmup）策略结合使用
- 学习率预热是在训练初期使用较小的学习率，然后逐渐增大学习率至预设的值，两者结合可以在加快训练速度的同时，保持良好的模型性能和泛化能力
理解：
- 相对初期降低学习率的方式，这种方式可以减少算力浪费？
- 但理论上，使用较小的学习率可能更合适一些，可以让模型始终稳定的走，一个基本的理解是：梯度大小 = 批次大小乘以学习率大小，所以使用大的批次和小的学习率可能更稳定

偏置更新率（bias update rate）

偏置更新率（bias update rate）是一个超参数，是无损失平衡路由中的用于动态调整路由得分偏置的
- 无损失平衡路由是不需要增加损失函数的启发式规则
DeepSeek-V3 提出了一种创新的无额外损耗负载均衡策略 ，通过引入并动态调整可学习的偏置项来影响路由决策
- 在训练过程中，会持续监控每个训练步骤中整个批次的专家负载情况
- 如果某个专家负载过重，就将其对应的偏置项减少一个偏置更新率 $\gamma$；如果某个专家负载过轻，就将其对应的偏置项增加一个偏置更新率 $\gamma$
- 通过这种动态调整，使得模型在训练过程中能够更好地平衡各专家的负载，避免了因负载不均衡导致的性能下降，同时也不会对模型性能产生额外的损耗
GLM4.5 中也是用了类似的策略

FlashInfer

FlashInfer 是一个专为大型语言模型服务设计的高性能 GPU 内核库，由华盛顿大学、NVIDIA、Perplexity AI 和卡内基梅隆大学的研究人员共同开发
FlashInfer具有以下核心功能与特点：
- 提供高效的注意力计算内核，支持多种注意力机制的实现，能在GPU上高效执行，显著提升LLM的推理速度
- 通过优化解码过程中的共享前缀批处理，减少计算和内存开销，提高解码效率
- 通过压缩和量化KV缓存，减少内存占用和计算量，加速注意力计算
- 优化 Grouped-Query Attention 的计算，减少计算复杂度，提高计算效率
- 实现 Fused-RoPE Attention，减少计算步骤和内存访问延迟，提高计算速度
- 提供 PyTorch API、TVM 绑定、C++ API 等多种接口，方便用户根据需求进行定制和扩展
- 兼容性强 ：支持多种 GPU 架构和硬件配置，还支持 WebGPU、iPhone 等本地环境，实现“一次编译，多端运行”，同时原生支持 Hugging Face 模型格式，兼容主流量化技术
FlashInfer 已被 MLC-LLM、Punica 和 sglang 等 LLM 服务系统采用
在实际应用中，FlashInfer 能显著提升 LLM 服务的性能
- 例如在处理大规模文本生成任务时，可比传统 CUDA 内核快 2-3 倍，同时保持较低的延迟

Curation

在大模型中，“Curation”通常指数据策划或数据精选
数据策划是对从各种来源收集的数据进行组织和整合的过程
- 涉及数据的标注、发布和呈现，以确保数据的价值随着时间的推移得以保持，并且数据仍然可以用于重复使用和保存
- 数据策划不仅仅是删除错误数据和重复项，还包括对不同语料数据的重新组织整合，比如选择用于训练的语言、对数据进行标注等
数据精选则强调优先使用高质量、与任务强相关的数据，而非盲目追求数据量
- 例如，通过人工标注、模型预筛选等方法过滤噪声数据，保留“信息密度高”的样本，以提升模型在专业领域的能力
此外，还有自我策划（Self-Curation） ，即利用大模型本身筛选高质量的数据构建新的数据集

Red Team

在大模型开发过程中，Red Team 指红队，是一群专门对大模型进行测试和攻击的专家团队
- Red Team 的目的是发现模型潜在的漏洞、偏见和不良行为，确保模型的安全性、可靠性和性能
红队测试起源于冷战时期的军事模拟演习，当时美国军方通过模拟“蓝队”（己方）与“红队”（敌方）的对抗，来学习如何像敌人一样思考
- 后来，这一做法被 IT 行业采用，用于探测计算机网络、系统和软件的弱点
在大模型开发中，红队会采用各种策略和技术来挑战模型
- 例如，他们可能会使用特殊的提示词来诱导模型生成有害内容，如仇恨言论、虚假信息等，或者尝试突破模型的安全限制，查看是否能够获取敏感数据
- 红队测试可以在多个层面进行，包括基底大语言模型层和应用程序层

单播、组播和广播

在分布式系统中，单播、组播和广播是三种不同的数据传输方式，它们的区别如下：
单播（Unicast），即一对一的通信模式，发送方将数据包发送到特定接收方的唯一 IP 地址
- 每条通信链路独立，数据包仅传输给目标主机；
- 基于TCP或UDP协议，支持可靠传输或低延迟传输；
- 安全性高，数据仅发送给指定接收方
- 举例：邮件发送
组播（Multicast），即一对多的通信模式，发送方将数据包发送到一个特定的组播组，只有加入该组的设备才能接收到数据
- 设备通过 IGMP（IPv4）或 MLD（IPv6）加入/离开组播组；
- 网络设备通过组播路由协议（如PIM）构建转发树，仅向有接收方的链路复制数据；
- 基于 UDP 协议，适合实时性要求高的场景；
- 高效利用带宽，扩展性强，但实现复杂
- 举例：视频直播、在线会议、分布式计算中的数据分发等
广播（Broadcast），即一对所有的通信模式，发送方将数据包发送到本地网络（广播域）内的所有设备
- 数据包的目标地址为广播地址（如IPv4的255.255.255.255）；
- 部署简单，发送方只需发送一次数据；
- 安全性低，且广播数据无法跨路由器传播，仅限于本地网络
- 举例：局域网内的网络发现、地址解析协议（ARP）请求、系统通知等

PTD 并行和 3D 并行

PTD 是Pipeline, Tensor, Data三个词的缩写；3D 则是 3 个 Dimensions（数据、张量、流水线 3 个维度）的含义
从核心构成上看，PTD并行与3D并行本质上描述的是同一种思想，即通过融合三种基础的并行技术来共同扩展模型的训练能力
总节两者主要区别在于：
- 术语归属 ：PTD与Megatron-LM紧密绑定，而3D并行是业界更通用的描述
- 优化焦点 ：PTD 并行（Megatron-LM）的特色在于其精巧的交错式流水线调度 ，旨在最大化计算效率；而3D 并行（DeepSpeed）的王牌在于和ZeRO技术的结合，在保证计算效率的同时，实现了极致的内存优化
这三种基础的并行技术分别是：
- 数据并行（Data Parallelism, DP）： 将训练数据分发到多个计算设备上，每个设备都持有一份完整的模型副本，并独立计算梯度，最后通过全局通信同步更新模型参数
- 张量并行（Tensor Parallelism, TP）： 也称为层内模型并行（Intra-Layer Model Parallelism），它将模型单个层（特别是其中巨大的权重矩阵）切分到不同设备上，进行协同计算
- 流水线并行（Pipeline Parallelism, PP）： 也称为层间模型并行（Inter-Layer Model Parallelism），它将模型的不同层（Layers）分配到不同的计算设备上，形成一个流水线，数据依次通过各个设备完成前向和反向传播

两者的核心区别：命名、实现与优化策略

PTD 并行 (PTD Parallelism)：
- 源于 NVIDIA 的Megatron-LM框架。PTD是Pipeline, Tensor, Data三个词的缩写，直观地表达了其技术构成
- 强调通过创新的流水线调度策略来提升效率，其代表性的优化是 “交错式流水线调度”（Interleaved Pipeline Schedule）
- 策略上看：PTD-P（Megatron-LM中的具体实现）通常建议在单个节点内部（通过NVLink等高速互联）应用张量并行，而在跨节点时应用流水线并行，最后在整个集群上应用数据并行。其核心创新在于通过将模型的层块（chunks）交错分配给不同的流水线阶段，有效减少了流水线“气泡”（bubble）——即设备空闲等待的时间，从而提高了计算资源的利用率
3D 并行 (3D Parallelism)：
- 一个更为通用的术语，被DeepSpeed等多个框架广泛采用，用以描述由数据、张量和流水线三个维度构成的并行策略
- 强调与 ZeRO（Zero Redundancy Optimizer）技术 的深度融合（ZeRO 是一种高度优化的数据并行技术，可以显著降低内存冗余）
- DeepSpeed 的 3D 并行将计算设备组织成一个三维网格（Mesh），分别对应数据并行、张量并行和流水线并行
- 3D 并行最大的特点是数据并行维度可以由ZeRO来赋能
- ZeRO 不仅切分数据，还能够将模型的参数、梯度和优化器状态进行切分和卸载，极大地优化了内存使用效率，使得在同等硬件条件下能够训练更大规模的模型

3D 并行示例

场景设定：假设有 16 张卡，3D 并行的策略为 tp=2，dp=2，pp=4
此时有以下结论：
- 共两个 DP 组，每组 8 张卡
- 每个 DP 组的 8 张卡包含 4 个 PP 阶段，每个阶段有 2 张 TP 组的卡，即这 8 张卡通过管道并行（PP） 和张量并行（TP） 的拆分方式，分别存储模型的不同部分（按层拆分+按参数维度拆分）
- 同一个 DP 组的 8 张卡共同构成了一个完整的模型 ，单独一张卡仅持有模型的部分参数（既不完整，也不独立），整个 DP 组的 8 张卡通过协作（通信+拼接）能够共同代表一个完整的模型结构
- 2 个 DP 组的 8 张卡可分别视为完整模型的“数据并行副本”
- 2 个 DP 组的参数拆分方式完全相同，只是处理不同的数据分片，训练中通过梯度同步保持参数一致性
特别地，在 MoE 中，还会多一个 EP，即专家并行，Expert Parallelism
- 核心作用是：拆分 MoE 模型的专家到不同 GPU，解决显存瓶颈，提升训练并行度

MFU（Model FLOPs Utilization）

MFU 通常指的是 Model FLOPs Utilization ，即“模型浮点运算利用率”
- 其中 FLOPs 是 “Floating Point Operations Per Second（每秒浮点运算次数）”的缩写，是衡量计算能力的重要指标
MFU衡量的是实际训练过程中，模型所用到的浮点运算量与 GPU 等硬件理论峰值性能的比例
MFU 的计算公式通常为：
$$
MFU = \frac{\text{模型实际每秒浮点运算次数}}{\text{硬件理论最大每秒浮点运算次数}}
$$
- 分子：模型在训练时实际消耗的 FLOPs（可通过模型结构和 batch size 等参数估算）
- 分母：硬件（如 GPU）理论上能够达到的最大 FLOPs（由硬件规格决定）
MFU 低可能意味着模型结构、数据管道、硬件配置存在瓶颈，开发者可以通过优化模型、提升数据加载效率、调整 batch size 等方式提升 MFU
MFU 是评估不同训练方案、模型架构或硬件平台性能的重要参考指标

MFU 与其他指标的区别

MFU 关注的是浮点运算利用率，强调计算资源的使用效率
GPU Utilization 则是 GPU 整体资源（包括计算、内存、IO 等）的使用率
TFLOPs 是硬件的理论计算能力，MFU 则是实际利用率

SPMD (Single Program Multiple Data)

SPMD (Single Program Multiple Data) 是一种编程范式，其特点为：
- 所有进程执行一份代码
- 每个进程通过传入不同分布式参数（比如 Rank）来处理不同的数据
SPMD 是非常常用的编程范式，比如：
- 数据并行：DDP，ZeRO，FSDP
- 张量并行
- 流水线并行
- 序列并行（Sequence Parallelism）
注：序列并行（Sequence Parallelism）是特指大语言模型中将同一个长序列分配到不同的 GPU 上进行分布式处理的方式
- 应用实例：比如 Megatron 中的 Context Parallelism（上下文并行，CP）通过切分 LayerNorm 和 Dropout 的输入，减少 30% 以上的激活内存，同时保持计算效率

Model Growth Initialization（模型增长初始化）

模型增长初始化（Model Growth Initialization，MGI） 是大模型领域中，通过从已训练小模型出发、渐进式扩展结构（如增层数、扩宽度、加专家数量），并复用小模型参数与优化状态进行初始化的技术
核心是用“知识迁移”降低大模型训练成本、提升效率
Model Growth Initialization 关键逻辑包括：
- 通过深度/宽度/MoE混合等策略扩展模型；
- 靠功能保留初始化（Function-Preserving Initialization，FPI）、身份映射初始化（Identity Mapping Initialization）等原则避免训练震荡；
- 典型方法有 Net2Net（结构扩展框架）、Stacking Transformers（深度堆叠加速）等
实际应用中，能减少 50% 左右训练时间、降低显存占用，还能让扩展后的大模型保持性能甚至激发复杂推理等“涌现能力”
目前仍面临扩展策略自动化、初始化精细化、分布式训练适配等挑战，是千亿级大模型高效训练的重要技术方向

GEMM

通用矩阵乘法（General Matrix Multiply，GEMM）是线性代数与深度学习中最核心的计算原语之一，用于高效地计算：
$$C = A × B$$
- 也支持带缩放与累加的
  $$C = \alpha AB + \beta C$$
GEMM 是 BLAS 中的核心例程（CBLAS 接口：cblas_sgemm/cblas_dgemm 等）
- 原始的 BLAS 是用 Fortran 语言编写的；CBLAS 则是 BLAS 的 C 语言接口（C Interface to BLAS）
DeepGEMM（FP8、JIT、MoE 优化）是针对深度学习场景优化的 GEMM 计算库，专注于提升大模型训练和推理中的矩阵乘法效率，尤其在混合精度计算、动态形状适配等场景有显著优势

RDMA

RDMA 是一种“远程直接内存访问”技术，允许网卡绕过 CPU 与内核，直接读写对端内存，实现低延迟、高吞吐、低CPU占用的网络通信；
RDMA 的常见实现包括 IB（InfiniBand）、RoCE（v1/v2）、iWARP，需 RDMA 网卡与配套网络/驱动
RDMA 的能力包括单边（RDMA Read/Write/Atomic）与双边（Send/Recv）语义，支持用户态 Verbs 接口

RDMA 与 NVLink 的关系

NVLink 是 NVIDIA 用于节点内 GPU 高速互连的技术，提供高带宽、低延迟与缓存一致性（取决于架构），用于近距紧耦合场景
NVLink 用于同一节点内 GPU 直连（NVIDIA Magnum IO 等库）；
RDMA（如 IB/RoCE）用于跨节点扩展，常配合 GPUDirect RDMA（GDR）等机制实现 GPU 到 GPU 的远程直接访问（绕过 CPU 提升端到端效率）

Micro Batch

索引关键词：Micro Batch Size, Micro-Batch-Size, micro_batch_size
micro-batch ：将 mini-batch 再切分的子批次，按序流经流水线，提升吞吐并降低气泡开销
在流水线并行中，每个 GPU 在一次前向传播中处理的是一个 micro-batch；
- 多个 micro-batch 逐个流过流水线各阶段，累积多次前向/反向后才做一次权重更新
简单来说，一次前向就是一个 micro-batch ：每个 GPU 每次前向处理一个 micro-batch，连续处理多个后再更新梯度
关系公式：train_batch_size = micro_batch_per_gpu $\times$ gradient_accumulation_steps $\times$ world_size
注：若不使用流水线并行，GPU 通常一次处理一个完整的 mini-batch（可以认为此时 micro-batch = mini-batch）
注：流水线并行中，BatchNorm 统计量按 micro-batch 计算，同时维护全局移动平均用于推理

muP（Maximal Update Parameterization, $\mu$P）

muP（Maximal Update Parameterization, $\mu$P）是一种网络参数化与超参缩放框架，通过让前向/反向传播与参数更新的量级对模型宽度近似不变 ，实现超参数从小模型到更大模型的“零样本迁移”（$\mu$-Transfer） ，从而显著降低超参与训练稳定性的调优成本
核心目标是让“好的超参”在放大时依然是“好的”，而非随宽度剧烈漂移
做法要点有：
- 初始化与权重尺度：令初始化方差随输入/输出维度缩放，确保激活与梯度量级稳定；对非方阵，在 fan_in/fan_out/fan_avg 间选择或统一处理
  - fan_in/fan_out/fan_avg 分别表示输入神经元数/输出神经元数/输入输出神经元数两者均值
- 学习率缩放：典型经验是学习率与宽度成反比（$\eta \propto \frac{1}{d}$），以控制每步损失增量不随规模爆炸；实际常配合层/模块自适应学习率
- 保持训练动态稳定：将前向、反向、损失增量与特征变化的量级稳定化，使得跨尺度迁移可行
与标准参数化（SP）的对比
- SP：最优超参会随宽度显著变化，通常需要在每个尺度上重新调参
- $\mu$P：通过重参数化让最优超参对宽度近似不变，实现“零样本迁移”
TLDR：$\mu$P 通过“宽度不变”的参数化与超参缩放，把小模型上的好超参“零样本”迁移到大模型，让“炼丹”更可预测、更省钱

梯度裁剪（Gradient Clipping）

梯度裁剪（Gradient Clipping） 主要作用是通过限制模型参数梯度的全局范数，避免训练过程中因梯度爆炸（Gradient Explosion）导致的模型不稳定（如 loss 震荡、参数更新幅度过大等问题）
梯度裁剪中最常用的L2范数梯度裁剪（L2 Gradient Clipping） 或全局梯度范数裁剪（Global Gradient Norm Clipping）
核心步骤：
- 1）计算全局梯度范数 ：先将当前 batch 中所有可训练参数的梯度拼接成一个向量，计算该向量的 L2 范数（即“整体梯度范数”）
- 2）判断是否裁剪 ：若该全局范数超过预设的“裁剪阈值（clip_grad）”，则执行裁剪；若未超过，则不干预梯度
- 3）统一缩放所有梯度 ：通过乘以“裁剪阈值/全局梯度范数”的缩放系数，对所有参数的梯度进行等比例缩放 ，最终使全局梯度范数恰好等于裁剪阈值，确保梯度规模可控，避免训练不稳定（如梯度爆炸）

代码实现：

torch.nn.utils.clip_grad_norm_(
	parameters,       # 待裁剪梯度的参数集合
	max_norm,         # 梯度的“最大允许范数”（裁剪阈值）
	norm_type=2.0,    # 计算范数的类型（默认L2范数）
	error_if_nonfinite=False  # 若梯度范数为无穷/NaN，是否抛出错误
)

Aux-Loss-Free 方法

Aux-Loss-Free 是 MoE 负载均衡的一种方法：在门控分数上加专家级偏置 $b$ 来调节路由，全程不引入辅助损失及其梯度，从而避免干扰主任务（如语言建模）的优化方向，兼顾负载均衡与模型性能
对比传统做法：
- 传统做法：用辅助损失推平专家负载，但权重不当会污染主梯度、损害性能
- Aux-Loss-Free 方法：在 top‑K 前给门控分数 $g$ 加偏置 $b$，仅影响路由结果，不回传梯度；负载过高的专家减小其 $b$，负载不足的增大 $b$，实现自适应均衡
Aux-Loss-Free 有许多优点
- 无梯度干扰：不改变 loss，不影响主任务梯度，稳定训练
- 因果一致：自回归可用，训练/推理一致
- 高效可实现：开销小、易部署，工程友好
常见实现为：
- 偏置更新：按当前负载与均匀分布的偏差，用符号梯度更新 $b$，如 $b \leftarrow b − \alpha \text{sign}$(实际负载 − 均匀负载)
- 典型参数：更新率 $\alpha \approx 0.001$；对门控激活较敏感，必要时解耦路由激活与主模型以稳定超参

EOT、EOD、EOS（结束符号辨析）

在自然语言处理中，EOT、EOD、EOS 都是用于标识文本边界的特殊 token，他们核心差异在于所标记的「边界类型」不同
EOS（End of Sequence）：序列结束符
- 表示一个「完整序列」的结束，是最通用的结束标记
- 在 GPT 系列中，<|endoftext|> 常作为 EOS 使用，标识生成文本的结束
- 机器翻译时，模型输出 <EOS> 表示翻译句子完成
EOD（End of Document）：文档结束符
- 专门用于标识「文档/篇章」的结束，强调「长文本单元」的边界
- 训练语料中，在每篇文章末尾插入 <EOD>，告诉模型“这篇文档到此结束”
- 长文档理解任务中，用 EOD 标记章节或全文的结束
EOT（End of Turn）：轮次结束符
- 用于「对话场景」，标识一轮对话的结束，强调「交互单元」的边界
- 对话训练数据中：用户：你好<EOT>模型：您好，有什么可以帮您？<EOT>
  - 聊天机器人生成回复时，用 <EOT> 标记当前轮次输出的结束

MPU（Model Parallel Unit）

MPU 一般指 Megatron’s MPU（Model Parallel Unit，模型并行单元），是 NVIDIA Megatron-LM 框架中用于实现大规模模型并行训练的核心组件
MPU 专为解决超大规模 Transformer 模型（如 GPT 系列）的训练挑战而设计，通过灵活的并行策略突破单设备内存限制，支持在多 GPU/多节点集群上高效训练千亿级参数模型
MPU 实现了 TP，PP 和 DP 的协同
MPU 的核心特性包括：“拆分模型、协调计算、管理通信”

1F1B

1F1B，即 One Forward and One Backward, 也称为 PipeDream
注意：1F1B 不同于 Gpipe，平时强调 1F1B 时主要是区别于 Gpipe
- Gpipe 发表晚于第一篇 PipeDream 1F1B（与第二篇 PipeDream 前后顺序不确定），但效率其实不如 PipeDream 1F1B
1F1B 主要有两种形式：
- PipeDream 1F1B
- Interleaved 1F1B：交错式 1F1B

PD 分离

关键词：PD分离；
PD分离（Prefill-Decode 分离）是大模型推理系统的一种性能优化架构
PD 分离的核心思想是：把一次 LLM 推理拆成 Prefill 和 Decode 两个阶段，并分别部署到最适合的硬件资源池里，让它们各自独立扩缩容、互不干扰
- PD 分离 让算力型任务去找算力卡 ，让显存型任务去找显存卡 ，用网络把中间结果搬过去，从而实现各自的优势
传统做法把两个阶段放在同一 GPU 上顺序执行，会带来三大痛点：
- Prefill 计算密集、Decode 内存带宽密集，混布时互相抢占，P99 延迟可飙升 78% 以上
- 两类负载峰值时段不同，共池导致要么算力浪费、要么显存不足
- 聊天机器人要首 token 时延（TTFT）<200 ms，代码补全却要求每 token 时延（TPOT）极低，共池架构无法兼顾
PD 分离具体做法：把 Prefill 节点单独成池，Decode 节点单独成池，中间通过 高速网络 把 KV Cache 从 P 池传给 D 池，之后两者完全异步、独立批量
PD 分离带来的好处
- 吞吐提升 2–3 倍 ：各自跑满最匹配的硬件，消除相互阻塞
- 延迟更稳 ：Decode 不再被新到的 Prefill 抢占，P99 延迟尖峰被削平
- 显存节省 30%+ ：KV Cache 可 offload 到 CPU/SSD，Decode 池只需留当前活跃缓存
- 成本下降 ：Prefill 池用高算力低显存卡，Decode 池用大显存低算力卡，整机性价比更高
vLLM、SGLang 均已给出原型或生产级方案

Training Dynamics

Training Dynamics 指的是训练过程中模型的各种属性随时间或迭代轮数的变化情况，包括但不限于损失函数值、准确率、模型参数的更新、梯度的分布等属性

在线量化（Online Quantization）

在线量化技术（Online Quantization）是模型量化的一种实现方式，指的是在模型推理过程中动态进行量化操作 ，而非像传统离线量化那样在推理前就完成所有量化参数（如缩放因子、零点）的计算和模型转换
Online Quantization 的核心特点是：
- 1）动态计算量化参数 ：量化所需的关键参数（如激活值的范围、缩放因子）不是预先计算好的，而是在模型实际运行时，根据实时输入数据的分布动态调整和更新
- 2）边推理边量化 ：模型在处理输入数据的同时完成量化转换，不需要提前对模型进行离线“校准”或“量化预处理”步骤
- 3）适应性强 ：能够更好地应对输入数据分布变化较大的场景（如不同用户、不同场景的输入差异），因为量化参数会随输入动态调整
在线量化的优势在于灵活性高，无需预先准备校准数据集，适合输入分布不稳定的场景；
- 但缺点是会增加推理时的计算开销（因为需要实时计算量化参数），可能对推理速度有一定影响
这种技术常见于资源受限的边缘设备或需要处理多样化输入的场景，平衡了模型压缩需求和对动态数据的适应能力

Fill-in-Middle（中间填充）目标

Fill-in-Middle（中间填充）和Next-Token-Prediction 是大语言模型中两种不同的训练目标
Next-Token-Prediction（NTP） 任务本质是自左向右的单向预测 ，模型仅能基于前文信息推断后续内容，无法利用“后文”信息
Fill-in-Middle（FIM） 中，模型接收的输入被拆分为三部分：前缀（prefix）、待填充的空白（middle）、后缀（suffix）
- 模型需要预测的是中间缺失的内容，且预测过程中同时利用前缀和后缀的信息
  - 例如：输入“今天天气[MASK]，适合野餐”，模型需要预测中间的“很好”；或更复杂的拆分如“前缀+<mask>+后缀”，其中<mask>是待填充位置
DeepSeek-Coder-V2 和 DeepSeek-V3

SHARP

在 Megatron-LM 或 Megatron-Core 这样的高性能分布式训练框架中提到的 SHARP 通常指的是 NVIDIA SHARP (Scalable Hierarchical Aggregation and Reduction Protocol) 技术
SHARP 是一种底层网络硬件加速技术 ，用于提高集体通信操作（$\text{Collective}$ $\text{Operations}$）的效率
SHARP 技术由 NVIDIA 开发，并集成在其 InfiniBand 网络硬件（如 Quantum 交换机）中
- 主要目标是加速大规模 AI 和高性能计算 (HPC) 应用中的集体通信
传统方式： 在分布式训练中，像 All-Reduce（用于同步梯度）、Reduce 和 Broadcast 这样的集体操作，需要将数据从一个 GPU 传输到另一个 GPU，并在 CPU 或 GPU 上执行计算（例如梯度求和）
- 这个过程会占用宝贵的计算资源并产生大量的网络流量
SHARP 方式： SHARP 将这些集体操作的聚合和归约功能直接卸载到网络交换机的硬件中执行（称为 In-Network Computing）
减少数据移动： Megatron 中可以选择开启 SHARP，在 SHARP 启用后，例如在执行 All-Reduce 时，数据沿着网络中的聚合树向上移动时，交换机就会实时地执行求和操作 ，而不是将所有原始数据都发送到终点
效果： 这大大减少了网络中传输的数据量（只需传输归约后的结果），从而显著降低了通信延迟和缓解了网络拥堵
SHARP 通过加速这些底层的 NCCL（NVIDIA Collective Communications Library）操作，直接提高了 Megatron-LM 整体的训练吞吐量和效率（Model FLOPs Utilization, MFU），尤其是在涉及大规模 GPU 节点间的 DP 通信时效果显著

Rubrics

Rubrics（评估细则）是一种奖励评估方法，与 Pairwise（成对比较）, Likert 量表（李克特量表）一样，都是生成式 RM 的一种评估方式
Rubrics 的做法是将复杂，难以评估的人类偏好转变成多个维度的二元可验证奖励
Pairwise是目前 RLHF 奖励模型（RM）训练中最主流和最可靠的方法
- 评估难度低，可靠性相对较高，获取了相对一致的偏好数据；但是效率低，复杂度是 $O(N^2)$
Likert 量表是效率最高、最常用的点式（Pointwise）评估方法之一
- 效率高，复杂度仅 $O(N)$ ，但分数存在不一致性（不同人评估标准不同）
- Likert 量表本质是一种主观态度 / 偏好的测量工具，通过让受试者（可以是 LLM）对一系列陈述（如 “对上述描述的满意程度”）选择 Likert 等级（可根据不同的），将定性态度量化为定量分数
  - 通常为 5 级，此时为 5 点量表 (5-Point Scale)：非常不同意、不同意、中立、同意、非常同意
  - 可以为 7 级，此时为 7 点量表 (7-Point Scale)：非常不同意、不同意、稍不同意、中立、稍同意、同意、非常同意
  - 注：也可以是满意、不满意等，可以根据不同的 Setting 选择不同的评分方式
- Likert 针对单个样本的主观评分，不直接体现样本间的相对顺序
- Likert 分数具有序数意义（如 5 分 > 4 分），但不代表分数间的间隔相等（不能认为 5-4 的差异等于 4-3）
Rubrics 提供了最精细、可解释的评估，是高质量、专业性任务的首选
- 线上效率高，复杂度仅 $O(N)$，但需要离线构造 Rubrics，往往比较耗时
- 可以与 Pairwise 结合使用（例如，通过 Pairwise 比较来动态生成或优化 Rubrics，或用 Rubrics 作为 LLM Judge 进行 Pointwise 评分的指导）
- 容易因 Rubrics 设计不够好而出现 Reward Hacking，特别静态 Rubrics 可能发生 Reward Hacking
Dynamic Rubrics 可能是未来的趋势
- 不再是静态固定的 Rubrics，而是在训练过程中，动态的根据模型的回复生成不同的 Rubrics
其他思考：
- 用多个模型生产 Rubrics，然后按照相似度聚合，同一个桶中的给一个想通的权重（即使用该桶的 count 来作为权重）
  - 理论上，随着模型数量的增加，效果会越来越好

Token 粘黏现象

Token 粘黏（这个名字暂时是我自己给的，待确认）
Token 粘黏是指 Prompt 和 Response 之间直接组合时，可能存在的 tokenize(prompt + answer) 不等于 tokenize(prompt) + tokenize(answer) 现象
该问题出现时，实际上可以在中间加一个 Special Token 来解决（最推荐的方式，一般可以完全解决问题）
实际上，也可以使用一下两种方式来解决
- 分开 tokenize，再合并（如果真的是比较特殊的情况，建议使用这种方式）
- 合并 tokenize，将中间 Token 分配给 Prompt 或者 Response
以上两种方式都可能导致 training 和 inference 不一致的情况
注：从统计意义上来看，或许这个问题并不重要，哪种方式都没问题，因为如果中间这个粘黏 Token 很常见的话，肯定会出现，从而被识别到，如果不常见的话，理论上 inference 时也会很少遇到

TIS（Truncated Importance Sampling）

TIS 即截断重要性采样，是一种方差缩减技术
TIS 通过智能筛选高价值样本并抑制异常值影响，来解决大模型训练中数据不平衡、标注成本高昂、计算资源消耗巨大等问题
在强化学习中，TIS 还可用于减轻 rollout 与训练之间的差距，通过引入重要性权重修正梯度计算，有效处理 rollout 分布与训练分布的不匹配问题，提升训练性能

MIS（Multiple Importance Sampling）

原始论文：(MIS)RL-PLUS: Countering Capability Boundary Collapse of LLMs in Reinforcement Learning with Hybrid-policy Optimization, PKU & Tongyi Lab, 20250731 & 20250805 & 20251019
MIS 是上述论文中提出的一种方法，对传统 PPO 的重要性采样进行了优化

MIS（Masked Importance Sampling）

掩码重要性采样 (Masked Importance Sampling, MIS) 是指对 Training-Inference 重要性采样比值差异较大的样本做置 0 处理（Masking）
这个掩码方式最早应该是在 (IcePop)Small Leak Can Sink a Great Ship—Boost RL Training on MoE with IcePop!, 20250919, AntGroup 中被提及（但该博客未给与 MIS 的命名）
在后来被其他文章中将这种方法称为 MIS（Masked Importance Sampling）
- 相关博客：When Speed Kills Stability: Demystifying RL Collapse from the Training-Inference Mismatch
- 相关 PR：【PR to TRL】[GRPO] Sequence-level TIS + MIS（20251106）

IcePop

原始博客：(IcePop)Small Leak Can Sink a Great Ship—Boost RL Training on MoE with IcePop!, AntGroup
IcePop 是蚂蚁 Ring-flash-2.0 搭载的独创算法，是一种梯度控制机制，能够解决 MoE 模型在长思维链RL训练中容易出现的“奖励崩溃”问题
Icepop 算法把训练中表现异常的 token 当场冻住，不让它们回传梯度，从而使训练能够持续稳定提升，避免梯度突然爆炸，减少训推精度差异

Megatron-Core（Mcore）

Megatron-Core，即 NVIDIA Megatron-Core，也称为 Megatron Core 或 MCore，是一个基于 PyTorch 的开源库，可在数千个 GPU 上以高速大规模训练大型模型
Megatron-Core 提供了先进的模型并行技术
- 包括张量、序列、工作流、上下文和 MoE 专家并行等
- 用户可以灵活结合不同的模型并行技术以适应训练工作负载
- 还具备节省内存的功能，如激活重新计算、分布式优化器和分布式检查点等
Megatron-Core 通过模块化和可组合的 API 提供可定制的基础模组，对于 Transformer 模型，它提供注意力机制、归一化层、嵌入技术等
借助 Megatron-Core（Mcore）规格系统，研究人员可以在 PyTorch 模型定义中轻松自定义所需抽象级别的子模块
Megatron-Core 是 Megatron-LM 的子集，即：
- Megatron-LM 依赖 Megatron-Core 实现底层分布式逻辑；
- 开发者可以单独使用 Megatron-Core，而无需引入 Megatron-LM 的全部功能

Flash Linear Attention（FLA）

FLA 是一种高效的自注意力机制实现方式
FLA 能够显著降低 Transformer 模型在长序列处理时的内存占用和计算复杂度
flame 框架是基于 torchtitan 构建的轻量级训练框架，专门为 FLA 模型的训练优化而设计，支持流式数据处理，避免了传统方法中繁琐的预处理步骤，特别适合大规模数据集训练

Gated DeltaNet（GDN）

GDN 是一种与 Mamba2 类似的架构，采用了粗糙的 head-wise 遗忘门

Kimi Delta Attention（KDA）

KDA 是 Kimi Linear 架构的核心，它是 Gated DeltaNet（GDN）的改进版本，引入了更高效的门控机制
KDA引入了一种 channel-wise 的变体，其中每个特征维度都保持独立的遗忘率，能够更精确地调控有限状态 RNN 的记忆
KDA通过 DPLR（Diagonal-Plus-Low-Rank，对角加低秩）矩阵的一种专门变体来参数化其转换动态，使得一种定制的分块并行算法成为可能，该算法相较于通用的 DPLR 公式能显著减少计算量
注：KDA 是 GDN 的改进版本，GDN 的遗忘门机制相对较为简单，而 KDA 则通过更细粒度的门控设计对其进行了优化

Kernel Fusion

Kernel Fusion 不改变模型的数学逻辑，仅通过合并计算步骤、减少冗余开销，让硬件的算力和带宽得到更高效利用
前置概念：
- 计算核（Kernel）：可以理解为 “硬件可直接执行的最小计算单元”—— 比如 PyTorch/TensorFlow 中的一个算子（如matmul矩阵乘法、add加法、gelu激活函数），最终都会被编译成 GPU/CPU 能执行的 Kernel
- 串行 Kernel 的问题：大模型的关键模块（如自注意力、FFN）是由多个算子串联组成的（例：matmul + add + gelu + matmul + add）
  - 如果每个算子单独作为一个 Kernel 执行，会产生大量冗余开销（如寄存器到全局内存(来回)的数据搬运开销、Kernel 调度开销、中间结果存储作为临时变量占用额外显存等）

Kernel Fusion 的核心逻辑：“合并算子，减少冗余”，以 Transformer 的前馈网络（FFN）为例：

原始串行执行（无Fusion）：

# 步骤1：第一个线性变换（matmul）+ 偏置（add）
x1 = torch.matmul(x, w1) + b1
# 步骤2：激活函数（gelu）
x2 = torch.gelu(x1)
# 步骤3：第二个线性变换（matmul）+ 偏置（add）
x3 = torch.matmul(x2, w2) + b2

注意：这会生成 3 个独立 Kernel，存在 2 次数据回写+调度开销

融合后执行（Fused Kernel）：

1
2
3

# 将`matmul + add + gelu + matmul + add`合并为一个Kernel，执行逻辑变为如下
# 单个Kernel内完成所有计算，数据不落地到全局内存
x3 = fused_ffn(x, w1, b1, w2, b2)

数据在寄存器中完成x->x1->x2->x3的流转，彻底消除中间步骤的内存读写和调度开销

Kernel Fusion 无法保证 bit-wise 对齐 ：
- Kernel Fusion 会改变计算的 “实现细节”，但不改变 “数学逻辑”，而浮点计算的特性决定了 “实现细节差异” 会导致二进制结果不同

Weight Decay Scheduling

权重衰减调度（Weight Decay Scheduling）是训练神经网络时，动态调整权重衰减系数（Weight Decay，代码中常常简写为 WD, wd）的策略
简单来说：就是“不固定权重衰减的大小，让它随训练步数变化”，核心目的是平衡模型的“拟合能力”和“泛化能力”，避免训练初期欠拟合、后期过拟合
权重衰减（Weight Decay）本身是什么？
- 权重衰减本质是 L2正则化 的一种实现（部分框架中二者等价）
- 通过在损失函数中添加“权重参数的平方和”项，惩罚过大的权重值，避免模型过度依赖少数特征（即过拟合）
- 比如：如果权重衰减系数 wd=0.0001，相当于每次更新权重时，都会让权重乘以 (1 - wd)，间接限制权重增长
为什么需要“动态调整”？
- 训练初期：模型还在学习基础特征，此时如果权重衰减过大，会“压制”模型的拟合能力，导致欠拟合（学不到关键模式）
- 训练后期：模型已经掌握核心特征，此时需要更大的权重衰减来抑制过拟合（避免模型“死记硬背”训练数据的噪声）
权重衰减调度的核心思路：
- 让权重衰减系数从“小”逐步变“大”，适配训练不同阶段的需求
注：权重衰减调度与学习率调度，目标、逻辑完全独立

权重衰减调度的实现

权重衰减调度的核心是按训练步数（global_step）动态调整系数，最常用的是 线性递增调度
- Megatron-LM 中默认/推荐策略是线性递增调度 constant
定义关键参数（不同框架参数名称可能不同，但都差不多）：
- wd_init：初始权重衰减系数（通常设为 0，训练初期不衰减）；
- wd：目标权重衰减系数（训练后期稳定值，如 0.01）；
- wd_incr_steps：从 wd_init 递增到 wd 的总步数（如 5000 步）
分阶段调整：
- 阶段1（递增期）：global_step < wd_incr_steps
  - 权重衰减系数随步数线性增长：current_wd = wd_init + (wd - wd_init) * (global_step / wd_incr_steps)
- 阶段2（稳定期）：global_step >= wd_incr_steps
  - 权重衰减系数固定为目标值 wd，持续抑制过拟合

closing tag 和 opening tag

在编程与标记语言（如 HTML、XML、Vue、WXML 等）中的核心概念，“closing tag” 是 “闭合标签” ，核心作用是 标记一段内容的结束
“closing tag”常常与对应的 起始标签（opening tag） 成对出现，确保语法结构完整、解析器能正确识别内容边界
闭合标签的格式是 <标签名/>（自闭合，适用于无内容的标签）或 </标签名>（常规闭合，适用于包含内容的标签），关键是比起始标签多了斜杠 `/
闭合标签告诉解析器（如浏览器、框架编译器）“当前标签对应的内容到此结束”，避免解析混乱（比如嵌套标签的层级、样式/逻辑的作用范围）
大多数包含内容的标签都需要闭合标签，例如 HTML 中的 <div> <p> <span>，Vue 中的 <template> <component> 等

PBRL (Preference-Based Reinforcement Learning)

PBRL 是一种强化学习范式，其核心思想是 “告诉模型哪个更好，而不是给模型一个具体的奖励打分”
- 在传统的强化学习中， Agent 通过环境反馈的数值奖励（Reward Function，例如 $+1$ 或 $-10$）来学习
  - 但在许多复杂任务中，设计一个完美的数值奖励函数极其困难（即 “Reward Engineering” 难题）
- PBRL 解决了这个问题：它不依赖预定义的数值奖励，而是依赖于“偏好”反馈 ，核心工作流程如下：
  - 1）交互与展示：智能体在环境中执行动作，生成若干条轨迹（Trajectory）或结果
  - 2）偏好查询：系统将这些轨迹展示给评估者（可以是人类、专家系统或预设规则），询问：“哪一个更好？”
  - 3）奖励建模 (Reward Modeling)：利用这些成对的偏好数据，训练一个神经网络（奖励模型），使其输出的数值满足评估者的偏好排序
  - 4）策略优化：智能体利用这个学到的奖励模型 ，使用标准的强化学习算法（如 PPO, SAC）来优化策略
PBRL vs RLHF：
- PBRL 是一个更广泛的算法框架/方法论；
  - 反馈来源不限于人类；
  - 适用于各种场景；比如让机械臂尝试两次倒水，一次很快但溅出来了，一次很慢但没溅出来；人类看着说：“第二次更好”
  - 关注如何在没有奖励函数的情况下解决控制问题，以及如何提高样本效率
  - PBRL 是理论基础 ：它告诉我们，可以通过比较（A > B）来学习奖励函数，进而训练智能体
- RLHF 是 PBRL 在 LLM 场景中的一个特定应用实例，是特定的技术 Pipeline；
  - 反馈来源一般是 “Human”；
  - 仅适用于 LLM 场景；
  - 关注如何让模型对齐人类价值观（有用性、诚实性、无害性）
  - RLHF 是具体应用 ：它是将 PBRL 的理论应用到 LLM 上，并引入了人类价值观（Human Alignment）作为核心目标的特定技术路线

Generative RM

Generative RM（Generative Reward Model，生成式奖励模型） ，有时候也简称 GenRM
Generative RM 通常不需要改变模型结构，而且一般不需要微调或少量微调即可很好的用于评估其他模型的输出质量
Generative RM 的核心是复用大模型的上下文能力，用 prompt 提示大模型对模型答案给出分数
与 Generative RM 对照的是标准奖励模型（Standard RM），标准奖励模型一般是在大模型最后再增加一个 MLP 来输出最终的分数

Discriminative RM

Discriminative RM（Discriminative Reward Model，判别式奖励模型） ，有时直接使用 奖励模型（RM）来称呼
- 别名：Standard RM（Standard Reward Model，标准奖励模型），有时也称为朴素奖励模型（Naive RM）
Discriminative RM 的核心设计是在预训练的大模型顶部直接接入一个奖励头，通常是线性层或简单的多层感知机（MLP），模型处理输入后直接输出一个标量奖励分数来评估结果质量
Discriminative RM 模型训练和推理速度极快，计算成本低，但一般需要针对特定数据进行微调
BERT 当时使用专有的 [CLS] Token 作为特殊标记从而实现输出分类的方式，也可以认为是一种奖励模型

BT RM

当 Discriminative RM 的损失是 Bradley-Terry 建模时，也称为 Bradley-Terry Reward Model ，简称 BT RM

Heavy Mode（Deep Thinking Mode）

Heavy Mode（译为 Heavy 模式）和 Deep Thinking Mode 本质上是同一概念的不同表述
- 他们都指代通过并行推理和延长思考时间来提升模型复杂任务处理能力的机制
- Heavy Mode ：强调资源消耗和计算强度（Heavy=重型/高负载）
- Deep Thinking/Deep Think Mode ：强调思维深度和推理过程

具体方法

Introducing Kimi K2 Thinking, 20251106, Moonshot AI (Kimi) 原文：

Heavy Mode: K2 Thinking Heavy Mode employs an efficient parallel strategy: it first rolls out eight trajectories simultaneously, then reflectively aggregates all outputs to generate the final result. Heavy mode for GPT-5 denotes the official GPT-5 Pro score.
说明：Heavy Mode 是一种通用的提升模型推理能力的方法，其方式为：
- 第一步：并行采样多个 Trajectories
- 第二步：结合第一步生成的结果放入模型，让 Summary 模型来解决问题
针对第一步给出的答案，针对不同的 query，第二步有不同的处理方式，query 可以分为以下三种：
- 投票可得正确解：直接通过投票获取到正确答案
  - 这种类型的 Query 甚至无需 Summary 模型，直接投票即可
- 投票得不到正确解，但正确 rollout 的数量也不少
  - Summary 模型真正发挥的地方，有一定能力的 Summary 模型可以找到正确解
- 极少部分正确：模型给出的结果大多都错误，投票几乎不可能得到正确解
  - Summary 也难以得到正确解
  - 这类 Query 有望通过 RL 来改善其回答？

OpenRouter

OpenRouter 是 2023 年初成立于美国纽约的 AI 基础设施公司，核心是AI 模型聚合与智能路由平台
OpenRouter 接入了大部分主流 AI 模型（25 年已经超 450 个），涵盖 OpenAI、Anthropic、Google 等头部厂商及 DeepSeek、Qwen 等开源模型，用户凭一个 API Key 就能调用所有模型，还能切换使用自有密钥或平台密钥
- OpenRouter 会依据价格、时延等 300+ 指标智能调度请求，50 毫秒内即可完成故障模型的备用切换
OpenRouter 提供透明的阶梯计费与详细使用报告，支持国内支付，还包含交互式游乐场方便测试模型；
OpenRouter 默认不存储用户数据，企业用户可启用零数据留存策略保障隐私，同时兼容 OpenAI SDK 及 Coze、LangChain 等多款工具，集成门槛低

Claude Code

Claude Code 是 Anthropic 公司（OpenAI 前员工创立）为 Claude 大模型打造的代码专属能力模块 ，本质是 Claude 大模型针对编程场景的优化版本，而非独立工具
Claude Code 提供代码全流程支持：覆盖代码生成、调试、重构、注释、性能优化、多语言迁移（如 Python 转 Go、Java 转 Dart），还能理解复杂业务逻辑并生成符合工程规范的代码；
Claude Code 支持超长上下文窗口（Claude 3 系列可达 200k+ tokens），能处理数万行代码的完整项目，理解跨文件依赖和架构逻辑；
Claude Code 支持主流编程语言（Python、Java、JavaScript/TypeScript、Go、Rust、Dart/Flutter 等），且能解释代码逻辑、排查 Bug；
Claude Code 支持自然语言对话式编程，可根据开发者的模糊需求逐步细化代码，还能针对代码问题给出详细的错误分析和修复方案
Claude Code 适用于快速编写业务代码、重构老旧项目、排查复杂代码 Bug、生成技术文档、辅助学习编程

Terminus

Terminus 主流释义：开源跨平台终端模拟器（Terminus Terminal），定制化、高效的命令行操作环境
Terminus 是一款 现代化、高度可定制的开源终端工具 ，替代传统的 Windows CMD、macOS Terminal、Linux xterm 等，定位是“开发者友好的终端模拟器 + SSH 客户端”
Terminus 核心特点是跨平台：支持 Windows、macOS、Linux，统一多系统终端体验；
Terminus 内置 SSH/SFTP 客户端、Zsh/Bash 集成、插件系统（如代码高亮、自动补全）；
Terminus 轻量且响应快，支持 GPU 渲染，适配高分屏（4K）
Terminus 适用于开发者日常命令行操作、远程服务器 SSH 连接、多终端会话管理、自定义开发环境终端

Flutter

Flutter 是 Google 推出的跨平台 UI 开发框架 ，核心定位是帮助开发者用一套代码构建高性能、高保真的移动/桌面/网页应用，彻底打破“多端多代码”的传统开发模式
注：Dart 是由 Google 主导开发的、开源的强类型编程语言，首次发布于 2011 年，设计目标是兼顾前端（跨平台 UI）、后端、命令行等多场景开发，核心定位是「面向多平台的现代化编程语言」，也是 Flutter 框架的唯一开发语言
Flutter 有跨平台能力：一套代码多端运行，提升开发效率
- 一套 Dart 代码可编译为 iOS、Android、Windows、macOS、Linux、Web 甚至嵌入式设备的原生应用，无需为不同平台单独适配核心逻辑；
Flutter 适用于典型应用场景：移动应用开发（如闲鱼、腾讯视频、字节跳动部分产品）、跨端桌面应用、轻量级 Web 应用
Flutter 可以和 Terminus 搭配使用：
- 用 Terminus 执行 Flutter 命令行开发
Flutter 可以和 Claude Code 搭配使用：
- 借助 Claude Code 生成/调试 Flutter 代码

Interleaved Thinking

vLLM 给出的定义：Interleaved Thinking
MiniMax-M2 就是一个 Interleaved Thinking 模型：huggingface.co/MiniMaxAI/MiniMax-M2
Interleaved Thinking 指模型在工具调用之间进行推理（Reason），允许模型在接受工具调用结果后，更加精细的决策
GLM-5：

Interleaved Thinking：模型在每次响应和工具调用前进行思考，提高了指令跟随能力和生成质量
Interleaved Thinking 会增加 Token 使用和响应时长
Interleaved Thinking 目前已经是 vLLM 的内嵌支持了
- 截止到 20251207日，支持 Kimi-K2 和 MiniMax-M2 两个模型

使用方式：在 messages 的 "assistant" role 中加入 "reasoning" 字段

messages.append(
	{
		"role": "assistant",
		"tool_calls": response.choices[0].message.tool_calls,
		"reasoning": response.choices[0].message.reasoning, # append reasoning
	}
)

更多详情参考：(vLLM)Interleaved Thinking

Tool‑Integrated Reasoning（TIR）

TIR，即 Tool‑Integrated Reasoning（工具集成推理） ，是让模型在推理流程中调用外部工具（如代码解释器、计算器、搜索引擎）来提升复杂任务解决能力的范式
- 如：推理到一半，模型觉得需要调用 Python 角度验证一下自己的推理数字是否准确，就可以调用（需要在训练时提供环境）
- 注：可多次调用外部工具，多次验证
- 思考格式：LLM 思考 -> LLM 判断是否调用工具 -> LLM 生成调用指令 -> 沙盒上完成工具执行 -> 整合结果到 Prompt 上 -> LLM 继续推理 -> 终止
  - 对 LLM 子集来说是多轮数据，但和人类没有交互，仅仅是和环境交互
- 数据格式：<Query> -> <思考> -> <工具调用> -> <观察> -> <答案>
TIR 允许模型在推理中动态调用工具，将自然语言推理与外部计算能力结合，解决纯文本模型难以处理的计算密集、知识依赖或精确性要求高的问题（如数学推理、数据验证、复杂规划）
TIR 的核心价值在于严格扩展模型的有效解空间，让原本不可行的推理路径变得可行
TIR 的形式化表示：多轮 TIR 的推理轨迹可形式化为迭代序列：
$$\tau = \mathcal{A}_1 \oplus \mathcal{A}_2 \oplus \cdots \oplus \mathcal{A}_N$$
- 其中每一步动作 $\mathcal{A}_k = \langle s_k, t_k, o_k \rangle$ 包含：
  - $s_k$：自然语言推理片段（思考过程）
  - $t_k$：工具调用指令（工具名+参数）
  - $o_k$：工具返回的输出结果
TIR 的关键挑战是多轮交互中的分布偏移导致训练不稳定、工具反馈污染上下文、轮次增多时推理漂移
TIR 典型应用场景如数学解题（代码执行验算）、数据处理（表格分析）、复杂决策（多工具组合调用）等
TIR 与 Interval Thinking 的区别：
- Tool-Integrated Reasoning 是 “模型使用外部工具解决问题” 的能力范式
- Interleaved Thinking 是 “思考与行动交替展开” 的多步推理结构
- Tool-Integrated Reasoning 强调工具，Interleaved Thinking 强调过程结构
- 多轮工具推理通常同时属于两者，但两者独立可分
- 总结1：Interleaved Thinking 是 Tool-Integrated Reasoning 的最常用结构（即 Tool-Integrated Reasoning 通常通过 Interleaved Thinking 结构来实现）
  - 几乎所有 TIR 论文都用 interleaved 格式：Think -> Tool -> Observation -> Think -> Tool -> Observation
- 注：Tool-Integrated Reasoning 常常表现为 Interleaved Thinking，但 Interleaved Thinking 不一定是 Tool-Integrated Reasoning
TIR 的应用场景包括用 Python 辅助解决数学问题等，广义的 TIR 一般表示允许模型在推理过程中自主判断是否调用工具（外部计算工具主要是 Python 环境），实现显示计算、验证一些可通过代码验证的问题，增强推理过程

AnyCoder

AnyCoder 是一款部署在 Hugging Face Spaces 上的开源 AI 编程辅助 Web 应用 ，由 Hugging Face 机器学习增长负责人Ahsen Khaliq（@akhaliq）开发维护，其核心定位是“直觉式编程工具（Intuitive Programming Tool）”，
AnyCoder 工具主打无需深厚编程基础，就能通过自然语言描述或多模态输入快速生成可运行的代码，尤其聚焦前端开发场景
- 它既可为新手开发者降低编程门槛，也能帮助专业开发者提升开发效率，同时可作为 Lovable 等同类直觉式编程服务的替代方案
AnyCoder 完全基于 Hugging Face 的开源 Python 开发环境 Gradio 构建，同时提供两个版本适配不同需求：
- 一是功能完整的 Python 版本，支持 OCR 处理、PDF 和 docx 文档解析等高级能力；
- 二是轻量化的 TypeScript 版本，聚焦核心 AI 代码生成功能，启动速度更快，移动端体验更优

GSM-style

GSM-style 推理任务核心是仿照 GSM8K（Grade School Math 8K）基准设计的多步骤小学数学文字题推理任务，核心考察 LLM 的分步算术推理与逻辑推导能力，需模型输出完整解题思路而非仅答案

“氛围测试”（Vibe-tests/Vibe-checks）

在人工智能和 LLM 的语境下，“氛围测试”（Vibe-tests）或“氛围检查”（Vibe-checks）是一种 基于人类直觉、主观感受和非正式交互的评估方法
Vibe-tests 与传统的、基于严格指标（如准确率、BLEU 分数、MMLU 基准测试）的评估方式不同
Vibe-tests 是指开发者或用户通过与模型对话，凭“感觉”来判断模型够不够聪明、回答是否得体、或者生成的应用是否符合预期
- 一般指在模型发布前或开发过程中，由开发者、研究人员或社区成员对模型进行的手动、非正式评估
Vibe-tests 让我可可以从“看跑分”到“看感觉”
- 主观性：不依赖预定义的测试集，而是依赖评估者对模型输出质量的“主观印象”
- 整体性：不仅仅关注答案的对错，更关注模型的语气、安全性、拒绝回答的边界（是否过于敏感）、逻辑流畅度以及是否“像人一样思考”
术语来源：似乎与“氛围编程”（Vibe Coding）有关
- OpenAI 联合创始人 Andrej Karpathy 在 2025 年初推广了 “Vibe Coding” 的概念，即通过自然语言提示让 AI 生成代码，人类主要负责审查和确认
- “Vibe-tests 指人类在验收这些 AI 生成的成果时，主要检查其功能和交互体验是否符合“预期的氛围”或直觉，而不是逐行检查代码逻辑
特点：
- 速度快，随时可测，但无法批量化
- 真实，细微，但包含主观感受
- 避免大模型在公开的学术基准（Benchmarks）上都能拿到高分，但在实际使用中却可能表现出“高分低能”
  - 例如，模型可能通过了逻辑测试，但在聊天时显得生硬、机械或充满偏见
- 可以进行难以量化的体验
  - 很多用户体验指标（如幽默感、情商、创造力、语气的恰当性）是很难用数学公式量化的，只能靠人的“Vibe”（直觉/氛围）来感知
表现形式：
- Sanity Check（健全性检查）：开发者随便问模型几个刁钻的问题（例如弱智吧问题、陷阱题），看模型是否会“一本正经地胡说八道”
  - 如果模型能识破陷阱，通常被认为“Vibe”是对的
- 语气与风格审查：检查模型是否过于说教（Preachy），或者是否在不该拒绝的时候拒绝用户（False Refusal）
  - 例如，用户让模型写个恐怖故事，模型却因为“安全原因”拒绝，这会被认为“Vibe check failed”（氛围检查不通过）
- 端到端体验：在 Agent 或长文本应用中，观察模型是否能长时间保持角色一致，或者是否能真正理解用户的意图而不仅仅是关键词匹配

TTS

TTS 有两个含义：
TTS 含义1：Test-Time Scaling，推理时扩展/测试时扩展
- 核心逻辑是：“让模型在回答问题前多思考一会儿，表现会更好”
- 传统上，通过增加训练数据和参数量（训练时扩展）来提升模型能力，而 Test-Time Scaling 发现，在推理阶段给模型分配更多的计算资源（Compute），也能显著提升逻辑推理、数学和编程能力
TTS 含义2：Text-To-Speech，语音合成 / 文本转语音

slop score

在 AI/LLM 领域（slop score），slop score 可用于量化低质量 AI 生成文本（俗称 “slop”）的指标，衡量文本的结构冗余、语义空洞、重复模式等负面特征，反映输出质量的劣化程度
- 注：slop 本意有“泔脚水；淡而无味的半流质食物；脏水” 的含义
slop score 可用于评估模型生成文本的 “slop” 占比，指导模型优化（如 Antislop 框架）以减少低质输出

CUA

- 在大模型领域，CUA 是 Computer-Using Agent（计算机使用代理） 的简称
CUA 这一简称是 OpenAI 最早正式提出并定义的 ，该定义随 OpenAI 智能体产品 Operator 于 2025年1月23日的研究预览版一同发布，用于特指能通过 GUI 交互完成数字任务的核心模型
- 将 Operator 的核心驱动模型命名为 Computer-Using Agent，并缩写为 CUA，强调其融合 GPT-4o 视觉能力与强化学习推理能力的技术特性
- 融合多模态视觉能力与强化学习驱动的高级推理能力，可通过虚拟鼠标键盘与图形用户界面（GUI）交互，无需依赖特定 API 即可完成网页操作、表单填写等复杂数字任务
注：此前 Anthropic 等机构虽有计算机使用相关智能体研究，但未使用 CUA 这一缩写；

Skills

Skills 最早由 Anthropic 提出，也叫做 Claude Skills
Skills 本质属性是知识封装/流程规范/任务编排器，是“工作流说明书”，让 Claude 按特定流程、规范高效完成专业任务
Skills 可用于封装 SOP、模板、最佳实践，指导工具调用顺序与参数，定义输入输出格式
Claude Skills 是按需加载的，仅匹配任务时调用相关内容，节省 Token 且高效
Claude Skills 以 SKILL.md 为核心的文件夹，含 Markdown 文档、脚本、模板等，支持版本控制与分享
与 MCP 的区别和联系：
- Claude Skills 和 MCP（Model Context Protocol）核心区别在于定位与职责：
  - MCP 是连接大模型与外部工具/数据源的标准化接口协议，解决“怎么连”的问题，更像是菜谱（规定步骤与标准）、施工蓝图
  - Skills 是封装工作流、规范与最佳实践的任务执行模块，解决“怎么做”的问题，更像是厨房设备（提供工具与连接能力）、施工设备与原材料
  - 注：二者常协同使用
- Skills 与 MCP 并非竞争，而是互补：
  - 1）Skills 可引用 MCP 配置的工具，定义调用逻辑与参数，让复杂任务流程化
  - 2）MCP 为 Skills 提供底层连接能力，保障外部工具的稳定、安全调用
  - 3）示例：“Notion 内容管理”Skill 定义搜索、创建页面的步骤，而 MCP 负责 Notion API 的认证、请求转发与结果返回

Reference

Skills 还可以通过 Reference 引用其他 Skills 文档，从而进行更进一步的封装，按需使用说明书
这种做法可以进一步减少复杂场景下的 Prompt 长度，从而节省 Token，也让模型的执行效率更高
比如：仅当用户要求计算房租/酒店价格时，再调用房租价格列表/酒店价格列表

Script

Skills 还可以通过调用其他 Script 执行任务
注意：Script 执行的任务非必要不会进入模型的上下文，所以很省 Token

MOPD

Multi-Teacher On-Policy Distillation (MOPD) 方法最早出自 MiMo 技术报告 MiMo-V2-Flash Technical Report, Xiaomi, 20260106

Rollout Routing Replay (R3)

Rollout Routing Replay (R3) 的本质含义是在大模型的 RL 训练中，使用与 rollout 相同的路由专家进行 RL 训练，通过优化的数据类型和通信重叠使其开销可忽略不计

span-level 重复率

在 LLM 的训练、数据清洗和效果评估中，样本 span-level 的重复率 是针对 文本片段（span） 维度的重复度量
span-level 重复率的核心是跳出 整句/整样本是否重复 的粗粒度判断，聚焦 文本中连续/离散的子片段 的重复情况，是衡量数据质量、模型生成冗余性的关键细粒度指标
span-level 重复率也是 LLM 领域解决训练数据过拟合、生成文本重复/赘余问题的核心观测维度
span 的定义：
- span 就是文本中任意长度的连续字符/词/子句片段，span-level 重复率就是统计这些片段在数据集（或模型生成结果）中重复出现的概率/比例
- 区别于样本级重复率（整样本完全重复）和 token-level 重复率（单个词/字的重复），是介于两者之间的中粒度、更贴近语义的重复度量

Self-Consistency

Self-Consistency（自洽性） 是 LLM 推理的一种解码策略 ，核心是：对同一问题生成多条不同推理路径，再通过“多数投票”选出最一致的答案 ，从而提升复杂推理的准确性与鲁棒性
Self-Consistency 建立在 Chain-of-Thought（CoT，思维链） 之上，解决的是：
- 传统 CoT 只用单一贪心解码（temperature=0），容易陷入局部最优、受随机噪声影响，导致推理错误
- 复杂问题通常有多条合理路径通向正确答案 ，而错误答案往往路径单一、不一致
基本思想：多路径采样 + 一致性投票 = 更可靠的推理
Self-Consistency 解码的标准流程：
- 1）CoT 提示 ：给模型带推理步骤的 prompt，引导它“一步步想”
- 2）多路径采样 ：用 temperature>0、top-k/top-p 等采样方式，生成 N 条不同推理链（比如 5/10/20 条）
- 3）结果聚合 ：提取每条链的最终答案，做多数投票（或加权、边际化）
- 4）输出最优解 ：把得票最高的答案作为最终结果

Adaptive KL Controller（Dynamic KL Coef）

原始论文：Fine-Tuning Language Models from Human Preferences, 20200108, OpenAI
注：原文没有给确定性名字，称为 Dynamic vary KL Coef，部分博客或者实现会叫做 Adaptive KL Controller、 Adaptive KL Scheduler 或者 Dynamic KL Scheduler 等
提出背景：作者发现，在固定的 KL Penalty 系数 $\beta$ 下，使用不同的随机种子训练模型有时候会导致模型的 KL 散度值 $\text{KL}(\pi_t, \rho)$ 会因为随机种子不同而有显著差异
- KL 值直接影响生成质量，不同 KL 的模型无法公平对比任务性能，干扰实验结论
解决方案：设定一个目标 KL 值 $KL_{target}$，动态调整$\beta$的核心目标是：让 $KL(\pi, \rho)$ 稳定收敛到预设目标值 $KL_{target}$
- 具体做法：若当前 KL 值大于目标值时，尽量降低 KL 值，反之提升 KL 值（保持在目标附近）
- 考虑到下面的规律：
  - $\beta$ 越大，KL 惩罚越强，微调策略 $\pi$ 越接近预训练模型 $\rho$，生成文本自然度高但任务性能可能不足；
  - $\beta$ 越小，KL 惩罚越弱，$\pi$ 越自由优化奖励模型 $r$，任务性能可能提升但易出现文本漂移、不连贯的问题
- 基于 类似 PID 的思路 对 KL Penalty 系数 $\beta$ 进行动态调整
优点：
- 稳定 KL 约束 ：确保不同实验、不同任务中，$KL(\pi, \rho)$ 始终围绕 $KL_{target}$ 波动，避免模型漂移或过度保守；
- 简化调参流程 ：无需手动测试多个 $\beta$ 值，仅需设定合理的 $KL_{target}$ 即可；
- 提升模型可比性 ：所有实验在统一的 KL 约束下进行，任务性能差异仅源于模型本身，而非 KL 散度的波动
实际使用中遇到的难点：
- KL 散度的目标值 $KL_{target}$ 很难设计
- 一般来说 KL Coef 设置多少合适？根据不同场景会有不同，VeRL 中许多默认值使用的 0.1

动态调整 $\beta$ 公式细节

论文中采用对数空间比例控制器 ，通过实时计算 KL 误差来迭代更新$\beta$，公式分为两步
第一步：计算 KL 误差项$e_t$
$$ e_t = \text{clip}\left( \frac{KL(\pi_t, \rho) - KL_{target} }{KL_{target} }, -0.2, 0.2 \right) $$
- $KL(\pi_t, \rho)$：$t$ 时刻策略 $\pi_t$ 与预训练模型 $\rho$ 的 KL 散度
- $KL_{target}$：预设的目标 KL 值
- $\text{clip}(\cdot, -0.2, 0.2)$：将误差截断在 $[-0.2, 0.2]$ 区间，避免极端误差导致 $\beta$ 突变
- 理解：
  - 若 $KL(\pi_t, \rho) > KL_{target}$，则 $e_t > 0$，说明当前 KL 过大，需增大 $\beta$ 增强惩罚
  - 若 $KL(\pi_t, \rho) < KL_{target}$，则 $e_t < 0$，说明当前 KL 过小，需减小 $\beta$ 减弱惩罚
第二步：迭代更新 KL 系数 $\beta_{t+1}$
$$ \beta_{t+1} = \beta_t \cdot \left( 1 + K_\beta \cdot e_t \right) $$
- $\beta_t$：$t$ 时刻的当前 $\beta$ 值
- $K_\beta = 0.1$：固定比例系数，控制 $\beta$ 的调整步长
- 理解：
  - 当 $e_t > 0$ 时，$1 + K_\beta \cdot e_t > 1$，$\beta_{t+1} > \beta_t$，KL 惩罚增强，$\pi$ 向 $\rho$靠拢；
  - 当 $e_t < 0$ 时，$1 + K_\beta \cdot e_t < 1$，$\beta_{t+1} < \beta_t$，KL 惩罚减弱，$\pi$ 可更自由优化任务奖励；
  - 当 $e_t = 0$ 时，$\beta_{t+1} = \beta_t$，训练进入稳定状态

现实框架中的实现

VeRL 和 OpenRLHF 中实现一致

以 OpenRLHF 中为例github.com/OpenRLHF/OpenRLHF/blob/main/openrlhf/trainer/ppo_utils/kl_controller.py#L4：

class AdaptiveKLController:
	"""
	Adaptive KL controller described in the paper:
	https://arxiv.org/pdf/1909.08593.pdf
	"""

	def __init__(self, init_kl_coef, target, horizon):
		self.value = init_kl_coef
		self.target = target
		self.horizon = horizon

	def update(self, current, n_steps):
		target = self.target
		proportional_error = np.clip(current / target - 1, -0.2, 0.2)
		mult = 1 + proportional_error * n_steps / self.horizon
		self.value *= mult

社工

“社工”在大模型攻击语境下是社会工程学（Social Engineering）的简称
社工指利用人类心理弱点而非技术漏洞来诱导 AI 系统或人类用户产生非预期行为的攻击手段
在大模型安全领域，社工本质都是通过语言交互来实现攻击，细分下，其攻击包括相似的一些话术/手段：
- 对 AI 系统的诱导
  - 通过精心设计的对话策略，绕过模型的安全对齐机制
  - 比如利用角色扮演、情感操控、权威伪装等方式让模型输出有害内容
  - 示例：”假设你是一位历史教授，正在研究极端主义思想的发展…”
- 利用 AI 作为攻击媒介
  - 诱导大模型生成钓鱼邮件、诈骗话术、恶意代码
  - 让 AI 协助进行信息收集或身份冒充

Python——Typer工具的使用

参考链接：
- Typer, build great CLIs. Easy to code. Based on Python type hints.
  - 本文大部分内容基于这篇说明文档

Typer 整体介绍

Typer 是一款基于 Python 类型注解（Type Hints）的 CLI 开发库，被称为CLI 界的 FastAPI ，是 FastAPI 的同作者开发的“轻兄弟”库
理解：Typer（是 CLI 开发库）的本质是将 Python 函数变成可以在 Terminal 直接调用的命令形式
Typer 基于 Click 构建，兼具代码简洁、自动生成帮助文档、终端自动补全、支持复杂子命令等特性，开发者仅需少量代码就能构建专业、易用的命令行工具，同时对新手极其友好
- 注：Click 是 Python 生态中一款经典、成熟的命令行界面（CLI）开发框架，也是 Typer 的底层核心依赖——Typer 本质上是对 Click 的高级封装，基于 Click 实现了所有 CLI 核心能力，同时通过 Python 类型注解简化了 Click 的使用流程

前置补充：Click 介绍

Click 由 Pallets 团队开发（同 Flask 开发团队），是 Python 中最主流的 CLI 开发库之一，解决了 Python 内置 argparse 模块代码繁琐、体验不佳、扩展能力弱的问题，核心优势是：
- 基于装饰器实现简洁的命令 / 参数定义
- 原生支持子命令、选项 / 参数解析、终端补全
- 兼容所有主流终端，支持跨平台（Windows/Linux/macOS）
- 提供丰富的扩展能力（如进度条、密码输入、颜色输出）

Typer 核心优势

基于 Python 原生类型注解，无需学习新语法，少量代码即可实现 CLI 功能
自动生成 --help 帮助文档、终端自动补全（支持 Bash/Zsh/Fish/PowerShell），bool 类型参数自动生成 --xxx/--no-xxx 双选项
可灵活扩展，从简单单命令到多层嵌套子命令，可随项目复杂度无缝升级
无缝兼容 Python 代码，无需修改现有 Python 脚本，直接通过 typer 命令将普通函数转为 CLI 工具
内置美观的错误提示（基于 Rich）、进度条、彩色输出，提升用户使用体验

Typer 安装

Typer 支持 Python 3.6+，推荐在虚拟环境中安装，执行以下命令即可：
1
pip install typer
安装完成后会自动附带三个核心依赖：
- Click ：Python 经典 CLI 框架，Typer 的底层基础
- Rich ：实现美观的格式化输出、彩色错误提示
- shellingham ：自动检测当前终端类型，支持自动补全安装

Typer 使用简单示例

Typer 的使用分为无侵入式运行普通脚本 和显式使用 Typer 开发 两种方式，先从最简单的无侵入式开始
示例来自：

无侵入式：普通脚本直接转 CLI

无需在代码中引入 Typer，直接将普通带类型注解的 Python 函数转为 CLI 工具

Step 1，创建 main.py，编写普通函数：

1
2
3

# 仅需普通Python代码+类型注解，无Typer相关代码
def main(name: str):
    print(f"Hello {name}!")

Step 2，通过 typer 命令运行：

# 查看帮助
typer main.py run --help
# 传入参数运行
typer main.py run 张三

Step 3，效果：自动识别 name 为必填字符串参数，缺失时会抛出美观的错误提示，无需手动处理参数解析

显式使用（入侵式）：引入 Typer 开发

在代码中引入 Typer，可直接通过 python 命令运行，更适合正式开发

修改 main.py，仅需2行新增代码（导入+运行）：

import typer  # 新增：导入Typer

def main(name: str):
    print(f"Hello {name}!")

if __name__ == "__main__":
    typer.run(main)  # 新增：运行Typer应用

直接通过 Python 运行，体验与原生 CLI 工具一致：

# 查看帮助
python main.py --help
# 传入参数运行
python main.py 张三

Typer 进阶用法：多子命令开发

当 CLI 工具需要多个功能时，Typer 支持通过 @app.command() 装饰器创建子命令 ，类似 Git 的 git add/git commit 模式，结构清晰

基础多子命令代码示例

创建包含 hello（问候）和 goodbye（告别）两个子命令的工具，goodbye 新增布尔可选参数 formal（正式模式）：

import typer

# 1. 创建Typer应用实例，作为CLI入口
app = typer.Typer()

# 2. 用@app.command()装饰函数，转为子命令
@app.command()
def hello(name: str):
    """子命令：普通问候"""
    print(f"Hello {name}!")

@app.command()
def goodbye(name: str, formal: bool = False):
    """子命令：告别，--formal 开启正式模式"""
    if formal:
        print(f"Goodbye Ms. {name}. Have a good day!")
    else:
        print(f"Bye {name}!")

# 3. 运行应用
if __name__ == "__main__":
    app()

基础多子命令运行与使用示例

查看全局帮助（显示所有子命令）：
1
python main.py --help
- 会自动列出 hello、goodbye 两个子命令，以及 --install-completion（安装终端补全）等全局选项

查看子命令帮助：

1 2	# 查看goodbye子命令的帮助，会显示--formal/--no-formal选项 python main.py goodbye --help

执行子命令：

# 普通告别
python main.py goodbye 张三
# 正式模式告别（bool参数自动生成--formal选项）
python main.py goodbye --formal 张三

基础多子命令示例关键特性说明

布尔参数自动优化 ：定义 formal: bool = False 后，Typer 会自动生成 --formal（开启）和 --no-formal（关闭）两个选项，无需手动配置
帮助文档自动生成 ：函数的文档字符串（"""注释"""）会自动作为子命令的帮助说明，--help 中直接显示
命令名省略规则 ：仅单个命令时，可直接 python main.py 参数；多个子命令时，必须显式指定子命令名（如 python main.py hello 张三）

Typer 核心语法：参数定义

Typer 完全基于Python 原生类型注解 定义 CLI 参数，无需学习额外的装饰器或语法，支持所有常见类型

基础类型参数

直接通过类型注解定义，Typer 自动解析为 CLI 位置参数/选项：

@app.command()
def demo(
    # 必填字符串参数（位置参数）
    name: str,
    # 可选整数参数，默认值10（选项参数）
    age: int = 10,
    # 布尔参数，默认False（自动生成--is-adult/--no-is-adult）
    is_adult: bool = False
):
    # 推荐使用 `typer.echo()` 替代 `print()`，支持彩色输出、跨终端兼容
    typer.echo(f"姓名：{name}，年龄：{age}，是否成年：{is_adult}")

常用参数类型

除基础类型外，Typer 还支持以下常用类型，直接注解即可：
- 列表：List[str]，接收多个参数
- 路径：Path，自动校验文件/目录是否存在
- 枚举：Enum，实现参数可选值限制
- 文件：typer.File()，直接读取文件对象

示例（枚举+列表）：

from typing import List
from enum import Enum
import typer

# 枚举：限制gender的可选值
class Gender(str, Enum):
    MALE = "male"
    FEMALE = "female"

@app.command()
def user(
    name: str,
    gender: Gender,  # 仅能传入male/female
    hobbies: List[str] = None  # 接收多个爱好，如--hobbies 篮球 读书
):
    typer.echo(f"姓名：{name}，性别：{gender}，爱好：{hobbies}")

Typer 高级功能：子命令组与全局配置

当 CLI 工具功能复杂时，可创建子命令组（如按模块拆分：db backup/db restore），并通过 @app.callback() 实现全局配置（如环境、全局参数）

Typer 子命令组示例（数据库工具）

示例代码

import typer

# 全局应用入口
app = typer.Typer(help="多功能CLI工具")

# 创建子命令组：db（数据库相关操作）
db_app = typer.Typer(help="数据库操作子命令组")
# 将子命令组添加到全局应用，命令名为db
app.add_typer(db_app, name="db")

# db子命令组下的子命令：backup（备份）
@db_app.command()
def backup(path: str = "./backup.db"):
    typer.echo(f"正在备份数据库到：{path}")

# db子命令组下的子命令：restore（恢复）
@db_app.command()
def restore(path: str = "./backup.db"):
    typer.echo(f"正在从{path}恢复数据库")

# 全局子命令：无归属，直接在根目录
@app.command()
def version():
    typer.echo("CLI工具版本：v1.0.0")

if __name__ == "__main__":
    app()

运行：

# 查看数据库子命令组帮助
python main.py db --help
# 执行数据库备份
python main.py db backup --path D:/mydb.db
# 执行全局版本命令
python main.py version

Typer 全局配置（@app.callback()）

通过 @app.callback() 定义全局参数（如运行环境 env），所有子命令均可共享：

import typer
from typer import Context

app = typer.Typer(help="带全局配置的CLI工具")

# 全局回调：定义全局参数，所有子命令生效，所有子命令执行前，都会先执行这个函数
@app.callback()
def global_config(ctx: Context, env: str = typer.Option("dev", help="运行环境：dev/prod/test")):
    # 将全局参数存入ctx，供子命令获取
    ctx.ensure_object(dict)
    ctx.obj["env"] = env # 注：所有子命令的 ctx 对象都可以传入 env 参数，并可通过 ctx.obj["env"] 获取到 env

@app.command()
def run(ctx: Context):
    # 获取全局配置的env
    env = ctx.obj["env"]
    typer.echo(f"在{env}环境中运行程序...")

if __name__ == "__main__":
    app()

运行：

# 用默认dev环境运行
python main.py run
# 指定prod环境运行
python main.py run --env prod

Typer 实用功能：终端补全与进度条

安装终端自动补全

Typer 支持一键安装终端自动补全，输入以下命令后按提示操作即可：
1
python main.py --install-completion
- 支持 Bash、Zsh、Fish、PowerShell 等主流终端，安装后输入命令时按 Tab 即可自动补全子命令和参数

内置进度条

处理耗时操作（如下载、批量处理）时，Typer 内置进度条功能，无需额外安装库，一行代码实现：

import typer
import time

app = typer.Typer()

@app.command()
def download(total: int = 10):
    """模拟下载，显示进度条"""
    # 用 typer.progressbar 创建进度条
    with typer.progressbar(range(total), label="下载中") as progress:
        for i in progress:
            time.sleep(0.5)  # 模拟耗时操作
    typer.echo("下载完成！")

if __name__ == "__main__":
    app()

Python——Ray-远程函数与本地函数的区别

整体说明

远程函数与本地函数的区别主要在 序列化机制 和 执行位置 两个维度
序列化本质差异：
- 本地函数是“传引用”，依赖执行环境已有定义；
- Ray 远程函数是“传定义+环境”，集群自动同步，支持跨节点；
执行位置差异：
- 本地函数固定在调用方进程，无分布式能力；
- Ray 远程函数由集群调度，可分布式并发执行；
使用场景：
- 本地函数：适用于单进程/单节点的简单逻辑，无需分布式；
- Ray 远程函数：适用于分布式计算、并发任务、跨节点执行，是 Ray 分布式能力的核心

核心差异总览

对比维度	本地函数（未用 `@ray.remote` 装饰）	Ray 远程函数（用 `@ray.remote` 装饰）
序列化方式	依赖 Python 原生 `pickle`，仅序列化「函数引用」	Ray 自定义序列化（结合 `pickle`+集群元数据），序列化「函数元信息+代码定义」
序列化限制	无法跨节点传递（远程节点无函数定义，引用失效）	可跨节点传递（集群自动同步函数定义到执行节点）
执行位置	固定在「调用方所在的本地进程/线程」	分布式调度到「集群任意节点的 Worker 进程」（可指定资源）
执行特性	同步执行，阻塞调用方；无并发调度能力	异步执行，返回 `ObjectRef`；支持集群级并发/分布式调度
依赖传递	需手动确保执行环境有函数依赖（如导入、变量）	Ray 自动打包函数依赖（如嵌套函数、闭包变量）并分发

序列化机制：“仅传引用” vs “传定义+元信息”

序列化的核心目的是：让函数能在「非定义环境」中被正确执行
两者的序列化逻辑完全不同：

本地函数：仅序列化“函数引用”，无实际代码

Python 原生 pickle 序列化本地函数时，不会打包函数的代码本身 ，只会记录函数的「模块路径+函数名」（比如 __main__.add）
这种“引用式序列化”仅在「同一进程/同一节点且函数已定义」的场景下有效，跨节点会直接失效

错误示例：

import ray

ray.init(ignore_reinit_error=True)

# 本地函数
def add_remote(a, b):
    return a + b

# 直接传递远程函数的引用（Ray 自动处理序列化）
@ray.remote
def execute_remote_func(func, x, y):
    return func(x,y)  # 远程工作进程无法识别调用方的 local func，错误

# 跨节点调度执行（单节点可以成功，但集群有多个节点会失败）
result_ref = execute_remote_func.remote(add_remote, 2, 3)
print(ray.get(result_ref))  # 单节点输出：5（成功执行）；多节点执行错误

ray.shutdown()

Ray 远程函数：序列化“函数元信息+代码定义”

Ray 对远程函数的序列化做了增强：
- 1）序列化时，不仅记录函数引用，还会打包函数的代码定义、依赖模块、闭包变量（若有）；
- 2）远程节点接收后，会自动还原函数的执行环境（无需手动导入）；
- 3）底层用 Ray 自定义的序列化器（兼容 pickle，但更适合分布式场景）

正确示例：远程函数跨节点调用成功

import ray

ray.init(ignore_reinit_error=True)

# Ray 远程函数（已注册，自动序列化代码）
@ray.remote
def add_remote(a, b):
    return a + b

# 直接传递远程函数的引用（Ray 自动处理序列化）
@ray.remote
def execute_remote_func(func, x, y):
    return ray.get(func.remote(x, y))  # 远程节点能识别并执行

# 跨节点调度执行（即使集群有多个节点也能成功）
result_ref = execute_remote_func.remote(add_remote, 2, 3)
print(ray.get(result_ref))  # 输出：5（成功执行）

ray.shutdown()

补充：Ray 还支持嵌套远程函数闭包变量传递

比如在远程函数中引用本地变量，Ray 会自动序列化传递：

import ray

ray.init(ignore_reinit_error=True)

@ray.remote
def outer_remote(x):
    # 闭包变量 x 会被 Ray 自动序列化到远程节点
    @ray.remote
    def inner_remote(y):
        return x + y
    return inner_remote.remote(10)

print(ray.get(ray.get(outer_remote.remote(5))))  # 输出：15

ray.shutdown()

执行位置：“本地固定” vs “集群分布式调度”

执行位置的差异是两者最直观的区别，直接决定了是否能利用集群资源：

本地函数：执行在「调用方所在进程」

本地函数的执行位置完全固定：
- 无论在哪里调用（即使在远程函数内部调用本地函数），函数都会在「发起调用的进程」中执行【存疑】
  - 问题：会出错吧，理论上远程函数内部无法调用本地函数？
- 若在远程函数中调用本地函数，本质是在「远程节点的 Worker 进程」中执行，但该进程没有本地函数的定义（除非手动同步代码），所以必然失败；
- 无并发能力：多个调用会串行执行在同一个进程/线程（或 Python 多进程的子进程，但需手动管理）

远程函数：执行在「集群 Worker 进程」

Ray 远程函数的执行位置由 Ray 集群的调度器统一管理：
- 1）调用 func.remote() 时，会向 Ray 调度器提交一个任务
- 2）调度器根据集群节点的资源（CPU、GPU、内存）情况，将任务分配到任意可用节点的 Worker 进程
- 3）执行完成后，结果会存储在 Ray 的对象存储中，通过 ray.get() 可获取
- 4）支持并发：多个 remote() 调用会被调度到不同 Worker 进程/节点，并行执行

示例：远程函数分布式执行（多节点/多进程并发）

import ray
import os
import time

# os.environ["RAY_DEDUP_LOGS"] = "0" # 本意是让每个进程结果都完整输出，但这行代码仅当前进程生效，需要启动前环境变量才可以
ray.init(ignore_reinit_error=True)

# Ray 远程函数：打印执行节点的进程 ID 和节点名
@ray.remote
def add_remote(a, b):
    node_name = ray.util.get_node_ip_address()  # 获取执行节点 IP
    pid = os.getpid()  # 获取执行进程 ID
    print(f"在节点 {node_name} 的进程 {pid} 执行 add({a}, {b})")
    time.sleep(1)  # 模拟耗时操作
    return a + b

# 提交 5 个并发任务（会被调度到不同 Worker 进程）
start = time.time()
result_refs = [add_remote.remote(i, i*2) for i in range(5)]
results = ray.get(result_refs)  # 等待所有任务完成
end = time.time()

print("结果:", results)  # 输出：[0, 3, 6, 9, 12]
print(f"总耗时: {end - start:.2f}s")  # 约 1s（并发执行，而非 5s 串行）

ray.shutdown()

执行上述脚本：
1
2
export RAY_DEDUP_LOGS=0
python demo.py
- 注意：仅在代码里面添加 os.environ["RAY_DEDUP_LOGS"] = "0" 是不够的，因为：
  - Ray 的日志去重功能是在 Worker 进程启动时就决定的，而 Worker 是由 Ray 的主进程（Driver）启动的
  - 上面的代码在 ray.init() 之后才启动 Worker，那么环境变量必须在 Driver 启动 Worker 之前就传递过去，否则 Worker 进程会继承默认的去重配置
  - 所以最安全的打印所有日志的方式就是再启动脚本前配置环境变量
- 另一种实现方式是在远程函数中返回 PID，然后由 Driver 打印

输出示例：

2025-11-04 11:42:43,175 INFO worker.py:1918 -- Started a local Ray instance. View the dashboard at 127.0.0.1:8265 
(add_remote pid=14393) 在节点 127.0.0.1 的进程 14393 执行 add(2, 4)
(add_remote pid=14399) 在节点 127.0.0.1 的进程 14399 执行 add(4, 8)
(add_remote pid=14398) 在节点 127.0.0.1 的进程 14398 执行 add(1, 2)
(add_remote pid=14400) 在节点 127.0.0.1 的进程 14400 执行 add(3, 6)
(add_remote pid=14396) 在节点 127.0.0.1 的进程 14396 执行 add(0, 0)
结果: [0, 3, 6, 9, 12]
总耗时: 1.62s

Math——f-divergence

f-divergence定义

$ f $-散度（$ f $-divergence）是概率论和信息论中的一种概念，用于衡量两个概率分布之间的差异
形式上，对于两个概率分布 $ P $ 和 $ Q $，定义在一个共同的样本空间上， $ f $-散度可以被定义为：
$$ D_f(P|Q) = \int_{\Omega} q(x) f\left(\frac{p(x)}{q(x)}\right) dx $$
- $ \Omega $ 是样本空间
- $ p(x) $ 和 $ q(x) $ 分别是 $ P $ 和 $ Q $ 的概率密度函数
- $ f $ 是一个凸函数，满足 $ f(1) = 0 $，这是为了保证当 $ P = Q $ 时 $ D_f(P|Q) = 0 $
$ f $-散度的一个重要性质是它是非负的，即 $ D_f(P|Q) \geq 0 $，并且只有当 $ P = Q $ 时等号成立。这意味着 $ f $-散度可以作为两个概率分布之间距离的一种度量，尽管它不满足距离的所有公理（比如对称性）

常见的f-divergence例子

Kullback-Leibler散度 (KL散度)，其中 $ f(u) = u \log u $
- 注意带入以后可以消去分母得到KL散度的最终公式
Hellinger距离，这里 $ f(u) = (\sqrt{u} - 1)^2 $
总变差距离，此时 $ f(u) = |u - 1| $
χ²散度，使用 $ f(u) = \frac{(u - 1)^2}{u} $

附录：KL散度的非负性证明

核心，利用Jensen不等式证明 Kullback-Leibler（KL）散度是非负的
对于两个概率分布 $ P $ 和 $ Q $ 在同一空间 $ \mathcal{X} $ 上，KL 散度定义为：
$$
D_{\text{KL} }(P \parallel Q) = \sum_{x \in \mathcal{X} } P(x) \log \frac{P(x)}{Q(x)}
$$
- 注意 KL 散度的积分权重和分子是相同的（这是由其含义和非负性决定的，详情见附录），若对换分子分母，得到的是 KL 的负数值
对于连续变量，定义为：
$$
D_{\text{KL} }(P \parallel Q) = \int_{-\infty}^{\infty} p(x) \log \frac{p(x)}{q(x)} , dx
$$
- 其中 $ p(x) $ 和 $ q(x) $ 分别是 $ P $ 和 $ Q $ 的概率密度函数
进一步地，KL散度可以表示为：
$$
D_{\text{KL} }(P \parallel Q) = \mathbb{E}_{P} \left[ \log \frac{P(x)}{Q(x)} \right]
$$
- 即 $ \log \frac{P(x)}{Q(x)} $ 在分布 $ P $ 下的期望

应用Jensen不等式求负KL散度

由于 $ \log(x) $ 是一个凹函数（伞状），根据Jensen不等式，对于凹函数有：
$$
\mathbb{E}[\log X] \leq \log \mathbb{E}[X]
$$
- 令 $ X = \frac{Q(x)}{P(x)} $，则：
  $$
  \mathbb{E}_{P} \left[ \log \frac{Q(x)}{P(x)} \right] \leq \log \left( \mathbb{E}_{P} \left[ \frac{Q(x)}{P(x)} \right] \right)
  $$
计算期望：
$$
\mathbb{E}_{P} \left[ \frac{Q(x)}{P(x)} \right] = \sum_{x} P(x) \cdot \frac{Q(x)}{P(x)} = \sum_{x} Q(x) = 1
$$
因此：
$$
\mathbb{E}_{P} \left[ \log \frac{Q(x)}{P(x)} \right] \leq \log(1) = 0
$$

推导KL散度的非负性

注意到：
$$
\mathbb{E}_{P} \left[ \log \frac{Q(x)}{P(x)} \right] = -D_{\text{KL} }(P \parallel Q)
$$
因此：
$$
-D_{\text{KL} }(P \parallel Q) \leq 0 \implies D_{\text{KL} }(P \parallel Q) \geq 0
$$
当且仅当 $ P(x) = Q(x) $ 对所有 $ x $ 成立时，$ \frac{P(x)}{Q(x)} = 1 $，此时：
$$
D_{\text{KL} }(P \parallel Q) = \sum_{x} P(x) \log 1 = 0
$$
KL散度始终满足：
$$
D_{\text{KL} }(P \parallel Q) \geq 0
$$
且 $ D_{\text{KL} }(P \parallel Q) = 0 $ 当且仅当 $ P = Q $

附录：KL 散度=交叉熵与熵的差推导

KL 散度本质上是交叉熵与熵的差，反映了用错误模型编码时的“额外信息量”

熵 $H(P)$ 和交叉熵 $H(P, Q)$ 的定义

对于离散分布 $P(x)$，熵定义为：
$$
H(P) = -\sum_x P(x) \log P(x)
$$
- 它表示在分布 $P$ 下，平均需要多少信息量（比特或 nats）来编码事件
交叉熵定义为：
$$
H(P, Q) = -\sum_x P(x) \log Q(x)
$$
- 它表示在真实分布是 $P$ 时，如果用分布 $Q$ 来编码，平均需要的信息量

KL 散度=两者的差

交叉熵与熵的差：
$$
\begin{align}
H(P, Q) - H(P) &= \left[ -\sum_x P(x) \log Q(x) \right] - \left[ -\sum_x P(x) \log P(x) \right] \\
&= -\sum_x P(x) \log Q(x) + \sum_x P(x) \log P(x) \\
&= \sum_x P(x) \left[ \log P(x) - \log Q(x) \right] \\
&= \sum_x P(x) \log \frac{P(x)}{Q(x)} \\
&= D_{\mathrm{KL} }(P | Q)
\end{align}
$$

理解

熵 $H(P)$ ：理想编码长度
交叉熵 $H(P, Q)$ ：用错误分布 $Q$ 编码的平均长度
KL 散度 ：额外的编码长度，也就是交叉熵比真实熵多出来的部分

附录：卡方散度和 KL 散度对比

卡方散度定义

设 $P,Q$ 为两个概率分布，且 $Q$ 绝对连续于 $P$（$P(x)=0\Rightarrow Q(x)=0$）， 皮尔逊卡方散度(简称卡方散度) 定义为：
$$
\chi^2(P|Q) = \int \frac{(P(x)-Q(x))^2}{Q(x)} dx
$$
离散形式：
$$
\chi^2(P|Q) = \sum_i \frac{(P_i-Q_i)^2}{Q_i}
$$

回顾 KL 散度定义

连续形式
$$
D_{\mathrm{KL} }(P|Q) = \int P(x)\log\frac{P(x)}{Q(x)} dx
$$
离散形式：
$$
D_{\mathrm{KL} }(P|Q) = \sum_i P_i\log\frac{P_i}{Q_i}
$$

卡方散度与 KL 散度的关系

关系1：泰勒展开关系
- 当 $P$ 接近 $Q$ 时，对 $\log\frac{P}{Q}$ 在 $P=Q$ 处展开：
  $$
  D_{\mathrm{KL} }(P|Q) = \frac{1}{2}\chi^2(P|Q) + o\bigl(|P-Q|^2\bigr)
  $$
  - 即：KL 散度在局部等价于卡方散度的 1/2
关系2：不等式关系
- 由 Jensen 不等式可证：
  $$
  D_{\mathrm{KL} }(P|Q) \le \chi^2(P|Q)
  $$

两者特点对比

对比详情：

特性	KL 散度 $D_{\mathrm{KL} }(P\|Q)$	卡方散度 $\chi^2(P\|Q)$
形式	含对数，信息论度量	二次型，统计检验度量
对称性	非对称：$D_{\mathrm{KL} }(P\|Q)\neq D_{\mathrm{KL} }(Q\|P)$	非对称：$\chi^2(P\|Q)\neq \chi^2(Q\|P)$
非负性	满足 $D_{\mathrm{KL} }\ge 0$	满足 $\chi^2\ge 0$
对小 $Q_i$	敏感，但存在对数约束，爆炸缓慢	及其敏感，但无对数，更容易爆炸
权重	按 $P_i$ 加权	按 $1/Q_i$ 加权
来源	信息论、编码、熵	皮尔逊卡方检验、拟合优度
优化	常用于变分推断、生成模型	常用于密度比、分布检验

重点：卡方散度比 KL 散度更不稳定（在 $Q(x)$ 极小时，卡方散度很容易出现爆炸）
- 卡方散度是被 $\frac{1}{Q}$ 修饰的，当 $Q(x)$ 减小时，是线性增长
- KL 散度是被 $\log \frac{1}{Q}$ 修饰的，当 $Q(x)$ 减小时，对数增长就慢很多

Math——线性规划求解方法和理解

本文包含对线性规划的直观理解，不严谨，后续有新的问题/理解持续更新

参考链接：
- 运筹学中应该如何理解互补松弛性。这条性质又该如何运用?
- 第4章对偶理论和敏感度分析
- 线性规划对偶问题的定义，有什么直觉上的解释吗？：原始问题到对偶问题最好的一种很简洁的解释
- 互联网广告算法漫谈——浅谈广告中的出价技术。注意：该参考链接中没有把预算约束相关的互补松弛定理写出来，且2.3中存在一些较为明显的小bug，但整体求解思路和结论没问题

原始问题

问题描述：
- 假设你是一个木匠有200单位的木头和90单位的时间
- 木匠可以制作桌子或者椅子
  - 桌子成本为5单位木头+2单位时间，售价10元
  - 椅子成本为2单位木头+1单位时间，售价3元
目标：在已有资源情况下，最大化收入，应该生产多少桌子和椅子？
问题形式化描述:
- 假设应该生产 $x_1$ 把桌子和 $x_1$ 把椅子
  $$
  \begin{align}
  \max \ \ 10x_1 &+ 3x_2 \\
  5x_1 + 2x_2 &<= 200 \\
  3x_1 + \ \ x_2 &<= 90 \\
  x_1,x_2 &>= 0 \\
  \end{align}
  $$
作图法可求得最优解为 $x_1^* = 30, x_2^*=0$，此时最大收益为300
- 在二维坐标轴上先画出可行域，然后按照目标直线斜率找到最优点

对偶问题

对偶问题描述：
- 上述原始问题可以换一个视角看
- 假设现在你是一个原材料收购商（想要以最低价格收购木匠的原材料）
- 目标：对单位木头和单位时间进行出价，以最低的价格买完木匠的资源（假设木匠愿意卖出的前提是收购上出价的最小值不小于木匠原始问题中收益的最大值）
  - 实际上最好是刚好等于木匠原始问题的最大收益
对偶问题形式化描述
$$
\begin{align}
\min \ \ 200p_1 &+ 90p_2 \quad – 总付款 \\
5p_1 + 3p_2 &>= 10 \quad – 一张桌子的资源售价不低于一张桌子的收益 \\
2p_1 + \ \ p_2 &>= 3 \quad – 一张椅子的资源售价不低于一张椅子的收益 \\
p_1,p_2 &>= 0 \quad – 售价不为负数 \\
\end{align}
$$
其中 $p_1, p_2$ 分别称为单位木头和单位时间的影子价格
作图法可求得最优解为 $p_1^* = 0, p_2^* = 3.3$，此时最小支付金额为300

互补松弛定理的理解

从原始问题的约束视角出发

等价于从对偶问题的解出发

对偶问题中，最优解是 $p_1^* = 0, p_2^* = 3.3$
- $p_1^* = 0$ 意味着我们的木材过量了，其实不需要这么多木材，原始问题中，最优解对应的木材约束是松的（ $5x_1^* + 2x_2^*=150 < 200$ ）
- $p_2^* = 3.3$ 说明时间资源非常紧俏，原始问题中，最优解对应的时间约束是紧的（ $3x_1^* + \ \ x_2^* = 90$ ）
对应互补松弛的含义：
- 如果在最优条件下一个约束不等式是松的（木材），那么这个约束对应的影子价格为0
- 反过来说，如果某个约束对应的影子价格严格大于0，那么这个约束不等式一定是紧的
- 总的来说，原始问题的约束和对偶问题变量(影子价格)总有一个要为0

从对偶问题的约束视角出发

等价于从原始问题的解出发

原始问题中，最优解是 $x_1^* = 30, x_2^*=0$
- $x_1^* = 30$ 意味着桌子非常合算，应该多生产桌子，对偶问题中，桌子约束是紧的（ $5p_1^* + 3p_2^* = 10$ ）
- $x_2^*=0$ 以为这椅子不合算，不应该生产椅子，对偶问题中，椅子的约束是松的（ $2p_1^* + \ \ p_2^* = 3.3 > 3$ ）
补充互补松弛的含义：
- 如果在对偶最优条件下一个约束不等式是松的（椅子），那么这个约束对应的原始问题变量最优解（ $x_2^*$ ）为0
- 反过来说，如果某个原始问题变量（桌子）对应的解（ $x_1^*$ ）严格大于0，那么对偶问题中这个约束不等式一定是紧的
- 总的来说，对偶问题的约束和对应原始问题变量总有一个要为0

互补松弛定理的公式化

$$
(5p_1^* + 3p_2^* - 10)x_1^* = 0 \\
(2p_1^* + p_2^* - 3)x_2^* = 0 \\
(5x_1^* + 2x_2^* - 200)p_1^* = 0 \\
(3x_1^* + x_2^* - 90)p_2^* = 0 \\
$$

附录：USCB推导

《A Unified Solution to Constrained Bidding in Online Display Advertising》——论文阅读
- 这篇文章的约束很多，每个商家都有自己的约束
- 推导时用到的对偶变换和互补松弛定理均可由论文推导得出【有时间再详细推导】

附录：BCB推导（单约束）

《Budget Constrained Bidding by Model-free Reinforcement Learning in Display Advertising》——论文原文
- 这篇文章中的问题定义比较简单，整体只有一个预算约束
- 上述结果详细的推导可以参考：
  - 智能出价——BCB求解
  - 互联网广告算法漫谈——浅谈广告中的出价技术。注意：该参考链接中没有把预算约束相关的互补松弛定理写出来，且2.3中存在一些较为明显的小bug，但整体求解思路和结论没问题
- 推导结果 $bid = \frac{v_i}{\lambda}$ 与常用的方法(RL-MPCA)结果不一致，但可以证明本质是等价的

附录：CPC约束推导（单约束）

问题描述：单位置、二价拍卖，且CPM计费场景，CPC约束下最大化商家点击量
推导过程可参考论文Bid Optimization by Multivariable Control in Display Advertising
基本推导思路：先通过拉格朗日乘子法得到最优解的形式（这里先忽略边际条件 $0\le x_i \le 1$ ），再将原始问题转换成对偶问题，进一步分情况讨论得到最终解
问题定义
$$
\begin{align}
&\max \sum_i x_i \cdot ctr_i \\
\text{s.t.} &\quad \frac{\sum_i x_i \cdot wp_i}{\sum_i x_i \cdot ctr_i} \le cpc \\
&\quad 0 \le x_i \le 1, \forall i
\end{align}
$$
第一步：推导最优出价形式：
- 写出拉格朗日函数并求导：
  $$\mathcal{L}(x, \lambda, \mu) = - \sum_i x_i \cdot ctr_i + \lambda \left(\sum_i x_i \cdot wp_i - \sum_i x_i \cdot ctr_i \cdot cpc\right) + \sum_i \mu_i (x_i - 1)$$
- 对任意的 $x_i$ 求导有：
  $$ \frac{\partial \mathcal{L}(x, \lambda, \mu)}{\partial x_i} = - \sum_i ctr_i + \lambda \sum_i wp_i - \lambda \sum_i ctr_i \cdot cpc + \sum_i \mu_i $$
- 令上述导数为0有（$\mu_i$ 来自边界条件 $0\le x_i \le 1$，为了得到最优解形式，接下来先忽略边界条件，最后会证明在满足边界条件下，该形式也是最优的）：
  $$
  \begin{align}
  wp_i &= \frac{ctr_i + \lambda \cdot cpc \cdot ctr_i}{\lambda} \\
  &= \frac{1 + \lambda \cdot cpc}{\lambda} \cdot ctr_i
  \end{align}
  $$
  - 所以我们令出价等于下面的形式：
    $$bid_i = \frac{1 + \lambda \cdot cpc}{\lambda} \cdot ctr_i$$
第二步：验证最优出价形式：
- 原始问题对应的对偶问题为：
  $$
  \begin{align}
  &\mathop{\min}_{\lambda, r_i} \sum_i r_i \\
  \text{s.t.} &\quad \lambda(wp_i - cpc\cdot ctr_i) + r_i \ge ctr_i \quad \text(1)\\
  &\quad \lambda \ge 0 \\
  &\quad r_i \ge 0, \forall i
  \end{align}
  $$
- 互补松弛条件:
  $$
  \begin{align}
  x_i(\lambda(wp_i - cpc\cdot ctr_i) + r_i - ctr_i) = 0 \quad &\text{(2)} \\
  r_i(x_i - 1) = 0, \forall i \quad &\text{(3)}
  \end{align}
  $$
- 将最优出价公式 $bid_i = \frac{ctr_i + \lambda \cdot cpc \cdot ctr_i}{\lambda}$ 带入公式(2)可得：
  $$ x_i(\lambda(wp_i - bid_i) + r_i) = 0$$
  - 当 $x_i \gt 0$ 时，有 $wp_i - bid_i = -\frac{r_i}{\lambda} \lt 0$，进一步推得 $bid_i \ge wp_i$
  - 当 $x_i = 0$ 时，由公式(3)有 $r_i = 0$；将最优出价公式 $wp_i = \frac{ctr_i + \lambda \cdot cpc \cdot ctr_i}{\lambda}$ 带入公式(1)可得 $\lambda(wp_i - bid_i) + r_i \ge 0$，进一步推得 $wp_i - bid_i \ge 0$，即$bid_i \le wp_i$
- 证毕
如何理解最优出价形式？
$$
\begin{align}
bid_i = \frac{1 + \lambda \cdot cpc}{\lambda} \cdot ctr_i = \color{red}{(\frac{1}{\lambda \cdot cpc} + 1)} \cdot cpc \cdot ctr_i
\end{align}
$$
- 二价计费场景中 ，计费比未知，所以引入了一个大于 1 的出价系数:
  $$ k = \color{red}{\frac{1}{\lambda \cdot cpc} + 1} $$
  - 用来提升出价以做到目标CPC达成（可以证明，在整个周期内流量足够多的情况下，如果实际CPC小于目标CPC，则此时一定不是点击最大化的出价策略）
  - 实际使用中，由于 $1$ 是全局固定值，商家的 $cpc$ 是商家粒度的固定值，$\lambda$ 是商家粒度的变量，可以合并成一个变量即可（$\lambda$ 和 $k$ 是一一对应的），最终可以忽略 $k$ 值的具体形式，只需要直接调节 $k$ 即可，此时最优公式为：
    $$ bid_i = \color{red}{k} \cdot cpc \cdot ctr_i $$
- 如果竞争环境非常激烈，计费比趋近于1（同时考虑预估值准确），此时每次出价都按照 $\color{red}{bid_i = cpc \cdot ctr_i} $，可保证投放周期内实际CPC的期望刚好等于目标CPC，$\color{red}{k=1}$ 就是最优的出价策略
- 调控系数的其他功能 ：从推导来看，系数 $k$ 可以用于补足二价计费的Gap；在实际应用中，这个 k 值还可以解决 CTR 均值预估值不准确的问题，比如CTR预估过高 ，$k$ 会小于1 ，从而保证不超成本
  - 可以注意到：在这个假设下有矛盾点，$k < 1$ 时对应的 $\lambda < 0$，并不满足对拉格朗日乘子的要求，但不用担心，这里实际上 $k = k_1 \cdot k_2$，其中，由 $\lambda$ 导出的 $k_1$ 依然是大于1的，用来调平CTR预估值 $k_2$ 是小于1的，实际上，$\lambda \geq 0$ 始终成立

附录：oCPC场景约束推导（单约束）

问题描述1：单位置、二价拍卖，且CPC计费场景，CPS约束下最大化商家订单量
实际上，本问题中与上文单位置拍卖的CPM计费场景，CPC约束下最大化商家点击量非常相似，仅需把对应的参数替换一下即可（$ctr_i \rightarrow cvr_i$，$cpc \rightarrow cps$），于是有最优出价形式是：
$$
\begin{align}
wp_i = \frac{1 + \lambda \cdot cps}{\lambda} \cdot cvr_i = \color{red}{(\frac{1}{\lambda \cdot cps} + 1)} \cdot cps \cdot cvr_i
\end{align}
$$
- 出价系数：
  $$ k = \color{red}{\frac{1}{\lambda \cdot cps} + 1} $$
- 注：实际使用中，同上描述，最终可以忽略 $k$ 值的具体形式，只需要直接调节 $k$ 即可，此时最优公式为：
  $$ bid_i = \color{red}{k} \cdot cps \cdot cvr_i $$
问题描述2：单位置、二价拍卖，且CPC计费场景，ROI约束下最大化商家Revenue
此时可以进一步表达为如下形式（$cvr_i \rightarrow cvr_i\cdot rev_i$，$cps \rightarrow rate = \frac{1}{ROI}$，）：
$$
\begin{align}
wp_i &= \frac{1 + \lambda \cdot 1/ROI}{\lambda} \cdot cvr_i \cdot rev_i \\
&= \frac{ROI + \lambda}{\lambda \cdot ROI} \cdot rev_i \cdot cvr_i \\
&= \frac{ROI + \lambda}{\lambda} \cdot \frac{rev_i \cdot cvr_i}{ROI} \\
&= \color{red}{(\frac{ROI}{\lambda} + 1)} \cdot \frac{rev_i \cdot cvr_i}{ROI} \\
\end{align}
$$
- 出价系数：
  $$ k = \color{red}{\frac{ROI}{\lambda} + 1}$$
- 注：实际使用中，同上描述，最终可以忽略 $k$ 值的具体形式，只需要直接调节 $k$ 即可，此时最优公式为：
  $$ bid_i = \color{red}{k} \cdot \frac{rev_i \cdot cvr_i}{ROI} $$

附录：紧约束和松约束

紧约束（Tight Constraint）和松约束（Slack Constraint）是描述约束条件对可行解集影响的两个概念
紧约束指的是那些在其边界上限制了最优解的约束条件。换句话说，如果改变某个约束条件会直接影响到最优解的位置或值，那么这个约束条件就是紧的。例如，在线性规划问题中，如果一个不等式约束以“=”的形式满足于最优解处，那么这个约束就是紧约束。紧约束对于确定最优解至关重要，因为它们直接定义了最优解所在的位置
松约束则指的是那些在最优解处并没有起到实际限制作用的约束条件。也就是说，即使这些约束不存在，也不会改变问题的最优解。这类约束条件提供了额外的空间，但在这个空间内的点并不会比边界上的点更优。因此，松约束的存在不会影响最终的优化结果，但在某些情况下，它们可能为寻找最优解提供便利或增加灵活性。

Math——运筹优化开源求解器-GLPK的使用

本文介绍各种运筹优化开源求解器-GLPK的使用

GLPK是一款完全开源免费的运筹优化求解器，可以任意商用

Ubuntu安装GLPK

据说Ubuntu安装较为方便，所以建议首选Ubuntu
在网站下载文件：https://ftp.gnu.org/gnu/glpk/
- 可以下载任意版本，建议选最新

安装命令

tar -xzvf glpk-xxx.tar.gz
./configure
make
sudo make install

安装后直接执行可能出现错误

1	error while loading shared libraries: libglpk.so.36:...

解决方案（原始解决方案地址）：
1
https://github.com/rstudio/renv/issues/1881

Ubuntu下GLPK的使用

下列式子参考了：线性规划工具　GLPK 的安装及基本使用

创建问题描述文件glpkDemo.mod

/* Variables */
var x1 >= 0;
var x2 >= 0;
var x3 >= 0;

/* Object function */
maximize z: 3*x1 + x2 +2*x3;

/* Constrains */
s.t. con1: x1 + x2 + 3*x3 <= 30;
s.t. con2: 2*x1 +2*x2 + 5*x3 <= 24;
s.t. con3: 4*x1 + x2 + 2*x3 <= 36;

end;

执行命令解决问题

1	glpsol -m glpkDemo.mod -o ./output/glpkDemo.sol

输出文件

Problem:    glpkDemo
Rows:       4
Columns:    3
Non-zeros:  12
Status:     OPTIMAL
Objective:  z = 28 (MAXimum)

   No.   Row name   St   Activity     Lower bound   Upper bound    Marginal
------ ------------ -- ------------- ------------- ------------- -------------
     1 z            B             28                             
     2 a            B             12                          30 
     3 b            NU            24                          24      0.166667 
     4 c            NU            36                          36      0.666667 

   No. Column name  St   Activity     Lower bound   Upper bound    Marginal
------ ------------ -- ------------- ------------- ------------- -------------
     1 x1           B              8             0               
     2 x2           B              4             0               
     3 x3           NL             0             0                   -0.166667 

Karush-Kuhn-Tucker optimality conditions:

KKT.PE: max.abs.err = 0.00e+00 on row 0
        max.rel.err = 0.00e+00 on row 0
        High quality

KKT.PB: max.abs.err = 0.00e+00 on row 0
        max.rel.err = 0.00e+00 on row 0
        High quality

KKT.DE: max.abs.err = 2.22e-16 on column 1
        max.rel.err = 3.17e-17 on column 1
        High quality

KKT.DB: max.abs.err = 0.00e+00 on row 0
        max.rel.err = 0.00e+00 on row 0
        High quality

End of output

Activity这一列就是想要的解
其他输出项如何理解？

自动化生成问题

使用shell或者Python自动生成.mod文件，然后自然解析.sol文件，实现自动化测试参数

RL——IQL

参考链接
- 原始论文：ICLR 2022 Poster, Offline reinforcement learning with implicit q-learning
- 相关论文：(AWR)ADVANTAGE-WEIGHTED REGRESSION: SIMPLE AND SCALABLE OFF-POLICY REINFORCEMENT LEARNING

IQL 的基本思想

常规的方法会直接约束策略或者正则来减少OOD问题，IQL则通过SARSA style的方法仅在见过的state-action上进行学习，不直接面对OOD问题
策略学习使用了AWR（Advantage Weighted Regression）方法

多步动态规划和 Single-step 方法

多步动态规划(Multi-step DP)

多步动态规划方法（multi-step dynamic programming methods，简写作Multi-step DP）
已有Offline RL方法的很大一部分是基于约束或正则化的近似动态规划（例如，Q-learning 或 actor-critic 方法），constraint或Regularization用于限制与行为策略的偏差。我们将这些方法称为多步动态规划(Multi-step DP)算法，因为它们对多次迭代执行真正的动态规划，因此如果提供高覆盖率数据，原则上可以恢复最优策略。通常情况下Multi-step DP问题也可以分为：
- 显式密度模型(explicit density model)：BRAC，BCQ，BEAR等
- 隐式差异约束（implicit divergence constraints）：AWAC，CRR，AWR等
如何理解显示密度模型和隐式约束模型的定义？
- 显式密度模型：直接建模State-Action的价值分布，从而得到最优策略
- 隐式差异约束：不直接建模State-Action的价值分布，更多是模仿优质策略行为的思想
问题：显示密度模型中的“密度”是什么意思？
- 这里的密度是指概率密度，显示密度模型即会直接定义并学习概率密度函数的模型

Single-step 方法

Single-step 方法（Single-step Methods）是指一类方法，这类方法仅依赖于单步策略迭代的方法，即对行为策略的价值函数或Q函数进行拟合，然后提取相应的贪心策略，或者完全避免价值函数并利用行为克隆目标
这类方法避免了访问看不见的状态动作对，因为它们要么根本不使用价值函数，要么学习行为策略的价值函数
IQL 就是一种 Single-step 方法
传统的模仿学习也属于 Single-step 方法

多步动态规划和 Single-step 方法的比较

from https://zhuanlan.zhihu.com/p/497358947

IQL 之前的方案

一般的 Offline RL 学习方法

思路：按照贝尔曼最优方程迭代
损失函数：
$$
L_{TD}(\theta) = \mathbb{E}_{(s,a,s’) \sim D} \left[ (r(s, a) + \gamma \max_{a’} Q_{\theta’}(s’, a’) - Q_\theta(s, a))^2 \right]
$$
分析：
- 直接使用上述损失函数存在值高估问题
- 大多数最近的离线RL方法修改了上述值函数损失（或直接约束argmax这个策略本身选择动作的方位），以正则化值函数，使其生成的策略接近数据，缓解值高估问题

能避免 OOD 的学习方法

思路：按照SARSA-style的方法迭代，即贝尔曼期望方程（ $a’\sim \pi_\beta$ ）
损失函数：SARSA-style的损失函数如下
$$
L(\theta) = \mathbb{E}_{(s,a,s’,a’) \sim D} \left[ (r(s, a) + \gamma Q_{\theta’}(s’, a’) - Q_\theta(s, a))^2 \right]
$$
- 按照上面的损失函数学习，学到的 $Q_\theta(s,a)$ 本质是行为策略对应的Q值，也就是说，当样本无限时，Q值收敛到
  $$
  Q_\theta^*(s, a) \approx r(s, a) + \gamma \mathbb{E}_{s’ \sim p(\cdot|s,a), a’ \sim \pi_\beta(\cdot|s’)} \left[ Q_{\theta’}(s’, a’) \right]
  $$
分析：
- 本质上是在估计数据集上的状态和动作分布下，Q值的期望
- 显然上面学到的只是行为策略对应的Q值，不是我们想要的最优Q值（行为策略不一定是最优策略）
- 上面的方法更像是在对行为策略进行模仿

Offline RL 的最优 Q 值目标

思路：避免OOD且能学到“最优策略”的迭代形式，限制了argmax动作不访问OOD的状态动作对
损失函数：
$$
L(\theta) = \mathbb{E}_{(s,a,s’) \sim D} \left[ (r(s, a) + \gamma \max_{a’ \in A, \pi_\beta(a’|s’) > 0} Q_{\theta’}(s’, a’) - Q_\theta(s, a))^2 \right]
$$
分析：
- 既保证使用的最大Q值对饮动作不超过数据集（避免了OOD），又可以在支持集上最大化当前策略
- 上面的定义实际上也可能访问到支持集以外的动作，后续需要使用期望回归来改进为SARSA-style的形式
注意：IQL 并不直接学习上述目标（ $\pi_\beta(a’|s’) > 0$ 导致无法学习），只是隐式的学习上述目标 ，具体方法是引入期望回归（Expectile Regression）
- BCQ等方法已经学习过上述目标的改进版本
- 上述目标无法直接学习，因为判断 $\pi_\beta(a’|s’) > 0$ 需要维护一个表格，统计所有数据，状态动作空间很大时无法实现，除非像BCQ一样，用一个网络去学习概率

IQL 的解决方案

期望回归与分位数回归

期望回归（Expectile Regression） ，是估计随机变量的各种统计量的方法，定义如下：
- 某个随机变量 $X$ 的 $\tau \in (0, 1)$ 期望值定义为以下非对称最小二乘问题的解：
  $$
  \mathop{\arg\min}_{m_\tau} \mathbb{E}_{x \sim X} \left[ L_\tau^2(x - m_\tau) \right], \quad \text{ Where } \quad L_\tau^2(u) = |\tau - 1(u < 0)| u^2.
  $$
- $L_\tau^2(u)$ 也常常写作 $L_\tau^e(u)$
- 给定 $\tau$， $m_\tau$ 就是在拟合随机变量的某个 $\tau$ 期望点，不同的 $\tau$ 下 $m_\tau$ 也会不同，学到的，比如 $\tau=0.5$ 时就是对应期望
- 分析：
  - 当 $\tau > 0.5$ 时，这种非对称损失函数会降低小于 $m_\tau$ 的 $x$ 值的权重，而增加大于 $m_\tau$ 的 $x$ 值的权重
  - 当 $\tau = 0.5$ 时，损失函数退化成对称的，等价于均方误差MSE（这里把 $u$ 看做是误差项）
    $$ L^{\tau=0.5}_{2}(u) = |0.5 - \Bbb{1}(u<0)|u^2 = \frac{1}{2}u^2 $$
条件随机变量的期望回归
- 对于给定的条件随机变量 $y = f(x)$，假定 $(x,y)$ 成对出现在数据集 $\mathcal{D}$ 中，则可以定义：
  $$\mathop{\arg\min}_{m_\tau(x)} \mathbb{E}_{(x,y) \sim \mathcal{D}} \left[ L_\tau^2(y - m_\tau(x)) \right]$$
- 给定 $\tau$， $m_\tau(x)$ 是一个关于 $x$ 的函数，不同的 $\tau$ 得到的拟合函数不同，相同的 $\tau$，给定不同的 $x$ 会得到不同的 $m_\tau(x)$， $m_\tau(x)$ 本质是在拟合 $y$，下图中最右侧的图展示了条件随机变量的期望回归
分位数回归（Quantile Regression）定义如下:
$$
\mathop{\arg\min}_{m_\tau} \mathbb{E}_{x \sim X} \left[ L_\tau^1(x - m_\tau) \right], \quad \text{ Where } \quad L_\tau^1(u) = (\tau - 1(u < 0)) u.
$$
- $L_\tau^1(u)$ 也常常写作 $L_\tau^q(u)$
- $(\tau - 1(u < 0)) u$ 不使用绝对值的原因是此时无论 $u$ 取值正负 $L_\tau^1(u) \ge 0$ 都成立，相当于已经给整体加了绝对值了，最终目标是类似MAE的形式
分位数回归和期望回归的对比
- 常规的MSE叫做mean，等价于求均值，等价于 $\tau = 0.5$ 的期望回归（expectile regression）
- 常规的MAE叫做median，等价于求中位数，等价于 $\tau = 0.5$ 的分位数回归（quantile regression）
更多比较
- 修正：左边第二行需要使用绝对值 $\mathcal{R}_\tau^e(u) = u^2|\tau - \mathbf{1}(u < 0)|$
问题：为什么使用期望回归而不是分位数回归？
- 审稿人也有这个疑问，作者的回答是实验得到的，没有正面给出回答？， $\tau=0.9$ 时效果最好

基于期望回归的 Q 值学习

借助期望回归来学习Q值：
$$
L(\theta) = \mathbb{E}_{(s,a,s’,a’) \sim D} \left[ L_\tau^2(r(s, a) + \gamma Q_{\theta’}(s’, a’) - Q_\theta(s, a)) \right]
$$
其中 $\mathcal{D} \sim \pi_\beta$，选择合适的 $\tau$ 后，可以学到一个大于 $Q^{\pi_\beta}(s,a)$ （行为策略对应的Q值）的 $Q(s,a)$
理解：给定 $(s,a)$ 的情况下，存在许多不同的 $(s’,a’)$ 样本，当 $\tau > 0.5$ 时，相当于是通过这种非对称损失函数降低小于 $Q_\theta(s, a)$ 的动作状态对 $(s’, a’)$ 所对应的目标值 $r(s, a) + \gamma Q_{\theta’}(s’, a’)$ 的权重，增加大于 $Q_\theta(s, a)$ 的动作状态对 $(s’, a’)$ 所对应的目标值 $r(s, a) + \gamma Q_{\theta’}(s’, a’)$ 的权重，从而学到较大的 $(s’,a’)$ 对应的目标值，极端情况下，学到的是最大值 $r(s, a) + \gamma \max_{(s,a,s’,a’) \sim \mathcal{D}} Q_{\theta’}(s’, a’)$
上面的损失函数还存在一些不足，由于环境可能是动态变化的，状态 $s’$ 是按照概率 $p(s’|s,a)$ 出现，所以以上损失函数还使得Q学到了环境转换的信息。具体来说，学到的Q值高不一定是选到了优秀动作的反应，还可能是因为运气好碰上了转移到一个较好的状态 $s’$ 上
- 补充说明1：即使是随机环境，在状态 $s$ 下，选择 $a$ 后有一定概率得到较优秀的 $s’$，能说明在状态 $s$ 下，选择 $a$ 是较为优秀的吗？回答是不一定！因为在这种随机环境的情况下，最优贝尔曼方程里面，我们也需要对 $s’$ 计算期望 $\mathbb{E}_{s’\sim p(s’|s,a)}$ 而不是取最大 $\max_{s’}$，这是我们的目标是找一个策略，使得按照这个策略交互得到的期望收益最大，而线上推断时，我们不能保证一定能走到最大的 $s’$，除非是确定性环境，即 $(s,a)$ 确定后， $s’$ 也是确定的
- 补充问题1：如果是确定性的环境，是否可以直接使用上述损失函数？

IQL 的 Q 值学习

由于基于期望回归的Q值学习引入了状态转移随机偏差，存在问题，所以需要进行改进：
第一步：使用期望回归去从已知的 $Q_{\hat{\theta}}(s,a)$ 中学习 $V(s)$
$$ L_V(\psi) = \mathbb{E}_{(s,a) \sim D} \left[ L_\tau^2(Q_{\theta’}(s, a) - V_\psi(s)) \right] $$
- 这里可以看出 $V(s)$ 学到的是 $\max_a Q_{\hat{\theta}}(s,a)$ 的思想，即对应V值的贝尔曼最优方程
第二步：使用最优的 $V$ 去学习 $Q$
$$L_Q(\theta) = \mathbb{E}_{(s,a,s’) \sim D} \left[ (r(s, a) + \gamma V_\psi(s’) - Q_\theta(s, a))^2 \right] $$
- 由于 $V$ 在上一步已经通过期望回归学到了最优形式，这一步不需要继续使用期望回归了
至此，我们已经实现了通过SARSA-style的形式，隐式的学到了近似最优Q值
关于参数 $\tau$ 的一些分析以及以上贝尔曼方程收敛性见附录

IQL 的策略学习

虽然我们已经得到了近似最优Q值，但为了避免使用样本外的动作，这里做策略学习时，我们不能直接遍历所有动作
AWR提供了一种方法从近似最优Q值里面提取策略（因为策略学习并不影响Q值，所以更像是从近似最优Q值中提取策略）：
$$
L_\pi(\phi) = \mathbb{E}_{(s,a) \sim D} \left[ \exp(\beta (Q_{\theta’}(s, a) - V_\psi(s))) \log \pi_\phi(a|s) \right]
$$
- 其中 $\beta \ge 0$ 是温度系数。对于较小的超参数值，该目标类似于行为克隆（近似所有样本权重相等的策略梯度，原始策略梯度中，样本权重是温度系数为1的Q值），而对于较大的值，它试图恢复Q函数的最大值（Q值越大，对应的样本权重越大）。正如AWR等先前工作所示，此目标学习一个在分布约束下的最大化Q值的策略
注意，策略学习时Q值收敛以后进行的(Q和V是交替更新)，Q值学习和策略学习是串行的，且Q值学习彻底完成以后才进行策略学习，并不是交替进行
思考：使用期望回归学到的 $V$ 值是 $V^{\pi^*} = \max_a Q_{\hat{\theta}}(s,a)$，为什么可以用最优的 $V$ 值来更新策略 $Q_{\theta’}(s, a) - V_\psi(s)$ ？
- 这种做法是可以的，Q值和V值符合优势函数的定义，因为传统优势函数的定义也是 $A^\pi(s,a) = Q^\pi(s,a) - V^\pi(s)$，其中 $V^\pi(s) = \mathbb{E}_{a \sim \pi(\cdot|s)}[Q^\pi(s,a)]$，看似与 IQL 中学到的 $V$ 值不同，但此时将当前Q值和V值对应策略 $\pi(a|s)$ 理解为选择Q值最大的动作或近似动作，实际上 $Q$ 值和 $V$ 值都满足传统的优势函数了
- 理解：（即使不满足原始优势函数）虽然此时的 $V$ 值是 $\max_a Q_{\hat{\theta}}(s,a)$，但是 $Q_{\theta’}(s, a) - V_\psi(s)$ 依然可以对动作的好坏进行区分。实际上，只要可以保证动作越好，优势函数越大即可，即使所有动作都是负的或者都是正的也没问题，因为策略的实现是一个softmax，大家都降低的时候，降的少的动作上对一个的概率自然会提升。实践也告诉我们，$V$ 值是否是当前状态下动作的期望结果并不重要
- 特别说明 ：AWR 中使用的 $V$ 值是从历史样本的累计奖励上学习的，相当于是历史样本上的期望，也就是行为策略 $\mu$（多轮迭代下可能是混合策略）对应的 $V^\mu$ 值，AWR 的整个推导中奖励 $\mathcal{R}^\mu_{\mathbf{s},\mathbf{a}}$ 和 $V^\mu$ 值都是使用行为策略 $\mu$ 来表示的，奖励使用的是蒙特卡洛估计 $\mathcal{R}^D_{\mathbf{s},\mathbf{a}} = \sum_{t=0}^T\gamma^t r_t$

IQL 训练流程

伪代码如下（说明：伪代码中最后一行策略更新公式有问题，应该是加号，或者把损失函数添上负号，因为这里是想要最大化目标，作者开源代码中是正确的github.com/ikostrikov/implicit_q_learning，论文中写错了）：

附录：为什么 AWR 和策略梯度法损失函数不同？

副标题：不同AC框架算法策略更新公式对比分析，为什么相同的目标推导出来完全不同的更新公式？
问题补充：
- 普通AC（策略梯度法）更新公式是:
  $$\mathop{\arg\max}_{\theta} \mathbb{E}_{(s,a) \sim \pi_{\theta_k}}\Big[(Q^{\pi_{\theta_k}}(s,a)-V^{\pi_{\theta_k}}(s))\log\pi_\theta(a|s)\Big]$$
- PPO更新公式：
  $$\mathop{\arg\max}_{\theta} \mathbb{E}_{(s,a) \sim \pi_{\theta_k}}\Big[\frac{\pi_\theta(a|s)}{\pi_{\theta_k}(a|s)} A^{\pi_{\theta_k}}(s,a) - \beta D_{KL}(\pi_{\theta_{k}}(\cdot|s), \pi_\theta(\cdot|s))\Big]$$
- DDPG更新公式
  $$\mathop{\arg\max}_{\theta} \mathbb{E}_{s_t \sim \rho^\beta(s)} [Q_w(s_t,\mu_\theta(s_t))] $$
- SAC更新公式
  $$\mathop{\arg\max}_{\theta}\mathbb{E}_{s_t \sim \mathcal{D}, \epsilon_t \sim \mathcal{N}}[\log \pi_\theta(f_\theta(\epsilon_t;s_t)\vert s_t) - Q_\theta(s_t, f_\theta(\epsilon_t; s_t))]$$
- AWR更新公式：
  $$\mathop{\arg\max}_{\theta} \mathbb{E}_{(s,a) \sim \pi_\beta}\Big[exp\Big(\frac{1}{\beta}(R_{s,a}^{\mathcal{D}}-V^{\mathcal{D}}(s))\Big)\log\pi_\theta(a|s)\Big]$$
  - 其中 $R_{s,a}^{\mathcal{D}} = \sum_{t=0}^\infty \gamma^t r_t$，不是网络，是真实的轨迹收益
- IQL更新公式：
  $$\mathop{\arg\max}_{\theta} \mathbb{E}_{(s,a) \sim \pi_\beta}\Big[exp\Big(\beta (Q_{\theta’}(s, a) - V_\psi(s))\Big)\log\pi_\theta(a|s)\Big]$$
- AWAC更新公式：
  $$\mathop{\arg\max}_{\theta} \mathbb{E}_{(s,a) \sim \pi_\beta}\Big[exp(\frac{1}{\lambda} A^{\pi_{\theta_k}}(s,a))\log\pi_\theta(a|s)\Big]$$
基本推导思路总结：
- 策略梯度法 ：推导是直接从最初目标出发，视图求最初目标相对策略的梯度
- PPO ：更新公式是从策略提升的视角出发得到梯度提升的目标，通过限制策略变化幅度和重要性采样分别将未知策略的状态和动作采样的问题切换到已知策略
- DDPG ：直接以最大化Q值为目标来更新，可直接传导策略梯度
- SAC ：的目标中增加了熵，可以看成是DDPG的增加熵的版本
- AWR、IQL和AWAC ：更新公式都是相同的形式，是从策略提升的视角出发得到梯度提升的目标，并对该目标进行推导，得到最终的最优策略形式，再带入最优策略形式，从而得到更新公式
也就是说，AWR、IQL和AWAC这三个方法的目标是为了策略提升量最大化 ，而策略梯度法的目标是为了原始目标最大化（梯度提升法）

附录：为什么 IQL 效果比 AWR 好？

IQL和 AWR 的 Q 值是不同策略的优势函数，IQL 的优势函数是在 $\tau$ 分位点期望动作策略分布上的 Q 和 V，即 $A^{\pi^*}(s,a) = Q^{\pi^*}(s,a) - V^{\pi^*}(s)$，而AWR的优势函数是真实的轨迹回报和V值 $A^{\pi_k}(s,a) = R_{s,a}^{\mathcal{D}} - V^{\pi_k}(s)$
IQL 不是迭代训练，是先学好 Q 值（不依赖策略），再利用学好的 Q 值一次性提取策略
标准的 AWR 是 off-policy 的，是一种迭代训练的流程，V 值学习依赖策略与环境交互的轨迹数据，策略学习也依赖上一步的V值，V值，策略，轨迹三者是不断优化的
如果把 AWR 直接用到 Offline R L场景下，则不再与环境交互，AWR 退化到学习一次V值，接着一次性学习策略；
- Offline RL 下学到的 V 值是行为策略对应的 V 值，不是最优的 V 值，但这本身应该没有问题
- 基于统计的 $R_{s,a}^{\mathcal{D}}$ 方差可能很大
使用公式 $L_\pi(\phi) = \mathbb{E}_{(s,a) \sim D} \left[ \exp(\beta (Q_{\theta’}(s, a) - V_\psi(s))) \log \pi_\phi(a|s) \right]$ 来迭代策略时，Q 值和 V 值应该使用什么样的才是最优的？
- 这个公式是从最大化策略提升项得到的，在推导策略提升时，这里使用的A值（对应到Q值和V值）是上一步策略对应的值 $A^\mu(s,a)$，即旧策略 $\mu$ 对应 Q 值和 V 值，而我们的目标是在 $\mu$ 的基础上有所提升，得到优秀的新策略 $\pi$，所以 Q 值和 V 值最好是优秀的策略对应的Q值和V值，否则可能我们的策略 $\pi$ 在不好的策略上提升，结果也可能不是很优秀
补充问题：可以随便使用一个策略来评估优势函数吗？
- 回答是不可以，因为不同策略下，A 值选择不同动作以后的值是不同的，显然学到的策略也不同，从推导看，必须使用上一步的才可以

附录：贝尔曼方程收敛性及 $\tau$ 的分析

关于参数 $\tau$ 的一些分析，原始论文中关于 $\tau$ 的分析如下：
当 $\tau = 0.5$，相当于是SARSA算法；当 $\tau \rightarrow 1$，相当于是Q-Learning算法
对于任意的 $\tau$，Q值和V值迭代都会收敛，且Q值和V值会收敛到 $Q_{\tau}(s,a)$ 和 $V_{\tau}(s)$，Lamma1中最后两行就是两者的贝尔曼方程，其中 $\mathbb{E}_{a \sim \mu(\cdot|s)}^\tau$ 表示 $\mu(\cdot|s)$ 分布下的 $\tau$ 期望分位值（或 $\tau$ 阶期望分位数）。注意，我们在说分位数时，还需要说明是那个随机变量或者哪个分布的分位数，否则没有意义
为什么说Q值和V值迭代都会收敛到 $Q_{\tau}(s,a)$ 和 $V_{\tau}(s)$ 呢？
- 理解：这里的 $\tau$ 期望分位动作可以视作是一个策略，每次选择动作时，不选择最优动作，也不选择随机动作，而是选择 $\tau$ 期望分位点动作，这样，可以得到跟论文中一样的结论：当 $\tau = 0.5$，相当于是SARSA算法；当 $\tau \rightarrow 1$，相当于是Q-Learning算法
- 证明：定义一个策略如下：
  $$\pi_\tau(s) = \mathop{\text{arg_expectile}^\tau}_a(Q(s,a))$$
  该策略表示在状态 $s$ 下，该策略会选择使得Q值等于 $Q(s,a)$ 关于动作 $a$ 的 $\tau$ 期望分位点的动作，则期望分位动作策略对应的贝尔曼方程跟普通策略下的贝尔曼方程没有区别
- 更详细的来说：
  - Q值：假定已经有了 $V_\tau(s’)$，此时Q值的更新是学习当前状态 $s$ 下，按照当前状态对应的 $\tau$ 期望分位动作，以及后续策略也采用 $\tau$ 期望分位动作得到的价值 $V_\tau(s’)$ 来进行拟合的目标值（注意，这里跟其他贝尔曼方程一样，一旦动作决定了， $r(s,a)$ 就确定了，我们所说的期望分位动作就是对动作 $a$ 的分布而言的， $Q(s,a)$ 的拟合只考虑 $(s,a)$ 状态动作对即可，不需要考虑期望分位动作）；
  - V值：假定已经有了 $Q_{\tau}(s,a)$，V值可以从 $Q_{\tau}(s,a)$ 中学到 $V_\tau(s’)$，这里需要使用 $Q_{\tau}(s,a)$ 而不是 $Q_{\pi_\beta(s,a)}$ 的原因是，V的本质是 $Q(s,a)$ 关于动作 $a$ 期望，但直接求期望只到了当前状态 $s$ 这一层，如果使用 $Q_{\pi_\beta(s,a)}$ 来学习那么学到的不是 $V_\tau(s’)$ （ $V_\tau(s’)$ 是指后续的动作也是 $\tau$ 期望分位动作来定义的，正如Q值和V值的常规贝尔曼方程一样）

Implicit 名字的来源

Implicit 含义是“隐式的”，与隐式约束的隐式不等价，在IQL中表示通过期望回归隐式的学到了最优价值函数 $V^*(s) = \max Q(s,a)$

IQL 可能存在的问题

IQL 没有没有像 CQL 一样对非行为策略的 Q 值进行打压（甚至学习过程中全程未学习未知状态动作对的 Q 值），也没有像 BCQ 一样对动作选择进行限制，理论上可能会因为对 OOD 状态动作 Q 值高估而出现问题
IQL 源码实现时的解法：采用 Twin Q 来缓解高估问题（理解：对于数据集中存在的，两个 Q 网络都能估准；对于数据集中不存在的，可能都估不准，但是我们取最小的那个，可以缓解对未知状态动作对 Q 值的高估问题）

Python——Ray-分布式架构简单了解

整体介绍

Ray 是一个用于分布式计算的开源框架，专为构建和运行分布式应用程序而设计
Ray 提供了简洁的 API，让开发者能够轻松地将单机程序扩展到分布式集群上，同时保持代码的可读性和可维护性
Ray 最初由 UC Berkeley 的 RISELab 开发，现在由 Anyscale 公司维护，广泛应用于机器学习、强化学习、并行计算等领域
Ray 既可以在本地实现并行计算，又可以非常容易的扩展到集群模式，实现分布式计算
Ray 与深度学习框架如 TensorFlow、PyTorch 和 MXNet 等互相兼容

Ray 的核心架构

Ray的系统架构采用了混合任务调度的思路，遵循典型的 Master-Slave 设计，但与传统分布式系统有所不同

Ray 中的关键组件总结

Ray在集群部署模式下启动了以下关键组件：
- GlobalScheduler(全局调度器) ：运行在Master节点上，负责接收本地调度器提交的任务，并将任务分发给合适的本地任务调度器执行
- RedisServer ：Master节点上启动的Redis服务器，用于保存分布式任务的状态信息(ControlState)，包括对象机器的映射、任务描述、任务 debug 信息等
- LocalScheduler(本地调度器) ：每个 Slave 节点上启动的本地调度器，用于提交任务到全局调度器，以及分配任务给当前机器的 Worker 进程
- Worker进程 ：每个 Slave 节点上可以启动多个 Worker 进程执行分布式任务，并将计算结果存储到 ObjectStore
- ObjectStore(对象存储) ：每个 Slave 节点上的存储系统，用于存储只读数据对象，Worker 可以通过共享内存的方式访问这些对象数据，有效减少内存拷贝和对象序列化成本。ObjectStore 底层由 Apache Arrow 实现
- Plasma ：每个 Slave 节点上的ObjectStore管理器，当 Worker 访问本地 ObjectStore 上不存在的远程数据对象时，Plasma 会主动拉取其它 Slave 上的对象数据到当前机器

执行模型

Ray的执行模型基于动态任务图 ，这与 TensorFlow 中的静态计算图有本质区别：
- TensorFlow的计算图用于表征神经网络，在单个应用中执行很多次
- Ray的任务图用于表征整个应用，并仅执行一次
- 任务图对于前台是未知的，随着应用的运行而动态地构建
- 一个任务的执行可能创建更多的任务，形成动态依赖关系

代码示例

并行计算示例（无状态）

基于 Ray 的并行计算代码 Demo：

import ray
import time
import numpy as np

# 初始化 Ray，默认在本地启动
ray.init()

# 使用 @ray.remote 装饰器将函数转换为分布式任务
@ray.remote
def compute_square(x):
    # 模拟耗时计算
    time.sleep(1)
    return x * x

# 生成一些数据
data = np.arange(10)

# 并行执行任务
start_time = time.time()
# 创建任务对象引用
square_refs = [compute_square.remote(i) for i in data]
# 等待所有任务完成并获取结果
results = ray.get(square_refs)
end_time = time.time()

print(f"串行计算结果: {[i*i for i in data]}")
print(f"Ray 并行计算结果: {results}")
print(f"Ray 并行计算耗时: {end_time - start_time:.4f} 秒")

# 关闭 Ray
ray.shutdown()

# 串行计算结果: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# Ray 并行计算结果: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# Ray 并行计算耗时: 1.4069 秒

串行计算示例（有状态）

基于 Ray 的串行计算代码 Demo：

import ray
import time

# 初始化 Ray
ray.init()

# 使用 @ray.remote 装饰器定义 Actor 类
@ray.remote
class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        time.sleep(1)  # 模拟耗时操作
        self.count += 1
        return self.count

    def get_count(self):
        return self.count

# 创建 Actor 实例
counter = Counter.remote()

# 并行调用 Actor 方法
start_time = time.time()
# 提交多个增量任务
increment_refs = [counter.increment.remote() for _ in range(10)]
# 获取所有增量任务的结果
results = ray.get(increment_refs)
# 获取最终计数
final_count = ray.get(counter.get_count.remote())
end_time = time.time()

print(f"每次增量结果: {results}")
print(f"最终计数: {final_count}")
print(f"执行耗时: {end_time - start_time:.4f} 秒")

# 关闭 Ray
ray.shutdown()

# 每次增量结果: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 最终计数: 10
# 执行耗时: 10.1293 秒

分布式调度示例（集群模式）

以上代码经过非常简单的修改即可进入集群模式
Ray 集群部署包括三个步骤（下面以 6379 端口为例展示流程）
第一步：启动主节点 ，运行 ray start --head 从主节点启动集群
1
ray start --head --port=6379 --redis-password='your_secure_password_123'
- 注：可通过 --redis-password 设置密码（可选），防止未授权节点加入，也可以不使用该参数
第二步：启动工作节点 ，运行 ray start --address=<主节点IP> 加入集群
1
ray start --address='<head-node-ip>:6379' --redis-password='your_secure_password_123'
- 执行上述命令后工作节点就会：
  - 自动连接到主节点
  - 等待接收任务
  - 执行主节点分配的计算任务
  - 将结果返回给主节点
第三步：在主节点上运行的代码中连接集群
1
ray.init(address='auto', _redis_password='your_secure_password_123')
- 注：以上代码仅在主节点上运行，工作节点不需要显示运行任何代码，仅需要启动并加入集群即可
关闭 Ray 服务：
1
ray stop
特别说明：集群模式与普通单机并行模式的区别很小，仅需要增加修改以上代码即可（其他代码都不需要修改）
Ray 在分布式下默认有许多默认功能：
- 自动负载均衡：Ray 会自动将任务分配到空闲节点
- 容错能力：如果某个工作节点失败，Ray 会重新调度任务
集群模式工作流程总结：
- 主节点通过 Redis 将任务（remote 函数或者类对象）放入队列
- 空闲的工作节点从队列中获取任务
- 工作节点执行任务
- 将运算结果通过共享内存/Object Store 返回给主节点

附录：工作节点启动高级配置

可以通过参数调整工作节点行为：

ray start --address='<head-node-ip>:6379' \
        --redis-password='your_secure_password_123' \
        --num-cpus=8 \          # 限制使用8个CPU核心
        --num-gpus=1 \          # 声明有1个GPU可用
        --object-store-memory=100000000 \  # 设置对象存储大小

附录：Ray 集群状态监控

Ray 提供了 Web UI 用于监控集群状态
在主节点启动时已经启用了 Dashboard（默认端口8265）
在浏览器访问：http://<主节点IP>:8265
在 Dashboard 中可以看到：
- 集群节点列表和资源使用情况
- 当前运行的任务
- 历史任务统计
- 每个节点的CPU/内存使用情况

DL——模型训练预热