habout632

[habout632 @tulin632]

last night when i type apache doris grammar (ie. lexer.g4, parser.g4) into apache doris as prompt, i found gpt4 can understand the grammar file apache doris sql syntax and generate a 100 lines sql based on some database schema super cool

[habout632 @tulin632]

@mtrainier2020 有点浪漫

[TechVerser @realfxw]

🚀 移动端 UI 自动化测试迎来重大进化：Maestro MCP 正式开源！

一直在关注移动端测试的朋友应该对 Maestro 不陌生——相比配置繁琐、执行不稳定的传统框架，Maestro 凭借简洁直观、人类可读的高层级语法以及出色的稳定性，早已成为移动端端到端测试的利器。而最新发布的 Maestro MCP（Model Context Protocol），则标志着 UI 测试正式步入 Agentic UI Testing（智能体自动化测试） 时代。

这次结合带来的质变体现在几个关键维度：

大模型直接操控真机与模拟器：基于 Anthropic 开源的 MCP 协议标准，AI Agent（如 Claude、Cursor 等）能够直接充当控制器，实时解析应用 UI 层级并自主调用 inputText、tapOn 等基础交互指令，端到端跑通复杂的业务流程。

从“人工排错”到“智能自愈”：传统 UI 自动化最令人头疼的就是因界面微调导致的脚本频繁崩溃。引入 Agent 运行时后，模型能够结合上下文意图理解动态定位元素，大幅降低日常回归用例的维护损耗。

自然语言直接落地测试流：团队只需用自然语言描述用户路径（例如“搜索食材并加入每日饮食清单”），智能体即可自主探索操作边界，自动验证反馈并沉淀出可维护的回归工程。

完全开源且深度契合现有工程流：延续了 Maestro 易于集成 CI/CD、提供强大 CLI 与桌面端工具的优势，让团队无需推翻现有基础设施即可体验下一代自动化能力。

大模型正在从“辅助编写脚本代码”演进为“自主交互与验证的闭环智能体”，UI 自动化的底层逻辑已被彻底重构。

各位移动端与 QA 开发者，你们看好 Agentic Testing 在复杂工业级项目中的落地表现吗？

#MobileDev #SoftwareTesting #OpenSource #AI #MCP #DevOps

[habout632 @tulin632]

@gkxspace 主要是美卡怎么搞定 美国手机号搞定了

[habout632 @tulin632]

@YChenLiu1 @gkxspace 我就遇到了kyc

[小码哥 @xmglab]

兄弟们，

我终于搞定了家庭宽带 IP！😅

几十块一年的家庭宽带 IP，性价比拉满了，可能是市面上性价比最高的了！！

这纯净度，这适合场景全解锁，没谁了吧？😎

保姆级教程我都写好了，趁还没涨价之前，有需要的，赶紧冲！！

[Jerry Fang @Jerry_fsy]

做AI Agent已经半年了，从最初的懵懂到现在可以交付生产级的Agent。在这个过程中，对Agent的理解逐渐加深。
现在回看，对Agent理解的一个转折点是在微信公众号上看了不少“三元同学”写的文章，逐渐对上下文等概念有了清晰的理解。后来，买了她在Sitor上面的课程，系统学习了Agent。在这些基础打牢后，现在吸收理解包括AI Inference，Agent评测这些知识就更容易了，也是体会一把知识的飞轮。
如果大家对AI Agent感兴趣，可以在公众号上关注“三元同学”，下面附一些我感觉不错的文章：
1.https://t.co/lyQvMMSkCO
2. https://t.co/mbDgtYDhMQ
3. https://t.co/UJDZD9VPdr

对AI感兴趣的朋友可以多交流交流。

[美研芒格君 @Kay2289123]

小米 MiMo-V2.6 把强化学习的方法和在线训练轨迹全公开了💥
https://t.co/Wquecqhne9

大模型业界团队 RL 到底怎么做、训练中途长什么样，这种一手材料比任何解读都管用。想往这个方向走的人，直接拿它当学习路线

我坚定相信，如果 AI 大模型是一块生日蛋糕，那么 pre-training 是做了蛋糕胚，微调和监督训练是在上面抹奶油，而RL的探索就是上面的那颗草莓和生日蜡烛，是整个蛋糕的灵魂

[habout632 @tulin632]

@alin_zone 主要是现在支付宝都是补货了 没了

[Bojie Li @bojie_li]

《深入理解 AI Infra》开源发布了！

写完《深入理解 AI Agent》后，在与读者交流的过程中，我越来越感到，要开发好基于模型的应用，还需要理解它赖以运行的基础设施。

最近几十年系统领域最重要的变化是编程抽象的上移：从操作系统到模型上下文。传统的操作系统、编译器和硬件要为事先未知的各种程序提供通用能力，系统优化总要在可编程性与性能之间取舍。

如今 LLM 成了最重要的应用，可以针对特定的模型和加速器架构优化；模型设计也开始反过来适应硬件，DeepSeek V4/V4.1 重新设计长上下文的表示方式，就是一例。

从某种意义上说，模型成了 LLM 时代的操作系统，AI Infra 成了 LLM 时代的计算机体系结构。《计算机体系结构：量化研究方法》是我在体系结构领域的入门书，而 AI Infra 领域还缺少一本从硬件约束和模型架构出发、量化推导系统设计的书，这是我写作本书的动机。

全书约 500 页，包括 12 章：
1. 初识 AI Infra
2. 模型架构
3. 推理与训练负载
4. 加速器架构
5. 算子与运行时
6. 超节点
7. 数据中心网络
8. 推理优化
9. 分布式推理
10. 训练系统
11. 资源调度与运行环境
12. 端边云协同

欢迎 star & 提 issue/PR！

https://t.co/R1DAPLMWVq

[Asa @app_sail]

@gkxspace 是时候祭出我的160w流量推文了，封禁了6个账号之后下血本全套美系装备，目前这个账号活了大半年了 https://t.co/2h7eRGki8H

[Asa @app_sail]

https://t.co/wRORCx6mY6

[Viv @Vtrivedy10]

this has been one of my fave series on data + code + infra for RL, from the HF team

previous 3 sessions are great watches

[Aravind Srinivas @AravSrinivas]

open-source RL-as-a-service https://t.co/UdKabiSfJP

[Brendan (can/do) @BrendanFoody]

Post-training is becoming more accessible by the day.

We're open-sourcing our post-training recipes and the end-to-end process.

Every enterprise will soon post-train its own models.

[tobi lutke @tobi]

@KaiserFrose We open sourced the system. https://t.co/4KvIoFtGE8

[Anirudha Majumdar @Majumdar_Ani]

🧑‍🏫 I am teaching an updated version of Intro to Robotics @Princeton this Fall! New this year: a revamped section on modern robot learning, along with the classics (planning, control, SLAM).

Video lectures will be posted here:
https://t.co/VVxtb7IXn7
Notes, slides, assignments, projects here:
https://t.co/zakz0McLAX

[小盖 @xiaogaifun]

强烈推荐大家读一读 Qwen3.8-Flash 的 Tech Report，真的非常精彩。

我读完之后最大的感受是，它没有发明什么惊天动地的新架构，更像是把过去一两年模型领域里出现的重要新技术，以恰当的方式重新组合到一起，而且取得了不错的效果。看这个论文的过程，有点像新技术大阅兵。

Qwen3.8-Flash 当初的目标很明确，就是尽可能保持甚至提升模型的智能水平，同时大幅降��训练和推理成本。

所以最后这个模型主干参数是 125B，每个 Token 只激活 6B，另外还有 51B 的 n-gram Embedding 参数。

和上一代的 Qwen3.7-Plus 相比，它只用了大约 1/3 的激活参数、1/3 的训练 Token，所以整体训练 FLOPs 只有大约 1/9。

Benchmark 的表现上，Qwen3.8-Flash 在其中 8 项超过上一代 Qwen3.7-Plus，剩下 6 项的最大差距也只有 2.6 分。所以，它的智能水平还是相当不错。

我们可以把 Qwen3.8-Flash 的改造理解成四次比较大的手术。它们分别在解决四个问题：

1、Attention 成本太高，尤其是长上下文下的计算开销。
2、模型层数深了以后，前面的重要信息容易被后面的信息冲淡。
3、增加参数往往也会增加计算成本。
4、训练过程还会出现不稳定，训练效率也还有提升空间。

第一刀先动 Attention。

传统的 Full Attention 机制有一个很明显的问题。当前 Token 在计算的时候，要回头看前面所有的 Token，所以一旦上下文变长，要算的东西就会越来越多，成本也会跟着迅速上升。

这两年，很多模型公司都在优化注意力机制。Qwen3.8-Flash 这次大量采用的是 GDN。

GDN 可以简单理解成一种可更新的记忆。模型不需要每次都重新查看前面所有 Token，而是不断把过去的信息压缩进一个固定大小的状态里。

这样上下文继续增长，保存和读取历史信息的成本不会像 Full Attention 那样快速增加。

但压缩记忆肯定没法完整保留所有细节，所以 Qwen 没有完全放弃 Full Attention。一开始的结构是三层 GDN 加一层 Full Attention，大部分时候依靠 GDN 保存和传递历史信息，隔几层再让模型直接查看完整上下文。

到了后续的长上下文继续预训练��段，Qwen 又把这些 Full Attention 层换成了 QSA，也就是 Qwen Sparse Attention。这样最终的结构就变成了三层 GDN 加一层 QSA。

Sparse Attention 的思路很好理解，没必要每次都查看全部历史内容，先找出最相关的一部分。

但这里还有一个问题。假如上下文已经有 100 万 Token，你光从这 100 万 Token 里找出哪些最重要，本身也可能很贵。

QSA 做的就是继续降低这一步的成本。它先把相邻 Token 压缩成一个个小 Block，让一个轻量的 Indexer 判断哪些 Block 最重要，然后只针对选中的内容计算 Attention。

效果非常明显。上下文达到 1M 时，QSA 的 Attention 模块在 Prefill 阶段提速 7.6 倍，Decode 阶段提速 4.9 倍。

第二刀是 Residual（残差）。

传统 Transformer 里，各层的信息都在同一条 Residual Stream 里不断累积。前面的层写入一些信息，后面的层继续往里面增加新的内容。

模型越来越深以后，早期的一些重要信息就会不断和后面的信息混在一起，越来越难保留下来。

Qwen3.8-Flash 的思路是一条通道不够，那就扩成四条。

于是有了 Gated Residual。模型同时维护四条 Residual Stream，每一层需要信息的时候，再通过 Gate 判断应该从不同通道里读取多少。

这样一些信息可以留在某条通道里，不需要一直和后面所有的新信息挤在一起。

更有意思的是，模型训练完以后，这四条通道真的出现了不同的分工。

论文分析了多个 Checkpoint，发现其中一条通道主要负责保存和传递更早的信息，另外三条更多负责附近几层之间的信息流动。

也就是说，这四条 Residual Stream 最后自己出现了分工，其中一条明显更负责长距离的信息传递。

第三刀是 n-gram Embedding。

这一刀解决的问题是，怎么给模型增加更多参数，又尽量不让计算量跟着一起增加。

Qwen 的办法，是在 Backbone 之外加一层 n-gram Embedding。n-gram 可以简单理解成连续几个 Token 组成的短片段。

模型会把当前 Token 前面的几个 Token 组合成短片段，当成一个索引，直接去一张很大的表里取���对应的向量，再补充到当前 Token 的表示中。

这和把参数继续堆进 Backbone 有很大区别。n-gram Embedding 每次只需要查表里很少的几个位置，不需要让这几十亿参数都参与计算。

所以表可以做得很大，每个 Token 增加的计算量却非常有限。Qwen3.8-Flash 最后在这里放了 51B 参数。

而且这 51B 参数可以放在 Host Memory，也就是服务器内存里，不需要一直占用 GPU 显存。

模型计算第一层的时候，就提前把第二层需要的数据读进来，所以 Qwen 最后把 n-gram Embedding 放在了第二层。

第四刀是训练。

除了改模型架构，Qwen 这次还重新调整了整个训练方案，其中一个重要变化是把 Muon 作为主要优化器。

Muon 是一种优化器，可以简单理解成训练模型时，决定参数每一步怎么更新的方法。Qwen 在实验中发现，Muon 加上前面的新架构以后，模型的训练稳定性明显提高。

即使把 Learning Rate 调到正常水平的数倍，训练依然比原来的 Qwen3.5 + AdamW 稳定很多。

稳定性提高以后，���来那套训练参数也未必还是最优的。

所以 Qwen 重新拟合了 Scaling Law，通过较小规模的实验去推算大模型更合适的 Learning Rate 和 Batch Size。结果发现，这两个值都可以往上调。

更大的 Learning Rate 可以加快收敛，更大的 Batch Size 则可以提高大规模训练时的并行效率。

他们还重新测试了 Batch Size Warmup。过去训练大模型时，经常会先用较小的 Batch Size，再慢慢增加。

Qwen 发现这样做最终效果并没有更好，同样的训练 Token 反而需要多跑 18.8% 的参数更新步骤，所以这次直接取消了。

我觉得这篇 Tech Report 最值得看的，确实就是 Qwen 怎么做这些技术取舍。

因为前面提到的 GDN、QSA、Gated Residual、n-gram Embedding、Muon，这些技术其实都不是第一次出现。

Qwen3.8-Flash 的参数规模也不算大，所以他们这次做的事情，很像是把过去一两年模型领域里出现的这些新技术，重���放到一个新的模型里头，然后一项一项去看效果。

模型 Scaling 越来越转向架构效率。或者说，架构、效率和��化本身就是一个耦合系统。因为一个技术到底好不好，不能只看 Training Loss。

技术报告里有很多这样的例子。有些改动对 Loss 的影响很小，但最后的 Benchmark 会明显变好。也有一些方案在预训练阶段看起来完全没问题，继续训练或者做完后训练以后，效果反而会变差。

就连 Batch Size Warmup 这种已经用了很多年的训练方法，他们重新验证以后也发现没有收益，反而多跑了 18.8% 的优化步骤。

所以现在做模型架构，已经很难只看某一个指标了。一个改动加进去以后，要同时看最终能力、训练成本、推理效率和训练稳定性，甚至还要看它会不会改变最合适的 Learning Rate 和 Batch Size。

记得报告最后提到，现在真正卡住他们的一个瓶颈，已经变成了 Evaluation Throughput。

他们最需要的是一种更便宜的中等规模实验，可以提前判断一个架构最后做完后训练以后到底行不行。这样才能更快地试更多方案，也更快地把真正有效的技术筛选出来。

这个思路还挺有意思。

Tech Report 见评论区。

[Avi Chawla @_avichawla]

Why KV cache stores K and V vectors but never Q?

(a popular technical LLM interview question)

LLMs are autoregressive so each token is predicted from every token before it, one at a time.

This autoregressive nature has a direct consequence inside the model.

A forward pass over <n> tokens produces <n> hidden states, but only the last one is projected to logits and is required to generate the next token.

So to understand why KV cache just stores K and V vector, we must back track to see how exactly is the last hidden state produced.

Let's walk through this with a 10-token prompt.

1) Prefill:

All 10 tokens go through the model in one forward pass, in parallel (with causal masking), since the whole prompt is already known.

At every layer, each of the 10 positions produces a query, a key and a value vector, and attention at each position runs against all positions up to it.

This pass is compute-heavy, and it's why the first token takes noticeably longer than the ones after it. TTFT is mostly prefill.

2) The first output token:

To generate the 11th token, only the 10th token's hidden state is needed. So this is projected from the hidden-dim to vocab-dim to generate logits over vocab.

These logits then go through softmax and sampling to generate token 11.

3) Back-track the hidden state:

The last hidden state is the last row of the feedforward block's output. The feedforward block is position-wise (it's applied to each row independently) so that row comes from the last row of the attention output before it.

So now we need to see how the last row of attention is computed.

4) Attention matrix:

QKᵀ for a 10-token prompt will give a 10 × 10 matrix.

Row <i> will have the dot product of query <i> with every key.

Row 10 is therefore Q₁₀·K₁, Q₁₀·K₂, all the way to Q₁₀·K₁₀.

Notice that only Q₁₀ appears in it. Q₁ through Q₉ only belong to their corresponding rows 1-9, and those rows' hidden states we already discarded because they were never needed.

The last row of attention goes through softmax and multiplies the full stack of value vectors, V₁ through V₁₀, to give the last row of the attention output.

So the last hidden state depends on exactly three things: Q₁₀, every key, and every value.

5) Generating token 12:

Token 11 is appended, and this time, we need row 11's hidden state to generate token 12.

Mathematically, attention operation turns out to be Q₁₁ against K₁ through K₁₁, then multiplied by V₁ through V₁₁.

K₁ through K₁₁ and V₁ through V₁₁ are bit-for-bit what prefill + first token produced since under causal masking, a token's key and value depend on that token and the ones before it, never on anything after, so appending token 11 cannot change anything at position 3.

6) The cache state:

Overall, this implies that you just need to retain the keys and values at each decoding step, and compute only the new position's Q, K and V.

Each decode step requires one query vector, which is never used again, so they are never cached across the decoding process.

The visual below explains the entire process.

That said, KV cache is only one of four separate caching layers in an LLM stack.

The other three are prefix caching on the server, prompt caching billed by a provider, and a semantic cache that skips the model entirely.

I wrote a full breakdown of all four caches in LLM serving that you should know as an AI engineer, with code for each.

Read it below.

[Applied Compute @appliedcompute]

Kimi K3 full fine-tuning is live on AC2. Our memory optimizations reduced GPUs required per training replica by ~40%.

At nearly 3T parameters, Kimi forced us to rethink how we manage memory, communication, rollouts, and checkpoints. The result is a much more efficient path to training frontier-scale open models.

[govin.eth | G哥 @goan999999]

Codex 5.6 必装插件：Sentry，让 AI 修 Bug (缺陷) 不再靠猜

最近做 Vibe Coding 项目经常遇到，刚修好一个 Bug，又出现新的问题，反反复复改特别浪费时间。

之后我开始找工具，发现 Codex 插件里有 Sentry，安装之后整个 Debug 流程完全不一样了。

现在不用反复截图、复制日志、手动排查问题了，只需要告诉它这段 prompt：

“使用 Sentry 排查当前线上 Bug。先读取完整 Error、Stack Trace、运行上下文、发生频率和版本信息，再结合当前代码定位根因，不要只根据最后一条报错直接修改。确认原因后先复现问题并补充回归测试，再完成修复，最后重新运行验证；如果发现同类潜在问题，一并指出并处理。”

Sentry 就可以直接完成：

1️⃣ 先读取完整 Stack Trace、运行上下文和版本信息，把 Bug 发生时的真实现场还原出来。

2️⃣ 再把线上 Error 对应到具体代码和调用链，结合当前项目直接定位真正根因，不再只看最后一条报错猜答案。

3️⃣ 最后复现问题、补回归测试、修改代码并重新运行验证，确认修复有效，同时避免同类 Bug 再次出现。

这样彻底告别 Bug 修了又坏、坏了再修的问题，���试试吧