模型与机制 on 扎塔-Zata

Jev：不写字的决策模型，和它真正适合解决的问题

Sun, 20 Sep 2026 11:55:44 +0800

9 月 15 日，硅谷的 AI 开发者社区被一个名字刷屏了：Jev。当天它在 Hacker News 拿到 1800 多分、近 500 条评论，第二天 Vercel 宣布 AI Gateway 接入。

我看到时的第一反应，大概和多数人一样——又是哪家大厂偷偷憋了个全能模型，准备去跟 GPT、Claude 叫板。点开文档才发现，方向完全是反的：它根本不会说话。

发布它的公司叫 TypeSafe AI，2024 年成立，带着 4000 万美元种子轮（DCVC 领投）走出隐身期。创始人是 Diogo Almeida——InstructGPT 论文的联合作者，OpenAI 在 GPT-4 的贡献名单里把他列在「Foundational RLHF and InstructGPT work」一行；Erik Gafni 和 Sasha Sheng 是另两位联创。

他在接受 TechCrunch 采访时说过一句话，基本能概括这个产品的动机：

We have lightning in a bottle, and yet it is not useful.

我们手里握着瓶中的闪电，可它却没什么用。理由很直白：过去几年行业优化的是人类语言，但真正消费智能的是软件。

两个名字，和一整套立场

Jev 身上有两个名字，都来自官方 FAQ，而且都不是随手起的。

第一个是 System One Model。它借的是丹尼尔·卡尼曼在《思考，快与慢》里的划分：系统 1 是快速、直觉的判断，系统 2 是缓慢、费力的推理。带思维链的推理模型更像系统 2，Jev 想做系统 1——快而聚焦的判断。

第二个是 Jev 本身。它取自经济学家威廉·斯坦利·杰文斯和杰文斯悖论：某种资源的利用效率大幅提升时，它的总消耗量往往不是缩减，而是成倍增长。TypeSafe 押的注就是这个——当单次智能决策的成本便宜到可以忽略，被塞进软件里的次数会指数级上升。原本写死 if-else 的地方，会开始考虑接一个模型来做动态判断。

顺着这个立场，还有两个更能说明态度的动作：发布前一周，TypeSafe 先发了两篇铺垫文章，一篇叫《The Bitterest Lesson》（主张"做对的任务 > 数据 > 算力 > 算法"），另一篇叫《Lies, Damned Lies, and Benchmarks》——宣布不发布标准基准成绩，理由是榜单会被刷，新评测发布即退役。

这既是姿态，也有一个很实际的后果：没有任何公开榜单分数可以外推到你的业务上。 想判断它行不行，只能自己拿数据测。

它砍掉的，是「生成文字」这件事

理解 Jev 的关键，是意识到它和 LLM 的分工不在同一个位置上。

LLM 是为"给人读"设计的：你问它一个问题，它把答案一个字一个字写出来。当你真正需要的是"一个程序能直接消费的判断"时，中间就出现了一层错配——你在强迫一个文本生成系统输出结构化结果，然后再写代码把那段文本解析回来。解析失败、格式漂移、多余的客套话，都是这层错配的副产品。

Jev 把这一步跳过了。它接收一份 state（程序当前的状态），回答你提前定义好的问题，直接返回带类型的值——choice、score、noul，以及每个选项的概率。

两条路径的差别不在于模型多聪明，而在于要不要先把答案"写"出来。

官方给了一张很直接的对比表（口径为官方自述）：LLM 用 RLHF / RLVR 优化人类偏好和可验证奖励，Jev 用 RLCD 优化"校准过的概率决策"；LLM 输出字符串需要解析和校验，Jev 输出类型化结果，选项是预先定义的；LLM 顺序解码一次一个 token，Jev 并行一次算完全部答案。至于成本那一栏，官方写的是输入 $0.042 / 百万 token、输出免费——比 Claude Fable 5.1 的输入价低 238 倍。

接口只有三种问法

Jev 目前只接受文本输入：字符串、JSON 对象，或者字符串数组。图片、音频、视频都还不支持。

它能回答的问题被限制在三种原语（官方叫 primitives）里：

原语	问什么	返回什么
`choice`	从一组选项里选一个（单题最多 255 个）	选中的选项 + 各选项概率 + confidence
`score`	在一组有顺序的等级上打分（2–10 级）	分数 + 等级图例 + 各等级概率 + confidence
`noul`	这句话成立吗？	一个 0–1 的概率，没有单独的 confidence 字段

几个容易读错的细节。

score 返回的那个数不是"选中了第几档"，而是各等级位置的概率加权平均。一个 3 级量表（0、1、2）如果概率是 0.0、0.7、0.3，得到的就是 0×0.0 + 1×0.7 + 2×0.3 = 1.3——它可以落在两档之间。

noul 没有 confidence 字段，因为概率本身就是置信度：0.92 是"很可能成立"，0.5 是"完全没头绪"。这里还藏着一个语义陷阱——noul 的 0.5 是"各半"，不是"程度中等"。想衡量程度要用 score，并且你得先把等级定义清楚。

还有一个只在文档角落里写着的实现细节：问题 ID 不会发给模型。你写在 questions 里的 key 只是给代码用的，模型只看 instructions。所以 instructions 必须自包含——写 "type": "noul", "instructions": "Does this convey urgency?" 是够的，但指望模型从 key 名 is_urgent 里猜出你的意思就不够了。

一次请求长这样，state 加一组问题：

{
 "model": "jev-latest",
 "state": "Help! My payouts have been failing for 3 days.",
 "questions": {
 "is_urgent": {
 "type": "noul",
 "instructions": "Does this convey urgency?"
 },
 "department": {
 "type": "choice",
 "instructions": "Which team should handle this?",
 "criteria": {
 "billing": "Payments, invoicing, refunds",
 "technical": "Bugs, outages, integrations",
 "sales": "Pricing, upgrades, new accounts"
 }
 },
 "frustration": {
 "type": "score",
 "instructions": "How frustrated is the customer?",
 "criteria": ["Calm", "Frustrated", "Very angry"]
 }
 }
}

三个问题一起回来：

{
 "model": "jev-latest",
 "answers": {
 "is_urgent": { "type": "noul", "noul": 0.92 },
 "department": {
 "type": "choice",
 "choice": "technical",
 "probabilities": { "billing": 0.08, "technical": 0.85, "sales": 0.07 },
 "confidence": 0.82
 },
 "frustration": {
 "type": "score",
 "score": 1.6,
 "legend": { "0": "Calm", "1": "Frustrated", "2": "Very angry" },
 "probabilities": { "0": 0.05, "1": 0.3, "2": 0.65 },
 "confidence": 0.78
 }
 }
}

调用方式有三条路，请求和响应的形状是一致的，只有 noul / boolean 的叫法不同：

TypeSafe 自己的 API：POST https://api.typesafe.ai/v1/systemone，Bearer token 鉴权，模型别名 jev-latest，当前解析到 jev-1.13.0
Vercel AI SDK 7：experimental_evaluate，模型 id typesafe-ai/jev——注意 OpenAI 兼容端点不支持
OpenRouter：SDK 里的 alpha.decisions.create，模型 id typesafe/jev-1.13

import { experimental_evaluate as evaluate } from 'ai';

const result = await evaluate({
 model: 'typesafe-ai/jev',
 state: contextText,
 questions: {
 action: {
 type: 'choice',
 instructions: 'How should this request be handled?',
 criteria: {
 allow: 'Safe to proceed',
 block: 'Should be blocked',
 escalate: 'Needs human review',
 },
 },
 },
});

但真正值得注意的不是这三种原语本身，而是官方文档里的这句话：

每个问题都是针对同一份 state、并行且相互独立地被评估的。增加问题通常不会增加延迟。 一个问题的答案不会成为另一个问题的隐藏上下文。

这句话的分量比"快"更重。它意味着你可以放心地把一个模糊的大判断拆成十个窄问题——拆开不会互相污染，也不会让延迟线性增长。官方文档甚至给这个做法起了名字：speculative fan-out（推测性扇出）。

限定条件也要一起读：请求规模和输入长度得可控，而且输入 token 消耗确实会增加。你省下的是延迟，不是账单。

为什么它快，而且便宜得不太像话

普通大模型哪怕最后只需要一个 JSON，也得先把它逐 token “写"出来，再由程序解析回结构。Jev 不走这条路：它直接计算各个候选答案的概率，多个问题还能同时算。

官方放出的并排演示里，同一个任务的对照是：Jev 用 0.114 秒、花 0.000081 美元；对照的 LLM 用 8.566 秒、花 0.013880 美元。换算下来，大约快 75 倍、便宜 171 倍。

成本和延迟的公开数据：

输入 $0.042 / 百万 token，输出按官方定价免费，上下文窗口 32K
端到端延迟 70–500 毫秒，OpenRouter 页面显示的 P50 约 0.23 秒
采纳速度：上线 Vercel AI Gateway 后，24 小时内被接近 13% 的付费团队使用，是该平台采用最快的新模型

不过"193.6 倍更快、444.6 倍更便宜"这类头条数字，需要看清它的测量方式。这四个工作流由 TypeSafe 内部团队制作，参考答案是 GPT-6 Astra 和 Claude Fable 5.1 高推理模式输出的平均，而且被测 LLM 用的是官方提供的结构化输出 wrapper。

也就是说：同一套工作流、官方出题、官方选裁判。 官网自己也承认这些数字处在"预期实际收益的较高端”。这套自我披露值得肯定，但它显然不是独立基准——后文会看到独立实测给出的量级。

拆开看：它到底是怎么做到的

Jev 目前没有开源，也没有公开的完整技术报告。但社区在发布后几个小时内就跑通了复现，路径已经很清楚了。

第一条路径是候选词的 logits 掩码投影。 模型做完单次前向传播后，直接取序列最后一个位置的 logits，把候选标签对应的 token id 挑出来，做一次局部 softmax 归一化。这也是过往做约束输出和意图路由时的常用方法。

# 你不需要重写注意力机制，在开源小模型上就能跑
logits = model(input_ids).logits[:, -1, :]
candidate_logits = logits[:, candidate_token_ids]
probs = torch.softmax(candidate_logits, dim=-1)

第二条路径是基于 NLI（自然语言推理）的交叉编码器。 把输入上下文当作前提（premise），候选动作当作假设（hypothesis），分类头直接输出蕴含、中立、矛盾的三分类得分，取蕴含概率做决策。

如果单次前向每次只能评估一个选项，面对高并发多选项依然不够快。Jev 靠的是 Decoder-only 架构的 KV Cache 前缀缓存共享：长文本上下文在 Prefill 阶段只算一次并驻留显存，后续几十个候选共享同一份前缀缓存指针，只并行算各自那少量 token 的注意力。评估几十个维度的总耗时，因此几乎等同于单次评估。

那普通小模型为什么不能直接套这套逻辑？因为 Softmax 输出的分数只是指数归一化的相对值，不等于真实概率。未经专门校准的模型普遍严重过度自信——即使预测完全错误，Softmax 也可能给出 0.99。

这正是 RLCD（Reinforcement Learning for Calibrated Decisions）要解决的问题。它优化的不是"回答像不像人"，而是预期校准误差（ECE）：通过样本校验与惩罚，让模型输出 0.8 的置信度时，在统计上真实对应约 80% 的准确率。

这一点必须要说清楚：校准是群体口径。 官方文档自己写着——校准是跨一组预测衡量的，不保证任何一条具体答案正确。一组被标为约 90% 置信度的预测，长期平均正确率可以接近九成；这不代表你手上这一条有九成把握。

有人会问：那这和 2018 年的 BERT 分类器有什么区别？区别在底座的常识储备和上下文容量。BERT 的窗口通常只有 512 token、词表小，读不了长代码、系统日志和长业务文档；Jev 站在现代因果 Transformer 底座上，具备现代语义理解能力，只是摘掉了自回归生成那一段。r/LocalLLaMA 上有个说法很传神：

它就是 BERT 式架构，只是配上了现代 LLM 的数据、算力和训练配方。

另一个配套的观点是：最接近的老东西是 NLI 零样本分类，区别在于 NLI 每个标签跑一次前向、分数不可比，而 Jev 一次并行给出完整分布。

接进系统：四步，和最容易踩空的那一步

Jev 最容易被用错的地方，是把它当成"另一个通用模型"。真正合适的接法是这样的：

第一步，只给它当前判断需要的 state。 工单分类就放客户消息、订单状态和已有标签，不要把几万字的对话历史整个塞进去。创始人专门在 X 上把这件事叫做 state engineering——判断的质量首先取决于你喂了什么，而不是模型多聪明。

第二步，把一个模糊的大问题拆成多个小问题。 不要问"接下来该怎么办"，而是分别问：转给哪个部门？客户是否在要求退款？紧急程度属于哪一级？这三项可以并行返回，代码只取相关的那几个。这也是官方推荐用法 speculative fan-out 的核心。

第三步，在代码里设置置信度阈值。 比如高于 0.9 才自动执行，中间区间异步记录并触发抽检，低于 0.6 转人工或交给更强的模型。这里有个必须钉死的认知：choice 和 score 返回的 confidence，是从概率分布算出来的集中程度指标，不等于"这次判断正确的概率"。阈值该设多高，只能拿自己的业务数据测——不能照抄任何示例数字。

第四步，把执行和验证留在代码里。 Jev 可以判断"该退款"，但真正调用退款接口之前，金额、权限、幂等性仍然要由代码检查。模型输出的只是一个概率，不是一个可以无条件执行的动作。

TypeSafe 为 coding agent 准备了一个官方 skill（typesafe-ai/skills，整个仓库只有一个 149 行的 SKILL.md，而且 8 月 25 日就建好了，比模型发布还早三周）。它做的三件事很能说明官方希望你怎样用它：

不写 API 手册，只给一张"什么任务读哪一页文档"的表
教 agent 拆需求——从应用"要展示什么、选择什么、改变什么"倒推需要哪些判断，而规则、计算、查表、执行全部留在代码里
纠正 LLM 时代的习惯——独立问题一次同问（包括投机性的）；confidence 只表示分布集中程度，不表示流程正确；问题和阈值常量放在同一个文件里

官方 FAQ 里还有一条很实在的提醒：如果你只是要选最优，直接取概率最高的那个就行，别到处设 confidence 阈值。

把这几条合起来，其实就是一条清晰的分工线：

确定性判断（文件存在吗？HTTP 200 吗？exit code 是 0 吗？）→ 写在代码里
语义闭集判断（这是哪类任务？该调哪个工具？风险几档？完成了吗？）→ 交给 Jev
开放式推理与生成（怎么拆任务？代码怎么改？报告怎么写？）→ 交给大模型
最终授权（删文件、发邮件、花钱）→ 交给人

四种设计模式

社区把 Jev 在真实工程里的用法收敛成了四种模式，比任何特性列表都好用。

推测性扇出。 面对一份几千字的工单，系统往往要同时提取多个维度的标签。用传统大模型挨个提问，耗时和费用线性增加；用前缀缓存共享，长文本只做一次 Prefill，十几个离散问题并发挂载在同一份缓存上，总耗时接近单次评估。前提是子问题在语义上相对独立——如果问题 B 依赖问题 A 的结果，就不能放进同一批。

置信度门控。 让答案决定动作，让置信度决定自动化等级：高于 0.9 直接执行；0.6–0.9 暂缓执行、异步记录并抽检；低于 0.6 转人工。高并发内容审核是典型场景——绝大多数确信合规或确信违规的内容瞬间处理，只有模糊地带进人工池。前提是模型在你的业务分布上校准可靠，阈值还要根据误杀和漏放的容忍度定期调整。

复合评分。 很多团队想让模型直接输出一个百分制综合评分，这种做法通常不稳定，细微的 prompt 扰动就能让分数剧烈漂移。更稳的做法是只让模型对单一维度打 0–10 的离散分，加权公式和安全硬规则全部交给后端确定性代码。策略变了只改本地权重，不用重新调提示词。

分层分类。 标签数量到几百上千个时，一次性塞进枚举列表会导致注意力稀释（而且还有 255 个选项的上限）。分层做法是先在顶层大类里选出 top-2 分支，再沿胜出的大类细化到二级子类，逐级剪枝。建议每层保留 2–3 个候选，避免早期误剪枝导致后续全部走偏。

社区已经拿它做了什么

发布 72 小时里长出来的东西，本身就是一种信号。挑几个有原始数据的看：

玩游戏。 最出圈的是 Doom：模型每秒大约做 10 次判断，持续读取游戏状态并选择射击、躲避、找补给，官方估算成本约 7 美元一小时。社区还做了 typesafe-mario——把 NES 内存解析成 JSON，一个 choice 选手柄动作、一个 noul 判断"现在跳有没有用"、一个 score 估计眼前的危险程度，每 8 帧决策一次。

但这里有个容易忽略的前提：喂给模型的是结构化的游戏状态（敌人坐标、距离、角度），不是画面。 官方也承认，专用的传统游戏机器人可以玩得更好。这个 demo 真正证明的是吞吐和低延迟，不是规划能力——真正执行动作、读地图、检查结果的仍然是外部代码。

浏览器 Agent。 Browser Use 的 jev-ultrafast 把浏览器动作空间做成"操作 + 目标"两组 choice，一次网络往返出两个决策，默认循环里不再截图，只有要输入文本时才调一个小语言模型。它给的独立测量是：浏览器协议调用从 1092 次降到 101 次，同一个 Google Flights 搜索任务的中位耗时从 9.45 秒降到 7.07 秒（约 −25%）。注意这个数字比官方口径的"快 25 倍"小了一个数量级——这就是真实工程里的样子。

框架集成。 LangChain 的 TypeSafeClassifier 可以直接 .invoke(state, questions)；值得看的是它另外提供的两个 middleware——ModelRouterMiddleware（用 Jev 判断这次请求交给便宜模型还是强模型）和 AutoModeMiddleware（执行前判断工具调用有没有风险）。Vercel 的 agent 框架 eve 也把模型路由做成了默认能力。

安全网关。 pi-warden 拦截 Agent 运行时的文件覆写和终端命令，替代传统关键词黑名单；pi-jev-auto-mode 用 Jev 做 bash / write / edit 调用的语义审批，无法判定时默认阻断。这类"执行前的守卫"是 Jev 最稳的用法之一。

上下文压缩。 fast-jev-compaction 把 Jev 引入 coding agent 的 compaction 流程，把"这条工具调用还有用吗"变成一组并行 noul 问题，保留的内容仍是原文。这个项目得到了 Jev 开发者的认可。

生态规模。 GitHub 上的 yibie/awesome-jev 和 yzfly/awesome-jev-zh 收了四十多个项目；V2EX 上有人把 433 个使用 Jev 的开源项目整理成了可检索目录。复现项目从 151M 的 ModernBERT、69M 的自研紧凑网络，一直到 Qwen3.5-35B MoE，各有取舍——比如 heman10x/rlcd-modernbert-151m 支持 25 个候选槽位、延迟小于 35ms，专门适配边缘推理。

顺便说一句：仓库数量不是成熟度指标。 那两个 awesome 列表自己就声明，收录不代表验证过代码质量、安全性、能不能跑通、报告结果能不能复现——一个漂亮的 README 完全可能出现在任何真实评测之前。

那个做交易机器人的，亏了 31,680 美元

上面几个案例都在讲 Jev 能做什么。但最该看的一个，是它做不到什么。

一位开发者用一晚加一个上午搭了个自动交易机器人，让 Jev 持续读取链上、链下数据并选择买入或卖出。界面很流畅，概率输出也很"像回事"，然后作者报告的结果是：亏损 31,680 美元。

它把边界展示得比任何成功案例都清楚：低延迟只能让决策更快地执行，补不上策略、风控和因果判断。 付款、交易、删库这类不可逆动作，不能把模型概率直接接到执行接口上——至少要有仓位上限、止损、回测、模拟盘和人工批准。

这里有一个出自官方 HN 评论区的细节值得一起记住：创始人自己承认，模型完全可能自信地犯错，而且未来所有更聪明的模型仍然会有这种可能。

官方数字、独立实测，和它们之间的差距

这部分是全文最该慢慢读的地方。

先说官方口径。 除了前面提到的价格和延迟，官方给出的工作流准确率是 67.8%，对照 GPT-5.6 Terra 的 67.9%——也就是说水平接近而非超越，只是成本是它的 1/76。类型错误率 0%。

再说独立实测。 综合几组可查证的数据：

测试者	方法与样本	结果
Every.to（Mike Taylor）	37 篇文档 × 21 个问题同问，单组 777 次判断	单组 < 0.7 秒、约 1/4 美分；逐段评估中位 0.35 秒，对照模型 8.83 秒；故意植入的 7 处缺陷检出 6 处，漏 1 处
Browser Use `jev-ultrafast`	同任务交替运行 6 次，比较新旧 harness	中位耗时 9.45s → 7.07s（约 1.34 倍）；协议调用 1092 → 101 次
Archer Hume	对官方接口发起上万次压测	长文本从 360 token 增到近 30,000 token，中位延迟 57.5ms → 218ms；并发问题从 1 增到 100，延迟稳定在 70–100ms，到 1,500 个时升到 610ms
VerySmallWoods	自己搭 Playground 走 Vercel AI Gateway	上游 210–340ms，端到端 350ms–1s；海外直连官方 API 则要 1.6–3.7 秒
SamuelSacco 独立审计	HTTP 契约、并行批处理、延迟、准确率	契约和并行属实；倍数"属实但夸大"（官方 20–400 倍，独立测得 5–25 倍）；“不会幻觉"不成立；校准无法验证

把这些摆在一起，结论其实很干净：

便宜和快是真的，但倍数取决于你拿什么当对照。官方 193.6× / 444.6× 的通用速度优势，目前没有独立的复现；可查证的量级是"成本极低 + 部分场景耗时下降约 25%"。
延迟的可预测性可能比绝对值更重要。LLM 的端到端延迟是一个跨越两个数量级的区间（3–329 秒），而 Jev 是 70–500 毫秒。对工程系统来说，这比"快多少倍"更值钱。
准确率和中档模型持平，落后于推理模型。官方自己的 67.8% 就是这个意思。
校准目前没有公开验证。官方说做了 RLCD，但没有公开校准曲线；社区有人用裸 Qwen2.5-7B 的 logits 做对照，和 TypeSafe 工作流参考答案的一致性只有 73.8%，而 Jev 是 86.6%——更重要的是，那个未校准的 Qwen 在预测错误时，Softmax 置信度仍然经常高于 0.90。

社区测出来的三种偏差

除了"准不准”，还有三种更隐蔽的行为偏差，值得在接入前心里有数。

无关选项会干扰结果。 在既有的四个有效选项后追加一个完全无关的"天气"选项，原有业务选项之间的优势 log-odds 会明显下滑。这说明候选项之间并非完全独立打分——底层全量注意力会让候选池内部产生竞争，无关选项也在参与注意力分配。对统计分布要求严格的场景，候选集要做严格清洗。

选项的物理顺序会影响判断。 因为自回归模型的单向注意力，排在后面的 token 能看到前面所有上下文。把判断依据从选项列表末尾移到开头或中间，正确率会明显下滑。实践建议是：依据能放进共享的 state 就放 state；只能放选项时，放列表末尾。

单步前向做不了多层因果推理。 一个专门测钓鱼邮件识别的基准发现，面对包含多层转折和伪造身份的诱骗邮件，带思维链的 Claude Haiku 判定准确率明显优于 Jev，Jev 漏判更多。原因很朴素：计算路径被压缩成了一次矩阵乘法，而大模型依赖自回归逐步构建中间逻辑。一旦语义欺骗嵌套超过两层，单步打分就力不从心。

这一点在德州扑克实测里被展示得最清楚。作者用 GTO 求解器（8 分钟、7.6 GB、0.59% 可被剥削度）算出标准答案，再把牌桌状态交给 Jev：一个明明该过牌的顺子牌面，Jev 16 次运行 16 次全部选择全下；直到把"对手手牌 = 同花 A 高"“我方当前落后"“我方 0 张补牌"这类已经得出结论的字段写进 state，它才改判为过牌。

作者的总结值得直接引下来：它不"算牌”，它只"读你写好的结论”。

「Jev 不会幻觉」这句话只能信一半

官网上最醒目的一句宣传是 Zero Hallucinations，配图给出的工具调用类型错误率是 0%。

准确的含义是：模型的输出分布永远定义在你给的 criteria 上，所以它不可能编造字段、编造选项、编造 JSON。这是结构与类型层面的保证。

它不包含的，是判断本身正确。Jev 完全可以在你给的选项里高置信度地选错。Hacker News 上这条反驳最典型：

Sure, it can’t emit an invalid type, but it can still emit a completely wrong valid value…

它可以不输出非法类型，但它完全可以输出一个完全错误的合法值。

创始人在 HN 评论区正面回应过这个争论。当有人指出"用约束解码就能让 LLM 做同样的事"时，他的回答是：constrained decoding 会让模型变笨——因为如果一个模型会给非法 token 分配概率，它本身就是糊涂的。这个回应在技术上有它的道理（结构化输出确实会损失一部分 LLM 能力），同时也意味着：Jev 的价值不在"不会错"，而在结构天生就在，不需要拿模型能力去换。

所以更准确的说法是：它保证了接口，不保证真相。

顺带一提，TypeSafe 不发布标准基准这件事，到这里也显出两面性：它避免了被榜单绑架，代价是你没有任何外部参照物可以外推。想判断它行不行，只能自己测。

别人是怎么写 Jev 的

这几天中文和英文圈都出了不少解读。它们角度差得很远，合起来看反而比任何单篇都完整。

中文圈里最硬核的是知乎那篇《万字长文解读 Jev 模型：毫秒级判定原理与工程应用边界》。 它的核心价值是把底层路径讲透了：两条社区复现路线（logits 掩码投影 / NLI 交叉编码器）、KV Cache 前缀共享为什么能让"几十个候选 ≈ 一次评估"、以及 Archer Hume 的压测数据。它还给出了四种设计模式和一套成本测算——按日均 10 万次请求、80% 能在前置判别层分流的假设，推理费用能降近 80%。需要留意的是，它引用的两条复现路径是社区逆向的思路，不是官方公布的架构。

51CTO 的《Jev详细解读：一个不说人话、只做决策的模型》视角是"它比 LLM 放弃了什么"，两个细节最有价值：一是点破了官方评测的参考答案来自 GPT-6 Astra 和 Claude Fable 5.1 的输出汇总，所以那组数字反映的是与参考模型的一致性，而不是独立准确率；二是 Doom 演示喂的是结构化游戏状态，不等于它会看画面。它最后的判断也克制：概念上并不全新，GLiNER 这类零样本分类器、各家 API 的结构化输出和约束解码都在逼近同一个方向；新的是"专用架构 + 专用训练方法 + 专用托管"这个组合。

封楚寒的《Jev 模型初探》是这几篇里最"学术"的。 作者很诚实地声明是 AI 辅助整理、自己没实测，然后把三条研究线索接了上来：Guo 等 2017 年那篇 On Calibration of Modern Neural Networks（ECE 怎么算、温度缩放到底改了什么）、Damani 等的 Beyond Binary Rewards（RLCR 的奖励函数 R = c − (q−c)²，以及它为什么在期望意义下鼓励报告真实概率）、以及 SelectiveNet 的 coverage / selective risk。它还提了一个很实用的缩写陷阱：2023 年已经有一篇 RLCD 叫 “Reinforcement Learning from Contrastive Distillation”，和 TypeSafe 的 “Reinforcement Learning for Calibrated Decisions” 不是一回事。 并且明确说：截至 9 月 18 日，找不到 Jev 或 RLCD 的公开论文——现有资料不足以重建它的算法。

VerySmallWoods 的《Jev 实测》是少见的真自己跑数据的中文实测。 作者搭了个 Playground（tryjev.xyz）跑了五个场景——一句话一个概率、五问并发的工单分诊、矛盾和乱码、模型路由、内容审核与 LLM 输出把关——并且把数字分成"官方宣称 / 独立实测 / 自己测出来"三层摆开。最有信息量的一段是它对独立审计结论的四分类：属实 / 属实但夸大 / 不成立 / 没法验证。它自己那句话总结得最好：便宜和快是真的，倍数看你拿什么比；类型安全是真的，但那是格式安全，不是答案正确；概率有没有校准，得拿自己的标注数据去验。

AIHubPlus 那篇《实测解析》虽然作者也声明"非一手实测"，但二次核对做得相当规范。 它把官方自报表和第三方实测表并排放，敢标 [待补证]，也敢写"需要更正的旧说法"——比如明确指出第三方实测并没有复现“快 25 倍"这类数字。它还挖出了几个别处看不到的细节：Jev 名字来自杰文斯悖论（官方 FAQ）、TypeSafe 不发布标准基准、以及 HN 上关于"能不能说不会幻觉"的原帖争论和创始人回应。

英文圈里被转得最多、也最不客气的是 Sean Goedecke 的《Jev means structured output is interesting again》。 核心三点：① 快的结构化输出现在就能做——他用 Qwen2.5-1.5B 自己做约束解码（只生成一个受限 token + 预填充）就拿到了 2–3 倍加速，据此推测 Jev 未必有技术护城河；② 它没有思维链、没有测试时计算，智能上限可能被锁死在"非推理 LLM"的水平，别指望它 scaling 出新智能；③ “零幻觉"是一种语义上的回避。

Every.to 的 Mini-Vibe Check 是媒体侧做得最实的一次：37 篇文档 × 21 个问题、单组 777 次判断，故意植入的 7 处缺陷检出 6 处，作者的结论是"快与便宜站得住，准确率够用但不完美”。

backnotprop 的德州扑克实测（前面提过）是目前公开资料里扎得最深的一篇独立测评，它的价值在于同时给出了反例和方法论：在 150 个决策点里，求解器自己就有 95 个点选择过牌，所以一条不用模型的"能过牌就过牌"一句话规则在全部点位上拿到 72%——这个数字大部分来自样本偏斜；但在真正有争议的 55 个点上，那条规则只有 24%，而 Jev 是 38%。

如果只想读两篇，我建议：想要工程落地细节看知乎那篇万字长文，想要独立证据看 VerySmallWoods 和 AIHubPlus 这两篇。 想要一台现成的 Playground，tryjev.xyz 可以直接用（key 存在浏览器本地）。

顺带一提：有人用一个小模型复刻了它的形式

Jev 刚发布，社区里就有人用 0.8B 级别的小模型在本地复刻了一个"视觉版 Jev”（jev-visual，用 Qwen3.5-0.8B + MLX 在 Mac 上跑）。做法是：图片和公共上下文只计算一次，然后批量读取各个候选答案对应的分数，最后交给代码组装结果。这样就绕开了"Jev 目前只能吃文本"的限制，能看着图片做选择、判断和打分。

作者自己也叠了甲：这只是在 inference 层对 Jev 的形式做的一次小复现，不是 Jev 的原理，效率也远不如成熟的推理框架。

但这恰恰说明了一件事：Jev 的形态并不是什么黑魔法。“不做逐字生成，直接读候选的概率”——这个动作本身，任何会用 logits 的人都能在自己的场景里近似出来。真正难的是把概率校准好，以及在系统层面把判断和执行干净地切开。

这也正好呼应了 Goedecke 那个不太好听但可能成立的判断：如果形式可以复刻，那壁垒就不在形式，而在训练配方和托管工程。

几点收获

第一，难的从来不是模型多聪明，而是问题能不能被拆成边界清楚的小决定。 让 Jev 去回答"接下来该怎么办"会得到垃圾；把它拆成"转给哪个部门"“是否要退款"“紧急程度几级”，它就很好用。拆分这一步是人做的，模型帮不上忙——官方自己也承认，难点从写提示词变成了设计决策的模式。

第二，“生成文字"和"做判断"本来就是两个不同的工程问题。 把它们混在一次调用里，代价是解析、格式漂移和多余的 token；分开之后，两边都能做得更好。Jev 占的就是这个位置。

第三，置信度只有配上阈值和兜底才有意义，而且它从来不是"正确率”。 校准是群体口径，不是单条保证。一个 0.82 的 confidence 单独看毫无价值，它必须在代码里对应到"自动执行 / 升级 / 转人工"的某一条分支上才算被用上了。顺便记住官方 FAQ 那句：只是要选最优的话，直接取概率最高的，别到处设阈值。

第四，低延迟会放大错误。 当一次错误的判断能在几十毫秒内被自动执行无数次时，速度就成了一种风险。不可逆操作前面，必须有人或者确定性代码守着。那个亏了 31,680 美元的交易机器人，就是这句话最贵的注解。

第五，看到厂商口径的数字要看清测量方式。 193.6 倍、0.23 秒、67.8%——这些数字都真实，但它们各自有各自的样本、参考答案和对照条件。和自己的历史流量跑一遍，永远比抄一个基准可靠。

第六，一个真正值得关注的信号，是它火的速度和方式。 发布 72 小时里长出了 400 多个项目、两个 awesome 列表、一个可检索目录，LangChain 和 Vercel 都在第一周就跟上了集成。不管 Jev 本身最终成不成，“把判断从生成里剥出来"这个方向已经被生态验证了一次——而这可能是比"Jev 会不会取代 LLM"更值得关心的问题。

大模型结构原理与代码实现

Mon, 31 Mar 2025 14:35:25 +0800

Transformer 模型原理和代码实现
GPT系列模型

参考：

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

Transformer 模型原理和代码实现教程

一、Transformer 模型简介

Transformer 是一种基于注意力机制的深度学习模型，由 Vaswani 等人在 2017 年的论文《Attention is All You Need》中提出。它抛弃了传统 RNN 的循环结构，完全依赖自注意力机制实现序列建模，广泛应用于 NLP 和其他领域。

二、Transformer 模型结构

1. 整体架构

Transformer 由编码器和解码器组成，通常堆叠 6 层，用于序列到序列任务。

上图展示了编码器和解码器的堆叠结构及数据流向。

2. 编码器（Encoder）

每个编码器层包含：

多头自注意力机制
前馈神经网络
加上残差连接和层归一化。

3. 解码器（Decoder）

解码器多了掩码自注意力，用于防止未来信息泄露。
上图详细展示了编码器和解码器层的子模块及连接方式。

4. 输入嵌入与位置编码

\[ PE_{(pos, 2i)} = \sin(pos / 10000^{2i/d_{model}}) \]\[ PE_{(pos, 2i+1)} = \cos(pos / 10000^{2i/d_{model}}) \]

三、自注意力机制（Self-Attention）详解

1. 计算过程

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

上图展示了自注意力的计算步骤。

2. 多头机制

将注意力分成多个子空间并行计算，最后拼接结果。

四、代码实现（基于 PyTorch）

以下是简化的编码器实现：

import torch
import torch.nn as nn
import math

# 位置编码
class PositionalEncoding(nn.Module):
 def __init__(self, d_model, max_len=5000):
 super(PositionalEncoding, self).__init__()
 pe = torch.zeros(max_len, d_model)
 position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
 div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
 pe[:, 0::2] = torch.sin(position * div_term)
 pe[:, 1::2] = torch.cos(position * div_term)
 pe = pe.unsqueeze(0)
 self.register_buffer('pe', pe)

 def forward(self, x):
 return x + self.pe[:, :x.size(1), :]

# 多头自注意力
class MultiHeadAttention(nn.Module):
 def __init__(self, d_model, num_heads):
 super(MultiHeadAttention, self).__init__()
 assert d_model % num_heads == 0
 self.d_k = d_model // num_heads
 self.num_heads = num_heads
 self.q_linear = nn.Linear(d_model, d_model)
 self.k_linear = nn.Linear(d_model, d_model)
 self.v_linear = nn.Linear(d_model, d_model)
 self.out_linear = nn.Linear(d_model, d_model)

 def forward(self, q, k, v, mask=None):
 batch_size = q.size(0)
 q = self.q_linear(q).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
 k = self.k_linear(k).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
 v = self.v_linear(v).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
 scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.d_k)
 if mask is not None:
 scores = scores.masked_fill(mask == 0, -1e9)
 attn = torch.softmax(scores, dim=-1)
 context = torch.matmul(attn, v)
 context = context.transpose(1, 2).contiguous().view(batch_size, -1, self.num_heads * self.d_k)
 return self.out_linear(context)

# Transformer 编码器层
class EncoderLayer(nn.Module):
 def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
 super(EncoderLayer, self).__init__()
 self.self_attn = MultiHeadAttention(d_model, num_heads)
 self.ffn = nn.Sequential(
 nn.Linear(d_model, d_ff),
 nn.ReLU(),
 nn.Dropout(dropout),
 nn.Linear(d_ff, d_model)
 )
 self.norm1 = nn.LayerNorm(d_model)
 self.norm2 = nn.LayerNorm(d_model)
 self.dropout = nn.Dropout(dropout)

 def forward(self, x, mask=None):
 attn_output = self.self_attn(x, x, x, mask)
 x = self.norm1(x + self.dropout(attn_output))
 ffn_output = self.ffn(x)
 x = self.norm2(x + self.dropout(ffn_output))
 return x

# 测试
d_model, num_heads, d_ff, seq_len, batch_size = 512, 8, 2048, 10, 2
encoder_layer = EncoderLayer(d_model, num_heads, d_ff)
x = torch.randn(batch_size, seq_len, d_model)
output = encoder_layer(x)
print(output.shape) # torch.Size([2, 10, 512])

GPT系列模型

从GPT-1到GPT-4，GPT系列模型详解

GPT 模型介绍

作为面试官，您好！下面我将从定义、历史发展、架构原理、工作机制、应用场景以及优缺点等方面，系统地介绍 GPT（Generative Pre-trained Transformer）模型。这是一个由 OpenAI 开发的生成式预训练 Transformer 模型系列，是当今大语言模型（LLM）的代表作之一。我会尽量保持简洁明了，如果您有特定焦点（如某个版本），可以进一步追问。

1. 什么是 GPT 模型？

GPT 是一种基于 Transformer 架构的深度学习模型，专为自然语言处理（NLP）设计。它能够理解和生成人类般的文本，通过预测序列中的下一个词（token）来实现“生成”功能。核心理念是“预训练 + 微调”：先在海量无标签数据上预训练模型学习语言模式，再针对特定任务微调。

2. 历史发展

GPT 系列从 2018 年起步，已迭代至 2025 年的 GPT-5，每代模型参数规模和能力大幅提升。以下是关键版本的简要比较（使用表格便于查看）：

版本	发布年份	参数规模	关键创新与特点
GPT-1	2018	1.17 亿	首次引入生成式预训练 Transformer，奠基架构；主要用于文本生成基准测试。
GPT-2	2019	15 亿	参数增加 10 倍，支持更连贯的文本生成；因潜在滥用风险，OpenAI 延迟完整发布。
GPT-3	2020	1750 亿	革命性规模，支持零样本/少样本学习；ChatGPT 的基础，推动 AI 应用爆发。
GPT-4	2023	未公开（估超万亿）	多模态支持（文本+图像）；更强推理能力，集成于 Bing 等产品。
GPT-5	2025	未公开（更大规模）	进一步提升多模态和实时交互；聚焦安全与效率优化。

这一演进反映了从简单生成向复杂智能的转变，受 Transformer 论文（2017 年）启发。

3. 架构原理

GPT 基于 Transformer 的解码器（Decoder-only）架构，主要组件包括：

自注意力机制（Self-Attention）：允许模型并行处理序列，捕捉长距离依赖（如句子上下文）。
多头注意力（Multi-Head Attention）：多个注意力头并行工作，提升表示能力。
前馈网络（Feed-Forward） 和 层归一化（Layer Normalization）：用于非线性变换和稳定训练。
位置编码（Positional Encoding）：处理序列顺序信息。

整体结构是堆叠多个 Transformer 块，输入文本被转化为 token 嵌入（Embedding），输出是概率分布，用于预测下一个 token。例如，输入“今天天气”，模型会计算每个词的上下文权重，生成“很好”作为续接。

4. 工作机制

预训练阶段：在互联网规模的文本语料（如 Common Crawl）上，使用无监督学习（掩码语言建模或因果语言建模）训练。目标：最大化预测下一个词的似然。
微调阶段：使用监督数据（如问答对）调整模型，适应下游任务（如翻译、摘要）。
推理过程：给定提示（Prompt），模型自回归生成（Autoregressive），逐步输出 token，直到结束符。

5. 应用场景

GPT 已广泛应用于：

内容生成：写作助手、代码补全（e.g., GitHub Copilot）。
对话系统：ChatGPT、客服机器人。
多模态任务：图像描述、语音转文本（GPT-4 后扩展）。
其他：教育（个性化学习）、医疗（辅助诊断）、娱乐（故事创作）。

6. 优势与局限

优势：生成流畅、自然；泛化强，支持零样本学习；开源部分模型促进生态。
局限：易产生“幻觉”（虚假信息）；训练成本高（能源消耗大）；潜在偏见（继承训练数据偏差）；隐私与伦理风险。

总之，GPT 模型标志着 AI 从规则驱动向数据驱动的范式转变，推动了生成式 AI 的普及。到 2025 年，它已成为行业标准，但也引发了对 AI 安全的讨论。如果您想深入某个方面（如代码实现或未来趋势），我可以扩展！

Llama

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

Llama (拉玛) 是由 Meta (前 Facebook) 开发的一系列大型语言模型 (LLM) 的总称。自推出以来，它因其强大的性能和相对开放的许可政策，对整个人工智能领域产生了巨大影响。

以下是 Llama 系列模型的主要特点：

核心特点

开放性（“社区许可”）：
- 这可能是 Llama 最显著的特点。与 GPT-4 等闭源模型不同，Meta 向公众发布了 Llama 模型的权重（尤其是 Llama 2 和 Llama 3），并提供了“社区许可”。
- 这意味着研究人员、初创公司和大型企业（在一定限制内，例如月活用户超过7亿的公司需要额外许可）都可以免费使用、修改和分发这些模型及其衍生品，极大地推动了 LLM 领域的创新和应用普及。
高性能与高效率：
- Llama 系列模型在各种规模（例如 8B、70B、405B 参数）上都表现出了与顶级闭源模型相竞争甚至超越的性能。
- 它们在推理、编码、常识推理和问答等标准基准测试中得分很高。
- Llama 的设计注重效率，使其在同等性能下所需的计算资源相对较少，更容易部署。
先进的架构：
- Llama 采用的是“仅解码器”（decoder-only）的 Transformer 架构，这是当今主流 LLM 的标准配置。
- 不过，它也包含了一些关键的架构改进，使其区别于早期的模型（如 GPT-3）：
  - SwiGLU 激活函数：代替标准的 ReLU，以提高性能。
  - 旋转位置编码 (RoPE)：使用相对位置编码来更好地处理序列中Token的相对关系，有助于提升长文本理解能力。
  - RMSNorm 归一化：使用均方根层归一化 (Root Mean Square Layer Normalization) 来代替标准 LayerNorm，以提高训练稳定性和效率。

主要版本演进

Llama 系列在不断迭代，每一代都在性能、功能和训练数据上进行重大升级：

🐐 Llama 1 (2023年2月)

定位：基础研究模型。
特点：最初仅以非商业许可形式提供给研究社区。它证明了在相对“较小”的规模（最大 65B 参数）上，使用海量的、高质量的数据（1.4 万亿个 Token）进行训练，可以达到顶尖的性能。它的发布意外地“泄露”并引爆了开源 LLM 社区。

🐐🐐 Llama 2 (2023年7月)

定位：首个可商用版本。
特点：
- 社区许可：正式开放给商业和研究使用。
- 更大的训练数据：在比 Llama 1 多 40% 的数据上进行预训练。
- 更长的上下文窗口：上下文长度翻倍，达到 4,096 个 Token。
- 强化的人类反馈 (RLHF)：Llama 2-Chat 版本经过了严格的监督微调 (SFT) 和基于人类反馈的强化学习 (RLHF)，使其在对话、遵循指令和安全性方面表现更佳。

🐐🐐🐐 Llama 3 (2024年4月)

定位：当前一代的旗舰模型。
特点：
- 卓越的性能：目前发布的 8B 和 70B 版本，在其同等规模上被认为是性能最强的开放模型，其性能可与 GPT-4 等顶尖闭源模型的中等版本相媲美。
- 海量训练数据：在一个超过 15 万亿 (15T) Token 的庞大数据集上进行训练，数据质量也经过了严格筛选。
- 更强的多语言能力：训练数据中包含超过 5% 的非英语高质量数据，覆盖 30 多种语言，显著提升了其多语言处理能力。
- 更大的上下文窗口：基础上下文窗口增加到 8,192 个 Token，并且有能力扩展到更长（例如 Llama 3.1 405B 版本支持 128K 上下文）。
- 未来的多模态：Meta 已经宣布 Llama 3 将具备多模态能力（理解图像和文本），未来版本（如传闻中的 Llama 4）将集成文本、图像和可能的音频输入。

deepseek

DeepSeek（深度求索）是一家成立于2023年的中国人工智能公司，正迅速成为全球AI领域的重要力量。与 Llama 类似，DeepSeek 以其高性能、模型开源和极具竞争力的成本而闻名，其重点是开发顶尖的通用人工智能（AGI）基础模型。

DeepSeek 的特点可以从其公司理念和其多样化的模型系列中看出来。

核心理念与特点

开源与开放：
- DeepSeek 效仿 Llama 2 和 Llama 3，将其许多强大的模型（包括模型权重）开源，供研究和商业使用。这极大地推动了AI社区的发展，允许开发者在他们的模型基础上进行构建和微调。
高性能与高效率：
- DeepSeek 的模型在各大AI性能排行榜（如 LLM 排行榜）上经常名列前茅，其性能在同等规模下可与全球顶尖的闭源模型（如 OpenAI 的 GPT 系列）和开源模型（如 Llama 系列）相媲美。
专注于“效率”与“智能”：
- DeepSeek 不仅追求模型“大”，更追求“高效”。他们率先在开源社区推出了先进的 MoE（Mixture-of-Experts，混合专家） 架构。这种架构允许模型在推理时只激活一部分“专家”参数，而不是全部参数，从而在保持极高性能的同时，大幅降低了推理成本和速度。
技术垂直细分：
- 与 Llama 相对统一的系列不同，DeepSeek 推出了一系列针对特定任务深度优化的模型家族，每个家族都有其独特专长。

DeepSeek 的主要模型系列

DeepSeek 并不是单一的模型，而是一个包含多个专业分支的大家族。

1. 旗舰通用模型 (DeepSeek-V3 系列)

这是 DeepSeek 目前的旗舰产品，对标 Llama 3 和 GPT-4。

架构：采用高效的 MoE 架构（如 V3.2-Exp 版本）。
特点：
- “Thinking Mode”（思考模式）：这是其API中的一个独特功能。用户可以选择是否开启“思考模式”（deepseek-reasoner），该模式下模型会调用更强的推理能力来处理复杂问题，而“非思考模式”（deepseek-chat）则响应更快，成本更低，适用于简单对话。
- 成本效益：由于采用了 MoE 和稀疏注意力（Sparse Attention）等技术，其 API 服务的价格极具竞争力，大幅降低了开发者使用高性能AI的门槛。
适用场景：复杂对话、内容创作、通识问答、API 集成。

2. 专项推理模型 (DeepSeek-R1)

这是一个专注于“推理”能力的模型家族，在逻辑、数学和编程问题上表现出色。

训练：通过大规模的强化学习（RL）进行训练，使其擅长解决需要逐步思考的复杂问题。
特点：在数学（MATH）、编程（HumanEval）和逻辑推理的基准测试中得分极高。
适用场景：数学解题、代码逻辑分析、科学推理、撰写技术文档。

3. 专项编码模型 (DeepSeek-Coder)

这是 DeepSeek 专门为程序员打造的模型系列，直接对标 Llama Code 和 GitHub Copilot。

训练数据：从头开始在海量代码数据（超过2万亿 Token，其中87%是代码）上进行训练。
特点：
- “Fill-in-the-Blank”（代码填空）：不仅仅是代码补全，还能根据上下文填充代码的中间部分，非常适合辅助编程。
- 多语言：支持包括 Python, Java, C++, JavaScript 在内的多种主流编程语言。
- 高性能：其 33B（330亿参数）模型在性能上超越了许多同类开源模型。
适用场景：编写代码、调试 Bug、学习编程、代码翻译。

4. 多模态模型 (DeepSeek-VL & DeepSeek-OCR)

这是 DeepSeek 的“视觉”分支，使其具备了理解图像和文档的能力。

DeepSeek-VL (视觉语言)：这是通用的视觉语言模型，可以像 GPT-4V 一样“看图说话”，理解图表、网页截图、照片等，并回答相关问题。
DeepSeek-OCR (光学字符识别)：这是一个更专业的模型，专注于从图像中提取文字。它能高效处理高分辨率文档，支持100多种语言，并能精确解析复杂的表格、数学公式和手写体。
适用场景：文档自动化、图表分析、图像内容问答、票据识别。

ICL-上下文学习

Wed, 12 Mar 2025 10:19:09 +0800

参考：

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

什么是上下文学习（ICL）？

上下文学习是指一种机器学习模型（尤其是大语言模型，LLM）在无需显式调整模型参数（即不进行传统意义上的微调）的情况下，通过提供任务相关的上下文信息（通常是输入中的示例或描述），就能完成特定任务的能力。这种能力通常出现在像 GPT 系列或类似的 transformer 模型中。

简单来说，ICL 是模型利用提示（prompt）中的信息“即时学习”的过程。它不需要通过梯度下降等方法重新训练模型，而是直接从输入的上下文中提取模式或规则，然后应用到新任务上。

ICL 的核心机制

提示（Prompt）的作用：
- 在 ICL 中，用户通过输入一段文字（即提示）来告诉模型任务是什么。例如，可以给模型几个示例（few-shot learning），或者直接描述任务（zero-shot learning）。
- 示例：如果你想让模型翻译句子，可以在提示中写：
```
翻译以下句子：
1. The cat is on the mat. -> 猫在垫子上。
2. I like to eat apples. -> 我喜欢吃苹果。
请翻译：The dog runs fast.
```
  模型会根据前面的例子推断出任务是翻译，并输出：狗跑得快。
无参数更新：
- 与传统的监督学习不同，ICL 不需要改变模型的权重。模型完全依赖预训练时学到的知识和提示中的上下文来推理。
灵活性：
- ICL 的一个显著特点是它对任务的适应性极强。只要提示设计得当，同一个模型可以处理多种任务，比如翻译、问答、文本生成等。

ICL 的类型

根据提示中提供的信息量，ICL 可以分为以下几种情况：

Zero-Shot Learning（零样本学习）：
- 模型只接收任务描述，没有具体示例。
- 示例：
```
将这句话翻译成中文：The sun is shining brightly.
```
  输出：太阳明亮地照耀着。
Few-Shot Learning（少样本学习）：
- 模型接收任务描述外加几个示例，帮助它理解任务。
- 示例：
```
翻译成中文：
1. The bird sings. -> 鸟儿在唱歌。
2. The flower blooms. -> 花儿盛开。
请翻译：The wind blows.
```
  输出：风在吹。
One-Shot Learning（单样本学习）：
- 介于两者之间，只给一个示例。
- 示例：
```
翻译成中文：The tree grows tall. -> 树长得很高。
请翻译：The river flows fast.
```
  输出：河水流得快。

ICL 的工作原理

ICL 的成功依赖于以下几个因素：

大规模预训练：
- 大语言模型在海量文本数据上预训练，积累了丰富的语言模式和知识。这些知识使得模型能够在提示中找到规律并应用到新任务。
注意力机制（Attention Mechanism）：
- Transformer 架构中的注意力机制让模型能够动态聚焦提示中的关键信息。例如，在 few-shot 示例中，模型会关注输入和输出之间的对应关系。
泛化能力：
- 模型通过预训练学会了泛化，即使面对全新的任务，只要提示足够清晰，它就能推断出正确的行为。

ICL 的优势

无需额外训练：
- 不需要为每个新任务准备标注数据或重新训练模型，节省时间和计算资源。
任务无关性：
- 一个模型可以处理多种任务，只需调整提示即可。
用户友好：
- 对于不懂机器学习的用户，只需提供自然语言描述或示例，模型就能工作。

ICL 的局限性

对提示敏感：
- 提示的质量和清晰度直接影响模型表现。如果提示模糊或不一致，输出可能不准确。
- 示例：如果提示是“翻译成中文：The cat”，但之前没说明任务，模型可能不知道是翻译还是其他操作。
上下文窗口限制：
- 模型能处理的上下文长度有限。如果提示太长，早期信息可能被忽略。
性能不如微调：
- 对于特定任务，ICL 的表现通常不如专门微调过的模型，尤其在数据量大时。

ICL 在实际中的应用

自然语言处理：
- 用于问答、文本生成、翻译、摘要等任务。
教育：
- 可以作为学习工具，帮助学生通过示例理解概念。
自动化：
- 在客服机器人、代码生成等领域，ICL 能快速适应新需求。

与传统学习的对比

特性	传统机器学习	上下文学习 (ICL)
训练方式	需要标注数据和微调	无需微调，依赖提示
任务适应性	任务特定	高度灵活
计算成本	高（训练阶段）	低（推理阶段）
用户门槛	高（需专业知识）	低（只需写提示）

总结

上下文学习（ICL）是大语言模型的一项强大能力，它让模型通过提示中的上下文“即时学习”并完成任务，而无需额外的训练。它的核心在于利用预训练知识和注意力机制，适用于零样本、单样本和少样本场景。虽然它对提示设计敏感且有上下文长度限制，但其灵活性和易用性使其在实际应用中非常有价值。

DeepSeek_NSA

Mon, 24 Feb 2025 00:00:00 +0000

DeepSeek-NSA

原文地址： https://arxiv.org/pdf/2502.11089

全文翻译

摘要

 Long-context modeling is crucial for next-generation language models, yet the high compu
tational cost of standard attention mechanisms poses significant computational challenges.
 Sparse attention offers a promising direction for improving efficiency while maintaining model
 capabilities. We present NSA, a Natively trainable Sparse Attention mechanism that integrates
 algorithmic innovations with hardware-aligned optimizations to achieve efficient long-context
 modeling. NSA employs a dynamic hierarchical sparse strategy, combining coarse-grained
 token compression with fine-grained token selection to preserve both global context awareness
 and local precision. Our approach advances sparse attention design with two key innovations:
 (1) We achieve substantial speedups through arithmetic intensity-balanced algorithm design,
 with implementation optimizations for modern hardware. (2) We enable end-to-end training,
 reducing pretraining computation without sacrificing model performance. As showninFigure 1,
 experiments show the model pretrained with NSA maintains or exceeds Full Attention models
 across general benchmarks, long-context tasks, and instruction-based reasoning. Meanwhile,
 NSAachieves substantial speedups over Full Attention on 64k-length sequences across decod
ing, forward propagation, and backward propagation, validating its efficiency throughout the
 model lifecycle.

Long-context modeling is crucial for next-generation language models, yet the high computational cost of standard attention mechanisms poses significant computational challenges. 对于下一代生成式语言模型而言，长文本建模至关重要，然而标准注意力机制的高计算成本带来了显著的计算挑战。

Sparse attention offers a promising direction for improving efficiency while maintaining model capabilities. 稀疏注意力为提高模型能力的同时提供了效率提供了路径。

We present NSA, a Natively trainable Sparse Attention mechanism that integrates algorithmic innovations with hardware-aligned optimizations to achieve efficient long-context modeling. 我们提出了NSA（Natively trainable Sparse Attention），一种原生可训练的稀疏注意力机制，它通过结合算法创新与硬件对齐的优化，实现了高效的长文本建模。

NSA employs a dynamic hierarchical sparse strategy, combining coarse-grained token compression with fine-grained token selection to preserve both global context awareness and local precision. NSA采用了一种动态分层稀疏策略，通过结合粗粒度的标记压缩和细粒度的标记选择，既保留了全局上下文感知能力，又确保了局部精度

Our approach advances sparse attention design with two key innovations: 我们的方法通过以下两项关键创新推动了稀疏注意力机制的设计： (1) We achieve substantial speedups through arithmetic intensity-balanced algorithm design, with implementation optimizations for modern hardware. (2) We enable end-to-end training, reducing pretraining computation without sacrificing model performance. (1) 我们通过算术强度平衡的算法设计以及针对现代硬件的实现优化，实现了显著的加速效果。 (2) 我们实现了端到端训练，在减少预训练计算量的同时不牺牲模型性能。

substantial 实质性的 speedups 加速效果 arithmetic 算术 implementation实现

As shown in Figure 1, experiments show the model pretrained with NSA maintains or exceeds Full Attention models across general benchmarks, long-context tasks, and instruction-based reasoning. 如图1所示，实验表明，使用NSA进行预训练的模型在通用基准测试、长文本任务以及基于指令的推理中，其性能维持或超越了全注意力机制模型。

Meanwhile, NSA achieves substantial speedups over Full Attention on 64k-length sequences across decoding, forward propagation, and backward propagation, validating its efficiency throughout the model lifecycle. 同时，NSA在64k长度序列的解码、前向传播和反向传播过程中，相较于全注意力机制实现了显著的加速，验证了其在整个模型生命周期中的高效性。

exceeds 超过 instruction-based 基于指令的 reasoning 推理

引言

这篇论文探讨了长上下文建模在下一代大语言模型中的重要性，并提出了一种名为 NSA（Native Sparse Attention） 的新架构，以解决传统注意力机制在处理长序列时的效率瓶颈问题。以下是论文的核心内容概述：

背景与挑战

长上下文建模的重要性：
- 长上下文建模在代码生成、多轮对话、复杂推理等实际应用中至关重要。
- 传统注意力机制（如全注意力）在处理超长序列（如64k tokens）时，计算复杂度和延迟显著增加，成为性能瓶颈。
现有稀疏注意力方法的局限性：
- 尽管已有多种稀疏注意力方法（如KV缓存优化、块级选择、哈希采样等），但它们在实际部署中往往无法实现理论上的加速效果。
- 现有方法主要关注推理阶段，缺乏对训练阶段的支持，难以充分利用注意力的稀疏性。

NSA 的创新点

为了解决上述问题，NSA 提出了两种核心创新：

硬件友好的系统设计：
- 通过分块稀疏注意力优化 Tensor Core 利用率和内存访问模式，确保计算强度均衡，从而将理论计算减少转化为实际速度提升。
支持训练的设计：
- 引入高效的算法和可微分的反向传播算子，使稀疏注意力能够在训练阶段稳定运行，同时降低训练成本。

NSA 的架构

（见图2）

NSA 的架构基于分层稀疏注意力，通过以下三个并行的注意力路径处理输入序列：

压缩粗粒度注意力：对先前的键值对进行压缩，捕捉全局模式。
选择性细粒度注意力：保留重要的 token 块，捕捉关键信息。
滑动窗口注意力：处理局部上下文信息。

这种设计显著减少了每查询的计算量，同时通过专用内核实现高效的实际性能。

实验结果

性能评估：
- 在通用语言任务、长上下文任务和链式推理任务中，NSA 的表现与全注意力基线相当甚至更优。
- 相比现有稀疏注意力方法，NSA 表现出更强的性能。
效率提升：
- 在 A100 GPU 上，NSA 在解码、前向传播和反向传播阶段均实现了显著加速，尤其是对于超长序列（如64k tokens），加速比进一步提高。

对稀疏注意力方法的再思考

这一部分标题为 “重新思考稀疏注意力方法”，深入分析了现代稀疏注意力技术的局限性，并提出了对一种新方法——原生稀疏注意力（NSA） 的需求。文章指出了两个关键挑战：高效推理 和 可训练稀疏性，并解释了为什么现有方法无法充分应对这些挑战。以下是详细总结：

2.1. 高效推理的幻觉

稀疏注意力方法通过选择性处理输入序列中重要的部分来减少计算复杂度。然而，许多方法未能将这种理论上的计算减少转化为实际推理过程中的延迟改进，主要原因有两个：

阶段受限的稀疏性：
- 一些方法（如 H2O）仅在 自回归解码阶段 应用稀疏性，但在 预填充阶段 需要进行昂贵的预处理步骤（如注意力图计算、索引构建）。
- 另一些方法（如 MInference）则专注于预填充阶段的稀疏性，但未优化解码阶段。
- 因此，这些方法无法在所有推理阶段实现加速，至少有一个阶段的计算成本与全注意力相当。这限制了它们在诸如书籍摘要（预填充密集型）或长链推理（解码密集型）等任务中的有效性。
与先进注意力架构的不兼容性：
- 现代架构（如 多查询注意力 MQA 和 分组查询注意力 GQA）通过在多个查询头之间共享键值（KV）缓存来提高效率。
- 许多稀疏注意力方法（如 Quest）为每个注意力头独立选择 KV 缓存子集，这种方法在多头注意力（MHA）模型中表现良好，但在基于 GQA 的模型中变得低效。在 GQA 中，内存访问量对应于同一组内所有查询头选择的并集，导致尽管计算减少了，但内存访问成本仍然很高。
- 这种稀疏注意力方法与先进架构之间的不匹配导致性能不佳。

关键要点：现有的稀疏注意力方法往往无法显著减少延迟，因为它们要么是阶段受限的，要么与现代架构不兼容。

2.2. 可训练稀疏性的神话

虽然稀疏注意力方法在推理中表现良好，但在支持高效训练方面却面临困难。主要存在两个问题：

性能下降：
- 在预训练后应用稀疏性（即后处理稀疏化）会迫使模型偏离其原始优化轨迹。例如，剪枝前 20% 的注意力得分只能覆盖总注意力的 70%，使得预训练模型中的某些结构（如检索头）在推理时变得脆弱。
- 这种不匹配导致从全注意力切换到稀疏注意力时性能下降。
训练效率需求：
- 在长序列上训练大语言模型（LLMs）对于增强模型能力以及适应长上下文任务（如微调和强化学习）至关重要。
- 现有的稀疏注意力方法主要针对推理，未解决训练中的计算挑战。这限制了它们在长上下文建模中的扩展能力。

此外，尝试将稀疏注意力方法应用于训练也面临进一步挑战：

不可训练的组件：
- 方法如 ClusterKV（使用 k-means 聚类）和 MagicPIG（使用 SimHash 选择）涉及离散操作，破坏了计算图，阻止了梯度流通过 token 选择过程。这限制了模型学习最优稀疏模式的能力。
低效的反向传播：
- 技术如 HashAttention 使用基于 token 的细粒度选择，需要从 KV 缓存中加载大量非连续的单个 token。这阻止了像 FlashAttention 这样依赖连续内存访问和块级计算的高效技术的使用。
- 结果是，由于硬件利用率低下，训练效率受到影响。

关键要点：现有稀疏注意力方法不适合训练，因为它们要么引入了不可训练的组件，要么在反向传播中效率低下。

2.3. 原生稀疏性的必要性

在 推理效率 和 训练可行性 方面的局限性表明，稀疏注意力机制需要进行根本性的重新设计。作者提出了 NSA（原生稀疏注意力），一个旨在解决这些挑战的框架，具体包括：

确保计算效率：
- NSA 集成了硬件友好的设计，在预填充和解码阶段最大化加速。
支持可训练稀疏性：
- NSA 通过引入高效的算法和反向传播算子，允许梯度流动并优化稀疏模式，从而实现端到端训练。

关键要点：NSA 是一个原生稀疏注意力框架，平衡了计算效率和训练需求，克服了现有方法的局限性。

总结

本节批判了现代稀疏注意力方法，指出它们无法在推理阶段提供一致的加速，并且缺乏对高效训练的支持。这些不足促使了 NSA 的开发，这是一种新框架，解决了计算和训练方面的挑战。NSA 通过硬件对齐的系统设计和可训练稀疏性，为更高效、更可扩展的长上下文建模铺平了道路。

方法

该文档描述了一种名为NSA（Natural Sparse Attention）的技术方法，旨在优化注意力机制的计算效率和硬件性能。以下是内容的总结：

1. 背景

$$ \text{Attn}(q_t, k, v)=\text{Softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) $$
$$ \mathrm{Attn}(\mathbf{q}_t, \mathbf{k}_{:t}, \mathbf{v}_{:t}) = \sum_{i = 1}^{t} \frac{\alpha_{t,i} \mathbf{v}_i}{\sum_{j = 1}^{t} \alpha_{t,j}}, \quad \alpha_{t,i} = e^{\frac{\mathbf{q}_t^{\top} \mathbf{k}_i}{\sqrt{d_k}}} $$
算术强度：定义为计算操作与内存访问的比率，决定了算法在硬件上的优化方向。训练和预填充阶段通常是计算密集型，而自回归解码阶段则受内存带宽限制。

2. 总体框架

NSA提出用更紧凑且信息密集的表示（key-value对）替代原始的key-value对，以优化注意力输出。
提出了三种映射策略：
1. 压缩（Compression）：将连续块的keys/values聚合为更高层次的语义表示。

$$\tilde{K}_{t}=f_{K}(q_{t}, k_{: t}, v_{: t})$$$$\tilde{V}_{t}=f_{V}(q_{t}, k_{: t}, v_{: t})$$$$o_{t}^{*}=\mathrm{Attn}(q_{t}, \tilde{K}_{t}, \tilde{V}_{t})$$

其中$\tilde{K}{t}$、$\tilde{V}{t}$是基于当前查询$q_{t}$和上下文记忆$k_{: t}$、$v_{: t}$动态构建的。

选择（Selection）：选择最相关的tokens，保留细粒度信息。我们可以设计各种映射策略来获得不同类别的$\tilde{K}{t}^{c}$、$\tilde{V}{t}^{c}$，并按如下方式组合它们： $$o_{t}^{*}=\sum_{c \in C} g_{t}^{c} \cdot \mathrm{Attn}(q_{t}, \tilde{K}_{t}^{c}, \tilde{V}_{t}^{c})$$

NSA有三种映射策略$C = {cmp, slc, win} $，分别代表键和值的压缩、选择和滑动窗口。$g_{t}^{c} \in [0, 1]$是对应策略$c$的门控分数，通过多层感知机（MLP）和sigmoid激活函数从输入特征中推导得出。

滑动窗口（Sliding Window）：专注于局部上下文，防止局部模式主导学习过程。

这些策略通过动态构造的keys/values实现，并结合门控机制（gate score）进行加权组合。

$$N_{t}=\sum_{c \in C} \mathrm{size}[\tilde{K}_{t}^{c}]$$

3. 算法设计（注意，本节内容没有详细写，需要重新看文章的伪代码）

3.1 Token Compression（压缩）

将连续块的keys/values聚合为块级表示，减少计算负担。
使用可学习的MLP（多层感知器）和位置编码来生成压缩表示。

3.2 Token Selection（选择）

基于块的重要性评分选择最相关的tokens。
重要性评分通过压缩tokens的注意力分数推导，支持高效的块级选择。
对于共享KV缓存的模型（如GQA/MQA），确保跨头的一致性选择。

3.3 Sliding Window（滑动窗口）

维护一个固定大小的窗口，专注于最近的tokens。
防止局部模式干扰其他分支的学习，同时引入最小的计算开销。

4. 内核设计

在Triton上实现硬件对齐的稀疏注意力内核，优化训练和预填充阶段的速度。
核心优化包括：
1. 组中心数据加载：按组加载查询（queries），共享稀疏KV块。
2. 共享KV获取：按需加载连续的KV块，减少冗余内存传输。
3. 外循环调度：利用Triton的网格调度器简化内核设计，平衡GPU流式多处理器的工作负载。

5. 目标

训练/预填充阶段：通过压缩和选择策略减少计算成本。
解码阶段：通过稀疏KV缓存减少内存访问，提升效率。

总结

NSA通过结合压缩、选择和滑动窗口策略，显著降低了注意力计算的复杂度，同时优化了硬件性能。其内核设计充分利用现代GPU架构特性，实现了接近FlashAttention级别的加速效果。

实验

以下是对上传文件内容的总结：

1. 研究目标

本文通过三个维度评估了一种新的稀疏注意力方法（NSA）：(1) 通用基准性能，(2) 长上下文基准性能，(3) 链式思维推理性能。NSA 方法与全注意力（Full Attention）基线和最先进的稀疏注意力方法进行了对比。

2. 模型架构

基础架构：
- NSA 使用了 Grouped-Query Attention (GQA) 和 Mixture-of-Experts (MoE) 的组合。
- 模型参数总量为 27B，其中激活参数为 3B。
- 包含 30 层，隐藏维度为 2560。
- GQA 设置了 4 组，共 64 个注意力头；每个头的查询、键和值的隐藏维度分别为 𝑑𝑞 = 𝑑𝑘 = 192 和 𝑑𝑣 = 128。
- MoE 使用 DeepSeekMoE 结构，包含 72 个路由专家和 2 个共享专家，设置 top-k 专家为 6。
- 第一层的 MoE 被替换为 SwiGLU 形式的 MLP，以确保训练稳定性。
稀疏注意力设计：
- NSA 设计了分层稀疏注意力机制，结合压缩 token 进行全局上下文扫描，以及选择 token 实现局部信息检索。
- 参数设置包括：压缩块大小 𝑙 = 32，滑动步幅 𝑑 = 16，选择块大小 𝑙′ = 64，选择块数量 𝑛 = 16，滑动窗口大小 𝑤 = 512。

3. 实验设置

预训练：
- NSA 和 Full Attention 模型均在 270B tokens 的 8k 长度文本上进行预训练，并在 32k 长度文本上进行继续训练和监督微调（使用 YaRN 方法）以适应长上下文。
- 训练至完全收敛，以确保公平比较。
基线方法：
- 对比了多种最先进的稀疏注意力方法（如 H2O、infLLM、Quest 和 Exact-Top），以及 Full Attention 基线。

4. 实验结果

(1) 通用基准性能

在知识、推理和编码任务上的多个基准测试中（如 MMLU、BBH、GSM8K 等），NSA 在 7/9 的指标上优于 Full Attention。
NSA 在推理相关任务（如 DROP 和 GSM8K）上表现尤为突出，分别提升了 +0.042 和 +0.034。
结果表明，尽管 NSA 是稀疏注意力模型，但其性能优于 Full Attention，验证了其作为通用架构的鲁棒性。

(2) 长上下文性能

在长上下文任务（如 LongBench 和 Needle-in-a-Haystack 测试）中，NSA 表现优异。
NSA 在 64k 上下文长度的 Needle-in-a-Haystack 测试中实现了完美的检索准确率。
在 LongBench 上，NSA 的平均得分最高（0.469），比 Full Attention 提升 +0.032，比 Exact-Top 提升 +0.046。
NSA 在复杂推理任务（如多跳 QA 和代码理解）上表现出显著优势。

(3) 链式思维推理性能

在数学推理任务（AIME 测试）中，NSA-R（NSA 的微调版本）在 8k 和 16k 上下文长度下均优于 Full Attention-R。
NSA-R 在 8k 上下文中提升 +0.075，在 16k 上下文中提升 +0.054。
结果表明，NSA 的稀疏注意力模式能够有效捕获长距离逻辑依赖关系，支持复杂的数学推导。

5. 效率分析

NSA 的实现显著减少了延迟，特别是在长上下文场景中，改进效果更加明显。
在前向传播时间对比中，NSA 的速度比 FlashAttention-2 快 9 倍（在 64k 上下文长度下）。
在反向传播时间对比中，NSA 也表现出显著的速度优势。

6. 结论

NSA 在通用基准、长上下文任务和链式思维推理任务中均表现出色，验证了其在性能和效率之间的有效权衡。
分层稀疏注意力机制使 NSA 能够同时保持全局感知和局部精度，适合处理多样化的长上下文挑战。
NSA 的硬件对齐设计和端到端优化使其成为一种高效的通用架构，适用于先进推理任务。

讨论

总结内容

在本文的讨论部分，作者对新提出的稀疏注意力机制（NSA）的开发过程进行了反思，并探讨了从不同稀疏注意力策略中获得的关键见解。尽管NSA方法展示了良好的性能，但对其替代策略的挑战和注意力模式的分析为未来的研究方向提供了重要的背景。

6.1 替代令牌选择策略的挑战

在设计NSA之前，作者尝试了将现有的稀疏注意力方法应用于训练阶段，但这些方法遇到了各种挑战，促使他们设计了一种新的稀疏注意力架构：

基于聚类的策略（Key-Clustering Based Strategies）
- 例如ClusterKV（Liu et al., 2024），这类方法将同一簇中的Keys和Values存储在连续的内存区域中。
- 挑战：
  1. 动态聚类机制引入了显著的计算开销。
  2. 在混合专家系统（MoE）中，由于专家并行性（EP）组执行时间的不平衡，操作优化变得更加困难。
  3. 必须进行周期性重新聚类以及分块顺序训练协议，这带来了实现上的限制。
- 这些因素共同导致了实际部署中的瓶颈问题。
其他块级选择策略（Other Blockwise Selection Strategies）
- 例如Quest（Tang et al., 2024）和InfLLM（Xiao et al., 2024），这些方法通过计算每个块的重要性得分并选择与查询最相似的前𝑛个块来实现稀疏性。
- 挑战：
  1. 选择操作是非可微的，因此基于神经网络的重要性得分计算依赖于辅助损失（auxiliary loss），这增加了操作开销并可能降低模型性能。
  2. 基于启发式的无参数重要性得分计算策略存在召回率低的问题，导致次优性能。
- 实验结果表明，这两种方法在3B参数模型上的表现均不如NSA和全注意力机制（Full Attention）。具体而言：
  - 辅助损失方法通过引入额外的查询和代表性键来估计块重要性得分，但效果有限。
  - 启发式无参数方法（如Quest）虽然避免了额外参数，但冷启动训练（Cold-Start Training）后仍表现出较高的损失值。

6.2 可视化分析

为了探索Transformer注意力分布中的潜在模式，作者对预训练的27B参数全注意力模型的注意力图进行了可视化（见图8）。

观察到的模式：
- 注意力得分呈现出块状聚类特性，即相邻的Keys往往具有相似的注意力得分。
- 这一现象表明，序列中相邻的令牌可能与查询令牌共享某些语义关系，尽管这些关系的具体性质需要进一步研究。
启发：
- 基于空间连续性的块选择可能是提高计算效率的有效方法，同时能够保留高注意力模式。
- NSA的设计正是受到这种块状聚类现象的启发，旨在通过对连续令牌块的操作而非单个令牌来实现稀疏注意力机制。

总结

通过对替代稀疏注意力策略的挑战和注意力模式的深入分析，作者得出以下结论：

现有的稀疏注意力方法在训练阶段面临显著的计算和实现瓶颈，难以满足实际部署需求。
注意力分布的块状聚类特性为稀疏注意力机制的设计提供了重要启示，推动了NSA的开发。
NSA通过基于块的选择策略，在保持高性能的同时实现了更高的计算效率，为未来的稀疏注意力研究提供了新的方向。

MoE

Mon, 24 Feb 2025 00:00:00 +0000

https://huggingface.co/blog/zh/moe

MoE 示例：

import torch
import torch.nn as nn
import torch.nn.functional as F

# 定义单个专家网络
class Expert(nn.Module):
 def __init__(self, input_dim, hidden_dim, output_dim):
 super(Expert, self).__init__()
 self.layer1 = nn.Linear(input_dim, hidden_dim)
 self.layer2 = nn.Linear(hidden_dim, output_dim)

 def forward(self, x):
 x = F.relu(self.layer1(x))
 x = self.layer2(x)
 return x

# 定义门控网络
class Gate(nn.Module):
 def __init__(self, input_dim, num_experts):
 super(Gate, self).__init__()
 self.layer = nn.Linear(input_dim, num_experts)

 def forward(self, x):
 return F.softmax(self.layer(x), dim=-1)

# 定义 MoE 模型
class MixtureOfExperts(nn.Module):
 def __init__(self, input_dim, hidden_dim, output_dim, num_experts):
 super(MixtureOfExperts, self).__init__()
 # 初始化多个专家
 self.experts = nn.ModuleList([
 Expert(input_dim, hidden_dim, output_dim)
 for _ in range(num_experts)
 ])
 # 初始化门控网络
 self.gate = Gate(input_dim, num_experts)
 self.num_experts = num_experts

 def forward(self, x):
 # 获取门控输出 (batch_size, num_experts)
 gate_output = self.gate(x)

 # 获取每个专家的输出 (batch_size, output_dim, num_experts)
 expert_outputs = torch.stack([expert(x) for expert in self.experts], dim=2)

 # 加权组合专家输出 (batch_size, output_dim)
 output = torch.einsum('be,bde->bd', gate_output, expert_outputs)
 return output

# 测试代码
def main():
 # 设置参数
 input_dim = 10
 hidden_dim = 20
 output_dim = 5
 num_experts = 3
 batch_size = 32

 # 创建模型
 model = MixtureOfExperts(input_dim, hidden_dim, output_dim, num_experts)

 # 生成随机输入数据
 x = torch.randn(batch_size, input_dim)

 # 前向传播
 output = model(x)

 print(f"Input shape: {x.shape}")
 print(f"Output shape: {output.shape}")
 print(f"Sample output: {output[0]}")

if __name__ == "__main__":
 # 检查是否有 GPU
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print(f"Using device: {device}")
 main()

代码说明：

Expert 类: 定义了一个简单的两层神经网络作为专家模型。
Gate 类: 定义了门控网络，用于为每个输入分配专家的权重。
MixtureOfExperts 类: 组合了多个专家和一个门控网络，通过加权求和得到最终输出。
main 函数: 测试代码，创建模型并运行一个随机输入。

输出示例：

运行代码后，你会看到类似以下的输出：

Using device: cpu
Input shape: torch.Size([32, 10])
Output shape: torch.Size([32, 5])
Sample output: tensor([ 0.1234, -0.5678, 0.9101, -0.2345, 0.6789])

注意事项：

这个实现是一个基础版本，实际应用中可能需要添加正则化、噪声（如在门控网络中加入 Gumbel-Softmax）或更复杂的专家结构。

什么是混合专家模型？

模型规模是提升模型性能的关键因素之一。在有限的计算资源预算下，用更少的训练步数训练一个更大的模型，往往比用更多的步数训练一个较小的模型效果更佳。

混合专家模型 (MoE) 的一个显著优势是它们能够在远少于稠密模型所需的计算资源下进行有效的预训练。这意味着在相同的计算预算条件下，您可以显著扩大模型或数据集的规模。特别是在预训练阶段，与稠密模型相比，混合专家模型通常能够更快地达到相同的质量水平。

那么，究竟什么是一个混合专家模型 (MoE) 呢？作为一种基于 Transformer 架构的模型，混合专家模型主要由两个关键部分组成:

稀疏 MoE 层: 这些层代替了传统 Transformer 模型中的前馈网络 (FFN) 层。MoE 层包含若干“专家”(例如 8 个)，每个专家本身是一个独立的神经网络。在实际应用中，这些专家通常是前馈网络 (FFN)，但它们也可以是更复杂的网络结构，甚至可以是 MoE 层本身，从而形成层级式的 MoE 结构。门控网络或路由: 这个部分用于决定哪些令牌 (token) 被发送到哪个专家。例如，在下图中，“More”这个令牌可能被发送到第二个专家，而“Parameters”这个令牌被发送到第一个专家。有时，一个令牌甚至可以被发送到多个专家。令牌的路由方式是 MoE 使用中的一个关键点，因为路由器由学习的参数组成，并且与网络的其他部分一同进行预训练。

Switch Transformers paper 论文中的 MoE layer 总结来说，在混合专家模型 (MoE) 中，我们将传统 Transformer 模型中的每个前馈网络 (FFN) 层替换为 MoE 层，其中 MoE 层由两个核心部分组成: 一个门控网络和若干数量的专家。

尽管混合专家模型 (MoE) 提供了若干显著优势，例如更高效的预训练和与稠密模型相比更快的推理速度，但它们也伴随着一些挑战:

训练挑战: 虽然 MoE 能够实现更高效的计算预训练，但它们在微调阶段往往面临泛化能力不足的问题，长期以来易于引发过拟合现象。推理挑战: MoE 模型虽然可能拥有大量参数，但在推理过程中只使用其中的一部分，这使得它们的推理速度快于具有相同数量参数的稠密模型。然而，这种模型需要将所有参数加载到内存中，因此对内存的需求非常高。以 Mixtral 8x7B 这样的 MoE 为例，需要足够的 VRAM 来容纳一个 47B 参数的稠密模型。之所以是 47B 而不是 8 x 7B = 56B，是因为在 MoE 模型中，只有 FFN 层被视为独立的专家，而模型的其他参数是共享的。此外，假设每个令牌只使用两个专家，那么推理速度 (以 FLOPs 计算) 类似于使用 12B 模型 (而不是 14B 模型)，因为虽然它进行了 2x7B 的矩阵乘法计算，但某些层是共享的。了解了 MoE 的基本概念后，让我们进一步探索推动这类模型发展的研究。

开源混合专家模型

目前，下面这些开源项目可以用于训练混合专家模型 (MoE):

Megablocks: https://github.com/stanford-futuredata/megablocks Fairseq: https://github.com/facebookresearch/fairseq/tree/main/examples/moe_lm OpenMoE: https://github.com/XueFuzhao/OpenMoE 对于开源的混合专家模型 (MoE)，你可以关注下面这些:

Switch Transformers (Google): 基于 T5 的 MoE 集合，专家数量从 8 名到 2048 名。最大的模型有 1.6 万亿个参数。 NLLB MoE (Meta): NLLB 翻译模型的一个 MoE 变体。 OpenMoE: 社区对基于 Llama 的模型的 MoE 尝试。 Mixtral 8x7B (Mistral): 一个性能超越了 Llama 2 70B 的高质量混合专家模型，并且具有更快的推理速度。此外，还发布了一个经过指令微调的模型。有关更多信息，可以在 Mistral 的公告博客文章中了解。

Attention

Sun, 16 Feb 2025 00:00:00 +0000

注意力机制（Attention Mechanism）详解

注意力机制是深度学习领域中一种重要的技术，广泛应用于自然语言处理（NLP）、计算机视觉（CV）、语音识别等领域。它通过模拟人类的注意力选择过程，使模型能够专注于输入数据中的重要部分，从而提升模型的性能和效率。

一、背景与动机

在传统的序列建模任务中（如机器翻译），RNN（循环神经网络）及其变体（LSTM、GRU）被广泛使用。然而，这些模型存在以下问题：

长距离依赖问题：RNN难以捕捉长序列中的远距离依赖关系。
固定长度上下文限制：编码器通常将整个输入序列压缩为一个固定长度的向量，这可能导致信息丢失。
计算效率低：RNN需要按顺序处理序列，无法并行化。

为了解决这些问题，注意力机制应运而生。它允许模型动态地关注输入序列的不同部分，而不是依赖单一的固定表示。

二、注意力机制的核心思想

首先我们可以看看李沐老师在《动手学深度学习》这么书中做的一些介绍

其中一句话比较吸引注意力：“受试者基于非自主性提示和自主性提示有选择地引导注意力的焦点。”

实际上，注意力机制的核心思想是：让模型学会根据当前任务的需求，分配不同的权重给输入的不同部分。换句话说，模型可以“聚焦”于输入中最相关的信息，而忽略无关的部分。

例如，在机器翻译任务中，当生成目标语言的一个单词时，模型可以根据源语言句子中的不同单词的重要性，动态调整它们对当前输出的影响。

三、注意力机制的基本原理

我感觉《动手学深度学习》中的介绍，很清楚的把注意力机制的机制介绍了

1. 基本组成

注意力机制通常由以下几个关键部分组成：

Query（查询）：表示当前需要关注的内容或任务需求。
Key（键）：表示输入数据的特征表示。
Value（值）：表示输入数据的实际内容。
Score Function（评分函数）：用于衡量Query与每个Key之间的相关性。
Softmax：将评分归一化为概率分布。
加权求和：根据归一化的权重对Value进行加权求和，得到最终的输出。

2. 数学公式

假设输入序列为 $ X = {x_1, x_2, …, x_n} $，其对应的Key和Value分别为 $ K = {k_1, k_2, …, k_n} $ 和 $ V = {v_1, v_2, …, v_n} $。Query为 $ q $。注意力机制的计算过程如下：

$$ e_i = \text{Score}(q, k_i) $$
常见的评分函数包括：
- 点积注意力（Scaled Dot-Product Attention）： $$ e_i = \frac{q \cdot k_i}{\sqrt{d_k}} $$ 其中 $ d_k $ 是Key的维度。
- 加性注意力（Additive Attention）： $$ e_i = v^T \tanh(W_q q + W_k k_i) $$
$$ \alpha_i = \text{Softmax}(e_i) = \frac{\exp(e_i)}{\sum_{j=1}^n \exp(e_j)} $$
$$ \text{Output} = \sum_{i=1}^n \alpha_i v_i $$

四、注意力机制的分类

根据应用场景和实现方式，注意力机制可以分为以下几种类型：

1. 自注意力机制（Self-Attention）

自注意力机制是一种特殊的注意力机制，其中Query、Key和Value都来自同一个输入序列。它常用于Transformer模型中，用于捕捉序列内部的关系。

特点：

输入序列中的每个元素都可以与其他元素交互。
能够捕捉全局依赖关系，而不受序列长度的限制。

应用：

Transformer模型中的多头自注意力（Multi-Head Self-Attention）。
BERT、GPT等预训练语言模型。

2. 交叉注意力机制（Cross-Attention）

交叉注意力机制用于两个不同序列之间的交互。例如，在机器翻译任务中，解码器通过交叉注意力机制关注编码器的输出。

特点：

Query来自一个序列，Key和Value来自另一个序列。
适用于序列到序列的任务。

应用：

机器翻译。
图像描述生成。

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

多头注意力是自注意力机制的一种扩展，它通过多个独立的注意力头并行计算，然后将结果拼接起来。这种方式可以捕捉输入序列中不同子空间的关系。

特点：

每个注意力头可以关注输入的不同方面。
提高了模型的表达能力。

应用：

Transformer模型。
多模态任务（如图文匹配）。

4. 局部注意力（Local Attention）

局部注意力机制只关注输入序列的一部分，而不是整个序列。这种方式可以降低计算复杂度，同时保留局部信息。

特点：

计算效率高。
适合处理长序列。

应用：

长文本处理。
视频分析。

5. 缩放点积注意力

缩放点积注意力也就是前面最开始说的注意力，只是前面的公式中加入了一个缩放因子，防止点积的数值过大，导致梯度消失或梯度爆炸。

五、注意力机制的优势

灵活性：注意力机制可以根据任务需求动态调整输入的重要性。
捕捉长距离依赖：相比RNN，注意力机制可以直接建模输入序列中任意两个位置之间的关系。
可解释性：通过注意力权重，可以直观地看到模型关注了哪些部分。
并行化：注意力机制的计算可以完全并行化，提高了训练效率。

六、注意力机制的应用

1. 自然语言处理（NLP）

机器翻译：Transformer模型利用注意力机制实现了端到端的翻译。
文本生成：GPT系列模型通过自注意力机制生成高质量的文本。
问答系统：BERT模型利用双向自注意力机制理解问题和文档的关系。

2. 计算机视觉（CV）

图像描述生成：通过交叉注意力机制，模型可以根据图像内容生成描述文字。
目标检测：注意力机制可以帮助模型聚焦于图像中的特定区域。

3. 语音识别

语音转文字：注意力机制可以捕捉语音信号中的重要片段。

4. 推荐系统

用户行为建模：通过注意力机制，模型可以关注用户历史行为中的重要部分。

七、总结

注意力机制是一种强大的工具，它通过动态分配权重的方式，使模型能够更好地捕捉输入数据中的重要信息。随着Transformer模型的普及，注意力机制已经成为深度学习领域的核心技术之一。未来，随着研究的深入，注意力机制将在更多领域发挥重要作用。

如果你对某个具体应用场景或实现细节感兴趣，可以进一步探讨！