![MaxForAI's tweet photo. 中秋快乐！刚刚看到一篇新论文 Memory Attention，感觉可能是个划时代的新注意力架构，给大家分享一下。
MA这篇的核心是Transformer 里的 V，可能根本没必要每次都重新算。
所以直接开始动 Attention 里最经典的 QKV 结构了。
传统 Attention 里，每个 token 都要从当前 hidden state 重新计算：
Q = XWq
K = XWk
V = XWv
但本文作者 @Jo1uck 问了一个很朴素的问题：
V 里面有多少东西，真的需要每次根据上下文重新算？
同一个 token 在不同句子里，显然存在大量可以复用的信息。
于是他们参考 Engram 这类 Memory 架构，给每个 token 建了一套可学习的 memory，然后更激进地把独立的 value projection 直接干掉：
V = K + Memory[token]
K 负责保留上下文信息，Memory 负责保存 token 自身可以复用的信息。
这样推理时，原来计算 V 的一次矩阵乘法，基本就变成了：查表 + 加法（这会大幅减少计算量）。
然后事情开始变得有意思了。
因为 Memory 只跟 token ID 和层数有关，所以甚至可以提前知道要读哪块数据，直接把这部分参数扔到 CPU，GPU 需要的时候提前 Prefetch。
实验里，MA-Offload 模型总参数是普通模型的 2.08 倍，但 GPU 上实际常驻的参数反而比普通 Transformer 少了 7.38%，推理延迟基本维持在同一水平。
训练上，在两个不同规模实验里，达到相同 loss 所需 token 数分别提升到了 1.42× 和 1.16× 的 token efficiency，也就是大约少用 29.6% 和 13.8% 的训练 token。
下游平均成绩也基本都比对应的 Standard Attention 更高。
更骚的是，作者还提出了一个 MA-Recall：
既然历史 V 可以通过 K + token memory 重新构造，那么理论上甚至不用一直保存完整的 V Cache，只保存 K 和 token ID，在需要的时候把 V 重建出来。
按论文的理论计算，这部分 KV Cache 可以砍掉接近一半，不过目前还只是分析，没有进入实际推理实验。
我觉得这篇的方向挺值得关注的。
过去大家做 Memory，更多是在 Transformer 外面继续加东西。
Memory Attention 开始反过来问：既然 Memory 已经能记住这些东西，那 Transformer 里面原来那些计算，是不是可以直接删掉？
当然论文自己写的也很克制：MA 用了更多参数，所以目前的收益还不能证明全部来自架构本身，而不是单纯的参数量增加。
但如果这条路继续成立，下一代模型的变化可能不只是 Attention 越做越复杂。
也可能是我们用了快十年的 QKV，终于开始有人认真考虑：哪些东西其实根本不用算。](https://pbs.twimg.com/media/HTCtu5vaAAA5iJp.jpg)
![MaxForAI's tweet photo. 中秋快乐！刚刚看到一篇新论文 Memory Attention，感觉可能是个划时代的新注意力架构，给大家分享一下。
MA这篇的核心是Transformer 里的 V，可能根本没必要每次都重新算。
所以直接开始动 Attention 里最经典的 QKV 结构了。
传统 Attention 里，每个 token 都要从当前 hidden state 重新计算：
Q = XWq
K = XWk
V = XWv
但本文作者 @Jo1uck 问了一个很朴素的问题：
V 里面有多少东西，真的需要每次根据上下文重新算？
同一个 token 在不同句子里，显然存在大量可以复用的信息。
于是他们参考 Engram 这类 Memory 架构，给每个 token 建了一套可学习的 memory，然后更激进地把独立的 value projection 直接干掉：
V = K + Memory[token]
K 负责保留上下文信息，Memory 负责保存 token 自身可以复用的信息。
这样推理时，原来计算 V 的一次矩阵乘法，基本就变成了：查表 + 加法（这会大幅减少计算量）。
然后事情开始变得有意思了。
因为 Memory 只跟 token ID 和层数有关，所以甚至可以提前知道要读哪块数据，直接把这部分参数扔到 CPU，GPU 需要的时候提前 Prefetch。
实验里，MA-Offload 模型总参数是普通模型的 2.08 倍，但 GPU 上实际常驻的参数反而比普通 Transformer 少了 7.38%，推理延迟基本维持在同一水平。
训练上，在两个不同规模实验里，达到相同 loss 所需 token 数分别提升到了 1.42× 和 1.16× 的 token efficiency，也就是大约少用 29.6% 和 13.8% 的训练 token。
下游平均成绩也基本都比对应的 Standard Attention 更高。
更骚的是，作者还提出了一个 MA-Recall：
既然历史 V 可以通过 K + token memory 重新构造，那么理论上甚至不用一直保存完整的 V Cache，只保存 K 和 token ID，在需要的时候把 V 重建出来。
按论文的理论计算，这部分 KV Cache 可以砍掉接近一半，不过目前还只是分析，没有进入实际推理实验。
我觉得这篇的方向挺值得关注的。
过去大家做 Memory，更多是在 Transformer 外面继续加东西。
Memory Attention 开始反过来问：既然 Memory 已经能记住这些东西，那 Transformer 里面原来那些计算，是不是可以直接删掉？
当然论文自己写的也很克制：MA 用了更多参数，所以目前的收益还不能证明全部来自架构本身，而不是单纯的参数量增加。
但如果这条路继续成立，下一代模型的变化可能不只是 Attention 越做越复杂。
也可能是我们用了快十年的 QKV，终于开始有人认真考虑：哪些东西其实根本不用算。](https://pbs.twimg.com/media/HTCtrUsaYAAGLiF.png)
Olivia
Online
chino
@ChinoLai
Joined August 2011
180 Following
11 Followers
3.6K Posts
A good technical LLM interview question:
You replace a dense feed-forward layer with a top-2 MoE.
The profiler confirms that the MoE executes fewer FLOPs per token.
However, end-to-end inference latency has increased instead of decreasing.
Why did this happen?
(answer below)
A standard Transformer applies the same feed-forward network to every token in a layer.
An MoE layer replaces that network with multiple experts. Each expert is a feed-forward network with its own weights.
A router reads each token's hidden-state vector, scores the available experts, and selects the top two. It also produces a routing weight for each selection.
Only those selected experts process the token. The model therefore contains many expert weights while executing only a small subset for each token.
The serving system must move activations when the selected experts are stored on different GPUs.
The visual follows a batch that begins on GPU 0.
The router returns two expert IDs and two routing weights per token. One selected path is shown for each example token to keep the diagram readable.
Token T1 selects E1 on GPU 0. Its activation remains in local GPU memory, where E1 processes it.
T2 selects E4 on GPU 1 in the same server. GPU 0 transfers the activation through NVLink, a high-bandwidth GPU-to-GPU connection. NVSwitch connects several GPUs through this fabric.
T3 selects E7 on GPU 2 in another server. Its activation crosses the cluster network through InfiniBand or Ethernet.
To be clear, the system transfers activation vectors, which are the numerical representations produced for a token by the preceding Transformer operations.
Each destination GPU runs its expert and returns the output to GPU 0.
GPU 0 multiplies both selected expert outputs by their routing weights, adds them together, and restores the original token order.
Different tokens can select different expert pairs. Across a batch, those assignments may involve every GPU storing experts.
Each GPU may therefore send activations to several GPUs while receiving activations for its own experts. This exchange is called all-to-all communication.
And there are several ways to optimize this.
For instance, keeping frequently selected experts within the same server reduces remote traffic.
Balanced routing prevents one GPU from delaying the layer.
Communication overlap allows local expert computation to continue while remote activations move.
In this setup, sparse routing reduces expert FLOPs, but token dispatch and network communication erase part of that saving.
If you want to dive deeper, I recently covered MoE inference engineering, including routing, expert placement, token dispatch, load balancing, communication overlap, memory, quantization, and offloading.
Read my article below.
其实，英伟达也是 RISC-V 架构的重度使用者
它的每块 GPU 内部通常包含 10 到 40 个 RISC-V 核心
英伟达在转向 RISC-V 之前
长期使用自研的 32 位专有架构 Falcon（快速逻辑控制器）
该架构最早于 2005 年左右随 G98 这一代产品首次亮相
截止2016十年间使用的 Falcon 核心总数约 30 亿个
但Falcon 为 32 位核心，缺乏 64 位寻址空间
既没有数据缓存，也无法运行真正的操作系统
英伟达从 2016 年起逐步将其替换为更具扩展性和标准化的 RISC-V 架构
（当时的备选方案包括 ARM 的 A 系列和 R 系列核心，以及 Synopsys 的 ARC、MIPS 和 Cadence 的相关技术，也曾评估过加州大学伯克利分校开发的参考核心 Rocket）
https://t.co/4tJQ4cWtXm
New M6/A20 ANE can autodetect sparsity (zeros) in weights AND activations + Winograd Sparsity for vision:
Measured on a 256-layer conv512 FP8 chain:
Dense: 56 -60 TFLOPS
75% zero activations (3:1): 71.8 TFLOPS
75% zero weights: 91 TFLOPS
joint ~50% act + 75% weight: 96 TFLOPS
Activation gains flatten near ~72 past ~75% zeros.
No sparse pack format, zeros in the tensor are enough.
Test code:
https://t.co/MQqjzN8mHM
Sam Altman, CEO de OpenAI:
"Ya no hace falta escribir prompts."
En 38 minutos explica cómo usar ChatGPT a un nivel que la mayoría ni se imagina.
Es una charla que dio a estudiantes de Stanford. Un amigo me pasó la grabación anoche.
Cuando terminé de verla me di cuenta de que solo le estaba sacando como un 15% de lo que puede hacer.
Apple Silicon M5
has been uploaded into https://t.co/nnZ0Fxg4hW
Nomura shared the main difference between scale-up / scale-across / scale-out. Felt it was easy to understand and visualize.
NVIDIA and Stanford just challenged Jev.
(their new System 1 architecture runs up to 9x faster.)
It is called a Contrastive Language Model, or CLM.
Like Jev, CLM is not designed to generate text. It handles the small, repeated decisions inside AI systems, such as choosing a tool, ranking a patch, routing a request, or selecting the next action.
But CLM reaches those decisions differently.
Instead of generating an answer token by token, it treats decision-making as a retrieval problem.
Here is how it works.
1) Encode the state
CLM takes the current situation, such as an agent’s context or the state of a game, and converts it into a vector.
It uses a frozen Qwen3-8B model with a small trainable state projection head.
2) Encode every possible action
A separate action head converts each candidate into the same vector space.
In the Mario example, the candidates are left, jump, and right run. CLM does not invent a fourth option. It only evaluates the actions supplied by the application.
3) Learn which states and actions belong together
During training, the correct state-action pair is pulled closer while incorrect pairs are pushed apart.
A batch of B examples produces a B × B similarity matrix. The matching pairs sit on the diagonal. Every other pairing becomes a negative example.
This contrastive training uses InfoNCE, the same general mechanism behind systems such as CLIP and dense retrieval.
4) Turn similarity into a decision
At inference, CLM measures the cosine similarity between the state and every candidate action.
A softmax converts those scores into a probability distribution. The application can choose the winner, apply a confidence threshold, or escalate an uncertain result.
The real speed advantage comes from separating states and actions.
Actions can be embedded once and cached. If an agent repeatedly chooses between the same tools, CLM only needs to encode the changing state and compare it with stored action vectors.
That replaces repeated generation with one embedding pass and a set of cheap dot products.
The researchers report that CLM-8B matches Jev across computer-use, gaming, and tool-calling evaluations while reaching up to 9x lower latency. The improvement is largest when actions repeat or the candidate set grows.
CLM still has limits. It cannot generate new actions, its probabilities are relative to the supplied candidates, and its strongest verifier results require task-specific fine-tuning.
But its central idea is powerful.
The entire research is open-source, including the code.
Read more here: https://t.co/I9kPwMPI7B
When software already knows the possible answers, an AI model should score them instead of generating more words.
I also wrote a full breakdown on how system one models like Jev work.
The article is quoted below.
中秋快乐！刚刚看到一篇新论文 Memory Attention，感觉可能是个划时代的新注意力架构，给大家分享一下。
MA这篇的核心是Transformer 里的 V，可能根本没必要每次都重新算。
所以直接开始动 Attention 里最经典的 QKV 结构了。
传统 Attention 里，每个 token 都要从当前 hidden state 重新计算：
Q = XWq
K = XWk
V = XWv
但本文作者 @Jo1uck 问了一个很朴素的问题：
V 里面有多少东西，真的需要每次根据上下文重新算？
同一个 token 在不同句子里，显然存在大量可以复用的信息。
于是他们参考 Engram 这类 Memory 架构，给每个 token 建了一套可学习的 memory，然后更激进地把独立的 value projection 直接干掉：
V = K + Memory[token]
K 负责保留上下文信息，Memory 负责保存 token 自身可以复用的信息。
这样推理时，原来计算 V 的一次矩阵乘法，基本就变成了：查表 + 加法（这会大幅减少计算量）。
然后事情开始变得有意思了。
因为 Memory 只跟 token ID 和层数有关，所以甚至可以提前知道要读哪块数据，直接把这部分参数扔到 CPU，GPU 需要的时候提前 Prefetch。
实验里，MA-Offload 模型总参数是普通模型的 2.08 倍，但 GPU 上实际常驻的参数反而比普通 Transformer 少了 7.38%，推理延迟基本维持在同一水平。
训练上，在两个不同规模实验里，达到相同 loss 所需 token 数分别提升到了 1.42× 和 1.16× 的 token efficiency，也就是大约少用 29.6% 和 13.8% 的训练 token。
下游平均成绩也基本都比对应的 Standard Attention 更高。
更骚的是，作者还提出了一个 MA-Recall：
既然历史 V 可以通过 K + token memory 重新构造，那么理论上甚至不用一直保存完整的 V Cache，只保存 K 和 token ID，在需要的时候把 V 重建出来。
按论文的理论计算，这部分 KV Cache 可以砍掉接近一半，不过目前还只是分析，没有进入实际推理实验。
我觉得这篇的方向挺值得关注的。
过去大家做 Memory，更多是在 Transformer 外面继续加东西。
Memory Attention 开始反过来问：既然 Memory 已经能记住这些东西，那 Transformer 里面原来那些计算，是不是可以直接删掉？
当然论文自己写的也很克制：MA 用了更多参数，所以目前的收益还不能证明全部来自架构本身，而不是单纯的参数量增加。
但如果这条路继续成立，下一代模型的变化可能不只是 Attention 越做越复杂。
也可能是我们用了快十年的 QKV，终于开始有人认真考虑：哪些东西其实根本不用算。
![MaxForAI's tweet photo. 中秋快乐！刚刚看到一篇新论文 Memory Attention，感觉可能是个划时代的新注意力架构，给大家分享一下。
MA这篇的核心是Transformer 里的 V，可能根本没必要每次都重新算。
所以直接开始动 Attention 里最经典的 QKV 结构了。
传统 Attention 里，每个 token 都要从当前 hidden state 重新计算：
Q = XWq
K = XWk
V = XWv
但本文作者 @Jo1uck 问了一个很朴素的问题：
V 里面有多少东西，真的需要每次根据上下文重新算？
同一个 token 在不同句子里，显然存在大量可以复用的信息。
于是他们参考 Engram 这类 Memory 架构，给每个 token 建了一套可学习的 memory，然后更激进地把独立的 value projection 直接干掉：
V = K + Memory[token]
K 负责保留上下文信息，Memory 负责保存 token 自身可以复用的信息。
这样推理时，原来计算 V 的一次矩阵乘法，基本就变成了：查表 + 加法（这会大幅减少计算量）。
然后事情开始变得有意思了。
因为 Memory 只跟 token ID 和层数有关，所以甚至可以提前知道要读哪块数据，直接把这部分参数扔到 CPU，GPU 需要的时候提前 Prefetch。
实验里，MA-Offload 模型总参数是普通模型的 2.08 倍，但 GPU 上实际常驻的参数反而比普通 Transformer 少了 7.38%，推理延迟基本维持在同一水平。
训练上，在两个不同规模实验里，达到相同 loss 所需 token 数分别提升到了 1.42× 和 1.16× 的 token efficiency，也就是大约少用 29.6% 和 13.8% 的训练 token。
下游平均成绩也基本都比对应的 Standard Attention 更高。
更骚的是，作者还提出了一个 MA-Recall：
既然历史 V 可以通过 K + token memory 重新构造，那么理论上甚至不用一直保存完整的 V Cache，只保存 K 和 token ID，在需要的时候把 V 重建出来。
按论文的理论计算，这部分 KV Cache 可以砍掉接近一半，不过目前还只是分析，没有进入实际推理实验。
我觉得这篇的方向挺值得关注的。
过去大家做 Memory，更多是在 Transformer 外面继续加东西。
Memory Attention 开始反过来问：既然 Memory 已经能记住这些东西，那 Transformer 里面原来那些计算，是不是可以直接删掉？
当然论文自己写的也很克制：MA 用了更多参数，所以目前的收益还不能证明全部来自架构本身，而不是单纯的参数量增加。
但如果这条路继续成立，下一代模型的变化可能不只是 Attention 越做越复杂。
也可能是我们用了快十年的 QKV，终于开始有人认真考虑：哪些东西其实根本不用算。](https://pbs.twimg.com/media/HTCtyIdaAAA7Bhv.jpg)
Coding 正在被模型快速解决，研发提效的主战场已从「让 AI 更会写代码」迁移到环境与验证，把「只有人会操作」的内部系统、知识、发布链路，翻译成 Agent 可调用、可验证、可追责的基础设施。
from 阿里巴巴《AI Native 研发范式实践手册》
Google lanzó la herramienta que todo desarrollador pedía desde hace años.
Se llama CodeWiki.
Pegas cualquier repositorio y la IA lo convierte automáticamente en una documentación interactiva.
No solo resume el código:
• Genera diagramas automáticamente
• Explica cómo funciona cada parte
• Crea tutoriales paso a paso
• Detecta arquitectura y dependencias
• Y hasta monta un chatbot que entiende tu código completo
Básicamente:
convierte proyectos imposibles de entender en algo que cualquier desarrollador puede navegar en minutos.
Enlace abajo👇
阿里把团队内部用了两年的官方 AI Code Review Skills 开源了，采用 “确定性工程 pipeline + AI Agent” 的混合架构，专门解决通用 Agent 做代码审查时 “漏审、定位漂移、质量不稳” 的老问题。
40.5K ✨ 开源项目 OpenCodeReview：
https://t.co/tKXXsQp19U
# 核心设计：确定性工程 pipeline × Agent 各司其职
确定性工程负责硬约束：
· 精确文件选择：用代码决定哪些文件必须审、哪些要过滤，不依赖模型自觉；
· 智能文件捆绑：把相关文件合成一个审查单元（例如 message_en.properties 和 message_zh.properties 捆绑），每个单元以上下文隔离的 sub-agent 运行，分治策略让超大变更集也稳，且天然支持并发（默认 8 个文件 worker）；
· 细粒度规则匹配：内置约 54 个按语言/文件类型的规则文档（Java、Go、TS/JS、Python、Rust、SQL/XML mapper、properties 等），用模板引擎而非自然语言把规则匹配到文件特征上，从源头消除信息噪声；
· 外部定位与反思模块：评论的“落点”和“内容”分别由独立的 re-location 和 reflection 模块系统性校正，这正对“位置漂移”痛点。
Agent 负责动态决策：
· 深度优化的场景 prompt（内部分为 plan → grouping → main → memory_compression → re_location → review_filter 多个任务模板，可在 internal/config/template/prompts/ 看到）；
· 从海量生产环境的 tool-call 轨迹（调用频率分布、单工具重复率、新工具对调用链的影响）反向蒸馏出的专用工具集，包括全文件读取、代码搜索、其他变更文件查阅等，比通用 agent 工具箱更小更稳。
# 能力面与生态集成
功能上覆盖：workspace/分支区间/单 commit 审查、断点恢复（ocr session）、全文件 scan（无 git 历史也能审计陌生代码库）、本地 Session Viewer 网页查看与回放、SARIF/JSON 输出、OpenTelemetry 可观测性、MCP Server 扩展。
作为 “Skills 生态” 级项目，它的形态相当完整：既提供 npm 全局 CLI，也提供可移植的 Agent Skill（skills/open-code-review/SKILL.md，带标准 frontmatter，可直接被兼容 skill 的 agent 加载），还有面向 Claude Code、Codex、Cursor、Kimi Code、OpenCode 等平台的插件，每种都封装成斜杠命令或可调用 skill。LLM 侧兼容 OpenAI、Anthropic、AWS Bedrock 三类协议，并可直接复用 Claude Code 的 ANTHROPIC_* 环境变量。
其中一个设计很巧妙：Delegation 模式（ocr delegate preview/rule）。此时 OCR 只做自己擅长的确定性部分（文件选择和规则解析）审查本身交给宿主 coding agent 的 LLM 执行，用户无需给 OCR 配任何 API key。这实际上是把“harness 能力”与“模型能力”彻底解耦。
# 工程质量：超出平均水准的部分
· 安全有正式的 Assurance Case（ASSURANCE_CASE.md）：完整的威胁模型、四条信任边界、T1–T7 威胁逐条给出缓解措施，并按 Saltzer & Schroeder 设计原则和 OWASP Top 10 做了映射。细节经得起推敲：所有外部进程调用只限 git 且子命令硬编码、--end-of-options 防 flag 注入；Agent 读文件路径经 pathutil.WithinBase() 在符号链接解析前后双重校验；本地 Viewer 有 Host 白名单防 DNS rebinding + 严格 CSP。这类文档在一般开源项目里非常罕见。
· 贡献规范近乎严苛（AGENTS.md）：使用 AI 必须在 issue/PR 中披露工具与模型、必须逐行理解 AI 生成的代码、禁止“AI 生成→反复修复→再修复”的循环、禁止把 commit 署名给 AI。源码强制英文（CI 有 english-check，连全角标点都查）、90% 测试覆盖率门槛、-race 与 govulncheck 每次 push 都跑、SPDX 头与 LF 行尾强制。
# Benchmark：数据情况
官方基准 AACR-Bench（已在 Hugging Face 开放）规模不小：50 个流行开源仓库、200 个真实 PR、10 种语言、80+ 资深工程师交叉验证出 1505 条标注问题。结论是同模型对比 Claude Code：Precision 和 F1 显著更高、token 消耗约为 1/9、速度更快。
需要指出两点：其一，Recall 低于通用 agent，README 自己承认这是“以精度换噪声”的刻意权衡，如果你最怕漏问题而非误报，可能不适合；其二，该基准由阿里自建，虽开放了数据集供社区复核，但独立第三方的复现结论目前还少，可以把它当作“有披露的、方向可信的参考”。
Djev-Spark (GitHub) figured out how to make DiffusionGemma 26B-A4B behave like Jev. They pre-built structures answer, leaving only the decision slots open, then read the model’s probabilities instead of generating JSON token by token
This runs locally with NVFP4 w/a patched vLLM structured-read engine and exposes a Jev-compatible endpoint.
Runs in GB10 only for now. DiffusionGemma is FAST!
🔥速码！谷歌官号亲自下场了！用 DiffusionGemma 开出一条兼容 Jev 的决策 API，一条命令就能挂上 Cloud Run。不用自备 Blackwell，闲置 $0，忙起来大约 $3/小时！
核心亮点
🔹官方 Gemma 号确认：DiffusionGemma-Jev（djev）可一键部署成 Jev 兼容端点
🔹单步延迟约 35–60ms，batch@32 约 100–123 req/s
🔹接口对标 TypeSafe 的 /v1/systemone：给 state + Choice/Score/Noul，直接回概率，不写长文
🔹底层是开源 DiffusionGemma 结构化读（seeded canvas + logprobs），不是闭源 Jev 权重
🔹按需扩缩：有请求才起 GPU，停下来不计费
关键操作
1️⃣准备 GCP 项目、开通 Cloud Run GPU（RTX PRO 6000 区域：us-central1 等）
2️⃣把量化权重传到 GCS（如 nvidia/diffusiongemma-26B-A4B-it-NVFP4）
3️⃣一条 gcloud beta run deploy：挂预构建镜像 https://t.co/KS1FHjX4Ll，挂 GCS 卷，GPU=1，min-instances=0
4️⃣用 Jev 同款 JSON 打 POST /v1/systemone 验证
5️⃣闲置自动缩到 0，只为真实流量付费
仓库：https://t.co/thQL1NCKYD
#Jev #djev #DiffusionGemma #Gemma #CloudRun #SystemOne #Agent #开源AI
DiffusionGemma-Jev now runs on vLLM 🚀
Ask yes/no, multiple-choice, or scored questions and get confidence with every answer. vLLM seeds a canvas with the response template, leaves only the answer slots noisy, then reads a probability distribution from every slot in a single denoising step.
Huge thanks to @mmastrac for driving this upstream! 🙏
https://t.co/HJJz0Q2KYe
At long last, the interactive DeepSeek-v4.1-Flash diagram is up ~
https://t.co/mkSKNtOdar
A book a day keeps the semiconductor grifters away
SGLang × Qwen × NVIDIA 三方合作：用 NVFP4 KV Cache 突破长上下文与 Agentic 推理瓶颈
长上下文和 Agentic 场景下，KV Cache 是推理系统最大的内存压力源：既要存得下，又要读得快。业界已有两条互补路线：分层缓存和 KV 量化。FP8 KV 已把占用相对 BF16 砍半，但再往下压到 4-bit，量化误差会显著放大，一直是难点。这篇博客的核心贡献是：把 NVIDIA 在 Blackwell 上推出的 NVFP4 格式落地到 SGLang 的 KV Cache 中，在 4-bit 精度下同时保住了精度和性能。
https://t.co/kbXzPTcb7o
# NVFP4 格式：两级缩放是关键
朴素 4-bit 量化的痛点是动态范围太窄。NVFP4 的解法是 两级缩放：
· 数值本身用 4-bit E2M1（1 符号 + 2 指数 + 1 尾数）；
· 每 16 个值一个块，配一个 FP8 (E4M3) 的块级缩放；
· 整个张量再配一个 FP32 全局缩放。
存储账很直观：16 个值打包占 8 字节，加上 1 字节块缩放，共 9 字节；而 FP8 同样 16 个值要 16 字节。即 9/16 ≈ 56.25% 的 FP8 占用，理想容量比约 1.78×。注意这不是 4-bit 理论上的 2×，那 1 字节的块缩放就是为精度付出的"税"，这笔账算得很诚实。
# SGLang 实现：三条注意力路径
实现接入了 SGLang 的分页 KV Cache，按阶段分三条路径，设计上很讲究：
1. 初始 prefill：注意力直接用 BF16 Q × FP8 K/V 计算（不牺牲算力），同时把 KV 从 FP8 量化成 NVFP4 写入持久缓存。此阶段不读缓存，所以没有反量化开销。
2. 分块 prefill / extend：把缓存的前缀 gather 出来，反量化到一个跨层共享的 FP8 workspace，与当前块的 KV 拼在一起做 FP8 注意力；算完再把本块量化进 NVFP4 缓存。共享 workspace 是为了控制额外显存开销。
3. Decode：这是最关键的一环。Decode 是访存受限的，如果先反量化再计算，就多了一次完整的显存往返。因此 kernel 直接读 NVFP4，在 kernel 内部即时反量化到 FP8/BF16：打包的 K/V tile 和 E4M3 块缩放进 shared memory，用 cvt.rn.bf16x2.e2m1x2 指令在寄存器里成对转换，全局缩放则通过 BMM 的 scaling 参数传入。计算全程 BF16。
这套设计的核心思想可以概括为：prefill 阶段可以容忍一次量化的额外写入（因为是计算受限），decode 阶段则必须做到读多少算多少（因为是访存受限）。
# 精度：基本无感，但有一个值得注意的缺口
两组模型都配合 FP8 权重测试（--kv-cache-dtype nvfp4）：
· Qwen3.5-397B-A17B（大模型）：几乎无差异。GSM8K 只少对 1 题（约 0.08 pp），GPQA-Diamond 和 AIME 2025 的合计正确数与 FP8 完全一致。
· Qwen3.8-27B（小模型）：出现任务相关的退化。GSM8K −0.31 pp、GPQA −1.01 pp、AIME 持平（98.33%）；最大的缺口在 SWE-bench Verified：76.20% vs 77.80%（−1.60 pp）。
团队的表述很克制且专业：两个模型、几个任务不足以建立"模型规模 vs 量化容忍度"的规律，任务级验证不可省略。尤其 SWE-bench 这类多轮、长轨迹的 agent 任务对 KV 误差更敏感，这个 −1.6 pp 是全文最值得使用者警惕的数字。
还有一个重要的说明：实验中 FP32 全局缩放被直接设为 1.0（未做校准）。也就是说，NVFP4 的两级缩放只用了其中一级。作者认为合理的校准（用满全局缩放）有可能缩小与 FP8 的差距，这意味着当前精度结果其实是 NVFP4 的"下界"，还有免费的提升空间。
# 性能：收益随上下文长度放大
测试在单张 RTX PRO 6000 Blackwell 上，Qwen3.8-27B，固定输入 32K / 160K / 1M token、各输出 1K，关闭 radix cache。
等并发对比（两种格式驻留相同的 decode 请求数：44/10/1）：NVFP4 的峰值 decode 吞吐提升 约 26–30%。这纯粹来自 KV 读取量减少，是最"干净"的收益。
等容量对比（同样的显存，尽量塞满）：可驻留并发从 44→70、10→15、1→2；峰值 decode 吞吐分别提升 37.37% / 57.75% / 78.46%。规律非常清晰：上下文越长，收益越大。1M 上下文时提升近 80%，因为此时 KV Cache 几乎独占显存，压缩它等于直接扩大 batch。
Prefill（TTFT）：等并发下 TTFT 仅增加 0.20–0.40%（量化/反量化的固定税，几乎可忽略）；容量驱动负载下 TTFT 反而下降 0.74–10.72%，但作者明确指出这主要来自排队效应（更多请求能驻留），不是 prefill 算得更快。这个归因分析避免了常见的误导性宣传。
文中也有诚实提醒：decode 提升不等于端到端提速。prompt 很长时 prefill 仍占主导，收益会被稀释。
# Agentic 负载：真正的杀手级场景
在 AgentX 基准上（8× RTX 6000D，Qwen3.5-397B-A17B，TP8，并发 1–16 扫描），结果呈现明显的分水岭：
· 并发 ≤ 8 时，NVFP4 与 FP8 相当；
· 并发 > 12 后，FP8 的吞吐和交互性急剧恶化，而 NVFP4 吞吐持续上升。
背后的机制比数字本身更有洞察：agent 会话有大量可复用的共享前缀（系统提示、工具定义、历史轨迹）。显存更省意味着 radix tree 能保留更多前缀，缓存命中率远高于 FP8（Fig 11），从而避免昂贵的前缀重算。也就是说，NVFP4 在 agent 场景的收益是双重叠加的：既减少了 KV 读取量，又通过更高的缓存命中率减少了 prefill 重复计算。对正在大规模部署 agent 的团队来说，这是全文最有实用价值的结论。
🚀New blog: Accelerating Long-Context and Agentic Inference with NVFP4 KV Cache
4-bit KV cache is here! NVFP4 KV in SGLang packs ~1.78× more context into GPU memory and speeds up long-context decode by up to 78%.
Together with @Alibaba_Qwen and @nvidia, we brought NVFP4 KV cache to Blackwell:
- NVFP4 stores KV in just ~56% of FP8's footprint per token
-️ Decode throughput jumps +37% / +58% / +78% at 32K / 160K / 1M context
- Near-lossless accuracy: matches FP8 on GPQA-Diamond & AIME 2025 (Qwen3.5-397B-A17B)
- Higher cache hit rate keeps AgentX throughput scaling where FP8 drops off
The whole recipe combines NVFP4 two-level scaling, in-kernel dequantization on decode, and paged KV cache, and you can enable it in SGLang with a single flag --kv-cache-dtype nvfp4
Computation and Data Movement for Inference
Mapping MoE models onto inference hardware: structure, flow, and efficient serving
https://t.co/3HCjoVu1r4
牛逼！Jev 刚火没两天，已经有人搞了个开源的Jev🤣
@bespokelabsai 发布了一个开源版的Jev：Bespoke Nimble。
更离谱的是，整个项目是基于 Qwen3.5-9B ，只花了大约两天。
数据、模型权重、训练配方、推理代码全部公开，而且没有从 Jev 蒸馏，只拿 Jev 做评测参照。
最终方法是在 Qwen3.5-9B 上做了一次很轻量的 LoRA微调。
只用了2676 条训练数据，结果在他们自己的 324 条 held-out 测试集上拿到了90.12%，而原版的Jev是93.21%。
一个 9B 模型，已经做到距离 Jev 只差 3 个百分点。
但我觉得最值得看的不是这个分数，而是他们到底怎么训的。
核心方法叫 contrastive data curation。
简单说，他们会构造两个几乎完全一样的样本，只修改一个足以改变最终决策的关键事实，让正确答案发生翻转。
模型因此被迫学会一件事：
到底哪条证据，才真正应该改变决策。
这其实特别符合 Jev 这类模型的用途。
它本来就不是拿来陪你聊天的，而是塞进 Agent 和软件系统里，做路由、审核、打分、策略判断这些高频的小决策。
推理方式上Nimble 不生成 CoT，甚至不生成 JSON。
它直接读取候选答案 token 的 logits，再把它们转成概率，最后由程序拼成结构化输出。
能不生成一个 token，就不生成一个 token。
这也是 Jev 这类模型路线真正有价值的地方。
对于大量根本不需要长思考的决策，怎么让模型几乎不想，直接判断。
PS：我个人很反感这两天狂吹 Jev 的帖子....
Last Seen Users on Sotwe
Something went wrong.