1.2.llm_intro

一些思考

The Second Half

OpenAI姚顺雨：欢迎来到AI下半场！

数十年来，人工智能主要致力于开发新的训练方法和模型。

我们不再仅仅问：“我们能否训练一个模型来解决X问题？”而是问：“我们应该训练人工智能去做什么，以及我们如何衡量真正的进步？”要在下半场取得成功，我们需要及时转变思维方式和技能组合，这些可能更接近产品经理的思维方式。

Welcome to the Era of Experience

强化学习之父当头一棒：RL版「苦涩的教训」来了！通往ASI，绝非靠人类数据

被《经验时代》刷屏之后，剑桥博士长文讲述RL破局之路

生成式AI进入第二幕：交大携手创智学院提出「认知工程」，AI新纪元开始了

Generative AI Act II: Test Time Scaling Drives Cognition Engineering

https://github.com/GAIR-NLP/cognition-engineering

中文版，自己转存了一份

刚刚！北大校友Lilian Weng最新博客来了：Why We Think

https://lilianweng.github.io/posts/2025-05-01-thinking/

上半场

上半场的游戏：专注于构建新的模型和方法（如Alexnet、transformer、GPT-3），而评估和基准测试（如Imagenet、WMT'14翻译）是次要的。原因：

• 方法比任务更难、更令人兴奋，需要非凡的洞察力和工程能力；而定义任务往往更简单：只是把人类已经做的事情（比如翻译、图像识别或国际象棋）变成基准测试，没有太多洞察力甚至工程能力。

• 方法也往往比单独的任务更通用、更广泛适用，因此它们特别有价值。

方案(the recipe)

在强化学习中，有三个关键组成部分：算法、环境和先验知识。长期以来，强化学习研究人员主要关注算法（例如REINFORCE、DQN、actor-critic、PPO、TRPO等），即智能体学习的智力核心，而将环境和先验知识视为固定或最小化的。

在深度强化学习时代，环境很重要：如果你忽略环境，你可能会构建一个只在玩具环境中表现出色的“最优”算法。所以，OpenAI设想的就是一旦我们将所有数字世界变成一个环境，用聪明的强化学习算法解决它，我们就拥有了数字通用人工智能（AGI），就搞了如下的项目：

• gym：各种游戏的标准强化学习环境

• World of Bits和Universe项目：将互联网或计算机变成一个游戏。

在GPT-3出现之后，才发现缺失的部分是先验知识，需要强大的语言预训练（language pre-training），将一般常识和语言知识提炼到模型中，然后可以对其进行微调。因此，强化学习中最重要的部分可能甚至不是强化学习算法或环境，而是先验知识，而这些先验知识可以通过与强化学习完全无关的方式获得。

思考（thinking，或者说推理，reasoning），是一种奇怪的动作（action），它并不直接影响外部世界，而且推理的空间是开放的、组合上是无限的。在经典的强化学习理论中，这是一个糟糕的交易，使得决策变得不可能。但是，通过在任何强化学习环境的动作空间中加入推理，我们利用语言预训练的先验知识来实现泛化，并且我们可以在不同的决策中使用灵活的测试时计算。可以参考论文ReAct: Synergizing Reasoning and Acting in Language Models

一旦我们有了正确的强化学习先验知识（语言预训练）和强化学习环境（将语言推理加入到动作中），事实证明强化学习算法可能就是最不重要的部分了。因此我们有了o系列、R1、深度研究、计算机使用智能体，还有更多即将出现的东西。

下半场

上半场的游戏是

• 开发新的训练方法或模型，不断改进基准测试的效果。

• 创建更难的基准测试，并继续这个循环。

但目前这种游戏正在被破坏，因为：

• 方案本质上已经标准化并工业化了，无需太多的新想法。一个针对特定任务的新方法可能提升5%，但下一个o系列模型可能没有明确针对这个任务，但能提升30%

• 即使有更难的基准测试，很快（并且越来越快）它们也会被方案解决，下图是最近5年基准测试的准确率变化情况：

但问题是：人工智能已经在国际象棋和围棋中击败了世界冠军，在SAT和律师资格考试中超越了大多数人类，并在国际信息学奥林匹克竞赛（IOI）和国际数学奥林匹克竞赛（IMO）中达到了金牌水平。但世界并没有发生太大变化，至少从经济和GDP的角度来看。这个问题可以称为效用（utility）问题，根源可能很简单：我们的评估设置与现实世界的设置在很多基本方式上不同：

• 评估“应该”自动运行：通常智能体接收任务输入，自主执行操作，然后接收任务奖励。但现实中，智能体需要和人类互动。因此需要新的基准测试，例如：

  • 将真实人类纳入其中，例如https://lmarena.ai/

  • 将用户模拟纳入其中，例如下图的tau-bench

• 评估“应该”独立同分布（i.i.d.）运行：如果你有一个包含500个任务的测试集，你独立运行每个任务，平均任务指标，然后得到一个总体指标。但现实中，你是按顺序解决任务，而不是并行解决。例如一个工程师在越来越熟悉代码库的过程中，会越来越擅长解决具体的代码问题，而目前的评测做不到这一点。所以需要长期记忆方法（而且确实有AGENT WORKFLOW MEMORY），但学术界没有合适的基准测试来证明这种需求。

下半场的游戏可能是：

• 开发针对现实世界效用的新的评估设置或任务。

• 用方案解决它们，或者用新组件增强方案。继续这个循环。

上半场的参与者在解决视频游戏和考试，充满了渐进式的方法和模型，而下半场的参与者可以通过构建有用的产品来建立价值数十亿甚至数千亿美元的公司，使用通用方案会轻易击败渐进式方法，除非你创造出打破方案的新假设。

如何持续地评估AI产品

姚顺雨提到的「AI下半场」，产品评估仍被误解

https://eugeneyan.com/writing/eval-process/

总有人以为再加个工具、添个指标，或者让大语言模型当裁判（LLM-as-judge），就能解决问题拯救产品。这根本是在回避核心问题，逃避真正该做的工作。评估并非一劳永逸，也不是什么快速起效的方法——它是运用科学方法的持续实践，是评估驱动开发，是AI输出的持续监测。

构建产品评估体系，本质上是一个不断提问、实验和分析的循环。

• 观察数据：审视输入内容、AI输出结果，以及用户与系统的交互情况。数据会告诉我们系统哪里运转良好，更重要的是，哪里会出问题。发现这些故障模式才是有效改进的起点。

• 标注数据：优先处理问题输出。这意味着要对成功和失败的样本进行标记，建立平衡且有代表性的数据集。理想情况下，正负样本应该五五开，并覆盖各类输入场景。这个数据集将成为针对性评估的基础，帮我们追踪已发现问题的改进情况。

• 提出假设：为什么会出现这个错误？可能是RAG检索没返回相关上下文，也可能是模型处理复杂（有时自相矛盾）的指令时力不从心。通过分析检索文档、推理轨迹和错误输出等数据，我们能确定要优先修复的问题以及要验证的假设。

• 设计实验验证假设：比如重写提示词、更新检索组件或切换不同模型。好的实验要能明确验证假设是否成立，最好还设置基线对照组进行比较。

• 测量(measure)和错误分析：这不同于随意的感觉判断，必须量化实验改动是否真有效果：准确率提升了吗？缺陷减少了吗？新版本在对比测试中表现更优吗？无法量化的改进根本不算改进。

• 实验成功就应用更新，失败就继续迭代。

评估驱动的开发（Eval-driven development，EDD）：开发AI功能前，先通过产品评估定义成功标准，确保从第一天就有明确目标和可衡量的指标。

评估指引开发方向。我们先评估基线（比如简单提示词）获取基准数据。之后每个提示词调整、系统更新和迭代都要评估：简化提示词提升了准确性吗？检索更新增加了相关文档召回率吗？还是反而让效果变差了？

EDD是如下的写评估->做改动->跑评估->整合改进的循环，确保了可衡量的改进，建立的不是模糊的直觉判断，而是扎根于软件工程实践的反馈闭环。

自动化评估工具（LLM-as-judge）也离不开人工监督。如果我们不主动审查AI输出和用户反馈，再多自动评估工具也救不了产品。

要评估和监测 AI 产品，通常需要采样输出并标注质量缺陷。有了足够多高质量标注数据，我们就能校准自动评估工具，使其与人类判断一致。这可能涉及测量二元标签的召回率/准确率，或通过两两比较决定输出之间的相关性。校准后的评估工具能有效扩展AI系统的持续监测能力。

但自动评估工具不能取代人工监督。我们仍需要定期采样、标注数据，分析用户反馈。理想情况下，我们应该设计能够通过用户交互获取隐式反馈的产品。不过，显式反馈虽然不那么频繁，偶尔也会有偏见，但也很有价值。自动化评估工具本质上是人工标注与反馈流程的放大器。

趋势

AI开源狂飙，OpenAI们慌了！GenAI大洗牌，2025趋势深度解读

硅谷今夜集体失眠！互联网女皇340页AI报告猛料刷屏，大佬熬夜头秃

AI 推理成本暴跌，「互联网女皇」 Mary Meeker 从中看到了什么？

52页PPT，谷歌Gemini预训练负责人首次揭秘！扩展定律最优解

https://vladfeinberg.com/assets/2025-04-24-princeton-talk.pdf

刚刚，谷歌AI路线图曝光：竟要抛弃注意力机制？Transformer有致命缺陷！

s：短期/即将上线；m：中期，开发中的项目；r：研究、长期项目；

• 全模态（r）：已经原生支持图像+音频生成，接下来是视频

• Diffusion的早期实验（r）：详见diffusion-llm部分

• 默认具备Agent能力（m）：从单纯的token处理器转向具备系统化推理能力的智能体

  • 之前：输入token，输出token，然后在外部构建各种scaffolding（支架）以增强功能。

  • 现在：模型自身越来越系统化，越来越能自主做事，不再只是「被动计算器」。

  • 未来：过去外部做的很多scaffolding，是否会被整合进模型的内部推理流程？

• 推理能力持续扩展（s）：

• 更多小模型（s）：很快会有更多内容可以分享

• 无限上下文（r）：以当前注意力机制和上下文处理方式，这是不可能实现的，需要在核心架构层面进行全新创新，才能实现这一目标，例如：moneta+yaad+memora

• 大模型：规模即一切

AI的下一个阶段：“主动式AI”（Proactive AI），AI主动为你发现问题、提供建议、自动处理任务。

AI时代对（跨境）电商的启示

专访阿里国际站总裁张阔：给AI时代生意人的9条启示

• 放弃流量焦虑，拥抱需求思维

越来越多的人开始用自然语言、长句子、图片和文件去表达自己的需求，传统的关键词搜索根本无法理解，但AI可以精确理解，所以商家不需要自己费尽心思去复制商品、改标题了，而是需要清晰、完整、结构化地描述你的产品和能力，平台把商家从和机器博弈的流量焦虑中解放出来，让他们重新回到“以用户为中心”的正确轨道上。

• 忘掉花哨的技巧，回归生意的本质

以前商家为了迎合搜索引擎，标题里恨不得把所有能想到的关键词都塞进去，甚至会出现“既是黑色又是白色”这种自相矛盾的描述。机器看着可能觉得相关性高，但真人一看就知道毫无意义。把那些花在研究平台规则上的精力收回来，全部投入到打磨产品、服务和供应链这些生意的本质上去。

• 把AI当成合伙人，别当普通员工

AI对于中小企业来说，不止是一个简单的提效的工具，更像一个超级合伙人，能帮你补齐几乎所有的短板。以前一个外贸新手，要成长为一个成熟的业务员，需要很长的培养周期。现在，一个刚入行的新人，只要有基本的商业判断力，配齐了AI这套工具，他的起点可能就是一个过去需要干三五年的老业务员的水平。所以，不要把AI仅仅看作是替代重复劳动的工具，而要把它当成一个全能的、不知疲倦的、而且成本极低的合伙人。

• 审美和提问，是AI时代的新核心能力

外贸的本质，就是八个字：供需匹配，交钱易货。以前，发现需求靠老板有钱，派一堆人去全球各地调研、开头脑风暴。现在，AI可以帮你实时捕捉全世界的需求脉搏。

发现需求、定义产品、满足审美的能力，变得空前重要，AI可以帮你把产品卖到全世界，但前提是，你得先做出一个值得被卖到全世界的好产品。

提问的能力也同样重要，你向AI提问的方式，决定了它能给你什么样的答案，无论是用AI去发现蓝海赛道，还是用AI去生成营销文案，你都需要具备精准定义问题、并与AI进行多轮高质量交互的能力。

-->审美决定了你生意的上限，而提问的能力决定了你利用AI的效率。

• 不要害怕AI犯错，建立人机协同的工作流：在设计AI的时候，需要设置非常明确的硬边界：

  • AI不知道的事，就不说

  • 涉及到拍板决策，必须由人来做。

• 小团队也能办大事，组织要因AI而变

做AI的目的，绝对不是让企业去减员增效，而是让现有的人可以做更多的事，去扩大生意的规模。AI可以放大优秀人才的能力。AI时代的组织架构，不应该是简单的裁员，而应该是重构。企业需要思考的是，如何围绕AI这个新的生产力核心，去重新设计岗位职责和团队协作方式。

• B2B的AI革命，会比C端来得更猛烈

  • 2C的电商，买家的决策链路相对简单。用户搜索、点击、下单，链路就结束了，本质是“多快好省”。有没有AI，对这个核心体验的影响不是颠覆性的。

  • 2B的电商，决策非常复杂和昂贵。采购需要考虑的是能生产这个商品的全套供应链，另外跨境贸易的流程极其繁琐，而这些复杂的、长链条的需求，天生就适合用AI去理解和匹配。

• AI是加速器，但不是点金石

商业的本质是供需匹配。AI能帮你更精准地找到需求，能帮你更高效地触达客户，能帮你提升转化率。但是，它不能替代你做出一个好产品的价值，也不能替代你提供差异化服务的能力。最重要的事情，永远是打磨好自己的“产品”这个内核。

• 我们正处在一个时代的关口

  • 第一阶段：从黄页到交易。平台通过提供担保交易，解决了信任问题，让大规模的在线跨境交易成为可能。

  • 第二阶段：从PC到无线。这是互联网人口红利的自然迁移。

  • 第三阶段：AI驱动的智能时代。AI带来的生产力变革，其深刻程度，丝毫不亚于前两个时代，甚至可能性更大。

LLM概述

PLM（pretrained language models），即bert等

LLM简史

• 2017年的Learning to generate reviews and discovering sentiment尝试用rnn来实现智能系统

• 2018年的gpt1：Improving language understanding by generative pre-training，生成式预训练（Generative pre-training, gpt），用transformer的decoder，参数量117m（0.1b），无监督预训练和有监督微调。确定对自然语言文本建模的基本原则为预测下一个单词。

• 2019年的gpt2：Language models are unsupervised multitask learners模型结构小改，增加数据，参数量变大为15亿（1.5b），无监督语言建模，无需使用标记数据进行显式微调。

  • 参考The natural language decathlon: Multitask learning as question answering中多任务求解的概率形式： $p(output|input,task)$ 。

  • 提出“由于特定任务的有监督目标与无监督目标（语言建模）相同，只是在序列的子集上进行评估，因此，无监督目标的全局最小值也是有监督目标的全局最小值”，即每个NLP任务可以看作世界文本子集的单词预测问题，如果模型有足够能力来复原世界文本，无监督语言建模可以解决各种问题。

  • 仅无监督与监督微调的SOTA相比效果还是不太行。虽然GPT2模型规模相对较小，但如对话等任务在其基础上做微调还是能拿到很好的效果的，例如DIALOGPT : Large-scale generative pre-training for conversational response generation、End-to-end neural pipeline for goal-oriented dialogue systems using GPT-2

• 2020年的gpt3：Language models are few-shot learners，175b（1750亿）参数，当参数量到达千亿时出现了『涌现』现象，发现可以in-context learning（这点在3.3亿的BERT和15亿的gpt2中看不到）。预训练和ICL有相同的语言建模范式：预训练预测给定上下文条件下的后续文本序列，ICL预测正确的任务解决方案，其可被格式化为给定任务描述和示范下的文本序列。

• GPT-3的两种改进方法：

  • 使用代码数据训练：GPT-3主要问题是缺乏对复杂任务的推理能力，2021年openai提出了Codex（Evaluating Large Language Models Trained on Code），在github代码上微调的GPT。A neural network solves and generates mathematics problems by program synthesis: Calculus, differential equations, linear algebra, and more发现Codex能解决非常困难的编程问题，还能在数学问题上有显著提升。Text and code embeddings by contrastive pre-training提出了训练文本和代码emb的对比学习，在线性探测分类、文本搜索、代码搜索等任务上有所提升。GPT-3.5就是在基于代码的GPT（code-davinci-002）的基础上开发的。

  • 与人类对齐：2017年openai就在learning from human preference的博客中提出了应用强化学习来学习由人类标的偏好比较，此后2021年7月openai发表了PPO。2020年GPT-2用RL进行微调，Deep reinforcement learning from human preferences，Learning to summarize from human feedback也做了相似工作。2022年提出了RLHF的InstructGPT(Training language models to follow instructions with human feedback)，其中的SFT就对应于常说的指令微调。在openai的博客Our approach to alignment research中提出了训练AI系统的3个有前途的方向：使用人类反馈、协助人类评估、做对齐研究。

• 2022年的ChatGPT：用类似InstructGPT的方式进行训练，专门对对话能力进行优化，将人类生成的对话（扮演用户和AI两个角色）与InstructGPT数据集结合起来以对话形式生成。

• 2023年的GPT-4：将文本输入扩展到多模态信号。此外，

  • 提升安全性：在RLHF训练中加入额外的安全奖励信号，采用多种干预策略如Anthropic提出的Red teaming language models to reduce harms: Methods, scaling behaviors, and lessons learned提到的红队评估（read teaming）机制以减轻幻觉、隐私和过度依赖问题。

  • 改进的优化方法：使用可预测扩展（predictable scaling）的机制，使用模型训练期间的一小部分计算量以预测最终性能。

  • 迭代部署的工程方案：Lessons learned on language model safety and misuse，遵循5阶段的开发和部署生命周期来开发模型和产品。

LLM列表（持续更新中）

• 百亿：除了LLaMA（最大650亿）和NLLB（最大545亿），大多数在100亿-200亿之间，通常需要数百甚至上千个GPU或TPU。

• 千亿：OPT、OPT-IML、BLOOM和BLOOMZ与GPT-3(175B)大致相同，GLM有1300亿，Galactica有1200亿，通常需要数千个GPU或者TPU。

ckpt?	模型	发布时间	大小	预训练数据规模	硬件	训练时间
Y	T5	2019.10	11B	1万亿tokens	1024 TPU v3	-
N	GPT-3	2020.05	175B	3000万亿tokens	-	-
N	GShard	2020.06	600B	1万亿tokens	2048 TPU v3	4天
Y	mT5	2020.10	13B	1万亿tokens	-	-
Y	PanGu-$\alpha$	2021.04	13B	1.1TB	2048 Ascend 910	-
Y	CPM-2	2021.06	198B	2.6TB	-	-
N	Codex	2021.07	12B	1000万亿tokens	-	-
N	ERNIE 3.0	2021.07	10B	3750亿tokens	384 v100	-
N	Jurassic-1	2021.08	178B	3000亿tokens	800 GPU	-
N	HyperCLOVA	2021.09	82B	3000亿tokens	1024 A100	13.4天
N	FLAN	2021.09	137B	-	128 TPU v3	60小时
N	Yuan 1.0	2021.10	245B	1800亿tokens	2128 GPU	-
Y	T0	2021.10	11B	-	512 TPU v3	27小时
N	Anthropic	2021.12	52B	4000亿tokens	-	-
N	WebGPT	2021.12	175B	-	-	-
N	Gopher	2021.12	280B	3000亿tokens	4096 TPU v3	920小时
N	ERNIE 3.0 Titan	2021.12	260B	-	-	-
N	GLaM	2021.12	1200B	2800亿tokens	1024 TPU v4	574小时
N	LaMDA	2022.01	137B	7680亿tokens	1024 TPU v3	57.5天
N	MT-NLG	2022.01	530B	2700亿tokens	4480 80G A100	-
N	AlphaCode	2022.02	41B	9670亿tokens	-	-
N	InstructGPT	2022.03	175B	-	-	-
N	Chinchilla	2022.03	70B	1.4万亿tokens	-	-
Y	CodeGen	2022.03	16B	5770亿tokens	-	-
Y	GPT-NeoX-20B	2022.04	20B	825GB	96 40G A100	-
Y	Tk-Instruct	2022.04	11B	-	256 TPU v3	4小时
N	PaLM	2022.04	540B	7800亿tokens	6144 TPU v4	-
Y	UL2	2022.05	20B	825GB	96 40G A100	-
Y	OPT	2022.05	175B	1800亿tokens	992 80G A100	-
Y	NLLB	2022.07	54.5B	-	-	-
N	AlexaTM	2022.08	20B	1.3万亿tokens	128 A100	120天
N	Sparrow	2022.09	70B	64 TPU v3	-	-
N	WeLM	2022.09	10B	3000亿tokens	128 A100 40G	24天
N	U-PaLM	2022.10	540B	-	512 TPU v4	5天
N	Flan-PaLM	2022.10	540B	-	512 TPU v4	37小时
N	Flan-U-PaLM	2022.10	540B	-	-	-
Y	GLM	2022.10	130B	4000亿tokens	768 40G A100	60天
Y	Flan-T5	2022.10	11B	-	-	-
Y	BLOOM	2022.11	176B	3660亿tokens	384 80G A100	105天
Y	mT0	2022.11	13B	-	-	-
Y	Galactica	2022.11	120B	1060亿tokens	-	-
Y	BLOOMZ	2022.11	176B	-	-	-
Y	OPT-IML	2022.12	175B	-	128 40G A100	-
Y	LLaMA	2023.02	65B	1.4万亿tokens	2048 80G A100	21天
N	GPT-4	2023.03	-	-	-	-
Y	CodeGeeX	2022.09	13B	8500亿tokens	1536 Ascend 910	60天
N	PanGU-$\Sigma$	2023.03	1085B	3290亿tokens	512 Ascend 910	100天
Y	Pythia	2023.04	12B	3000亿tokens	256 40G A100	-

可以直接把对应的md丢给gpt，叫它导出一个excel，然后就可以自定义排序或者画散点图看了

LLM开源库

• transformers：huggingface的库

• deepspeed：微软的库，与pytorch兼容，训练了MT-NLG、BLOOM等模型，包括各种分布式训练优化技术，如内存优化（ZeRO、梯度检查点等）和管道并行。

• megatron-lm：英伟达的库，同样包括各种分布式训练技术，包括模型和数据并行、混合精度训练和FlashAttention。（Megatron-lm: Training multi-billion parameter language models using model parallelism、Efficient large-scale language model training on GPU clusters using megatron-lm和Reducing activation recomputation in large transformer models）

• jax：google的库，允许用户在带有硬件加速（GPU或TPU）的情况下进行数组的高效运算，可以在各种设备高效计算，支持自动微分和即时编译等功能。

• colossal-AI：HPC-AI Tech的库，基于pytorch，可以使用[PatrickStar](Patrickstar: Parallel training of pre-trained models via a chunk-based memory management)提出的方法优化异构内存管理，分布了基于LLaMA的ColossalChat

• BMTrain：openBMB的库，强调代码简洁、低资源占用和高可用性

• [FastMoE](Fastmoe: A fast mixture-of-expert training system)：专门用于MoE模型的训练库，基于pytorch，简化了将transformer转换为MoE模型的过程

• semantic-kernel：微软的开源库

AI的4场景战役

一些开源的小模型：从零训练的 1B 以下小模型汇总

一些综述

• Foundation Models for Natural Language Processing -- Pre-trained Language Models Integrating Media

• 大规模语言模型：从理论到实践，Pre-trained Models for Natural Language Processing: A Survey邱锡鹏等

• 人大的大模型综述：https://github.com/RUCAIBox/LLMSurvey，自己存了一份pdf，（！！！本文大部分内容按这个来组织！！！），出书和课件了：https://llmbook-zh.github.io/

• Talking about large language models

• Pre-train, prompt, and predict: A systematic survey of prompting methods in natural language processing，引用数2k+

• A comprehensive survey on pretrained foundation models: A history from BERT to chatgpt，唐杰等

• Pre-Trained Models: Past, Present and Future

• A Comprehensive Survey of AI-Generated Content (AIGC): A History of Generative AI from GAN to ChatGPT

• Pretrained Language Models for Text Generation: A Survey

• A survey for in-context learning

• Towards reasoning in large language models: A survey

• Reasoning with language model prompting: A survey

• Dense Text Retrieval based on Pretrained Language Models: A Survey

• Fine-tune之后的NLP新范式：Prompt越来越火，CMU华人博士后出了篇综述文章

• 如何高效部署大模型？CMU最新万字综述纵览LLM推理MLSys优化技术：Towards Efficient Generative Large Language Model Serving: A Survey from Algorithms to Systems

• 一篇对大语言模型（LLMs）进行全面、深入分析的43页综述（Word2Vec作者出品）==>Large Language Models: A Survey，自己存了一份

• Large Language Models for Information Retrieval: A Survey

• awesome-LLM-resourses

• 14天速成LLM高手！大佬开源学习笔记，GitHub狂揽700星：https://github.com/hesamsheikh/ml-retreat

• GitHub超火开发者路线图库有AI学习路线了！star数近30万：https://github.com/kamranahmedse/developer-roadmap

• 写的真好，万字长文串烧LLM大模型技术原理：https://zhuanlan.zhihu.com/p/713794852

• Jeff Dean演讲回顾LLM发展史，Transformer、蒸馏、MoE、思维链等技术都来自谷歌

• 盘一盘，2017年Transformer之后，LLM领域的重要论文

• 2023-2025大模型领域2年发展综述

• 一个google大佬的笔记：google doc，我copy了一份：google doc，同时导出了一个pdf

• 这个真的不错：https://github.com/changyeyu/LLM-RL-Visualized，自己fork了一份：https://github.com/daiwk/LLM-RL-Visualized

• Learning Deep Representations of Data Distributions：马毅团队重磅发布新书：从MCR²到白盒Transformer，重构深度学习的第一性原理，https://ma-lab-berkeley.github.io/deep-representation-learning-book/index.html

课程

https://github.com/mlabonne/llm-course

https://github.com/PacktPublishing/LLM-Engineers-Handbook

https://github.com/decodingml/llm-twin-course

Sebastian Raschka著作免费开放！《机器学习与AI核心30问》，新手专家皆宜

https://sebastianraschka.com/books/ml-q-and-ai/#table-of-contents 对应的代码：https://github.com/rasbt/MachineLearning-QandAI-book

面试题

大模型面试八股

大模型八股答案（一）——基础知识

大模型八股答案（二）——训练框架

信息过载时代，如何真正「懂」LLM？从MIT分享的50个面试题开始

https://github.com/daiwk/collections/blob/master/assets/interviews/MIT_LLM_Interview_Questions.pdf

openai面试题

扩展法则(scaling law)

openai的扩展法则

2020年,openai的Scaling laws for neural language models通过拟合模型在不同数据大小（2000w到230亿个token）、不同的模型大小（7.68亿到15亿个非嵌入参数）的性能，提出了在计算预算$c$的条件下，$L$是用nats(信息量的单位，底数为e的ln，即交叉熵是用的ln，不是log2)表示的交叉熵损失，模型性能与模型规模$N$、数据集规模$D$以及训练计算量$C$间存在如下幂律关系：

$L(N)=(\frac{N_c}{N})^{\alpha _N}, {\alpha}_N\sim 0.076,N_c\sim 8.8\times 10^{13}$

$L(D)=(\frac{D_c}{D})^{\alpha _D}, {\alpha}_D\sim 0.095,D_c\sim 5.4\times 10^{13}$

$L(C)=(\frac{C_c}{C})^{\alpha _C}, {\alpha}_C\sim 0.05,C_c\sim 3.1\times 10^{8}$

其中，$N_c$表示非嵌入参数数量，$D_c$表示训练token数量，$C_c$表示PF-days，其中$1 PF-days = 10^{15}\times 86400=8.64\times 10^{19}$浮点数运算。

Go Wider Instead of Deeper说了，transformer效果的提升不在于计算量的变大，而应该在于通过提升模型的hidden dim来增加模型参数量

Chinchilla扩展法则

DeepMind在Training compute-optimal large language models中提出了Chichilla扩展法则来指导LLM最优计算量的训练。通过变化更大范围的模型大小（7000w到160亿参数）和数据大小（50亿到5000亿个token）进行实验，拟合了如下的扩展法则：

$$L(N, D)=E+\frac{A}{N^\alpha}+\frac{B}{D^\beta}$$

其中$E=1.69,A=406.4,B=410.7,\alpha = 0.34, \beta =0.28$，通过在约束条件$C\approx 6ND$下优化损失$L(N,D)$，将计算预算最优地分配给模型大小和数据大小的方法：

$$N_{o p t}(C)=G\left(\frac{C}{6}\right)^a, \quad D_{o p t}(C)=G^{-1}\left(\frac{C}{6}\right)^b$$

其中$a=\frac{\alpha}{\alpha+\beta}$，$b=\frac{\beta}{\alpha+\beta}$，$G$是由$A,B,\alpha,\beta$计算出的扩展系数。

随着计算预算的增加，

• openai的扩展法则更偏向于将更大预算分给模型大小，因为其对比各模型时使用了固定的训练数据量和学习率等超参，低估了数据量的作用。每增加10倍的计算量，应该让数据集大小增加为约1.8倍，模型参数量增加为约5.5倍。即模型参数量更加的重要。

• Chinchilla扩展法则认为模型大小和数据大小要同比例增加，即$a$和$b$取值差不多。因为其在无视模型大小的前提下，发现设置与数据量差不多match的学习率能获得更好的loss。每增加10倍的计算量，应该让数据集大小增加为约3.16倍，模型参数量也增加为约3.16倍。即数据集大小和模型参数量一样重要。

然而，有一些能力（如涌现）无法根据扩展法则进行预测，只有当模型达到一定规模时才会出现。

chinchilla-law

飘红的就是常见的10B模型，大概要205B的token来训练，能达到计算最优点，当然并不一定是loss最小的点，这个可以参考llama3的现象

scaling law的一些讨论

Scaling Laws 又失灵了？谷歌新研究：扩散模型不是越大越好

Bigger is not Always Better: Scaling Properties of Latent Diffusion Models

腾讯混元、北大发现Scaling law「浪涌现象」，解决学习率调参难题

Surge Phenomenon in Optimal Learning Rate and Batch Size Scaling

SIGIR24最佳论文：Scaling Laws For Dense Retrieval

中科大联合华为诺亚提出Entropy Law，揭秘大模型性能、数据压缩率以及训练损失关系

词表的scaling law

NeurIPS 2024 | 大模型的词表大小，同样适用于Scaling Law

Scaling Laws with Vocabulary: Larger Models Deserve Larger Vocabularies

https://github.com/sail-sg/scaling-with-vocab/

scaling law for precision

Scaling Laws终结，量化无用，AI大佬都在审视这篇论文

Scaling Laws for Precision

你训练的 token 越多，你需要的精度就越高。

Densing law

LLM最大能力密度100天翻一倍！清华刘知远团队提出Densing Law

Densing Law of LLMs

涌现能力

llm-capabilities

涌现能力：在小型模型中不存在而在大型模型中产生的能力，当规模达到一定程度时，性能显著提升，超出随机水平（参考 Emergent Abilities of Large Language Models）。与物理学中的相变现象类似（物质从一种相（状态）转变为另一种相的过程，通常伴随着能量的吸收或释放，并且涉及不同的物理性质，例如固体、液体和气体之间的转变）。

普林斯顿DeepMind用数学证明：LLM不是随机鹦鹉！「规模越大能力越强」有理论根据

A Theory for Emergence of Complex Skills in Language Models：

涌现

LLM的3种典型涌现能力及其对应代表模型：

上下文学习(in-context learning)

GPT-3（Language models are few-shot learners）提出，只要提供一个自然语言指令和/或几个任务演示，语言模型就能通过完成输入文本的词序列的方式来为测试实例生成预期输出，不用额外的梯度更新。

• ICL能力小模型不具备：1750亿的GPT-3有ICL能力，但GPT-1和GPT-2无此能力。

• ICL能力取决于具体下游任务：130亿的GPT-3能在算术任务上有ICL，但1750亿的GPT-3在波斯语QA上无能为力。

指令遵循(instruction following)

使用自然语言描述的混合多任务数据集进行微调（指令微调），LLM在未见过的以指令形式描述的任务上表现出色，具有更好的泛化能力。例如Multitask prompted training enables zero-shot task generalization、Training language models to follow instructions with human feedback、Finetuned language models are zero-shot learners。

在Finetuned language models are zero-shot learners的实验中，当模型大小达到680亿时，经过指定微调的LaMDA-PT开始在未见过的任务上显著优于未微调的模型，而80亿或更小的模型则没有这个现象。

在Scaling instruction-finetuned language models的实验中，PaLM至少在620亿参数上才能在4个评估基准的各种任务上表现良好。

精准0误差，输入价格打骨折！OpenAI官宣API支持结构化输出，JSON准确率100％

逐步推理(multi-step reasoning)

对于涉及多个推理步骤的复杂任务（如数学），可以使用思维链（Chain-of-Thought, CoT）提示策略（Chain of thought prompting elicits reasoning in large language models），让LLM通过利用中间推理步骤的提示机制来解决这类任务。

Chain of thought prompting elicits reasoning in large language models发现，CoT在模型大于600亿的PaLM和LaMBDA变体中能够提升在算术推理基准任务的效果，而当模型大于1000亿时，相比标准提示的优势更明显。

How does GPT Obtain its Ability? Tracing Emergent Abilities of Language Models to their Sources

LLM关键点

如何让LLM能够通用且有能力？

扩展

更大的模型、数据规模和更多的训练计算，但计算预算是有限的，可以用扩展法更高效地分配计算资源，如Chinchilla在相同计算预算下增加训练token数，优于更大模型规模的Gopher，同时需要数据清理。

训练

• 分布式的训练框架：包括DeepSpeed（Deepspeed: System optimizations enable training deep learning models with over 100 billion parameters）和Megatron-LM（Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism和Efficient large-scale language model training on GPU clusters using megatron-lm）

• 优化技巧：有助于提升训练稳定性和模型性能，如重新开始以克服训练损失激增（Palm: Scaling language modeling with pathways）和混合精度训练（BLOOM: A 176b-parameter open-access multilingual language model）。

能力引导

当LLM执行某些特定任务时，可能不会显式地展示出其通用求解器的能力，设计合适的任务指令或具体的ICL策略可以激发这种能力，例如

• 通过包含中间推理步骤的CoT提示

• 使用自然语言表达的任务描述，对LLM进行指令微调

对齐微调

由于预训练语料库包括高质量和低质量的数据，LLM可能生成有毒、偏见甚至有害的内容，要让LLM和人类价值观保持一致，如有用性、诚实性和无害性。RLHF相关工作如Training language models to follow instructions with human feedback和Deep reinforcement learning from human preferences能够产生高质量、无害的回答（例如拒绝回答侮辱性问题）。

工具操作

LLM本质是基于海量文本语料库进行文本生成训练的，对于不适合以文本形式表达的任务表现不佳（如数字计算），且其能力受限于预训练数据，无法获取最新信息。可以利用外部工具：

• Toolformer: Language models can teach themselves to use tools能利用计算器进行准确计算

• Webgpt: Browser-assisted question-answering with human feed- back能利用搜索引擎检索未知信息

LLM数据集

常用数据集

llm中文数据集：https://juejin.cn/post/7238921093553438779

• Books：

  • BookCorpus：超过11000本电子书，用于GPT和GPT-2。

  • Gutenberg：超过70000本文学作品，包括小说、散文、诗歌、戏剧、历史、科学、哲学和其他公共领域，用于MT-NLG和LLaMA。

  • Books1和Books2：比BookCorpus大得多，但未公开，用于GPT-3。

• CommonCrawl：最大的开源网络爬虫数据库之一，百万亿字节，有大量噪音和低质信息，需要过滤，有如下4个子集：

  • C4：包括en（806G，训练T5、LaMDA、Gopher、UL2）、en.noclean（6T）、realnewslike（36G）、webtextlike（17G）、multilingual（38T，训练mT5）。

  • CC-Stories：31G，内容以故事的形式展示

  • CC-News：76G

  • RealNews：120G

• Reddit Links：Reddit上的帖子，高赞通常比较有用，可以拿来创建高质量数据集。

  • WebText：由Reddit上的高赞链接组成，未公开，对应的开源版是OpenWebText。

  • Pushshift.io：实时更新的数据集，包括Reddit自创建以来的历史数据，有数据存储，也有实用工具，供用户搜索、总结和统计分析。

• Wikipedia：大部分文章使用写作风格，并支持引用，英语版本用于大多数LLM，如GPT-3、LaMDA、LLaMA，还有多语言版。

• Code：包括开源许可证的公共代码库（如github）和与代码相关的问答平台（如StackOverflow）,Google公开了BigQuery数据集，CodeGen用的BIGQUERY是其的一个子集。

• 其他：

  • The Pile有800G，包括书籍、网站、代码、科学论文和社交媒体平台，有22个子集，用于GPT-J(6B)、CodeGen(16B)、Megatron-Turing NLG（530B）。

  • ROOTS由各种小数据集组成，共1.6T，包括59种语言（自然语言和编程语言），用于BLOOM。

数据收集

数据获取

• 通用文本数据：

  • 网页：例如CommonCrawl，同时需要过滤和处理以提高质量

  • 对话文本：公共对话数据如PushShift.io，对于在线社交媒体的对话数据，可以转换成树形结构，每句话与回应其的话相连。多方的对话树可以划分为预训练语料库中的多个子对话。过度引入对话数据可能会有潜在风险（OPT: open pre-trained transformer language models）：陈述性指令和直接疑问句被错误地认为是对话的开始，导致指令的有效性下降。

  • 书籍：更正式的长文本，利于学习语言知识、建模长期依赖关系、生成叙述性和连贯的文本。

• 专用文本数据：

  • 多语言文本：BLOOM的预训练语料中包括了46种语言，PaLM包含了122种

  • 科学文本：如arxiv论文、科学教材、数学 网页等，通常需要特定的标记化和预处理。

  • 代码：一是编程问答社区，二是开源代码仅为。对应长距离依赖和准确的执行逻辑，可能是复杂推理能力的来源。将推理任务格式化为代码形式还能帮LLM生成更准确的结果（如Language models of code are few-shot commonsense learners和Autoformalization with large language models）

数据预处理

• 质量过滤：有一些基于分类器的方法，例如维基百科的数据为正样本，负采样其他数据训练二分类器，但这种方法会删除方言、口语和社会语言的高质量文本，可能导致有偏、减少多样性。还有启发式的方法，主要包括：

  • 基于语言的过滤：如果该llm主要用于某种语言，可以把其他语言删了

  • 基于度量的过滤：利用生成文本的评估度量（如perplexity）来检测和删除不自然的句子

  • 基于统计的过滤：如标点符号分布、符号和单词比例、句子长度等

  • 基于关键词的过滤：删除噪声或无用元素，如HTML标签、超链接、模板、攻击性词语等。

• 去重：Scaling laws and interpretability of learning from repeated data中发现重复数据会降低多样性，可能导致训练不稳定。下面3个级的去重都很有用

  • 句子级：删掉包含重复单词和短语的句子，因为可能在语言建模中引入重复模式（The curious case of neural text degeneration）(后面的章节会讲)

  • 文档级：通过文档间的表层特征（如n-gram或单词重合率）来删掉重复文档

  • 数据集级：训练集中删掉测试集可能出现的重复文本，防止训练集和评估集间的重叠

• 隐私去除：删掉可识别个人信息（PII），如基于关键词（姓名、地址、电话号码）识别。另外，Deduplicating Training Data Mitigates Privacy Risks in Language Models发现LLM在隐私攻击下的脆弱性可能归因于预训练语料中存在重复PII数据。

• 分词：可以直接利用已有分词器，也可以使用专门为预训练语料库设计的分词器，如SentencePiece，而且BPE(byte pair encoding)能确保分词后的信息不会丢失，但其中的如NFKC(Unicode normalization forms)的归一化技术可能会降低分词的性能。

预训练语料的重要性

• 混合来源：不同领域和场景的数据能让LLM有更强大的泛化能力。需要仔细设置数据分布，Gopher对数据分布消融，发现增加书籍数据可以提升捕捉长期依赖的能力，增加c4数据集比例可以提升其在c4验证集上的效果，但单独训练过多的某个领域数据会影响LLM在其他领域的泛化能力。

• 数据量：模型性能方面，数据大小也能看到与模型大小类似的扩展法则。LLaMA发现，用更多数据训练更长时间，较小的模型也能实现良好性能。

• 数据质量：Gopher、GLaM和T5都发现，在清理后的数据上训练能提升llm效果。数据的重复可能导致『双下降现象』（Scaling laws and interpretability of learning from repeated data和Deep double descent: Where bigger models and more data hurt），甚至会导致训练不稳定。此外，Scaling laws and interpretability of learning from repeated data还发现，重复数据会降低LLM从上下文复制的能力，从而影响ICL中的泛化能力。

注：双下降指的是随着模型复杂性的增加，可能loss先下降，然后再升高，最后又下降：

• 当模型的复杂性低于数据的复杂性时，增加模型的复杂性可以帮助减少训练误差。

• 当模型的复杂性超过数据的复杂性时，增加模型的复杂性反而可能导致训练误差增加。这是因为模型开始过拟合数据，捕获数据中的噪声而非实际的模式。

• 当模型的复杂性远大于数据的复杂性时，训练误差可能再次开始减少。这是因为模型有足够的能力来对数据的噪声进行平滑，同时仍然能够捕获数据的实际模式。

benchmark

MMLU

Measuring massive multitask language understanding

LLM模型架构

MoE原理

MoE模型的前世今生

MoE 系列论文解读：Gshard、FastMoE、Tutel、MegaBlocks 等

CMU开源GRIFFIN：一种新颖的无需训练的MoE方法，提高大模型的生成效率！

Prompt-prompted Mixture of Experts for Efficient LLM Generation

From Sparse to Soft Mixtures of Experts: softmoe

MoE的核心问题是一个如何把token分配给哪个专家的离散优化问题，有如下离散+稀疏的分配方法，都需要辅助loss来平衡每个专家的负载，以减少drop tokens：

• 线性规划

• 强化学习

• 人为固定规则

• 最优运输方法

• 贪心topk token-choose-expert

• 贪心topk expert-choose-token

softmoe

在softmoe中，假设N个token，S个slot，E个expert

代码：

https://github.com/google-research/vmoe/blob/main/vmoe/projects/soft_moe/router.py#L97和https://github.com/google-research/vmoe/blob/main/vmoe/moe.py#L128

算法、系统和应用，三个视角全面读懂混合专家（MoE）

A Survey on Mixture of Experts

moe-gating

从ACL 2024录用论文看混合专家模型（MoE）最新研究进展

Dynamic MoE

Harder Tasks Need More Experts: Dynamic Routing in MoE Models

https://github.com/ZhenweiAn/Dynamic_MoE

XMoE

是上面两种方法的并集

XMoE: Sparse Models with Fine-grained and Adaptive Expert Selection

https://github.com/ysngki/XMoE

HyperMoE

HyperMoE: Towards Better Mixture of Experts via Transferring Among Experts

https://github.com/Bumble666/Hyper_MoE

Expert Pruning

Not All Experts are Equal: Efficient Expert Pruning and Skipping for Mixture-of-Experts Large Language Models

https://github.com/Lucky-Lance/Expert_Sparsity

MixLoRA

Multimodal Instruction Tuning with Conditional Mixture of LoRA

ESFT

Let the Expert Stick to His Last: Expert-Specialized Fine-Tuning for Sparse Architectural Large Language Models

多模态MoE

混合专家更有主见了，能感知多模态分情况行事，Meta提出模态感知型专家混合

Chameleon: Mixed-modal early-fusion foundation models单一Transformer架构，可以根据下一个token的预测目标，对由离散图像和文本token组成的混合模态序列进行建模，从而在不同模态之间进行无缝推理和生成。然而对于Chameleon这样各种模态会在模型训练的早期混合起来的模型，想要拓展它的能力，需要投入大量算力。

MoMa: Efficient Early-Fusion Pre-training with Mixture of Modality-Aware Experts使用路由式稀疏架构（routed sparse architecture）

HMOE

优化传统MoE结构，腾讯混元团队提出专家差异化新思路

HMoE: Heterogeneous Mixture of Experts for Language Modeling

在 HMoE 中，每个专家的大小不再相同，从而赋予了每个专家不同的表达能力。这种差异化设计使得路由可以根据专家的实际能力动态分配不同难度的 token，有效解决了专家专业化程度不足的问题。

OLMoE

OLMoE: Open Mixture-of-Experts Language Models

https://huggingface.co/allenai/OLMoE-1B-7B-0924

https://github.com/allenai/OLMoE

元象MOE

中国最大开源MoE模型，255B参数无条件免费商用，元象发布

XVERSE-MoE-A36B，该模型总参数255B，激活参数36B，达到100B模型性能的「跨级」跃升。

https://github.com/xverse-ai/XVERSE-MoE-A36B

MoEUT

Jurgen、曼宁等大佬新作：MoE重塑6年前的Universal Transformer，高效升级

MoEUT: Mixture-of-Experts Universal Transformers

https://github.com/robertcsordas/moeut

MoA

无问芯穹提出混合稀疏注意力方案MoA，加速长文本生成，实现最高8倍吞吐率提升

https://github.com/thu-nics/MoA

MoA: Mixture of Sparse Attention for Automatic Large Language Model Compression

GRIN

专家模型不要专家并行！微软开源MoE新路径

GRIN: GRadient-INformed MoE

主流框架

• 编码器-解码器架构(encoder-decoder)：标准Transformer，如T5、BART，只有少数LLLM还用这种结构，如Flan-T5

• 因果解码器架构(causual decoder)：也叫decoder-only，单向注意力掩码，输入和输出token通过解码器以相同方式进行处理，以GPT系列为代表，现有大部分LLM都是这种架构，如OPT、BLOOM、Gopher等。

• 前缀解码器架构(prefix decoder)：修正因果解码器的掩码机制，使其能对前缀token执行双向注意力，并且仅对生成的token执行单向注意力（和encoder-decoder类似），即Unified language model pre-training for natural language understanding and generation提出的uni-lm。What language model architecture and pretraining objective works best for zero-shot generalization?建议不从头开始预训练，而是继续训练因果编码器，然后将其转换成前缀编码器以加速收敛。例如U-PaLM从PaLM演化而来，还有GLM-130B也是这种架构。

uni-lm

https://github.com/microsoft/unilm

对于这3种架构，都可以用MoE进行扩展，每个输入的一小部分神经网络权重被稀疏激活，如Switch Transformer和GLaM。Unified scaling laws for routed language models发现，通过增加专家数量或总参数大小，性能会有显著改进。

讨论：为什么现在的LLM都是Decoder only的架构？

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

• 泛化性能强：ICML 22的What language model architecture and pretraining objective works best for zero-shot generalization.在最大5B参数量、170B token数据量的规模下做了一些列实验，发现用next token prediction预训练的decoder-only模型在各种下游任务上zero-shot泛化性能最好；另外，ACL23的Why Can GPT Learn In-Context? Language Models Implicitly Perform Gradient Descent as Meta-Optimizers等工作表明，decoder-only模型相当于基于给出的几个示例隐式地进行梯度下降，对应的in-context learning泛化能力更强，

• 秩的讨论：Attention is not all you need: pure attention loses rank doubly exponentially with depth的讨论，$n\times d$和$d\times n$相乘后（$n\gg d$）再加上softmax后，秩不超过$d$，而decoder-only中有一个下三角矩阵的mask，所以输入的是一个下三角矩阵，而下三角矩阵的行列式是对角线之积，且有softmax，对角线肯定大于0，所以是满秩的(行列式不为0-->矩阵经过变换后不会有一行或者一列全为0-->当前矩阵满秩)

• 预训练任务难度更大：相比encoder-decoder，decoder-only架构里每个位置能接触到的信息更少，故难度更高，当模型大小和数据量够的时候，上限更高

• 隐式学习了位置信息：Transformer Language Models without Positional Encodings Still Learn Positional Information，encoder里对语序的区分能力较弱，需要结合position encoding，而causual attention隐式地具备了这种建模位置的能力。

• 工程效率：支持复用kv-cache，对多轮对话更友好，**『DIN的FLOPS』**一节里有讲

盛名一时的BERT哪去了？这个问题的答案昭示了LLM范式的转变

What happened to BERT & T5? On Transformer Encoders, PrefixLM and Denoising Objectives

去噪目标

去噪目标指的是span corruption任务的任意变体，即填充(infilling)或填空(fill in the blank)。表达方式有很多，比如span长度、随机性、sentinel token等。

• BERT类的模型中，大部分是in-place的去噪目标，例如对mask tokens的分类head，

• T5的做法则是通过encoder-decoder或decoder-only模型来处理数据变换，即把masked token move to the back给模型预测。

去噪目标的效果很好，可以作为常规语言建模的补充目标，但不足以单独作为目标，因为去噪有两个缺点：

• 更少的loss exposure：在去噪目标中，只有少量token会被mask和学习，而常规语言建模则接近100%，使得每个FLOP的样本效率非常低

• 比常规语言建模更不自然：以一种奇怪的方式重新设定输入输出格式，不太适合少样本学习

PrefixLM vs decoder-only

注：归纳偏置(inductive bias)指模型在预测未遇到的输入时，做的一些假设的集合，例如最小描述长度（奥卡姆剃刀）指的就是当构成一个假设时，试图去最小化其假设的描述长度。假设越简单，越可能为真的。

对语言模型来说，双向注意力是一种有趣的归纳偏置，相比于较小规模的场景，双向注意力在规模较大时可能就没那么重要了，或者可能对不同的任务或模态有不同的影响，例如PaliGemma就用的prefixLM（PaliGemma: A versatile 3B VLM for transfer）

paligemma

PrefixLM也存在缓存问题，是这类架构的一个固有缺陷

encoder-decoder的优缺点

• 相比decoder-only的优势：endocer不受causal的限制，可以激进地试各种pooling/linear attention，因此可以offload一些不那么重要的context到encoder中，也可以让encoder更小，例如Charformer

• 相比prefixLM的缺点：输入和目标必须分配固定的预算，例如输入预算是1024token，那么encoder就必须pad到1024，而这可能会浪费大量计算。相反，在 PrefixLM 中，输入和目标可以直接concat起来，从而可以缓解这个问题

组件配置

标准化（norm）

LN(layer norm)能缓解LLM训练不稳定的问题，其位置很重要。

pre-ln

• 前置LN：最初Transformer使用后置LN，但大多数LLM采用前置LN以实现更稳定的训练，尽管会有一些性能损失(On layer normalization in the transformer architecture)。Sandwich-LN在残差连接前添加额外的LN，虽然能避免数值爆炸，但有时会无法稳定LLM的训练，可能导致训练崩溃（GLM-130B: an open bilingual pre-trained model）

• RMS Norm：训练和性能都不错，在Gopher和Chinchilla里使用

• Deep Norm：比LN有更好的训练稳定性，和后标准化一起用在GLM-130B里

deep-norm

• DyT：用$tanh(\alpha x)$替换掉layer norm里的normalize

class DyT(nn.Module):
    def __init__(self, num_features, alpha_init_value=0.5):
        super().__init__()
        self.alpha = nn.Parameter(torch.ones(1) * alpha_init_value)
        self.weight = nn.Parameter(torch.ones(num_features))
        self.bias = nn.Parameter(torch.zeros(num_features))
    
    def forward(self, x):
        x = torch.tanh(self.alpha * x)
        return x * self.weight + self.bias

此外，在emb后直接加额外的LN能提升训练稳定性，但会导致显著的性能下降(What language model to train if you have one million GPU hours?)，在后来的LLM中被移除（BLOOM: A 176b-parameter open-access multilingual language model）。

神经网络可能不再需要激活函数？Layer Normalization也具有非线性表达！

On the Nonlinearity of Layer Normalization

激活函数

FFN中的激活函数：

• GeLU：大部分都是这个

• GLU(gated linear units)的变体：应用在PaLM和LaMDA等模型中，如SwiGLU和GeGLU有更好的效果，但在FFN中的参数量比GeLU要大50%

原始Transformer中

$\operatorname{FFN}\left(x, W_1, W_2, b_1, b_2\right)=\max \left(0, x W_1+b_1\right) W_2+b_2$

T5中把bias干掉了

$\operatorname{FFN}_{\operatorname{ReLU}}\left(x, W_1, W_2\right)=\max \left(x W_1, 0\right) W_2$

然后，$\operatorname{GELU}(x)=x \Phi(x)$，同时$\operatorname{Swish}_\beta(x)=x \sigma(\beta x)$，接下来

$\operatorname{GLU}(x, W, V, b, c)=\sigma(x W+b) \otimes(x V+c)$

$\operatorname{Bilinear}(x, W, V, b, c)=(x W+b) \otimes(x V+c)$

$\operatorname{ReGLU}(x, W, V, b, c)=\max (0, x W+b) \otimes(x V+c)$

$\operatorname{GEGLU}(x, W, V, b, c)=\operatorname{GELU}(x W+b) \otimes(x V+c)$

$\operatorname{SwiGLU}(x, W, V, b, c, \beta)=\operatorname{Swish}_\beta(x W+b) \otimes(x V+c)$

对应起来就是

$\operatorname{FFN}_{\mathrm{GLU}}\left(x, W, V, W_2\right)=(\sigma(x W) \otimes x V) W_2$

$\operatorname{FFN}_{\text {Bilinear }}\left(x, W, V, W_2\right)=(x W \otimes x V) W_2$

$\operatorname{FFN}_{\operatorname{ReGLU}}\left(x, W, V, W_2\right)=(\max (0, x W) \otimes x V) W_2$

$\operatorname{FFN}_{\text {GEGLU }}\left(x, W, V, W_2\right)=(\operatorname{GELU}(x W) \otimes x V) W_2$

$\operatorname{FFN}_{\text {SwiGLU }}\left(x, W, V, W_2\right)=\left(\operatorname{Swish}_1(x W) \otimes x V\right) W_2$

位置编码

Transformer的self-attention有转换不变性，故要位置编码以引入绝对或相对位置信息来建模序列。

• 绝对位置编码：

  • 正弦函数：原始Transformer中使用

  • 可学习的位置编码：LLM中常用

• 相对位置编码：Exploring the limits of transfer learning with a unified text-to-text transformer提出，其实是在Self-attention with relative position representations一文提出的，根据k和q之间的偏移量生成emb

• Alibi：Train short, test long: Attention with linear biases enables input length extrapolation提出，使用k和q之间距离的惩罚来给注意力分数加bias，What language model architecture and pretraining objective works best for zero-shot generalization发现其有更好的零样本泛化能力和更强的外推能力，能够在比训练序列更长的序列上表现良好。

• RoPE：Roformer: Enhanced transformer with rotary position embedding提出，k和q之间的分数用相对位置信息计算，利于建模长序列，在PaLM、LLaMA、GLM-130B中都有应用。

注意力机制和Bias

• 稀疏注意力：Generating long sequences with sparse transformers)，计算复杂度更低，GPT-3用了

• FlashAttention：Flashattention: Fast and memory-efficient exact attention with IO-awareness，考虑显存访问

• 其他attention：如Random feature attention、Big bird: Transformers for longer sequences

• 移除bias：PaLM和Galactica中将bias删了，能够增加训练稳定性。

小结

归一化位置

sublayer表示FFN或self-attention模块

方法	公式
post Norm	$\operatorname{Norm}(\mathbf{x}+\operatorname{Sulayerb}(\mathbf{x}))$
pre Norm	$\mathbf{x}+\operatorname{Sublayer}(\operatorname{Norm}(\mathbf{x}))$
Sandwich Norm	$\mathbf{x}+\operatorname{Norm}(\operatorname{Sublayer}(\operatorname{Norm}(\mathbf{x})))$

归一化方法

方法	公式
Layer Norm	$\frac{\mathrm{x}-\mu}{\sqrt{\sigma}} \cdot \gamma+\beta, \quad \mu=\frac{1}{d} \sum_{i=1}^d x_i, \quad \sigma=\sqrt{\frac{1}{d} \sum_{i=1}^d(x_i-\mu)^2}$
RMSNorm	$\frac{\mathrm{x}}{\operatorname{RMS}(\mathrm{x})} \cdot \gamma, \quad \operatorname{RMS}(\mathbf{x})=\sqrt{\frac{1}{d} \sum_{i=1}^d x_i^2}$
Deep Norm	$LayerNorm (\alpha \cdot \mathbf{x}+\operatorname{Sublayer}(\mathbf{x}))$

激活函数

方法	公式
ReLU	$\operatorname{ReLU}(\mathbf{x})=\max (\mathbf{x}, \mathbf{0})$
GeLU	$\operatorname{GeLU}(\mathbf{x})=0.5 \mathrm{x} \otimes[1+\operatorname{erf}(\mathbf{x} / \sqrt{2})], \quad \operatorname{erf}(x)=\frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} d t$
Swish	$\operatorname{Swish}(\mathbf{x})=\mathbf{x} \otimes \operatorname{sigmoid}(\mathbf{x})$
SwiGLU	$\operatorname{SwiGLU}\left(\mathbf{x}_1, \mathbf{x}_2\right)=\operatorname{Swish}\left(\mathbf{x}_1\right) \otimes \mathbf{x}_2$
GeGLU	$\operatorname{GeGLU}\left(\mathbf{x}_1, \mathbf{x}_2\right)=\operatorname{GeLU}\left(\mathbf{x}_1\right) \otimes \mathbf{x}_2$

位置嵌入

• $A_{ij}$：q和k之间的注意力分数

• $r_{i-j}$：基于q和k之间偏移的可学习标量

• $\mathbf{R}_{\theta, i-j}$：旋转角度为$t\cdot \theta$的旋转矩阵

方法	公式
绝对位置编码	$\mathbf{x}_i=\mathbf{x}_i+\mathbf{p}_i$
相对位置编码	$A_{i j}=\mathbf{W}_q \mathbf{x}_i \mathbf{x}_j^T \mathbf{W}_k^T+r_{i-j}$
RoPE	$A_{i j}=\mathbf{W}_q \mathbf{x}_i \mathbf{R}_{\theta, i-j} \mathbf{x}_j^T \mathbf{W}_k^T$
Alibi	$A_{i j}=\mathbf{W}_q \mathbf{x}_i \mathbf{R}_{\theta, i-j} \mathbf{x}_j^T \mathbf{W}_k^T A_{i j}=\mathbf{W}_q \mathbf{x}_i \mathbf{x}_j^T \mathbf{W}_k^T-m(i-j)$

预训练任务

语言建模

语言建模是仅解码器LLM的常见目标，给定token序列$\mathbf{x}=\left\{x_1, \ldots, x_n\right\}$，旨在基于序列中前面的token，自回归地预估目标token：

$$\mathcal{L}_{L M}(\mathbf{x})=\sum_{i=1}^n \log P\left(x_i \mid x_{<i}\right)$$

对应到代码里：

hidden_states = outputs[0]
logits = self.lm_head(hidden_states)

# gemma系列模型会做soft-cap
cap = self.config.logits_soft_cap
logits = nn.functional.tanh(logits / cap) * cap

logits = logits.float()
loss = None
if labels is not None:
    # Shift so that tokens < n predict n
    ## 假设句子长度为4，词表有3个词，
    ## logits: [ [0.1, 0.2, 0.7], [0.3, 0.4, 0.3], [0.5, 0.2, 0.3], [0.6, 0.1, 0.3] ]
    ## labels: [0, 2, 1, 0]
    ## shift_logits: [ [0.1, 0.2, 0.7], [0.3, 0.4, 0.3], [0.5, 0.2, 0.3]
    shift_logits = logits[..., :-1, :].contiguous()
    ## shift_labels: [2, 1, 0]
    shift_labels = labels[..., 1:].contiguous()
    # Flatten the tokens
    loss_fct = CrossEntropyLoss()
    # [, seq_len - 1, vocab_size] 变为 [( * (seq_len - 1)), vocab_size]
    shift_logits = shift_logits.view(-1, self.config.vocab_size)
    # [, seq_len - 1] 变为 [( * (seq_len - 1))]
    shift_labels = shift_labels.view(-1)
    # Enable model parallelism
    shift_labels = shift_labels.to(shift_logits.device)
    loss = loss_fct(shift_logits, shift_labels)

前缀解码器架构使用的是前缀语言建模任务，其loss不涉及对前缀内token的预测，故预训练时涉及的序列中token较少，故当预训练token数相同时，前缀语言模型的性能往往略低于传统语言模型任务。

另外，自回归的loss：

• 训练时：是可以并行的，因为每个位置的label是已知的，可以并行算，

• 预测时：是串行的，因为得预测完了第t个词，才能去预测第t+1个词。

去噪自编码

DAE是BERT待模型的常见任务，即MLM（masked language model），输入$\mathbf{x}_{\backslash \tilde{\mathbf{x}}}$是一些有随机替换区间的损坏文本，目标是恢复被替换的token $\tilde{\mathbf{x}}$：

$$\mathcal{L}_{D A E}(\mathbf{x})=\log P\left(\tilde{\mathbf{x}} \mid \mathbf{x}_{\backslash \tilde{\mathbf{x}}}\right)$$

在T5和GLM-130B中使用，自回归地恢复替换区间。

其他任务

multi-token prediction，一次预估未来的k个词

Better & Faster Large Language Models via Multi-token Prediction

multi-token-prediction

典型LLM简介

llm榜单：

https://huggingface.co/spaces/lmsys/chatbot-arena-leaderboard

llm-families

GPT系列

GPT3

2020年的gpt3：Language models are few-shot learners，175b（1750亿）参数，当参数量到达千亿时出现了『涌现』现象，发现可以in-context learning。

CODEX

Evaluating Large Language Models Trained on Code

能够解析自然语言，并生成代码。CODEX是gpt3在github上收集的代码语料上进行finetune得到的，并且在微软的copilot中使用。

WebGPT

WebGPT: Browser-assisted question-answering with human feedback

https://openai.com/blog/webgpt/

为了回答开放性问题，使用基于文本的浏览器对gpt3进行finetune，包括如下3个步骤：

• 学习使用人类示范（demonstration）数据来模仿人类的浏览行为

• 学习一个reward函数来预测人类偏好

• 用强化学习和拒绝采样来优化reward函数

注：重要性采样和拒绝采样

• 重要性采样的关键是降低方差：因为相同的样本量，用$\pi(x)$分布采样得到的结果方差较大(或者是$\pi(x)$不好采样)，而用$p(x)$采样的样本得到的结果方差较小，用来估计原分布$\pi(x)$

• 拒绝采样：引入易于采样的分布$Q(x)$，然后从中随机地筛掉某些样本(根据接受概率接受或者拒绝样本)，使得剩下的样本服从分布$P(x)$

拒绝采样的步骤：

• 从辅助分布$Q(x)$中采样得到样本$x_i$

• 计算接受概率$A = P(x_i) / (M \times Q(x_i))$，其中$M$是一个常数，满足$P(x) \leq M \times Q(x)$对于所有$x$成立

• 以概率$A$接受样本$x_i$，即生成一个随机数$u$，如果$u \leq A$，则接受样本$x_i$；否则拒绝样本$x_i$。

重复上述步骤，直到获得足够数量的样本。

InstructGPT

Training language models to follow instructions with human feedback

sft+rm+rl，在最小性能降低的情况下，提升了生成结果的真实性，并降低了毒害性

ChatGPT&GPT-4

2022.11.30推出了ChatGPT，基于GPT3.5，即InstructGPT的兄弟

2023.3推出了GPT-4，多模态LLM，能输入图像和文本

o3/o4-mini：Agent 要被吃进大模型了

LLaMA系列

LLaMA

2023年2月发布，LLaMA: Open and Efficient Foundation Language Models，开源的LLaMA-13B比 GPT3 175B在很多任务上都更好

参考代码： https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/modeling_llama.py

https://github.com/meta-llama/llama

之前的工作考虑的是在训练预算有限的前提下，如何提升模型性能（2022年deepmind的Training Compute-Optimal Large Language Models的Chinchilla）,llama考虑在预测时的预算。例如chinchilla是一个10b的模型在200b的token上训练，但其实一个7b的模型当用了1T的token后，性能仍在提升。LLama-13b比gpt3在大多数benchmark上好，但size只有1/10，在一个GPU上就能跑。

llama只用公开数据训练，而Chinchilla、PaLM、GPT-3都有自己的未公开数据集。其他的OPT、GPT-NeoX、BLOOM、GLM虽然也只用公开数据集，但打不过PaLM-62B或者Chinchilla

预训练数据

• English CommonCrawl(67%)：使用CCNet pipeline，去重、用fasttext把非英文的页面删了，用n-gram把低质内容删了。此外，还训了一个线性模型，对页面进行分类：作为维基百科的引用 vs 随机采样的页面，最后把不属于引用这个类别的页面删了

• C4(15%)：与CCNet类似，主要区别在质量过滤是基于启发式的规则，如标点符号的存在，或者词数和句子数

• github(4.5%)：使用Google BigQuery里的公开github数据集，只用Apache、D和MIT证书的。低质判断是启发式规则，如字母数字占比、行的长度等，用正则删掉head等样式，最终以文件粒度进行去重。

• wikipedia(4.5%)：2022年6-8月的数据，包括20种语言

• Gutenberg and Books3(4.5%)：两个书籍数据集，对有90%以上内容重复的书籍做去重。

• Arxiv(2.5%)：拿原始的tex文件，删掉first section之前的东西，还有一些注释、宏

• Stack Exchange(2%)：高质量的问答网站，按答案的分数排序

llama_data

tokenizer：BPE，使用sentencepiece的实现。将所有numbers切成单个数字，回退到字节去处理未知的utf8字符（fallback to bytes to decompose unknown UTF-8 characters）

总共有1.4T的token，对大部分训练数据，每个token在训练时只用了一次，除了维基和book大概用了两次。

附：gpt4说：当我们说"一个token只训练一次"，我们其实是在说在一个epoch（一个完整遍历训练集的过程）中，我们只遍历一次完整的数据集。如果一个特定的token在数据集中出现多次，那么在一个epoch中，这个token就会被用来训练模型多次。

llama

一些大模型

网络结构

• SwiGLU激活函数(PaLM)：取代ReLU，Glu variants improve trans- former，把PaLM里的$4d$改了$2/34d$

说白了就是输入$x$，SwiGLU激活完是$swish(w_1(x)) * w_3(x)$，其中swish又叫silu，是$f(x)=x \cdot sigmoid(x)$

然后再过一个$w_2$，得到$w_2(swish(w_1(x)) * w_3(x))$就是最终的ffn输出

以下是transformers里的实现：https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/modeling_llama.py

class LlamaMLP(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.config = config
        self.hidden_size = config.hidden_size
        self.intermediate_size = config.intermediate_size
        self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
        self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
        self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
        self.act_fn = ACT2FN[config.hidden_act] ## 默认是silu，即swish

    def forward(self, x):
        if self.config.pretraining_tp > 1:
            slice = self.intermediate_size // self.config.pretraining_tp
            gate_proj_slices = self.gate_proj.weight.split(slice, dim=0)
            up_proj_slices = self.up_proj.weight.split(slice, dim=0)
            down_proj_slices = self.down_proj.weight.split(slice, dim=1)

            gate_proj = torch.cat(
                [F.linear(x, gate_proj_slices[i]) 
                    for i in range(self.config.pretraining_tp)], dim=-1
            )
            up_proj = torch.cat([F.linear(x, up_proj_slices[i]) 
                for i in range(self.config.pretraining_tp)], dim=-1)

            intermediate_states = (self.act_fn(gate_proj) * up_proj).split(slice, dim=2)
            down_proj = [
                F.linear(intermediate_states[i], down_proj_slices[i]) 
                    for i in range(self.config.pretraining_tp)
            ]
            down_proj = sum(down_proj)
        else:
            down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))

        return down_proj

这个是llama官方代码的实现：https://github.com/meta-llama/llama/blob/ef351e9cd9496c579bf9f2bb036ef11bdc5ca3d2/llama/model.py#L337-L345

class FeedForward(nn.Module):
    def __init__(
        self,
        dim: int,
        hidden_dim: int,
        multiple_of: int,
        ffn_dim_multiplier: Optional[float],
    ):
        """
        Initialize the FeedForward module.

        Args:
            dim (int): Input dimension.
            hidden_dim (int): Hidden dimension of the feedforward layer.
            multiple_of (int): Value to ensure hidden dimension is 
                a multiple of this value.
            ffn_dim_multiplier (float, optional): 
                Custom multiplier for hidden dimension. Defaults to None.

        Attributes:
            w1 (ColumnParallelLinear): Linear transformation for the first layer.
            w2 (RowParallelLinear): Linear transformation for the second layer.
            w3 (ColumnParallelLinear): Linear transformation for the third layer.

        """
        super().__init__()
        hidden_dim = int(2 * hidden_dim / 3)
        # custom dim factor multiplier
        if ffn_dim_multiplier is not None:
            hidden_dim = int(ffn_dim_multiplier * hidden_dim)
        hidden_dim = multiple_of * ((hidden_dim + multiple_of - 1) // multiple_of)

        self.w1 = ColumnParallelLinear(
            dim, hidden_dim, bias=False, gather_output=False, init_method=lambda x: x
        )
        self.w2 = RowParallelLinear(
            hidden_dim, dim, bias=False, input_is_parallel=True, init_method=lambda x: x
        )
        self.w3 = ColumnParallelLinear(
            dim, hidden_dim, bias=False, gather_output=False, init_method=lambda x: x
        )

    def forward(self, x):
        return self.w2(F.silu(self.w1(x)) * self.w3(x))

• Rotary embeddings(GPTNeo)：删掉原来的绝对位置编码，加上rotary positional embedding(RoPE)，网络的每一层都加，参考Roformer: Enhanced transformer with rotary position embedding

• pre-normalization(gpt3)：提升训练稳定性，对每个子层的输入做norm，而非输出。此外，使用的是RMSNorm函数(Root mean square layer normalization)取代标准的layer-norm

  • layernorm计算单个样本在单层中所有激活的均值和标准差，并使用这些统计数据来归一化该层的激活。

  • RMSnorm只计算激活的平方根均值（RMS），而不是标准差。这样做的一个好处是计算上更简单，因为它省去了计算均值的步骤，只关注激活的规模（scale）而非其准确的分布。$\operatorname{RMSNorm}\left(x_i\right)=\frac{x_i}{\sqrt{\frac{1}{H} \sum_{j=1}^H x_j^2}+\epsilon}$，其中$H$是该层的神经元个数，而且也不用求均值

class RMSNorm(torch.nn.Module):
    def __init__(self, dim: int, eps: float = 1e-6):
        """
        Initialize the RMSNorm normalization layer.

        Args:
            dim (int): The dimension of the input tensor.
            eps (float, optional): A small value added to the denominator 
                for numerical stability. Default is 1e-6.

        Attributes:
            eps (float): A small value added to the denominator 
                for numerical stability.
            weight (nn.Parameter): Learnable scaling parameter.

        """
        super().__init__()
        self.eps = eps
        self.weight = nn.Parameter(torch.ones(dim))

    def _norm(self, x):
        """
        Apply the RMSNorm normalization to the input tensor.

        Args:
            x (torch.Tensor): The input tensor.

        Returns:
            torch.Tensor: The normalized tensor.

        """
        # rsqrt(x)= 1/ sqrt(x)
        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)

    def forward(self, x):
        """
        Forward pass through the RMSNorm layer.

        Args:
            x (torch.Tensor): The input tensor.

        Returns:
            torch.Tensor: The output tensor after applying RMSNorm.

        """
        output = self._norm(x.float()).type_as(x)
        return output * self.weight

优化器：AdamW，cosine学习率schedule，最终学习率是最大学习率的10%。0.1的weight decay和1.0的gradient cliping，使用2000steps的warmup

训练加速

• 对causal multi-head attention加速：实现在http://github.com/facebookresearch/xformers中，降低内存使用和运行时间，参考self-attention does not need $o(n^2)$ memory，以及Flashattention: Fast and memory-efficient exact attention with io-awareness。思想是

  • 不存储attention weights

  • 不计算被mask的key/query得分

• 减少xxx：

LLaMA2

2023年7月，Llama 2: Open Foundation and Fine-Tuned Chat Models

• 基于公开数据集预自监督地训练一个llama-2

• llama-2-chat模型:

  • sft后得到初始版本

  • 使用RLHF迭代地更新（拒绝采样+ppo）

llama-2-chat

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

使用了GQA（grouped query attention）(参考Gqa: Training generalized multi-query transformer models from multi-head checkpoints)，在注意力机制中对K/V进行参数共享的方案，可以在推理过程中减小KV缓存。

gqa

LLaMA3

原始LLaMa3

2024年4月

开源大模型Llama 3王者归来！最大底牌4000亿参数，性能直逼GPT-4

Llama 3超大杯有何惊喜？Meta会一直开源吗？当初为何笃信元宇宙？扎克伯格新访谈回应一切

Llama 3细节公布！AI产品总监站台讲解：Llama系列超庞大生态系统

OpenAI 前创始成员、特斯拉自动驾驶前负责人 Andrej Karpathy 发表 Meta Llama 3 笔记

Karpathy称赞，从零实现LLaMa3项目爆火，半天1.5k star

Karpathy点赞，这份报告教你如何用 LLaMa 3创建高质量网络数据集

https://github.com/naklecha/llama3-from-scratch

三个版本：8B 和 70B 参数的模型，还有一个 405B 参数的密集模型（还在训练之中，但已经在逼近GPT-4的领域，例如84.8 MMLU vs. 86.5 4Turbo），8B版本基本上与Llama-2的最大版本一样强大。

Llama 3的主要亮点：

• 训练语料：基于超过15T token训练，比Llama 2数据集(2T)的7倍还多：

  • scaling law的新发现：对于一个8B模型，Chinchilla的计算最优点将是训练约200B词汇(前面提到了10B模型，大概要205B的token来训练，以此类推)，所以这里超出了75倍，而且还未收敛。可见，我们经常使用的LLMs在训练上显著不足，可能是100-1000倍或更多，远未达到它们的收敛点。

• tokenizer：词汇数量从Llama 2的32K增加到Llama 3的128K，增加了4倍，拥有更多的词汇可以在长度上更有效地压缩序列。

• 上下文窗口：从Llama 2的4096和Llama 1的2048增加到了8192，相比GPT4的128k还差得很远

• 训练效率：比 Llama 2高3倍，做了很多工程优化；

• 模型结构：在Llama 2中，只在更大的模型使用了分组查询注意力（GQA），但llama3的所有模型都使用了，包括最小的8B模型。

• 新能力范畴：Llama-2只能使用非常特定的工具，而 Llama-3 能使用好得多的工具，无需人工编程就能让其使用谷歌执行搜索，类似的功能还有编程和运行代码等。

https://github.com/meta-llama/

https://github.com/meta-llama/llama3

多模态llama3

多模态 Llama-3 它来了 ！！[全网首发微调教程]

https://github.com/InternLM/XTuner

中文llama3

首批中文版Llama3模型来了，解释成语、答弱智吧问题

https://github.com/CrazyBoyM/llama3-Chinese-chat

https://huggingface.co/shenzhi-wang/Llama3-8B-Chinese-Chat

LLama3.1

最强模型Llama 3.1 405B正式发布，扎克伯格：开源引领新时代

微调大模型，AMD MI300X就够了！跟着这篇博客微调Llama 3.1 405B，效果媲美H100

The Llama 3 Herd of Models

Llama3 92页技术报告中文全文详解

还开放了一个生态系统：

• model：https://github.com/meta-llama/llama-models/tree/main/models/llama3_1

• tool-chain：https://github.com/meta-llama/llama-toolchain

• agent-system：https://github.com/meta-llama/llama-agentic-system

整体架构

multimodal-llama3.1

有2个主要的stage：

• language model pre-training：用多语言的语料进行next token prediction

  • 使用超过15万亿(15T)个token训练Llama 3.1 405B，context window是8k tokens

  • 又加上一个continued pretraining stage，将context windows增加到128k tokens

• language model post-training：sft+dpo+新的能力（如工具使用，能提升代码和推理能力）+safety

(toread)

这里有一些总结：关于post-training和一些思考

为了支持多模态，还加入了如下3个stage：

• 多模态encoder pre-training：

  • image encoder：在大量的img-text pair上训练，让模型能理解图片+描述

  • speech encoder：自监督，mask掉部分的speech输入，通过离散token表示来重建被mask的部分

• vision adapter training：

  • 训练一个adapter将pretrained的image encoder融入到pretrained language model里，adapter包括一系列的cross-attention层将image-encoder表示输入language model。在image-text pair上训练，对齐图文表示。训练时更新image-encoder的参数，但不更新language model的参数。

  • 基于这个image-encoder来训练一个video-adapter，用的是video-text数据，让模型能聚合多帧间的信息。视频侧的temporal aggregator是有一个perceiver的resampler

• speech adapter training：将speech encodings转成token表示，直接输入finetuned language model。在sft阶段，adaper和encoder的参数联合更新，但不更新language model的参数，还集成进了一个text-to-speech的系统。

预训练

在超过16,000个H100（80G HBM3）上训练，训练平台是Meta open compute project, grand teton ai platform，基于MAST: Global scheduling of ml training across geo-distributed datacenters at hyperscale进行schedule

选择了decoder only transformer with minor adaptations，而不是MOE，以最大限度地提高训练稳定性。

• 使用GQA with 8 key-value heads，提升推理速度，在decoding时降低k-v cache的大小

• 使用attention mask，让同一序列里的不同documents不计算self-attention。在标准的pretraining中影响不大，但对于超长序列的continued pre-training非常重要

• 128K tokens的vocab，100k的tiktoken tokenizer+28k的额外token，更好地支持非英语的语言。相比llama2，每个token能压缩的字符3.17变成3.94，压缩率更高了，即同样计算量能读更多文本，同时也能提升下游任务效果。

• 把RoPE的base frequency超参加大到500,000，能更好地支持更长contexts，Effective Long-Context Scaling of Foundation Models说这个值对32768长度的context很有效。

参数量：

	8B	70B	405B
Layers	32	80	126
Model Dimension	4,096	8192	16,384
FFN Dimension	6,144	12,288	20,480
Attention Heads	32	64	128
Key/Value Heads	8	8	8
Peak Learning Rate	3e-4	1.5e-4	8e-5
Activation Function	SwiGLU	SwiGLU	SwiGLU
Vocabulary Size	128,000	128,000	128,000
Positional Embeddings	RoPE ($\theta$ = 500,000)	RoPE ($\theta$ = 500,000)	RoPE ($\theta$ = 500,000)

后训练

采用iterative post-training procedure，即预训练后进行多轮对齐，每轮都使用sft、RS（拒绝采样）、直接偏好优化(DPO, Direct Preference Optimization)，能够为每轮创建最高质量的合成数据，并提高每项能力（capability）的性能。

• 使用合成数据生成(synthetic data generation)来产生绝大多数SFT示例，并多次迭代以在所有能力生成越来越高质量的合成数据。

• 采用了多种数据处理技术来过滤这些合成数据，达到最高质量，并可以跨能力来扩展微调数据量。

推理

从bf16量化为fp8

• 推理：对精度要求较高，对数值范围要求偏低，故一般用FP8-E4M3

• 训练：Gradients通常对精度损失不太敏感，但需要更高的范围(例如clip变小的时候，模型效果会变差，说明grad的range是比较大的)，故一般用FP8-E5M2

• 离线量化： 在推理前，利用离线dump数据/训练依赖/权重本身，产生量化scale，保存在模型中，推理中直接使用。history

• 在线量化： 推理中，利用输入数据在线计算scale，需要在线统计a/b的amax，推理速度慢。就是current scale

LLama-3.1-Minitron

英伟达玩转剪枝、蒸馏：把Llama 3.1 8B参数减半，性能同尺寸更强

Compact Language Models via Pruning and Knowledge Distillation

NVIDIA用TensorRT-LLM优化了Llama 3.1 8B和Llama-3.1-Minitron 4B模型。

LLama-Nemotron

英伟达253B开源新王登场，Llama 4三天变陪衬！直逼DeepSeek-R1成推理天花板

英伟达开源最新大模型Nemotron 70B后，只有OpenAI o1一个对手了

公开模型一切，优于DeepSeek-R1，英伟达开源Llama-Nemotron家族

Llama-Nemotron: Efficient Reasoning Models

https://github.com/NVIDIA/NeMo-Aligner/tree/llama-nemotron-dev

https://github.com/NVIDIA/NeMo

https://huggingface.co/collections/nvidia/llama-nemotron-67d92346030a2691293f200b

post training的数据集：

https://huggingface.co/datasets/nvidia/Llama-Nemotron-Post-Training-Dataset

开源了LN-Nano（8B）、LN-Super（49B）与LN-Ultra（253B），还有独立变体LN-UltraLong（8B，支持超长上下文）。

构建面向推理优化的模型

LN-Super和LN-Ultra通过Puzzle框架实现高效推理优化。Puzzle是一个神经网络架构搜索（Neural Architecture Search, NAS）框架，能够在真实部署约束条件下，将大型语言模型转化为面向硬件高效的变体(Puzzle: Distillation-Based NAS for Inference-Optimized LLMs)

以Llama 3 Instruct模型为起点（LN-Super(49B)基于Llama3.3-70B-Instruct，LN-Ultra(253B)基于Llama 3.1-405B-Instruct），Puzzle通过逐模块局部蒸馏（block-wise local distillation）方法构建可替代的Transformer模块库。每个模块独立训练且可并行处理，允许每个替代模块在精度与效率之间进行权衡（accuracy-efficiency tradeoff），模块变体主要包括以下几种类型：

• 移除注意力机制（Attention removal）：部分模块完全省略注意力机制，从而显著减少计算开销和KV cache内存占用。

• 可变FFN维度（Variable FFN dimensions）：通过调整FFN的中间维度，在不同粒度下实现模型压缩（如将隐藏层维度压缩至原始的87%、75%、50%，甚至低至 10%）。

尽管Puzzle同样支持其他结构替换方式（如多GQA中不同的kv head数、线性注意力替代方案、以及不执行操作的替换模块），但实际评估结果表明，在优化LN-Super和LN-Ultra两个模型的总体吞吐量与内存节省方面，最有效的技术仍是移除注意力机制与FFN压缩。

在模块库构建完成后，Puzzle通过逐层选取模块的方式组装完整模型。模块选择过程由整数混合规划（Mixed-Integer Programming, MIP）求解器控制，在给定的约束条件下（如硬件兼容性、最大推理延迟、总内存预算或指定推理吞吐量）确定效率最优的模块配置。

由于每一层支持多个具有不同精确度–效率权衡方案的模块变体，Puzzle允许用户精确定位至任何位于精度-效率帕累托前沿（Pareto frontier）上的模型配置点。例如，Puzzle 可生成满足特定智能体系统（agentic systems）或部署流程所需约束（如内存不可超出上限或端到端响应时间严格受限）的模型。

用FFN融合实现纵向压缩（Vertical Compression with FFN Fusion）：针对LN-Ultra模型，引入了一种额外的压缩技术——FFN融合（FFN Fusion），该方法旨在降低模型的序列深度，并进一步缩短推理延迟。利用Puzzle移除部分注意力层后的结构特性：在这种结构下，模型中经常会出现连续的FFN模块序列。FFN Fusion会识别出这类序列，并将其替换为更少但更宽的FFN层，这些宽层可并行执行，从而减少序列处理步骤的数量，同时保留模型的表达能力，还能显著提升计算资源的利用率，特别是在多GPU环境中，可以有效降低跨层通信带来的开销。

在NAS之后，进行了continue pretraining(CPT)：

• LN-Super：使用(Puzzle: Distillation-Based NAS for Inference-Optimized LLMs里的Distillation Mix数据集，以知识蒸馏目标函数训练了400亿个Token

• LN-Ultra：首先使用相同的蒸馏数据集进行了650亿Token的蒸馏训练，随后在Nemotron-H第四阶段预训练数据集上进行了额外880亿Token的持续预训练。

LN-Ultra不仅实现了与基准模型Llama 3.1-405B-Instruct相当的性能，还在多个关键基准测试上取得超越。说明即使进行激进的架构优化，也可通过短周期的蒸馏与预训练恢复并提升模型性能。

合成数据

设计了「detailed thinking on/off」指令机制，在合成数据中显式标记是否需要展开详细推理过程，引导模型在训练中学习何时进行逐步思考、展示推理链条，何时直接给出简明答案。指令为「on」时，模型输出完整的中间推理过程并展示解题思路；指令为「off」时，模型仅呈现最终结果。

拿deepseek-r1、llama-4等作为teacher来生产数据，产出的数据总共33,011,757条，里面66%是数学的，30%是代码的（这两部分里都是reasoning off占大头），剩下的是科学和instruction following

SFT

基于合成数据来进行SFT，不同大小的student用的seq_len、epoch数不太一样，也有一些小trick，详见原文

推理能力强化学习

只蒸馏的话，student很难超越teacher，所以需要强化学习，考虑到资源问题，只对LN-Ultra搞了GRPO

两个reward：

• 准确率奖励（Accuracy rewards）：每个训练样本提供标准答案（数字、句子或段落），使用Llama-3.3-70B-Instruct模型判定策略模型响应是否与标准答案一致。

• 格式奖励（Format rewards）：和DeepSeek一致，在detailed thinking on时，需将推理过程置于<think></think>标签之中；而在off时，确保不包含思考标签。

一些trick：

• 样本过滤：由LN-Super为每道题生成8个独立回答，计算通过率，并过滤通过率大于等于0.75的样本，提升总体训练数据难度。

• 课程学习（curriculum learning）：渐进式批处理策略（progressive batching），使用预计算通过率作为样本难度指标，在固定batch size下，动态计算每个batch的目标难度分布。该分布以高斯函数建模，从早期批次集中在高通过率（简单样本），逐步过渡至后期批次的低通过率（高难度样本）。每个batch中，样本按目标分布随机分配，并根据不同通过率池中剩余样本量进行容量填充。确保样本难度在batch层面逐步递进，同时batch内部保持随机性。

• 基于fp8的生成阶段：修改vLLM，支持bf16转fp8，然后用fp8做gemm

用于偏好优化的强化学习

• 指令跟随：在前面的科学推理任务的强化学习之后，对LN-Super和LN-Ultra再进行短期的强化学习，提升指令跟随能力。参考Instruction-following evaluation for large language models，生成包含1至10条详细指令的合成提示词，用RLOO（Back to basics: Revisiting reinforce style optimization for learning from human feedback in llms）在batch128跑了120个steps，用自定义指令跟随验证器作为奖励函数。发现能同时提升指令跟随任务和推理类任务的效果。

• RLHF：增强模型的通用协助能力（helpfulness）与多轮聊天能力

  • LN-Super：用iterative online RPO（ Reward-aware preference optimization: A unified mathematical framework for model alignment）来最大化HelpSteer2数据集上的Llama-3.1-Nemotron-70B-Reward

  • LN-Ultra：一样的方法，只是换成了GRPO

  • LN-Nano：2轮的offline RPO

    • 第一轮：用混合了reasoning和非reasoning的数据，来提升reasoning控制能力

    • 第二轮：用使用当前正在训练（优化）的策略生成的数据（on-policy的数据），来提升指令遵循能力

Llama-3.2

刚刚，Llama 3.2 来了！支持图像推理，还有可在手机上运行的版本

Llama 3.2

• 最大的两个模型11B和90B：都支持图像推理，包括文档级的图表理解、图像描述和视觉定位任务，比如直接根据自然语言描述定位图像中的事物。

• 轻量级的1B和3B：都是纯文本模型，但也具备多语言文本生成和工具调用能力。

Sebastian Raschka最新博客：从头开始，用Llama 2构建Llama 3.2

Llama-3.3

新版Llama 3 70B反超405B！Meta开卷后训练，谷歌马斯克都来抢镜

Llama 3.3能用70B实现405B的效果，主要是“运用了后训练技术的最新进展”，其中包括在线偏好优化（online preference optimization）。

https://huggingface.co/meta-llama/Llama-3.3-70B-Instruct

https://github.com/meta-llama/llama-models/blob/main/models/llama3_3/MODEL_CARD.md

Llama-4

Meta深夜开源Llama 4！首次采用MoE，惊人千万token上下文，竞技场超越DeepSeek

https://ai.meta.com/blog/llama-4-multimodal-intelligence/

模型	结构	参数量	特点
Llama 4 Behemoth	多模态MoE，288B激活，16专家	2T	还没训完，暂未开源
Llama 4 Maverick	多模态MoE，17B激活，128专家	400B	推理+编程与deepseek v3相当
Llama 4 Scout	多模态MoE，17B激活，16专家	109B	10M上下文窗口

• 架构：

  • iRoPE架构：使用无位置嵌入的交错注意力层（interleaved attention layers），并通过推理时的温度缩放(Scalable-Softmax Is Superior for Attention)来增强长上下文泛化能力。

  • 原生多模态设计：通过早期融合将文本和视觉token无缝整合到统一的模型骨干中，能够使用大量未标记的文本、图像和视频数据对模型进行联合预训练。此外，还改进了Llama 4中的视觉编码器，基于MetaCLIP，以更好地使编码器适应LLM。

• 训练：

  • MetaP：能够可靠地设置模型超参数，例如每层的学习率和初始化规模。选定的超参数在不同批量大小、模型宽度、深度和训练 token 值之间具有良好的迁移性。

  • 数据：200种语言的数据，比llama3多了10倍的多语言token；训练所用的数据混合总量超过30万亿（30T）token，是Llama 3预训练数据混合量的两倍多，涵盖了多样化的文本、图像和视频数据集。

  • fp8训练：兼具质量并确保高FLOPs利用率，使用FP8和32K GPU预训练Llama 4 Behemoth模型时，实现了每GPU有390 TFLOPs。

• mid-training：

  • 利用专门的数据集扩展长上下文，使得Llama 4 Scout具备业界领先的1000万(10M)输入上下文长度。

• post-training：

  • 轻量级监督微调（SFT）> 在线强化学习（RL）> 轻量级直接偏好优化（DPO）。发现SFT和DPO可能会过度约束模型，限制在线RL阶段的探索能力:

    • 轻量级监督微调（SFT）：Meta 使用Llama模型作为评判，移除了超过50%的标记为简单的数据，并在剩余较难的数据集上进行SFT。剪枝比例：2T的模型95%，较小模型50%

    • RL：

      • 通过policy model进行pass@k分析，采样难度较高的prompt，并构建难度逐渐增加的训练课程

      • 训练过程中动态过滤掉零advantage的prompt，并构建包含多种能力的混合prompt训练batch

      • 从多种系统指令中采样，确保模型在推理和编码任务中保持指令遵循能力(这个可能讲的是dpo？)

    • 轻量级直接偏好优化（DPO）：处理与模型响应质量相关的边缘情况，有效实现了模型智能与对话能力的良好平衡。

• 新的框架：

  • 现有的分布式训练框架为了将所有模型加载到内存中而牺牲了计算内存，Meta的新基础设施能够灵活地将不同模型分配到不同的GPU上，并根据计算速度在多个模型之间平衡资源。

  • 对MoE并行化的设计进行了优化

  • 完全异步的在线强化学习训练框架

Alpaca

Alpaca: A Strong, Replicable Instruction-Following Model

Stanford的羊驼（Alpaca）模型，有70亿（7b）参数，没有使用RLHF，而是使用监督学习的方法，参考Self-Instruct: Aligning Language Model with Self Generated Instructions（代码https://github.com/yizhongw/self-instruct）

数据集是通过查询基于GPT-3的text-davinci-003模型的结果，得到的52k的指令-输出对（instruction-output pairs）。

因此，Alpaca本质上使用的是一种弱监督（weakly supervised）或以知识蒸馏（knowledge-distillation-flavored）为主的微调，即“用 LLM 来训练 LLM”。

Alpaca

https://github.com/tatsu-lab/stanford_alpaca

Vicuna

通过ShareGPT收集的用户对话数据，对llama进行finetune得到的13B模型。效果接近chatgpt的92%，而且训练消耗比较低，大概只要300美元。

Guanaco

QLoRA: Efficient Finetuning of Quantized LLMs也是对llama进行微调，使用了QLoRA，能够在一台48G的GPU上微调65B的模型。只需要在单台GPU上finetune 24小时就能达到99.3%的chatgpt的效果。

https://github.com/artidoro/qlora

https://github.com/TimDettmers/bitsandbytes

QLoRA将一个固定的4 bit量化的预训练权重转成low Rank Adapters来更新梯度

Koala

Koala: A dialogue model for academic research

使用用户与闭源大模型交互的用户输入和模型返回数据进行训练

Mistral

Mistral 7b

7B参数比最好的13B模型（llama-2-13B）要更好，而且比llama-34B在reasoning、数学、代码生成都更好。

• 使用grouped-query attention来做更快的infer

• 使用滑动窗口attention来用更低的infer消耗来高效地处理任意长度的序列。

https://mistral.ai/news/mixtral-of-experts/ 提出了moe的8x7b

Mixtral of Experts

Mixtral 8x7B(Mistral MoE) 模型解析

Mistral开源8X22B大模型，OpenAI更新GPT-4 Turbo视觉，都在欺负谷歌

https://huggingface.co/mistral-community/Mixtral-8x22B-v0.1

Mistral AI两连发：7B数学推理专用、Mamba2架构代码大模型

mathtral：https://huggingface.co/mistralai/mathstral-7B-v0.1

codestral-mamba: https://huggingface.co/mistralai/mamba-codestral-7B-v0.1，基于mamba2，可以直接用trt-llm启动

准狙击Llama 3.1？Mistral AI开源Large 2，123B媲美Llama 405B

Mistral AI 基于此前Codestral 22B和Codestral Mamba的经验，在很大一部分代码上训练了 Mistral Large 2。其表现远远优于上一代的Mistral Large，并且与GPT-4o、Claude 3 Opus和Llama 3 405B等顶尖模型相当。

https://huggingface.co/mistralai/Mistral-Large-Instruct-2407

​Mistral首个多模态模型Pixtral 12B来了！还是直接放出24GB磁力链接

https://huggingface.co/mistral-community/pixtral-12b-240910

发力了，Mistral对标ChatGPT全面升级le Chat，还祭出超大杯多模态模型

最强代码模型刷新：Mistral新品上线即登顶，上下文窗口增至256k

单个4090就能跑，Mistral开源多模态小模型，开发者：用来构建推理模型足够香

phi-3

微软发布Phi-3，性能超Llama-3，可手机端运行

Phi-3 Technical Report: A Highly Capable Language Model Locally on Your Phone

phi-4

微软首个多模态Phi-4问世，56亿参数秒杀GPT-4o！LoRA华人大佬带队

https://huggingface.co/microsoft/Phi-4-multimodal-instruct

PaLM系列

PaLM

2022年4月提出了第一个PaLM：Palm: Scaling language modeling with pathways，直到2023年3月还是private的。是一个540B(5400亿)参数的模型，在包含了780B的tokens的高质量数据集上预训练。使用Pathways的6144块TPU v4进行训练。

U-PaLM

Transcending scaling laws with 0.1% extra compute提出了8B，62B和540B的U-PaLM模型，用UL2R来对PaLM进行继续训练，用的是UL2的mixture-of-denoiser objective(UL2: Unifying Language Learning Paradigms)

Flan-PaLM

Flan-PaLM（Scaling instruction-finetuned language models）是instrunction-finetuned版本的U-PaLM。使用了更多的任务、更大的模型，以及CoT数据。使用了473个数据集，146类的task，总共1836个task。

flan-palm

https://huggingface.co/google/flan-t5-xl

PaLM-2

PaLM 2 Technical Report是一个更计算高效型的LLM，有更好的多语种和reasoning能力，在很多任务上都比PaLM好，并且在infer上比PaLM要更快更高效。

Med-PaLM

Nature的Large language models encode clinical knowledge提出了Med-PaLM，在PaLM上用parameter-efficient方法进行instruction prompt tuning，使用少量的典型范例（exemplars）让LLM对齐到新领域。

Med-PaLM2(Towards expert- level medical question answering with large language models)通过med-domain的finetuning和ensemble refinement prompting，效果比Med-PaLM要好。

其他LLM

FLAN

Finetuned language models are zero-shot learners

通过instruction tuning，大模型能很好地提升在没见过任务上的zero-shot能力。对一个137B的预训练模型在60个NLP数据集上使用instruction template进行instruction tuning。

flan

一些instruction template：

flan-instruction-template

https://github.com/google-research/flan

Gopher

Scaling language models: Methods, analysis & insights from training gopher基于152个多样的任务，对比了从44M到208B（Gopher）的不同transformer，发现Gopher在大多数任务上均达到sota：

Model	Layers	Number Heads	Key/Value Size	d_model	Max LR	Batch Size
44M	8	16	32	512	$6 \times 10^{-4}$	0.25M
117M	12	12	64	768	$6 \times 10^{-4}$	0.25M
417M	12	12	128	1,536	$2 \times 10^{-4}$	0.25M
1.4B	24	16	128	2,048	$2 \times 10^{-4}$	0.25M
7.1B	32	32	128	4,096	$1.2 \times 10^{-4}$	2M
Gopher 280B	80	128	128	16,384	$4 \times 10^{-5}$	3M -> 6M

T0

Multitask Prompted Training Enables Zero-Shot Task Generalization设计了一个系统，将任意nlp任务映射成一个人类可读的prompt格式。训练了一个encoder-decoder的T0模型，输入文本，输出文本，在混合数据集上进行多任务学习。

RETRO

参数量仅为4%，性能媲美GPT-3：开发者图解DeepMind的RETRO

http://jalammar.github.io/illustrated-retrieval-transformer/

Improving language models by retrieving from trillions of tokens

Retrieval Enhanced Transformer(Retro)基于与preceding(前述) tokens的相似度，从大的语料库里检索出文档段（document chunks）作为条件，增强了自回归模型的能力。通过少25%的参数，在Pile数据集上达到了与gpt3和Jurassic-1相当的效果

retro

• 左图：

  • 输入一个长度为12的序列，每4个token一个chunk，切成3个chunk

  • 每个chunk通过freezed的bert去语料库中拿2个相似neighbors出来，每个neighbor过bert得到向量

  • 邻居作为k和v，原来的3个chunk作为k，做attention(CCA, chunked cross attention)

• 右图：CCA的结构

  • 保证了因果性，即chunk1的邻居只对chunk1的last token以及chunk2的所有token有影响

GLaM

Glam: Efficient scaling of language models with mixture-of-experts提出了Generalist Language Model(GLaM)，用稀疏激活的MOE架构，同时能scale模型容量，也能相比dense更可观地降低训练成本。最大的模型有1.2T参数，是gpt3的7倍。但只需要GPT3的1/3的能量来训练，而且在infer时也只有一半的flops，且在29个NLP任务上都有更好的0/1/few shot效果。

Glam

如图，2 in 64的结构，每个token只会取64个experts里的top 2相关的expert，对这两个的输出加权平均输入给后面的层

LaMDA

Lamda: Language models for dialog applications，有137B的参数，在1.5T的公开对话数据和互联网文本上pretrain，用标注数据微调，以及让模型能够咨询（consult）外部知识源能够让模型在安全性和factual grounding上有很好的改进。

OPT

OPT: Open Pre-trained Transformer Language Models提出了从125M到175B的预训练decoder-only模型

Chinchilla

Galactica

CodeGen

AlexaTM

Sparrow

MoD

BLOOM

GLM

ACL22 GLM: General Language Model Pretraining with Autoregressive Blank Infilling

iclr23 GLM-130B: An Open Bilingual Pre-trained Model

GLM-4

GLM-4开源版本终于来了：超越Llama3，多模态比肩GPT4V，MaaS平台也大升级

https://github.com/THUDM/GLM-4

Pythia

Orca

StarCoder

KOSMOS

Claude

全球最强大模型一夜易主，GPT-4时代终结！Claude 3提前狙击GPT-5，3秒读懂万字论文理解力接近人类

The Claude 3 Model Family: Opus, Sonnet, Haiku

• 对齐：使用Constitutional AI(Constitutional AI: Harmlessness from AI Feedback)， explicitly specifying rules and principles based on sources like the UN Declaration of Human Rights.

• 基于Collective Constitutional AI(Collective Constitutional AI: Aligning a Language Model with Public Input)，added an additional principle to Claude’s constitution to encourage respect for disability rights

• 公开了部分RHLF数据：https://huggingface.co/datasets/Anthropic/hh-rlhf，对应的论文是Training a Helpful and Harmless Assistant with Reinforcement Learning from Human Feedback

力压GPT-4o！新王Claude 3.5 Sonnet来了，直接免费可用

大模型代肝，自动刷《崩铁》升级材料，Claude操纵计算机还能这么用！

The Dawn of GUI Agent: A Preliminary Case Study with Claude 3.5 Computer Use

https://github.com/showlab/computer_use_ootb

Octopus

超越GPT-4，斯坦福团队手机可跑的大模型火了，一夜下载量超2k

Octopus v2: On-device language model for super agent

https://huggingface.co/NexaAIDev/Octopus-v2

参数量不到10亿的OctopusV3，如何媲美GPT-4V和GPT-4？

Octopus v3: Technical Report for On-device Sub-billion Multimodal AI Agent

Octopus v4: Graph of language models

Cohere Command R+

开源模型打败GPT-4！LLM竞技场最新战报，Cohere Command R+上线

https://huggingface.co/CohereForAI/c4ai-command-r-plus

https://huggingface.co/CohereForAI/c4ai-command-r-plus-4bit

1040亿的参数量，相比于Grok-1（3140亿）还差了一些，但Command R+并非Grok那种MoE架构，所以这1040亿参数是实打实的完全用于推理，而Grok-1的活跃参数为860亿。相比commend R：

• 高级检索增强生成（RAG）与引用以减少幻觉

• 10种主要语言的多语言覆盖，支持全球业务运营

• 工具的运用以自动化复杂的业务流程

明确了：文本数据中加点代码，训练出的大模型更强、更通用

To Code, or Not To Code? Exploring Impact of Code in Pre-training

CT-LLM：以中文为中心的LLM

Chinese Tiny LLM: Pretraining a Chinese-Centric Large Language Model

当前，绝大多数LLM基本上都是以英文语料库训练得到的，然后经过SFT来匹配不同的语种。本文作者考虑以中文为基础的预训练模型是否可以激活对其它语言的能力。

作者从头开始训练中文大模型，在训练过程中「主要纳入中文文本数据」，最终作者得到了一个2B规模的中文Tiny LLM（CT-LLM）。结果表明，该模型在中文任务上表现出色，且通过SFT也能很好的支持英文。

OpenELM

苹果卷开源大模型，公开代码、权重、数据集、训练全过程，OpenELM亮相

OpenELM: An Efficient Language Model Family with Open-source Training and Inference Framework

https://github.com/apple/corenet

超强Siri即将到来！苹果10篇重磅AI研究全总结，iOS 18关键一瞥

苹果智能背后模型公布：3B模型优于Gemma-7B，服务器模型媲美GPT-3.5-Turbo

Arctic

仅需Llama3 1/17的训练成本，Snowflake开源128x3B MoE模型

全球最大开源模型再刷爆纪录！4800亿参数MoE击败Llama 3、Mixtral

https://huggingface.co/Snowflake/snowflake-arctic-instruct

FALCON 2

时隔一年Falcon回归！110亿参数5.5万亿token，性能超越Llama 3

MiniCPM

MOEfication

大模型隐藏玩家上桌：DeepSeek 向左，面壁向右

MoEfication：Transformer Feed-forward layers are Mixtures of Experts

MiniCPM-Llama3-V

登顶Top2！MiniCPM-V 8B新版本：GPT-4V水准小钢炮，8G显存，4070轻松推理！

可信度超越GPT-4V，清华&面壁揭秘「小钢炮」模型背后的高效对齐技术

RLAIF-V: Aligning MLLMs through Open-Source AI Feedback for Super GPT-4V Trustworthiness

https://github.com/RLHF-V/RLAIF-V

MiniCPM 3.0

小模型杀疯了！仅4B参数性能超GPT-3.5！无限长文本性能超Kimi

MiniCPM: Unveiling the Potential of Small Language Models with Scalable Training Strategies

DCFormer

彩云科技DCFormer大模型发布，效率是Transformer的两倍！

Improving Transformers with Dynamically Composable Multi-Head Attention

https://github.com/Caiyun-AI/DCFormer

hunyuan

腾讯混元又来开源，一出手就是最大MoE大模型

Hunyuan-Large: An Open-Source MoE Model with 52 Billion Activated Parameters by Tencent

https://github.com/Tencent/Hunyuan-Large

https://llm.hunyuan.tencent.com/

hunyuan turbo-s

https://github.com/Tencent/llm.hunyuan.turbo-s

阶跃星辰

在「最难LLM评测榜单」上，阶跃万亿参数模型拿下中国第一

六小虎「阶跃星辰」疯狂了！连发6款大模型，多模态霸榜第一

Tülu 3(基于llama3.1)

(toread)

这才是真开源模型！公开「后训练」一切，性能超越Llama 3.1 Instruct

TÜLU 3: Pushing Frontiers in Open Language Model Post-Training

https://github.com/allenai/open-instruct

提出了具有可验证奖励的强化学习(Reinforcement Learning with Verifiable Rewards, RLVR)，可能和openai的rft有关系

https://huggingface.co/allenai/Llama-3.1-Tulu-3-70B

baichuan

百川新模型超GPT-4o近20%，首创自约束训练方案突破瓶颈，主打「领域增强」

Baichuan4-Finance

评测benchmark：https://github.com/FLAME-ruc/FLAME/tree/main

post training的一些总结

工业界主流大语言模型后训练(Post-Training)技术总结

长文 | 大模型Post-Training总结

小模型

权重、代码、数据集全开源，性能超越Mistral-7B，苹果小模型来了

DataComp-LM: In search of the next generation of training sets for language models

https://huggingface.co/apple/DCLM-7B

小模型卷起来了：Mistral联合英伟达开源12B小模型，128k上下文

Mistral NeMo 使用基于 Tiktoken 的新分词器 Tekken，该分词器经过 100 多种语言的训练，能比以前 Mistral 模型中使用的 SentencePiece 分词器更有效地压缩自然语言文本和源代码。在压缩源代码、中文、意大利文、法文、德文、西班牙文和俄文时，它的效率要高出约 30%。在压缩韩文和阿拉伯文时，它的效率是原来的 2 倍和 3 倍。事实证明，与 Llama 3 分词器相比，Tekken 在压缩所有语言中约 85% 的文本方面更胜一筹。

Mistral NeMO 经历了高级微调和对齐阶段。与 Mistral 7B 相比，它在遵循精确指令、推理、处理多轮对话和生成代码方面的能力大大提升。

• 基础模型：https://huggingface.co/mistralai/Mistral-Nemo-Base-2407

• 指令微调模型：https://huggingface.co/mistralai/Mistral-Nemo-Instruct-2407

大模型已过时，小模型SLM才是未来？苹果正在研究这个

Computational Bottlenecks of Training Small-scale Large Language Models

研究大模型门槛太高？不妨看看小模型SLM，知识点都在这

A Comprehensive Survey of Small Language Models in the Era of Large Language Models: Techniques, Enhancements, Applications, Collaboration with LLMs, and Trustworthiness

https://github.com/FairyFali/SLMs-Survey

BitNet

微软开源爆火1.58bit大模型推理框架！千亿参数模型量化后单CPU可跑，速度每秒5-7个token

BitNet: Scaling 1-bit Transformers for Large Language Models

The Era of 1-bit LLMs: All Large Language Models are in 1.58 Bits

https://github.com/microsoft/BitNet

Zamba 2

7B新王登基！Zamba 2完胜同级模型，推理效率比Llama 3提升20%，内存用量更少

用了mamba 2

Zamba: A Compact 7B SSM Hybrid Model

• hf版本：https://huggingface.co/Zyphra/Zamba2-2.7B

• 纯pytorch版本：https://github.com/Zyphra/Zamba2

小结

开源模型进展盘点：最新Mixtral、Llama 3、Phi-3、OpenELM到底有多好？

外推问题

常见位置编码

Sinusoidal位置编码

Transformer升级之路：Sinusoidal位置编码追根溯源

其实就是transformer最开始的位置编码，其中$\boldsymbol{p}_{k, 2 i}, \boldsymbol{p}_{k, 2 i+1}$分别是位置$k$的编码向量的第$2i,2i+1$个分量，$d$是向量维度

$$\left\{\begin{array}{l} \boldsymbol{p}_{k, 2 i}=\sin \left(k / 10000^{2 i / d}\right) \\ \boldsymbol{p}_{k, 2 i+1}=\cos \left(k / 10000^{2 i / d}\right) \end{array}\right.$$

ALiBi

Train Short, Test Long: Attention with Linear Biases Enables Input Length Extrapolation，如下添加一个不学习的bias，ALiBi(Attention with Linear Biases)

$$\operatorname{softmax}\left(\mathbf{q}_i \mathbf{K}^{\top}+m \cdot[-(i-1), \ldots,-2,-1,0]\right)$$

其中的$m$是坡度（slope），和attention heads有关。假设有n个head，那取值范围就是$2^{-8/n}, 2^{-8/n\times 2}, 2^{-8/n\times 3}, ...,2^{-8}$

RoPE

Transformer升级之路：博采众长的旋转式位置编码

Transformer升级之路：RoPE的底数设计原则

Base of RoPE Bounds Context Length

Decoder-only的LLM为什么需要位置编码？

HuggingFace工程师亲授：如何在Transformer中实现最好的位置编码

https://github.com/ZhuiyiTechnology/roformer

Sinusoidal位置编码是一种“想要成为相对位置编码的绝对位置编码”，RoPE是一种配合 Attention 机制能达到“绝对位置编码的方式实现相对位置编码”的设计，还是目前唯一一种可用于线性 Attention 的相对位置编码。

longRoPE

LongRoPE：超越极限，将大模型上下文窗口扩展超过200万tokens

CoPE

解决Transformer根本缺陷，CoPE论文爆火：所有大模型都能获得巨大改进

Contextual Position Encoding: Learning to Count What’s Important

DAPE

NeurIPS 2024 | Transformer长度外推，全新位置编码DAPE大幅提升模型性能

DAPE: Data-Adaptive Positional Encoding for Length Extrapolation

https://github.com/chuanyang-Zheng/DAPE

长上下文的问题

长序列（Long Context）大模型笔记

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

LLM长上下文的问题

专访月之暗面杨植麟：lossless long context is everything

语言模型窗口外推技术综述

以中文为例，大部分模型每个token对应的中文字数都>1.5个字，所以200k的token就对应30w字的上下文

对长文本的几个要求：

• 在文本比较长的时候，还能保证通顺，ppl要足够低

• 能attention到前面提过的细节，不能自我矛盾

注意：如果训练时是2k长度的语料，而推理设定8k窗口，那么PPL会急剧上升，因为

• RoPE不能很好地处理没有训练过的位置编码

• 推理时注意力机制所处理的token数量远超训练时的数量，导致注意力机制的崩坏

两阶段训练方式

• 直接输入连续长文本（如书籍）

• 多个中等文本拼接，再通过attention mask来限制各段文本之间注意力，让它们可以在各自的位置上各训各的，互不干扰。甚至实际上即使不做attention mask，效果也挺好。

如果简单地增加长度，例如从4k变到32k，长度增加8倍，为了加速计算需要缓存中间结果（如QK的结果是$s^2$的空间复杂度），所以显存会扩大$8^2=64$倍。一般的做法是2阶段：

• 第一阶段：用2k或者4k训练一个基础模型，让模型学好文本内容和短位置关系

• 第二阶段：用比第一阶段小的数据量优化模型在长上下文的效果

外推方法

针对位置编码的插值类方法

线性插值

Extending Context Window of Large Language Models via Positional Interpolation

NTK-Aware Interpolation

NTK-by-parts

Dynamically NTK Scaled RoPE

针对attention score的缩放方法

YaRN

Qwen和DeepSeek为何都选YaRN？

logn

lossless long context

新的模型结构

retrieval head

Retrieval Head Mechanistically Explains Long-Context Factuality

Hawk & Griffin

RNN效率媲美Transformer，谷歌新架构两连发：同等规模强于Mamba

Griffin: Mixing Gated Linear Recurrences with Local Attention for Efficient Language Models

简介

global attention在infer阶段的效率和序列长度成二次关系，而且序列长度与KV cache呈线性增长关系。Fast Transformer Decoding: One Write-Head is All You Need提出的multi-query attention(MQA)可以通过一个constant factor来减小cache size，部分缓解这个问题，但cache还是与序列长度线性相关。

循环模型能够将整个序列压缩到一个fixed-size的hidden state，并通过迭代进行更新。但要想取代transformer，rnn不仅需要在效果上可比，还要相似的硬件效率，相关工作如下：

• Efficiently modeling long sequences with structured state spaces

• Long range language modeling via gated state spaces提出了GSS block

• Simplified state space layers for sequence modeling

• Resurrecting Recurrent Neural Networks for Long Sequences

• Hungry hungry hippos: Towards language modeling with state space models

• Hyena hierarchy: Towards larger convolutional language models

• Mamba: Linear-time sequence modeling with selective state spaces

本文提出了新的RG-LRU层，一种新的gated linear recurrent layer，并基于此提出了将MLP和RG-LRU结合的Hawk，还有将MLP和RG-LRU与local attention混合的Griffin。

griffin-hawk

• 对于最多超过7B的模型，Hawk和Griffin发现了held-out loss和训练FLOPS间的power law scaling（上图左边）

• Hawk-3B比Mamba-3B在下游任务上要好，而训练的token数只有mamba的一半；Griffin-7B和14B与Llama-2效果相当，而训练数据只有其1/7

• 训练在TPU-v3上完成，用JAX中的Pallas实现了RG-LRU(Real-Gated Linear Recurrent Unit)层的内核(https://jax.readthedocs.io/en/latest/pallas/index.html)，减小内存transfer

• infer阶段比MQA的吞吐高很多（上图右边），而且对长序列有更低的latency

• 训练时在长序列上比transformer更好，而且能够高效地学习复制和检索的任务。但如果没有finetune，直接对比pretrain的效果，transformer会更好

网络结构

包括三大类组件：

• residual block:

• MLP block：

• temporal-mixing block

griffin-arch

Residual Block

受pre-norm transformer的启发，用的RMSNorm

MLP block

参考Language modeling with gated convolutional networks（类似star两个W直接element-wise product），采用了gated MLP，即如下两个linear的结果（输入维度$D$，输出维度都是$MD,M=3$）进行element-wise product(类似GeGLU（Glu variants improve transformer）)，再过一个linear

• 直接过一个linear，但没有激活

• linear后加一个GeLU激活（实际用的nn.functional.gelu(input, approximate="tanh")）

看recurrentGemma-2b的config，发现总共有26个block，一个block依次包括：

• rg-lru或者MQA，每个block里的选择方式是(rg,rg,att,rg,rg,att,rg,rg,att,...)

• 再过一个gated MLP

  "_block_types": [
    "recurrent",
    "recurrent",
    "attention"
  ],
  "num_hidden_layers": 26,
  "attention_window_size": 2048,

Temporal-mixing block

global Multi-Query Attention(MQA)

Fast Transformer Decoding: One Write-Head is All You Need中为了加速推理，采用了MQA的方法，本文固定了head的维度为$D_{head}=128$，head的个数$H$也固定，且$HD_{head}=D$，所以model的维度$D$需要是128的倍数。没用绝对位置编码，用了RoPE。

local(sliding-window) MQA

Longformer: The long-document transformer提出了可以用local attention，即滑动窗口attention。让每个位置只和前面的固定个tokens去算attentioin，可以

• 降低计算的FLOPS

• 让KV cache的size的上界变成了window的size，从而不是序列长度的二次关系

RG-LRU

类似GSS block，也类似Mamba，输入$D$，分别过一个linear得到两个分支，均是$D_{RNN}$：

• 分支1：过GeLU激活，同上，实际用的nn.functional.gelu(input, approximate="tanh")

• 分支2：

  • 参考Hungry hungry hippos: Towards language modeling with state space models的H3模型里的Shift-SSM，过一个Conv1D，其temporal filter dim是4

  • Conv1D的参数只有$4D_{RNN}$，因此再过一个RG—LRU模块

两个分支的输出element-wise product一下，再过一个linear得到$d$。

conv1d参考torch官方doc

• 输入：$\left(N, C_{i n}, L_{i n}\right)$

• 输出：$\left(N, C_{\text {out }}, L_{\text {out }}\right)$

其中，

$$L_{\text {out }}=\left\lfloor\frac{L_{\text {in }}+2 \times \text { padding }- \text { dilation } \times(\text { kernel\_size }-1)-1}{\text { stride }}+1\right\rfloor$$

当groups==in_channels and out_channels=K*in_channels，也叫depthwise convolution，K是depthwise乘子。即每个输入通道都有自己的卷积核，并且只作用于该通道。

        ## conv1d_width = 4, 
        ## 对图像卷积来讲，padding就是让输出的shape不小于输入shape
        ## 输入是hidden_size=2560，而lru_width也是2560
        self.conv_1d = nn.Conv1d(
                    config.lru_width, # in_channels
                    config.lru_width, # out_channels
                    kernel_size=config.conv1d_width,
                    groups=config.lru_width,
                    padding=config.conv1d_width - 1,
                )
        
        ## 输入[, seq_len, hidden_size]
        x_branch = self.linear_x(input_states)
        ## 变成[, hidden_size, seq_len]
        x_branch = x_branch.transpose(1, 2)
        if use_cache:
            if cache_position.shape[0] != 1:  # prefill
                self.conv1d_state = nn.functional.pad(x_branch, 
                    (self.conv1d_width - x_branch.shape[-1] - 1, 0))
                x_branch = self.conv_1d(x_branch)[..., :seq_len]
            else:  # decoding
                conv_state = torch.cat((self.conv1d_state, x_branch), -1)
                x_branch = torch.sum(conv_state * self.conv_1d.weight[:, 0, :], dim=-1) 
                    + self.conv_1d.bias
                x_branch = x_branch.unsqueeze(-1)
                self.conv1d_state = conv_state[:, :, 1:]
        else:
            # 前面维度不变，最后一维截断到seq_len
            x_branch = self.conv_1d(x_branch)[..., :seq_len]

参考Resurrecting Recurrent Neural Networks for Long Sequences提出的LRU(Linear Recurrent Unit)，并参考传统LSTM和GRU引入了gate：

$$\begin{aligned} r_t & =\sigma\left(W_a x_t+b_a\right), \quad \text { recurrence gate } \\ i_t & =\sigma\left(W_x x_t+b_x\right), \quad \text { input gate } \\ a_t & =a^{c r_t}, \\ h_t & =a_t \odot h_{t-1}+\sqrt{1-a_t^2} \odot\left(i_t \odot x_t\right) . \end{aligned}$$

其中，recurrent weight $a=\sigma(\Lambda)$是一个对角矩阵，$\Lambda$是一个可学习的参数。$c$是一个常数8，为了计算稳定，在log-space计算$a^{c r_t}$，即先算出$\log a_t$，再取exp。

$$\log a_t=\log a^{c r_t}=\log \sigma(\Lambda)^{c r_t}=-\operatorname{csoftplus}(\Lambda) \odot r_t$$

(这个公式可能有点问题，感觉应该是$-\operatorname{csoftplus}(-\Lambda) \odot r_t$，不过$\Lambda$是一个可学习的nn.Parameter，其实这个错误无所谓吧)

    def __init__(self, config):
        super().__init__()
        self.num_attention_heads = config.num_attention_heads
        self.block_width = config.lru_width // self.num_attention_heads

        self.recurrent_param = nn.Parameter(torch.empty([config.lru_width]))
        self.input_gate_weight = nn.Parameter(
            torch.empty([self.num_attention_heads, self.block_width, self.block_width])
        )
        self.input_gate_bias = nn.Parameter(torch.empty([self.num_attention_heads, self.block_width]))

        self.recurrent_gate_weight = nn.Parameter(
            torch.empty([self.num_attention_heads, self.block_width, self.block_width])
        )
        self.recurrent_gate_bias = nn.Parameter(torch.empty([self.num_attention_heads, self.block_width]))
        self.recurrent_states = None

    def forward(xxx):
        ## reshape成适合多头的情况
        reshape_act = activations.reshape(batch_size * seq_len, self.num_attention_heads, self.block_width)
        ## (num_attention_heads, batch_size * seq_len, block_width)
        reshape_act = reshape_act.permute(1, 0, 2)

        ## 批量矩阵乘法（baddbmm），在reshape_act和self.input_gate_weight之间进行，
        ## 并加上偏置self.input_gate_bias。这一步计算输入门的原始值。
        res = torch.baddbmm(self.input_gate_bias[:, None, :], reshape_act, self.input_gate_weight)
        input_gate = torch.sigmoid(res.transpose(0, 1).reshape(batch_size, seq_len, lru_width))

        ## 类似input_gate
        res = torch.baddbmm(self.recurrent_gate_bias[:, None, :], reshape_act, self.recurrent_gate_weight)
        recurrent_gate = torch.sigmoid(res.transpose(0, 1).reshape(batch_size, seq_len, lru_width))

        # Compute the parameter `A` of the recurrence.
        # 上面的公式
        log_recurrent_gate = -8.0 * recurrent_gate * nn.functional.softplus(self.recurrent_param)
        recurrent_gate = torch.exp(log_recurrent_gate)

还有如下几个特点：

• $W_a$和$W_x$用LeCun init初始化

• 初始化$\Lambda$，使得在训练开始时，$a^c$均匀分布在0.9和0.999之间，类似Resurrecting Recurrent Neural Networks for Long Sequences

• 不像大部分SSM（例如Hippo: Recurrent memory with optimal polynomial projections）基于orthogonal polynomials（正交多项式）理论进行初始化。

• 也不像Efficiently modeling long sequences with structured state spaces在底层的连续系统上进行离散化定义

• 不像原始的LRU用了复数，虽然 On the universality of linear recurrences followed by nonlinear projections说复数的表达能力更强，但在实践中对语言模型并没有什么用（Mamba: Linear-Time Sequence Modeling with Selective State Spaces）

gate特点

先复习一下LSTM：

lstm-peephole-lstm

GRU：

• 重置门（reset gate）：如果重置门关闭，会忽略掉历史信息，即历史不相干的信息不会影响未来的输出。

• 更新门（update gate）：将LSTM的输入门和遗忘门合并，用于控制历史信息对当前时刻隐层输出的影响。如果更新门接近1，会把历史信息传递下去。

gru

• 两个gate只和$x_t$有关，和$h_{t-1}$无关。

• input gate $i_t$和LSTM类似，直接对输入$x_t$进行filter或者scale down。

• recurrent gate $r_t$和之前的gate机制不同：

  • mamba里的selection机制和GRU的update gate类似，在之前的状态和当前输入$x_t$之间进行插值（interpolate），功能类似LSTM的forget gate，能够reset状态，并遗忘之前的信息

  • 本文的recurrent gate则类似于在LRU的更新和之前的隐藏状态之间进行插值，能够有效地丢弃输入，并且保持之前历史里的所有信息。使得模型在处理不相关或重复输入（uniformative inputs）时，更能达到超指数的记忆能力，以更有效地保留有用信息(因为这个gate和$h_{t-1}$无关)。

feedback attention memory

TransformerFAM: Feedback attention is working memory

infini-attention

Leave No Context Behind: Efficient Infinite Context Transformers with Infini-attention

【重磅】谷歌重塑Transformer：无限记忆力，无限长输入，LLM基础研究重大突破

将压缩记忆整合进标准的点积注意力机制，并在单个Transformer块内同时实现了掩码局部注意力和长期线性注意力机制

infini-attention

与transformer-xl对比：

infini-attention-vs-transformer-xl

https://github.com/mustafaaljadery/gemma-2B-10M

https://github.com/dingo-actual/infini-transformer

MEGA

Mega: Moving average equipped gated attention

https://github.com/facebookresearch/mega

标准的self-attention公式

对于序列长度=$n$的输入$\boldsymbol{X}=\left\{\mathbf{x}_1, \mathbf{x}_2, \ldots, \mathbf{x}_n\right\} \in \mathbb{R}^{n \times d}$，输出$\boldsymbol{Y}=\left\{\mathbf{y}_1, \mathbf{y}_2, \ldots, \mathbf{y}_n\right\} \in \mathbb{R}^{n \times d}$

$$\boldsymbol{Y}=\operatorname{Attn}(\boldsymbol{X})=f\left(\frac{\boldsymbol{Q} \boldsymbol{K}^T}{\tau(\boldsymbol{X})}\right) \boldsymbol{V}$$

$$\boldsymbol{Q}=\boldsymbol{X} W_q+b_q,\boldsymbol{K}=\boldsymbol{X} W_k+b_k,\boldsymbol{V}=\boldsymbol{X} W_v+b_v$$

其中，$\text { Attn : } \mathbb{R}^{n \times d} \rightarrow \mathbb{R}^{n \times d}$，$W_q, W_k, W_v \in \mathbb{R}^{d \times d}$，$b_q, b_k, b_v \in \mathbb{R}^d$，而且有两种定义方式：

• $f(\cdot)=f_{\text {softmax }}(\cdot)$，同时$\tau(\boldsymbol{X})=\sqrt{d}$，这是经典操作Neural Machine Translation by Jointly Learning to Align and Translate

• $f(\cdot)=f_{\mathrm{relu}^2}(\cdot)$即$relu(x)^2$，同时$\tau(\boldsymbol{X})=n$，这是Primer: Searching for efficient transformers for language modeling和Transformer Quality in Linear Time提出的

gau

对于$h$个attention heads，计算$\boldsymbol{A}=f\left(\frac{\boldsymbol{Q} \boldsymbol{K}^T}{\tau(\boldsymbol{X})}\right) \in \mathbb{R}^{n \times n}$需要的时间和空间复杂度都是$O(hn^2)$

EMA

对于输出的序列$\boldsymbol{Y}$采用Exponential Moving Average(指数滑动平均)如下

$$\mathbf{y}_t=\boldsymbol{\alpha} \odot \mathbf{x}_t+(1-\boldsymbol{\alpha}) \odot \mathbf{y}_{t-1}$$

其中，$\boldsymbol{\alpha} \in(0,1)^d$表示权重衰减，$\odot$是element-wise product

$\boldsymbol{\alpha}$越大，$1-\boldsymbol{\alpha}$越小，对历史的衰减也越快：

ema

EMA的计算看成$n$个独立的卷积，可以通过**FFT(快速傅立叶变换)**来加速计算。具体。。。再看看

Damped EMA：由于输入的x是d维向量，可以引入一个因子$\boldsymbol{\delta} \in(0,1)^d$让EMA更鲁棒：

$$\mathbf{y}_t=\boldsymbol{\alpha} \odot \mathbf{x}_t+(1-\boldsymbol{\alpha} \odot \boldsymbol{\delta}) \odot \mathbf{y}_{t-1}$$

MEGA

EMA可以看成是一种与位置相关的归纳偏置（inductive bias），即假设当前位置与之前位置满足滑动平均的关系，而attention矩阵的计算其实并没有考虑位置信息，所以可以把二者结合一下。

mega

其中的multi-dimensional damped EMA大致流程如下：

• 先变成h维：先把$\boldsymbol{X} \in \mathbb{R}^{n \times d}$通过矩阵$\beta$映射成$\boldsymbol{U}\in \mathbb{R}^{n \times h}$

• 计算EMA：然后通过EMA得到$\boldsymbol{h}\in \mathbb{R}^{n \times h}$（具体$\mathbf{h}_t^{(j)}=\boldsymbol{\alpha}_j \odot \mathbf{u}_t^{(j)}+\left(1-\boldsymbol{\alpha}_j \odot \boldsymbol{\delta}_j\right) \odot \mathbf{h}_{t-1}^{(j)}$）

• 再变回d维：再通过一个矩阵$\eta$变回$\boldsymbol{Y}\in \mathbb{R}^{n \times h}$

然后看整个流程：

• 先计算EMA

$$\begin{aligned} \boldsymbol{X}^{\prime} & =\operatorname{EMA}(\boldsymbol{X}) & & \in \mathbb{R}^{n \times d} \\ \boldsymbol{Z} & =\phi_{\text {silu }}\left(\boldsymbol{X}^{\prime} W_z+b_z\right) & & \in \mathbb{R}^{n \times z} \end{aligned}$$

• 再基于EMA的结果计算QK，基于原始的X计算V：

$$\begin{array}{ll} \boldsymbol{Q}=\boldsymbol{\kappa}_q \odot \boldsymbol{Z}+\boldsymbol{\mu}_q & \in \mathbb{R}^{n \times z} \\ \boldsymbol{K}=\boldsymbol{\kappa}_k \odot \boldsymbol{Z}+\boldsymbol{\mu}_k & \in \mathbb{R}^{n \times z} \\ \boldsymbol{V}=\phi_{\text {silu }}\left(\boldsymbol{X} W_v+b_v\right) & \in \mathbb{R}^{n \times v} \end{array}$$

• 计算带位置bias的attention：

$$\boldsymbol{O}=f\left(\frac{\boldsymbol{Q} \boldsymbol{K}^T}{\tau(\boldsymbol{X})}+\boldsymbol{b}_{\mathrm{rel}}\right) \boldsymbol{V} \quad \in \mathbb{R}^{n \times v}$$

• 通过reset gate $\boldsymbol{\gamma}$和update gate $\boldsymbol{\varphi}$计算输出

$$\begin{aligned} \boldsymbol{\gamma} & =\phi_{\text {silu }}\left(\boldsymbol{X}^{\prime} W_\gamma+b_\gamma\right) & & \in \mathbb{R}^{n \times v} \\ \boldsymbol{\varphi} & =\phi_{\text {sigmoid }}\left(\boldsymbol{X}^{\prime} W_{\varphi}+b_{\varphi}\right) & & \in \mathbb{R}^{n \times d} \\ \hat{\boldsymbol{H}} & =\phi_{\text {silu }}\left(\boldsymbol{X}^{\prime} W_h+(\boldsymbol{\gamma} \boldsymbol{O}) U_h+b_h\right) & & \in \mathbb{R}^{n \times d} \\ \boldsymbol{Y}&=\boldsymbol{\varphi} \odot \hat{\boldsymbol{H}}+(1-\boldsymbol{\varphi}) \odot \boldsymbol{X} \quad & & \in \mathbb{R}^{n \times d} \end{aligned}$$

这里把attention里的softmax改成了如下的laplace函数：

$$f_{\text {laplace }}(x ; \mu, \sigma)=0.5 \times\left[1+\operatorname{erf}\left(\frac{x-\mu}{\sigma \sqrt{2}}\right)\right]$$

其中，$\operatorname{erf}(x)=\frac{1}{\sqrt{\pi}} \int_{-x}^x e^{-t^2} \mathrm{~d} t=\frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} \mathrm{~d} t$是误差函数，

为了让laplace逼近$f_{\text {relu }^2}$，对于$x=\sqrt{2}$这个点，求解如下方程

$$\begin{aligned} & f_{\text {relu2 }}(\sqrt{2})=f_{\text {laplace }}(\sqrt{2}) \\ & f_{\text {relu2 }}^{\prime}(\sqrt{2})=f_{\text {laplace }}^{\prime}(\sqrt{2}) \end{aligned}$$

可以得到$\mu=\sqrt{1 / 2}$，$\sigma=\sqrt{1 / 4 \pi}$，对应的曲线和准确率如下：

laplace-vs-relu2

mega-chunk

mega-chunk

将序列切分成长度固定为$c$的$k=n/c$个chunk，对每个chunk独立计算上面的attention，这样复杂度就变成了$O(kc^2)=O(nc)$，由于有EMA，所以这样做还是能够保持一定程度的长距离依赖。

MEGALODON

Meta无限长文本大模型来了：参数仅7B，已开源

革命新架构掀翻Transformer！无限上下文处理，2万亿token碾压Llama 2

MEGALODON: Efficient LLM Pretraining and Inference with Unlimited Context Length

https://github.com/XuezheMax/megalodon

Megalodon: Efficient LLM Pretraining and Inference with Unlimited Context Length

基于MEGA进行改进，能够同时实现

• 高效训练（减少通信和计算量）

• 高效推理（保持恒定的KV缓存）

MOD

Mixture-of-Depths: Dynamically allocating compute in transformer-based language models

每层选不同的token过moe

multi-head moe

微软让MoE长出多个头，大幅提升专家激活率

Multi-Head Mixture-of-Experts

https://github.com/yushuiwx/MH-MoE

Lory

150B token从头训练，普林斯顿Meta发布完全可微MoE架构Lory

Lory: Fully Differentiable Mixture-of-Experts for Autoregressive Language Model Pre-training

Perciever

Perceiver: General Perception with Iterative Attention

Aaren

更早期的：Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention

Bengio等人新作：注意力可被视为RNN，新模型媲美Transformer，但超级省内存

Attention as an RNN

many-to-one RNN

对query向量$q$的attention可以看成是一个函数，对输入的$N$个token $x_{1: N}$通过他们的key和value $\left\{\left(k_i, v_i\right)\right\}_{i=1}^N$ 变换成输出 $\text { Attention }\left(q, k_{1: N}, v_{1: N}\right)$，假设$\bar{s}_i=\operatorname{dot}\left(q, k_i\right)$，那么输出就是

$$o_N=\sum_{i=1}^N \operatorname{softmax}(s)_i v_i=\frac{\sum_{i=1}^N \exp \left(s_i\right) v_i}{\sum_{i=1}^N \exp \left(s_i\right)}=\frac{\hat{a}_N}{\hat{c}_N}$$

可以发现，分子和分母其实都可以写成递推形式$\hat{a}_k=\hat{a}_{k-1}+\exp \left(s_k\right) v_k$和$\hat{c}_k=\hat{c}_{k-1}+\exp \left(s_k\right)$，由于直接这么做可能会产生很大或者很小的值（例如算exp），所以可以通过如下方式进行缓解：计录到第k步的最大值$m_k=\max _{i \in\{1, \ldots, k\}} s_i$，然后减掉它，即$a_k=\sum_{i=1}^k \exp \left(s_i-m_k\right) v_i$和$c_k=\sum_{i=1}^k \exp \left(s_i-m_k\right)$，这样就可以改写为如下形式：

$$\begin{aligned} a_k & =a_{k-1} \exp \left(m_{k-1}-m_k\right)+v_k \exp \left(s_k-m_k\right) \\ c_k & =c_{k-1} \exp \left(m_{k-1}-m_k\right)+\exp \left(s_k-m_k\right) \\ m_k & =\max \left(m_{k-1}, s_k\right) \end{aligned}$$

其中第一行其实就是$s_i-m_k=s_i-m_k+m_{k-1}-m_k$，然后exp一下，$exp(s_i-m_k)=exp(s_i-m_k)exp(m_{k-1}-m_k)$，总结成如下图：

attention-rnn-cell

所以Attention的RNN cell就是输入$\left(a_{k-1}, c_{k-1}, m_{k-1}, q\right)$，输出$\left(a_k, c_k, m_k, q\right)$，初始的状态是$\left(a_0, c_0, m_0, q\right)=(0,0,0,q)$

然后就可以将之前的attention看成如下几类many-to-one的RNN了：

• 传统attention只计算最后的一个输出

• self-attention使用输入token作为初始状态

• Perceiver的cross-attention使用依赖input的隐变量作为初始状态

many-to-one-rnn

对于新来的token而言：

• 传统的RNN一般是流式地输入数据，因此只需要O(1)的内存和计算就行了

• Transformer需要把这个新token当成一个初始状态加进来，所以需要把之前时间步的再重新算一次，需要O(N)的计算

• Perceiver中的隐变量是依赖输入的，而且这个新token会改变value，因此初始状态也会变，所以需要从头算一遍，需要O(NL)的计算，L是隐变量个数（可以参考代码perceiver_torch和如下gpt4o的回答）

perceiver

many-to-many RNN

要计算$\left\{o_i=\operatorname{Attention}\left(q, x_{1: i}\right)\right\}_{i=1}^N$，通过如下的并行前缀扫描算法，对于$N$个序列数据的$N$个前缀，通过关联运算符$\oplus$并行计算，能够高效地通过$\left\{x_k\right\}_{k=1}^N$计算$\left\{\bigoplus_{i=1}^k x_i\right\}_{k=1}^N$

parallel-prefix-scan

由于$\operatorname{Attention}\left(\mathrm{q}, \mathrm{x}_{1: \mathrm{k}}\right)=o_k=\frac{a_k}{c_k}$，为了计算$\left\{\text { Attention }\left(\mathrm{q}, \mathrm{x}_{1: \mathrm{k}}\right)\right\}_{k=1}^N$，只需要先按这个并行扫描算法计算$\left\{a_k\right\}_{k=1}^N$、$\left\{c_k\right\}_{k=1}^N$和$\left\{m_k\right\}_{k=1}^N$，再把$a_k$和$c_k$结合起来就行。

接来来定义三元组$\left(\mathrm{m}_A, \mathrm{u}_A, \mathrm{w}_A\right)$，其中

• $A$：一些下标的集合

• $\mathrm{m}_A=\max _{i \in A} s_i$

• $\mathrm{u}_A=\sum_{i \in A} \exp \left(s_i-\mathrm{m}_A\right)$

• $\mathrm{w}_A=\sum_{i \in A} \exp \left(s_i-\mathrm{m}_A\right) v_i$

所以并行扫描算法的输入是$\left\{\left(\mathrm{m}_{\{i\}}, \mathrm{u}_{\{i\}}, \mathrm{W}_{\{i\}}\right)\right\}_{i=1}^N=\left\{\left(s_i, 1, v_i\right)\right\}_{i=1}^N$，再来定义操作$\oplus$：

$$\left(\mathrm{m}_A, \mathrm{u}_A, \mathrm{w}_A\right) \oplus\left(\mathrm{m}_B, \mathrm{u}_B, \mathrm{w}_B\right)=\left(\mathrm{m}_{A \cup B}, \mathrm{u}_{A \cup B}, \mathrm{w}_{A \cup B}\right)$$

其中，

• $\mathrm{m}_{A \cup B}=\max \left(\mathrm{m}_A, \mathrm{~m}_B\right)$

• $\mathrm{u}_{A \cup B}=\mathrm{u}_A \exp \left(\mathrm{m}_A-\mathrm{m}_{A \cup B}\right)+\mathrm{u}_B \exp \left(\mathrm{m}_B-\mathrm{m}_{A \cup B}\right)$

• $\mathrm{w} _{A \cup B}=\mathrm{w}_A \exp \left(\mathrm{m}_A-\mathrm{m}_{A \cup B}\right)+\mathrm{w}_B \exp \left(\mathrm{m}_B-\mathrm{m}_{A \cup B}\right)$

这个并行扫描算法最终输出下式，即$\left\{\left(m_k, c_k, a_k\right)\right\}_{k=1}^N$：

$$\left\{\left(\mathrm{m}_{\{1, \ldots, k\}}, \mathrm{u}_{\{1, \ldots, k\}}, \mathrm{w}_{\{1, \ldots, k\}}\right)\right\}_{k=1}^N=\left\{\left(m_k, \sum_{i=1}^k \exp \left(s_i-m_k\right), \sum_{i=1}^k \exp \left(s_i-m_k\right) v_i\right)\right\}_{k=1}^N$$

many-to-many-rnn

Aaren

Aaren(attention as a recurrent newral network)的结构如下：

$$\begin{aligned} h_1^{(0)}, \ldots, h_N^{(0)} & \leftarrow x_1, \ldots, x_N \\ {\left[h_1^{(j+1)}, \ldots, h_N^{(j+1)}\right] } & \leftarrow \operatorname{Aaren}\left(q^{(j)},\left[h_1^{(j)}, \ldots, h_N^{(j)}\right]\right) \end{aligned}$$

transformer的query是输入的token，而Aaren的query token $q$是在训练的过程中通过bp学习的。迭代地计算$y_k$只需要常数级的计算，因为它依赖$h_{k-1}$和$x_k$。

transformer：

• 使用kv cache时需要线性的内存

• 需要保存所有之前的tokens，包括在中间层的那些

aaren：

• 只需要常数级的内存

• 不需要保存之前的所有tokens

stacking-aaren

Matmul-free

从LLM中完全消除矩阵乘法，效果出奇得好，10亿参数跑在FPGA上接近大脑功耗

H2O attention

H2O: Heavy-Hitter Oracle for Efficient Generative Inference of Large Language Models

• sparsity for small cache size：kv cache很稀疏，只要5%效果就可以了

• Heavy-Hitters for low miss rate：一小部分的token贡献了大部分attention score

• 贪心法选择需要干掉的token：假设总共需要保留k个token，对于第i个token，加进来后，遍历集合里的所有token，看干掉哪一个对attention score影响最小，就把它干掉

TransNAR

拯救Transformer推理能力！DeepMind新研究TransNAR：给模型嵌入「算法推理大脑」

Transformers meet Neural Algorithmic Reasoners

基于：Neural Algorithmic Reasoning

softmax数学原理

通向概率分布之路：盘点Softmax及其替代品

把softmax的分母记为$Z(x)$，其对数是max的一个光滑近似：

$$\begin{array}{r} \log Z(\boldsymbol{x})=\log \sum_{j=1}^n e^{x_j}=\operatorname{logsumexp}(\boldsymbol{x}) \\ \lim _{\tau \rightarrow 0^{+}} \tau \operatorname{logsumexp}(\boldsymbol{x} / \tau)=\max (\boldsymbol{x}) \end{array}$$

当$\tau$取1时，可以得到$\operatorname{logsumexp}(\boldsymbol{x}) \approx \max (\boldsymbol{x})$

StreamingLLM

Efficient Streaming Language Models with Attention Sinks

深度解析streamingLLM之无限长文本生成能力

attention sink：输入给LLM推理开头的几个intial tokens是非常特殊的，就像水龙头一样，出水那一瞬间吸引了人们大量的attention。而且intial tokens与生成token的绝对距离距离和语义信息都不重要，重要的是这第一个或者前面几个token。

softmax需要所有位置的值的总和为1，因此必须给某些位置权重，即使这个位置对输出没有任何贡献，可能导致在backward的过程中产生错误的权重更新，而这个错误在后续的过程中很难被纠正。因此，模型倾向于将不必要的注意力值转嫁给特定的token。其实在https://www.evanmiller.org/attention-is-off-by-one.html就提出了，要给softmax的分母+1：$(\operatorname{softmax_1}(\mathrm{x}))_i=\frac{\exp \left(x_i\right)}{\sum_j \exp \left(x_j\right)+1}$

当每个token都趋向负无穷时，softmax的极限是1/k（k是token数），也就是会让每个token的概率都是1/k

$$\lim _{x 1 \rightarrow-\infty} \ldots \lim _{x_k \rightarrow-\infty}(\operatorname{softmax}(x))_i=\frac{1}{k}>0$$

而$softmax_1$因为分母有个1（即$exp(0)=1$），相当于在最前面引入了一个或者多个的无意义的global_token。同样当每个token都趋向负无穷时，因为分母已经有一个1了，所以可以让其他正常token都趋于0

$$\lim _{x 1 \rightarrow-\infty} \ldots \lim _{x_k \rightarrow-\infty}\left(\operatorname{softmax}_1(x)\right)_i=0$$

https://github.com/mit-han-lab/streaming-llm

集成到trt-llm里了：https://github.com/NVIDIA/TensorRT-LLM/tree/main/examples/llama#run-llama-with-streamingllm

• trtllm-build时，加上--streamingllm enable

• infer时，加上--sink_token_length设置sink的token数，加上--max_attention_window_size设置sliding_window

是否还要RAG?

谷歌重磅：告别RAG，长上下文的大语言模型无需检索增强

memory^3

鄂维南院士领衔新作：大模型不止有RAG、参数存储，还有第3种记忆

Memory3 : Language Modeling with Explicit Memory

TSLLM

没想到！AlphaZero式树搜索也能用来增强大语言模型推理与训练

AlphaZero-Like Tree-Search can Guide Large Language Model Decoding and Training

https://github.com/waterhorse1/LLM_Tree_Search

PEER

单一作者论文，谷歌提出百万专家Mixture，超越密集前馈、稀疏MoE

MoE也有Scaling Law，「百万专家」利用率近100%！DeepMind华人挑战MoE极限

Mixture of A Million Experts

TTT

彻底改变语言模型：全新架构TTT超越Transformer，ML模型代替RNN隐藏状态

Learning to (Learn at Test Time): RNNs with Expressive Hidden States

https://github.com/test-time-training/ttt-lm-jax

https://github.com/test-time-training/ttt-lm-pytorch

ttt

连OpenAI都推不动Scaling Law了？MIT把「测试时训练」系统研究了一遍，发现还有路

The Surprising Effectiveness of Test-Time Training for Atract Reasoning

Axiomatic Training

6700万参数比肩万亿巨兽GPT-4！微软MIT等联手破解Transformer推理密码

公理训练让LLM学会因果推理：6700万参数模型比肩万亿参数级GPT-4

Teaching Transformers Causal Reasoning through Axiomatic Training

训练大模型新范式——公理框架（Axiomatic Framework），作者从头开始训练了6700万参数的模型，仅使用了简单的因果链作为训练数据。在推断复杂图表中的因果关系时，67M模型的表现超越了十亿级参数LLM，甚至可以与GPT-4相媲美。

PNN

AI大模型有望再扩1000倍！剑桥耶鲁康奈尔：PNN是变革关键

Training of Physical Neural Networks

JRT

小技巧大功效，「仅阅读两次提示」让循环语言模型超越Transformer++，注：这里的transformer++指的就是llama2的架构

Just read twice: closing the recall gap for recurrent language models

https://github.com/HazyResearch/prefix-linear-attention

jrt

order的重要性

线性attention的recurrent state很小，存储空间有限，往往很难选择要存储哪些state。

如果集合A和集合B有交集，且A元素比B多，先出现集合A的时候，需要存储整个A，而先出现集合B的时候，则只需要存储集合B

JRT-Prompt

上下文学习任务以$(\mathcal{C}, \mathcal{Q}, \mathcal{Y})$作为输入，$\mathcal{C}$为一些上下文来源（如文档或代码存储库），$\mathcal{Q}$为给定上下文时对模型的一些问题或请求，$\mathcal{Y}$为答案。

• 使用自回归的标准上下文学习模型$\mathcal{A}$，输入$\mathcal{C}$和$\mathcal{Q}$，并根据正确的完成情况$Y$来评估生成的输出$\hat{\mathcal{Y}}=\mathcal{A}(\mathcal{C}, \mathcal{Q})$。

• JRT-PROMPT：在提示模型输出答案之前会在上下文中重复提示中的信息（如问题和文档），例如$\hat{\mathcal{Y}}=\mathcal{A}(\mathcal{C}, \mathcal{Q}, \mathcal{C}, \mathcal{Q})$。在上下文第二次出现时，模型根据完整的上下文来决定存储哪些信息。

示例：

# 原来的prompt
## input: 
百度是一个xxx公司，1999年，xxxxx，2001年，xxx，2002年，xxxx。百度成立于
## output: 
2001年

# JRT的prompt
## input：
百度成立于哪一年？百度是一个xxx公司，1999年，xxxxx，2001年，xxx，2002年，xxxx。
百度是一个xxx公司，1999年，xxxxx，2001年，xxx，2002年，xxxx。百度成立于
## output: 
2001年

base的linear transformer

通过$\phi: \mathbb{R}^d \rightarrow \mathbb{R}^{\tilde{d}}$，使得$\phi\left(\boldsymbol{q}_i\right)^{\top} \phi\left(\boldsymbol{k}_j\right) \approx \exp \left(\boldsymbol{q}_i^{\top} \boldsymbol{k}_j / \sqrt{d}\right) .$

$$\boldsymbol{y}_i=\frac{\phi\left(\boldsymbol{q}_i\right) \sum_{j=1}^i\left(\phi\left(\boldsymbol{k}_j\right)^{\top} \boldsymbol{v}_j\right)}{\phi\left(\boldsymbol{q}_i\right) \sum_{j=1}^i \phi\left(\boldsymbol{k}_j\right)}$$

先计算k和v的乘法，时间和空间复杂度是$\mathcal{O}(N d \tilde{d})$，而softmax attention是$O\left(N^2 d\right)$

infer阶段包括两个phases：

• prefill：并行处理prompt，得到两个state：

  • KV-state：$\boldsymbol{s}_l=\sum_{j=1}^l \phi\left(\boldsymbol{k}_j\right)^{\top} \boldsymbol{v}_j$

  • K-state：$\boldsymbol{z}_l=\sum_{j=1}^l \phi\left(\boldsymbol{k}_j\right)^{\top}$

• decoding：计算如下3步，其中$\boldsymbol{s}_i \in \mathbb{R}^{d \times \tilde{d}}$，$\boldsymbol{z}_i \in \mathbb{R}^{\tilde{d}}$，一个decode step有$O(1)$的时间和空间复杂度，而softmax attention加上kv-caching有$O(N)$

  • $\boldsymbol{s}_i=\boldsymbol{s}_{i-1}+\phi\left(\boldsymbol{k}_i\right)^{\top} \boldsymbol{v}_i$

  • $\boldsymbol{z}_i=\boldsymbol{z}_{i-1}+\phi\left(\boldsymbol{k}_i\right)^{\top}$

  • $\boldsymbol{y}_i=\frac{\phi\left(\boldsymbol{q}_i\right) \boldsymbol{s}_i}{\phi\left(\boldsymbol{q}_i\right) \boldsymbol{z}_i}$

JRT-RNN架构

PLA（Prefix Linear Attention）受Prefix-LM启发，主要有2个特点：

• prefix-LM在encoder和decoder的projection是共享的，而JRT-RNN的encoder用$\boldsymbol{k}_e, \boldsymbol{v}_e$，decoder用$\boldsymbol{k}_d, \boldsymbol{v}_d$

• 编码器使用了non-causal的线性注意力，而解码器使用标准causal线性注意力。

prefill阶段，并行地对长度为$l$的prompt进行如下计算，如果长度$l< M$，进行left-pad到$M$长度

$$\boldsymbol{y}_i=\frac{\phi\left(\boldsymbol{q}_i\right)\left(\sum_{j=1}^i \phi\left(\boldsymbol{k}_{d_j}\right)^{\top} \boldsymbol{v}_{d_j}+\sum_{j=1}^M \phi\left(\boldsymbol{k}_{e_j}\right)^{\top} \boldsymbol{v}_{e_j}\right)}{\phi\left(\boldsymbol{v} q_i\right)\left(\sum_{j=1}^i \phi\left(\boldsymbol{k}_{d_j}\right)^{\top}+\sum_{j=1}^M \phi\left(\boldsymbol{k}_{e_j}\right)^{\top}\right)}$$

初始化如下：

$$\boldsymbol{s}_M=\sum_{j=1}^M\left(\phi\left(\boldsymbol{k}_{e_j}\right)^{\top} \boldsymbol{v}_{e_j}+\phi\left(\boldsymbol{k}_{d_j}\right)^{\top} \boldsymbol{v}_{d_j}\right),\ \boldsymbol{z}_M=\sum_{j=1}^M\left(\phi\left(\boldsymbol{k}_{e_j}\right)^{\top}+\phi\left(\boldsymbol{k}_{d_j}\right)^{\top}\right)$$

对于decoding阶段，输出$y_i, i>M$，和base的linear transformer一样，不需要修改

训练loss是ntp和mlm的混合，假设序列长度是$N$，前$M$个token算MLM，后面的$N-M$个token算NTP：

$$\mathcal{L}=\frac{w_1 \mathcal{L}_{\mathrm{NTP}}+w_2 \mathcal{L}_{\mathrm{MLM}}}{w_1+w_2}$$

效率提升

虽然Linear attention比softmax attention要快，但其实不如精心优化的softmax attention（如flash attention），Simple linear attention language models balance the recall-throughput tradeof实现了一个io-aware的kernel（https://github.com/HazyResearch/based/），在prefill阶段精细地partitioning & storing暛的matrix-valued recurrent state across warp-registers，PLA参考这个实现了自己的加速版。

LM-steer

ACL 2024

LM-Steer: Word Embeddings Are Steers for Language Models

https://github.com/Glaciohound/LM-Steer

发现词向量空间上的线性变换空间等价于对语言模型生成样式的调节，并以此设计了名为 LM-Steers 的语言模型调控方法。我们发现词向量的这种调节作用普遍存在于各种尺寸的语言模型中。它只需要学习原始模型 0.2% 的参数就可以引导各种风格。在语言模型去毒化和生成情感控制等任务上，LM-Steers 可以实现与最先进的受控生成方法相当或更好的性能，同时保持更好的生成质量平衡。学习到的 LM-Steer 还可以充当文本风格的解读器：它可以解释各种文本样式与词向量哪些维度相关，并且可以用于寻找最具代表性的文本片段。 LM-Steer 可通过显式计算来在不同语言模型之间转移，而不需要额外训练。我们还可以简单地通过缩放 LM-Steer 来实现风格的连续控制，或者实现多种生成控制的组合。

razerattention

减少kv-cache的大小

RazorAttention: Efficient KV Cache Compression Through Retrieval Heads

受anthropic的induction head(In-context Learning and Induction Heads)启发:

• short head：对长文没有任何响应

• long head(induction head)：对长文能直接找到对应位置，并且对那附近的词有很强的信号

MLP-Mixer

MLP-Mixer: An all-MLP Architecture for Vision

sigmoid attention

Sigmoid注意力一样强，苹果开始重新审视注意力机制

Theory, Analysis, and Best Practices for Sigmoid Self-Attention

https://github.com/apple/ml-sigmoid-attention

证明了从理论上讲，与 softmax 注意力相比，具有sigmoid注意力的Transformer是通用函数逼近器，并且受益于改进的正则化。

lstm+transformer

LSTM+Transformer王炸创新，荣登Nature

AnyGraph

港大黄超团队推出AnyGraph, 首次揭秘图大模型的Scaling Law

AnyGraph: Graph Foundation Model in the Wild

https://github.com/HKUDS/AnyGraph

液态神经网络

给机器人装上「虫脑」？非Transformer液态神经网络终于来了！MIT CSAIL负责人创业成果

Liquid Foundation Models（LFM），1B、3B和40B LFM在各个规模上均能实现SOTA性能，同时保持更小的内存占用和更高效的推理。2020年就有了Liquid Time-constant Networks

差分transformer

这篇论文非常火！差分Transformer竟能消除注意力噪声，犹如降噪耳机

Differential Transformer

Transformer往往会过度关注不相关的上下文，即注意力噪声（attention noise），而差分Transformer则能放大对答案范围的注意力并消除噪音，从而增强上下文建模的能力。

SparseLLM

NeurIPS 2024｜SparseLLM：突破性全局剪枝技术，大语言模型稀疏化革命

SparseLLM: Towards Global Pruning of Pre-trained Language Models

https://github.com/BaiTheBest/SparseLLM

minLSTM+minGRU

图灵奖得主Yoshua Bengio新作：Were RNNs All We Needed?

Were RNNs All We Needed?

MixCon

北大林宙辰团队全新混合序列建模架构MixCon：性能远超Mamba

MixCon: A Hybrid Architecture for Efficient and Adaptive Sequence Modeling

self-lengthen

阿里千问提出Self-Lengthen，大模型实现自迭代扩展输出长度

Language Models Can Self-Lengthen to Generate Long Texts

https://github.com/QwenLM/Self-Lengthen

BLT

Tokenization不存在了？Meta最新研究，无需Tokenizer的架构来了

Byte Latent Transformer: Patches Scale Better Than Tokens

R2L tokenizer

从2019年到现在，是时候重新审视Tokenization了

https://huggingface.co/spaces/huggingface/number-tokenization-blog

memory layers at scale

Meta探索大模型记忆层，扩展至1280亿个参数，优于MoE

Memory Layers at Scale

https://github.com/facebookresearch/memory

TITANS

(toread)

谷歌新架构一战成名，打破Transformer记忆瓶颈，姚班校友钟沛林新作

近8年后，谷歌Transformer继任者「Titans」来了，上下文记忆瓶颈被打破

Titans: Learning to Memorize at Test Time

Miras

谷歌Transformer过时了？清华姚班校友等三连击，爆改注意力！

It's All Connected: A Journey Through Test-Time Memorization, Attentional Bias, Retention, and Online Optimization

atlas

Atlas: Learning to Optimally Memorize the Context at Test Time

Hope+Nested Learning

TITANS的改进版

终结Transformer统治！清华姚班校友出手，剑指AI「灾难性遗忘」

Nested Learning: The Illusion of Deep Learning Architectures

嵌套学习将优化器（Optimizer，例如基于动量的优化器）视为一种联想记忆模块。这使我们能从联想记忆的角度重新设计优化算法。传统优化器通常依赖「点积相似度」来衡量样本间相似性，但这一机制无法考虑样本间的复杂关系。通过将优化目标改为标准损失函数，提出了新的动量更新公式，使优化过程对不完美数据更具鲁棒性。

在标准的Transformer模型中，

• 序列建模层承担短期记忆，保存当前上下文信息；

• 而前馈神经网络层则充当长期记忆，存储训练前的知识。

嵌套学习扩展了这一思想，提出「连续记忆系统」（Continuum Memory Systems，CMS），这是一种由多个模块组成的记忆谱系，每个模块以不同频率进行更新，这为持续学习创建了一个更加丰富、高效的记忆系统。

Hope是一种可自我修改的递归架构，能实现无限层级的上下文内学习。还结合了连续记忆系统，能够扩展到更大的上下文窗口。

...看不懂

Transformer^2

Transformer^2要做「活」的AI模型，动态调整权重，像章鱼一样适应环境

TRANSFORMER2 : SELF-ADAPTIVE LLMS

MTA

Multi-Token突破注意力机制瓶颈，Meta发明了一种很新的Transformer

Multi-Token Attention

Linear MOE

Linear-MoE：线性注意力遇上混合专家的开源实践

Linear-MoE: Linear Sequence Modeling Meets Mixture-of-Experts

https://github.com/OpenSparseLLMs/Linear-MoE

记忆能力

最新发现！每参数3.6比特，语言模型最多能记住这么多

How much do language models memorize?

MTLA

时空压缩！剑桥大学提出注意力机制MTLA：推理加速5倍，显存减至1/8

Multi-head Temporal Latent Attention

https://github.com/D-Keqi/mtla

StreamBP

无损减少80%激活值内存，提升5倍训练序列长度，仅需两行代码

StreamBP: Memory-Efficient Exact Backpropagation for Long Sequence Training of LLMs

https://github.com/Ledzy/StreamBP

DnD

LLM进入「拖拽时代」！只靠Prompt，几秒定制一个大模型，效率飙升12000倍

Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights

2-simplicial attention

原来Scaling Law还能被优化？Meta这招省token又提效

Fast and Simplex: 2-Simplicial Attention in Triton

将Transformer的点积注意力机制泛化到了三线性形式。

EBT

新范式来了！新能量模型打破Transformer++扩展上限，训练扩展率快35%

Energy-Based Transformers are Scalable Learners and Thinkers

MoR

Transformer终结者！谷歌DeepMind全新MoR架构问世，新一代魔王来了

「有望成为Transformer杀手」，谷歌DeepMind新架构MoR实现两倍推理速度

Mixture-of-Recursions: Learning Dynamic Recursive Depths for Adaptive Token-Level Computation

https://github.com/raymin0223/mixture_of_recursions 暂时还没有

• 每个recurrent step里有固定层数的transformer，router决定每个token是pass through还是exit

• recurrent block参数有一些是共享的

• 一个句子里，有的token需要过多个block，有的不重要的token只需要过很少的block

其实就是哪些层在不同的recurrent block之间是共享的，总共有$L$个block，每个block里有$N_r$层

• Cycle Strategy：所有block都共享

• Middle-Cycle Strategy：block里第0层和最后一层不共享，其他的共享。【实验发现这种效果最好】

• Sequence Strategy：参考下图(gpt解释的)

• Middle-Sequence Strategy：把middle-cycle的机制用到sequence strategy里

工程相关：

routing机制：

• Expert-choice routing：每个recursion step，routing选出top k的token继续，这里的k逐个step递减。优点是对计算负载均衡，缺点是会破坏causal，有泄露。

• Token-choice routing：每个token只做一次routing计算，决定它走后面多少个recursion step。优点是不会泄露，但缺点是可能负载不均

Kv caching机制：相比原始transformer都有优化

• recursion-wise KV caching：在某一个recursion step，只有对被路由过来的token做kv cache并计算attention。相比下面的方法，kv cache的io更小，attention flops更低

• recursive KV sharing：在第一个recursion step生成并缓存所有token的kv cache，然后在之后所有层中重复使用。相比上面的方法，kv cache存储更少，io更大，attention flops更高

对比如下：

Jet-Nemotron

英伟达再出手！新型混合架构模型问世，两大创新实现53.6倍吞吐提速

Jet-Nemotron: Efficient Language Model with Post Neural Architecture Search

• Post Neural Architecture Search，PostNAS：一种高效的后训练架构探索与自适应pipeline，可适用于任意预训练的Transformer模型。

• JetBlock：一种新型的线性注意力模块，其性能显著优于Mamba2等设计。

TPA

KV缓存不再爆！清华姚期智团队重写注意力维度，长上下文更省更强 | NeurIPS 2025 Spotlight

Tensor Product Attention Is All You Need

https://github.com/tensorgi/TPA

• $\mathbf{X} \in \mathbb{R}^{T \times d_{\text {model }}}$

• $\mathbf{Q}, \mathbf{K}, \mathbf{V} \in \mathbb{R}^{T \times h \times d_h}$，共$h$个head，每个head的dim是$d_h=d_k=d_{model}/h$，$\boldsymbol{W}^O \in \mathbb{R}^{\left(h \cdot d_h\right) \times d_{\text {model }}}$

• $\mathbf{Q}_i, \mathbf{K}_i, \mathbf{V}_i \in \mathbb{R}^{T \times d_h}$表示第$i$个head

• $\boldsymbol{W}_i^Q, \boldsymbol{W}_i^K, \boldsymbol{W}_i^V \in \mathbb{R}^{d_{\text {model }} \times d_k}$表示第$i$个head的权重

• $\mathbf{Q}_t, \mathbf{K}_t, \mathbf{V}_t \in \mathbb{R}^{h \times d_h}$表示第$t$个token的Q/K/V

• 向量外积：给定$\mathbf{a} \in \mathbb{R}^m, \mathbf{b} \in \mathbb{R}^n$，外积$\mathbf{a} \otimes \mathbf{b}=\mathbf{C} \in \mathbb{R}^{m \times n}$，其中$C_{i j}=a_i b_j$

• 矩阵外积：矩阵$\mathbf{C} \in \mathbb{R}^{m \times n}$，定义$\operatorname{vec}(\mathbf{C}) \in \mathbb{R}^{m n}$，即把矩阵flatten成一个长的列向量；也可以这么理解，$\mathbf{C}=\left[\mathbf{c}_1, \mathbf{c}_2, \ldots, \mathbf{c}_n\right]$，有n个列向量，那么，$\operatorname{vec}(\mathbf{C})=\left[\mathbf{c}_1^{\top}, \mathbf{c}_2^{\top}, \ldots, \mathbf{c}_n^{\top}\right]^{\top}$

TPA本质就是把$\mathbf{Q}_t, \mathbf{K}_t, \mathbf{V}_t \in \mathbb{R}^{h \times d_h}$进行分解，即$h\times d_h$的矩阵拆成$h$的a向量，和$d_h$的b向量的外积，还搞了R组的(a,b)，算R次外积并取平均值。

$$\begin{gathered} \mathbf{Q}_t=\frac{1}{R_Q} \sum_{r=1}^{R_Q} \mathbf{a}_r^Q\left(\mathbf{x}_t\right) \otimes \mathbf{b}_r^Q\left(\mathbf{x}_t\right), \quad \mathbf{K}_t=\frac{1}{R_K} \sum_{r=1}^{R_K} \mathbf{a}_r^K\left(\mathbf{x}_t\right) \otimes \mathbf{b}_r^K\left(\mathbf{x}_t\right), \\ \mathbf{V}_t=\frac{1}{R_V} \sum_{r=1}^{R_V} \mathbf{a}_r^V\left(\mathbf{x}_t\right) \otimes \mathbf{b}_r^V\left(\mathbf{x}_t\right), \end{gathered}$$

其中，$\mathbf{a}_r^Q\left(\mathbf{x}_t\right), \mathbf{a}_r^K\left(\mathbf{x}_t\right), \mathbf{a}_r^V\left(\mathbf{x}_t\right) \in \mathbb{R}^h, \mathbf{b}_r^Q\left(\mathbf{x}_t\right), \mathbf{b}_r^K\left(\mathbf{x}_t\right), \mathbf{b}_r^V\left(\mathbf{x}_t\right) \in \mathbb{R}^{d_h}$

然后对rope也处理了一下

OpenAI

GPT-OSS

https://github.com/openai/gpt-oss

• 两个模型，一个是5.1 in 117b的大模型，一个是3.6 in 21b的小模型

• apache 2.0协议，看来可以随便用咯

• 可以自定义reasoning的预算

• 可finetune、有agentic能力

• 原生用混精度fp4训练moe层

gpt_oss/torch/model.py里有naive版的torch实现，可以拿来理解模型结构

教程列表：https://cookbook.openai.com/topic/gpt-oss

finetune方法：https://cookbook.openai.com/articles/gpt-oss/fine-tune-transfomers

model card

117b的配置：

• sparse attn（滑动窗口是8）和full attn交替的，共32层

• 总共128专家，每个token激活4个，这个可以自己算一下，和官方model card里的参数是可以对应上的

• rope，并且通过yarn可以从4k外推到128k（rope_scaling的factor是32）

• attention用的是gqa，q有64个head，kvheads是8，即分成64/8=8组，每组共享kv

• 这个是model card里提到的：每个attn head在softmax分母里还有一个learned bias，类似attention sink的作用，让attention可以起到对任何token都pay no attention的作用

模型配置

class ModelConfig:
    num_hidden_layers: int = 36
    num_experts: int = 128
    experts_per_token: int = 4
    vocab_size: int = 201088
    hidden_size: int = 2880
    intermediate_size: int = 2880
    swiglu_limit: float = 7.0
    head_dim: int = 64
    num_attention_heads: int = 64
    num_key_value_heads: int = 8
    sliding_window: int = 128
    initial_context_length: int = 4096
    rope_theta: float = 150000.0
    rope_scaling_factor: float = 32.0
    rope_ntk_alpha: float = 1.0
    rope_ntk_beta: float = 32.0

attention部分

几个点：

• 可以看下原始streaming-llm的实现，核心是在kvcache里的这段https://github.com/mit-han-lab/streaming-llm/blob/main/streaming_llm/kv_cache.py，即cache中一直保留前start_size个token（sink token），还有当前token往前window_size个token

• oss是用到了attention bias的，可以看代码self.qkv是torch.nn.Linear，而这个类默认的参数就是bias=True，这个和hf的transformers里的实现也对上了

class AttentionBlock(torch.nn.Module):
    def __init__(
        self,
        config: ModelConfig,
        layer_idx: int = 0,
        device: torch.device | None = None,
    ):
        # 120b的模型head_dim是64
        self.head_dim = config.head_dim
        # 120b的模型num_attention_heads是64
        self.num_attention_heads = config.num_attention_heads
        # GQA的配置，K有多少个head，V有多少个head
        # num_attention_heads / num_key_value_heads就是分成多少组
        # 120b的模型num_key_value_heads是8
        self.num_key_value_heads = config.num_key_value_heads
        # 每隔一层搞一下sliding window
        self.sliding_window = config.sliding_window if layer_idx % 2 == 0 else 0
        # 实现attn sink的功能，长度为64，后面会拆成8*8
        self.sinks = torch.nn.Parameter(
            torch.empty(config.num_attention_heads, device=device, dtype=torch.bfloat16)
        )
        # 正常的rmsnorm
        self.norm = RMSNorm(config.hidden_size, device=device)
        # Q K V三个矩阵，Q的head数是64，K和V的head数都是8，这里是head_dim * head_num
        qkv_dim = config.head_dim * (
            config.num_attention_heads + 2 * config.num_key_value_heads
        )
        # 同上，对应的Q K V三个矩阵
        self.qkv = torch.nn.Linear(
            config.hidden_size, qkv_dim, device=device, dtype=torch.bfloat16
        )
        # attn算完后，还是和query一样的64个head
        self.out = torch.nn.Linear(
            config.head_dim * config.num_attention_heads,
            config.hidden_size,
            device=device,
            dtype=torch.bfloat16,
        )
        # 1/sqrt(head_dim)
        self.sm_scale = 1 / math.sqrt(config.head_dim)
        # rope，包括了yarn外推的功能
        self.rope = RotaryEmbedding(
            config.head_dim,
            config.rope_theta,
            torch.float32,
            initial_context_length=config.initial_context_length,
            scaling_factor=config.rope_scaling_factor,
            ntk_alpha=config.rope_ntk_alpha,
            ntk_beta=config.rope_ntk_beta,
            device=device,
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # pre-norm
        t = self.norm(x)
        qkv = self.qkv(t)
        # 就是把q k v从qkv里按顺序截取出来
        # 其中contiguous是把tensor转为内存连续存储的形式
        q = qkv[:, : self.num_attention_heads * self.head_dim].contiguous()
        k = qkv[
            :,
            self.num_attention_heads
            * self.head_dim : (self.num_attention_heads + self.num_key_value_heads)
            * self.head_dim,
        ].contiguous()
        v = qkv[
            :,
            (self.num_attention_heads + self.num_key_value_heads)
            * self.head_dim : (self.num_attention_heads + 2 * self.num_key_value_heads)
            * self.head_dim,
        ].contiguous()
        # seq_len, 8, 64/8, head_dim
        q = q.view(
            -1,
            self.num_key_value_heads,
            self.num_attention_heads // self.num_key_value_heads,
            self.head_dim,
        )
        # seq_len, 8, head_dim
        k = k.view(-1, self.num_key_value_heads, self.head_dim)
        v = v.view(-1, self.num_key_value_heads, self.head_dim)
        # q k过rope，v不用，因为只是对算attn score时考虑位置信息
        q, k = self.rope(q, k)
        t = sdpa(q, k, v, self.sinks, self.sm_scale, self.sliding_window)
        # 最终映射到了hidden_size，即d
        t = self.out(t)
        # residual连接，因为是pre-norm，所以这里不用norm了
        t = x + t
    
def sdpa(Q, K, V, S, sm_scale, sliding_window=0):
    # sliding_window == 0 means no sliding window
    # q_mult就是GQA里的多少组，即64/8=8
    # seq_len, 8, 64/8, head_dim
    n_tokens, n_heads, q_mult, d_head = Q.shape 
    assert K.shape == (n_tokens, n_heads, d_head)
    assert V.shape == (n_tokens, n_heads, d_head)
    # 把每个head的向量复制q_mult份
    K = K[:, :, None, :].expand(-1, -1, q_mult, -1)
    V = V[:, :, None, :].expand(-1, -1, q_mult, -1)
    # S是64，拆成8 * 8，并复制seq_len份
    S = S.reshape(n_heads, q_mult, 1, 1).expand(-1, -1, n_tokens, -1)
    # 搞一个全-inf的矩阵，然后把上三角取出来，即下三角都是0，上三角都是-inf
    mask = torch.triu(Q.new_full((n_tokens, n_tokens), -float("inf")), diagonal=1)
    if sliding_window > 0:
        # 把sliding_window外(即只有[i-wind,i]是可见的)的也mask成-inf
        mask += torch.tril(
            mask.new_full((n_tokens, n_tokens), -float("inf")), diagonal=-sliding_window
        )
    # 输入：q和k都是seq_len, 8, 64/8, head_dim
    # 输出：8, 64/8, seq_len, seq_len，即把d（即head_dim）消掉了
    QK = torch.einsum("qhmd,khmd->hmqk", Q, K)
    QK *= sm_scale
    QK += mask[None, None, :, :]
    # 把sink拼进来，sink是[8, 64/8, seq_len, 1]
    QK = torch.cat([QK, S], dim=-1)
    # 算softmax的时候带上sink
    W = torch.softmax(QK, dim=-1)
    # 把sink扔掉
    W = W[..., :-1]
    # W是8, 64/8, seq_len, seq_len
    # V是seq_len, 8, 64/8, head_dim
    # 输出seq_len, 8, 64/8, head_dim
    attn = torch.einsum("hmqk,khmd->qhmd", W, V)
    # reshape成seq_len, 8*64/8*head_dim=4096
    return attn.reshape(n_tokens, -1)

MOE部分

# 这个是一个特殊的swiglu，多了clamp、最后+1
# 这里的1.702来自于[Gaussian Error Linear Units (GELUs)](https://arxiv.org/pdf/1606.08415)
def swiglu(x, alpha: float = 1.702, limit: float = 7.0):
    # 输入的x是[b,4,2d]，其实是当成2个
    # 最后一维的偶数下标当成gating
    # 最后一维的奇数下标元素当成linear
    # 在一个函数里实现了swiglu(gate, x)的操作
    x_glu, x_linear = x[..., ::2], x[..., 1::2]
    # Clamp the input values
    x_glu = x_glu.clamp(min=None, max=limit)
    x_linear = x_linear.clamp(min=-limit, max=limit)
    out_glu = x_glu * torch.sigmoid(alpha * x_glu)
    # Note we add an extra bias of 1 to the linear layer
    return out_glu * (x_linear + 1)

class MLPBlock(torch.nn.Module):
    def __init__(
        self,
        config: ModelConfig,
        device: torch.device | None = None,
    ):
        super().__init__()
        # 120b的模型是num_local_experts=128，这里是简化实现，估计也是128
        self.num_experts = config.num_experts
        # 120b的模型是experts_per_token=4
        self.experts_per_token = config.experts_per_token
        # 120b的模型是swiglu_limit=7.0
        self.swiglu_limit = config.swiglu_limit
        self.world_size = dist.get_world_size() if dist.is_initialized() else 1
        self.norm = RMSNorm(config.hidden_size, device=device)
        # d, expert数
        self.gate = torch.nn.Linear(
            config.hidden_size, config.num_experts, device=device, dtype=torch.bfloat16
        )
        assert config.intermediate_size % self.world_size == 0
        # expert数, 2d, d
        self.mlp1_weight = torch.nn.Parameter(
            torch.empty(
                (
                    config.num_experts,
                    config.intermediate_size * 2 // self.world_size,
                    config.hidden_size,
                ),
                device=device,
                dtype=torch.bfloat16,
            )
        )
        # expert数, 2d
        self.mlp1_bias = torch.nn.Parameter(
            torch.empty(
                (config.num_experts, config.intermediate_size * 2 // self.world_size),
                device=device,
                dtype=torch.bfloat16,
            )
        )
        # expert数, d, d
        self.mlp2_weight = torch.nn.Parameter(
            torch.empty(
                (
                    config.num_experts,
                    config.hidden_size,
                    config.intermediate_size // self.world_size,
                ),
                device=device,
                dtype=torch.bfloat16,
            )
        )
        # expert数, d, d
        self.mlp2_bias = torch.nn.Parameter(
            torch.empty(
                (config.num_experts, config.hidden_size),
                device=device,
                dtype=torch.bfloat16,
            )
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        t = self.norm(x)
        # 这里把attn输出的d映射到了expert数
        g = self.gate(t)
        # 取出最大的4个，以及对应下标
        experts = torch.topk(g, k=self.experts_per_token, dim=-1, sorted=True)
        expert_weights = torch.nn.functional.softmax(experts.values, dim=1)
        expert_indices = experts.indices

        # MLP #1
        # 在[expert数, 2d, d]里把这4个expert对应的拿出来，得到[4, 2d, d]
        mlp1_weight = self.mlp1_weight[expert_indices, ...]
        mlp1_bias = self.mlp1_bias[expert_indices, ...]
        # b, 4, 2d, d和b, d乘，得到b, 4, 2d
        t = torch.einsum("beck,bk->bec", mlp1_weight, t) + mlp1_bias
        t = swiglu(t, limit=self.swiglu_limit)

        # MLP #2
        mlp2_weight = self.mlp2_weight[expert_indices, ...]
        mlp2_bias = self.mlp2_bias[expert_indices, ...]
        # swiglu后正常再过一层mlp
        t = torch.einsum("beck,bek->bec", mlp2_weight, t)
        if self.world_size > 1:
            dist.all_reduce(t, op=dist.ReduceOp.SUM)
        t += mlp2_bias

        # Weighted sum of experts
        t = torch.einsum("bec,be->bc", t, expert_weights)

        return x + t

Gemmini&Gemma系列

Gemini 1.0

Gemini: a family of highly capable multimodal models

Gemini 1.5

谷歌Gemini 1.5深夜爆炸上线，史诗级多模态硬刚GPT-5！最强MoE首破100万极限上下文纪录

Gemini 1.5: Unlocking multimodal understanding across millions of tokens of context

• 更新的 Gemini 1.5 Pro，其大部分功能和基准都超过了 2 月份的版本

• Gemini 1.5 Flash，一种更轻量级的变体，专为提高效率而设计，并且在性能方面的减益很小。

此前的SOTA模型能处理**20万(200K)的token，Gemini 1.5能稳定处理100万(1M)的token（极限为1000万(10M)**的token），能够处理11小时的音频、1小时的视频、超过3w行的代码库、超过70w个单词

gemma

https://blog.google/technology/developers/gemma-open-models/

Gemma: Open Models Based on Gemini Research and Technology

代码：

https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma/modeling_gemma.py

codegemma

• 专门处理代码补全和代码生成任务的 7B 预训练变体

• 用于代码聊天和指令跟随的 7B 指令调优变体

• 在本地计算机上运行快速代码补全的 2B 预训练变体

CodeGemma: Open Code Models Based on Gemma

codegemma

RecurrentGemma

RecurrentGemma: Moving Past Transformers for Efficient Open Language Models

在infer阶段，需要检索KV cache，并加载到内存中，而KV cache会随着序列长度线性增长。Longformer: The Long-Document Transformer通过local attention来降低cache大小，但模型效果会变差。recurrent gemma将输入序列压缩到一个固定大小的state中，从而不会降低效果，对长序列能降低内存占用并高效infer。

基于Griffin架构，将门控线性递归与本地滑动窗口注意力混合在一起，在生成长序列时实现快速推理，相比gemma：

• 减少内存用量：内存要求越低，就越能在内存有限的设备（例如单个 GPU 或 CPU）上生成较长的样本。

• 吞吐量较高：能够以明显较高的batch_size执行推理，这意味着每秒可以生成更多tokens，尤其是在生成长序列时。

相比原始griffin：

• 对输入emb乘以一个常数（等于model width(下表中的2560)的平方根，如下代码所示）。输入和输出的emb是tied的，这个常数没有乘到output上去。gemma里也有一个类似的因子

• 对recurrent layers（RG-LRU）在训练时并没有进行weight decay(本质是L2正则化，参考https://zhuanlan.zhihu.com/p/607909453)，当bp到开方操作时，为了训练稳定会加最大值为1000的梯度clip

def __init__(self, ...):
    #...
    self.register_buffer(
        "normalizer", torch.tensor(self.config.hidden_size**0.5, 
            dtype=torch.bfloat16), persistent=False
    )
def forward(self, ...):
    #...
    if inputs_embeds is None:
        inputs_embeds = self.embed_tokens(input_ids)

    hidden_states = inputs_embeds

    if use_cache and inputs_embeds.shape[1] != 1:  
        # TODO let's maybe only call in the `generate`?
        self._setup_cache(self.config, hidden_states.shape[0], 
        hidden_states.device, hidden_states.dtype)

    if cache_position is None:
        cache_position = torch.arange(hidden_states.shape[1], 
        device=hidden_states.device)
    if position_ids is None:
        position_ids = cache_position.unsqueeze(0)

    causal_mask = self._update_causal_mask(attention_mask, 
        inputs_embeds, cache_position)

    ## 这里就是那个因子
    hidden_states = hidden_states * self.normalizer.type(hidden_states.dtype)

具体参数：

变量	大小
总参数量	2.7b
非emb参数量	2.0b
emb参数量	0.7b
vocab size	256k
model width	2560
rnn width	2560
MLP expansion factor	3，即intermediate_size=2560*3=7680
Depth	26
Attention heads	10
local attention window size	2048

训练：

https://github.com/huggingface/transformers/blob/main/src/transformers/models/recurrent_gemma/modeling_recurrent_gemma.py

在线推理的C++实现(cpu版本)

https://github.com/google/gemma.cpp

gemma-2

单张A100全精度推理！谷歌明星开源模型Gemma 2上新9B/27B，挑战3140亿Grok-1

谷歌「诚意之作」，开源9B、27B版Gemma2，主打高效、经济！

https://huggingface.co/collections/google/gemma-2-release-667d6600fd5220e7b967f315

https://blog.google/technology/developers/google-gemma-2/

Gemma 2: Improving Open Language Models at a Practical Size

用了RoPE和GeGLU，网络结构上：

• 局部滑动窗口和全局注意力：在每隔一层中交替使用局部滑动窗口注意力(Longformer: The long-document transformer)和全局注意力（Effective Approaches to Attention-based Neural Machine Translation），局部注意力层的滑动窗口大小设置为4096个token，而全局注意力层的跨度设置为8192个token。

• Logit软封顶：根据Gemini 1.5的方法，研究团队在每个注意力层和最终层限制logit，使得logit的值保持在$−soft\_cap,+soft\_cap$之间。对于9B和27B模型，注意力对数封顶设置为50.0，最终对数封顶设置为30.0。截至本文发表时，注意力logit软封顶与常见的FlashAttention实现不兼容，因此他们已从使用FlashAttention的库中移除了此功能。对模型生成进行了有无注意力logit软封顶的消融实验，发现大多数预训练和后期评估中，生成质量几乎不受影响。本文中的所有评估均使用包含注意力logit软封顶的完整模型架构。然而，某些下游性能可能仍会受到此移除的轻微影响。

$$\text { logits } \leftarrow \text { soft\_cap } * \text { tanh(logits } / \text { soft\_cap) }$$

• RMSNorm进行post-norm和pre-norm。为了稳定训练，用RMSNorm对每个变换子层、注意力层和前馈层的输入和输出进行归一化。

• gqa：27B和9B模型均使用GQA，num_groups = 2，基于消融实验表明在保持下游性能的同时提高了推理速度。

https://github.com/huggingface/transformers/blob/v4.42.3/src/transformers/models/gemma2/modeling_gemma2.py

Gemma Scope: Open Sparse Autoencoders Everywhere All At Once on Gemma 2

https://huggingface.co/google/gemma-scope

datagemma

整合海量公共数据，谷歌开源AI统计学专家DataGemma

Knowing When to Ask - Bridging Large Language Models and Data

提出了一种名为**检索交错生成（Retrieval Interleaved Generation，RIG）**的新方法，可以可靠地将Data Commons中的公共统计数据整合到LLM的响应中。RIG是一种受工具启发的方法，可以将统计数据标记与适合从Data Commons检索的自然语言问题交错。

为了获得这种能力，他们利用Gemini 1.5的帮助生成了一个指令-响应数据集，并在此基础上对LLM进行了微调。RIG方法将事实准确性从5-7%提高到了约58%。

gemini 2.0

OpenAI深夜被狙，谷歌Gemini 2.0掀翻牌桌！最强智能体组团击毙o1

谷歌“狙击”OpenAI，发布新一代大模型！主打Agent+多模态

我扒出了Gemini 2.0超实时多模态幕后的黑科技，第六代TPU芯片Trillium！

谷歌逆风翻盘暴击OpenAI，90天王者归来！44页报告押注25年三大技术前沿

data and ai trends report 2024

gemini 2.0 flash thinking

推理最强也最快，谷歌发布Gemini 2.0 Flash Thinking，全面超越o1-preview

https://ai.google.dev/gemini-api/docs/thinking-mode?hl=zh-cn

https://colab.research.google.com/github/google-gemini/cookbook/blob/main/gemini-2/thinking.ipynb

我自己复制的一个：https://colab.research.google.com/github/daiwk/llms_new/blob/main/gemini-2/thinking.ipynb

对应的github：https://github.com/daiwk/llms_new/blob/main/gemini-2/thinking.ipynb

gemini 2.5

DeepSeek逼出谷歌新推理模型：40分优势超GPT4.5登顶竞技场，支持原生多模态，但依然败给了“竹竿问题”

谷歌终于登顶一次了！最强推理模型Gemini 2.5 Pro实测体验，真的有点东西

谷歌首款混合推理Gemini 2.5登场，成本暴降600%！思考模式一开，直追o4-mini

Gemini 2.5 Pro的上下文窗口是1M tokens，并且支持原生多模态：可以理解庞大数据集并处理来自不同信息源的复杂问题，包括文本、音频、图像、视频，甚至是整个代码库。2.5 pro擅长创造视觉上引人注目的Web应用程序和智能体代码。

刚刚，Gemini 2.5 Pro升级，成编程模型新王

Gemini 2.5: Pushing the Frontier with Advanced Reasoning, Multimodality, Long Context, and Next Generation Agentic Capabilities.

模型架构是sparse moe，支持多模态输入，context可以达到1M+，flash是对pro的蒸馏，在多个8906卡TPUv5p集群上训练，引入一些容错和监控机制，缓解了SDC(silent data corruption)错误。别的细节没讲了…

gemma-3

Google 发布多模态开源模型 Gemma 3：性能与功能全面升级，附技术报告英中对照版

• 架构设计：Gemma 3基于decoder-only架构，与前两代Gemma模型类似。但在细节上有所创新，例如采用GQA和RMSNorm，还引入了QK-norm替代Gemma 2中的软封顶机制，以提升性能和稳定性。

• 训练策略：Gemma 3的训练过程包括预训练和指令微调两个阶段。在预训练阶段，模型使用知识蒸馏技术，从大规模数据中学习语言和视觉表示。训练数据涵盖了文本、图像以及多语言等多种类型，且经过严格的筛选和清洗，以减少有害内容和低质量数据的影响。在指令微调阶段，Gemma 3 采用了新颖的训练方法，重点关注数学、聊天、指令遵循和多语言等能力的提升。

一台3090就能跑Gemma 3 27B！谷歌发布Gemma 3全系QAT版模型

gemini-cli

谷歌杀疯！百万token神器免费开源，Claude和Codex都顶不住了？

https://github.com/google-gemini/gemini-cli

gemma-3n

谷歌开源Gemma 3n：2G内存就能跑，100亿参数内最强多模态模型

https://ai.google.dev/gemma/docs/gemma-3n

https://huggingface.co/collections/google/gemma-3n-685065323f5984ef315c93f4

https://developers.googleblog.com/zh-hans/introducing-gemma-3n-developer-guide/

进一步地，可以开发一个ios的app

• https://ai.google.dev/edge/mediapipe/solutions/genai/llm_inference/ios?hl=zh-cn

• https://github.com/google-ai-edge/mediapipe-samples/tree/main/examples/llm_inference/ios

安卓的：https://github.com/google-ai-edge/gallery

用JAX和ML Pathways训练的模型

• 多模态：原生支持图像、音频、视频和文本输入和文本输出，输入最多可以有32K的tokens

• 内存优化：

  • E2B：原始参数数量5B，运行内存占用2GB，与传统的2B相当

  • E4B：原始参数数量8B，运行内存占用3GB，与传统的4B相当

• 架构：

  • MatFormer架构：提升infer速度、减小infer模型大小

  • PLE(Per-Layer Embedding)：提高内存效率

  • KV Cache Sharing：加速首token生成时间(time-to-first-token)

  • USM：通用语音模型（USM）的高级音频编码器

  • MobileNet-v5：视觉编码器

• 质量提升：在多语言（支持140种文本语言和35种语言的多模态理解）、数学、编码和推理方面均实现了质量提升。

MatFormer

MatFormer: Nested Transformer for Elastic Inference

对FFN进行处理，原来中间的dim是$d_{ff}$，取其中一小段搞出一些更小的，即${d_{ff}/8, d_{ff}/4, d_{ff}/2, d_{ff}}$，针对每层都是这个dim的各有一个transformer，共4个transformer，

• 训练：每条样本从这4个trans里随机选一个去训练

• infer：通过mix'n'match的启发式策略搞出给infer用的子网络，即每一层的粒度尽量慢慢变大，不要忽大忽小，即从2变到3比从1直接到4要好

gemma-3n里的两种模型配置

• E4B：35层，7个block，每个block里5层(4层sliding attn+1层full attn)，每层是8xFFN（即2048*8=16384）

• E2B：30层，6个block，每个block里5层(4层sliding attn+1层full attn)，每层是4xFFN（即2048*4=8192）

用户可以自己通过通过这个代码来用mix'n'match搞一个自定义的模型，即模型里intermediate_size这个参数，为list的时候就是指定每层的dim，否则就是每层都用这个dim

PLE

PLE允许很大一部分参数（与每层相关的嵌入）在CPU上加载并高效计算，即只有核心Transformer权重（E2B约为2B，E4B约为4B）需要存储在通常较为受限的加速器内存 (VRAM) 中。 原文讲得比较模糊，可以参考https://www.reddit.com/r/LocalLLaMA/comments/1kuy45r/gemma_3n_architectural_innovations_speculation/，看config里的text_config里有laurel_rank可能和LAuReL: Learned Augmented Residual Layer有关

还有另一种Conditional parameter loading，可以skip掉一些参数的loading，并且是在运行时决定的。

KV Cache Sharing

优化了模型处理初始输入处理阶段（即prefill阶段）的方式，来自局部和全局注意力机制的中间层的k和v将直接与所有顶层共享，与Gemma3 4B相比，prefill性能显著提升了两倍，即模型能够比以往更快地提取和理解较长的prompt。

USM

Google USM: Scaling Automatic Speech Recognition Beyond 100 Languages

每160毫秒的音频生成一个token（约每秒6个token）：

• 自动语音识别 (ASR)：直接在设备上实现高质量的语音到文本的转录

• 自动语音翻译 (AST)：将口语翻译成另一种语言的文本。英语与西班牙语、法语、意大利语和葡萄牙语之间的翻译AST效果尤为出色，可以通过如下的cot提升翻译效果

<bos><start_of_turn>user
Transcribe the following speech segment in Spanish, 
then translate it into English: 
<start_of_audio><end_of_turn>
<start_of_turn>model

MobileNet-v5

MobileNet-v5支持

• 多种输入分辨率：原生支持256x256、512x512和768x768像素的分辨率。

• 广泛的视觉理解：在广泛的多模式数据集上进行联合训练，在各种图像和视频理解任务中表现出色。

• 高吞吐量：在Google Pixel上每秒处理高达60帧，实现实时设备视频分析和交互式体验。

其架构创新包括：

• MobileNetV4 -- Universal Models for the Mobile Ecosystem里的Universal Inverted Bottlenecks和Mobile MQA

• 显著扩大的架构：采用混合深度金字塔模型，比最大的MobileNet-V4变体大10倍。

• 一种新颖的多尺度(Multi-Scale)融合VLM适配器，可提高token的质量，从而提高准确性和效率。

蒸馏后的MobileNet-V5-300M比基线Gemma3里的SoViT（用SigLip训练，没蒸馏）效果更好。在Google Pixel Edge TPU上，在量化的情况下实现了13倍的加速（不使用量化的情况下为6.5倍），所需参数减少了46%，内存占用减少了4倍，同时在视觉语言任务上实现了显著更高的准确率。

要跑gemma3n需要pip3 install timm transformers==4.53.0

Gemini 3

Gemini 3深夜来袭：力压GPT 5.1，大模型谷歌时代来了

拆解Gemini 3：Scaling Law的极致执行与“全模态”的威力【101直播】

Gemini 3 Pro：

• 以1501 Elo的突破性高分登顶LMArena Leaderboard，在Humanity’s Last Exam（在不使用任何工具的情况下达到 37.5%）和GPQA Diamond（91.9%）上获得最高分，展示了博士级的推理能力。它还在数学方面为前沿模型树立了新标准，在MathArena Apex上达到了23.4%的最新SOTA水平。

• 在多模态上，在MMMU-Pro和Video-MMMU上分别斩获了81%和87.6%的高分，这意味着无论是解析复杂的科学图表还是理解动态视频流，它都游刃有余。

• 在SimpleQA Verified上取得了72.1%的成绩，显示出在事实准确性上的巨大进步

Gemini 3 Deep Think：

• 在Humanity's Last Exam（不使用工具的情况下得分41.0%）和 GPQA Diamond（得分93.8%）上的表现均优于Gemini 3 Pro

• 在ARC-AGI-2（代码执行，已通过ARC Prize验证）上也取得了前所未有的45.1%的得分，展现了其解决全新挑战的能力。

Grok

grok1

马斯克开源Grok-1：3140亿参数迄今最大，权重架构全开放，磁力下载

https://github.com/xai-org/grok-1

马斯克发布Grok 1.5！编码和数学能力大幅提升

• 上下文窗口提升16倍，达到128k

• 不使用通用的Python语言+Pytorch框架，采用分布式训练架构，使用Rust、JAX+Kubernetes构建。

• 提出了自定义训练协调器，可自动检测到有问题的节点，然后剔除。

• 优化了checkpointing、数据加载和训练重启等流程，最大限度地减少故障停机时间。

马斯克的首款多模态大模型来了，GPT-4V又被超越了一次

Grok-1.5V: https://x.ai/blog/grok-1.5v

grok-2：Grok-2来了，能生图识图、性能比肩GPT-4o，马斯克：发展猛如火箭

目前对Grok 3分析最为透彻的一篇文章

grok2.5

刚刚，马斯克开源Grok 2.5：中国公司才是xAI最大对手

https://huggingface.co/xai-org/grok-2

DeepSeek系列

DeepSeek-V2

一块钱100万token，超强MoE模型开源，性能直逼GPT-4-Turbo

https://github.com/deepseek-ai/DeepSeek-V2

DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model

从MHA到MLA看Attention优化：谈谈DeepSeek拼多多级的推理价格

缓存与效果的极限拉扯：从MHA、MQA、GQA到MLA

主要包括2部分：

MLA

输入第$t$个token $h_t$，分别经过一个$W^Q$、$W^K$和$W^V$得到$d$维的$q_t=W^Qh_t$、$k_t=W^Kh_t$和$v_t=W^Vh_t$，split成$n_h$份，每份的dim是$d_h=d/n_h$，每一份就是图里的一条竖线

• MHA(Multi-head Attention)：每个head各自算注意力，再拼接

• GQA(Grouped-Query Attention)：出自GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints，将所有Head分为$g$个组（g可以整除h），每组共享同一对K、V

• MQA(Multi-Query Attention)：出自Fast Transformer Decoding: One Write-Head is All You Need，让所有Attention Head共享同一个K、V

• MLA(Multi-head Latent Attention)：

  • 降维：输入的$h_t$先过一个$W^{DKV}\in R^{d_c\times d}$，得到$c_t^{KV}=W^{DKV}h_t$，其中$d_c\ll d$

  • 升维：$k^C_t=W^{UK}c_t^{KV}$，$v^C_t=W^{UV}c_t^{KV}$，其中$W^{UK}\in R^{d\times d_c}$，$W^{UV}\in R^{d\times d_c}$

  • 同时对q也降维，不过是降到$d'_c$，$c^Q_t=W^{DQ}h_t$，$q^C_t=W^{UQ}c_t^Q$，其中$c^Q_t\in R^{d'_c}$，$W^{UQ}\in R^{d_hn_h\times d'_c}$

  • 为了兼容RoPE，

    • $q^R_t=RoPE(W^{QR}c^Q_t)$，其中$W^{QR}\in R^{d^R_hn_h\times d'_c}$，再split成$n_h$份：$[q^R_{t,1};q^R_{t,2};...;q^R_{t,n_h}]$，每一份的dim是$d^R_h$

    • $k^R_t=RoPE(W^{KR}h_t)$

    • $q_{t,i}=[q^C_{t,i};q^R_{t,i}]$，$k_{t,i}=[k^C_{t,i};k^R_t]$，维度都是$d_h+d^R_h$，

    • 再拿这个q和k去算attn，$o_{t,i}=\sum ^t_{j=1}softmax_j(\frac{q^T_{t,i}k_{j,i}}{\sqrt {d_h+d^R_h}})v^C_{j,i}$

    • $u_t=W^O[o_{t,1};o_{t,2};...;o_{t,n_h}]$

attn	KV Cache per Token	Capability
MHA	$2n_hd_hl$	Strong
GQA	$2n_gd_hl$	Moderate
MQA	$2d_hl$	Weak
MLA	$(d_c + d_h^R)l \approx \tfrac{9}{2}d_hl$	Stronger

最终在计算时，需要cache的是图中的蓝色部分，所以是$(d_c + d_h^R)l$，在Deepseek-v2中，设置$d_c=4d_h, d^R_h=d_h/2$

DeepSeekMoE

DeepSeekMoE: Towards Ultimate Expert Specialization in Mixture-of-Experts Language Models

https://github.com/deepseek-ai/DeepSeek-MoE

FFN部分的MoE，相比传统的GShard 等MoE架构，DeepSeekMoE用了更细粒度的专家分配机制，并将部分专家设置为共享专家。

细粒度专家分配：假设有$N$个专家，即么对于原来的每个专家，把它的intremediate hidden dim分成$m$份，每一份的长度是原来的$\frac{1}{m}$，这样就有了$mN$个专家，原来选$K$个，现在就选$mK$个

$\mathbf{u}_t$表示FFN输入的第$t$个token，$N_s$是shared experts的数量，$N_r$是routed experts的数量，$K_r$表示被激活的router专家数量，$\mathbf{e}_i$表示第i个routed专家的centroid vector，即每个专家有一个向量

$$\begin{aligned} & \mathbf{h}_t^{\prime}=\mathbf{u}_t+\sum_{i=1}^{N_s} \operatorname{FFN}_i^{(s)}\left(\mathbf{u}_t\right)+\sum_{i=1}^{N_r} g_{i, t} \operatorname{FFN}_i^{(r)}\left(\mathbf{u}_t\right), \\ & g_{i, t}= \begin{cases}s_{i, t}, & s_{i, t} \in \operatorname{Topk}\left(\left\{s_{j, t} \mid 1 \leqslant j \leqslant N_r\right\}, K_r\right), \\ 0, & \text { otherwise },\end{cases} \\ & s_{i, t}=\operatorname{Softmax}_i\left(\mathbf{u}_t^T \mathbf{e}_i\right), \end{aligned}$$

score计算部分的代码实现：以v3为例，注意这里用的是sigmoid而非softmax，

class DeepseekV3TopkRouter(nn.Module):
    def __init__(self, config):
        #...
        # 这个就是e，shape是[out_features, in_features]
        self.weight = nn.Parameter(torch.empty((self.n_routed_experts, config.hidden_size)))
    def forward(self, hidden_states):
        hidden_states = hidden_states.view(-1, self.config.hidden_size)
        # 这里算的就是u和e的矩阵乘
        router_logits = F.linear(hidden_states.type(torch.float32), self.weight.type(torch.float32))
        scores = router_logits.sigmoid()

device-limited routing：保证每个token的目标专家分布在最多$M$个设备上

• 首先选择有最高相关性（即上面的$s_{i,t}$）的$M$个设备出来

• 再从这$M$个设备里选出top-K个专家出来

负载均衡的辅助loss：

• expert-level的负载均衡loss：$\alpha_1$是超参

$$\begin{aligned} \mathcal{L}_{\text {ExpBal }} & =\alpha_1 \sum_{i=1}^{N_r} f_i P_i, \\ f_i & =\frac{N_r}{K_r T} \sum_{t=1}^T \mathbb{1}(\text { Token } t \text { selects Expert } i), \\ P_i & =\frac{1}{T} \sum_{t=1}^T s_{i, t}, \end{aligned}$$

• device-level的负载均衡loss：把所有routed专家分成$D$组$\left\{\mathcal{E}_1, \mathcal{E}_2, \ldots, \mathcal{E}_D\right\}$，并把每一组放到一个单独的设备上：

$$\begin{aligned} \mathcal{L}_{\text {DevBal }} & =\alpha_2 \sum_{i=1}^D f_i^{\prime} P_i^{\prime} \\ f_i^{\prime} & =\frac{1}{\left|\mathcal{E}_i\right|} \sum_{j \in \mathcal{E}_i} f_j \\ P_i^{\prime} & =\sum_{j \in \mathcal{E}_i} P_j \end{aligned}$$

• 通信负载均衡loss：如果一个设备收到的token比较多，它的通信代价也比较大。因为要选$M$个设备出来，总共有$T$个词，所以，鼓励每个设备最多传输$MT$个隐层状态去其他设备，同时从其他设备接收到$MT$左右个的隐层状态。

$$\begin{aligned} \mathcal{L}_{\text {CommBal }} & =\alpha_3 \sum_{i=1}^D f_i^{\prime \prime} P_i^{\prime \prime} \\ f_i^{\prime \prime} & =\frac{D}{M T} \sum_{t=1}^T \mathbb{1}(\text { Token } t \text { is sent to Device } i) \\ P_i^{\prime \prime} & =\sum_{j \in \mathcal{E}_i} P_j \end{aligned}$$

DeepSeek-Prover-V1.5

DeepSeek开源数学大模型，高中、大学定理证明新SOTA

DeepSeek-Prover-V1.5: Harnessing Proof Assistant Feedback for Reinforcement Learning and Monte-Carlo Tree Search

https://github.com/deepseek-ai/DeepSeek-Prover-V1.5

Deepseek-v3

4篇DeepSeek神作论文速读，屠龙少年的名言：You play the game I play the rule.

DeepSeek-V3 正式发布

论文

下载了一个：https://github.com/daiwk/collections/blob/master/assets/DeepSeek_V3.pdf

DeepSeek-V3技术报告解读

Deepseek V3 预训练策略解读

MiniMax-01 与 DeepSeek-V3 对比

DeepSeek绕开CUDA垄断，V3论文细节再挖出！英伟达护城河不存在了？

直接写PTX（并行线程执行），PTX是专门为其GPU设计的中间指令集架构，位于高级GPU编程语言（如CUDA C/C++或其他语言前端）和低级机器代码（流处理汇编或SASS）之间。PTX是一种接近底层的指令集架构，将GPU呈现为数据并行计算设备，因此能够实现寄存器分配、线程/线程束级别调整等细粒度优化，这些是CUDA C/C++等语言无法实现的

首次披露！DeepSeek V3 发布软硬一体协同训练论文，公开「降成本」秘诀

刚刚，DeepSeek首曝V3降成本秘诀！软硬协同突破Scaling天花板

DeepSeek-V3再发论文，梁文锋署名，低成本训练大模型的秘密揭开了

Insights into DeepSeek-V3: Scaling Challenges and Reflections on Hardware for AI Architectures

NSA

刚刚！DeepSeek梁文锋亲自挂名，公开新注意力架构NSA

【手撕NSA】DeepSeek新作-原生稀疏注意力-超长文(附代码)

Native Sparse Attention: Hardware-Aligned and Natively Trainable Sparse Attention

FlashMLA

“源神”DeepSeek！突破H800性能上限，FlashMLA重磅开源，算力成本还能降

https://github.com/deepseek-ai/FlashMLA

DeepEP

DeepSeek开源第二弹，为MoE和EP量身定制的通信库！暂和英伟达显卡绑定

https://github.com/deepseek-ai/DeepEP

DeepGEMM

DeepSeek-R2曝5月前上线！第三弹DeepGEMM 300行代码暴击专家优化内核

https://github.com/deepseek-ai/DeepGEMM

DualPipe

DeepSeek一口气开源3个项目，还有梁文锋亲自参与，昨晚API大降价

https://github.com/deepseek-ai/DualPipe

EPLB

https://github.com/deepseek-ai/eplb

profile-data

https://github.com/deepseek-ai/profile-data

3fs

DeepSeek开源周最后一天：让数据处理「从自行车升级到高铁

https://github.com/deepseek-ai/3FS

在3fs上的数据处理框架：https://github.com/deepseek-ai/smallpond

推理系统

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

中文版：https://github.com/deepseek-ai/open-infra-index

对应英文版：https://github.com/deepseek-ai/open-infra-index/blob/main/202502OpenSourceWeek/day_6_one_more_thing_deepseekV3R1_inference_system_overview.md

优化目标：更大的吞吐，更低的延迟。 方案：大规模跨节点专家并行(Expert Parallelism, EP)

EP好处：

• 增加batchsize，提高gpu矩阵乘法效率，提升吞吐

• 专家分散在不同GPU，每个GPU只计算少量专家，访存更少，降低延迟

EP的复杂性：

• 引入了跨节点传输，需要设计合理计算流程使计算和传输可以同步进行

• 因为多节点，需要DP（数据并行），不同DP间要负载均衡

大规模跨节点专家并行

V3/R1的结构：从第4层开始是MOE，每层有1个共享专家和256个路由专家，每次激活8个路由专家，即8 in 256，稀疏度很高，因此需要用更大的overall batchsize，才能给每个专家提供足够的专家batchsize

• Prefill：

  • 路由专家EP32

  • MLA和共享专家DP32

  • 一个部署单元是4节点（32卡），每张卡包括：

    • 9个路由专家（共9*32=288个专家），其中：

      • 1个冗余专家，共1*32=32个

      • 8个路由专家，共8*32=256个

    • 1个共享专家，共1*32=32个

• Decode：

  • 路由专家EP144

  • MLA和共享专家DP144，

  • 一个部署单元是18节点(18*8=144卡)，每张卡包括：

    • 2个路由专家，共2*144=288

      • 总共32个冗余专家

      • 总共288-32=256个正常的路由专家

    • 1个共享专家，共1*144=144个

计算通信重叠

多机多卡的EP会引入较大的通信开销，可以用双batch重叠来掩盖通信开销，提升整体吞吐：

• prefill阶段：2个batch的计算和通信交错进行，一个batch计算时可以掩盖另一个batch的通信开销。即attn->dispatch->mlp->shared/combine这4步（这里是shared和combine并行）

• decode阶段：不同阶段的执行时间有差别， attention部分拆成了两个stage（图中的attn-0（attn前的一些proj操作等）和attn-1（核心的attn计算等）），共5个stage的流水线（attn0->attn1->dispatch/shared->mlp->combine）来实现计算和通信的重叠（这里是shared和dispatch并行）。

细节可以参考https://github.com/deepseek-ai/profile-data

尽可能地负载均衡

尽可能为每个GPU分配均衡的计算负载+通信负载

• prefill load balancer：

  • 问题：不同DP实例上的请求数、长度不同，导致core-attention的计算量、dispatch发送量不同

  • 目标：

    • 各GPU的计算量尽量相同==>core-attention计算负载均衡

    • 输入的token数量尽量相同==>dispatch发送量负载均衡，避免部分GPU处理时间过长

• decode load balancer：

  • 问题：不同DP实例上的请求数量、长度不同，导致core-attention计算量（与 KVCache 占用量相关）、dispatch发送量不同

  • 目标：

    • 各GPU的KVCache占用量尽量相同==>core-attention计算负载均衡

    • 请求数量尽量相同==>dispatch发送量负载均衡

• expert-parallel load balancer：

  • 问题：对于给定MoE模型，存在一些天然的高负载专家，导致不同GPU的专家计算负载不均衡

  • 目标：每个GPU上的专家计算量均衡==>最小化所有GPU的dispatch接收量(即MOE的输入)的最大值

架构图

prefill和decode拆了2个service，并且每个前面有负载均衡，内部有EP的负载均衡

线上效果

H800，精度和训练一致：

• 矩阵计算和dispatch传输用fp8

• core-attn计算和combine用bf16

白天用所有节点部署服务，晚上减少节点，峰值278节点（每个节点8卡H800，共278 * 8=2224卡，前面提到了prefill要32卡，decode要144卡，其实就是32x+14y=2224），平均占用226.75个节点，每张卡2美金1小时，那就是2 * 226.75 * 8 * 24 = 87072美金/天

• 输入总token数608B，有342B命中kvcache缓存，命中率56.3%

• 输出总token数168B，平均输出速度20~22tps(tokens per second)，这里指的应该是单请求的生成速度，平均每输出一个token的KVCache长度是4989。

• 平均每台H800(8卡)的吞吐量：

  • prefill任务：输入吞吐约 73.7k tokens/s（含缓存命中）。

    • 推测：每秒每8卡输入的token数是608000000000 / 226.75/86400=31k，好像对不太上这个73.7k，可能猜测：缓存那部分非常快，非缓存很慢，而这31k是假设全天流量不变的平均值

  • decode任务：输出吞吐约 14.8k tokens/s。

    • 推测：每秒每8卡输出的token数是168000000000 / 226.75 /86400=8575，前面提到了每个请求每秒的输出token数是20~22，那就相当于每8卡机器每秒能处理有8575/21=408个请求，所以总的返回qps大概是408 * 226.75=9.25k

DeepSeek-Prover-V2

DeepSeek开源Prover-V2强推理模型，网友：奥数从没这么简单过

专为Lean 4 打造的开源大语言模型，专注于形式化定理证明。

https://github.com/deepseek-ai/DeepSeek-Prover-V2/blob/main/DeepSeek_Prover_V2.pdf

下载了一份：pdf

两阶段训练，建立了两种互补的证明生成模式：

1. 高效非思维链（non-CoT）模式：针对快速生成正式的Lean证明代码进行优化，专注于生成简洁的证明，没有显式的中间推理步骤。

2. 高精度思维链（CoT）模式：系统地阐述中间推理步骤，强调透明度和逻辑进展，然后构建最终的正式证明。

与 DeepSeek-Prover-V1.5一致，这两种生成模式由两个不同的引导提示控制。

• 第一阶段采用专家迭代，在课程学习框架内训练一个非CoT证明模型，同时通过基于子目标的递归证明合成难题的证明。选择非CoT生成模式是为了加速迭代训练和数据收集过程。

• 在此基础上，第二阶段利用了冷启动链式思维（CoT）数据，通过将 DeepSeek-V3 复杂的数学推理模式与合成形式证明相结合而生成。CoT模式通过进一步的强化学习阶段得到增强，遵循了通常用于推理模型的标准训练流程。

DeepSeek-Prover-V2的非CoT模式训练过程遵循专家迭代的范式，这是开发形式化定理证明器广泛采用的框架。在每次训练迭代中，当前最佳证明策略用于生成那些在先前迭代中未解决的难题的证明尝试。这些成功的尝试经由Lean证明助手验证后，被纳入SFT数据集以训练改进的模型。

这一迭代循环不仅确保模型能够从初始演示数据集中学习，还能提炼出自己的成功推理轨迹，逐步提高其解决更难问题的能力。总体训练过程与 DeepSeek-Prover-V1 的训练过程大致一致，仅对训练问题的分布进行了两项修改：

• Prover-V2引入了来自自动形式化和各种开源数据集的额外问题，扩大了训练问题领域的覆盖范围。

• 新模型通过子目标分解生成的问题来扩充数据集，旨在解决MiniF2F基准测试有效划分中的更多挑战性实例。

在DeepSeek-V3-Base-671B上使用恒定的学习率5e-6，在16384个token的上下文中进行监督微调。训练语料库由两个互补来源组成：

• 通过专家迭代收集的非CoT数据，生成无需中间推理步骤的Lean代码；

• 冷启动CoT数据，将DeepSeek-V3的高级数学推理过程提炼为结构化的证明路径。非CoT组件强调精益定理证明器生态系统中的形式验证技能，而CoT示例明确地建模了将数学直觉转化为形式证明结构的认知过程。

Prover-V2采用GRPO，通过为每个定理提示采样一组候选证明并根据它们的相对奖励优化策略，消除了对单独critic模型的需求。训练使用二元奖励，每个生成的Lean证明如果被验证为正确则获得1个奖励，否则为0。为了确保有效学习，研究人员精心挑选训练提示，仅包括那些对监督微调模型具有足够挑战性但可解决的问题。模型在每次迭代中采样256个不同的问题，为每个定理生成32个候选证明，最大序列长度为32768个token。

模型蒸馏：

• 把DeepSeek-Prover-V1.5-Base-7B的最大上下文长度从4096个token扩展到了32768个，并使用DeepSeek-Prover-V2-671B强化学习阶段收集的rollout数据对这个扩展上下文模型进行微调。

• 除了CoT推理模式外，还整合了专家迭代过程中收集的非CoT证明数据，以实现一种成本效益高的证明选项，该选项能够生成简洁的形式化输出，并且模型规模较小。

• 7B模型也采用了与671B模型训练相同的强化学习阶段以提升性能。

DeepSeek-V3.2-exp

https://huggingface.co/deepseek-ai/DeepSeek-V3.2-Exp

刚刚，DeepSeek开源V3.2-Exp，公开新稀疏注意力机制DSA

https://github.com/deepseek-ai/DeepSeek-V3.2-Exp/blob/main/DeepSeek_V3_2.pdf

DeepSeek-OCR

太强了！DeepSeek刚刚开源新模型，用视觉方式压缩一切

DeepSeek-OCR: Contexts Optical Compression

https://github.com/deepseek-ai/DeepSeek-OCR/

一张包含文档文本的图像可以用比等效文本少得多的Token来表示丰富的信息，因此，初步探索了通过光学二维映射技术压缩长文本上下文可行性。

效果：当文本token数量在视觉token的10倍以内（即压缩率 <10x）时，模型的解码（OCR）精度可达97%；即使在压缩率达到20x的情况下，OCR准确率仍保持在约60%。在实际生产环境中，单张A100-40G GPU每天可生成超过20万页（200k+）的LLM/VLM训练数据。

• DeepEncoder：提取图像特征，并将视觉表示进行Token化和压缩，共380M参数

  • 80M的SAM-base：原始图像切成n个patch，单个patch大小为16x16，然后输入给SAM进行local attn

  • 2层的卷积模块：对视觉Token进行16倍的下采样，即得到n/16个token。参考Vary: Scaling up the vision vocabulary for large vision-language model，每个卷积层的核大小为3，步长为2，pad为1，通道数从256增加到1024。具体过程如下：

    • 假设输入一张1024x1024的图像

    • 输入给sam的是$1024\times 1024/16 \times 16 \times 16=64\times 64 \times (16\times 16)$，即$64\times 64$个patch

    • 从sam输出的应该是$64\times 64 \times 256$。

    • 经过第一个conv后，宽度变成$(64-2\times 1 - 3)/2 +1=32$，所以shape是(32,32,256)，所以shape是(16,16,1024)，即token数变成了$16\times 16=256$，相比原来的$64\times 64$而言就是缩小了16倍。

  • 300M的CLIP-large：进行global attn

• DeepSeek3B-MoE-A570M解码器：根据图像Token和prompt生成所需的结果，用来重建文本表示。570M in 3B的MoE，64个router专家激活6个，还有2个共享专家

训练：先训encoder，再训decoder

支持不同模式：

• Native resolution(infer函数里crop_mode=False)：

  • Tiny: 512×512 （64 vision tokens）

  • Small: 640×640 （100 vision tokens）

  • Base: 1024×1024 （256 vision tokens）

  • Large: 1280×1280 （400 vision tokens）

• Dynamic resolution(infer函数里crop_mode=True)：

  • Gundam: n×640×640 + 1×1024×1024

相关prompt：

1. document: <image>\n<|grounding|>Convert the document to markdown.
2. other image: <image>\n<|grounding|>OCR this image.
3. without layouts: <image>\nFree OCR.
4. figures in document: <image>\nParse the figure.
5. general: <image>\nDescribe this image in detail.
6. rec: <image>\nLocate <|ref|>xxxx<|/ref|> in the image.

Qwen系列

早期的Qwen

早期的：

Qwen1.5-110B：首个国产千亿参数开源大模型

4月26日，Qwen开源了其第一个千亿参数大模型Qwen1.5-110B，这应该也是国内第一个千亿规模的开源大模型。其包含1100亿参数，更重要的是这是一个Dense模型，而非MoE模型。从各项评测来看，Qwen1.5-110B足以与Llama3-70B相抗衡，部分指标也取得了更高的水平。

阿里云Qwen2.5发布！再登开源大模型王座，Qwen-Max性能逼近GPT-4o

所有 Qwen2.5 系列模型都在 18 万亿（18T）tokens 的数据上进行了预训练。在语言模型方面，Qwen2.5开源了7个尺寸：0.5B、1.5B、3B、7B、14B、32B、72B，每个都在同等参数赛道创造了业界最佳成绩。这些型号的设定充分考虑了下游场景的不同需求：

• 3B：适配手机等端侧设备的黄金尺寸；

• 32B：最受开发者期待的「性价比之王」，可在性能和功耗之间获得最佳平衡

• Qwen2.5-32B的整体表现甚至超越了Qwen2-72B。

阿里除夕发布Qwen2.5-Max反超DeepSeek V3，一句话开发小游戏

Qwen2.5-Max同DeepSeek V3一样是超大规模的MoE模型，

QwQ-max-preview

阿里旗舰推理模型硬刚DeepSeek！官宣独立APP，发布公告AI亲自写

https://chat.qwen.ai

QWQ-32B

https://qwenlm.github.io/blog/qwq-32b/

https://huggingface.co/Qwen/QwQ-32B

目前只有博客，写得挺简单的，看介绍是用了两阶段RL：

• 1阶段RL：在冷启ckpt上，只拿代码和数学语料，基于outcome-base reward，随着训练的进行，发现这两方面的能力都有持续提升

  • 数学：有一个accuracy verifier，检查最终解决方案是否正确

  • 代码：有一个代码执行server，检查代码是否通过预定义好的测试用例

• 2阶段RL：没说用什么语料，但用的是general reward model加上rule-based verifiers产生的reward，发现只要少量的step就能提升模型的通用能力，如指令遵循、人类偏好对齐、agent性能，而且代码和数学能力下降不明显

Qwen2.5-Omni

阿里深夜开源Qwen2.5-Omni，7B参数完成看、听、说、写

Qwen2.5-Omni Technical Report

https://github.com/QwenLM/Qwen2.5-Omni/tree/main

https://github.com/QwenLM/Qwen2.5-Omni

Qwen3

猛击OpenAI o1、DeepSeek-R1！刚刚，阿里Qwen3登顶全球开源模型王座，深夜爆火

Qwen3：思深，行速

Qwen3技术报告英中对照版.pdf

Qwen3 Technical Report

https://github.com/QwenLM/Qwen3

Qwen3技术报告首次全公开！“混合推理模型”是这样炼成的

开源了两个MoE模型的权重：

• Qwen3-235B-A22B：拥有2350多亿总参数和220多亿激活参数

• Qwen3-30B-A3B：拥有约300亿总参数和30亿激活参数

此外，还有6个Dense模型：Qwen3-32B、Qwen3-14B、Qwen3-8B、Qwen3-4B、Qwen3-1.7B和Qwen3-0.6B

网络结构

tokenizer用的是Qwen的，即BBPE（byte-level byte-pair encoding），词表大小是151,669

dense架构和Qwen2.5类似，

• 有GQA、SwiGLU、Rope和pre-normalization的RMSNorm等，

• 删掉了Qwen2中的QKV-bias

• 引入QK-Norm，保证训练稳定

MoE架构：

• 类似Qwen2.5-MoE，实现了DeepseekMoE的细粒度的专家切分

• 有128个专家，激活8个

• 不同于Qwen2.5-MoE，没有共享专家

• 使用global-batch load balancing loss来鼓励专家更专业化(specialization)，参考Demons in the detail: On implementing load balancing loss for training specialized mixture-of-expert models

注：其中的tie embedding指的是输入的emb和输出的emb共享

预训练

数据：

• 数据规模：Qwen2.5是在18万亿个token上进行预训练的，而Qwen3使用的数据量几乎是其两倍，达到了约36万亿(36T)个token，涵盖了119种语言和方言。

• 合成数据：

  • 先使用Qwen2.5-VL对大量类似PDF的文档进行文本识别。再利用Qwen2.5对识别出的文本进行优化以提升其质量。获得了额外的总量达数万亿tokens 的高质量文本。

  • 使用Qwen2.5、Qwen2.5-Math和Qwen2.5-Coder等模型合成了多种形式的文本token，包括教材、问答对、指令和代码片段等，覆盖数十个领域，总量达到数万亿tokens。

预训练过程分为三个阶段。

• general stage：各Qwen3的模型都在超过30T个token上进行了预训练，序列长度为4K token，为模型提供了基本的语言技能和通用知识。

• reasoning stage：通过增加如STEM(science/technology/engineering/mathematics)、编程和推理任务的数据比例来改进数据集，在这额外的5T个token上进行了预训练。

• long context stage：使用高质量的长上下文数据将序列长度扩展到32K token，确保模型能够有效地处理更长的输入。

  • 数据集里有75%的长度是16384到32768之间，剩下的25%是4096到16384之间

  • 通过ABF技巧(Effective long-context scaling of foundation models)，将RoPE的base频率从10000增加到1000000

  • 使用YARN（YaRN: Efficient context window extension of large language models）和DCA(Dual Chunk Attention, Training-free long-context scaling of large language models)，在推理阶段的序列长度capacity达到了4倍的增加

预训练效果：

• Qwen3 Dense基础模型的整体性能与参数更多的Qwen2.5基础模型相当：Qwen3-1.7B/4B/8B/14B/32B-Base分别与Qwen2.5-3B/7B/14B/32B/72B-Base表现相当。特别是在STEM、编码和推理等领域，Qwen3 Dense基础模型的表现甚至超过了更大规模的Qwen2.5模型。

• Qwen3 MoE基础模型在仅使用10%激活参数的情况下，达到了与Qwen2.5 Dense基础模型相似的性能，带来了训练和推理成本的显著节省。

后训练

四阶段：

stage1: Long-CoT cold start

使用多样的的长思维链数据对模型进行微调，涵盖了数学、代码、逻辑推理和STEM问题等多种任务和领域。每条样本都有验证过的reference答案或者是基于代码的测试用例。

• query filter：

  • 用Qwen2.5-72B-Instruct来判断并过滤那些不容易验证的query，例如一些包括多个子问题的query，或者通用的文本生成。

  • 过滤掉了Qwen2.5-72B-Instruct不需要CoT reasoning就能正确回答的那些query。确保只有那些需要更深reasoning的复杂问题才保留下来

  • 为每个query通过Qwen2.5-72B-Instruct标注了领域，确保数据集里每种领域的分布比较平衡。

• response filter：用QwQ-32B为每个query生成N个候选responses，当QwQ-32B一直没法生成正确解法时，人工介入来评估。对于pass@N为正的query，进一步地过滤掉如下几类回答：

  • 最终答案错误

  • 包含大量重复内容

  • 明显只是猜测、缺乏充分推理支撑

  • 思路过程与总结结论不一致

  • 存在语言混用或风格突变问题的

  • 疑似过于接近潜在的验证集内容

精挑细选出一小部分来训练，目标是在不过度追求中间推理准确性的前提下，先建立模型的基础推理模式。可以确保模型的潜力不会被早期训练限制住，从而为后续的RL阶段提供更大的优化空间和灵活性。为达成这一目标，建议在该准备阶段尽量减少训练样本数量和训练步数。

stage2: Reasoning RL

重点是大规模强化学习，利用基于规则的奖励来增强模型的探索和钻研能力。query-verifer的pair数据必须满足4个条件：

• 没在cold start阶段用过

• 对cold start模型来说是可学习的

• 尽可能有挑战性

• 包括了很多子领域

最终收集了3995个pair对，用GRPO训练。用大的batchsize，每个query有很多的rollouts，再加上off-policy的训练来提升采样效率，对训练都是有益的。同时，通过控制模型的entropy的稳定增加，以平衡探索和利用，对稳定训练非常重要。

stage3: Thinking Mode Fusion

在一份包括长思维链数据和常用的指令微调数据的组合数据上对模型进行微调，将非思考模式整合到思考模型中。确保了推理和快速响应能力的无缝结合。

• sft数据构造：

  • 思考数据：拿stage1的query，用stage2的模型通过拒绝采样产出，保证sft不会让stage2的模型变差

  • 非思考数据：涵盖了很多tasks，例如代码、数学、指令遵循、多语言任务、创意写作、问答、角色扮演。此外，还用自动生成的checklists来评估非思考数据的回答质量

  • 为了增加在小语种上的效果，特地增加了翻译任务的占比

• chat template设计：non-thinking模式里直接把<think>和</think>间置空。为了实现默认是thinking模式，当用户query没有/think时，也加了一些thinking模式的样本。对于多轮会话，在用户query里随机插入/think或者/no_think，让模型根据最后一个flag来产出回答。

• thinking预算：一旦模型学会了在non-thinking和thinking模式进行回复时，自发地产生了一种能力：能够基于不完整的thiking来产出结果。这也是实现thinking预算控制的基础。当thiking的长度达到一个用户定义的阈值后，会手动停止thking模式，并插入一个instrunction：Considering the limited time by the user, I have to give the solution based on the thinking directly now.\n</think>.\n\n，然后模型就会自己输出回答了。值得注意的是，这种能力并非通过显式训练获得，而是应用思考模式融合后自然涌现出的结果。

https://muellerzr.github.io/til/end_thinking.html

可以参考这个来直接改logit，大概意思是假设生成了k个token，设置了最多思考m个token，那</think>这个token的logit乘以$1+\frac{m}{k}$，如果超预算了，直接把这个token的概率改成0，并把其他所有token的概率改成-inf，相当于强制输出这个token。。

stage4: General RL

建立了一个复杂的奖励系统，覆盖超过20种不同的任务，每项任务都配有定制化的评分标准。提升如下几个能力：

• 指令遵循：模型准确地解释并遵循用户指令，包括内容、格式、长度、结构化输出等，与用户预期对齐

• 模版遵循：遵循特定的格式要求，例如thinking和non-thinking模式、用设计好的token（<think>和</think>）来区分thinking和回复

• 偏好对齐：对于开放性的问题，提升模型的helpfulness、engagement和style，提供更自然和令人满意的用户体验

• Agent能力：工具调用，在rl rollout期间，模型能够与真实环境进行完整的多轮交互，并且得到执行反馈，从而提升long-horizon决策任务上的性能和稳定性

• 特殊场景能力：例如RAG任务，设计reward，鼓励产生准确且符合上下文的答案，从而减小幻觉的风险

3种奖励机制：

• 基于规则的奖励：有助于产出高准确率的答案，缓解reward hacking

• 带参考答案的基于模型的奖励（Model-based Reward with Reference Answer）：对每个query给出一个参考答案，并用Qwen2.5-72B-Instruct基于这个参考答案对模型输出进行打分。相比规则reward更灵活，且能支持更多样的任务。

• 不带参考答案的基于模型的奖励：利用人类偏好数据，训练一个reward model，对模型回答输出一个scalar。能够适用于更多类型的query。

strong-to-weak蒸馏

包括5个密集模型（Qwen3-0.6B、1.7B、4B、8B和14B）以及一个MoE模型（Qwen3-30B-A3B），蒸馏过程主要分为两个阶段：

• Off-policy蒸馏(即teacher产出样本)：结合教师模型在 /think和/no_think两种模式下生成的输出，用于对学生模型进行回应蒸馏。有助于轻量级学生模型掌握基本的推理能力，并学会在不同思考模式之间切换。

• On-policy蒸馏（即student产出样本）：学生模型基于当前策略生成回应序列用于微调。对提示词进行采样，学生模型以 /think 或 /no_think 模式生成回应。随后，通过将其输出logits与教师模型（Qwen3-32B或Qwen3-235B-A22B）对齐，最小化两者之间的KL散度，从而对学生模型进行微调。

使用

vllm：

vllm serve Qwen/Qwen3-30B-A3B --enable-reasoning --reasoning-parser deepseek_r1
# 要禁用思考模式，可以移除--reasoning-parser以及--enable-reasoning

软切换机制，可以在enable_thinking=True时动态控制模型的行为，即在用户prompt或系统prompt中添加/think和/no_think来逐轮切换模型的思考模式。

from transformers import AutoModelForCausalLM, AutoTokenizer

classQwenChatbot:
    def __init__(self, model_name="Qwen3-30B-A3B/Qwen3-30B-A3B"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForCausalLM.from_pretrained(model_name)
        self.history = []

    def generate_response(self, user_input):
        messages = self.history + [{"role": "user", "content": user_input}]

        text = self.tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True
        )

        inputs = self.tokenizer(text, return_tensors="pt")
        response_ids = self.model.generate\
          (**inputs, max_new_tokens=32768)[0][len(inputs.input_ids[0]):].tolist()
        response = self.tokenizer.decode(response_ids, skip_special_tokens=True)

        # Update history
        self.history.append({"role": "user", "content": user_input})
        self.history.append({"role": "assistant", "content": response})

        return response

# Example Usage
if __name__ == "__main__":
    chatbot = QwenChatbot()

    # First input (without /think or /no_think tags, 
    # thinking mode is enabled by default)
    user_input_1 = "How many r's in strawberries?"
    print(f"User: {user_input_1}")
    response_1 = chatbot.generate_response(user_input_1)
    print(f"Bot: {response_1}")
    print("----------------------")

    # Second input with /no_think
    user_input_2 = "Then, how many r's in blueberries? /no_think"
    print(f"User: {user_input_2}")
    response_2 = chatbot.generate_response(user_input_2)
    print(f"Bot: {response_2}") 
    print("----------------------")

    # Third input with /think
    user_input_3 = "Really? /think"
    print(f"User: {user_input_3}")
    response_3 = chatbot.generate_response(user_input_3)
    print(f"Bot: {response_3}")

MCP：可以使用MCP配置文件，使用Qwen-Agent内置的工具，或者自行集成其他工具。

from qwen_agent.agents import Assistant

# Define LLM
llm_cfg = {
    'model': 'Qwen3-30B-A3B',
    # Use the endpoint provided by Alibaba Model Studio:
    # 'model_type': 'qwen_dashscope',
    # 'api_key': os.getenv('DASHSCOPE_API_KEY'),
    # Use a custom endpoint compatible with OpenAI API:
    'model_server': 'http://localhost:8000/v1',  # api_base
    'api_key': 'EMPTY',
    # Other parameters:
    # 'generate_cfg': {
    #         # Add: When the response content is `<think>this is the thought</think>this is the answer;
    #         # Do not add: When the response has been separated by reasoning_content and content.
    #         'thought_in_content': True,
    #     },
}

# Define Tools
tools = [
    {'mcpServers': {  # You can specify the MCP configuration file
            'time': {
                'command': 'uvx',
                'args': ['mcp-server-time', '--local-timezone=Asia/Shanghai']
            },
            "fetch": {
                "command": "uvx",
                "args": ["mcp-server-fetch"]
            }
        }
    },
  'code_interpreter',  # Built-in tools
]

# Define Agent
bot = Assistant(llm=llm_cfg, function_list=tools)

# Streaming generation
messages = [{'role': 'user', 'content': 
  'https://qwenlm.github.io/blog/ Introduce the latest developments of Qwen'}]
for responses in bot.run(messages=messages):
    pass
print(responses)

ParScale

ParScale：一种全新的大模型Scaling Law

Parallel Scaling Law for Language Models

https://github.com/QwenLM/ParScale

WorldPM

建模世界偏好：偏好建模中的Scaling Laws

WorldPM: Scaling Human Preference Modeling

https://huggingface.co/Qwen/WorldPM-72B

QwenLong-L1

强化学习解决长上下文推理问题：通义推出QwenLong-L1-32B

https://github.com/Tongyi-Zhiwen/QwenLong-L1

https://huggingface.co/Tongyi-Zhiwen/QwenLong-L1-32B

QwenLong-L1: Towards Long-Context Large Reasoning Models with Reinforcement Learning

长上下文推理强化学习范式中的两个核心挑战：

• 次优的训练效率：

  • 奖励收敛较慢

  • 模型输出熵的显著降低，限制了优化过程中的探索行为。

• 不稳定的优化过程

  • KL散度突刺较多

  • 这是由于较长的输出长度和不均匀的输入长度导致方差变大，导致策略更新不稳定。

QwenLong-L1：

• 渐进式上下文扩展：

  • 监督微调预热（Warm-Up Supervised Fine-Tuning）：使用蒸馏的长上下文推理数据来sft模型，获取稳定的初始策略，降低训练过程中的不稳定。

  • 课程引导的分阶段强化学习（Curriculum-Guided Phased Reinforcement Learning）：将强化学习训练分为两阶段，每阶段仅训练当前长度区间的样本，避免混合长度导致的优化冲突。

    • 阶段1：输入长度20K

    • 阶段2：扩展至60K，逐步适应长上下文。

  • 难度感知的回顾采样（Difficulty-Aware Retrospective Sampling）：根据样本平均奖励动态计算难度，低奖励样本（高难度）被优先保留至后续阶段。阶段2训练时，包含阶段1的高难度样本，强制模型持续探索复杂case。

• 混合奖励机制：

  • 规则奖励：与标准答案严格匹配，确保答案格式正确性，防止Reward Hacking。

  • 模型评判：用Qwen2.5-1.5B-Instruct作为轻量级评判模型，评估预测答案和标准答案之间语义等价性。

  • 组合策略：取规则与模型评判的最大值，兼顾精确性与答案多样性。

token entropy

Beyond the 80/20 Rule: High-Entropy Minority Tokens Drive Effective Reinforcement Learning for LLM Reasoning

推理能力的提升仅由高熵词贡献

Qwen-VLo

Qwen VLo：从“看懂”世界到“描绘”世界

• 更精准的内容理解与再创造：以往的多模态模型在生成过程中容易出现语义不一致的问题，例如将汽车误生成其他类型的物体，或者无法保留原图的关键结构特征。而Qwen VLo通过更强大的细节捕捉能力，能够在生成过程中保持高度的语义一致性。例如，当用户输入一张汽车的照片并要求“更换颜色”时，Qwen VLo不仅能准确识别车型，还能保留其原有的结构特征，同时完成色彩风格的自然转换。

• 支持开放指令编辑修改生成：用户可以通过自然语言提出各种创意性指令，如“将这张画风改为梵高风格”、“让这张照片看起来像19世纪的老照片”或“给这张图片添加一个晴朗的天空”。Qwen VLo能够灵活响应这些开放性指令，并生成符合用户预期的结果。无论是艺术风格迁移、场景重构还是细节修饰，模型都能轻松应对。甚至一些传统的视觉感知人物如预测深度图、分割图、检测图以及边缘信息等也可以通过编辑指令轻松完成。更进一步，像很多更复杂的指令，比如一条指令中同时包含修改物体、修改文字、更换背景，模型也能轻松完成。

• 多语言指令支持：Qwen VLo支持包括中文、英文在内的多种语言指令。

训练：

• 采用动态分辨率训练，支持动态分辨率生成。无论是输入端还是输出端，模型都支持任意分辨率和长宽比的图像生成。这意味着用户不再受限于固定的格式，可以根据实际需求生成适配不同场景的图像内容，无论是海报、插图、网页Banner还是社交媒体封面，都能轻松应对。

• 创新性地引入了一种全新的生成机制：从上到下、从左到右逐步清晰的生成过程。这一机制不仅提升了生成效率，还特别适用于需要精细控制的长段落文字生成任务。例如，在生成带有大量文本的广告设计或漫画分镜时，Qwen VLo逐步生成慢慢修改。这种渐进式的生成方式让用户可以实时观察生成过程，并根据需要进行调整，从而获得最佳的创作效果。

Qwen-Image

告别文字乱码！全新文生图模型Qwen-Image来咯

https://github.com/QwenLM/Qwen-Image，集成在diffusers里了

Qwen-Image Technical Report

• x1：文本经过Qwen2.5 VL得到的输出

• x2：图片经过VAE-encoder(用Wan-2.1-VAE)得到emb，和noise以及扩散时的timestep t一起经过patchify后得到的输出

• x3：timestep t直接过mlp得到的输出

• x3作为gate，x1和x2双流输入一个MM-DiT，中间过程可以理解为x1和x2分别得到qkv，对应地拼在一起，过一个self-attn，再和x3乘一下，和原来的x1或者x2相加，得到新的x1和x2

MM-Dit结构来自Stable Diffusion 3，即Scaling Rectified Flow Transformers for High-Resolution Image Synthesis，如下，c对应上面的x1，x对应上面的x2，y对应上面的x3

MSRoPE如图所示，即图像的位置编码完后，沿对角线把文本的加进去

关于汉字的渲染方面，没有像Seedream 2.0一样专门搞一个Glyph-ByT5的encoder，而是通过数据集构造来完成这一点

Qwen3-Next

Qwen3-Next：迈向更极致的训练推理性价比

• Qwen3-Next-80B-A3B-Base：实现了与Qwen3-32B dense模型相近甚至略好的性能，训练成本仅为Qwen3-32B的十分之一不到，在32k以上的上下文下的推理吞吐则是Qwen3-32B的十倍以上

• Qwen3-Next-80B-A3B-Instruct：与旗舰模型 Qwen3-235B-A22B-Instruct-2507表现相当，在256K超长上下文处理任务中展现出显著优势。

• Qwen3-Next-80B-A3B-Thinking：优于预训练成本更高的Qwen3-30B-A3B-Thinking-2507与Qwen3-32B-Thinking，且在多项基准测试中超越闭源模型Gemini-2.5-Flash-Thinking，部分关键指标已逼近Qwen3-235B-A22B-Thinking-2507

• 混合架构：

  • Gated DeltaNet(Gated Delta Networks: Improving Mamba2 with Delta Rule)比滑动窗口注意力（Sliding Window Attention）和Mamba2有更强的in-context learning能力。QK：16个head，V有32个head

  • 在3:1的混合比例（75%层使用Gated DeltaNet，25%层保留标准注意力）下，能超过超越单一架构，实现性能与效率的双重优化

  • 标准注意力中：

    • 沿用Qwen先前工作（Gated Attention for Large Language Models: Non-linearity, Sparsity, and Attention-Sink-Free）中的输出门控机制，缓解注意力中的低秩问题。

    • 单个注意力头维度从128扩展至256

    • 仅对注意力头前25%的位置(前64维)维度添加RoPE，提高长度外推效果

    • Q：16个head，KV有2个head

• 极致稀疏MoE：仅激活3.7%参数

  • 512总专家，10路由(即激活)专家+1个共享专家，expert intermediat dim=512；而Qwen3-MoE是128个总专家和8个路由专家

  • 全局负载均衡(Demons in the Detail: On Implementing Load Balancing Loss for Training Specialized Mixture-of-Expert Models)：当激活专家固定时，持续增加专家总参数可以带来稳定的loss下降

• 训练稳定性：

  • QK-Norm：Zero-Centered RMSNorm(Gemma: Open Models Based on Gemini Research and Technology)，并在此基础上, 对norm weight施加weight decay, 以避免权重无界增长。

  • 初始化时归一化了MoE router的参数(Approximating Two-Layer Feedforward Networks for Efficient Transformers)，确保每个expert在训练早期都能被无偏地选中，减小初始化对实验结果的扰动。

• MTP：

  • 引入原生 Multi-Token Prediction机制(Better& faster large language models via multi-token prediction)，既得到了Speculative Decoding接受率较高的MTP模块，又提升了主干本身的综合性能。

  • 优化了MTP多步推理性能，通过训练推理一致的多步训练，进一步提高了实用场景下的Speculative Decoding接受率。

其中：https://github.com/NVlabs/GatedDeltaNet

Qwen3-Omni

又是深夜炸弹，Qwen3-Omni 和 Qwen3-TTS 同时发布！我是劳模…

https://github.com/QwenLM/Qwen3-Omni

https://huggingface.co/collections/Qwen/qwen3-omni-68d100a86cd0906843ceccbe

https://github.com/QwenLM/Qwen3-Omni/blob/main/assets/Qwen3_Omni.pdf

• Thinker：输入文本、图像和音频，生成文本

• Talker用于生成streaming speech tokens，输入是Thinker里图像和音频的高层语义表征，还有原始文本，这里不像Qwen2.5-Omni一样用Thinker的文本表征，可以更方便地给Talker嵌入其他外部模块（RAG/函数调用/安全过滤）方便人工干预，还可以为Thinker和Talker设置不同的prompt，例如分别控制Thinkier的风格和Talker的风格

• 为了极致地降低延时，自回归地预测多码本序列：在每一步解码中，MTP模块输出当前帧的残差码本，随后Code2Wav（轻量级的ConvNet）增量地合成对应波形，实现逐帧流式生成。

• 音频编码器：训了一个AuT(audio transformer)，attention-based encoder-decoder，基于2000万小时的音频数据(80%的中英文ASR数据，10%的其他语言ASR数据，10%的语音理解数据)训练。在attention layer之前，用Conv2D对filter bank特征进行8倍的下采样，将token rate降低到12.5Hz。用带了动态窗口的flash attention，来平衡实时的prefill caching效率和离线语音任务的效果。拿AuT的encoder来作为音频编码器，大概0.6B

• 文本处理：用Qwen的tokenizer，词表大小151k

• 视觉编码器：Qwen3-VL，543M参数，用SigLIP2-So400m初始化，在图片和视频的语料上训练

• 位置编码：TM-RoPE（Time-aligned Multimodal RoPE），在Multimodal RoPE的基础上引入了时间信息

• 预训练：早期的预训练就混合了单模态和多模态的语料，并且设置了很多不同的prompt

  • Encoder Alignment Stage（S1）：LLM部分用Qwen3初始化，vision encoder用Qwen3-VL初始化，audio encoder用AuT初始化。之前的Qwen2.5-omni和Qwen2.5-VL是会fixed LLM，然后用图+文的数据去训练，同时在各encoder基础上有adapter去做模态对齐。这里把这个干掉了，而是这两个encoder只用单独自己模态的数据去训。

  • General Stage (S2)：在大约2T tokens的数据集（0.57T文本、0.77T语音、0.82T图像、0.05T视频、0.05T视频-语音）上训练

  • Long Context Stage (S3)：将最大的token length从8192扩展到32768，并把长语音和长视频的数据比例变大。

• 后训练：

  • Thinker：有文本对话数据、图文对话数据、语音对话数据、混合模态对话数据，处理成ChatML格式

    • 轻量SFT：用不会偏离预训练分布太远的指令遵循的数据集来训

    • strong-to-weak蒸馏：teacher是Qwen3-32B或者Qwen3-235B-A22B，和Qwen3一样，先off-policy蒸馏（用teacher模型产出结果，做response蒸馏），再on-policy蒸馏（用student产出结果，并用于finetune，最小化student的logit和teacher的KL散度）

    • GSPO：用了两种reward：rule-based和model-based（LLM-as-a-judge，对于通用任务用Qwen3，视觉相关的任务用Qwen2.5-VL）

  • Talker：

    • 用数亿的带有多模态上下文的语音数据训练，建立一个从多模态表示到语音的单调映射

    • 用高质量数据进行CPT，减少幻觉并且提升生成语音的质量；同时加了long context训练，让模型能处理复杂输入并生成符合上下文的语音输出

    • 基于多语言语音数据构建偏好pair对，并用DPO来训练，提升多语言语音的生成能力

    • speaker finetuning，让模型能够采用特定的声音（应该是类似变声器那种）

  • Captioner：开源了Qwen3-Omni-30B-A3B-Captioner，对Qwen3-Omni-30B-A3B基于对大量detailed audio descriptions数据训练的模型，能够对任意语音输入产出详细的、低幻觉的caption。

(提了个issue问MTP的具体实现逻辑：https://github.com/QwenLM/Qwen3-Omni/discussions/15)

Kimi系列

MOBA

撞车DeepSeek NSA，Kimi杨植麟署名的新注意力架构MoBA发布，代码也公开

MoBA: Mixture of Block Attention for Long-Context LLMs

https://github.com/MoonshotAI/MoBA

Kimi-VL

月之暗面开源轻量级MoE多模态模型，支持推理，效果超过GPT-4o！

Kimi-VL technical report

https://huggingface.co/collections/moonshotai/kimi-vl-a3b-67f67b6ac91d3b03d382dd85

Kimi 16B胜GPT-4o！开源视觉推理模型：MoE架构，推理时仅激活2.8B

K2

Kimi K2 发布并开源，擅长代码与 Agentic 任务

https://bigeagle.me/2025/07/kimi-k2/

Kimi K2官方技术报告出炉：采用384个专家，训练不靠刷题靠“用自己的话再讲一遍”

https://github.com/MoonshotAI/Kimi-K2/blob/main/tech_report.pdf

参考：https://aider.chat/，https://github.com/CharlesQ9/Alita

稳定的复杂指令解析能力，将需求自动拆解为一系列格式规范、可直接执行的ToolCall结构。

模型结构

https://huggingface.co/moonshotai/Kimi-K2-Instruct

项目	值
总参数量	1T
激活参数量	32B
层数	61
Dense层数	1
Attention Hidden Dimension	7168
MoE Hidden Dimension (每个 Expert)	2048
Attention Head数	64
专家数	384
每个token选择的专家数	8
共享专家数	1
Vocabulary Size	160K
Context Length	128K
Attention	MLA
激活函数	SwiGLU

MuonClip优化器

月之暗面开源改进版Muon优化器，算力需求比AdamW锐减48%，DeepSeek也适用

原始muon：https://github.com/KellerJordan/Muon

Muon is Scalable for LLM Training

https://github.com/MoonshotAI/Moonlight

K2的架构和deepseek-v3类似，为了更好地scale up：

• 减小了head数以提升长上下文的效率

• 增加MoE的稀疏度以提升token效率

但scale up的挑战就是attention logit的爆炸带来的训练不稳定，现有的例如logit的soft capping和q-k norm还不够。因此，对Muon优化器引入了qk-clip，即在Muon更新之后，对q和k的映射矩阵直接rescale，从而在源头上控制attention logits的scale，

$$\begin{gathered} q_i=\eta^\alpha W_q x_i \\ k_i=\eta^{1-\alpha} W_k x_i \end{gathered}$$

其中$\alpha$是一个超参，对应的attention logit就变成了：

$$\left(\eta^\alpha q_i\right)^{\top}\left(\eta^{1-\alpha} k_j\right)=\eta q_i^{\top} k_j$$

而$\eta$是每个step后，根据这个step里的最大attention logit来设置的，$t$是一个提前设置好的阈值

$$\eta=\min \left(\frac{t}{\max _{i, j}\left(q_i^{\top} k_j\right)}, 1\right)$$

这种方法使得K2没有logit爆炸，且能保持下游任务的性能，在15.5T的tokens上稳定训练，没有loss spike

详见苏剑林的博客：QK-Clip：让Muon在Scaleup之路上更进一步

Agentic能力：大规模Agentic Tool Use数据合成

参考ACEBench，开发了一个pipeline，可以大规模模拟真实世界的工具使用场景。覆盖数百领域、数千工具（包括MCP）。所有任务都基于评分标准（rubric），agent和user agent还有环境（工具模拟器）进行交互，通过llm进行judge，最终筛选出一个高质量的数据集。

Agentic能力：通用强化学习

可验证任务的如数学和编程竞赛，而撰写研究报告则是不可验证的任务。这个通用强化学习系统还采用自我判断(self-judging)机制，让模型充当自身的critic，为不可验证任务提供可扩展的、基于评分标准(rubric)的反馈。

同时，使用可验证奖励的on-policy rollout来持续更新critic，使critic不断提高其在最新policy上的评估准确性。可以看成是一种利用可验证奖励来改进不可验证奖励估计的方法。

Kimi-Linear

Kimi Linear: An Expressive, Efficient Attention Architecture

• Kimi Delta Attention (KDA)：用finegrained gating优化了gated delta rule

• 混合架构：3:1的KDA-to-global MLA比例，减小内存占用并提升相比full attention的效果

• 效果：在很多task上比full attention更好，包括long-context和RL-style benchmarks

• 高吞吐: 最多6x的decoding加速，显著降低TPOT(time per output token).

和qwen3-next的整体对比，fullattn一个用的是gated softmax attn，一个用的是mla，moe部分类似，主要区别在linear部分

把GDN里更新状态的那个方程里的alpha换成了如下的一个对角矩阵

alpha/beta/gate的nn改成了lora结构，alpha和beta也加了swish

K2 Thinking

Kimi K2 Thinking突袭！智能体&推理能力超GPT-5，网友：再次缩小开源闭源差距

https://huggingface.co/moonshotai/Kimi-K2-Thinking

MiniMax

MiniMax-01

MiniMax开源4M超长上下文新模型！性能比肩DeepSeek-v3、GPT-4o

MiniMax押注线性注意力，让百万级长文本只用1/2700算力｜对话MiniMax-01架构负责人钟怡然

MiniMax-01: Scaling Foundation Models with Lightning Attention

m层lightning attention后再接1层softmax attention，参数456B，每次推理激活45.9B。

MiniMax-M1

性能比肩DeepSeek-R1，MiniMax仅花380万训出推理大模型性价比新王｜开源

https://github.com/MiniMax-AI/MiniMax-M1

MiniMax-M1: Scaling Test-Time ComputeEfficiently with Lightning Attention

结构

每7个Lightning Attention的Transnormer块后接1个传统Softmax Attention的Transformer块。这种设计理论上可以让推理长度高效扩展到数十万个token。

CISPO

强化学习Clipped IS-weight Policy Optimization

MiniMax-M2

MiniMax M2 & Agent，大巧若拙

全注意力、复杂推理不掉速：MiniMax M2把Agent做成了「可执行能力」

看着是采用全full attn了，swa和lightning attention都没有了

百度

ERNIE 3.0

ERNIE 3.0: Large-scale Knowledge Enhanced Pre-training for Language Understanding and Generation结合自回归网络和autoencoding网络，让模型能够同时做语言理解和语言生成任务，可以支持zero-shot、few-shot和finetuning。有10B参数，在4TB的文本和图谱数据上训练。

ernie3.0

ERNIE4.5

提前免费！百度连发两款模型，我们实测：能听歌看电影，还会蛐蛐人

推理模型文心X1：

• 应用了递进式强化学习训练方法

• 具备 “长思维链”，采用了思维链和行动链耦合的端到端训练方式，不是只学习思考或者只学习行动，而是把思考和行动结合起来

• 采用了多元统一的奖励系统

文心4.5：

• FlashMask 动态注意力掩码：FlashMask: Efficient and Rich Mask Extension of FlashAttention，通过列式稀疏掩码表示方法，将传统的二维稠密掩码矩阵转换为一维的行索引区间表示，从而显著降低了存储复杂度，从$O(N^2)$降低到$O(N)$。极致的加速了大模型训练效率，尤其是长序列场景下的训练效率。

• 多模态异构专家扩展技术：结合多模态数据处理与混合专家模型（MoE）的创新架构，旨在通过针对不同模态特点构建的异构专家模块，解决多模态融合中的梯度不均衡问题，提升模型的多模态融合能力。多模态异构专家扩展技术在多个应用场景中展现了显著优势，例如多模态问答任务，这种技术能够更高效地处理复杂的多模态数据。

• 时空维度表征压缩技术：把图片和视频里的关键信息进行浓缩的方法。在不丢失重要细节的情况下，在时空维度对图片和视频的语义表征进行高效压缩，让这些数据变得更小、更高效。这样一来，训练多模态模型（也就是同时处理文字、图片、视频等多种数据的模型）时就能更快、更省资源。

• 基于知识点的大规模数据构建技术：知识分级采样优先把重要的、核心的知识挑出来，接着把挑出来的知识点进行压缩，去掉多余的部分，把相关的知识融合在一起。对于那些比较少见、不太好找的知识点，专门合成一些相关内容，确保这些重要的小众知识也不会被遗漏。这样一来，模型幻觉大大降低。

• 基于自反馈的Post-training技术：通过多种评估方式不断优化模型的后训练方法。简单来说，它让模型在训练过程中不断反思自己的表现，根据不同的评价标准调整自己，从而让模型变得更稳定、更可靠。这种技术还能显著提升预训练模型理解人类意图的能力，让模型的回答更符合人类的期望。

文心4.5系列模型，正式开源！

https://huggingface.co/collections/baidu/ernie-45-6861cd4c9be84540645f35c9

ERNIE 4.5 Technical Report

参考小红书上的帖子

快手

AutoThink

DeepSeek-V3 & R1合体了？ 快手开源"Auto Think"大模型，根据问题自动调节思考深度

https://huggingface.co/Kwaipilot/KwaiCoder-AutoThink-preview

冷启

采用Agentic的流程设计，基于训练数据Query，为其构建其优势模式下的Response，构建多样化AutoThink冷启动数据，让模型适应AutoThink的数据形式，并指导其挖掘自身优势场景。即使通过非思考模型，也能获得高质量的带有思考过程的推理数据。

Reasoning RL

• 采用动态调整context length的方式，提升RL的效率：在训练初期先用16K的最大回复长度，在训练过程中通过观察模型回复的截断概率，逐步扩大其回复长度限制，最终扩展至32K。

• 采用了大的batchsize和rollout个数，利用off-policy的更新策略来进一步提升模型的训练效率。在训练过程中会动态地丢弃“过于简单”的样本，来保证batch内有效梯度样本的数量，如在SRPO论文(SRPO: A Cross-Domain Implementation of Large-Scale Reinforcement Learning on LLM)

• 为了平衡模型的探索-利用，通过训练时的熵值来调整KL-Loss的约束力度以及off-policy更新时模型的clip范围，进一步加速模型收敛。

Step-SRPO

由于GRPO缺乏可解释的过程监督信号，导致我们在训练过程中出现了一系列不稳定现象，比如模型认为应该开启think模式却选择了不进行思考，以及对于一些代码/数学题，哪怕问题比较简单也会选择开启思考模式。

面对这些问题，我们基于传统GRPO强化学习算法开发出了面向带有中间过程的Step-SRPO强化学习算法，对不同的token根据未来期望收益使用不同的优势计算函数。发现

• 不仅模型判断的准确性提升了，同时思考能力和非思考性能都有大幅上升。

• 在模型能力上升的同时，模型选择不开启思考模式的比例也在不断上升，模型回答的token数量也随之不断减少。

从而实现了在控制推理资源消耗的同时，提升了模型的整体表现，达成性能与成本的最优协同。

同时也观察到，对于有些榜单，即使模型没有开启思考模式，在这种强化学习过程之后，开启思考模式的比例大幅下降同时，模型性能仍然保持了比强化学习之前更高的基准。

Magistral

Mistral的首个强推理模型：拥抱开源，推理速度快10倍

https://huggingface.co/mistralai/Magistral-Small-2506

论文

核心设计原则是使用与用户相同的语言进行推理。在未经任何处理的数学和编程问题上进行强化学习通常会导致模型在推理过程中出现混合语言。在没有语言限制的初步实验中，Mistral也经常观察到混合英语、中文和俄语单词的输出。虽然这些输出是连贯的，但为了避免语言切换，他们在计算对话（由问题、想法、答案组成）的奖励时，首先通过删除LaTeX内容和代码块对这三个部分进行归一化，然后对每个部分应用fastText分类器。如果分类器指示所有三个部分都使用相同的语言，则会额外给予0.1的奖励。

智谱

GLM-4.1V-9B-Thinking

9B“小”模型干了票“大”的：性能超8倍参数模型，拿下23项SOTA | 智谱开源

GLM-4.1V-Thinking: Towards Versatile Multimodal Reasoning with Scalable Reinforcement Learning

https://github.com/THUDM/GLM-4.1V-Thinking

GLM-4.5

GLM-4.5: Agentic, Reasoning, and Coding (ARC) Foundation Models

模型结构

• MoE用的是DeepSeek-V3 Technical Report里的loss-free balance routing（Auxiliary-Loss-Free Load Balancing Strategy for Mixture-of-Experts）和sigmoid gate

• 减小宽度（routed专家的个数和hidden dim）、增加深度（层数），因为发现更深的模型reasoning能力更强

• self-attn部分用GQA+partial RoPE，用了2.5倍的attn heads（96head，5120dim），虽然对训练loss没有帮助，但对reasoning benchmarks有持续提升。加了QK-Norm来稳定attn logits的范围

• 加了一层MoE来实现MTP(multi-token prediction)层(Better & Faster Large Language Models via Multi-token Prediction)，从而在infer的时候支持投机采样

Model	GLM-4.5	GLM-4.5-Air	DeepSeek-V3	Kimi K2
# Total Parameters	355B	106B	671B	1043B
# Activated Parameters	32B	12B	37B	32B
# Dense Layers	3	1	3	1
# MoE Layers	89	45	58	60
# MTP Layers	1	1	1	0
Hidden Dim	5120	4096	7168	7168
Dense Intermediate Dim	12288	10944	18432	18432
MoE Intermediate Dim	1536	1408	2048	2048
Attention Head Dim	128	128	192	192
# Attention Heads	96	96	128	64
# Key-Value Heads	8	8	128	64
# Experts (total)	160	128	256	384
# Experts Active Per Token	8	8	8	8
# Shared Experts	1	1	1	1
QK-Norm	Yes	No	No	No

预训练

后训练

GLM-4.6

节前重磅：开源旗舰模型新SOTA，智谱GLM-4.6问世

美团

LongCat-flash

https://longcat.chat/

https://github.com/meituan-longcat/LongCat-Flash-Chat/blob/main/tech_report.pdf

LongCat-Flash Technical Report

Longcat-flash-thinking

https://huggingface.co/meituan-longcat/LongCat-Flash-Thinking

https://github.com/meituan-longcat/LongCat-Flash-Thinking/blob/main/tech_report.pdf

mamba-transformer混合

SSM

为什么线性注意力要加Short Conv？

挑战Transformer的Mamba是什么来头？作者博士论文理清SSM进化路径

Pretraining Without Attention

预训练无需注意力，扩展到4096个token不成问题，与BERT相当

Diffusion Models Without Attention

丢掉注意力的扩散模型：Mamba带火的SSM被苹果、康奈尔盯上了

一文看懂Mamba，Transformer最强竞争者

Long Range Language Modeling via Gated State Spaces 认为 Transformer 和 SSM 完全可以互补。

选择性状态空间模型(selective state space model)是Mamba论文作者Albert Gu此前主导研发的S4架构(Structured State Spaces for Sequence Modeling)的一个简单泛化。

https://stacks.stanford.edu/file/druid:mb976vf9362/gu_dissertation-augmented.pdf

序列模型在训练和推理时的侧重点：

• 训练时：在整个list上计算loss，需要优化forward的耗时

• 推理时：一次输入一个时间步，需要高效地顺序处理

SSM原理

输入$u(t) \in \mathbb{R}$，输出是$y(t) \in \mathbb{R}$，引入状态$x(t) \in \mathbb{R}^N$，目标是学习映射$u(t) \mapsto y(t)$，

$$\begin{aligned} x^{\prime}(t) & =\boldsymbol{A} x(t)+\boldsymbol{B} u(t) \\ y(t) & =\boldsymbol{C} x(t)+\boldsymbol{D} u(t) \end{aligned}$$

结合维基百科的图，方便理解

ssm

各变量含义如下（看起来和RNN很像）：

• $\boldsymbol{A}\in \mathbb{R}^{N\times N}$：状态矩阵

• $\boldsymbol{B}\in \mathbb{R}^{N\times N}$：输入矩阵

• $\boldsymbol{C}\in \mathbb{R}^{N\times N}$：输出矩阵

• $\boldsymbol{D}\in \mathbb{R}^{N\times N}$：feedforward矩阵或者feedthrough矩阵

• $x^{\prime}(t):=\frac{d}{d t} \mathbf{x}(t)$是$x(t)$关于$t$的导数，所以图里有一个积分$\int$操作把它变回$x(t)$

假设序列长度为$L$，那么

• 时间复杂度：

  • SSM：$O(N^2L)$，因为$\boldsymbol{A} x(t)$是$N\times N$和$N\times 1$的矩阵乘法，复杂度是$N^2$

  • RNN：$O(N^2L)$，和SSM类似

  • CNN：$O(kLM^2)$，假设$k$个卷积核，每个卷积核$M\times M$，一般$M \ll N$

• 空间复杂度：

  • SSM：$O(N^2+NL)$，因为中间状态$x(t) \in \mathbb{R}^N$是需要额外存储的

  • RNN：$O(N^2)$，所有时间步共享权重，不需要像SSM专门为每个时间步存一个状态$x(t)$

  • CNN：$kM^2$

所以传统SSM的时空复杂度都很高，作者提出了S4(structured state space model)

====>hippo的假设会让模型更关注宽波，对于很窄的毛刺信号效果不好，所以对大海捞针任务效果并不好

Mamba

Mamba: Linear-Time Sequence Modeling with Selective State Spaces

https://huggingface.co/state-spaces

https://github.com/havenhq/mamba-chat

MODELING SEQUENCES WITH STRUCTURED STATE SPACES

Mamba2

再战Transformer！原作者带队的Mamba 2来了，新架构训练效率大幅提升

Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality

https://github.com/state-spaces/mamba

Mamba3

Mamba-3惊现AI顶会ICLR 2026！CMU知名华人教授一作首代工作AI圈爆红

Mamba-3惊现ICLR 2026投稿：三重升级打满“推理优先”范式

Mamba-3: Improved Sequence Modeling using State Space Principles

SAMBA

长文本模型近期研究工作梳理

SAMBA: Simple Hybrid State Space Models for Efficient Unlimited Context Language Modeling

Mamba in llama

Mamba作者新作：将Llama3蒸馏成混合线性 RNN

The Mamba in the Llama: Distilling and Accelerating Hybrid Models

Mamba+Transformer

Mamba真比Transformer更优吗？Mamba原作者：两个都要！混合架构才是最优解

An Empirical Study of Mamba-based Language Models

Block-State Transformer

Block-State Transformer

Jamba

Mamba做大做强！混合Transformer，打败Transformer

https://huggingface.co/ai21la/Jamba-v0.1

让mamba做短程头，让transformer做长程头

Falcon Mamba

非Transformer架构站起来了！首个纯无注意力大模型，超越开源巨头Llama 3.1

Welcome FalconMamba: The first strong attention-free 7B model

https://huggingface.co/tiiuae/falcon-mamba-7b

https://github.com/huggingface/transformers/blob/main/src/transformers/models/falcon_mamba/modeling_falcon_mamba.py

核心是FalconMambaMixer这个类

无需增加内存存储，就可以处理任意长度的序列，并且能够在单个 24GB A10 GPU 上运行。

训练数据有5500GT ，主要由RefinedWeb数据集组成，并添加了来自公共源的高质量技术数据、代码数据和数学数据。

采用多阶段训练策略进行训练，上下文长度从2048增加到了8192。此外，受到课程学习概念的启发，整个训练阶段精心选择了混合数据，充分考虑了数据的多样性和复杂性。在最后的训练阶段，使用了一小部分高质量精选数据（即来自 Fineweb-edu 的样本），以进一步提升性能。

大部分训练是在256个H100 80GB GPU上完成的，采用了 3D 并行（TP=1、PP=1、DP=256）与 ZeRO 相结合的策略。

用adamW+WSD（预热 - 稳定 - 衰减）学习率schedule，在前50 GT的训练过程中，batch大小从b_min=128增加到了b_max=2048

Nemotron-H

https://research.nvidia.com/la/adlr/nemotronh/

STORM

Token-Efficient Long Video Understanding for Multimodal LLMs

VAMBA

长视频理解新突破！Mamba混合架构让显存消耗腰斩，处理10万视频token不费力

VAMBA: Understanding Hour-Long Videos with Hybrid Mamba-Transformers

干预训练使长度泛化

Transformer死角，只需500步后训练，循环模型突破256k长度泛化极限

Understanding and Improving Length Generalization in Recurrent Models

diffusion LLM

综述

挑战AR霸权！MBZUAI发布扩散语言模型全面综述：解析语言建模新范式

A Survey on Diffusion Language Models

https://github.com/VILA-Lab/Awesome-DLMs

gemini diffusion

大模型全面爆发，所有榜一都是Gemini！谷歌一夜站到了台前

12秒生成1万token！谷歌推出文本「扩散模型」Gemini Diffusion，研究员：演示都得降速看

LLaDA

冲击自回归，扩散模型正在改写下一代通用模型范式

Large Language Diffusion Models

LLaDOU

与Gemini Diffusion共振！首个扩散式「发散思维链」来了

Reinforcing the Diffusion Chain of Lateral Thought with Diffusion Language Models

https://github.com/maple-research-lab/LLaDOU

fast-dLLM

谷歌之后，英伟达入局扩散大语言模型，Fast-dLLM推理速度狂飙27.6倍

DiffuCoder

苹果出手！改进GRPO，让dLLM也能高效强化学习

DiffuCoder: Understanding and Improving Masked Diffusion Models for Code Generation

https://github.com/apple/ml-diffucoder

Mercury

这个扩散LLM太快了！没有「请稍后」，实测倍速于Gemini 2.5 Flash

Mercury: Ultra-Fast Language Models Based on Diffusion

https://poe.com/Inception-Mercury

Seed Diffusion

https://seed.bytedance.com/zh/seed_diffusion

Seed Diffusion: A Large-Scale Diffusion Language Model with High-Speed Inference

RND1

Qwen3 变身扩散语言模型？不从零训练也能跑，30B参数创纪录

Training Diffusion Language Models at Scale using Autoregressive Models

https://github.com/RadicalNumerics/RND1

• 系统性研究了大规模A2D（Autoregressive-to-Diffusion）转换过程中的关键因素，如初始化策略、层级学习率和临界batchsize。

• 识别出能够实现可扩展性与稳定性的关键因素，并证明当这些因素与成熟的自回归预训练方法结合时，简单的技术组合也能催生可扩展的DLM

高效attention总结

A Survey of Efficient Attention Methods: Hardware-efficient, Sparse, Compact, and Linear Attention

https://github.com/attention-survey/Efficient_Attention_Survey

各种结构对比

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

世界模型

怒斥Sora之后，LeCun放出「视觉世界模型」论文，揭示AI学习物理世界的关键​

100万token，一次能分析1小时YouTube视频，「大世界模型」火了

WORLD MODEL ON MILLION-LENGTH VIDEO AND LANGUAGE WITH RINGATTENTION

https://github.com/LargeWorldModel/LWM

Sora是世界模拟器吗？全球首篇综述全面解析通用世界模型

Is Sora a World Simulator? A Comprehensive Survey on General World Models and Beyond

世界模型也扩散！训练出的智能体竟然不错

Diffusion for World Modeling: Visual Details Matter in Atari

https://github.com/eloialonso/diamond

pandora

通用世界模型问世：不学习就能生成新领域视频，可实时控制

Pandora : Towards General World Model with Natural Language Actions and Video States

https://github.com/maitrix-org/Pandora

ACL 2024论文盖棺定论：大语言模型≠世界模拟器，Yann LeCun：太对了

Can Language Models Serve as Text-Based World Simulators?

WHALE

WHALE来了，南大周志华团队做出更强泛化的世界模型

WHALE: TOWARDS GENERALIZABLE AND SCALABLE WORLD MODELS FOR EMBODIED DECISION-MAKING

genie 2

谷歌世界模型爆发：单张图生成可玩3D世界，还要和马斯克一起做AI游戏

https://deepmind.google/discover/blog/genie-2-a-large-scale-foundation-world-model/

NWM

LeCun团队新作：在世界模型中导航

Navigation World Models

https://www.amirbar.net/nwm/

V-JEPA 2

刚刚，LeCun亲自出镜，Meta推出新世界模型！

V-JEPA 2: Self-Supervised Video Models Enable Understanding, Prediction and Planning

https://github.com/facebookresearch/vjepa2

https://huggingface.co/collections/facebook/v-jepa-2-6841bad8413014e185b497a6

Agents-world-model

AGI真方向？谷歌证明：智能体在自研世界模型，世界模型is all You Need

General agents contain world models

Context as Memory

上下文记忆力媲美Genie3，且问世更早：港大和可灵提出场景一致的交互式视频世界模型！

Context as Memory: Scene-Consistent Interactive Long Video Generation with Memory Retrieval

Dreamer4

梦里啥都有？谷歌新世界模型纯靠「想象」训练，学会了在《我的世界》里挖钻石

Training Agents Inside of Scalable World Models

https://danijar.com/project/dreamer4/

现有模型的问题：

• 世界模型智能体（如 Dreamer 3）是迄今为止在游戏和机器人领域表现最佳且最为稳健的强化学习算法之一。虽然这些模型在其特定的狭窄环境中速度快且准确，但其架构缺乏拟合复杂现实世界分布的能力。

• 可控视频模型（如Genie 3）已在多样的真实视频和游戏上进行训练，并实现了多样的场景生成和简单交互。这些模型基于可扩展架构，如diffusion transformer。然而，它们在学习物体交互和游戏机制的精确物理规律方面仍存在困难，这限制了它们在训练成功智能体方面的实用性。此外，它们通常需要多个GPU才能实时模拟单个场景，这进一步降低了它们在想象训练方面的实用性。

Dreamer 4是一种可扩展的智能体，它通过在快速且准确的世界模型中进行想象训练(Imagination Training)来解决控制任务。

• 利用一种新颖的shortcut forcing目标和高效的Transformer架构，准确学习复杂的物体交互，同时实现实时人机交互（在单个GPU上）和高效的想象训练。

• 可以在大量无标签视频上进行训练，并且只需要少量与动作配对的视频。这为未来从多样的网络视频中学习通用世界知识开辟了可能性，因为这些网络视频没有动作标签。

模型：

• Tokenizer：对部分被掩码的图像块和latent token进行编码，通过带有tanh激活的低维投影压缩潜变量，并对图像块进行解码。它使用因果注意力实现时间压缩，同时允许逐帧解码。

• 动力学模型：在由动作、shortcut 噪声水平、步长和tokenizer表示交错组成的序列上运行。通过shortcut forcing目标对表示进行去噪，以实现少量前向传递的交互式生成，并防止随时间累积误差。

首先在视频和动作上预训练tokenizer和世界模型，然后通过交错任务嵌入将策略和奖励模型微调至世界模型中，最后通过想象训练对策略进行后训练。

Emu3.5

世界模型有了开源基座Emu3.5！拿下多模态SOTA，性能超越Nano Banana

Emu3.5: Native Multimodal Models are World Learners

FantasyWorld

高德的

FantasyWorld: Geometry-Consistent World Modeling via Unified Video and 3D Prediction

小结

world model和vla的讨论：xhs

VLA(Vision-Language-Action Model)：统一的多模态模型，将视觉感知、语言理解和动作执行融合在一个端到端的框架内。通常采用Transformer，能够接收图像/视频和自然语言指令作为输入，并自回归地生成一系列动作指令(Token)。

典型的VLA模型(如RT-2,OpenVLA)两阶段训练：

• 大规模预训练：在海量的互联网图文+视频数据上进行学习，以获得通用的视觉和语言表征能力。

• SFT：在由人类专家操作机器人录制的高质量“状态-动作”轨迹数据上进行行为克隆(Behavioral Cloning)，教会模型执行具体任务。

然而，纯SFT的VLA模型本质上是“模仿学习”,严重依赖于演示数据的覆盖范围，当遇到新场景或新指令时，泛化能力不足。

机器人技术主要面临以下瓶颈：

• 模型泛化能力差：传统的机器人大多在特定、封闭的实验室环境中工作，一旦进入全新的家庭环境，面对新物体、新布局和新光照，便会失灵。暴露了其严重依赖训练分布后，缺乏开放世界泛化能力。

• SFT的局限性：SFT依赖于大量高质量的专家演示数据，但这不仅收集成本高昂、过程繁琐(数据稀缺性)，更关键的是，模型仅仅在"模仿"专家，无法通过试错来探索更优或更鲁棒的约策略，导致泛化能力差

• 强化学习(RL)的效率问题：Model-Free强化学习虽然能通过探索学习，但直接应用于高维视觉输入时，样本效率极低，需要数亿次的交互才能学会简单任务，在真实机器人上几乎不可行。

• 仿真到现实(Sim-to-Real)的鸿沟：虽然可以在模拟器中低成本地训练，但模拟器与真实世界之间始终存在动力学差异，导致在模拟器里表现优异的策略，迁移到真实机器人上时性能会大幅下降

为了解决这些问题，研究者们开始探索将世界模型作为环境的内部模拟器以提升学习效率，并利用强化学习赋予VLA模型超越模仿的探索和泛化能力，最终走向一个统一、高效且泛化的智能机器人框架。

世界模型(World Model，WM)是智能体内部构建的关于环境如何运作的动态模型。其核心思想是让智能体先学习一个环境的"模拟器"，然后可以在这个内部的、可微分的"梦境"或"想象"中进行高效、快速的规划和策略学习，从而大幅减少与真实世界的昂贵交互。世界模型主要扮演三大核心角色：

• 动力学模型(Dynamic Model for MBRL)：用于(model-based rl，MBRL)，模型在紧凑的潜在空间(Latent Space)中预测未来的状态和奖励，智能体在此基础上进行策略优化。经典代表是Dreamer系列，它基于循环状态空间模型(RSSM)在潜在空间中进行长时序的想象(rollout),并完全在想原中训练Actor-Critic策略,极大地提升了样本效率。

• 神经模拟器(Neural Simulator)：此类世界模型专注于生成高保真、可控的感官数据(如视频),作为传统物理引擎的替代品。它可以用来生成训练数据、合成罕见或危险的场景、或进行闭环测试。代表模型如Cosmos、GAIA-1等,通常基于扩散模型(Diffusion Model)或自回归Transformer,能够生成高质量、时空一致的视频

• 奖励模型(Reward Model)：在奖励稀疏或难以设计的任务中，世界模型可以用来生成稠密的奖励信号。例如，VIPER利用预训练的视频测测模型，将"智能体轨迹与专家演示视频的相似度"作为奖励，从而在没有显式奖励函数的情况下驱动策略学习。

从架构上看,世界模型经历了从早期的递归模型(如RSSM)到能够捕捉长程依赖的Transformer，再到生成质量更高的扩散模型和自回归模型的演进。

VLA+WM

将VLA的语义理解能力与WM的动态预测/规划能力深度融合，构建一个既能"听懂指令"，又能"预见未来"的统一智能体。典型实现方案：

• 统一的自回归框架：WorldVLA将"动作模型(VLA)"和"世界模型(WM)"统一到一个共享的自回归Transformer框架和词表中。通过不同的提示，模型既可以以生成动作(VLA任务:"机器人下一步该做什么?")，也可以预测世界的下一帧视觉画面(WM任务:"接下来会发生什么?")。这种设计带来了双向增益：WM学到的物理因果关系能提升动作的合理性；VLA对动作的理解则能让WM的视频预测更符合物理规律。

• 基于世界表征的策略学习：DreamVLA提出了一种更解耦的思路。首先用一个世界模型从输入中提取并预测一个抽象的world embedding，代表了"未来世界状态的批抽象表示"。然后，VLA的动作策略不再直接观察原始图像，而是基于这个紧凑且蕴含未来的world embedding来决策。这种"看未来的因果结果,再决定动作"的方式,比传统的"模式匹配像素"更为高效和鲁棒。

• 世界模型作为动态后训练：WM被用作一个独立的训练阶段。例如，在策略微调之前，先让模型仅用视频和指令来学习预测后续视频帧(世界模型后训练)，能让模型扎实地学到"语义+时序动力学"，为后续生成更精准、更具前瞻性的动作策略打下坚实基础。

通过VLA与WM的结合，模型不仅能理解任务目标，还能在内部进行"推演"，评估不同动作可能带来的后果，从而做出更智能的决策

具身智能

大模型走向物理世界，TeleAI 发布大模型驱动的具身智能综述，覆盖300篇文献

Embodied-AI with large models: research and challenges

李飞飞的文章

李飞飞最新长文：AI的下一个十年——构建真正具备空间智能的机器

From Words to Worlds: Spatial Intelligence is AI’s Next Frontier

ReKep

李飞飞团队提出ReKep，让机器人具备空间智能，还能整合GPT-4o

ReKep: Spatio-Temporal Reasoning of Relational Keypoint Constraints for Robotic Manipulation

https://github.com/huangwl18/ReKep

GR-2

GR-2登场！ByteDance Research提出机器人大模型，具备世界建模和强大泛化能力

GR-2: A Generative Video-Language-Action Model with Web-Scale Knowledge for Robot Manipulation

https://gr2-manipulation.github.io/

RDT-1B

清华开源全球最大双臂机器人扩散大模型RDT，懂调酒能遛狗，登顶HF具身热榜

RDT-1B: a Diffusion Foundation Model for Bimanual Manipulation

HIL-SERL

强化学习训练一两个小时，100%自主完成任务：机器人ChatGPT时刻真来了？

Precise and Dexterous Robotic Manipulation via Human-in-the-Loop Reinforcement Learning

Genesis

历时2年，华人团队力作，震撼开源生成式物理引擎Genesis，可模拟世界万物

https://github.com/Genesis-Embodied-AI/Genesis

language of motion

李飞飞团队统一动作与语言，新的多模态模型不仅超懂指令，还能读懂隐含情绪

The Language of Motion: Unifying Verbal and Non-verbal Language of 3D Human Motion

视觉空间智能

李飞飞、谢赛宁等探索MLLM「视觉空间智能」，网友：2025有盼头了

Thinking in Space: How Multimodal Large Language Models See, Remember, and Recall Spaces

具身多模态推理

统一框架下的具身多模态推理：自变量机器人让AI放下海德格尔的锤子

PEVA

伯克利&Meta面向具身智能的世界模型：让AI通过全身动作「看见」未来

Whole-Body Conditioned Egocentric Video Prediction

https://dannytran123.github.io/PEVA/

MTU3D

ICCV 2025满分论文：一个模型实现空间理解与主动探索大统一

Move to Understand a 3D Scene: Bridging Visual Grounding and Exploration for Efficient and Versatile Embodied Navigation

https://github.com/MTU3D/MTU3D

CoA

模仿学习新范式，Chain-of-Action：轨迹自回归实现动作推理

Chain-of-Action: Trajectory Autoregressive Modeling for Robotic Manipulation

https://github.com/ByteDance-Seed/Chain-of-Action

持续学习

Lifelong learning of LLM

(toread)

Towards Lifelong Learning of Large Language Models: A Survey

https://github.com/qianlima-lab/awesome-lifelong-learning-methods-for-llm

online learning

xhs

Online Learning 的关键在于突破人类知识上限，让模型具备探索和自我奖励的能力。如果模型只能在既有知识中循环，就难以出现真正的飞跃。目前，研究者普遍把 Online Learning 分成两类：

• Lifelong Learning，通过用户反馈等方式不断优化；

• Meta Online Learning，强调快速适应新任务。往往被视作Lifelong Learning的前提，二者结合，才可能让模型逐步逼近更高层次的智能。

不过，现实中仍有挑战。最大的问题在于如何获取有效的反馈信号（reward）。在编码等场景，反馈明确、密集，更容易落地；但在开放对话、复杂任务中，反馈往往稀疏模糊，难以驱动模型进步。同时，如何在算力受限的情况下做到快速迭代，也是亟待解决的问题。

总的来看，Online Learning 不仅是提升模型性能的一种方法，更是塑造未来AI交互和推理模式的关键。它要求模型和外部系统（如 memory）协同更新，从而实现动态优化。未来，我们可能看到模型具备自我生成任务、自我管理记忆的能力，这才是真正意义上的在线学习。

一些前沿

Potemkin Understanding

Gary Marcus惊世之言：纯LLM上构建AGI彻底没了希望！MIT、芝大、哈佛论文火了

Potemkin Understanding in Large Language Models

H-Net

无Tokenizer时代真要来了？Mamba作者再发颠覆性论文，挑战Transformer

Dynamic Chunking for End-to-End Hierarchical Sequence Modeling

https://github.com/goombalab/hnet

分层架构，假设输入有m个字

• encoder + chunking：其中chunking模块包括两部分

  • routing module：通过相似度评分预测相邻元素之间的边界，可以理解为把原始输入分成k个词（chunk）

  • downsampler：基于边界进行下采样，即将每个边界词产出一个向量，共k个

• 主网络：可以是任意网络，例如transformer或者mamba

• dechunking + decoder：其中dechunking模块包括两部分：

  • smoothing module：将离散的chunk转化成插值的表示，用的是指数滑动平均（EMA），所以图里看着有点渐变的那个样子

  • upsampler：基于边界还原成m个字，用到了ste（Straight-Through Estimator）的技巧来保证训练稳定：

    • 前向：1和soomthing的输出z相乘

    • 反向：routing的输出p处理一下得到c（如果是边界那就是p，不是边界就用1-p，所以图中c和p有的一样，有的是“互补”的），和soomthing的输出z来相乘，其实就是保证有连续的梯度

MTP改造

五倍推理加速，激发自回归潜能，苹果新工作让LLM预测未来

Your LLM Knows the Future: Uncovering Its Multi-Token Prediction Potential

• 原来的llm，ntp的话，如果在assistant后面给出4个placeholder(图中的<->)，其实能在top200里找得到最终答案，说明模型隐式地知道未来

• 通过mask来finetue一个mtp的版本，能在top10里找到答案

• 再加一个sampler能进一步提升

• 在序列的最后加入$k$个不同的mask tokens，$[m_1,..,m_k]$（图中的黄色部分），和原序列拼在一起得到$X_m=\left[x_1, \ldots, x_n, m_1, \ldots, m_k\right]$，通过decoder模型输出的emb是$z_1,z_2,...,z_n,z_{n+1}, ...,z_{n+k}$

• $y_{n+1}$还是通过自回归+unembedding（就是一个矩阵$W\in R^{V\times d}$，把emb映射回词表$p_n=Wz_n, z_n\in R^d$）+argmax预估的，而在生成m的预估即$y_{n+2}$到$y_{n+k}$时则会再加上一个sampler（其实就是输入有上一次采样出来的$y_{n-1}$和当前的$z_{n}$，过一个MLP再去和W乘）

• gated LoRA adaptation：就是一个lora，但是对NTP（即输入x预测下一个x）并不生效，只对输入m走MTP的时候生效。MTP不仅更新lora的A和B，还更新sampler

假设输入3个x，预估2个m，划分为3个block:$[x_0,m_1,m_2],[x_1,m_1,m_2],[x_2,m_1,m_2]$，mask的原则如下：

• NTP：每个x只能看到左边的x，看不到右边的x，而且是跨block的，即$x_2$能看到前2个block里的$x_1$和$x_0$

• MTP：能看到当前block左边的m，看不到前面block里的m

一致性loss：如图，m1其实是模拟的x1，所以他的输出也要和x1的输出去对齐，m2同理

其中的投机采样细节看着有点复杂，还要再看下论文

OaK

强化学习之父Richard Sutton最新演讲揭示OaK架构：通向超级智能的八步愿景

为何幻觉

OpenAI罕见发论文：我们找到了AI幻觉的罪魁祸首

Why Language Models Hallucinate

• 幻觉定义：模型自信地生成不真实答案。

• 原因：标准的训练和评估程序更倾向于对猜测进行奖励，而不是在模型勇于承认不确定时给予奖励。如果你不知道答案，但随意猜测，你可能会很幸运地猜对。留空则必定得零分。当模型仅根据准确度（即完全答对问题的百分比）进行评分时，它们会被鼓励进行猜测，而不是承认「我不知道」。

• 和下一个词预测的关系：与传统的机器学习问题不同，每个语句没有「真/假」标签，模型只看到流畅语言的正面示例，并且必须去近似整体分布。当没有任何被标注为无效的示例时，区分有效语句和无效语句会更加困难。但即使有标签，一些错误也是不可避免的。拼写和括号遵循一致的模式，就算有错误会随着规模的扩大而消失。但像宠物的生日这样低频的事实，无法仅凭模式预测，因此会导致幻觉。

• 解决办法：对自信错误（confidential error）的惩罚力度大于对不确定性的惩罚力度，并对恰当表达不确定性的行为给予部分加分。如果主要评估指标依然继续为模型幸运的猜测给予奖励，模型就会继续学习猜测。修改评估指标可以扩大降低幻觉技术的采用范围，包括新开发的和先前研究的技术。

embed检索的问题

DeepMind爆火论文：向量嵌入模型存在数学上限，Scaling laws放缓实锤？

On the Theoretical Limitations of Embedding-Based Retrieval

当知识库规模足够大、一个问题需要多份文档共同回答时，即使采用最先进的嵌入模型，也可能因为维度不足而无法完整召回关键信息。这会导致大模型在生成时受到错误或不完整上下文的干扰。

持续学习

多模态大模型持续学习系列研究，综述+Benchmark+方法+Codebase一网打尽！

Continual Learning for Generative AI: From LLMs to MLLMs and Beyond

superweight

0.01%参数定生死！苹果揭秘LLM「超级权重」，删掉就会胡说八道

The Super Weight in Large Language Models

REFRAG

扎克伯格的豪赌初见成效？Meta新方法让LLM长上下文处理提速30倍

Meta超级智能实验室首篇论文：重新定义RAG

REFRAG: Rethinking RAG based Decoding

Markovian Thinker

算力成本大降！马尔可夫思考机来了，LLM推理成本直接降为线性

The Markovian Thinker

https://github.com/McGill-NLP/the-markovian-thinker

TRM

700万参数击败DeepSeek R1等，三星一人独作爆火，用递归颠覆大模型推理

Less is More: Recursive Reasoning with Tiny Networks

FBAM

Attention is NOT All You Need：让“深度”重新流入时间，而非堆叠在参数之上

Recurrence-Complete Frame-based Action Models

与传统语言模型直接预测下一个 token 不同，FBAM 在每一步预测“动作（action）”，由环境反馈生成下一帧（frame），从而形成一个动态的交互式训练循环。

1. Frame Head（帧头）：使用Transformer结构处理单帧内容，通过自注意力机制提取帧内特征；

2. Integrator（整合器）：使用LSTM架构在帧间累积状态，实现跨时间的递归整合。

两者共同构成了一个“帧内并行、帧间递归”的混合模型。这一设计保留了注意力机制在局部结构建模上的优势，同时恢复了时间维度上的深度。

Free Transformer

Meta打碎Transformer 8年铁律！改写AI最底层规则，模型首次冒出潜意识

The Free Transformer

CALM

微信、清华连续自回归模型CALM，新范式实现从「离散词元」到「连续向量」转变

Continuous Autoregressive Language Models

auto-encoder

• 输入k个连续token，查到他们的emb，通过encoder映射到隐层，再decode回去

• 加了一个VAE的正则$\mathcal{L}_{\mathrm{KL}}\left(p_E\left(\mathbf{z} \mid \mathbf{x}_{1: K}\right) \| \mathcal{N}(0, \mathbf{I})\right)=-\frac{1}{2} \sum_{i=1}^l\left(1+\log \sigma_i^2-\sigma_i^2-\mu_i^2\right)$，注意vae就是把隐层向量通过nn产出均值和方差，再基于这个去采样

如图，原始token经过上面encoder的压缩后输入给transformer，然后加一个L层的energy-based的head，同时输入一个噪声，得到的输出就是预估的下一个向量。infer的时候再经过decoder得到原始token，再把这个输入trans