深度学习 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"更值得关心的问题。

Alignment-DPOvsPPOvsGRPO

Tue, 25 Nov 2025 20:51:18 +0800

GRPO

GRPO (Group Relative Policy Optimization) 是一种高效的强化学习（RL）算法，专门用于大型语言模型（LLM）的后训练阶段（Post-training）。

它由 DeepSeek 团队在发布 DeepSeekMath 和 DeepSeek-R1（推理模型）时作为核心技术推出。GRPO 的最大创新在于摒弃了传统 PPO（近端策略优化）中昂贵的“评论家”（Critic / Value Function）模型，从而极大地降低了训练时的显存占用和计算成本。

以下是关于 GRPO 的详细技术介绍：

1. 核心概念：什么是 GRPO？

全称：Group Relative Policy Optimization
中文直译：组相对策略优化
核心思想：在传统的强化学习（如 PPO）中，我们需要一个“评论家”模型来预测当前状态的价值，以计算“优势函数”（Advantage）。 GRPO 发现，我们可以通过对同一个问题（Prompt）采样一组（Group）不同的回答，利用这一组回答的平均奖励作为基准（Baseline），来计算每个回答的相对好坏。这样就不再需要一个额外的神经网络来做“评论家”了。

2. GRPO 的工作原理（算法流程）

GRPO 的训练过程可以简单概括为“小组赛马，优胜劣汰”：

生成（Group Sampling）：对于每一个输入的问题 $q$，模型（Actor）会生成一组 $G$ 个不同的输出 ${o_1, o_2, …, o_G}$。
- 例如：给模型一道数学题，让它生成 64 种不同的解题过程。
打分（Reward Calculation）：使用奖励模型（Reward Model）或规则（如数学题答案是否正确）给这 $G$ 个输出分别打分，得到奖励值 ${r_1, r_2, …, r_G}$。
$$A_i = \frac{r_i - \text{mean}(R)}{\text{std}(R)}$$
- $A_i$：第 $i$ 个回答的优势值。
- $\text{mean}(R)$：这组回答的平均分。
- 如果一个回答的分数高于平均分，它的优势就是正的（被鼓励）；反之则是负的（被抑制）。
策略更新（Policy Optimization）：利用计算出的优势值 $A_i$，通过梯度下降更新模型的参数，使其下一次更有可能生成高分回答。同时，GRPO 会在损失函数中加入 KL 散度（KL Divergence） 项，防止模型更新步子太大，偏离原始模型（Reference Model）太远，导致训练崩塌。

3. GRPO vs. PPO：关键区别

这是理解 GRPO 价值的最重要部分。PPO 是 ChatGPT 等模型使用的传统方法，而 GRPO 做出了重大简化。

特性	PPO (Proximal Policy Optimization)	GRPO (Group Relative Policy Optimization)
模型组件	需要 4 个模型： 1. Actor (当前策略) 2. Critic (价值网络) 3. Ref (参考模型) 4. Reward (奖励模型)	只需要 3 个模型： 1. Actor (当前策略) 2. Ref (参考模型) 3. Reward (奖励模型) ❌ 移除了 Critic
显存占用	极高。Critic 模型通常和 Actor 一样大，训练时需要加载两个巨型模型。	较低。节省了 Critic 模型的显存，通常能节省 30%-50% 的资源。
计算优势的方式	依赖 Critic 模型预测的“价值”来计算 GAE (Generalized Advantage Estimation)。	依赖组内平均分（Group Mean）作为基准。
计算复杂度	高，需要前向和反向传播 Critic 网络。	低，仅涉及简单的统计计算。

4. GRPO 的核心优势

大幅降低训练成本：由于不需要训练和推理那个和 LLM 一样大的 Critic 模型，显存需求大幅下降。这意味着在同样的硬件上，你可以训练参数量更大的模型，或者使用更大的 Batch Size。
更适合“推理”任务： DeepSeek-R1 的成功证明了 GRPO 非常适合数学、代码等逻辑推理任务。在这些任务中，通过多次采样（生成多种解法）来寻找正确路径是一种非常自然的学习方式。
训练稳定性：虽然移除了 Critic，但 GRPO 通过组内归一化（Group Normalization）和 KL 惩罚项，依然保持了非常稳定的训练过程，不仅没有损失效果，在数学推理榜单（如 GSM8K, MATH）上甚至超越了传统 PPO。

5. 总结

GRPO 是强化学习在 LLM 时代的一次“减法”革命。

它证明了在拥有强大基础模型（Base Model）的前提下，我们不需要复杂的价值网络来指导模型，只需要让模型“自己和自己比”（在一组生成结果中比较），就能高效地进化出强大的推理能力。这也是 DeepSeek 系列模型能够以较低成本取得高性能的关键技术之一。

分割线 2025-11-26

DPO (Direct Preference Optimization) 和 PPO (Proximal Policy Optimization) 是目前大语言模型（LLM）对齐（Alignment） 阶段最主流的两种算法。它们的核心目标都是让模型的输出符合人类的偏好（即 RLHF - Reinforcement Learning from Human Feedback）。

简单来说：PPO 是经典的“学院派”方法（OpenAI 早期使用），而 DPO 是高效的“实战派”新贵（目前开源界更流行）。

以下是两者的详细介绍和对比：

一、 PPO (Proximal Policy Optimization)

全称：近端策略优化

PPO 是在 ChatGPT 早期训练中成名的方法。它是一种标准的强化学习（RL）算法。

1. 核心原理

PPO 的核心思想是：在优化策略（Policy）以获得更高奖励的同时，限制新策略与旧策略之间的差异，防止模型“学歪”或训练崩溃。

在 LLM 的 RLHF 流程中，PPO 通常包含以下三个阶段：

SFT (Supervised Fine-Tuning)： 先用高质量指令数据微调模型，得到基座模型。
RM (Reward Model Training)： 训练一个奖励模型（Critic），它能给 LLM 的回复打分（模仿人类的偏好）。
RL (PPO)： 利用 RM 的打分作为奖励信号，通过 PPO 算法更新 LLM 的参数。

2. 训练时的“四个模型”

PPO 的工程实现非常复杂，因为它在训练显存中通常需要维护 4 个模型：

Actor (策略模型)： 正在训练的 LLM，负责生成文本。
Critic (价值模型)： 估计当前状态的价值（通常由 RM 初始化）。
Ref Model (参考模型)： 冻结权重的 SFT 模型，用于计算 KL 散度（防止 Actor 跑偏）。
Reward Model (奖励模型)： 冻结权重，用于给 Actor 的输出打分。

3. 优缺点

优点：
- 理论上限高： 在数据极其丰富、算力充足的情况下，PPO 往往能探索出更好的解。
- 在线生成： 它在训练中会不断生成新的样本（Sampling），能够探索未见过的空间。
缺点：
- 极其耗费资源： 需要同时加载多个模型，显存占用巨大。
- 训练极不稳定： 超参数极其敏感（学习率、KL 系数等），容易出现 reward hacking（模型为了高分输出乱码）或训练发散。
- 速度慢： 因为涉及到在线采样（Generation）过程，训练吞吐量低。

二、 DPO (Direct Preference Optimization)

全称：直接偏好优化

DPO 是斯坦福大学在 2023 年提出的算法。它颠覆了 RLHF 必须包含“奖励模型”和“强化学习”的传统范式。

1. 核心原理

DPO 的核心洞见是：我们不需要显式地训练一个奖励模型（Reward Model）。

数学推导证明，最优的策略（Policy）和最优的奖励函数之间存在直接的映射关系。DPO 将 RLHF 问题转化为了一个简单的 二分类损失函数（Classification Loss） 问题。

DPO 不需要让模型在训练时生成文本，而是直接使用偏好数据对 $(x, y_w, y_l)$ 进行训练（$x$ 是提示，$y_w$ 是胜出的回复，$y_l$ 是失败的回复）。

2. 训练流程

DPO 省略了 RM 的训练步骤，直接优化 Policy：

公式直觉： 增加模型生成“好回复”($y_w$) 的概率，同时降低生成“坏回复”($y_l$) 的概率。
参考模型： 训练时只需要加载 2 个模型（正在训练的 Policy Model 和冻结的 Reference Model）。

3. 优缺点

优点：
- 实现简单： 代码实现类似传统的监督学习（Cross Entropy），无需复杂的 RL 循环。
- 显存占用低： 不需要 Critic 和独立的 Reward Model。
- 训练稳定： 不容易发散，超参数较少。
- 速度快： 没有推理采样阶段，训练速度大幅提升。
缺点：
- 容易过拟合： 对偏好数据的质量非常敏感。如果数据中有噪声，DPO 会迅速拟合这些噪声。
- 分布外泛化能力： 有研究指出，在处理完全没见过的 Prompt 时，PPO 可能比 DPO 稍好（存在争议）。

三、 PPO vs. DPO 核心对比表

特性	PPO (Proximal Policy Optimization)	DPO (Direct Preference Optimization)
本质	强化学习 (RL)	监督学习 / 优化方法
显存需求	极高 (需加载 Actor, Critic, Ref, RM)	较低 (只需 Policy, Ref)
训练流程	复杂 (采样 -> 打分 -> 更新 -> 循环)	简单 (直接在偏好数据上计算 Loss)
稳定性	差 (对超参极度敏感，调试困难)	好 (类似 SFT 的稳定性)
数据要求	需要 Reward Model 训练数据 + Unlabeled Prompts	需要成对的偏好数据 $(y_w, y_l)$
主要风险	Reward Hacking (钻空子刷分)	Overfitting (过拟合差数据)
工业界现状	OpenAI (GPT-4), Anthropic 早期使用	Llama 3, Zephyr, Qwen 等开源模型主流选择

四、为什么现在开源界主要用 DPO？

虽然 PPO 在理论上可能探索能力更强，但在实际的开源大模型开发（如 Llama 3 的微调、Qwen 的对齐）中，DPO 及其变体（如 IPO, KTO）已经占据了统治地位。原因如下：

算力就是金钱： PPO 需要的显存和时间是 DPO 的数倍。对于大多数团队，用 PPO 训练一个 70B 的模型成本过高。
效果足够好： 实验表明，在大多数公开基准测试中，DPO 的效果与 PPO 持平甚至更好，且实现难度低得多。
变体涌现： 基于 DPO 衍生出了很多改进版，例如：
- ORPO： 甚至不需要 SFT 阶段，直接由预训练模型一步到位进行偏好对齐。
- SimPO： 进一步简化 DPO，去掉了 Reference Model，显存更省。

五、总结建议

如果你是学术研究者，研究 RL 算法本身，或者你有无限算力想要探索 LLM 的极限，可以深入研究 PPO。
如果你是算法工程师（在企业落地 LLM），或者你在做微调项目，请首选 DPO。它能让你用更少的 GPU，在更短的时间内获得一个听话、对齐良好的模型。

接下来您希望我为您做什么？

提供一段使用 TRL 库进行 DPO 训练的 Python 代码示例。
深入讲解 DPO 的损失函数（Loss Function）数学细节。
介绍 DPO 的最新变体（如 ORPO 或 SimPO）是如何进一步优化的。

JAX

Fri, 14 Nov 2025 22:35:11 +0800

JAX 详细介绍

JAX 是一个由 Google 开发的开源 Python 库，主要用于高性能数值计算和大规模机器学习研究。它以 NumPy 为基础，提供了一个熟悉的数组计算 API，同时引入了先进的程序转换机制，如自动微分（autodiff）和即时编译（JIT），使其特别适合加速器环境（如 GPU 和 TPU）。JAX 的设计理念是“可组合的函数转换”，允许开发者轻松地将计算优化为高效的机器码，从而在保持代码简洁性的前提下实现高性能。

历史背景

JAX 的开发源于 Google Brain 团队对高性能计算的需求。最初于 2018 年左右作为内部工具启动，旨在解决 TensorFlow 在研究阶段的灵活性问题。2020 年，JAX 正式开源，并迅速在机器学习社区流行开来。它受到了 NumPy、Autograd 和 XLA（Accelerated Linear Algebra，Google 的编译器后端）的启发。JAX 的目标是桥接研究原型与生产部署的差距，让研究者能用纯 Python 代码快速迭代，而无需切换到低级优化。截至 2025 年，JAX 已演变为一个成熟生态，集成到 Flax（神经网络库）和 Optax（优化器）等工具中，并被广泛用于天体物理、量子计算和强化学习等领域。

核心特性

JAX 的强大之处在于其“函数转换”系统，这些转换可以无缝应用于 NumPy-like 的代码，而无需修改核心逻辑。以下是其主要特性：

特性	描述	示例应用
NumPy-like API	提供 `jax.numpy`（简称 `jnp`）模块，几乎兼容 NumPy 的所有数组操作，便于从 NumPy 迁移。	数组创建、线性代数、统计计算。
自动微分 (autodiff)	支持前向/反向模式自动求导，适用于复杂梯度计算。	机器学习中的梯度下降优化。
JIT 编译	使用 XLA 后端将 Python 函数编译为高效机器码，支持懒惰求值。	加速循环密集型计算，如模拟。
向量化 (vmap)	自动将函数向量化，支持批量处理。	处理多维数据，如图像批次。
并行映射 (pmap)	在多设备（如多个 GPU）上并行执行函数。	分布式训练。
多后端支持	无缝运行于 CPU、GPU（CUDA/ROCm）和 TPU，无需代码修改。	异构计算环境。
纯函数式设计	数组不可变（immutable），避免副作用，确保可预测性。	调试和重现性强。

这些特性使 JAX 在性能上远超纯 NumPy，尤其在加速器上。

与 NumPy 和 TensorFlow 的比较

JAX 常被视为 NumPy 的“升级版”和 TensorFlow 的“研究友好”替代品。以下是关键区别：

与 NumPy 的比较：

相似点：JAX 的 API 高度兼容 NumPy（如 jnp.array()、jnp.dot()），迁移成本低。

区别：

方面	NumPy	JAX
数组可变性	支持原地修改（in-place）。	不可变，必须返回新数组（函数式风格）。
性能	CPU 上高度优化，但无加速器支持。	CPU 上可能稍慢（因抽象层），但 GPU/TPU 上更快（JIT 优化）。
高级功能	无自动微分或编译。	支持 autodiff、JIT 等转换。

适用场景：NumPy 适合简单脚本；JAX 适合需要梯度或高性能的场景。

与 TensorFlow 的比较：

相似点：两者都支持自动微分和图优化，TensorFlow 的 Keras 可与 JAX 集成。

区别：

方面	TensorFlow	JAX
抽象层	高层 API（如 Keras）+ 图模式/急切执行。	低层、纯函数式，专注于核心计算。
灵活性	研究时需切换模式，部署复杂。	统一风格，易于原型到生产。
性能	内置优化，但自定义扩展难。	通过转换实现极致优化，支持自定义后端。
学习曲线	更完整框架，适合生产。	更轻量，适合研究（如结合 Flax）。

适用场景：TensorFlow 适合端到端应用；JAX 更适合实验性 ML 研究，常与 PyTorch-like 库（如 Flax）结合。

总体上，JAX 强调“编写一次，到处运行”，而 NumPy/TensorFlow 更侧重通用性或生产部署。

安装指南

JAX 的安装简单，通过 pip 完成。基本命令：

pip install --upgrade jax jaxlib

CPU 版：上述命令即可。
GPU 版（CUDA）：pip install --upgrade "jax[cuda12_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html（替换 cuda12 为你的 CUDA 版本，如 11 或 12）。
TPU 版：需 Google Cloud 环境，参考官方文档。安装后，验证：import jax; print(jax.devices())（显示可用设备）。

基本使用示例

以下是简单示例，展示核心功能。假设已安装 JAX。

基本数组操作（NumPy 风格）：

import jax.numpy as jnp

x = jnp.array([1.0, 2.0, 3.0])
y = jnp.sin(x) + jnp.dot(x, x)
print(y) # 输出: [1.84147098 3.90929337 9.83602988]

自动微分：

from jax import grad

def f(x):
 return jnp.sin(x) ** 2

df_dx = grad(f)(1.0) # 计算 f 在 x=1.0 处的导数
print(df_dx) # 输出: 0.6823278（约值）

JIT 编译（加速）：

from jax import jit

@jit
def fast_f(x):
 return jnp.dot(x, x) + jnp.sin(x)

x = jnp.arange(1000000.0)
result = fast_f(x) # 首次运行编译，后续高速

向量化（处理批量）：

from jax import vmap

def single_loss(params, x, y):
 return jnp.sum((jnp.dot(x, params) - y) ** 2)

batched_loss = vmap(single_loss, in_axes=(None, 0, 0)) # 向量化第二个和第三个参数
# 可用于批量数据训练

这些示例展示了 JAX 的简洁性。

生态系统与应用

JAX 的生态丰富，包括：

Flax/Equinox：构建神经网络。
Optax：优化器集合。
Haiku：TensorFlow-like 模块化。应用领域：深度学习、天体模拟（jaxoplanet）、量子计算（QuTiP 集成）和生成模型。截至 2025 年，JAX 在学术会议（如 NeurIPS）中频繁出现，并被 Meta 和 OpenAI 等公司采用。

总结

JAX 是现代 ML 研究者的利器，它结合了 NumPy 的易用性和 TensorFlow 的高性能，同时提供无与伦比的灵活性。如果你从事数值计算或 AI 原型开发，强烈推荐从官方文档（https://jax.readthedocs.io）入手。JAX 的未来在于进一步优化多模态 AI 和分布式系统，值得持续关注。

mechine_learning_models

Thu, 06 Nov 2025 21:52:05 +0800

random_forest

好的，这是一个非常经典且强大的机器学习算法。我会为您提供一个关于“随机森林”（Random Forest）的详细介绍。

🌳 什么是随机森林 (Random Forest)？

简单来说，随机森林是一种集成学习（Ensemble Learning）算法。

想象一下，当您要做出一个重要决定时，您可能会去询问很多不同领域的朋友或专家，然后综合他们的意见，最终得出一个更明智、更可靠的结论。

随机森林做的就是同样的事情。它不会只依赖一个“决策树”（Decision Tree）模型，而是构建一个由大量决策树组成的“森林”，然后通过集体投票（用于分类）或取平均值（用于回归）的方式来得出最终的预测结果。

它既可以用于分类问题（比如，判断一封邮件是否为垃圾邮件），也可以用于回归问题（比如，预测明天的房价）。

随机森林的“魔法”在于它的名字——“随机”。它通过引入两种随机性来确保森林中的每一棵树都不相同，从而提高模型的整体鲁棒性和准确性。

核心思想：“森林”的构建

随机森林的基础单元是决策树 (Decision Tree)。一棵决策树就像一个流程图，通过一系列“是/否”的问题（例如：“年龄>30岁吗？”、“收入>5万吗？”）来对数据进行划分，最终得出一个结论。

但是，单棵决策树很容易“过拟合”（Overfitting），即它在训练数据上表现完美，但在新的、未见过的数据上表现很差。它“死记硬背”了训练数据，而不是学习到了通用的规律。

“随机”的体现：防止过拟合的秘诀

随机森林通过两种随机化策略来解决单棵树过拟合的问题：

随机性一：数据的随机（Bagging）

Bagging (Bootstrap Aggregating) 的意思是“自助聚合抽样”。
假设我们有1000个训练样本。随机森林在训练第1棵树时，它不会使用全部1000个样本，而是从这1000个样本中随机有放回地抽取1000个样本（这意味着某些样本可能被抽中多次，某些样本可能一次也没被抽中）。
它会训练很多棵树（比如100棵），每棵树都使用这样一份“略有不同”的随机样本集来训练。
效果： 确保了每棵树都是在不同的数据子集上训练的，增加了树之间的差异性。

随机性二：特征的随机（Random Feature Subspace）

这是随机森林相比其他Bagging算法（如单独的Bagging Decision Trees）更进一步的地方。
在训练每棵树的每一个节点时，当算法需要决定“用哪个特征来划分数据”时（例如，是看“年龄”还是看“收入”？），它不会在所有特征中去寻找最优解。
相反，它会随机抽取一小部分特征（例如，总共有50个特征，它随机选出5个），然后只在这5个特征中寻找“最优”的划分点。
效果： 这种做法进一步降低了树之间的相关性。如果某个特征特别强（比如在某个数据集中，“年龄”总是最重要的），那么在不使用特征随机的情况下，森林中的很多树都会在顶部使用“年龄”来划分，导致树长得很像。而特征随机性迫使模型去探索其他“没那么强”但同样有用的特征组合。

最终决策：森林的智慧

当新的数据需要被预测时，森林中的所有树都会对这个数据进行一次预测：

分类问题： 采用“投票”制。例如，100棵树中，有80棵树认为这封邮件是“垃圾邮件”，20棵树认为是“正常邮件”，那么随机森林的最终结论就是“垃圾邮件”。
回归问题： 采用“取平均值”。例如，预测房价，100棵树的预测值分别是 100万、101万、99万…… 随机森林的最终结论就是这些预测值的平均数。

👍 优点

高准确性： 通常情况下，随机森林的表现非常好，是业内最常用的“开箱即用”算法之一，因为它在多种数据集上都有很强的预测能力。
强大的抗过拟合能力： 两种“随机性”的引入，使得它很难发生过拟合。
处理高维数据： 它能处理具有非常多特征（高维度）的数据集，而且通常不需要做特征选择。
特征重要性评估： 随机森林可以评估并输出“哪个特征对预测结果最重要”，这对于业务理解和数据洞察非常有帮助。
鲁棒性强： 它对数据中的缺失值和异常值不敏感，数据预处理的压力较小。
易于并行化： 森林中的每棵树都是独立训练的，因此可以很容易地分配到不同的CPU核心或机器上并行计算，训练速度快。

👎 缺点

黑盒模型： 相比于单棵决策树（可以清晰地画出决策流程图），随机森林（由上百棵树组成）的决策过程非常难以解释。你很难知道它 为什么 会做出某个具体的预测。
计算和内存开销： 当树的数量非常多（例如上千棵）时，训练和预测所需的时间和内存开销会比较大。
对某些类型数据不擅长： 对于某些极度不平衡的数据（例如，99%是A类，1%是B类），它可能表现不佳，需要特殊处理。

总而言之，随机森林是一种非常强大和灵活的机器学习工具，它通过“三个臭皮匠，顶个诸葛亮”的集成思想，极大地提高了模型的稳定性和准确性。

vllm

Thu, 30 Oct 2025 01:27:14 +0800

vLLM 是一个非常流行的高性能大语言模型（LLM）推理和服务库。它之所以速度快，关键在于它采用了 PagedAttention 和持续批处理 (Continuous Batching) 等先进技术，极大提高了 GPU 内存的利用率和吞吐量。

这是一个详细的 vLLM 使用教程，分为几个关键步骤。

1. 什么是 vLLM？

高性能：vLLM 的吞吐量远高于传统的 Hugging Face Transformers 实现（快几十倍）。
高效内存管理：通过 PagedAttention，vLLM 像操作系统管理虚拟内存一样管理注意力机制中的 Key 和 Value（KV 缓存），减少了内存浪费和碎片。
OpenAI 兼容：它提供了一个与 OpenAI API 完全兼容的服务器，让您可以无缝替换原有的 API 调用。

2. 🔧 安装

vLLM 的安装非常简单，但它有一个关键的前提条件：

您必须有一块支持 CUDA 的 NVIDIA GPU。
需要安装 Python 3.8 或更高版本。

您可以使用 pip 直接安装：

pip install vllm

3. 🚀 核心用法一：使用 Python API (离线推理)

这是最直接的使用方式，适合在 Python 脚本中进行批量推理。

您只需要导入 LLM 和 SamplingParams 这两个核心类。

LLM：用于加载模型。
SamplingParams：用于指定生成文本时的参数（如温度、top_p 等）。

示例代码：

from vllm import LLM, SamplingParams

# 准备提示词列表
prompts = [
 "Hello, my name is",
 "The president of the United States is",
 "The capital of France is",
 "The future of AI is",
]

# 准备采样参数
# 您可以为所有提示词设置一组参数
sampling_params = SamplingParams(
 temperature=0.8,
 top_p=0.95,
 max_tokens=100
)

# 初始化 LLM 类，指定要加载的模型
# vLLM 会自动从 Hugging Face Hub 下载模型
# 第一次加载模型可能需要一些时间
print("正在加载模型...")
llm = LLM(model="meta-llama/Llama-2-7b-chat-hf")
print("模型加载完毕。")

# 运行批量推理
print("正在生成文本...")
outputs = llm.generate(prompts, sampling_params)
print("生成完毕。")

# 打印输出结果
for output in outputs:
 prompt = output.prompt
 generated_text = output.outputs[0].text

 print(f"--- 提示词 (Prompt) ---")
 print(prompt)
 print(f"--- 生成结果 (Generated) ---")
 print(generated_text)
 print("\n")

4. 🚀 核心用法二：部署 OpenAI 兼容 API 服务器

这是 vLLM 最强大的功能之一：将任何开源大模型部署为一个高速的、与 OpenAI API 格式一致的 API 服务。

第 1 步：启动服务器

您只需要一行命令即可启动服务器。vLLM 推荐使用 vllm serve 命令。

（请注意：meta-llama/Llama-2-7b-chat-hf 是一个需要授权的门控模型，您需要先登录 huggingface-cli login 才能下载。您也可以换成其他开放模型，如 Qwen/Qwen2-1.5B-Instruct）。

# 启动服务器，加载 Llama-2-7b-chat 模型
# 服务器默认运行在 http://localhost:8000
vllm serve meta-llama/Llama-2-7b-chat-hf

服务器启动后，您会看到类似以下的日志：

...
INFO 10-29 10:00:00 server.py:98] Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
INFO 10-29 10:00:00 utils.py:322] Using Eager mode.
INFO 10-29 10:00:00 utils.py:537] Effectively using 1 GPUs.
...

第 2 步：查询服务器 (使用 Python)

现在，您可以使用任何 HTTP 客户端来调用它。最简单的方法是使用 openai 官方 Python 库。

首先，请确保您已安装 openai 库： pip install openai

然后，运行以下 Python 脚本：

from openai import OpenAI

# 1. 初始化 OpenAI 客户端
# 指向您本地 vLLM 服务器的地址
client = OpenAI(
 base_url="http://localhost:8000/v1",
 api_key="vllm" # API 密钥不是必需的，但 OpenAI 库要求填写
)

# 2. 调用聊天接口 (Chat Completions)
print("正在调用 vLLM 服务器...")
chat_response = client.chat.completions.create(
 model="meta-llama/Llama-2-7b-chat-hf", # 确保这里的模型名与服务器加载的_一致
 messages=[
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "What is the capital of France?"}
 ],
 max_tokens=50,
 temperature=0.7
)

print("--- 服务器响应 ---")
print(chat_response.choices[0].message.content)

# 3. (可选) 调用文本补全接口 (Completions)
# print("\n--- 调用文本补全接口 ---")
# completion_response = client.completions.create(
# model="meta-llama/Llama-2-7b-chat-hf",
# prompt="The capital of France is",
# max_tokens=50,
# temperature=0.7
# )
# print(completion_response.choices[0].text)

5. 📚 关键概念：`SamplingParams`

在用法一中，SamplingParams 对象是控制文本生成的关键。以下是一些常用参数：

temperature (浮点数): 控制随机性。0 表示确定性输出，更高的值（如 0.8）表示更多样化的输出。
top_p (浮点数): 核采样 (Nucleus sampling)。仅从累积概率超过 top_p 的最小标记集中进行采样。
max_tokens (整数): 生成的最大 token 数量。
n (整数): 为每个提示词生成多少个独立的输出。
stream (布尔值): 是否以流式（逐个 token）返回结果。
stop (字符串列表): 遇到列表中的任何字符串时停止生成。

6. 🔗 官方资源

vLLM 发展非常快，最准确的信息始终来自官方：

官方文档: https://docs.vllm.ai/
GitHub 仓库: https://github.com/vllm-project/vllm

openbayes算力平台使用教程

Tue, 13 May 2025 14:39:02 +0800

基础知识

vllm使用教程

Tue, 13 May 2025 14:14:39 +0800

参考知乎

常用命令

# 通过魔搭社区构建
VLLM_USE_MODELSCOPE=true vllm serve [魔搭建社区的模型名，如：Qwen/Qwen3-0.6B-FP8] --enable-reasoning --reasoning-parser deepseek_r1

# 通过本地模型文件构建
python -m vllm.entrypoints.openai.api_server --model ~/Qwen3-0.6B --served-model-name Qwen3-0.6B --max-model-len=2048

基本使用

什么是 vLLM？

vLLM 是一个为大型语言模型（LLM）推理和服务而设计的高性能开源库。它通过引入创新的技术，如 PagedAttention 和连续批处理（Continuous Batching），显著提高了吞吐量并有效管理内存，使得在生产环境中部署 LLM 更加高效。

核心优势:

高吞吐量: 通过 PagedAttention 和连续批处理等技术，vLLM 能够处理更多的请求。
内存效率: PagedAttention 有效地管理注意力机制中的键（key）和值（value）缓存，减少内存浪费和碎片。
易用性: 与 Hugging Face Transformers 模型无缝集成，并提供 OpenAI 兼容的 API 服务器。
灵活性: 支持多种解码算法（如并行采样、束搜索等）、张量并行和流水线并行以进行分布式推理。
广泛的模型支持: 支持许多流行的开源 LLM。

1. 安装 vLLM

vLLM 需要 Linux 环境、Python 3.8 或更高版本，以及具有 CUDA 计算能力 7.0 或更高版本的 NVIDIA GPU（例如 V100, T4, RTX20xx, A100, L4, H100 等）。vLLM 通常使用特定版本的 CUDA 进行编译（例如 CUDA 12.1）。

推荐使用 Conda 创建新环境:

conda create -n vllm-env python=3.9 -y
conda activate vllm-env

通过 pip 安装 (通常需要与你的 CUDA 版本匹配):

# 安装与 CUDA 12.1 兼容的 vLLM
pip install vllm

如果你本地的 CUDA 版本不同，或者想使用特定的 PyTorch 版本，可能需要从源码编译或者安装特定 CUDA 版本的预编译包。请参考 vLLM 官方文档获取最新的安装指南和针对不同 CUDA 版本的安装命令。

查看官方文档获取最新和更详细的安装说明: https://docs.vllm.ai/en/latest/getting_started/installation.html

2. 基本离线推理 (Python API)

你可以直接在 Python 脚本中使用 vLLM 进行离线推理。

from vllm import LLM, SamplingParams

# 准备你的提示语列表
prompts = [
 "Hello, my name is",
 "The president of the United States is",
 "The capital of France is",
 "The future of AI is",
]

# 初始化采样参数
# temperature: 控制生成文本的随机性，值越高越随机。
# top_p: 核采样，选择概率总和达到 top_p 的最小词汇集。
# max_tokens: 控制生成的最大 token 数量。
sampling_params = SamplingParams(temperature=0.8, top_p=0.95, max_tokens=50)

# 从 Hugging Face Hub 加载模型
# 你可以选择不同的模型，例如 "meta-llama/Llama-2-7b-chat-hf", "mistralai/Mistral-7B-v0.1" 等
# 确保你已经登录 Hugging Face CLI 并且接受了模型的 license (如果需要)
# export HF_TOKEN=YOUR_HUGGINGFACE_TOKEN (如果模型需要授权)
llm = LLM(model="facebook/opt-125m") # 这是一个小模型，方便快速测试

# 执行推理
outputs = llm.generate(prompts, sampling_params)

# 打印输出结果
for output in outputs:
 prompt = output.prompt
 generated_text = output.outputs[0].text
 print(f"Prompt: {prompt!r}, Generated: {generated_text!r}")

3. 启动 OpenAI 兼容的 API 服务器

vLLM 可以启动一个与 OpenAI API 兼容的服务器，允许你通过 HTTP 请求与模型交互，这对于将 LLM 集成到现有应用中非常方便。

# 启动 API 服务器，将 MODEL_NAME 替换为你想要服务的 Hugging Face 模型名称
# 例如: facebook/opt-125m, meta-llama/Llama-2-7b-chat-hf
# --model: 指定要加载的模型
# --tensor-parallel-size: (可选) 如果你有多个 GPU，可以使用张量并行来加速，例如 --tensor-parallel-size 2 表示使用 2 个 GPU
python -m vllm.entrypoints.openai.api_server --model="facebook/opt-125m"

# 服务器默认运行在 http://localhost:8000
# 你可以通过 --host 和 --port 参数修改
# 例如: python -m vllm.entrypoints.openai.api_server --model="facebook/opt-125m" --host 0.0.0.0 --port 8080

一旦服务器运行起来，你就可以像使用 OpenAI API 一样向它发送请求。

使用 curl 测试 API 服务器 ( Completions API - 适用于非聊天模型 ):

curl http://localhost:8000/v1/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "facebook/opt-125m",
 "prompt": "San Francisco is a",
 "max_tokens": 7,
 "temperature": 0
 }'

使用 curl 测试 API 服务器 ( Chat Completions API - 适用于聊天模型 ):

对于像 Llama-2-chat 这样的聊天模型，你应该使用 /v1/chat/completions 端点。

# 假设你已经使用聊天模型启动了服务器，例如:
# python -m vllm.entrypoints.openai.api_server --model="meta-llama/Llama-2-7b-chat-hf"

curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "meta-llama/Llama-2-7b-chat-hf",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Who won the world series in 2020?"}
 ],
 "max_tokens": 50,
 "temperature": 0.7
 }'

使用 Python openai 库与 vLLM 服务器交互:

首先，安装 openai 库: pip install openai

import openai

# 修改 openai.api_base 指向你的 vLLM 服务器
openai.api_base = "http://localhost:8000/v1"
openai.api_key = "YOUR_API_KEY" # 对于本地 vLLM 服务器，API 密钥通常是可选的或任意字符串，如 "EMPTY"

# 列出可用的模型 (会返回你通过 --model 参数指定的模型)
models = openai.Model.list()
print("Available models:", models.data)

if models.data:
 model_name = models.data[0].id # 获取第一个可用的模型名称
 print(f"Using model: {model_name}")

 # Chat Completions 示例
 try:
 chat_completion = openai.ChatCompletion.create(
 model=model_name,
 messages=[
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "What is the capital of France?"}
 ],
 temperature=0.7,
 max_tokens=50
 )
 print("Chat Completion:", chat_completion.choices[0].message['content'])
 except Exception as e:
 print(f"Error in Chat Completion: {e}")

 # Legacy Completions 示例 (如果模型支持)
 try:
 completion = openai.Completion.create(
 model=model_name,
 prompt="The capital of France is",
 max_tokens=10,
 temperature=0
 )
 print("Completion:", completion.choices[0].text)
 except Exception as e:
 print(f"Error in Completion: {e}")
else:
 print("No models available from the server.")

4. 常用参数说明

无论是在 Python API 还是 OpenAI 兼容服务器中，一些核心参数是共通的：

model (字符串): 指定要加载的 Hugging Face 模型仓库的名称 (例如, "facebook/opt-125m", "meta-llama/Llama-2-7b-chat-hf")。
temperature (浮点数, 通常在 0.0 到 2.0 之间): 控制输出的随机性。较低的温度使输出更具确定性和重复性，较高的温度则更具创造性和多样性。建议值：0.7-1.0 适用于创造性任务，0.0-0.2 适用于需要精确和事实性回答的任务。
top_p (浮点数, 通常在 0.0 到 1.0 之间): 核采样参数。模型会从概率总和达到 top_p 的最小词汇集合中进行采样。例如，top_p=0.9 表示只考虑概率加起来达到90%的最可能的词。通常不与 temperature 同时设为非默认值。
top_k (整数): 从 logits 最高的 K 个 token 中进行采样。如果设置为非零值，则会覆盖 top_p。
max_tokens (整数): 生成响应的最大 token 数量。注意这包括了输入提示和输出。
n (整数): 为每个输入提示生成多少个独立的候选项。
presence_penalty (浮点数): 对已经出现在文本中的 token 施加惩罚，降低重复性。
frequency_penalty (浮点数): 与 presence_penalty 类似，但惩罚的程度与 token 在文本中出现的频率成正比。
stop (字符串或列表): 一个或多个停止序列。当模型生成这些序列时，会停止进一步的生成。

查阅 vLLM 和 OpenAI 的文档可以获取更详细的参数列表和解释。

5. 进阶特性 (简介)

vLLM 支持许多高级功能以优化性能和扩展能力：

量化 (Quantization): 支持如 AWQ, GPTQ, SqueezeLLM 等量化方法，以更低的精度（如 INT8, INT4）运行模型，减少内存占用和加速推理，但可能会有轻微的精度损失。
- 示例 (GPTQ): llm = LLM(model="TheBloke/Llama-2-7B-GPTQ")
LoRA (Low-Rank Adaptation): 高效地微调或加载经过 LoRA 适配器调整的模型。vLLM 支持动态加载和卸载 LoRA 适配器。
分布式推理 (Distributed Inference):
- 张量并行 (Tensor Parallelism): 将模型的权重和计算分布到多个 GPU 上，以运行单个大型模型。在启动服务器或 LLM 类时使用 tensor_parallel_size 参数。
```
# Python API
llm = LLM(model="your_large_model", tensor_parallel_size=4) # 使用 4 个 GPU
```
```
# API 服务器
python -m vllm.entrypoints.openai.api_server --model="your_large_model" --tensor-parallel-size 4
```
- 流水线并行 (Pipeline Parallelism): (vLLM 对此的支持可能仍在发展中，主要依赖于底层模型的实现方式，通常张量并行更为直接)
前缀缓存 (Prefix Caching / Automatic Prefix Caching): 自动缓存和重用共享前缀的 KV 缓存，加速具有共同前缀的请求序列。
投机解码 (Speculative Decoding): 使用一个小的、快速的草稿模型来预测多个 token，然后由主模型进行验证，以加速解码过程。
多模态支持: vLLM 正在扩展对多模态模型（如 LLaVA）的支持。

这些高级特性的具体用法请参考 vLLM 的官方文档和示例。

6. 常见用例

vLLM 因其高性能和高吞吐量，非常适合以下场景：

实时聊天机器人和虚拟助手: 需要低延迟响应。
大规模文本生成服务: 如内容创作、代码生成、摘要等。
批处理推理任务: 对大量数据进行离线处理。
需要高效扩展 AI 驱动的工作流: 当用户量或数据量增长时，vLLM 可以帮助系统保持性能。
研究和实验: 快速迭代和测试不同的 LLM。

7. 更多资源

vLLM GitHub 仓库: https://github.com/vllm-project/vllm
vLLM 官方文档: https://docs.vllm.ai/
vLLM 示例: https://docs.vllm.ai/en/latest/getting_started/examples/examples_index.html

实战

vllm部署 Qwen3 ：使用4090 （成功）

https://www.modelscope.cn/models/Qwen/Qwen3-32B

我使用的是bayes平台，首先创建一个容器

我选的是自带vllm环境的容器,所以并没有涉及到安装环境

执行如下命令

VLLM_USE_MODELSCOPE=True vllm serve Qwen/Qwen3-0.6B --enable-reasoning --reasoning-parser deepseek_r1

首先查看有哪些模型

curl http://localhost:8000/v1/models

# 如果jq没安装 apt install jq

curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "Qwen/Qwen3-0.6B",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Who won the world series in 2020?"}
 ]
 }' | jq .

也可以使用如下的py代码

from openai import OpenAI
client = OpenAI(
 base_url="http://localhost:8000/v1",
 api_key="token-abc123", # 随便设，只是为了通过接口参数校验
)

completion = client.chat.completions.create(
 model="Qwen/Qwen3-0.6B",
 messages=[
 {"role": "user", "content": "你是什么模型？"}
 ]
)

print(completion.choices[0].message)

vllm部署 Qwen3 ：使用v100_32 （失败）

我使用的是bayes平台，首先创建一个容器

然后是环境的准备

推荐使用uv安装，因为快啊


mkdir qwen3

cd qwen3

pip install uv

uv venv

source ./venv/bin/activate

# uv pip install cudatoolkit=12.1 -y

# uv pip install torch torchvision torchaudio # 也可以配置一下镜像源

# python -c 'import torch; print(torch.cuda.is_available())'

uv pip install vllm ray transformers accelerate

# 创建conda环境
conda create -n qwen3 python=3.10 -y # -y表示无需确认
conda activate qwen3

# 安装CUDA相关依赖（确保与vLLM兼容的CUDA版本）
# vLLM通常编译于CUDA 12.1
conda install cudatoolkit=12.1 -y

# 安装PyTorch（确保与CUDA版本兼容）
pip install torch torchvision torchaudio

# 检查CUDA是否正确安装
python -c 'import torch; print(torch.cuda.is_available())'

pip install vllm ray transformers accelerate

然后配置魔搭（许多服务器不支持翻墙，所以hugging face可能难用）

pip install modelscope

之后vllm应用就可以默认从modelscope上下载镜像了。

https://www.modelscope.cn/models/Qwen/Qwen3-32B

VLLM_USE_MODELSCOPE=True vllm serve Qwen/Qwen3-0.6B --enable-reasoning --reasoning-parser deepseek_r1

然后修改成以下命令

VLLM_USE_MODELSCOPE=True vllm serve Qwen/Qwen3-0.6B --enable-reasoning --reasoning-parser deepseek_r1 --dtype=half

此外，我们也可以用本地的镜像文件进行模型部署，方法如下（我这里选择用本地，比较灵活）。

git lfs clone https://www.modelscope.cn/Qwen/Qwen3-0.6B.git

python -m vllm.entrypoints.openai.api_server --model ~/Qwen3-0.6B --served-model-name Qwen3-0.6B --max-model-len=2048

之后进行测试：可以使用python进行测试：

from openai import OpenAI
client = OpenAI(
 base_url="http://localhost:8000/v1",
 api_key="token-abc123", # 随便设，只是为了通过接口参数校验
)

completion = client.chat.completions.create(
 model="Qwen3-0.6B",
 messages=[
 {"role": "user", "content": "你是什么模型？"}
 ]
)

print(completion.choices[0].message)

增量学习研究综述：理论、方法、应用与未来展望

Fri, 09 May 2025 16:51:10 +0800

增量学习研究综述：理论、方法、应用与未来展望

前言

本报告旨在对增量学习（Incremental Learning, IL）领域进行系统性梳理与深入探讨。增量学习，亦常被称为持续学习（Continual Learning, CL）或终身学习（Lifelong Learning, LLL），是机器学习领域中一个至关重要的研究方向。它致力于赋予智能系统一种能够像人类一样持续从数据流中获取新知识，同时保留、整合甚至优化已有知识的能力。本报告将详细阐述增量学习的基本定义与核心原理，剖析其面临的关键挑战，特别是灾难性遗忘问题。在此基础上，报告将系统介绍各类主流的增量学习方法，并探讨相关的开源代码项目与研究框架。此外，本报告将重点关注增量学习在光谱分析领域的应用，涵盖高光谱图像分析、化学计量学以及天文光谱数据处理等方向，并结合具体案例进行比较分析。同时，报告还将解析相关领域的重要研究论文，讨论评估增量学习系统性能的指标与实验设置，并将其与在线学习、迁移学习、元学习等相关学习范式进行比较。最后，本报告将展望增量学习未来的发展趋势与面临的挑战，以期为相关领域的研究人员与实践者提供有价值的参考。

1. 增量学习的基础

1.1. 增量学习（IL）、持续学习（CL）与终身学习（LLL）的定义

增量学习（IL）是指机器学习系统在不断接收新样本的过程中，能够持续学习新知识，同时保留大部分先前习得知识的能力，并且这一过程通常不依赖于对所有原始训练数据的访问。这种学习范式被认为是机器学习的一个特殊场景，其目标更贴近于人类的行为和思维模式，使模型能够像生物体的大脑系统一样，在其“一生”中不断学习新知识并巩固旧知识。在学术文献和研究社区中，“增量学习”、“持续学习”和“终身学习”这三个术语经常被互换使用。它们共同的核心目标是使模型能够从连续的信息流中学习，并在学习新知识的同时保留、整合甚至优化旧知识。尽管这些术语在侧重点上可能存在细微差别——例如，“终身学习”有时更强调在一个非常长的时间跨度内积累多样化技能的广度——但在本报告的范畴内，它们主要被视为同义词，共同指向应对顺序知识获取和保持的核心挑战。

增量学习的研究历史已超过20年，其早期思想更多地起源于认知神经科学对人类记忆和遗忘机制的研究。许多增量学习论文的创新点也受到了认知科学发展成果的启发。这种对生物启发机制的关注，进一步凸显了增量学习致力于模拟人类学习能力的本质。强调在学习新知识时无需访问全部原始数据，不仅是增量学习的一个关键特征，也揭示了其重要的实际应用驱动力，包括数据隐私保护、存储资源限制以及避免大规模重复训练带来的计算效率问题。

1.2. 核心原理：稳定性-可塑性困境

增量学习的核心原理在于模型需要在学习新知识和巩固旧知识之间达到一种精妙的平衡。具体而言，模型必须同时具备“可塑性”（plasticity）以吸收新信息，以及“稳定性”（stability）以巩固现有知识。这种对立统一的需求构成了增量学习中著名的“稳定性-可塑性困境”（stability-plasticity dilemma）。模型需要足够的可塑性来学习新任务或适应新数据的分布。然而，如果模型参数在学习新知识时发生过大的变化，就可能破坏先前学习到的表示，导致对旧知识的遗忘。反之，如果为了防止遗忘而使网络权重过于稳定，模型又可能难以有效地学习新任务或适应环境的变化。

传统的机器学习模型通常假设训练数据是独立同分布的，并且数据分布是固定的或平稳的。当模型需要从非平稳的数据流中持续学习时，新知识的引入很容易干扰甚至覆盖旧知识，导致模型在旧任务上的性能显著下降。稳定性-可塑性困境是增量学习领域的核心理论挑战。一个增量学习系统的有效性，在很大程度上取决于其驾驭这一困境的能力。因此，所有旨在解决灾难性遗忘的增量学习方法，其本质都可以被看作是管理这种两难困境的策略。

生物学上的启发为理解和解决这一困境提供了有益的视角。例如，人脑中海马体（hippocampus）和新皮质（neocortex）的分工常被提及：海马体能够快速学习新信息并具有短期适应性，而新皮质则负责缓慢学习和形成长期记忆。一些增量学习方法，如基于回放的策略，便明确借鉴了这种生物学机制，试图模拟大脑在新旧知识整合过程中的记忆与巩固方式。这种生物启发不仅为算法设计提供了思路，也加深了对增量学习本质的理解。

1.3. 中心挑战：灾难性遗忘（CF）

灾难性遗忘（Catastrophic Forgetting, CF）是增量学习领域长期存在且最为核心的挑战。它指的是当一个预训练好的模型在学习新任务或接收新数据时，其在新知识上的性能得到提升，但先前学习到的关于旧任务或旧数据的知识却被严重破坏，导致在旧任务上的性能急剧下降甚至完全丢失的现象。灾难性遗忘的根本原因在于，当模型学习新知识时，其内部参数（如神经网络的权重）会根据新数据的特性进行调整。由于新数据的分布可能与旧数据存在显著差异，这些调整可能会覆盖或干扰对旧知识至关重要的参数配置。深度神经网络（DNNs）由于其高度参数化和复杂的非线性映射能力，对输入数据的分布变化尤为敏感，因此特别容易遭受灾难性遗忘的影响。

灾难性遗忘不仅仅是模型性能的简单下降，它更是构建能够持续适应动态环境的人工智能系统的根本障碍。如果一个系统在学习新事物时会忘记旧事物，那么它就无法真正实现知识的积累和持续进化。因此，有效缓解或克服灾难性遗忘，是增量学习研究的首要目标，也是衡量增量学习算法成功与否的关键标准。灾难性遗忘的严重程度也与具体的学习场景有关。例如，在任务增量学习（task-incremental learning）场景中，模型在推理时会被告知当前任务的ID，因此模型不必区分来自不同任务的类别，灾难性遗忘的挑战相对较小。然而，在更具挑战性的类增量学习（class-incremental learning）场景中，模型在推理时无法访问任务ID，这就要求模型具备从所有已学习任务中区分所有类别的能力。在这种情况下，如果旧类别的表征被新类别的学习过程所破坏，灾难性遗忘的问题会更加突出，因为模型失去了区分新旧类别的能力。

2. 增量学习的方法论

为了应对灾难性遗忘并平衡稳定性与可塑性，研究者们提出了多种增量学习方法。这些方法大致可以归为以下几类：

2.1. 基于回放的策略（Exemplar and Generative）

基于回放（Replay-based）的方法是增量学习中最直观且有效的策略之一。其核心思想是在学习新任务时，让模型“复习”先前任务的知识。根据回放样本的来源，主要分为两类：

基于样本回放（Exemplar Replay）： 该策略在学习完每个任务后，保存一部分当前任务的原始样本（称为“记忆样本”或“exemplars”）在一个固定大小的内存空间中。在后续学习新任务时，这些存储的旧样本会与新任务的样本混合在一起共同训练模型。这一过程类似于人脑将新信息快速存储在海马体中，然后通过不断回放新旧信息，缓慢地将其整合到新皮质系统中，以尽量减少新信息整合过程对现有知识的干扰。iCaRL（Incremental Classifier and Representation Learning）是一个典型的样本回放方法，它结合了知识蒸馏和基于原型的样本回放策略。样本回放方法虽然有效，但也面临一些挑战。首先，存储记忆样本需要额外的内存空间，并且随着任务数量的增加，有限的存储空间可能难以容纳所有旧任务的代表性样本。其次，如何选择最具代表性的记忆样本以最大化回放效果，本身就是一个研究问题。例如，iCaRL假设越靠近类别特征均值的样本越有代表性。
基于生成回放（Generative Replay / Pseudo-Rehearsal）： 为了克服样本回放中存储原始数据带来的内存和隐私问题，研究者提出了生成回放策略。该策略不直接存储旧任务的原始样本，而是训练一个生成模型（如生成对抗网络 GANs 或变分自编码器 VAEs）来学习旧任务的数据分布。在学习新任务时，利用该生成模型生成与旧数据分布相似的“伪样本”（pseudo-samples），并将这些伪样本与新任务的真实样本一同用于模型训练。FearNet便是采用此类策略的一个例子。生成回放的优势在于可以显著减少对原始数据的存储需求，并在一定程度上缓解数据隐私泄露的风险。然而，训练高质量的生成模型本身具有一定难度，生成的伪样本可能无法完全捕捉真实数据的复杂分布，从而影响回放的效果。

总的来说，基于回放的方法通过在新旧知识之间建立直接的联系来对抗遗忘，通常能够取得较好的性能。然而，它们也引入了关于内存开销、计算成本以及（在样本回放中）数据隐私的权衡。选择样本回放还是生成回放，往往取决于具体的应用场景、资源限制和隐私需求。

2.2. 基于正则化的策略

基于正则化（Regularization-based）的策略通过在模型学习新任务时，向损失函数中添加额外的约束项，来限制模型参数的更新幅度，从而保护先前任务学习到的重要知识。这类方法的核心思想是选择性地降低模型对旧知识相关参数的可塑性。根据正则化对象的不同，主要可以分为权重正则化和功能正则化（常通过知识蒸馏实现）。

权重正则化（Weight Regularization）： 这类方法的核心思想是识别并保护对先前任务至关重要的模型权重。在学习新任务时，通过施加惩罚来限制这些重要权重的改变幅度。例如，弹性权重巩固（Elastic Weight Consolidation, EWC）算法利用费雪信息矩阵（Fisher Information Matrix）来估计每个参数对于旧任务的重要性，对重要参数的修改施加二次惩罚。其他类似的方法还包括突触智能（Synaptic Intelligence, SI）和记忆感知突触（Memory Aware Synapses, MAS）。这些方法的挑战在于如何准确且高效地度量参数的重要性。不同的方法采用不同的启发式策略来估计这种重要性，例如EWC基于参数对任务损失函数梯度的敏感度，而SI则通过参数在学习过程中的路径积分来衡量。
知识蒸馏（Functional Regularization）： 这类方法也称为基于数据约束或功能正则化的方法，其目标是约束新旧模型在功能层面的一致性，而非直接约束参数本身。核心思想是利用旧模型在新数据或部分旧数据上的输出（“软标签”）作为指导，来训练新模型。通过使新模型在新任务上的预测行为与旧模型在新任务或旧任务上的预测行为相近，从而将旧模型的“知识”蒸馏到新模型中，缓解灾难性遗忘。Learning without Forgetting (LwF) 是一个典型的知识蒸馏方法。它通常不需要存储旧数据，而是利用新任务的数据来生成旧模型的软标签。基于正则化的方法通常被认为是一类“优雅”的增量学习方法，因为它们很多时候不需要存储旧数据，从而节省了存储空间并避免了隐私问题。然而，它们的有效性可能高度依赖于新旧任务之间的相关性。如果任务差异过大，正则化约束可能难以有效地保护旧知识，甚至可能出现任务混淆。此外，随着学习任务数量的增加，一些正则化方法的训练时间可能会线性增长，并且引入的正则项也可能无法完全约束模型在新任务上的优化过程。

2.3. 基于参数隔离和架构的策略

基于参数隔离（Parameter Isolation）或架构（Architecture-based）的策略通过为每个任务分配独立的模型参数或网络结构，来从根本上避免不同任务之间的参数相互干扰，从而防止灾难性遗忘。

参数隔离（Parameter Isolation）： 这类方法为每个新任务分配一组独立的模型参数或一个独立的子网络。当学习新任务时，模型只更新与当前任务相关的参数，而先前任务学习到的参数则被“冻结”或保持不变。这样，新知识的学习就不会覆盖旧知识。
动态架构 / 模型扩展（Dynamic Architectures / Model Expansion）： 这类方法在学习新任务时，会根据需要动态地扩展模型的结构，例如增加新的神经元、层或整个子网络来学习新知识，而先前任务学习到的网络部分则保持不变或受到保护。渐进式神经网络（Progressive Neural Networks, PNN）和动态扩展网络（Dynamically Expandable Networks, DEN）是此类方法的代表。PNN为每个新任务添加新的网络列，并通过横向连接从先前学习的任务列中迁移知识。

基于参数隔离和架构的方法能够非常有效地避免灾难性遗忘，因为不同任务的知识存储在物理上分离的参数中。然而，这类方法的主要缺点是模型容量会随着任务数量的增加而快速增长，导致参数量和计算量显著增加，可能难以扩展到任务数量非常多或非常复杂的场景。此外，如果任务之间完全隔离参数，可能会阻碍知识在不同任务间的正向迁移。因此，如何在隔离参数以防止遗忘的同时，有效地实现知识共享和迁移，是这类方法需要解决的一个关键问题。在某些架构策略中，会引入一个选择器模块，用于在推理时判断应该使用哪个任务专属的模型或参数子集。

2.4. 混合及新兴方法

随着增量学习研究的深入，越来越多的方法开始融合不同策略的优点，形成了混合型（Hybrid）方法。这些方法试图通过结合多种机制来更全面地应对灾难性遗忘和稳定性-可塑性困境。例如，iCaRL 通过结合知识蒸馏（一种正则化技术）和样本回放（一种回放技术）来提升性能。这种趋势表明，单一策略往往难以在所有方面都达到最优，通过优势互补可以设计出更强大的增量学习系统。

与此同时，增量学习的研究领域也在不断扩展，催生了一些新兴的研究方向和方法。其中，联邦类增量学习（Federated Class-Incremental Learning, FCIL）是一个备受关注的新兴领域。FCIL 将增量学习的挑战置于联邦学习的框架之下，旨在让多个参与方在不共享私有数据的前提下，协同训练一个能够持续学习新类别并适应任务序列的全局模型。在FCIL中，传统的联邦学习算法（如FedAvg）同样面临严重的灾难性遗忘问题。针对这一挑战，研究者们提出了一些新的方法，例如 FedGTG (Federated Global Twin Generator) 框架，它在服务器端训练一个数据生成器和特征生成器来创建所有已见类别的合成信息，然后发送给客户端，客户端再利用这些信息来辅助本地模型的知识保持和新任务学习。这些混合型和新兴方法的出现，反映了增量学习领域正朝着更复杂、更贴近实际应用场景的方向发展。它们不仅要解决核心的灾难性遗忘问题，还需要考虑数据隐私、通信效率、去中心化协作等额外的约束条件。

3. 增量学习研究的代码库与框架

为了促进增量学习领域的研究与发展，社区中涌现出一些优秀的开源代码库和框架。这些工具为研究者提供了标准化的实验平台、预实现的算法和评估指标，极大地降低了研究门槛，加速了算法的迭代与比较。

3.1. PyCIL (Python Class-Incremental Learning) 深度解析

PyCIL 是一个基于 PyTorch 的开源工具箱，专门为类增量学习（Class-Incremental Learning, CIL）设计。CIL 是增量学习中一个极具挑战性的场景，要求模型在不断学习新类别的同时，能够区分所有已见类别，且通常在测试时没有任务ID的提示。PyCIL 的目标是通过实现一系列关键的CIL算法，来减轻研究人员的负担，并推动该领域的基础研究。该工具箱包含了众多CIL算法的实现，既有奠基性的工作，如 EWC (Elastic Weight Consolidation)、LwF (Learning without Forgetting) 和 iCaRL (Incremental Classifier and Representation Learning)，也涵盖了当前最先进的算法，例如 DER (Dynamically Expandable Representation)、FOSTER (Feature Boosting and Compression for Class-incremental Learning)、MEMO (Memory-Efficient Class-Incremental Learning)、BEEF (Bi-Compatible Class-Incremental Learning via Energy-Based Expansion and Fusion) 以及最新的 TagFex 等。这种广泛的算法覆盖使得 PyCIL 成为进行CIL算法复现、比较和创新的重要资源。

PyCIL 为常用的CIL基准数据集（如 CIFAR-100, ImageNet-100, ImageNet-1000）提供了预处理流程。研究者可以通过配置文件灵活地设置实验参数，包括记忆缓存大小（memory-size）、初始阶段的类别数量（init-cls）、每个增量阶段新增的类别数量（increment）、骨干网络类型（convnet-type）以及随机种子（seed）等。此外，PyCIL 也积极跟进研究前沿，支持基于预训练模型（如CLIP）的CIL方法，并发布了相关的 PILOT 工具箱。PyCIL 以其对CIL领域的专注和全面的算法实现，为研究者提供了一个强大而专业的平台。其持续更新和对最新SOTA方法的及时跟进（例如，其更新日志中提到“TagFex. State-of-the-art method of 2025!”），表明了其维护团队致力于保持工具箱在前沿研究中的领先地位。该项目采用MIT许可证开源，并已在《SCIENCE CHINA Information Sciences》上发表。

3.2. Avalanche 深度解析

Avalanche 是另一个基于 PyTorch 的端到端持续学习库，由 ContinualAI 这一非营利性组织维护和推动。与 PyCIL 专注于CIL不同，Avalanche 的目标是提供一个更通用、更全面的持续学习研究平台，支持广泛的CL场景、动态架构、数据流处理以及增量式的训练和评估方法。Avalanche 的架构设计具有良好的模块化特性，主要包含以下核心模块：

Benchmarks： 提供统一的数据处理API，用于从各种数据集中生成数据流，并包含了主流的CL基准测试（如 PermutedMNIST, Split CIFAR 等）。
Training： 包含模型训练所需的所有实用工具，支持便捷地实现新的CL策略，并预置了一系列CL基线算法和SOTA算法。
Evaluation： 提供评估CL算法性能的各种指标和工具，支持对持续学习系统所关注的各个方面进行全面评估，并集成了高级日志记录和绘图功能（如原生TensorBoard支持）。
Models： 提供实现模型扩展和任务感知模型的实用程序，以及一系列可用于CL实验的预训练模型和流行架构。
Logging： 支持标准的stdout、文件以及TensorBoard等多种日志记录方式。

一个显著的特点是 Avalanche 将其能力扩展到了持续强化学习（Continual Reinforcement Learning, CRL）领域，推出了 Avalanche RL。Avalanche RL 建立在 Avalanche 的核心结构之上，支持 OpenAI Gym 接口的环境，能够处理环境流，并实现了如 A2C、DQN 等CRL算法。Avalanche 强调研究的可复现性、模块化、可重用性、效率和可移植性。作为一个由 ContinualAI 社区驱动的开源项目，Avalanche 具有强大的社区支持和协作基础，这有助于其广泛采纳和持续发展，使其成为一个覆盖从监督学习到强化学习等多种CL范式的综合性研究工具。

3.3. 其他值得注意的资源概述

除了 PyCIL 和 Avalanche 这两个专注于增量/持续学习的库之外，还有一些其他资源对该领域的研究者非常有价值。一个重要的资源是名为 “Awesome_Continual-Lifelong-Incremental_learning” 的 GitHub 仓库。这类 “Awesome” 列表通常由社区成员共同维护，汇集了特定领域内的大量高质量资源，包括最新的研究论文、相关的代码实现、学术研讨会信息以及挑战赛等。对于增量学习这样一个快速发展的领域，这样的列表为研究者提供了一个便捷的入口，帮助他们快速了解领域动态，发现相关的研究工作和工具。当然，通用的机器学习框架如 TensorFlow、PyTorch 和 Scikit-learn 也是进行增量学习研究的基础。它们提供了构建和训练机器学习模型的核心组件。然而，这些通用框架本身并不直接提供针对增量学习特定挑战（如灾难性遗忘管理、特定基准设置、专用评估指标等）的内建解决方案。正是由于这些通用框架在直接支持增量学习方面的局限性，才凸显了像 PyCIL 和 Avalanche 这样的专用库的价值。这些专用库在通用框架的基础上，封装了增量学习特有的逻辑和工具，从而极大地简化了相关研究的复杂度。

表1：PyCIL 与 Avalanche 特性对比

特性	PyCIL (Python Class-Incremental Learning)	Avalanche
主要关注点	类增量学习 (CIL)	通用持续学习 (CL)，包括CIL, 领域IL, 任务IL, 持续强化学习 (CRL) 等
核心支持算法/策略举例	EWC, LwF, iCaRL, DER, FOSTER, MEMO, BEEF, TagFex 等众多CIL SOTA方法	包含多种CL基线和SOTA策略，如EWC, LwF, GEM, Replay等，并支持用户自定义策略
基准测试处理	为CIFAR-100, ImageNet-100/1000 等CIL常用数据集提供预处理和标准设置	提供PermutedMNIST, Split CIFAR等多种CL基准，并有灵活的基准生成器
强化学习支持	不直接支持	通过Avalanche RL模块支持持续强化学习，兼容Gym环境
社区/维护	由南京大学LAMDA实验室主导开发和维护，有特定研究社区关注	由ContinualAI非营利组织维护，拥有更广泛的国际社区支持和协作
独特优势	对CIL场景的深度专注和算法覆盖的全面性，紧跟CIL研究前沿	框架的通用性和模块化设计，支持多样化的CL场景和CRL，强大的社区生态

这张对比表清晰地展示了 PyCIL 和 Avalanche 各自的定位和优势。研究者可以根据其具体的研究方向和需求来选择合适的工具。例如，如果研究重点是图像分类中的类增量学习，PyCIL 可能是更直接的选择；而如果研究兴趣在于更广泛的持续学习范式、跨领域应用或持续强化学习，Avalanche 则提供了更全面的支持。

4. 增量学习的应用与比较案例研究

增量学习作为一种旨在赋予机器持续学习能力的范式，其应用潜力遍及众多需要模型适应动态变化环境的领域。

4.1. 通用应用领域

增量学习的应用范围非常广泛，几乎涵盖了所有传统机器学习能够应用的领域，并在这些领域中解决了数据和任务不断演化带来的挑战。在计算机视觉领域，图像分类和各种视觉任务是增量学习研究的传统阵地。模型需要不断学习识别新的物体类别，或在变化的视觉场景中保持性能。自然语言处理（NLP）也是增量学习的重要应用方向，例如，在对话系统中，模型需要学习新的对话主题或用户意图；在关系抽取和命名实体识别任务中，新的实体类型或关系模式会不断出现。机器人技术领域对增量学习的需求尤为迫切。机器人需要在其生命周期中学习新的物体、掌握新的技能、适应不断变化的环境，例如实现终身同步定位与建图（Lifelong SLAM）以及持续改进的感知能力。在网络安全领域，特别是入侵检测系统（IDS）中，新的攻击手段和恶意软件模式层出不穷，增量学习可以帮助IDS模型实时适应这些新出现的威胁。医疗健康领域也从增量学习中获益，例如，模型可以学习识别新的疾病模式或适应不同医疗设备产生的医学影像数据。此外，推荐系统需要根据用户兴趣的变化和新项目的出现来更新推荐模型。自动驾驶系统必须能够识别新的交通标志、障碍物类型或适应不同的道路和天气条件。社交媒体内容分析中，模型需要应对不断出现的新的欺诈手段、不当内容类型或热门话题。甚至在虚假音频检测等特定应用中，随着新的音频合成技术的出现，检测模型也需要持续更新其知识库。电子商务平台也面临每日新增产品类型的问题，需要分类模型能够增量学习。这些多样化的应用场景共同的特点是数据流的非平稳性和任务需求的演化性。在这些场景下，从头开始完全重新训练模型不仅成本高昂，有时甚至是不现实的（例如，由于数据隐私或存储限制）。增量学习提供了一种更有效、更灵活的解决方案，使得AI系统能够持续进化，真正适应动态的世界。

4.2. 不同场景下的性能比较分析

对增量学习方法进行比较分析可以揭示其在不同场景下的有效性和局限性。在入侵检测系统（IDS）领域的一项研究中，基于增量学习的SVM模型在CI-CIDS 2017数据集上的表现优于传统的批量学习方法。具体而言，增量学习SVM在精确率（98% vs 95%）、召回率（97% vs 93%）和F1分数（97.5% vs 94%）上均取得了更好的结果。这表明增量学习能够更好地适应实时出现的网络威胁，尽管其计算需求可能相对更高。这突出了增量学习在需要快速响应动态变化环境的应用中的价值。在更具挑战性的少样本类增量学习（Few-Shot Class-Incremental Learning, FSCIL）场景中，传统的评估方式面临新的问题。通常在标准CIL中被视为性能上限的联合训练（joint training，即在所有新旧数据上一起训练）方法，在FSCIL中由于严重的类别不平衡可能导致的任务间类别分离困难，而不再是一个有意义的上限基准。为此，有研究提出了针对FSCIL的新的联合训练基准，该基准集成了不平衡学习技术，以弥合基础类别和增量类别之间的性能差距。同时，研究也指出现有FSCIL方法在实验设置和评估方面存在不一致性，呼吁更规范的比较协议。这表明，随着增量学习向更复杂和资源受限的场景发展，我们需要更细致和针对性的评估方法。对通用CIL算法的计算效率也存在一些反思。一项在ImageNet-1K数据集上进行的分析发现，一些被高度引用的CIL算法，在仅考虑旧数据不可用的约束下，其计算开销甚至超过了在每个任务阶段都对所有数据进行简单重训的成本。这一发现对那些主要以避免访问旧数据为目标的CIL算法的实用性提出了质疑，强调了在评估IL方法时综合考虑准确性和效率的重要性。在持续指令调优（Continual Instruction Tuning, CoIN）的背景下，对LwF、EWC等方法在一系列包含10个数据集、横跨8个任务（如ScienceQA, TextVQA等）的基准套件上的评估，也显示了不同方法在各项任务上的性能和后向迁移（BWT）表现各异。这进一步印证了增量学习算法的性能具有很强的任务依赖性。从这些比较分析中可以看出，不存在一种普适性的“最佳”增量学习方法。算法的选择高度依赖于具体的应用背景，包括数据特性（如样本量、类别平衡度）、可用的计算资源、对实时性的要求等。此外，领域内对于如何建立公平且有意义的性能上界和比较标准仍在积极探索中，尤其是在FSCIL这类复杂场景或需要考虑计算预算的情况下。这意味着除了平均准确率等传统指标外，还需要更全面的评估维度。一个值得注意的警示是，即使某些增量学习方法避免了存储旧数据，从而在理论上具有数据隐私优势，但如果训练好的模型本身能够“记住”并被用于重构敏感的训练数据，那么这种隐私保护的优势可能会被削弱。这对不依赖样本回放的增量学习方法的设计和评估提出了新的思考。

5. 深度探索：增量学习在光谱分析中的应用

光谱分析技术通过测量物质与电磁辐射相互作用产生的特征光谱，来获取物质的组成、结构和状态等信息。由于其非侵入性、快速、信息丰富等优点，光谱分析在诸多领域都有广泛应用。随着数据采集技术的进步，光谱数据量急剧增长，且应用场景往往面临动态变化（如新物质、新状态的出现），这为增量学习提供了广阔的应用前景。

5.1. 高光谱图像（HSI）分类

高光谱图像（HSI）在数百甚至数千个连续的窄光谱波段上捕捉地物的详细光谱信息，从而能够对地表物质进行精细区分。这使得HSI在农业（如作物健康监测、病害检测）、林业（如树种识别、森林资源调查）、城市规划、环境监测和矿产勘探等领域具有重要应用价值。然而，HSI分析也面临诸多挑战，如数据维度高（“维度灾难”）、标记样本稀缺、不同地物光谱特征相似性以及地物尺度变化等问题。在动态的地球观测中，地表覆盖类型、农作物品种、矿物种类等可能随时间演化或出现新的类别，大气条件也可能发生变化。在这种情况下，如果每次出现新情况都从头训练HSI分类模型，将耗费大量的计算资源和时间。增量学习为HSI分类模型的持续更新提供了一种更高效的途径。已有多项研究将增量学习应用于HSI分类。例如，一篇题为《基于类增量学习和选择性状态空间模型的高光谱图像分类》的论文直接探讨了CIL在HSI中的应用。另一项工作《基于解析学习的类增量高光谱图像分类》也关注此方向。相关的研究，如GS2FIN-CIL方法，在Indian Pines、Pavia University和Salinas等经典HSI数据集上进行了实验，结果表明通过缓解灾难性遗忘，其CIL性能优于现有方法。高光谱数据的高维度和信息丰富性，使得从头训练模型的代价高昂。当新的地物类别（如新作物品种、土地覆盖变化）出现时，增量学习能够以较低成本更新模型。然而，HSI中不同类别地物间可能存在细微的光谱差异和较高的光谱相似性，这使得灾难性遗忘问题尤为突出。如果模型在学习新类别时忘记了区分旧类别的关键细微特征，其应用价值将大打折扣。因此，能够有效保持细粒度判别特征的增量学习方法对HSI分类至关重要。针对这一问题，有研究提出了如CREATE（Confusion-REduced AuTo-Encoder classifier）这样的方法，旨在解决基于原型的CIL方法中存在的表征能力不足和特征重叠/漂移问题，以减少类别间的混淆。

5.2. 化学分析与化学计量学（例如拉曼/近红外光谱）

光谱技术（如拉曼光谱、近红外光谱NIR）结合化学计量学方法，在食品分析（如成分鉴定、产地溯源、掺假检测、化合物定量）、化学工业中的过程分析技术（PAT）等领域有广泛应用。在这些场景中，样品批次、原材料来源、生产工艺条件或环境因素可能会随时间变化，导致已建立的分析模型性能下降或不再适用，这种现象被称为模型“老化”或“失学习”。增量学习为解决这一问题提供了有效手段。一项研究将增量支持向量机（SVM）模型应用于拉曼光谱数据，用于测定酒精-水混合物中乙醇的浓度。实验结果表明，与传统化学计量学软件（如Unscrambler）相比，增量学习模型在计算时间上更优，在低浓度区域的准确性、精密度和灵敏度更高，并能实现用户友好的在线校准。该模型通过批量处理、并行执行和分布式数据处理减少了计算时间，同时能够容纳新数据并以较低的错误率提升准确性。另一项研究提出了基于增量子空间学习的化学计量学方法，用于基于近红外光谱的食品分析，例如鉴别植物油种类。该方法的优势包括模型创建速度快、可增量改进现有模型，以及能够在不同实验室或机构间共享和更新模型，而无需公开原始光谱数据，仅需少量新光谱样本即可增强模型的泛化性和适应性。在工业PAT和食品质量控制中，生产过程和原材料的微小变化较为常见。增量学习使分析模型能够适应这些变化（如新成分、不同批次的原材料、仪器漂移），无需进行昂贵且耗时的全面重新校准，同时避免遗忘历史知识。在化学计量学应用中，一个关键考量是使用“少量新光谱样本”更新模型的能力。这在实际分析中尤为重要，因为为每种可能的变化收集大规模、完整标注的数据集往往不切实际。增量学习有效利用现有模型，减少对新数据量的依赖，提升数据效率。其核心要求是模型能够基于少量新数据快速学习和调整，同时在不访问原始训练数据集的情况下保留旧知识。

5.3. 天文光谱数据分析

光谱学是天体物理学的基石，通过分析天体（如恒星、星系）发射或吸收的光谱，推断其化学组成、温度、密度、运动和距离等信息。随着斯隆数字巡天（SDSS）、盖亚（Gaia）以及即将推出的4MOST等大规模天文巡天的开展，天文学领域正以前所未有的速度生成海量且持续演变的光谱数据。这种数据特性为增量学习的应用提供了天然的契合点。增量学习/持续学习在天文光谱分析中的潜在应用包括：

天体分类与发现：分类演变的恒星类型或新发现的暂现源（如超新星、潮汐撕裂事件）。随着观测数据的积累，新的天体类别或现有类型的子类别可能出现，要求模型增量学习这些新知识。
模型适应性：使模型适应新的观测仪器、变化的观测条件或数据处理流程的调整。
时序光谱分析：处理非平稳的时序光谱数据，例如监测变星的光谱变化或暂现源的演化。

一些研究已开始探索相关方向。一篇论文通过对特征空间进行谱分析（注：这里的“谱分析”指数学上的特征分解，而非直接分析天文光谱），研究了增量学习中的特征表示，提出了classAug方法以学习更具迁移性的表示，并发现具有较大特征值的谱分量较不易被遗忘。另一项工作FDINet提出将图像分解为高频和低频分量用于持续学习，低频信息用于增强跨任务泛化，高频信息用于保留类别特定细节，同时减少模型参数和内存使用。尽管FDINet主要针对图像，其频率分解方法可能启发处理具有不同结构尺度的光谱数据。更直接相关的研究包括使用生成对抗网络（GANs）从恒星光谱中解耦大气物理参数（如有效温度、表面重力、金属丰度），创建可有效提取这些参数的潜在空间，GANDALF是为此开发的一个工具。这种解耦和潜在表示的学习对增量学习至关重要；如果模型能学习光谱的底层物理属性而非仅记忆光谱模式，面对新观测或略有不同的光谱时，其适应性和抗遗忘能力可能更强。面对海量的天文数据，研究者还在探索构建“光谱基础模型”的可能性。这些模型旨在通过大规模预训练和持续学习不断吸收新的天文数据，增强对恒星光谱的模拟和理解，契合终身学习的愿景。例如，即将推出的4MOST望远镜预计将生成大量暂现源光谱，自动光谱分类对及时处理这些数据至关重要。相关研究正在比较DASH、NGSF和SNID等分类器在模拟4MOST数据的性能。

5.4. 遥感影像分析

遥感（RS）数据采集具有固有的动态性，新的卫星影像和训练数据集定期发布。地球表面的持续变化（如土地使用/覆盖变化、季节转换、城市扩张、自然灾害）以及传感器技术的进步，导致遥感数据呈现非独立同分布（non-IID）特性。在这种情况下，仅用新数据更新模型可能导致对旧场景知识的灾难性遗忘，而使用所有历史数据从头重新训练模型则会带来高昂的计算成本。因此，增量学习成为遥感影像分析中应对这种动态性的关键技术。目前，遥感中的持续学习方法大多聚焦于监督分类任务，这些任务需要为每个持续学习任务提供大量标注数据。标注数据获取的高成本限制了其在实际操作场景中的适用性。为克服对标注数据的依赖，持续自监督学习（CSSL）在遥感领域日益受到关注。CSSL旨在使模型能够从无标签数据流中按顺序学习新任务。一篇论文提出了一种新的遥感CSSL方法，旨在实现高学习可塑性同时保持记忆稳定性。其核心机制包括采用知识蒸馏策略并引入解耦机制：首先，将特征维度分为任务共享和任务特定部分；然后，强制任务共享特征的相关性以确保记忆稳定性，同时强制任务特定特征的去相关性以促进新特征学习。实验结果表明，该方法在任务增量和类增量场景中的平均准确率等指标上优于CaSSLe等广泛使用的CSSL框架。遥感影像分析的挑战不仅限于添加新物体类别，模型还需适应域迁移（例如，同一类别在不同时间、传感器或大气条件下的表现）。这凸显了域增量学习（Domain-IL）在遥感应用中的重要性。CSSL等方法的出现为处理海量无标签遥感数据和实现持续模型适应提供了有前景的解决方案。

表2：增量学习在光谱分析领域的应用总结

光谱领域	具体应用	采用的增量学习技术举例	常用数据集 (如有提及)	主要报告成果/效益	主要解决的挑战
高光谱图像 (HSI)	作物分类、土地覆盖分类、矿物识别	类增量学习 (CIL), 解析学习与CIL结合, CREATE (基于自编码器的CIL)	Indian Pines, Pavia University, Salinas	提高分类准确率，缓解灾难性遗忘，适应新类别出现	高维数据处理，标记样本稀缺，光谱相似性导致的混淆，地物尺度变化，新类别不断出现
化学分析 (拉曼/近红外)	过程分析技术 (PAT)，食品纯度/成分分析	增量SVM, 增量子空间学习	酒精-水混合物 (拉曼), 植物油 (NIR)	减少计算时间，提高低浓度检测精度，用户友好校准，无需原始数据即可更新模型，提高模型泛化性	模型“老化”/失学习，适应新样品/批次/工艺条件，数据共享隐私
天文光谱 (恒星)	恒星参数化 (温度、重力、丰度)，恒星分类	GANs用于参数解耦, 特征空间谱分析 (classAug), 光谱仿真基础模型	Gaia RVS, APOGEE, LAMOST, Gaia-ESO, GALAH	实现物理参数的有效提取，学习可迁移的特征表示，构建可随数据增长持续改进的光谱仿真模型	海量持续增长的数据，新类型天体发现，模型适应新仪器/条件，从复杂光谱中解耦物理信息
天文光谱 (星系/暂现源)	暂现源分类 (如超新星)，星系演化研究	自动化光谱分类器比较 (DASH, NGSF, SNID)	模拟4MOST光谱数据	提高大规模巡天项目中暂现源的实时分类效率和纯度	应对即将到来的海量暂现源光谱数据，自动化分类流程，区分不同子类和奇异天体
遥感影像分析	土地利用/覆盖变化监测，地物分类	持续自监督学习 (CSSL) 与知识蒸馏、特征解耦结合	特定遥感数据集 (未详述具体名称)	在无标签数据流上实现持续学习，提高学习可塑性，优于现有CSSL框架 (如CaSSLe)	动态数据采集，非IID数据分布 (地表变化、传感器差异)，标签数据获取成本高，灾难性遗忘

此表汇总了增量学习在不同光谱分析子领域的应用情况，突出了所采用的技术、面临的挑战以及取得的进展。它清晰地展示了增量学习如何帮助这些领域应对动态数据和不断演化的知识需求，从而为用户提供了一个关于光谱分析中增量学习应用的结构化概览。

6. 评估增量学习系统：指标与协议

对增量学习系统进行全面且公平的评估是推动该领域发展的关键。由于增量学习的特殊性，其评估不能简单沿用传统机器学习的指标和方法，而需要一套能够反映其持续学习能力的评价体系。

6.1. 关键性能指标

研究者们提出了一系列专门用于衡量增量学习模型性能的指标：

平均准确率（Average Accuracy, ACC）： 这是衡量模型在完成所有任务序列学习后，在所有已学习任务上的平均表现。一个较高的平均准确率表明模型在学习新知识的同时，也较好地保留了旧知识。
遗忘量（Forgetting Measure, FM）/ 后向迁移（Backward Transfer, BWT）： 这两个指标都用于量化模型在学习新任务后对旧任务知识的遗忘程度。BWT 通常定义为学习新任务对旧任务性能的影响，正值表示促进（罕见），负值表示遗忘。FM 则更直接地衡量模型在学习完整个序列后，相比于刚学习完某个旧任务时的最佳性能，在该旧任务上性能下降了多少。理想的增量学习模型应具有较低的遗忘量或接近于零的负向BWT。
前向迁移（Forward Transfer, FWT）： 衡量模型从已学习任务中获得的知识对其学习未来新任务的积极影响。正的FWT表明模型能够利用旧知识加速或改进新任务的学习。
内存开销（Memory Overhead）： 指增量学习方法除了模型参数本身之外，额外需要的存储空间，例如用于存储记忆样本、生成模型参数或与任务相关的重要信息等。这对于资源受限的应用场景尤为重要。
计算成本/训练测试时间（Computational Cost / Train/Test Time）： 评估增量学习过程的效率，包括模型在每个增量阶段的训练时间以及在所有已学习任务上的测试时间。
可塑性/稳定性平衡的度量： 虽然没有单一的直接度量，但通常通过综合ACC、BWT、FWT等指标来间接评估模型在学习新知识（可塑性）和保留旧知识（稳定性）之间的平衡能力。一些研究也尝试定义新的指标，如“顽固性”（intransigence），用于衡量模型适应新任务的能力，这与可塑性相关。
其他迁移性评估指标： 如LEEP score、LogME、OTCE等，用于更细致地评估模型在任务间的知识迁移能力。

仅仅依赖最终的平均准确率不足以全面评价一个增量学习系统的好坏。必须结合上述多个维度的指标，综合考量其在准确性、知识保持、知识迁移、资源消耗和计算效率等方面的表现。评估指标的选择本身也可能对不同类型的增量学习策略产生偏好。例如，那些通过扩展模型结构来学习新任务的方法可能在准确率上表现优异，但在内存开销指标上则处于劣势。因此，在进行评估时，必须明确评估目标并选择合适的指标组合。

6.2. 标准基准和数据集

为了方便不同增量学习算法之间的比较，社区建立了一些常用的基准数据集和实验设置。

图像分类领域： 这是增量学习研究中使用最为广泛的领域。常用的数据集包括：
- MNIST 及其变体，如 Permuted MNIST (PMNIST)，后者通过对MNIST像素进行固定置换来构造一系列任务。
- CIFAR-10 和 CIFAR-100，通常通过将类别划分为多个批次来模拟增量学习过程。
- ImageNet 的不同子集，如 ImageNet-100 (选取100类)、ImageNet-1000 (完整的ILSVRC 2012 数据集)。
- Tiny-ImageNet，一个ImageNet的子集，包含200个类别，图像尺寸较小，常用于快速实验。
- Specific datasets for specific domains:
  - CORe50：一个专为持续物体识别设计的视频数据集，包含不同光照、姿态和遮挡条件下的物体。
  - CI-CIDS 2017：用于网络入侵检测系统增量学习研究的数据集。
  - 高光谱图像数据集：如 Indian Pines, Pavia University, Salinas 等，常用于评估HSI分类中的增量学习算法。
  - CoIN 基准套件：包含10个精心设计的数据集，横跨8种任务，用于评估持续指令调优的性能。

尽管标准的图像分类基准在增量学习研究中占据主导地位，但这些基准往往简化了现实世界的复杂性。例如，它们可能不包含类别不平衡、少样本学习、模糊的任务边界或显著的领域漂移等问题。因此，领域内也越来越呼吁开发和使用更能反映真实世界挑战的基准数据集。

6.3. 常见实验设置（协议）

增量学习的实验设置（或称协议）定义了任务如何呈现给模型，以及关于任务边界和任务身份的假设，这直接影响了问题的难度和适用策略。

任务增量学习（Task-Incremental Learning, Task-IL）： 在这种设置下，模型按顺序学习一系列不同的任务。关键在于，在训练和测试阶段，模型都会被明确告知当前样本所属的任务ID。这使得模型可以为每个任务使用独立的输出头或参数模块。
领域增量学习（Domain-Incremental Learning, Domain-IL）： 模型学习的是同一个底层任务（例如，识别同一组物体类别），但是输入数据的分布会随时间发生变化。例如，模型可能先在一种风格的图像上训练，然后遇到不同光照条件或背景风格的图像。任务边界可能是模糊的，模型通常不会接收到明确的任务ID。
类增量学习（Class-Incremental Learning, Class-IL）： 这是最具挑战性的设置之一。模型需要按顺序学习新的类别。初始阶段学习一部分类别，后续阶段不断引入新的类别。模型的目标是能够区分所有迄今为止学习过的类别，并且通常在测试时不提供任务ID。这意味着模型需要一个统一的分类器来处理所有见过的类别。

实验协议的选择对增量学习问题的难度和有效策略的类型有显著影响，不同协议下的结果通常不具有直接可比性。例如，一个在Task-IL设置下表现良好的方法，由于可以利用任务ID来切换模型组件，可能在更难的Class-IL设置下（需要从混合的类别中区分）表现不佳。因此，研究界也在推动更标准化和公平的评估协议，尤其是在FSCIL等子领域或在比较不同内存预算下的方法时，以确保方法之间的比较更具意义和可靠性。

7. 增量学习与其他相关学习范式的比较

为了更清晰地理解增量学习的特点和定位，有必要将其与一些相关的机器学习范式进行比较，如在线学习、迁移学习和元学习。

7.1. 增量学习 vs. 在线学习

在线学习（Online Learning）和增量学习都涉及按顺序处理数据。在线学习的核心特征是模型一次处理一个或一小批数据样本，并根据每个样本即时更新。这种方式使得模型能够适应数据流的变化。然而，两者在目标和假设上存在关键区别。传统的在线学习更侧重于模型对当前数据分布的快速适应，并不一定强调对过去所有知识的长期保留，尤其是在数据分布非平稳的情况下，可能会“忘记”旧的模式以适应新的模式。而增量学习（或持续学习）的核心目标恰恰是克服灾难性遗忘，在适应新数据的同时积累并保持历史知识，特别是在面对非平稳数据流时。因此，可以将增量学习视为在线学习的一个特定分支或高级形式，它对知识的保持和在非平稳环境下的鲁棒性提出了更高的要求。一些文献有时会将两者视为相近甚至等同的概念，但强调增量学习需具备在不访问旧数据的情况下保留旧知识的能力，而标准在线学习若不经特殊设计，则可能对连续的数据流非常敏感。

7.2. 增量学习 vs. 迁移学习

迁移学习（Transfer Learning）旨在将在一个或多个源任务（source task）或源领域（source domain）上学到的知识，应用于一个不同但相关的目标任务（target task）或目标领域（target domain），以期提高在目标任务上的学习效率或性能，特别是在目标任务数据稀疏的情况下。迁移学习通常关注的是一次性的知识迁移过程。增量学习则是一个持续的、序列化的学习过程，涉及多个（可能是无限的）任务。在增量学习中，知识迁移是一个重要的组成部分，体现为前向迁移（利用旧任务知识帮助新任务学习）和后向迁移（学习新任务反过来巩固或改进旧任务性能，尽管后者更罕见且难以实现）。与迁移学习的单向或少数几次迁移不同，增量学习强调知识的不断积累、整合和适应，贯穿整个学习生命周期。可以说，迁移学习是增量学习实现其目标（如提高学习效率、促进知识泛化）的一种重要机制，但增量学习的范畴更广，它关注的是整个动态学习过程中的知识演化和保持。

7.3. 增量学习 vs. 元学习

元学习（Meta-Learning），常被称为“学会学习”（learning to learn），其目标是让模型通过从多个相关的学习任务（元训练集）中提取经验，来学习一种通用的学习策略或获取先验知识，从而能够在面对新的、未见过的任务（元测试集）时，仅用少量样本就能快速学习和适应。元学习优化的是学习算法本身。增量学习的核心目标是在一系列连续的任务中保持和扩展知识，而不是优化学习新任务的速度（尽管这也是期望的副产品）。元学习可以被视为一种用于改进增量学习算法的工具或方法论。例如，可以通过元学习来找到一个对持续学习特别有效的模型初始化参数、一个能够更好平衡稳定性和可塑性的学习率调整策略，或者一个能够快速适应新任务同时减少遗忘的更新规则。在这种“元持续学习”（meta-continual learning）或“学会持续学习”的框架下，元学习的每个“эпизод”（episode）都变成了一个持续学习的过程。总结来说，这几种学习范式虽然都处理与数据或任务变化相关的问题，但其核心目标、假设和方法论各有侧重：

在线学习： 关注实时数据流处理和快速适应。
迁移学习： 关注知识从源到目标的单次或少数几次迁移。
元学习： 关注学习普适的学习策略以实现快速学习新任务。
增量学习： 关注在连续任务序列中长期积累和保持知识，克服灾难性遗忘。

它们之间并非完全独立，而是存在交叉和融合的可能，共同推动着人工智能向更智能、更自适应的方向发展。

8. 增量学习领域的开创性与前沿研究解析

增量学习领域的研究历经多年发展，涌现出一批具有里程碑意义的开创性工作，同时也伴随着持续的技术创新和新方法的提出。

8.1. 奠基性论文及其影响

以下三篇论文常被认为是增量学习领域的经典之作，它们提出的方法为后续研究奠定了重要基础：

弹性权重巩固 (Elastic Weight Consolidation, EWC) (Kirkpatrick et al., PNAS 2017): EWC 是一种基于正则化的方法，其核心思想是减缓对先前任务重要的权重的学习速度。它通过费雪信息矩阵（Fisher Information Matrix）来估计每个网络权重对于已学习任务的重要性，并在学习新任务时，对这些重要权重的改变施加二次惩罚。影响: EWC 是最早有效解决深度神经网络灾难性遗忘问题的开创性工作之一。它确立了通过识别和保护重要参数来实现知识保留的原则，启发了后续一系列基于参数重要性度量的正则化方法。
无遗忘学习 (Learning without Forgetting, LwF) (Li & Hoiem, ECCV 2016): LwF 采用知识蒸馏技术来保留旧任务的性能。在训练新任务时，它使用旧模型在新数据（或部分旧数据）上产生的输出（软标签）作为新模型的附加学习目标，从而使得新模型在保持对新任务学习能力的同时，其行为（在旧任务相关方面）与旧模型保持一致。LwF 的一个显著优点是不需要存储旧任务的原始训练数据。影响: LwF 提出了一种有效的、不依赖旧数据的知识保留方法（特指不依赖旧任务的原始输入数据进行回放），迅速成为增量学习领域一个广泛应用的基线方法，并常被用作更复杂混合策略的一个组成部分。
iCaRL (Incremental Classifier and Representation Learning) (Rebuffi et al., CVPR 2017): iCaRL 是一种混合方法，它巧妙地将知识蒸馏与基于样本的回放策略相结合。它会存储少量来自旧类别的代表性样本（exemplars），并在训练新任务时与新数据一同使用。此外，iCaRL 采用最近平均样本（nearest-mean-of-exemplars）分类器进行预测。影响: iCaRL 充分展示了混合策略在应对类增量学习挑战方面的潜力，并为视觉任务中的类增量学习提供了一个强有力的基准。它还强调了在增量学习过程中，同时学习有效的数据表示和分类器的重要性。

这些奠基性的工作不仅提出了具体的算法，更重要的是，它们揭示了解决灾难性遗忘问题的不同途径和核心思想，为增量学习领域后续的繁荣发展指明了方向。

8.2. 近期进展与新颖方法回顾

在上述奠基性工作的基础上，增量学习领域的研究持续活跃，不断涌现出新的思路和更优的解决方案，以应对更复杂的场景和挑战。

生成式回放的演进： 为了克服样本回放中数据隐私和存储限制的问题，基于生成模型（如GANs, VAEs）的伪样本回放方法持续受到关注。例如，在联邦类增量学习（FCIL）中，FedGTG 利用全局生成器来合成旧类数据，辅助客户端学习。尽管生成高质量且多样性的样本仍然是一个挑战，但对无数据回放（data-free replay）的追求反映了实际应用中对数据效率和隐私保护的强烈需求。
特征空间分析与增强： 研究者开始更深入地探究特征表示在增量学习中的作用。例如，classAug 方法通过对特征表示进行谱分解，识别并增强那些更具迁移性的特征分量，发现具有较大特征值的谱分量更不容易被遗忘。FDINet 则通过将图像分解为高频和低频分量，分别用于保留类别特有细节和增强跨任务泛化，从而在持续学习中取得良好效果，并实现了模型轻量化。这些工作表明，从理解和优化特征表示的角度出发，可以设计出更具针对性的正则化或数据增强策略，而不仅仅是简单地惩罚权重变化。
高级回放策略： 简单的样本回放机制也在不断被改进。例如，Rainbow Memory 提出存储多样化的样本以提高回放效率；PASS (Prototype Augmentation and Self-Supervision) 和 RMM (Reinforced Memory Management) 等方法则探索了更复杂的记忆样本管理和增强技术，以最大化所存储样本的效用。
预训练模型在增量学习中的应用： 近年来，一个非常显著的趋势是利用大规模预训练模型（如Vision Transformers, CLIP等）进行持续学习。这些预训练模型通常具有强大的泛化能力和高质量的特征表示，为增量学习提供了一个良好的起点，有望减轻灾难性遗忘的程度并促进知识迁移。如何有效地对这些大型模型进行持续微调，同时保持其原有能力，是当前的研究热点。
对效率和资源限制的关注： 随着增量学习方法走向实际应用，对计算效率和内存占用的考量日益重要。FDINet 明确以轻量级架构和在边缘设备上的高效运行为目标。同时，一些研究对现有CIL算法的高计算成本提出了批评，这推动了对更具资源意识的解决方案的探索。
超越分类任务： 增量学习的应用正在从传统的图像分类扩展到更广泛的任务类型。例如，在生成模型领域出现了Hyper-LifelongGAN，在语义分割领域有PLOP 等方法。更有研究者提出，增量学习的目标不应局限于分类，而应更多地考虑密度估计或生成式目标，这可能更有利于知识的积累和任务识别。

这些近期进展显示，增量学习领域正在从主要关注在受控环境中缓解灾难性遗忘，逐渐转向构建能够在更复杂、更动态、资源更受限的真实场景中持续学习和适应的智能系统。

9. 未来展望：挑战、趋势与通往真正终身学习之路

增量学习作为实现通用人工智能的关键环节之一，虽然取得了显著进展，但距离实现真正意义上的人类水平的终身学习仍有很长的路要走。未来，该领域将面临诸多挑战，同时也孕育着重要的发展机遇。

9.1. 应对当前局限性

可扩展性与效率： 目前许多增量学习方法主要在相对较小的数据集或有限的任务序列上进行测试。如何将这些方法扩展到包含数千个任务的场景，或者应用于参数量巨大的超大规模模型，仍然是一个巨大的挑战。计算成本是制约增量学习实际应用的一个主要瓶颈。真正的终身学习系统需要在极长的时间跨度内持续运行，并处理海量多样化的数据，这对算法的效率提出了极高要求。
真实世界鲁棒性： 基准数据集上的性能与在充满噪声、类别不平衡、任务边界模糊的真实世界应用中的表现之间，往往存在显著差距。未来的研究需要更加关注如何在这些“混乱”的真实数据流中保持学习的稳定性和有效性。
任务关系与知识迁移： 仅仅关注减轻灾难性遗忘是不够的，更理想的增量学习系统应该能够智能地利用任务之间的内在联系，实现显著的正向和反向知识迁移，从而“越学越好”。目前的方法在平衡遗忘与迁移方面仍有较大提升空间，有时甚至会面临两者之间的权衡。
理论理解的深化： 尽管经验性的成功不断涌现，但对灾难性遗忘发生的深层机制以及不同增量学习方法为何有效的理论理解仍有待加强。更坚实的理论基础将有助于指导设计出更具原则性、更可靠的算法。

9.2. 新兴研究方向

大规模预训练模型（LPTMs）的持续学习： 如何有效地对大型预训练模型（如Transformer架构的语言模型和视觉模型，CLIP等多模态模型）进行持续学习，是一个非常活跃且重要的研究方向。参数高效微调（Parameter-Efficient Fine-Tuning, PEFT）技术，如LoRA，正在被探索用于持续学习场景，以期在保持LPTMs强大能力的同时，减少更新成本并缓解遗忘，特别是在需要保持特定对齐（如LLM的安全性）的情况下。
无回放的持续学习（Rehearsal-free CL）： 出于对内存消耗和数据隐私的考虑，不依赖存储旧样本或生成伪样本的持续学习方法持续受到关注。然而，如何确保在完全不接触旧数据的情况下有效抵抗遗忘，以及如何处理生成式方法中伪样本与真实数据的一致性问题，仍是主要挑战。
生成式与密度估计目标： 将增量学习的目标从传统的判别式分类任务，扩展到包含生成式建模或概率密度估计，被认为可能为缓解灾难性遗忘和进行任务识别提供新的途径。学习数据的内在分布可能比仅仅学习分类边界更有利于知识的长期保持和泛化。
持续自监督学习（CSSL）： 从未标记的数据流中进行持续学习，对于像遥感这样拥有海量无标签数据的领域至关重要。CSSL能够显著降低对昂贵人工标注的依赖，使持续学习技术更易于在实际中大规模部署。
增量学习中的公平性、隐私与安全： 随着增量学习系统在现实世界中的部署日益增多，确保其决策的公平性、在学习过程中（尤其是在使用回放或生成模型时）保护用户数据隐私、以及抵御潜在的对抗性攻击等问题，将成为不可忽视的关键考量。
与开放集识别和主动学习的结合： 现实世界的系统经常会遇到训练阶段未曾见过的新类别（开放集问题），并且可能从主动选择信息量最大的样本进行学习中受益。将这些能力与增量学习框架相结合，是提升系统适应性和学习效率的一个有前景的方向。

9.3. 总结性思考：通往真正终身学习的轨迹

增量学习（或持续学习、终身学习）无疑是当前人工智能领域一个充满活力且至关重要的研究热点，并将在未来很长一段时间内持续受到关注。其最终目标是构建能够像人类一样持续学习和适应的智能体，无缝地整合新知识，同时保留、提炼并应用已有的经验。当前的研究趋势表明，增量学习正在从主要关注在受控环境下解决分类任务中的灾难性遗忘问题，逐渐演进到应对更广泛的挑战，包括构建能够在复杂、动态、资源受限的真实世界应用中高效学习和鲁棒适应的系统。与大规模预训练模型和自监督学习的深度融合，以及对更多样化任务类型和学习目标的探索（如生成任务、密度估计），标志着该领域的显著进步。研究的重心也正从单纯地“不忘记”转向如何实现有效的正向知识迁移，从而让系统能够“越学越好”。尽管通往真正意义上的人类水平的终身学习之路依然漫长且充满挑战，但当前的研究动态和技术突破预示着一个充满希望和潜力的未来。通过不断克服现有局限，探索新的理论和方法，增量学习必将在推动人工智能向更高级、更智能、更具适应性的方向发展过程中扮演核心角色。

结论

增量学习作为机器学习领域应对动态环境和持续知识获取挑战的关键技术，已经取得了长足的进步。从其核心的稳定性-可塑性困境和灾难性遗忘问题出发，研究者们发展出基于回放、正则化、参数隔离等多种方法论，并通过PyCIL、Avalanche等开源框架推动了研究的标准化和可复现性。在应用层面，增量学习已在图像识别、自然语言处理、机器人技术、网络安全等多个领域展现出应用潜力。尤其值得关注的是其在光谱分析领域的独特价值：无论是高光谱图像分类中应对地物类型的动态变化，化学计量学中适应过程和样品的变化，还是天文光谱分析中处理海量持续增长的观测数据，以及遥感影像分析中适应地表和传感器的演变，增量学习都提供了有效的解决方案，帮助模型在保留旧知识的同时学习新信息。评估增量学习系统需要综合考量准确率、遗忘程度、知识迁移能力、内存开销和计算效率等多个指标，并采用合适的实验协议（任务增量、领域增量或类增量）。将其与在线学习、迁移学习和元学习等相关范式进行比较，有助于更清晰地界定其独特性和适用范围。尽管面临可扩展性、真实世界鲁棒性、深度理论理解等挑战，但新兴的研究方向，如结合大规模预训练模型、发展无回放策略、探索生成式和自监督持续学习、以及关注公平性与隐私等，正引领着增量学习向更深层次、更广阔的应用前景迈进。未来的研究将更加注重构建不仅能够“不忘记”，更能“学得更好”、更高效、更适应复杂真实世界的终身学习智能体。对光谱分析等特定领域的持续深耕，结合增量学习的最新进展，有望催生更多创新性的应用成果。

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

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多种语言，并能精确解析复杂的表格、数学公式和手写体。
适用场景：文档自动化、图表分析、图像内容问答、票据识别。

什么是算子？

Sun, 30 Mar 2025 20:31:40 +0800

字典学习（Dictionary Learning）

Thu, 20 Mar 2025 17:59:37 +0800

参考：

维基百科

博客园，似乎是讲的比较详细了

知乎

前言

在中文网络中，“字典学习”是关于这个概念最直接且最常见的翻译，但是我认为，实际上这个翻译是不合适的，我认为“稀疏编码” 才更加符合这个概念。

因为实际上人们更加关心的实际上是将原本的数据进行压缩，整个过程符合稀疏编码的概念，而字典是在整个压缩过程中所产生的产品。

第一部分：背景知识

1.1 信号处理的起源

字典学习的根源可以追溯到信号处理领域。信号处理的目标是从复杂的信号（如音频、图像、视频）中提取有意义的信息。20世纪中期，傅里叶变换（Fourier Transform）和小波变换（Wavelet Transform）成为信号分析的主流工具：

傅里叶变换：将信号分解为不同频率的正弦波和余弦波的组合。
小波变换：在傅里叶变换基础上增加了时间局部性，适合分析非平稳信号。

然而，这些方法依赖于预定义的基函数（比如正弦波、小波），对某些复杂信号的表示能力有限。比如，图像中的边缘特征或音频中的瞬态变化可能无法被这些固定基函数很好地捕捉。这就引出了一个问题：能不能从数据本身学习一组更适合的基函数？

1.2 稀疏表示的兴起

20世纪90年代，稀疏表示（Sparse Representation）开始受到关注。稀疏表示的核心思想是：许多自然信号可以用少量基向量的线性组合来表示。这种思想受到以下启发：

生物学：人类视觉系统（比如V1皮层）倾向于用稀疏的方式编码信息。例如，神经元对特定方向的边缘响应，而对其他方向不响应。
压缩感知（Compressed Sensing）：Donoho 和 Candès 等人在2000年代证明，如果信号是稀疏的，可以通过少量测量精确重构信号。

稀疏表示需要一个“字典”（Dictionary），传统方法（如傅里叶基、小波基）使用固定字典，但这些字典并非对所有信号都最优。于是，研究者开始探索从数据中自适应学习字典的可能性。

1.3 机器学习与特征提取

与此同时，机器学习领域也在快速发展。20世纪末，特征提取成为模式识别和数据分析的关键问题。传统的特征提取方法（如主成分分析 PCA）虽然有效，但有局限性：

PCA 是线性方法，假设数据服从高斯分布。
PCA 的基向量是全局的，无法捕捉局部特征。

字典学习应运而生，它结合了稀疏表示和自适应学习的优势，成为一种强大的特征提取工具。与 PCA 不同，字典学习不要求基向量正交，且可以通过过完备字典（原子数大于数据维度）捕捉更多样化的模式。

1.4 历史里程碑

1996年，Olshausen 和 Field：提出了稀疏编码的概念，首次尝试从自然图像中学习字典，模拟人类视觉系统。
2006年，K-SVD 算法：Aharon 等人提出了 K-SVD，一种高效的字典学习算法，结合了 K-Means 和奇异值分解（SVD），成为经典方法。
2000年代后期，压缩感知：字典学习与压缩感知结合，推动了其在信号恢复中的应用。
2010年代，深度学习：卷积稀疏编码和字典学习的思想被融入深度神经网络，进一步扩展了其影响力。

第二部分：理论基础

2.1 线性代数视角

\[ X \approx D A \]

如果 $ k = m $ 且 $ D $ 可逆，这类似于 PCA 或 ICA（独立成分分析）。
如果 $ k > m $，字典是过完备的（Overcomplete），允许更灵活的表示，但增加了求解难度。

2.2 稀疏性与 L1 正则化

\[ \min_a \| x - D a \|_2^2 \]\[ \min_a \| x - D a \|_2^2 + \lambda \| a \|_1 \]

L1 范数（$ \| a \|_1 = \sum |a_i| $）相比 L2 范数（$ \| a \|_2^2 = \sum a_i^2 $）更倾向于产生零值解，这是稀疏性的来源。

2.3 过完备字典的优势

过完备字典（$ k > m $）相比完备字典（$ k = m $）有以下优势：

表达能力强：可以表示更复杂的模式。
鲁棒性：对噪声和数据缺失更具容忍度。
稀疏性：允许用更少的原子组合表示信号。

但缺点是计算复杂度增加，且优化问题变得非凸（Non-convex），需要迭代求解。

2.4 与其他方法的对比

PCA：字典正交，重构误差最小，但不稀疏。
NMF（非负矩阵分解）：字典和系数非负，适合特定数据（如图像光谱），但不一定稀疏。
小波变换：固定字典，计算效率高，但缺乏自适应性。

第三部分：更详细的数学推导

3.1 目标函数

\[ \min_{D, A} \| X - D A \|_F^2 + \lambda \sum_{i=1}^n \| a_i \|_1 \]

其中：

$ \| X - D A \|_F^2 = \sum_{i,j} (X_{ij} - (D A)_{ij})^2 $ 是 Frobenius 范数。
$ \sum_{i=1}^n \| a_i \|_1 $ 是稀疏惩罚项。

3.2 稀疏编码推导

\[ \min_{a_i} \| x_i - D a_i \|_2^2 + \lambda \| a_i \|_1 \]

这是一个凸优化问题。我们可以用近端梯度下降（Proximal Gradient Descent）：

定义损失函数 $ f(a_i) = \| x_i - D a_i \|_2^2 $ 和正则项 $ g(a_i) = \lambda \| a_i \|_1 $。
梯度：$ \nabla f(a_i) = 2 D^T (D a_i - x_i) $。
近端算子：对 $ g(a_i) $ 的近端映射是软阈值（Soft Thresholding）： \[ \text{prox}_{\lambda}(z) = \text{sign}(z) \max(|z| - \lambda, 0) \]
迭代更新：$ a_i^{t+1} = \text{prox}_{\lambda} (a_i^t - \eta \nabla f(a_i^t)) $。

3.3 字典更新推导

\[ \min_D \| X - D A \|_F^2 \]\[ \frac{\partial}{\partial D} \| X - D A \|_F^2 = -2 (X - D A) A^T \]\[ D = X A^T (A A^T)^{-1} \]

但为了避免 $ D $ 的列范数过大，通常加入约束 $ \| d_j \|_2 \leq 1 $，需要投影到约束集。

3.4 K-SVD 的细节

K-SVD 改进了字典更新步骤：

对每个原子 $ d_j $ 和对应的系数行 $ a^j $ 单独更新。
计算残差 $ E_j = X - \sum_{k \neq j} d_k a^k $。
对 $ E_j $ 做 SVD 分解，更新 $ d_j $ 和 $ a^j $。

第四部分：更详细的实现（K-SVD 示例）

以下是一个手写 K-SVD 的简版实现，帮助你理解其内部机制：

import numpy as np

def omp(X, D, sparsity):
 """正交匹配追踪求稀疏系数"""
 n_samples, n_features = X.shape
 k = D.shape[1]
 A = np.zeros((k, n_samples))

 for i in range(n_samples):
 x = X[i]
 residual = x.copy()
 support = []
 for _ in range(sparsity):
 scores = np.abs(D.T @ residual)
 if not support:
 idx = np.argmax(scores)
 else:
 idx = np.argmax(scores * (1 - np.array(support, dtype=int)))
 support.append(idx)
 D_s = D[:, support]
 a_s = np.linalg.pinv(D_s) @ x
 residual = x - D_s @ a_s
 A[support, i] = a_s
 return A

def k_svd(X, n_atoms, sparsity, n_iter):
 """K-SVD 算法"""
 n_features, n_samples = X.shape
 D = np.random.randn(n_features, n_atoms)
 D /= np.linalg.norm(D, axis=0) # 归一化

 for iteration in range(n_iter):
 # 稀疏编码
 A = omp(X, D, sparsity)

 # 字典更新
 for j in range(n_atoms):
 I = A[j, :] != 0
 if np.sum(I) == 0:
 continue
 E_j = X[:, I] - D @ A[:, I] + np.outer(D[:, j], A[j, I])
 U, s, Vt = np.linalg.svd(E_j, full_matrices=False)
 D[:, j] = U[:, 0]
 A[j, I] = s[0] * Vt[0]

 return D, A

# 测试
X = np.random.randn(20, 100) # 20维，100个样本
D, A = k_svd(X, n_atoms=30, sparsity=5, n_iter=10)
X_reconstructed = D @ A
error = np.mean((X - X_reconstructed) ** 2)
print(f"重构误差: {error:.4f}")

代码解释

OMP：实现正交匹配追踪，逐步选择字典原子。
K-SVD：交替进行稀疏编码和字典更新。
归一化：确保字典原子单位长度。

第五部分：更广泛的背景与展望

5.1 跨学科联系

神经科学：字典学习与大脑的稀疏编码机制有相似之处。
物理学：在量子信息和稀疏恢复中有潜在应用。
计算机视觉：用于目标检测、图像超分辨率等。

5.2 当前挑战

计算复杂度：大数据下的字典学习仍需优化。
非凸性：全局最优解难以保证。
可解释性：学到的字典如何与物理意义对应？

5.3 未来方向

与深度学习的融合（如卷积字典学习）。
在线学习和分布式计算的应用。
多模态数据的字典学习。

命名实体识别

Thu, 13 Mar 2025 14:29:48 +0800

基于Transformers的命名实体识别（NER）教程

命名实体识别（NER）是自然语言处理（NLP）中的一项重要任务，目标是从文本中识别出命名实体（如人名、地名、组织名等）并对其进行分类。本教程将使用Hugging Face的transformers库，结合一个中文NER数据集（例如“人民日报NER数据集”），实现一个完整的NER模型训练和预测流程。

Step 1: 导入相关包

首先，我们需要导入必要的库和模块：

import evaluate
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForTokenClassification, TrainingArguments, Trainer, DataCollatorForTokenClassification

evaluate: 用于加载评估指标，例如seqeval，专门用于NER任务的评估。
datasets: Hugging Face提供的数据集管理工具，用于加载和处理数据。
transformers: 核心库，提供预训练模型、分词器和训练工具。

Step 2: 加载数据集

我们需要一个NER数据集。这里以“人民日报NER数据集”为例，您可以在线加载或从本地加载：

# 在线加载（需要联网）
# ner_datasets = load_dataset("peoples_daily_ner", cache_dir="./data")

# 本地加载（无需联网）
from datasets import DatasetDict
ner_datasets = DatasetDict.load_from_disk("ner_data")
print(ner_datasets)

输出示例：

DatasetDict({
 train: Dataset({...})
 validation: Dataset({...})
 test: Dataset({...})
})

查看数据集内容

查看第一条训练数据：

print(ner_datasets["train"][0])

输出示例：

{'tokens': ['小', '明', '在', '北', '京', '上', '班'], 'ner_tags': [1, 2, 0, 3, 4, 0, 0]}

查看特征信息：

print(ner_datasets["train"].features)

输出示例：

{'tokens': Sequence(feature=Value(dtype='string')),
 'ner_tags': Sequence(feature=ClassLabel(names=['O', 'B-PER', 'I-PER', 'B-LOC', 'I-LOC', ...]))}

获取标签列表：

label_list = ner_datasets["train"].features["ner_tags"].feature.names
print(label_list)

输出示例：

['O', 'B-PER', 'I-PER', 'B-LOC', 'I-LOC', ...]

这里，O表示非实体，B-和I-分别表示实体的开始和内部（BIO标注格式）。

Step 3: 数据集预处理

NER任务需要将文本分词并对齐标签。由于预训练模型的分词器（如BERT）可能会将一个词拆分成多个子词（subword），我们需要确保标签与分词后的结果对齐。

加载分词器

tokenizer = AutoTokenizer.from_pretrained("hfl/chinese-macbert-base")

测试分词器

对于已经分词好的数据（如tokens），需要设置is_split_into_words=True：

res = tokenizer(ner_datasets["train"][0]["tokens"], is_split_into_words=True)
print(res)

输出示例：

{'input_ids': [101, 2207, 6607, 1762, 1266, 7425, 677, 4408, 102], 'token_type_ids': [...], 'attention_mask': [...]}

查看word_ids（每个token对应的原始词索引）：

print(res.word_ids())

输出示例：

[None, 0, 1, 2, 3, 4, 5, 6, None]

None表示特殊token（如[CLS]和[SEP]），其他数字对应原始tokens的索引。

定义预处理函数

我们需要将标签与分词结果对齐：

def process_function(examples):
 tokenized_examples = tokenizer(examples["tokens"], max_length=128, truncation=True, is_split_into_words=True)
 labels = []
 for i, label in enumerate(examples["ner_tags"]):
 word_ids = tokenized_examples.word_ids(batch_index=i)
 label_ids = []
 for word_id in word_ids:
 if word_id is None: # 特殊token用-100标记（会被模型忽略）
 label_ids.append(-100)
 else:
 label_ids.append(label[word_id]) # 对齐原始标签
 labels.append(label_ids)
 tokenized_examples["labels"] = labels
 return tokenized_examples

# 应用到数据集
tokenized_datasets = ner_datasets.map(process_function, batched=True)
print(tokenized_datasets["train"][0])

Step 4: 创建模型

加载预训练模型，并指定标签数量：

model = AutoModelForTokenClassification.from_pretrained("hfl/chinese-macbert-base", num_labels=len(label_list))
print(model.config.num_labels) # 验证标签数量

注意：num_labels必须与label_list长度一致，否则会导致设备错误。

Step 5: 创建评估函数

NER任务通常使用seqeval来计算F1分数等指标：

# 安装seqeval（如果未安装）
# !pip install seqeval

# 加载评估模块
seqeval = evaluate.load("seqeval_metric.py") # 本地加载方式

def eval_metric(pred):
 predictions, labels = pred
 predictions = np.argmax(predictions, axis=-1)

 # 将ID转换为标签，忽略-100
 true_predictions = [[label_list[p] for p, l in zip(pred, label) if l != -100]
 for pred, label in zip(predictions, labels)]
 true_labels = [[label_list[l] for p, l in zip(pred, label) if l != -100]
 for pred, label in zip(predictions, labels)]

 result = seqeval.compute(predictions=true_predictions, references=true_labels, mode="strict", scheme="IOB2")
 return {"f1": result["overall_f1"]}

Step 6: 配置训练参数

args = TrainingArguments(
 output_dir="models_for_ner",
 per_device_train_batch_size=64,
 per_device_eval_batch_size=128,
 evaluation_strategy="epoch",
 save_strategy="epoch",
 metric_for_best_model="f1",
 load_best_model_at_end=True,
 logging_steps=50,
 num_train_epochs=1 # 为了演示设为1，实际可设为3-5
)

Step 7: 创建训练器

trainer = Trainer(
 model=model,
 args=args,
 train_dataset=tokenized_datasets["train"],
 eval_dataset=tokenized_datasets["validation"],
 compute_metrics=eval_metric,
 data_collator=DataCollatorForTokenClassification(tokenizer=tokenizer)
)

DataCollatorForTokenClassification会自动对齐输入和标签，填充到相同长度。

Step 8: 模型训练

trainer.train()

训练完成后，评估测试集：

trainer.evaluate(eval_dataset=tokenized_datasets["test"])

Step 9: 模型预测

使用pipeline进行推理：

from transformers import pipeline

# 设置id2label
model.config.id2label = {idx: label for idx, label in enumerate(label_list)}

# 创建NER pipeline
ner_pipe = pipeline("token-classification", model=model, tokenizer=tokenizer, device=0, aggregation_strategy="simple")

# 预测示例
text = "小明在北京上班"
res = ner_pipe(text)
print(res)

输出示例：

[{'entity_group': 'PER', 'start': 0, 'end': 2, 'word': '小明'},
 {'entity_group': 'LOC', 'start': 3, 'end': 5, 'word': '北京'}]

提取结果：

ner_result = {}
for r in res:
 if r["entity_group"] not in ner_result:
 ner_result[r["entity_group"]] = []
 ner_result[r["entity_group"]].append(text[r["start"]:r["end"]])
print(ner_result)

输出示例：

{'PER': ['小明'], 'LOC': ['北京']}

总结

通过以上步骤，您已经完成了：

数据加载与预处理
模型创建与训练
评估与预测

文本分类

Thu, 13 Mar 2025 10:54:48 +0800

基础概念

什么是文本分类？

文本分类是自然语言处理（NLP）中的一个核心任务，目的是将一段文本分配到一个或多个预定义的类别中。例如：

情感分析：判断文本是“正面”、“负面”还是“中性”。
垃圾邮件检测：判断邮件是“垃圾邮件”还是“正常邮件”。
主题分类：将新闻分为“体育”、“科技”、“政治”等。

文本分类的基本流程

数据准备：收集并标注文本数据。
文本预处理：清洗和转换文本，使其适合机器学习模型。
特征提取：将文本转化为数值形式（如词袋模型或词嵌入）。
模型训练：选择并训练一个分类模型。
评估与优化：测试模型性能并改进。

scikit-learn 框架

步骤详解与代码示例

以下基于 Python，使用 scikit-learn 库实现一个简单的文本分类任务。我们以情感分析为例，区分“正面”和“负面”评论。

1. 数据准备

假设我们有以下小型数据集：

# 示例数据
texts = [
 "这个电影太棒了，值得一看！",
 "服务很好，我很满意。",
 "剧情很无聊，太差了。",
 "浪费时间，完全不好看。"
]
labels = ["正面", "正面", "负面", "负面"] # 对应的标签

2. 文本预处理

中文文本需要分词（英文通常只需小写化和去标点）。我们使用 jieba 库进行中文分词。

import jieba

# 分词函数
def preprocess(text):
 return " ".join(jieba.cut(text)) # 分词后用空格连接

# 应用到数据
processed_texts = [preprocess(text) for text in texts]
print(processed_texts)
# 输出示例: ['这个 电影 太棒了 ， 值得 一看 ！', ...]

3. 特征提取

将文本转化为数值表示。这里使用 TF-IDF（词频-逆文档频率）方法。

from sklearn.feature_extraction.text import TfidfVectorizer

# 初始化 TF-IDF 向量化器
vectorizer = TfidfVectorizer()

# 转换为 TF-IDF 特征矩阵
X = vectorizer.fit_transform(processed_texts)
print(X.shape) # 输出矩阵形状，例如 (4, 15)
print(X[0])
print(X[1])
print(X[2])
print(X[3])

4. 模型训练

使用一个简单的分类器，比如逻辑回归。

from sklearn.linear_model import LogisticRegression

# 初始化模型
model = LogisticRegression()

# 训练模型
model.fit(X, labels)

5. 测试与预测

用训练好的模型预测新文本的情感。

# 新文本
new_texts = ["这个产品真不错！", "太差了，不推荐。"]
new_processed = [preprocess(text) for text in new_texts]
new_X = vectorizer.transform(new_processed)

# 预测
predictions = model.predict(new_X)
print(predictions) # 输出: ['正面', '负面']

6. 评估模型（可选）

如果有更多数据，可以拆分为训练集和测试集，用准确率等指标评估模型。

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 拆分数据
X_train, X_test, y_train, y_test = train_test_split(X, labels, test_size=0.25, random_state=42)

# 训练与预测
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 计算准确率
print("准确率:", accuracy_score(y_test, y_pred))

进阶建议

更复杂的模型：
- 试试支持向量机（SVM）：from sklearn.svm import SVC
- 或深度学习模型（如 LSTM），使用 TensorFlow 或 PyTorch。
词嵌入：
- 用预训练模型（如 word2vec 或 BERT）替代 TF-IDF，提升效果。
- 对于中文，可以用 transformers 库加载中文 BERT。
中文处理优化：
- 去停用词（如“的”、“了”），提高特征质量。
- 使用更大的数据集，比如从网络爬取评论。

工具与资源

Python 库：scikit-learn, jieba, transformers
数据集：可以从 Kaggle 或中文 NLP 数据集（如微博情感数据集）获取。
学习资料：推荐《Natural Language Processing with Python》或在线课程。

transformers 框架

中文情感分类实例

示例文件：

ChnSentiCorp_htl_all.csv
metric_f1
metric_accuracy

1. 环境准备

确保已安装必要的库。如果没有安装，请运行以下命令：

pip install transformers torch datasets evaluate

evaluate: 用于加载和计算评估指标（如准确率和F1分数）。

2. Step 1: 导入相关包

我们需要导入Transformers的核心模块、datasets用于数据加载，以及torch用于张量操作。

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments, DataCollatorWithPadding, pipeline
from datasets import load_dataset
import torch
import evaluate

3. Step 2: 加载数据集

你提供的代码使用本地CSV文件ChnSentiCorp_htl_all.csv，这是一个中文酒店评论情感分类数据集。我们假设CSV文件格式为：

review: 评论文本。
label: 情感标签（0表示差评，1表示好评）。

加载并过滤掉review为空的数据：

dataset = load_dataset("csv", data_files="./ChnSentiCorp_htl_all.csv", split="train")
dataset = dataset.filter(lambda x: x["review"] is not None)
print(dataset)

输出示例：

Dataset({
 features: ['review', 'label'],
 num_rows: 7766 # 数据行数取决于你的文件
})

4. Step 3: 划分数据集

将数据集分为训练集和测试集（例如90%训练，10%测试）：

datasets = dataset.train_test_split(test_size=0.1)
print(datasets)

输出示例：

DatasetDict({
 train: Dataset({
 features: ['review', 'label'],
 num_rows: 6989
 })
 test: Dataset({
 features: ['review', 'label'],
 num_rows: 777
 })
})

5. Step 4: 数据集预处理

使用hfl/chinese-macbert-large的预训练分词器对中文文本进行分词和编码。

tokenizer = AutoTokenizer.from_pretrained("hfl/chinese-macbert-large")

def process_function(examples):
 tokenized_examples = tokenizer(examples["review"], max_length=32, truncation=True, padding="max_length")
 tokenized_examples["labels"] = examples["label"] # 将"label"重命名为"labels"，Trainer需要此字段
 return tokenized_examples

tokenized_datasets = datasets.map(process_function, batched=True, remove_columns=datasets["train"].column_names)
print(tokenized_datasets)

max_length=32: 限制输入长度为32个token，适合短文本任务，可根据需要调整。
remove_columns: 删除原始列（如review和label），保留分词后的字段（如input_ids、attention_mask和labels）。

输出示例：

DatasetDict({
 train: Dataset({
 features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],
 num_rows: 6989
 })
 test: Dataset({
 features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],
 num_rows: 777
 })
})

6. Step 5: 创建模型

加载hfl/chinese-macbert-large预训练模型，指定分类任务的类别数（2类：差评和好评）。

model = AutoModelForSequenceClassification.from_pretrained("hfl/chinese-macbert-large", num_labels=2)

7. Step 6: 创建评估函数

使用evaluate库加载准确率和F1分数指标，并定义评估函数。

acc_metric = evaluate.load("accuracy") # 如果网络不好，可用本地文件加载
f1_metric = evaluate.load("f1")

def eval_metric(eval_predict):
 predictions, labels = eval_predict
 predictions = predictions.argmax(axis=-1) # 取最大概率的类别
 acc = acc_metric.compute(predictions=predictions, references=labels)
 f1 = f1_metric.compute(predictions=predictions, references=labels, average="binary")
 return {"accuracy": acc["accuracy"], "f1": f1["f1"]}

如果网络不佳，可以下载metric_accuracy.py和metric_f1.py脚本本地加载（从Hugging Face的evaluate库获取）。

8. Step 7: 创建TrainingArguments

定义训练参数，控制训练过程。

train_args = TrainingArguments(
 output_dir="./results", # 模型保存路径
 evaluation_strategy="epoch", # 每轮评估一次
 save_strategy="epoch", # 每轮保存一次
 learning_rate=2e-5, # 学习率
 per_device_train_batch_size=16, # 训练批次大小
 per_device_eval_batch_size=16, # 验证批次大小
 num_train_epochs=3, # 训练轮数
 weight_decay=0.01, # 权重衰减
 logging_dir="./logs", # 日志保存路径
 logging_steps=10, # 每10步记录一次日志
 load_best_model_at_end=True, # 训练结束时加载最佳模型
 metric_for_best_model="f1", # 以F1分数选择最佳模型
)

load_best_model_at_end=True: 确保训练结束后加载在验证集上表现最好的模型。

9. Step 8: 创建Trainer

初始化Trainer，并结合参数冻结和数据整理器。

# 参数冻结（可选，仅微调分类头）
for name, param in model.bert.named_parameters():
 param.requires_grad = False # 冻结BERT部分参数，节省计算资源

# 数据整理器，动态填充批次
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

trainer = Trainer(
 model=model,
 args=train_args,
 train_dataset=tokenized_datasets["train"],
 eval_dataset=tokenized_datasets["test"],
 data_collator=data_collator,
 compute_metrics=eval_metric,
)

参数冻结: 冻结BERT主干，仅训练分类层，适合资源有限或数据量较小的场景。若需全参数微调，可删除冻结代码。
DataCollatorWithPadding: 动态填充批次中的序列长度，提高效率。

10. Step 9: 模型训练与评估

开始训练并在测试集上评估模型。

# 训练模型
trainer.train()

# 评估模型
eval_results = trainer.evaluate(tokenized_datasets["test"])
print("评估结果:", eval_results)

# 预测测试集
predictions = trainer.predict(tokenized_datasets["test"])
print("预测结果示例:", predictions.predictions[:5]) # 查看前5个预测logits

11. Step 10: 模型预测

对新句子进行推理，提供两种方式：手动推理和使用pipeline。

手动推理：

sen = "我觉得这家酒店不错，饭很好吃！"
id2_label = {0: "差评！", 1: "好评！"}
model.eval()
with torch.inference_mode():
 inputs = tokenizer(sen, return_tensors="pt")
 inputs = {k: v.to("cuda") for k, v in inputs.items()} # 如果有GPU
 logits = model(**inputs).logits
 pred = torch.argmax(logits, dim=-1)
 print(f"输入：{sen}\n模型预测结果:{id2_label[pred.item()]}")

使用Pipeline：

model.config.id2label = id2_label # 为pipeline设置标签映射
pipe = pipeline("text-classification", model=model, tokenizer=tokenizer, device=0) # device=0表示GPU
result = pipe(sen)
print(f"输入：{sen}\nPipeline预测结果:{result}")

输出示例：

输入：我觉得这家酒店不错，饭很好吃！
模型预测结果:好评！
Pipeline预测结果:[{'label': '好评！', 'score': 0.95}]

12. 完整代码示例

以下是将所有步骤整合的完整脚本：

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments, DataCollatorWithPadding, pipeline
from datasets import load_dataset
import torch
import evaluate

# Step 2: 加载数据集
dataset = load_dataset("csv", data_files="./ChnSentiCorp_htl_all.csv", split="train")
dataset = dataset.filter(lambda x: x["review"] is not None)

# Step 3: 划分数据集
datasets = dataset.train_test_split(test_size=0.1)

# Step 4: 数据集预处理
tokenizer = AutoTokenizer.from_pretrained("hfl/chinese-macbert-large")
def process_function(examples):
 tokenized_examples = tokenizer(examples["review"], max_length=32, truncation=True, padding="max_length")
 tokenized_examples["labels"] = examples["label"]
 return tokenized_examples
tokenized_datasets = datasets.map(process_function, batched=True, remove_columns=datasets["train"].column_names)

# Step 5: 创建模型
model = AutoModelForSequenceClassification.from_pretrained("hfl/chinese-macbert-large", num_labels=2)

# Step 6: 创建评估函数
acc_metric = evaluate.load("accuracy")
f1_metric = evaluate.load("f1")
def eval_metric(eval_predict):
 predictions, labels = eval_predict
 predictions = predictions.argmax(axis=-1)
 acc = acc_metric.compute(predictions=predictions, references=labels)
 f1 = f1_metric.compute(predictions=predictions, references=labels, average="binary")
 return {"accuracy": acc["accuracy"], "f1": f1["f1"]}

# Step 7: 创建TrainingArguments
train_args = TrainingArguments(
 output_dir="./results",
 evaluation_strategy="epoch",
 save_strategy="epoch",
 learning_rate=2e-5,
 per_device_train_batch_size=16,
 per_device_eval_batch_size=16,
 num_train_epochs=3,
 weight_decay=0.01,
 logging_dir="./logs",
 logging_steps=10,
 load_best_model_at_end=True,
 metric_for_best_model="f1",
)

# Step 8: 创建Trainer
for name, param in model.bert.named_parameters():
 param.requires_grad = False # 参数冻结
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
trainer = Trainer(
 model=model,
 args=train_args,
 train_dataset=tokenized_datasets["train"],
 eval_dataset=tokenized_datasets["test"],
 data_collator=data_collator,
 compute_metrics=eval_metric,
)

# Step 9: 模型训练与评估
trainer.train()
eval_results = trainer.evaluate(tokenized_datasets["test"])
print("评估结果:", eval_results)

# Step 10: 模型预测
sen = "我觉得这家酒店不错，饭很好吃！"
id2_label = {0: "差评！", 1: "好评！"}
model.eval()
with torch.inference_mode():
 inputs = tokenizer(sen, return_tensors="pt")
 inputs = {k: v.to("cuda") for k, v in inputs.items()}
 logits = model(**inputs).logits
 pred = torch.argmax(logits, dim=-1)
 print(f"输入：{sen}\n模型预测结果:{id2_label[pred.item()]}")

# 使用Pipeline预测
model.config.id2label = id2_label
pipe = pipeline("text-classification", model=model, tokenizer=tokenizer, device=0)
print(f"Pipeline预测结果:{pipe(sen)}")

补充说明

数据集下载: 如果没有ChnSentiCorp_htl_all.csv，可从网上下载（如https://github.com/pengming617/bert_classification）。
硬件需求: chinese-macbert-large模型较大，建议使用GPU运行。若无GPU，可减小max_length或使用更小的模型（如bert-base-chinese）。
参数调整: 若数据量较大，可取消参数冻结（删除requires_grad = False），进行全参数微调。
保存模型: 训练完成后，模型会自动保存到./results目录，可用trainer.save_model()手动保存。

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

RLHF

Wed, 12 Mar 2025 10:02:16 +0800

RLHF（Reinforcement Learning from Human Feedback）的详细解释

RLHF（基于人类反馈的强化学习，Reinforcement Learning from Human Feedback）是一种用于对齐大语言模型（LLM）与人类价值观和偏好的训练方法。它通过结合强化学习（Reinforcement Learning, RL）和人类反馈，解决传统监督学习难以直接优化的主观目标问题（如生成“有用、诚实、无害”的输出）。以下是对RLHF的详细解释，包括其背景、原理、步骤、优势与挑战。

1. 背景与动机

大语言模型通常通过预训练（基于无标注文本预测下一个词元）和监督微调（基于标注数据优化特定任务）构建。然而，互联网上的训练数据可能包含低质量、有偏见或有害的内容，导致模型输出不符合人类期望。例如，模型可能生成虚假信息、有害建议或不恰当的语气。在实际应用中，用户希望模型不仅能完成任务，还要符合人类的价值观和道德标准，如“3H对齐标准”（Helpfulness 有用性、Honesty 诚实性、Harmlessness 无害性）。

传统的监督学习依赖于明确的损失函数（如交叉熵损失），但“有用性”或“无害性”这样的目标难以形式化定义，无法直接通过标注数据优化。强化学习则通过奖励机制优化模型行为，适合处理这类复杂目标。RLHF将人类反馈引入强化学习，作为奖励信号的来源，从而指导模型生成更符合人类预期的输出。

2. RLHF的基本原理

RLHF的核心思想是：通过人类评估模型输出质量，构建一个奖励模型（Reward Model），然后利用强化学习算法优化语言模型，使其最大化预期奖励。 换句话说，它将人类的主观判断转化为可量化的信号，用于改进模型行为。

在强化学习框架中：

智能体（Agent）：大语言模型。
动作（Action）：生成特定的文本输出。
环境（Environment）：人类的反馈机制。
奖励（Reward）：基于人类偏好计算的数值，用于衡量输出的质量。

RLHF的关键创新在于，奖励不是由预定义的规则生成，而是通过人类反馈间接学习。

3. RLHF的工作流程

RLHF通常分为三个主要步骤：

步骤1：收集人类反馈数据

过程：让人类评估者对模型生成的多个输出进行评分或排序。例如，给定一个问题，模型生成两个回答，人类评估者选择哪个更好，或者按质量打分（如1-5分）。
数据形式：通常是成对比较（Pairwise Comparison），如“输出A优于输出B”，或者直接评分。
目的：通过人类反馈构建一个偏好数据集，反映人类对输出的主观判断。

步骤2：训练奖励模型（Reward Model）

目标：基于人类反馈数据训练一个独立的神经网络（奖励模型），预测某段输出的“奖励分数”。
方法：
1. 使用监督学习，将人类偏好数据转化为奖励模型的训练目标。例如，若人类认为“输出A > 输出B”，奖励模型学习给A更高的分数。
2. 常见损失函数是基于Bradley-Terry模型的偏好损失，用于拟合人类排序数据。
输入和输出：奖励模型接收语言模型的输出（文本），输出一个标量值，表示该输出的质量。
结果：奖励模型作为一个“代理”，替代人类直接评估，为后续优化提供连续的奖励信号。

步骤3：强化学习优化语言模型

方法：使用强化学习算法（如PPO，Proximal Policy Optimization）调整语言模型的参数，使其生成最大化奖励模型预测分数的输出。
过程：
1. 语言模型生成文本（动作）。
2. 奖励模型评估该文本并给出分数（奖励）。
3. 强化学习算法根据奖励更新模型策略，倾向于生成高奖励的输出。
约束：为了避免模型偏离原始语言能力，通常会加入KL散度惩罚（KL Divergence Penalty），确保优化后的模型不会过于偏离预训练分布。
结果：模型学会生成更符合人类偏好的输出，如更友好、准确或安全的回答。

4. RLHF的实际案例

以OpenAI的ChatGPT为例：

初始模型：GPT-3通过预训练和监督微调生成对话，但可能包含不准确或有害内容。
RLHF应用：
1. 收集人类对话数据，评估者对模型输出进行偏好排序。
2. 训练奖励模型，预测哪些回答更“有用、诚实、无害”。
3. 用PPO算法优化GPT-3，使其输出更符合人类期望。
效果：ChatGPT相比原始GPT-3更加安全、友好，且能更好地遵循指令。

5. RLHF的优势

灵活性：能优化难以形式化的目标（如主观质量），无需明确的标注数据。
对齐性：有效将模型行为与人类价值观对齐，减少偏见和有害输出。
通用性：适用于多种任务，如对话生成、问答等。
动态调整：通过持续收集反馈，可以逐步改进模型。

6. RLHF的挑战与局限

复杂性：训练奖励模型和强化学习过程计算成本高，优化不稳定。
人类反馈质量：依赖评估者的一致性和专业性，反馈噪声可能影响奖励模型。
过优化风险：模型可能过于迎合奖励模型，导致失去多样性或生成“讨好式”输出。
可解释性：奖励模型的黑盒性质使得对齐过程难以完全理解。
扩展性：需要大量人类反馈数据，成本随模型规模增加而上升。

7. RLHF的改进与替代

由于RLHF的复杂性，学术界提出了简化方法：

DPO（Direct Preference Optimization）：直接基于人类偏好优化模型，跳过奖励模型训练，降低计算复杂度。
监督微调（SFT）：用高质量标注数据直接微调模型，作为RLHF的补充或替代。

此外，OpenAI的“超级对齐”（Super-alignment）项目探索如何在未来监管超级智能，确保其行为可控，这表明RLHF可能只是对齐技术的一个起点。

8. 总结

RLHF是一种将人类主观偏好融入大语言模型优化的强大方法，通过“人类反馈 → 奖励模型 → 强化学习”的流程，显著提升模型的安全性、实用性和对齐性。它在大语言模型（如ChatGPT、GPT-4）的发展中起到关键作用，是实现“3H对齐标准”的重要技术。尽管存在复杂性和成本挑战，RLHF仍是当前对齐研究的主流方向，并为通用人工智能的伦理治理提供了宝贵经验。

深度学习开源框架

Thu, 06 Mar 2025 21:38:33 +0800

DeepSpeed

什么是 DeepSpeed？

DeepSpeed 是一个开源深度学习优化库，专为分布式训练和大规模模型设计。它提供了多种工具和技术，如 ZeRO（零冗余优化器）、混合精度训练和高效的并行策略，帮助开发者在 GPU 上更快、更高效地训练模型。DeepSpeed 的主要目标是降低内存占用并提升训练速度，特别适用于超大型语言模型（LLM）。
deepspeed在深度学习模型软件体系架构中所处的位置是？

核心功能

ZeRO（零冗余优化器）：通过分割优化器状态、分梯度和参数，减少内存冗余，支持更大的模型。
混合精度训练：结合 FP16 和 BF16，加速计算并减少内存需求。
分布式训练支持：支持数据并行、模型并行和流水线并行。
高效激活检查点：优化内存使用，允许更大的批量大小。
超大模型支持：能够训练超过千亿参数的模型。

安装 DeepSpeed

在开始使用 DeepSpeed 之前，需要安装它。以下是安装步骤：

确保环境准备：
- Python 3.6 或更高版本
- PyTorch（建议最新稳定版）
- CUDA（与 PyTorch 兼容的版本）
通过 pip 安装 DeepSpeed：
```
pip install deepspeed
```
验证安装：运行以下命令检查是否成功安装：
```
ds_report
```
这将显示 DeepSpeed 的配置信息和环境兼容性。

集成 DeepSpeed 到 PyTorch

以下是一个简单的例子，展示如何将 DeepSpeed 集成到 PyTorch 训练代码中。

示例代码

import torch
import torch.nn as nn
import deepspeed

# 定义一个简单的模型
class SimpleModel(nn.Module):
 def __init__(self):
 super(SimpleModel, self).__init__()
 self.fc1 = nn.Linear(10, 10)
 self.fc2 = nn.Linear(10, 2)

 def forward(self, x):
 x = torch.relu(self.fc1(x))
 x = self.fc2(x)
 return x

# 初始化模型和数据
model = SimpleModel()
data = torch.randn(32, 10) # 批量大小 32，输入维度 10
labels = torch.randint(0, 2, (32,))

# 定义 DeepSpeed 配置
ds_config = {
 "train_batch_size": 32,
 "gradient_accumulation_steps": 1,
 "fp16": {
 "enabled": True # 启用混合精度训练
 },
 "optimizer": {
 "type": "Adam",
 "params": {
 "lr": 0.001
 }
 }
}

# 初始化 DeepSpeed
model_engine, optimizer, _, _ = deepspeed.initialize(
 model=model,
 model_parameters=model.parameters(),
 config=ds_config
)

# 前向传播和反向传播
outputs = model_engine(data)
loss = nn.CrossEntropyLoss()(outputs, labels)
model_engine.backward(loss)
model_engine.step()

代码说明

模型定义：这里使用了一个简单的两层全连接神经网络。
DeepSpeed 配置：ds_config 是一个字典，指定训练参数，如批量大小、优化器类型和混合精度选项。
初始化 DeepSpeed：deepspeed.initialize 将模型和优化器包装为 DeepSpeed 引擎。
训练步骤：使用 model_engine 替代原始 PyTorch 模型进行前向传播、反向传播和参数更新。

配置文件的替代方式

除了在代码中定义 ds_config，你还可以创建一个 JSON 文件（例如 ds_config.json）：

{
 "train_batch_size": 32,
 "gradient_accumulation_steps": 1,
 "fp16": {
 "enabled": true
 },
 "optimizer": {
 "type": "Adam",
 "params": {
 "lr": 0.001
 }
 }
}

然后在初始化时加载：

model_engine, optimizer, _, _ = deepspeed.initialize(
 model=model,
 model_parameters=model.parameters(),
 config="ds_config.json"
)

运行分布式训练

要使用多个 GPU 运行训练，只需通过 deepspeed 命令启动脚本：

deepspeed train.py --deepspeed --deepspeed_config ds_config.json

确保你的脚本支持分布式环境（例如，使用 torch.distributed.launch 或 DeepSpeed 的内置分布式支持）。

高级功能：ZeRO 优化

ZeRO 有三个阶段，可以通过配置启用：

ZeRO-1：分割优化器状态。
ZeRO-2：分割优化器状态和梯度。
ZeRO-3：分割优化器状态、梯度和参数。

示例配置：

{
 "zero_optimization": {
 "stage": 2,
 "allgather_partitions": true,
 "reduce_scatter": true
 }
}

注意事项

硬件要求：DeepSpeed 需要 GPU 支持，建议使用 NVIDIA GPU。
调试：如果遇到问题，可以检查 ds_report 输出或启用详细日志（"verbose": true）。
文档参考：查看 DeepSpeed 官方文档获取更多高级用法。

transformers

transformers 库（通常指 Hugging Face 公司开发的库）是目前深度学习，尤其是自然语言处理（NLP）领域中最重要、最核心的库之一。

它本身是一个 Python 库，但由于其生态系统极其完整和强大，很多人也视它为一个“框架”。它极大地简化了访问和使用最先进（SOTA）的 Transformer 模型（如 BERT, GPT, T5 等）的复杂度。

以下是 Hugging Face transformers 库的主要特点：

🤖 Hugging Face `transformers` 的核心特点

1. 庞大且活跃的模型中心 (Model Hub)

这是 transformers 最核心的优势。Hugging Face 运营着一个巨大的模型仓库（Model Hub），任何人都可以上传、下载和分享预训练模型。

海量模型： 截至目前，上面有数十万个预训练模型，涵盖了文本、图像、音频等多种模态。
社区驱动： 不仅有 Google、Meta、OpenAI 等大公司发布的官方模型，还有大量由社区贡献的、针对特定任务或特定语言微调（Fine-tune）过的模型。
版本控制与复现： 所有模型都与代码和分词器（Tokenizer）绑定，可以轻松复现他人的工作。

2. 极佳的易用性 (Ease of Use)

Hugging Face 的 API 设计哲学是“简单”和“一致”。

pipeline() 抽象： 这是最简单的入门方式。您只需几行代码，就可以完成一个复杂的NLP任务（如情感分析、问答），而无需关心背后的模型和数据处理流程。
AutoModel / AutoTokenizer： 您不需要知道某个具体模型（比如 ‘bert-base-uncased’）是 BertModel 还是 RobertaModel。您只需使用 AutoModel.from_pretrained(...)，它会自动识别并加载正确的模型架构。
一致的 API： 无论您使用的是 BERT 还是 GPT-2，加载模型 (from_pretrained) 和保存模型 (save_pretrained) 的方法都是完全一样的。

3. 框架互操作性 (Framework Interoperability)

transformers 库并不是要取代已有的深度学习框架，而是构建在它们之上。

无缝切换： 它完美支持 PyTorch, TensorFlow 和 JAX。
灵活性： 您可以使用 PyTorch 版本的 transformers 训练一个模型，然后将其保存，再用 TensorFlow 版本的 transformers 加载它，模型权重会自动转换。这为不同技术栈的团队协作提供了巨大便利。

4. 任务导向的抽象 (Task-Oriented Abstraction)

transformers 库围绕“任务”提供了清晰的模型分类。

明确的命名： 当您想做一个分类任务时，您会寻找 ...ForSequenceClassification 结尾的模型（如 BertForSequenceClassification）。
开箱即用： 这些模型已经在基础模型（如 BERT）的顶部添加了适合特定任务的“头部”（Head），例如一个用于分类的全连接层。您加载后只需直接进行微调。

5. 强大且一致的分词 (Tokenization)

文本处理是NLP的第一步。transformers 配套了 tokenizers 库（一个用 Rust 编写的高性能库）。

一致性： 提供了与 AutoModel 对应的 AutoTokenizer，确保您使用的分词器与预训练模型是严格匹配的。
高性能： 分词速度极快，可以并行处理大量文本。

6. 完整的生态系统 (A Complete Ecosystem)

transformers 并不是孤立的，Hugging Face 围绕它构建了一整套工具链：

datasets: 用于高效加载和处理大型数据集（TB级别）。
evaluate: 用于评估模型性能的指标库。
accelerate: 用于简化分布式训练和混合精度训练的工具。
diffusers: 专注于扩散模型（如 Stable Diffusion）的库。

对比了几种大模型在相同任务下的表现

Thu, 06 Mar 2025 15:11:55 +0800

每个模型我试了多次，然后取比较好的，当然可能也和提示词有关！！！

内容梳理任务

总结文档的内容-1

Summarize the content from the following websites:

https://www.zhihu.com/hot: 知乎 - 有问题，就会有答案打开知乎App在「我的页」右上角打开扫一扫其他扫码方式：微信下载知乎App开通机构号无障碍模式 验证码登录密码登录获取短信验证码获取语音验证码登录/注册其他方式登录未注册手机验证后自动登录，注册即代表同意《知乎协议》《隐私保护指引》知乎专栏圆桌发现移动应用联系我们来知乎工作注册机构号Investor Relations© 2025 知乎京 ICP 证 110745 号京 ICP 备 13052560 号 - 1京公网安备 11010802020088 号京网文[2022]2674-081 号出版物经营许可证药品医疗器械网络信息服务备案（京）网药械信息备字（2022）第00334号广播电视节目制作经营许可证:（京）字第06591号互联网宗教 信息服务许可证：京（2022）0000078侵权举报网上有害信息举报专区儿童色情信息举报专区互联网算法推荐举报专区违法和不良信息举报：010-82716601举报邮箱：jubao@zhihu.com
https://www.aibase.com/zh/daily : AI日报 - 每天三分钟关注AI行业趋势_AIbase zh AI产品榜 每月不到10元，就可以无限制地访问最好的AIbase。立即成为会员 首 页 AI资讯 AI日报 变现指南 AI教程 AI工具导航 AI产品库zh AI产品榜 3月5号 AI 日报AI日报：抖音测试接入豆包AI；即梦接入DeepSeek支持智能提示词生成；Grok语 音模式全面开放查看日报 包含 10 个AI热点话题内容1、AI思维导图神器 MindMapper ：扔个链接就能生成交互式思维导图2、全新技术 Fast3R ：实现千张图片一键3DD 重建，速度惊人!3、强强联合！即梦接入DeepSeek 从提示词到绘画一步到位4、抖音打通豆包AI，字节跳动开启超级AI生态战略5、Grok 语音模式全面开放：11 种模式 上线，自带字幕成英语学习利器6、爱诗科技完成A5轮融资，剑指AI视频生成领域新高地7、微软开源图片模型ART，可生成多图层透明图片8、音乐创作领域投下核弹！DiffRhythm 炸裂问世：10 秒 AI 神曲，人声伴奏一键搞定！9、vivo重组调整，成立新AI部门并将大模型训练转向端侧10、雷军亮相首场代表通道：小米将把最新的AI技术 应用到各个终端上往期日报~3月4号 AI 日报AI日报：可生成汉字！智谱开源文生图模型CogView4；大模型工具Ollama存在严重漏洞；腾讯元宝下载量超DeepSeek 包含 13 个AI热点话题内容查看日报1、智谱发布首个能生成汉字的开源文生图模型CogView42、超强视频生成模型 Wan2.1 GP：低配GPU也能搞定大片！3、颠覆城市建模！AI生 成3D城市模型GaussianCity，生成速度提升 60 倍！4、火山引擎宣布大模型应用开源：上线“大模型应用实验室”，释放 AI 创新潜力5、雷军两会建议：建议加强“AI换脸拟声”违法侵权重灾区治理6、雷军2025两会建议：聚焦人工智能终端与AI换脸拟声治理7、警惕安全隐患！Ollama 大模型工具被指存在严重漏洞8、从编码到创意写作 xAI Grok-3 击败 GPT4.5全能登顶大模型竞技场3月3号 AI 日报AI日报：字节AI编程工具Trae国内版发布；天价AI域名ai.com挂牌1亿美元；星火深度推理大模型X1全面升级 包含 13 个AI热点话题内容查看日报1、科大讯飞宣布完成星火深度推理大模型X1全面升级2、百度文库、百度网盘AI创作新物种「自由画布」全量上线3、中国2025一季 度人工智能现状分析：摆脱“学生”标签，从追赶者到竞争者4、Flora推出AI驱动的“无限画布”工具，专为创意专业人士打造5、字节跳动AI编程产品Trae国内版发布 配置 豆包1.5pro、满血版DeepSeek模型6、荣耀 CEO 李健发布阿尔法计划：未来5年投100亿美元打造 AI 生态！7、超越DeepSeek-R1！阿里万相大模型登上全球开源榜首8、天价域名再现：ai.com挂牌1亿美元，或成史上最贵域名交2月28号 AI 日报AI日报：OpenAI最大最贵模型GPT-4.5发布；百度文心大模型4.5上线定档3月16日；字节AI编程工具Trae集成Claude 3.7 包含 13 个AI热点话题内容查看日报1、百度网盘与百度文库全量上线DeepSeek-R1满血版 前者将于3月改版2、免费试用！Krea推出 Wan 2.1模型：动态效果惊艳 可理解复杂提示3、转战 AI 课程直播！“嘎子哥”谢孟伟开卖DeepSeek课程4、荣耀与阿里在AI领域展开合作 千问、万相等已接入YOYO智能体5、百度文 心大模型4.5将于3月16日发布 具备原生多模态、深度思考等能力6、华为AI助手小艺网页版上线 支持问答、写作、编程等7、文生图模型Ideogram 2a 震撼发布：速度翻 倍、成本减半，英文排版媲美人类设计8、DeepSeek开源周第五天：6.6TiB/s炸场！3FS重新定义AI存储基建2月27号 AI 日报AI日报：阿里春招3000岗位AI相关占50%；DeepSeek开源DualPipe与EPLB技术；字节豆包APP推“照片动起来”功能 包含 18 个AI热点话题内容查看日报1、腾讯混元新一代快思考模型 Turbo S 发布 即将在腾讯元宝中上线2、百度文心4.5或将在3月中旬发布 提升推理及多模态能力3、Anthropic 开放 Claude AI GitHub 集成，助力开发者代码效率4、快手可灵AI 1月全球访问用户环 比增长113%5、Adobe推出Photoshop iOS版本，提供丰富免费功能与无缝跨设备体验6、B站文本转语音模型IndexTTS ：支持拼音纠正汉字发音、精准控制停顿7、阿里启动2026届春招，开放3000岗位AI相关占近50%8、字节跳动AI智能助手豆包APP推出“照片动起来”功能2月26号 AI 日报AI日报：阿里开源文生视频模型万相2.1；幻方量化回应DeepSeek-R2模型提前发布；百度“秒哒”开启用户邀测 包含 16 个AI热点话题内容查看日报1、OpenAI向免费用户推出基于GPT-4o mini的高级语音模式2、支持联网搜索！OPPO ColorOS接入满血版DeepSeek-R13、谷歌超低价AI模型Gemini 2.0 Flash-Lite正式上线 4、OpenAI免费开放ChatGPT高级语音聊天模式 基于GPT-4o mini5、萌翻全网！AI“魔法”让校园地标秒变毛绒玩偶，创意特效火爆出圈！6、报道称字节跳动旗下AI产品 “即梦” 考虑接入 DeepSeek7、AI料理 “神还原” 引爆全网 网友：8888元卖给 上海人！8、阿里全面开源文生视频模型万相2.1：14B和1.3B双版本上线2月25号 AI 日报AI日报：全球首个混合推理模型Claude 3.7 Sonnet发布；阿里开源推理模型QwQ ；DeepSeek平台API充值服务恢复 包含 12 个AI热点话题内容查看日报1、谷歌推出免费AI代码助手Gemini Code Assist ：每月提供18万次代码补全2、DeepSeek开放平 台API充值服务已正式恢复3、百度教育「拍照搜题」、「AI写作文」接入DeepSeek-R1模型4、京东零售技术发布京点点AIGC内容生成平台 一键生成商品图、营销文案5、 拼多多组建电商推荐大模型团队：负责人年薪数倍于百度时期，内部推行赛马机制6、商汤小浣熊家族全面升级：多模态融合 10秒钟即可复刻网页7、DeepSeek开源周第二日：首个面向MoE模型的开源EP通信库8、ChatGPT新增Safari扩展功能，可设置为Safari浏览器地址栏默认搜索引擎2月24号 AI 日报AI日报：DeepSeek开源大模型加速 器FlashMLA；海螺AI推I2V-01-Director模型；Pixverse V4.0支持同步音效与转绘功能 包含 13 个AI热点话题内容查看日报1、百度APP全面焕新：上线AI入口 DeepseekR1深度搜索不卡顿2、海螺AI解锁全新“导演”模式：I2V-01-Director模型向所有人开放3、1x发布家庭机器人NEO Gamma：能冲咖啡、洗衣和吸尘等4、DeepSeek 开源周首日 ：发布大模型加速利器FlashMLA 解码性能飙升至3000GB/s5、Grok 3上线实时语音功能 一共支持10种模式 6、LiblibAI哩布哩布AI宣布再获数亿元融资 一年内连续完成 四轮融资7、融资速度“开挂”！LiblibAI再获数亿投资，一年连融四轮 领跑 AI 应用赛道8、Meta AI 发布新型视频学习模型V-JEPA ：视频理解新突破2月21号 AI 日报AI日报：给力！DeepSeek下周将开源五个项目；阿里通义万相将开源视频生成模型WanX 2.1；ChatGPT周活跃用户突破4亿 包含 15 个AI热点话题内容查看日报1、网信办发布2025年“清朗”系列专项行动 整治AI技术滥用乱象2、小红书将接入DeepSeek，AI 搜索产品“点点” 内测深度思考功能3、腾讯文档接入DeepSeek 上线PPT直出、周报神 器、文献速读功能4、DeepSeek App 上线一个月下载量突破 1 亿5、扣子Coze宣布独家支持 DeepSeek Function Calling 工具调用能力6、超给力！DeepSeek 宣布下周开源五个项目7、Figure推出新型智能模型 Helix，让人形机器人接受语音命令做家务8、Midjourney 网站新增多项组织功能，提升用户体验2月20号 AI 日报AI日报：腾讯 深度思考模型“混元T1”全面开放；字节跳动全新视频生成工具Phantom；苹果智能将于4月初支持简体中文 包含 12 个AI热点话题内容查看日报1、xAI称已面向所有用户 免费提供 Grok3 直到他们服务器崩溃2、谷歌发布全新视觉语言模型 PaliGemma 2 Mix 集成多种功能助力开发者3、NVIDIA和Arc研究所联合发布全球最大生物学 AI 模型 Evo2，助力基因组研究与设计4、Mistral的AI助手Le Chat两周内下载量突破百万5、警惕！马斯克的新AI模型Grok 3被曝存在严重安全漏洞，黑客可轻松操控！6、Xboxx推新生成AI模型Muse,助力游戏开发者高效创建游戏元素7、微软团队推多模态AI模型Magma：整合视觉、语言和动作决策技能8、Rabbit展示新AI代理能力：从下载游戏 到自动管理购物清单

Task:


<URL>: <保留原本的内容，但是更有利于阅读，总结>. ...

模型效果

Qwen ☆☆☆☆☆
Grok ☆☆☆☆☆
Deepseek ☆☆
ChatGLM ☆

Qwen2.5-max ☆☆☆☆☆

Grok3 ☆☆☆☆☆

DeepSeek-V3 ☆☆

ChatGLM-plus ☆

总结文档的内容-2 （检查是否更新

模型效果

qwq-32b ☆☆☆☆☆
Grok ☆☆☆☆☆
Deepseek ☆☆
ChatGLM ☆

这里我给出一个实际上没有更新的内容，最好应该就是返回没有更新


你是一个订阅号运营专家，可以根据差异内容总结出订阅内容的更新情况，请对以下内容差异进行总结：
 "[""Changed: '53 分钟' -> '1 小时'"", ""Changed: '1' -> '2'"", ""Changed: '3' -> '4'"", ""Changed: '3' -> '4'"", ""Changed: '4' -> '5'"", ""Changed: '4' -> '5'""]"

 注意，有些内容的可能仅仅是时间或者数据的变化，这样的内容更新是不需要总结的，可以看作没有更新，返回空数组

 要求：
 1. 提供简洁的内容更新概要
 2. 提取关键点
 3. 计算内容的列表长度
 返回结果使用中文,如果内容更新或者没有关键点，请返回空数组。
 请根据以上要求，总结出订阅内容的更新情况，并返回结果。


 返回格式json（请严格按照以下格式返回）：
 {{
 "summary": {{
 "content": [],
 "key_points": [],
 "word_count": 0,
 "generated_at": ""
 }},
 }}


 """

qwq-32b ☆☆☆☆☆

非常可以，只返回了json，没有一点多余的内容

Grok3 ☆☆☆☆

也非常可以，对了，但是比起qwq-32b ，还是没有做到：只返回json

按照要求输出内容-1

from datetime import datetime
import time
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import PydanticOutputParser
import json
import re
from pydantic import BaseModel, Field
from typing import List, Optional

# 假设的 LLM 获取函数（需要根据你的实际环境调整）
from src.agent.llm import get_ali_llm

# 定义 Pydantic 模型用于输出解析
class SummaryResponse(BaseModel):
 content: List[str] = Field(default_factory=list, description="内容更新概要")
 key_points: List[str] = Field(default_factory=list, description="关键点列表")
 word_count: int = Field(default=0, description="内容字数统计")
 generated_at: str = Field(default="", description="生成时间")
 status: str = Field(default="success", description="处理状态")
 error_message: Optional[str] = Field(default=None, description="错误信息")
 raw_response: Optional[str] = Field(default=None, description="原始响应")

class SubscriptionAgent:
 def __init__(self, llm_model=None, max_retries=3, retry_delay=2):
 # 初始化 LLM，如果没有传入特定模型，使用默认配置
 self.llm = llm_model if llm_model else get_ali_llm("qwen-7b-chat")
 self.max_retries = max_retries # 最大重试次数
 self.retry_delay = retry_delay # 重试间隔时间（秒）

 # 定义 Pydantic 输出解析器
 self.parser = PydanticOutputParser(pydantic_object=SummaryResponse)

 # 定义提示模板，进一步优化以确保提取 key_points
 self.prompt_template = PromptTemplate(
 input_variables=["contentdiff"],
 partial_variables={"format_instructions": self.parser.get_format_instructions()},
 template="""
 你是一个订阅号运营专家，可以根据差异内容总结出订阅内容的更新情况。请对以下内容差异进行总结：
 {contentdiff}

 ###注意，有些内容的可能仅仅是时间或者数据的变化，这样的内容更新是不需要总结的，可以看作没有更新，返回空数组

 ###要求：
 1. 提供内容更新概要（content），用数组形式返回。
 2. 提取每个内容的关键点（key_points），每个关键点应简洁且突出重点。
 3. content和key_points的列表长度应当一致，也就是他们是一一对应关系
 4. 计算 content 字段的总字数（仅统计中文和英文字符，不包括标点和空格）。
 5. 返回结果使用中文，如果没有实质性更新或关键点，返回空数组。
 6. 严格按照以下 JSON 格式返回结果，不添加任何多余的说明文字或注释：
 {format_instructions}
 """
 )

 def extract_json(self, raw_content: str) -> str:
 """从原始响应中提取 JSON 字符串"""
 json_match = re.search(r'\{.*\}', raw_content, re.DOTALL)
 return json_match.group(0) if json_match else raw_content

 def generate_summary(self, contentdiff: str) -> SummaryResponse:
 """
 生成 summary 的主函数
 参数:
 contentdiff: 输入的内容差异文本
 返回:
 SummaryResponse: 包含摘要内容的 Pydantic 模型
 """
 retries = 0
 last_exception = None
 raw_response = None

 while retries < self.max_retries:
 try:
 # 执行 LLM 调用获取原始响应
 chain = self.prompt_template | self.llm
 raw_response = chain.invoke({"contentdiff": contentdiff})

 # 检查并提取原始内容
 raw_content = raw_response.content if hasattr(raw_response, 'content') else str(raw_response)
 json_content = self.extract_json(raw_content)

 # 尝试解析响应
 response = self.parser.parse(json_content)

 # 确保生成时间字段有值
 if not response.generated_at:
 response.generated_at = datetime.now().isoformat()

 # 计算字数（如果 LLM 未提供，则基于 content 计算）
 if response.word_count == 0 and response.content:
 response.word_count = len("".join(response.content).replace(" ", "").replace(",", "").replace(".", ""))

 # 添加原始响应到结果中
 response.raw_response = raw_content

 return response

 except Exception as e:
 last_exception = e
 retries += 1
 if retries < self.max_retries:
 time.sleep(self.retry_delay)
 continue

 # 所有重试都失败后，返回错误响应
 raw_content = raw_response.content if raw_response and hasattr(raw_response, 'content') else str(raw_response) if raw_response else "No response"
 return SummaryResponse(
 content=[],
 key_points=[],
 word_count=0,
 generated_at=datetime.now().isoformat(),
 status="error",
 error_message=f"Failed to parse SummaryResponse: {str(last_exception)}",
 raw_response=raw_content
 )

# 使用示例
def main():
 # 创建示例 contentdiff，确保包含可提取的关键点
 sample_contentdiff = """
"[""Changed: '1' -> '2 分钟前\n.\nAIbase\nFlower Labs 颠覆AI应用模式，2360万美元打造首个全开放混合计算平台\n人工智能正在以前所未有的速度融入我们的日常应用，而一家名为Flower Labs的初创公司正以革命性的方式改变AI模型的部署和运行方式。这家获得Y Combinator支持的新锐企业近日推出了Flower Intelligence，一个创新的分布式云平台，专为在移动设备、个人电脑和网络应用中提供AI模型服务而设计。Flower Intelligence的核心优势在于其独特的混合计算策略。该平台允许应用程序在本地设备上运行AI模型，既保证了速度，又增强了隐私保护。当需要更强大的计算能力时，系统会在获得用户同意的情况下，无\n7'"", ""Added: '美国埃隆大学的一项调查显示，5'"", ""Added: '%的美国成年人都曾使用过像ChatGPT、Gemini、Claude这样的AI大语言模型。这项由北卡罗来纳州埃隆大学“想象数字未来中心”在'"", ""Added: '月份开展的调查，选取了500名受访者。结果发现，在使用过AI的人群中，34%的人表示至少每天会使用一次大语言模型。其中，ChatGPT最受欢迎，72%的受访者都用过;谷歌的Gemini位居第二，使用率为50% 。图源备注：图片由AI生成，图片授权服务商Midjourney越来越多的人开始和AI聊天机器人建立起特殊的关系。调查显示，38%的用户认为大语言模\n27'"", ""Changed: '3' -> '9'"", ""Changed: '49' -> '55'"", ""Changed: '1' -> '2'"", ""Deleted: '\n2 小时前\n.\nAIbase\n叫板Sora？潞晨科技开源视频大模型Open-Sora 2.0，降本提速\n听说过壕无人性的 OpenAI Sora 吧?动辄几百万美元的训练成本，简直就是视频生成界的“劳斯莱斯”。现在，潞晨科技宣布开源视频生成模型 Open-Sora2.0!仅仅花费了区区20万美元（相当于224张 GPU 的投入），就成功训练出了一个拥有 110亿参数的商业级视频生成大模型。性能直追“OpenAI Sora ”别看 Open-Sora2.0成本不高，实力可一点都不含糊。它可是敢于叫板行业标杆 HunyuanVideo 和拥有300亿参数的 Step-Video 的狠角色。在权威评测 VBench 和用户偏好测试中，Open-Sora2.0的表现都令人刮目相看，多项关键指'""]"

 """

 # 初始化智能体
 agent = SubscriptionAgent(max_retries=3, retry_delay=2)
 summary_result = agent.generate_summary(sample_contentdiff)

 # 打印调试信息
 # print("Raw response:", summary_result.raw_response)
 # print("Error message:", summary_result.error_message)
 # print("Summary result:")
 print(json.dumps(summary_result.model_dump(), indent=2, ensure_ascii=False))

if __name__ == "__main__":
 main()





现在我只要你返回应当的json内容

qwq-max ☆☆☆☆

返回的格式不完全符合要求

qwq-32b ☆☆☆

返回的内容不完全符合要求

grok3 ☆☆☆☆☆

完全符合要求

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模型的普及，注意力机制已经成为深度学习领域的核心技术之一。未来，随着研究的深入，注意力机制将在更多领域发挥重要作用。

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

LLM微调：qwen2_chat模型部署和微调

Thu, 09 Jan 2025 10:14:04 +0800

Qwen - chat

模型部署

下载源码项目地址：https://github.com/QwenLM/Qwen

git clone https://github.com/QwenLM/Qwen.git 2. 配置环境

虚拟环境
安装相关的库 pip install -r requirements.txt

去modelspace或者github下面模型文件 git lfs install # 首先需要确保git lfs已经安装，安装方式：apt-get install git-lfs git clone https://www.modelscope.cn/qwen/Qwen-1_8B-Chat.git
修改web_demo.py中的模型文件地址，然后运行 python web_demo.py

注意，可能碰到问题：这个问题是由于安装的库不对导致的

模型微调

找到对应的数据集这里使用的是法律的数据集：https://modelscope.cn/datasets/Robin021/DISC-Law-SFT/files
在Qwen的文件里面新建一个Data文件夹
使用脚本把数据重新处理


import json
json_data = []
with open('DISC-Law-SFT-Triplet-released.jsonl', 'r', encoding='utf-8') as f:
 for line in f:
 json_data.append(json.loads(line))

template = []

for idx, data in enumerate(json_data):
 conversation = [
 {
 "from": "user",
 "value": data['input']
 },
 {
 "from": "assistant",
 "value": data['output']
 }
 ]
 template.append({
 "id":f"identity_{idx}",
 "conversations": conversation
 })

print(len(template))
print(json.dumps(template[2], indent=2, ensure_ascii=False))
output_file = 'DISC-train-data.json'
with open(output_file, 'w', encoding='utf-8') as f:
 json.dump(template, f, indent=2, ensure_ascii=False)
print(f"Data saved to {output_file}")

4. 安装模型训练用的依赖 pip install “peft<0.8.0” deepspeed 注意：可能会安装失败（一般是在Windows系统里面或者没有GPU）

缺失cpuinfo ： pip install py-cpuinfo
aio.lib 缺失参考：https://blog.csdn.net/dalaomanzou/article/details/137188431

set DS_BUILD_AIO=0
set DS_BUILD_EVOFORMER_ATTN=0
set DS_BUILD_OPS=0
set DS_BUILD_SPARSE_ATTN=0
pip install deepspeed==0.3.16 # 注意版本，新版本不支持了

如果还是会出现问题，就换环境吧

修改微调文件 finetune\finetune_lora_single_gpu.sh 中的MODEL和DATA变量
运行 bash finetune\finetune_lora_single_gpu.sh 就可以开始微调了（这个微调就必须要硬件设备达到，达不到硬件设备是跑不起来的）
微调好之后的模型会存储在项目文件夹下的output_qwen文件夹下面，会按照epoch次数存储多个检查点文件夹
下一步需要把训练好的lora模型和原始模型合并，这里我写了一个用于合并的代码

# 导入PEFT库中的AutoPeftModelForCausalLM类，用于加载和合并模型
from peft import AutoPeftModelForCausalLM

# 设置adapter模型的路径
path_to_adapter = "/openbayes/home/20250121-Qwen/Qwen-main/output_qwen/checkpoint-1000"
# 设置合并后模型的保存路径
new_model_path = "/openbayes/home/20250121-Qwen/Qwen-main/law_model-chat" # load model

# 加载adapter模型，设置device_map为auto自动分配设备，允许使用远程代码，并设置为评估模式
model = AutoPeftModelForCausalLM.from_pretrained(path_to_adapter, device_map="auto",trust_remote_code=True).eval()
# 合并adapter和基础模型
merged_model = model.merge_and_unload()

# 保存合并后的模型，设置最大分片大小为2048MB，使用安全序列化
merged_model.save_pretrained(new_model_path,max_shard_size="2048MB",safe_serialization=True)

# 保存分词器
# 导入AutoTokenizer用于处理分词
from transformers import AutoTokenizer
# 从adapter模型路径加载分词器，允许使用远程代码
tokenizer = AutoTokenizer.from_pretrained(path_to_adapter,trust_remote_code=True)
# 将分词器保存到新模型路径
tokenizer.save_pretrained(new_model_path)

创建merge_model.py,运行代码 9. 然后修改推理模型进行推理还是和之前一样，运行python web_demo.py

在这个过程中我遇到了一个问题，发现是transformers-stream-generator库的问题，在微调的时候我安装的这个库和推理的时候这个库不一致

深度学习 on 扎塔-Zata

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

两个名字，和一整套立场

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

接口只有三种问法

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

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

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

四种设计模式

社区已经拿它做了什么

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

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

社区测出来的三种偏差

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

别人是怎么写 Jev 的

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

几点收获

Alignment-DPOvsPPOvsGRPO

GRPO

1. 核心概念：什么是 GRPO？

2. GRPO 的工作原理（算法流程）

3. GRPO vs. PPO：关键区别

4. GRPO 的核心优势

5. 总结

一、 PPO (Proximal Policy Optimization)

1. 核心原理

2. 训练时的“四个模型”

3. 优缺点

二、 DPO (Direct Preference Optimization)

1. 核心原理

2. 训练流程

3. 优缺点

三、 PPO vs. DPO 核心对比表

四、 为什么现在开源界主要用 DPO？

五、 总结建议

JAX

JAX 详细介绍

历史背景

核心特性

与 NumPy 和 TensorFlow 的比较

安装指南

基本使用示例

生态系统与应用

总结

mechine_learning_models

random_forest

vllm

1. 什么是 vLLM？

2. 🔧 安装

3. 🚀 核心用法一：使用 Python API (离线推理)

4. 🚀 核心用法二：部署 OpenAI 兼容 API 服务器

第 1 步：启动服务器

第 2 步：查询服务器 (使用 Python)

5. 📚 关键概念：SamplingParams

6. 🔗 官方资源

openbayes算力平台使用教程

基础知识

vllm使用教程

常用命令

基本使用

什么是 vLLM？

1. 安装 vLLM

2. 基本离线推理 (Python API)

3. 启动 OpenAI 兼容的 API 服务器

4. 常用参数说明

5. 进阶特性 (简介)

6. 常见用例

7. 更多资源

实战

vllm部署 Qwen3 ：使用4090 （成功）

vllm部署 Qwen3 ：使用v100_32 （失败）

增量学习研究综述：理论、方法、应用与未来展望

增量学习研究综述：理论、方法、应用与未来展望

前言

1. 增量学习的基础

1.1. 增量学习（IL）、持续学习（CL）与终身学习（LLL）的定义

1.2. 核心原理：稳定性-可塑性困境

1.3. 中心挑战：灾难性遗忘（CF）

2. 增量学习的方法论

2.1. 基于回放的策略（Exemplar and Generative）

四、为什么现在开源界主要用 DPO？

五、总结建议

5. 📚 关键概念：`SamplingParams`