<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Alice Charlotte的博客</title><description>Alice Charlotte 的小站</description><link>https://neko.aliceneko.xyz/</link><language>zh_CN</language><item><title>把 81 个工具塞进提示词，然后想办法拿出来</title><link>https://neko.aliceneko.xyz/posts/cutting-tool-schemas/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/cutting-tool-schemas/</guid><description>工具定义的 JSON schema 是输入里最肥的一块。记录一次从 13,400 token 压到 2,244 的过程，包括一个被实测否决的聪明方案。</description><pubDate>Sun, 01 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;上一篇讲的是把可复用的内容排成稳定前缀。&lt;/p&gt;
&lt;p&gt;这一篇处理前缀里最大的一块：工具定义。&lt;/p&gt;
&lt;h2&gt;先看它有多肥&lt;/h2&gt;
&lt;p&gt;拆开一次请求的输入，比例是这样的：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;部分&lt;/th&gt;
&lt;th&gt;token&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;工具定义的 JSON schema&lt;/td&gt;
&lt;td&gt;13,400（全量时）&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;动态上下文&lt;/td&gt;
&lt;td&gt;2,100&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;静态人格提示词&lt;/td&gt;
&lt;td&gt;1,400&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;八十一 个工具，每个都要给出名字、描述、参数结构、参数类型、是否必填。这些信息必须是结构化 JSON，因为模型的工具调用依赖它。&lt;/p&gt;
&lt;p&gt;一万三千 token 意味着什么？一次寒暄请求总共才六千多 token。也就是说，光是把工具列表摆出来，就已经是实际对话内容的两倍。&lt;/p&gt;
&lt;h2&gt;第一个想法，被实测否决&lt;/h2&gt;
&lt;p&gt;一个很自然的思路是：请求里只放工具名清单，模型需要用到某个工具时，再单独把它的完整 schema 取过来。&lt;/p&gt;
&lt;p&gt;理论上，这能把 13,400 压到几百 token。听起来像是稳赚。&lt;/p&gt;
&lt;p&gt;实测结果：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;请求形态&lt;/th&gt;
&lt;th&gt;模型是否发起工具调用&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;精简工具 + 工具名目录文本&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;否&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;精简工具，无目录&lt;/td&gt;
&lt;td&gt;是&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;全量工具，无目录&lt;/td&gt;
&lt;td&gt;是&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;第一行是致命的。只要模型看到工具名清单，它就不再走结构化调用了——它会直接在正文里写 &lt;code&gt;工具名 {}&lt;/code&gt;，像是在模仿某种它见过的格式，然后等着别人来解析。&lt;/p&gt;
&lt;p&gt;第二行和第三行的对比说明这不是&quot;工具太少所以不用&quot;，而是&quot;目录文本本身改变了它的行为模式&quot;。三个形态里，只有带目录的那个失效。&lt;/p&gt;
&lt;p&gt;这个方案对测试过的所有主模型都不成立，代码已经删掉了。&lt;/p&gt;
&lt;p&gt;我把这段失败记录留在报告里，因为它划定了一条边界：**省 token 不能以破坏协议为代价。**模型的工具调用行为对提示形态极其敏感，任何看起来聪明的压缩方案，都必须先跑一遍实测再说。&lt;/p&gt;
&lt;h2&gt;按类别加载&lt;/h2&gt;
&lt;p&gt;回到现实可行的做法。&lt;/p&gt;
&lt;p&gt;第一步是把工具分类。用关键词映射：说到&quot;股票&quot;&quot;大盘&quot;&quot;持仓&quot;就加载股票类，说到&quot;视频&quot;&quot;UP主&quot;就加载视频类。日常闲聊不命中任何类别，只带基础集。&lt;/p&gt;
&lt;p&gt;改造前的情况很难看：命中关键词就加载全部 81 个工具。实测下来，&lt;strong&gt;85% 的轮次背着全量工具，实际只用了其中 10 个左右。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这一步省下来的量很大，但会带来缓存问题——上一节讲过，工具数组排在历史前面，它一变，后面全部失效。这个问题留到第四节解决，先看能省多少。&lt;/p&gt;
&lt;h2&gt;基础集瘦身&lt;/h2&gt;
&lt;p&gt;第二步是给常驻的基础集减重。&lt;/p&gt;
&lt;p&gt;原基础集 23 个工具、3,340 token。观察一周之后，把三类低频工具挪出常驻集：技能装卸、内容创作、技能生成用的股票工具。它们不是没用，只是不该每轮都在。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;版本&lt;/th&gt;
&lt;th&gt;工具数&lt;/th&gt;
&lt;th&gt;token&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;原基础集&lt;/td&gt;
&lt;td&gt;23&lt;/td&gt;
&lt;td&gt;3,340&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;现基础集&lt;/td&gt;
&lt;td&gt;17&lt;/td&gt;
&lt;td&gt;2,244&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;省下 1,945 token。判断标准很简单：过去一周有没有被主动调用过。没有就挪出去，需要时按类别加载回来。&lt;/p&gt;
&lt;h2&gt;白名单裁剪&lt;/h2&gt;
&lt;p&gt;第三步的思路和前两步不同，值得单独说。&lt;/p&gt;
&lt;p&gt;有些能力是通过命令直接调 API 实现的，整个链路里不经过模型的工具数组。也就是说，模型其实不需要&quot;看见&quot;这些工具——它不会自主决定调用它们，调用是由应用代码发起的。&lt;/p&gt;
&lt;p&gt;既然模型不需要看见，就应该从可见列表里裁掉。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;类别&lt;/th&gt;
&lt;th&gt;裁剪前&lt;/th&gt;
&lt;th&gt;裁剪后&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;股票&lt;/td&gt;
&lt;td&gt;18&lt;/td&gt;
&lt;td&gt;16&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;视频平台&lt;/td&gt;
&lt;td&gt;23&lt;/td&gt;
&lt;td&gt;13&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;社交平台&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;视频平台砍得最多，从 23 减到 13。因为那个域里的大量操作是流程化的——浏览、筛选、评论，每一步都由上游逻辑决定，模型只负责最后&quot;评论什么&quot;。&lt;/p&gt;
&lt;p&gt;这里的分界线是：**这个工具的调用由谁决策？**如果是模型决策，它必须在 schema 里；如果是代码决策，它就不该占提示词的位置。&lt;/p&gt;
&lt;h2&gt;结果是这些&lt;/h2&gt;
&lt;p&gt;同一条消息、同一个干净会话，只改工具加载策略，取 API 返回的实际 usage 字段：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;消息&lt;/th&gt;
&lt;th&gt;优化前&lt;/th&gt;
&lt;th&gt;优化后&lt;/th&gt;
&lt;th&gt;降幅&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;「在吗」&lt;/td&gt;
&lt;td&gt;5,710&lt;/td&gt;
&lt;td&gt;4,566&lt;/td&gt;
&lt;td&gt;−20%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;「今天大盘怎么样」&lt;/td&gt;
&lt;td&gt;16,428&lt;/td&gt;
&lt;td&gt;7,280&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;−56%&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;「视频平台最近有什么新内容」&lt;/td&gt;
&lt;td&gt;16,431&lt;/td&gt;
&lt;td&gt;6,601&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;−60%&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;工具定义单项：13,456 → 2,244（基础）/ 3,958（视频平台）/ 4,950（股票）。&lt;/p&gt;
&lt;p&gt;寒暄类只降了两成，因为它的工具定义本来就少；带工具的问句降了一半以上，因为那部分是纯粹被工具 schema 撑起来的。&lt;/p&gt;
&lt;p&gt;按日均 170 万 token 计算，每天减少 60 到 80 万。&lt;/p&gt;
&lt;h2&gt;但这条路有个代价&lt;/h2&gt;
&lt;p&gt;按类别加载、基础集瘦身、白名单裁剪，这三步都在做同一件事：让提示词里的工具定义更少。&lt;/p&gt;
&lt;p&gt;它们同时也都在做另一件事：让工具定义更不稳定。&lt;/p&gt;
&lt;p&gt;而工具定义排在历史前面，不稳定就意味着缓存失效。&lt;/p&gt;
&lt;p&gt;如果只看 token 数，这三步全是收益；把缓存单价算进去，第三篇要讲的那个&quot;让失效只发生一次&quot;的机制才是把它们兜住的东西。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;下一篇讲那个机制：为什么一个&quot;加载过就一直带着&quot;的简单规则，能让缓存的收益翻倍。&lt;/p&gt;
</content:encoded></item><item><title>让缓存只失效一次</title><link>https://neko.aliceneko.xyz/posts/cache-invalidation-once/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/cache-invalidation-once/</guid><description>按需加载工具能省钱，但每次切换都打坏缓存。一个&quot;加载过就一直带着&quot;的简单规则，怎么把这两件事的矛盾解开。</description><pubDate>Sun, 01 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;前两篇各讲了一半：把可复用的内容排成稳定前缀能省钱；把工具定义裁到最小也能省钱。&lt;/p&gt;
&lt;p&gt;这两件事放在一起就会打架。&lt;/p&gt;
&lt;h2&gt;矛盾是这样的&lt;/h2&gt;
&lt;p&gt;按类别加载工具，是为了让这一轮的提示词更短。日常闲聊只带 17 个基础工具，问股票才把那 18 个加进来。&lt;/p&gt;
&lt;p&gt;问题在于工具定义排在历史对话前面。&lt;/p&gt;
&lt;p&gt;于是当一句话触发新类别时，工具数组从 17 个变成 35 个，字节全变了。排在它后面的全部历史——可能已经积累了几十轮、上万 token——跟着一起失效。&lt;/p&gt;
&lt;p&gt;上一轮刚刚命中到 95% 的缓存，这一轮掉回三成多。&lt;/p&gt;
&lt;p&gt;实测记录里有一组很典型的轨迹：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;「在吗」              prompt= 4,318  cached=   186  (  4%)
「今天大盘怎么样」     prompt= 7,936  cached= 4,162  ( 52%)
                     prompt= 8,269  cached= 7,936  ( 95%)
「视频平台有什么新内容」 prompt=11,489  cached= 4,169  ( 36%)  ← 换类别
                     prompt=13,128  cached=11,489  ( 87%)
「在吗」              prompt=13,215  cached=11,490  ( 86%)
                     prompt=14,830  cached=13,215  ( 89%)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;第三处那个 36% 就是换类别造成的。它之后又恢复到 87%，然后一路稳定在 86% 到 89%。&lt;/p&gt;
&lt;p&gt;这一来一回的代价很难直观感受。可以这样算：一次前缀失效，等于把之前积累的整段历史重新全价付费了一遍。省下的那点工具定义 token，远远补不上这个洞。&lt;/p&gt;
&lt;h2&gt;如果每轮都选最省的呢&lt;/h2&gt;
&lt;p&gt;顺着&quot;每轮最小 token&quot;这个目标走下去，会得到一个看起来很合理的实现：每个请求独立计算需要哪些工具，能少带就少带。&lt;/p&gt;
&lt;p&gt;这个实现会把缓存打得很碎。用户正常聊天时，句子里的关键词是随机漂移的——这轮提到&quot;视频&quot;，下轮聊别的，工具集就在两个状态之间反复横跳，每跳一次全量失效。&lt;/p&gt;
&lt;p&gt;频次上还有个隐蔽的放大效应：缓存失效不是局部的，它会把后面所有内容一起作废。而工具定义之后跟着的是完整历史，那是提示词里最长的部分。&lt;/p&gt;
&lt;p&gt;所以&quot;每轮最省&quot;这个目标本身是错的。真正的目标应该是：&lt;strong&gt;让可复用的前缀尽可能长地保持有效。&lt;/strong&gt;&lt;/p&gt;
&lt;h2&gt;一条很短的规则&lt;/h2&gt;
&lt;p&gt;做法只有一个判断：某个类别一旦加载过，本次会话后续就一直带着它。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def select_tools(session, message):
    new_cats = match_categories(message) - session.stuck
    if new_cats:
        session.stuck |= new_cats   # 永久带上
    return build_tools(session.stuck)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;代码只有三行，但要理解它为什么有效，需要看清楚它改变的是什么。&lt;/p&gt;
&lt;p&gt;它没有让任何一轮的请求变短。恰恰相反，它让后续轮次多带了一些用不上的工具——聊完股票之后再闲聊，股票那 18 个工具还挂在提示词里。&lt;/p&gt;
&lt;p&gt;它改变的是失效的次数：从一个会话里&quot;每次换类别都失效&quot;，变成&quot;最多失效几次，之后就稳定了&quot;。&lt;/p&gt;
&lt;p&gt;代价和收益放在一起看：多带十几个工具的 schema，大约是几千 token 的固定开销；而一次前缀失效，可能让上万 token 的历史重新全价计费。只要一个会话超过几轮，后者就更贵。&lt;/p&gt;
&lt;h2&gt;这个取舍的一般形式&lt;/h2&gt;
&lt;p&gt;这条规则其实是一个更普遍问题的具体解法：&lt;strong&gt;当&quot;局部最优&quot;和&quot;全局稳定&quot;冲突时，选稳定。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;缓存这类机制的特点是，它奖励的从来不是单次请求的效率，而是一段连续请求之间的相似性。任何让相邻请求产生差异的优化，都在破坏它赖以生效的基础。&lt;/p&gt;
&lt;p&gt;按类别加载是这样。动态调整工具描述、按语义重排历史、给不同轮次换不同的人格片段——凡是让前缀字节漂移的做法，都有同样的问题。&lt;/p&gt;
&lt;p&gt;反过来，那些看起来&quot;浪费&quot;的设计往往在这里更划算：多带一些用不上的工具、多保留几轮已经不太相关的历史、给静态段留一些永远不会被触发的规则。&lt;/p&gt;
&lt;p&gt;它们浪费的是 token 数量，节省的是缓存命中。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;写到这里，三篇正好讲完一条链：缓存认前缀不认语义（第一篇），所以工具定义要裁到最小（第二篇），但裁剪会让前缀漂移，于是需要用&quot;粘住&quot;把失效封顶（第三篇）。&lt;/p&gt;
&lt;p&gt;三者的共同前提是同一个事实——前缀缓存是字节级的判断。&lt;/p&gt;
&lt;p&gt;下一篇换一个方向：从提示词结构挪到工程细节，讲几个让我排查了很久的静默失败。&lt;/p&gt;
</content:encoded></item><item><title>线程开得越多，嵌入越慢</title><link>https://neko.aliceneko.xyz/posts/embedding-thread-and-recall/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/embedding-thread-and-recall/</guid><description>本地向量检索的几个反直觉参数：线程数、召回数量、中文分词、时间衰减的权重。都来自实测，不是经验之谈。</description><pubDate>Sun, 01 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;一个长期在线的聊天机器人需要记住跨会话的事。我的做法是本地向量检索：五百条长期记忆，512 维嵌入，全部在内存里。&lt;/p&gt;
&lt;p&gt;这篇文章讲这条链路上几个调参发现，每一个都和直觉相反。&lt;/p&gt;
&lt;h2&gt;线程越多越慢&lt;/h2&gt;
&lt;p&gt;先看这个数字。4 核 CPU 上，同一个 512 维中文嵌入模型，同一批文本：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;线程数&lt;/th&gt;
&lt;th&gt;单条延迟&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;207ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;30ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;20ms&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;四线程比单线程慢了十倍。&lt;/p&gt;
&lt;p&gt;第一次看到这个结果我以为是测错了。重测、换输入、换批次，结论稳定。&lt;/p&gt;
&lt;p&gt;原因是小模型的矩阵运算量太小，算力还不足以摊平线程间的分发和同步开销。四个线程各自抢锁、同步中间结果，光协调成本就超过了并行带来的收益。&lt;/p&gt;
&lt;p&gt;而框架的默认值通常是&quot;CPU 核数&quot;。对一个几千万参数的嵌入模型来说，这个默认值是错的。&lt;/p&gt;
&lt;p&gt;后来我在部署脚本里把 &lt;code&gt;OMP_NUM_THREADS&lt;/code&gt; 和 &lt;code&gt;torch.set_num_threads&lt;/code&gt; 都固定成 1，前提是只有一两个并发请求。如果 QPS 上去了，正确的做法是多进程而不是多线程——每个进程单线程，靠进程数吃满核。&lt;/p&gt;
&lt;p&gt;这个坑的普遍性在于：所有&quot;小模型 + 默认线程数&quot;的组合都可能踩到。嵌入、重排序、小分类器，都是小模型。&lt;/p&gt;
&lt;h2&gt;召回数量不该固定&lt;/h2&gt;
&lt;p&gt;朴素的做法是向量检索取 top-k，k 设成 5 或者 10。&lt;/p&gt;
&lt;p&gt;但 k 的合适值取决于库的大小。库只有二十条的时候，取前 5 条里可能有 3 条是噪声；库有五百条的时候，取 5 条可能不够覆盖。&lt;/p&gt;
&lt;p&gt;现在的召回数是自适应的：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;库规模&lt;/th&gt;
&lt;th&gt;召回条数&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;≤20 条&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;≤100 条&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;更大&lt;/td&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;设计原则是：&lt;strong&gt;召回数量应该跟&quot;候选池里有多少有效内容&quot;成正比，而不是跟&quot;我习惯取几条&quot;挂钩。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;小库取太多是净损失——噪声进上下文，既花钱又降低回答质量。&lt;/p&gt;
&lt;h2&gt;中文 BM25 必须分词&lt;/h2&gt;
&lt;p&gt;向量召回能找到语义相近的内容，但对精确词、专有名词、数字不敏感。所以补了一路 BM25。&lt;/p&gt;
&lt;p&gt;第一次接进去的时候，关键词那一路的分数恒为 0。&lt;/p&gt;
&lt;p&gt;不是效果差，是根本算不出来。BM25 依赖词频统计，而中文没有空格，不先分词的话整个句子被当成一个&quot;词&quot;，词频永远是 1，分数公式退化。&lt;/p&gt;
&lt;p&gt;加了分词之后，这一路才开始起作用。&lt;/p&gt;
&lt;p&gt;这个坑的危险之处在于它是沉默的：分数为 0 不会报错，融合之后权重 0.12 的那一路相当于不存在，而系统看起来一切正常。&lt;/p&gt;
&lt;h2&gt;两路分数量纲不一致怎么办&lt;/h2&gt;
&lt;p&gt;向量相似度和 BM25 分数是两个完全不同的尺度，一个是余弦距离，一个是基于词频的无界数值，直接加权平均没有意义。&lt;/p&gt;
&lt;p&gt;解法用 RRF（Reciprocal Rank Fusion）：不看分数，只看排名。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;score = 1 / (60 + rank)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每一路贡献一个基于排名的分数，k=60 是原论文的常用值。两路融合之后，谁排得靠前谁贡献大，而不需要关心它们各自的分数量纲。&lt;/p&gt;
&lt;p&gt;这个方法的额外好处是不用调权重——省掉了一个必然会过拟合的参数。&lt;/p&gt;
&lt;h2&gt;时间衰减的权重只有 0.08&lt;/h2&gt;
&lt;p&gt;记忆需要时间衰减，越久远的事越该淡出。衰减函数本身很标准：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;weight = 0.5 ^ (小时数 / 72)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;半衰期 72 小时。&lt;/p&gt;
&lt;p&gt;但&lt;strong&gt;时间衰减在总分里的权重只有 0.08&lt;/strong&gt;，而语义相似度占 0.55。&lt;/p&gt;
&lt;p&gt;为什么压得这么低？因为它的作用是&quot;同分时的平手裁决&quot;，不是主导因素。如果把时间衰减的权重调高，检索会退化成&quot;总是想起最近的&quot;，长期记忆就等于白存了。&lt;/p&gt;
&lt;p&gt;这个参数我调过几轮。最开始设的是 0.25，结果是明显偏近期、早期记忆几乎不出现。&lt;/p&gt;
&lt;p&gt;但这里还有个副作用值得说：正因为时间衰减&quot;只在同分时起作用&quot;，反过来说明加权打分对语义的区分度可能不足——如果语义分能拉开差距，时间衰减就不会有机会介入。&lt;/p&gt;
&lt;p&gt;所以它同时是一个诊断信号。现在我把&quot;提高语义区分度&quot;（上一级精排、交叉编码器）列进了改进项。&lt;/p&gt;
&lt;h2&gt;写入前必须查重&lt;/h2&gt;
&lt;p&gt;这一条不是性能问题，是容量问题。&lt;/p&gt;
&lt;p&gt;五百条上限，如果只写不合并，两周就满了。&lt;/p&gt;
&lt;p&gt;所以写入前有一个闸门：与已有记忆的相似度 ≥ 0.8 时，合并更新而不是新增。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;similar = search(vec, top_k=1)
if similar and similar[0].score &amp;gt;= 0.8:
    merge(existing=similar[0], new=memory)   # 更新，不新增
else:
    insert(memory)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;合并之后，库的增长速率取决于&quot;新信息的多样性&quot;，而不是对话量。这个区别很大——一个人在群里聊一整天，真正新的信息可能只有几条。&lt;/p&gt;
&lt;h2&gt;定期遗忘比写入更重要&lt;/h2&gt;
&lt;p&gt;最后说清理。&lt;/p&gt;
&lt;p&gt;每六小时滚动执行一次（带 ±0.5 小时抖动），做三件事：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;短期记忆里重要性 ≥0.35 的转入长期&lt;/li&gt;
&lt;li&gt;相似度 &amp;gt;0.9 的近重复组，保留最重要的一条&lt;/li&gt;
&lt;li&gt;超过 7 天且重要性 &amp;lt;0.5 的降 30%；超过 30 天且重要性 &amp;lt;0.3 的降到 0.05，等冷存储清理&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;为什么是滚动而不是&quot;每天夜里跑一次&quot;？因为这是长期在线的服务，&quot;夜里空闲&quot;这个概念不存在。随机化的滚动任务反而更均匀，也不会集中在同一时刻产生资源尖峰。&lt;/p&gt;
&lt;p&gt;第二条那个近重复合并是防膨胀的关键。不做这一步，长期的容量很快会被同类内容填满——比如同一个人的口头禅、反复出现的日常寒暄。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;这几条里，线程数和召回数属于&quot;参数反直觉&quot;，分词属于&quot;沉默失败&quot;，时间衰减权重属于&quot;参数暴露了更深的问题&quot;。&lt;/p&gt;
&lt;p&gt;它们共同说明一件事：向量检索看起来是个成熟的组件，但真正决定效果的往往是这些边角参数，而它们很少写在文档里。&lt;/p&gt;
</content:encoded></item><item><title>提示词的排列顺序，决定了你的账单</title><link>https://neko.aliceneko.xyz/posts/prompt-order-and-billing/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/prompt-order-and-billing/</guid><description>一个每天重发上百万 token 的长期在线聊天机器人，为什么把提示词结构当成最需要反复推敲的部分。</description><pubDate>Sun, 01 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;模型每回答一句话，都要把之前的全部内容再送一遍。人格设定、工具定义、完整历史，一个字都不能少。&lt;/p&gt;
&lt;p&gt;对一次性的问答工具来说，这不是问题。但当一个智能体长期在线，一天跑九十多轮对话、上百次模型调用，这件事就会变成账单上最显眼的一行：实测每天输入约 170 万 token，其中九成九都是&quot;重复发送的旧内容&quot;，真正新产生的输出只占百分之一。&lt;/p&gt;
&lt;p&gt;于是优化的方向变得很清楚：不是让它说得更短，而是让重复发送的部分更便宜。&lt;/p&gt;
&lt;p&gt;而便宜的程度，取决于这些内容排在第几个字节。&lt;/p&gt;
&lt;h2&gt;缓存认的是前缀，不是内容&lt;/h2&gt;
&lt;p&gt;现在的模型服务普遍提供前缀缓存：如果这次请求的开头和上一次完全一致，那一段可以按大约十分之一的单价计费。&lt;/p&gt;
&lt;p&gt;关键在于&quot;开头&quot;这两个字的严格程度。它不是一个语义判断，是字节判断——前缀中任何一个字符变了，从那个位置往后的全部内容都会失效。&lt;/p&gt;
&lt;p&gt;我用同一把密钥、同一个模型做了三次隔离请求，把这件事确认下来：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;请求形态&lt;/th&gt;
&lt;th&gt;prompt&lt;/th&gt;
&lt;th&gt;命中&lt;/th&gt;
&lt;th&gt;命中率&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;完全相同的请求发两次&lt;/td&gt;
&lt;td&gt;1,522&lt;/td&gt;
&lt;td&gt;1,520&lt;/td&gt;
&lt;td&gt;99.8%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;前半相同，结尾不同&lt;/td&gt;
&lt;td&gt;1,526&lt;/td&gt;
&lt;td&gt;1,514&lt;/td&gt;
&lt;td&gt;99.2%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;带完整工具定义&lt;/td&gt;
&lt;td&gt;1,756&lt;/td&gt;
&lt;td&gt;1,754&lt;/td&gt;
&lt;td&gt;99.9%&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;第二行的结论最有用：只在末尾追加新内容，前面全部还能命中。&lt;/p&gt;
&lt;p&gt;这也解释了为什么尾部变化不影响前缀——缓存不是把整个请求当成一个整体去比对，它是沿着字节序列往前找最长公共前缀。&lt;/p&gt;
&lt;h2&gt;由此倒推出来的结构&lt;/h2&gt;
&lt;p&gt;既然命中与否由前缀决定，那什么该放前面就不是风格问题，而是成本问题。&lt;/p&gt;
&lt;p&gt;变化最少的东西要放最前面。全进程只构建一次、字节永远不变的人格提示词放在第一位；工具定义次之；历史对话严格递增；每轮都会变的动态状态放最后；本轮消息排在最末。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[静态人格提示词]   ← 只构建一次，字节恒定
[工具定义数组]     ← 必须在历史之前，且要稳定
[历史对话]         ← 严格递增，上一轮发过的就是本轮前缀
[本轮动态状态]     ← 每轮变化
[本轮消息]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个顺序带来的实际效果，看一段真实的多轮记录就明白了：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;「在吗」              prompt= 4,318  cached=   186  (  4%)  ← 冷启动
「今天大盘怎么样」     prompt= 7,936  cached= 4,162  ( 52%)
                     prompt= 8,269  cached= 7,936  ( 95%)
「视频平台有什么新内容」 prompt=11,489  cached= 4,169  ( 36%)  ← 异常
                     prompt=13,128  cached=11,489  ( 87%)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;前两轮很正常：冷启动命中率低，之后每一轮都在复用上一轮的前缀，稳定在九成以上。&lt;/p&gt;
&lt;p&gt;第三组突然掉到 36%，是因为这句话触发了新的工具类别。工具定义排在历史前面，它一变，后面排着的全部历史就跟着失效了。&lt;/p&gt;
&lt;p&gt;这个现象值得多想一层：它说明&quot;优化&quot;和&quot;优化&quot;之间会互相打架。&lt;/p&gt;
&lt;h2&gt;一个被字节稳定性否掉的设计&lt;/h2&gt;
&lt;p&gt;我原本把发送者信息写进了静态段。理由很自然——它属于&quot;这个人在跟她说话&quot;的背景设定，看起来就该和人格放在一起。&lt;/p&gt;
&lt;p&gt;但同一个 QQ 号在群聊和私聊之间切换时，这个值会变。它一变，整段静态前缀连同后面的全部历史一起失效。一次普通的场景切换，把缓存打回冷启动。&lt;/p&gt;
&lt;p&gt;现在的做法是把发送者信息一律挪到动态段。牺牲的是&quot;静态段信息更完整&quot;这个美观，换来的是前缀的字节稳定。&lt;/p&gt;
&lt;p&gt;同一类取舍还有一个更明显的例子：表情标签列表。&lt;/p&gt;
&lt;p&gt;它被我一次性固化进静态段，代价是运行期新增的表情类别不会出现在提示词里。这看起来像 bug，其实是刻意的——静态段里放什么，等价于宣布&quot;这些东西的字节永远不会变&quot;。想让一个新表情被模型认识，就得接受它把整段前缀打坏一次。&lt;/p&gt;
&lt;h2&gt;缓存稳定和 token 数量是一个权衡&lt;/h2&gt;
&lt;p&gt;工具定义是最肥的一块。全量 81 个工具的 schema 排下来是 13,400 token，占了单次请求输入的大半。&lt;/p&gt;
&lt;p&gt;第一版优化是&quot;按类别加载&quot;：用关键词判断这轮需要哪类工具，只带那一类。日常闲聊不命中任何类别，只带基础集。改造前的情况是，85% 的轮次背着全部 81 个工具，实际只用了其中 10 个。&lt;/p&gt;
&lt;p&gt;省 token 的效果立竿见影，但它同时带来一个新问题：工具集跟着关键词变，工具数组又排在历史前面，于是每次类别切换都会打坏一次缓存。&lt;/p&gt;
&lt;p&gt;如果按&quot;每轮最省 token&quot;来算，这没什么可犹豫的。但把缓存单价算进去之后，结论会反过来——一次前缀失效的代价，可能比多带十几个工具更高。&lt;/p&gt;
&lt;p&gt;最后落地的方案不是二选一，而是让失效只发生一次：某个类别一旦加载过，本次会话后续就一直带着它。&lt;/p&gt;
&lt;p&gt;代价是后面的轮次会多带一些用不上的工具；收益是缓存失效从&quot;每次关键词命中都发生&quot;变成&quot;每个会话最多发生一次&quot;。字节稳定换来了连续命中。&lt;/p&gt;
&lt;h2&gt;精简通道反而更贵&lt;/h2&gt;
&lt;p&gt;这条最反直觉，我花了很久才接受。&lt;/p&gt;
&lt;p&gt;我曾做过一条轻量通道：短消息（二十来字以内的社交回合）走精简路径，只带最近两轮历史和一段短人格提示，跳过动态上下文、工具定义和工具循环。直觉上它一定更便宜——发送的内容确实少了一大半。&lt;/p&gt;
&lt;p&gt;但这个通道现在是关闭的。&lt;/p&gt;
&lt;p&gt;原因在于两种成本不能直接比 token 数。全量上下文虽然长，但几乎全部命中缓存，单价是十分之一；精简上下文虽然短，但它和主对话的前缀不一致，只能全价计费。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;方案&lt;/th&gt;
&lt;th&gt;token&lt;/th&gt;
&lt;th&gt;单价&lt;/th&gt;
&lt;th&gt;相对成本&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;全量 + 缓存命中&lt;/td&gt;
&lt;td&gt;8,000&lt;/td&gt;
&lt;td&gt;0.1×&lt;/td&gt;
&lt;td&gt;800&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;精简 + 无缓存&lt;/td&gt;
&lt;td&gt;2,000&lt;/td&gt;
&lt;td&gt;1×&lt;/td&gt;
&lt;td&gt;2,000&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;一边是&quot;发得多但很便宜&quot;，一边是&quot;发得少但全价&quot;。后者的 token 数只有四分之一，账单却是前者的两倍多。&lt;/p&gt;
&lt;p&gt;这件事的教训不是&quot;精简通道没用&quot;，而是：&lt;strong&gt;任何关于成本的判断，都必须用真实计费来验证。&lt;/strong&gt;&quot;这个肯定更省&quot;是一个很容易犯的错，尤其当它建立在 token 数量这种看起来很直接的指标上。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;写到这里回头看，这一整套结构其实只服务于一个事实：缓存按字节比对前缀，不认语义。&lt;/p&gt;
&lt;p&gt;理解了这一条，提示词该按什么顺序排、哪些信息能放静态段、什么时候该为了稳定性放弃节省——都是它的推论。&lt;/p&gt;
&lt;p&gt;下一篇写工具定义本身：13,400 token 是怎么压到两千出头的，以及一个看起来更聪明的方案为什么会被实测否决。&lt;/p&gt;
</content:encoded></item><item><title>那些不报错的故障最难查</title><link>https://neko.aliceneko.xyz/posts/silent-failures/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/silent-failures/</guid><description>四个真实案例：模型吐出非法 JSON、表情包被当成空消息、图片被上下文挤没了、正则顺序吃掉转义。它们的共同点是都没有报错。</description><pubDate>Sun, 01 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;这四件事都发生在同一个项目里，症状各不相同，但有同一个特征：&lt;strong&gt;没有任何报错。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;日志是干净的，指标是正常的，用户看到的是&quot;有时候可以，有时候不行&quot;。&lt;/p&gt;
&lt;h2&gt;一、被悄悄丢掉的工具调用&lt;/h2&gt;
&lt;p&gt;现象：让它画图，有时候能成，有时候毫无反应。没有任何错误提示，它也不说自己失败了。&lt;/p&gt;
&lt;p&gt;排查了很久才找到根因。模型偶尔会吐出不合法的 JSON 参数，比如画幅参数写成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&quot;ratio&quot;:3:4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;少了引号。这不是模型的&quot;错误&quot;——它只是在一个需要严格语法的位置上，给了个看起来像 JSON 的东西。&lt;/p&gt;
&lt;p&gt;而旧实现的处理是：&lt;code&gt;json.loads&lt;/code&gt; 失败，打一条 warning，然后把这个工具调用整个丢弃。&lt;/p&gt;
&lt;p&gt;从模型的角度，它已经调用过了，于是继续往下生成。从用户的角度，什么都没发生。&lt;/p&gt;
&lt;p&gt;这条 warning 埋在日志里，因为它不是异常，只是一条&quot;解析失败&quot;的记录。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;修法不是修 JSON，是改掉&quot;失败就丢弃&quot;这个决定。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;现在是七级降级：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;级别&lt;/th&gt;
&lt;th&gt;处理&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;标准 JSON 解析&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;移除代码块包装，截取最外层花括号&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;修复尾逗号&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;给未加引号的值补引号&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;单引号转双引号&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;清理控制字符，转义裸换行&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;仍然失败，就带空参数执行&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;第七级是关键。带空参数执行，工具自己会报&quot;缺少必要参数&quot;，用户能看到一条明确的错误。&lt;/p&gt;
&lt;p&gt;原则可以概括成一句：&lt;strong&gt;宁可执行失败让用户看到错误，也不静默吞掉调用。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;一条被丢弃的调用，和一个明确报错的失败，对用户来说是完全不同的两件事。前者让人以为系统坏了，后者让人知道哪里填错了。&lt;/p&gt;
&lt;h2&gt;二、表情包被当成空消息&lt;/h2&gt;
&lt;p&gt;现象：有人在群里发了个表情包，它回了一句&quot;你想问咱什么呀&quot;。&lt;/p&gt;
&lt;p&gt;看起来像是&quot;没识别出图片内容&quot;。但真实原因更基础——它认为那条消息是空的。&lt;/p&gt;
&lt;p&gt;消息有效性判定看的是&quot;成功下载的图片字节列表&quot;。表情包多为 GIF 或外链，下载经常失败，列表是空的，于是判定&quot;这条消息什么都没说&quot;。&lt;/p&gt;
&lt;p&gt;判据选错了层级。&lt;/p&gt;
&lt;p&gt;正确的判据应该是&quot;消息里有没有图片段&quot;，也就是看结构，而不是看&quot;我们有没有成功处理它&quot;。下载失败是另一个问题，该给一句占位说明，而不是把整条消息当成不存在。&lt;/p&gt;
&lt;p&gt;这类缺陷有一个共同的形状：&lt;strong&gt;你要判断的是&quot;用户做了什么&quot;，代码判断的是&quot;我们处理成功了吗&quot;。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;两者在正常情况下结果一致，所以测试很容易通过。一旦出现网络抖动、格式不支持、第三方限流，它们就会分叉。&lt;/p&gt;
&lt;p&gt;我在项目里用这个形状又找到几处同类问题。现在只要看到&quot;根据处理结果的返回值来判断用户意图&quot;的代码，都会停下来多想一层。&lt;/p&gt;
&lt;h2&gt;三、图片被上下文挤没了&lt;/h2&gt;
&lt;p&gt;现象：某个视觉模型，有时候能看图，有时候完全&quot;看不见&quot;。&lt;/p&gt;
&lt;p&gt;它不会报错，会正常回复&quot;抱歉，我无法识别图片内容&quot;。所以最初的判断是图片格式问题、上传失败、模型不支持。&lt;/p&gt;
&lt;p&gt;真实原因在测试里暴露出来：动态上下文在 1,500 字符时，图片识别正常；到 3,002 字符，就完全看不见了。&lt;/p&gt;
&lt;p&gt;图片是以 token 的形式进入上下文的，而上下文长度有上限。文本太多的时候，图片那些 token 被挤出了有效窗口。&lt;/p&gt;
&lt;p&gt;不是模型不能识别，是它根本没有收到图。&lt;/p&gt;
&lt;p&gt;这解释了一个很奇怪的现象：为什么&quot;问复杂问题时它看不见图&quot;——因为复杂问题触发的动态上下文更长。&lt;/p&gt;
&lt;p&gt;现在的处理是，带图的轮次把动态上下文压到 1,200 字符以内，只保留时间、心情、状态这三段（决定语气的部分），把技能清单和工具偏好的内容丢掉。&lt;/p&gt;
&lt;p&gt;有意思的是，这不是模型厂商文档里写的东西。它是在自己的数据里发现的。&lt;/p&gt;
&lt;h2&gt;四、被用掉的那个 &amp;amp;&lt;/h2&gt;
&lt;p&gt;现象：偶尔有消息发出来变成 &lt;code&gt;&amp;amp;喵&amp;amp;amp;&lt;/code&gt; 这种半截转义的样子，甚至更糟——正文里冒出纯文本 &lt;code&gt;amp;&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;根因不在模型，在清洗管线：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;text = re.sub(r&quot;&amp;amp;[^&amp;amp;]*&amp;amp;&quot;, &quot;&quot;, text)      # 先跑：移除单 &amp;amp; 包裹的标记
text = html.unescape(text)               # 后跑：还原转义
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;输入是 &lt;code&gt;&amp;amp;喵&amp;amp;amp;&lt;/code&gt;，本意是&quot;一个用 &amp;amp; 包裹的协议标记，内容是已转义的喵&quot;。&lt;/p&gt;
&lt;p&gt;但第一个正则先跑了。它贪婪地匹配了从 &lt;code&gt;&amp;amp;喵&amp;amp;&lt;/code&gt; 这一段，把中间的内容吃掉，留下 &lt;code&gt;amp;&lt;/code&gt;。然后 unescape 对着 &lt;code&gt;amp;&lt;/code&gt; 什么也做不了。&lt;/p&gt;
&lt;p&gt;两行代码顺序调换，问题就没了：先统一还原转义，再做标记剥离。&lt;/p&gt;
&lt;p&gt;这件事的成本很低——一行调整。但它说明的问题不小：&lt;strong&gt;多个正则串联的时候，执行顺序本身就是逻辑。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;我后来把清洗管线里所有多步处理都重新审了一遍，凡是&quot;先删再还原&quot;、&quot;先提取再转义&quot;这类组合，都检查语义依赖。&lt;/p&gt;
&lt;h2&gt;它们的共同点&lt;/h2&gt;
&lt;p&gt;四个案例放在一起看：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;一个把失败当成了&quot;没有发生&quot;&lt;/li&gt;
&lt;li&gt;一个把&quot;处理成功&quot;当成了&quot;用户表达了什么&quot;&lt;/li&gt;
&lt;li&gt;一个把&quot;上下文超限&quot;表现成了&quot;能力不足&quot;&lt;/li&gt;
&lt;li&gt;一个把&quot;顺序错误&quot;表现成了&quot;规则不匹配&quot;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这四种情况里，系统都没有抛异常，因为它每一步都在&quot;按设计运行&quot;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;设计本身把两种不同的情况混成了一种。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这也是为什么这类问题特别难查：调试器帮不上忙，因为没有 bug；日志里只有一条无害的 warning；复现条件依赖外部状态（网络、上下文长度、输入里的特殊字符）。&lt;/p&gt;
&lt;p&gt;现在我的习惯是，在写&quot;判断某件事是否发生&quot;的代码时，先问一句：这个判据，判断的是用户的行为，还是我的处理结果？&lt;/p&gt;
&lt;p&gt;如果是后者，它迟早会在某个边界条件下答错。&lt;/p&gt;
</content:encoded></item><item><title>Jaume：一个给 Agent 用的 350M 句子嵌入模型</title><link>https://neko.aliceneko.xyz/posts/jaume-embedding-v01/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/jaume-embedding-v01/</guid><description>从零训练一个双向 Transformer 编码器，走完 MLM、对比学习、硬负例、决策头全流程。附第一版技术报告和一篇负结果论文。</description><pubDate>Mon, 26 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Jaume 是一个模型系列，每个成员解决一个方向的问题。做它的动机很实际：Agent 系统里需要一个又小又强的语义底座。&lt;/p&gt;
&lt;p&gt;检索、去重、意图判断、判断&quot;这句话到底有没有答案&quot;——这些事如果每次都调大模型，成本会失控。一个 350M 的专用编码器能干完这些，而且推理快。&lt;/p&gt;
&lt;h2&gt;架构&lt;/h2&gt;
&lt;p&gt;双向 Transformer 编码器，用了 GQA、RoPE、RMSNorm 和 MoE。词表直接复用之前那个 MoE 小模型的 151646 BPE。&lt;/p&gt;
&lt;p&gt;注意力部分换成 GQA 之后，KV 头数比 Q 头少，KV cache 的内存占用降下来了。这部分代码和之前写 decoder 时是同一套思路，只是方向反过来。&lt;/p&gt;
&lt;p&gt;输出是池化后的单位向量，然后接三个决策头：多选一、打分、判断&quot;无答案&quot;。一次编码，多路决策。&lt;/p&gt;
&lt;h2&gt;训练走了六个阶段&lt;/h2&gt;
&lt;p&gt;一张 3080 Ti 12G 上跑完的，关键数字记在下面。&lt;/p&gt;
&lt;p&gt;MLM 预训练用了英文和中文维基各四十万段，实际训练三十万句，一个 epoch，loss 从 11.9 降到 4.06。&lt;/p&gt;
&lt;p&gt;对比学习阶段用 MNRL 加 Matryoshka 损失，STS-B 到了 0.6111。&lt;/p&gt;
&lt;p&gt;硬负例重训是最有效的一步：从新编码器挖掘硬负例，覆盖率 70%，重训之后 STS-B 到 0.6223（512 维）/ 0.6108（128 维）。&lt;/p&gt;
&lt;p&gt;Matryoshka 截断的衰减很小，512 维到 128 维只掉 0.012。&lt;/p&gt;
&lt;p&gt;决策头换了一版。第一版是冻结骨干加线性头，第二版改成 MLP trunk 再解冻顶层四层，效果差别很大：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;头&lt;/th&gt;
&lt;th&gt;v1&lt;/th&gt;
&lt;th&gt;v2&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;多选一&lt;/td&gt;
&lt;td&gt;98.0%，ECE 0.070&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;99.75%，ECE 0.0017&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;无答案判断&lt;/td&gt;
&lt;td&gt;AUROC 0.608&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;AUROC 0.837&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;打分&lt;/td&gt;
&lt;td&gt;Pearson 0.253&lt;/td&gt;
&lt;td&gt;Pearson 0.286（仍然弱）&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;打分头还是不行。0 到 5 分的 MOS 类任务，靠一个几百万参数的头很难做好，可能还得排序损失或者更长的输入上下文。&lt;/p&gt;
&lt;p&gt;最后做了温度标定。多选一头天生校准正常；无答案判断过自信，标定温度 3.16，标完 ECE 降到 0.015。&lt;/p&gt;
&lt;h2&gt;几个值得单独讲的实践点&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;MLM 初始化的收益比我预期大。&lt;/strong&gt; 随机初始化直接做对比学习，STS-B 只有 0.5451；先做 MLM 再做对比，是 0.6111。差 0.07，而后者只多跑了一个 epoch。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;单卡做大有效 batch 得靠 GradCache。&lt;/strong&gt; 对比学习需要大 batch，但 12G 显存塞不下。GradCache 两段式梯度是等价的（chunk 级逐位一致，有测试验证），配合关掉梯度检查点，实测能跑到有效 batch 256、每秒 52 对。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;评测必须 hold-out。&lt;/strong&gt; STS-B 自训自测会过拟合，我实测过虚高。所以模型卡上那些分数都标注了来源是历史训练管线，独立的 hold-out 复核按预注册协议走——这是给这个系列定的规矩。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;多语言退化的根因和我一开始想的相反。&lt;/strong&gt; 加了六种语言续训 MLM，STS22 一点没恢复。排查之后发现根因不在 MLM 语料，而在纯英文的 NLI 对比阶段冲刷了多语言对齐。修复路径应该是往对比阶段混多语言数据，不是改 MLM。&lt;/p&gt;
&lt;h2&gt;另一个成员：一个认真做的负结果&lt;/h2&gt;
&lt;p&gt;系列里还有个 Jaume-Memory，做的是给编码器加记忆：要么是可学习的记忆槽，要么是跨输入块传递的递归状态。&lt;/p&gt;
&lt;p&gt;两个机制都在预注册的判据下失败了。&lt;/p&gt;
&lt;p&gt;记忆槽比参数量对齐的注意力池化对照组低 0.0168 Spearman，大约是种子标准差的 3 倍。递归状态在五次运行里全部为负。&lt;/p&gt;
&lt;p&gt;我还做了四阶段诊断，想看它到底卡在哪：输出从来没有读过携带的状态；加性更新把新输入稀释了（相对变化从 0.318 掉到 0.098）；门控退化成常数（标准差从 0.132 降到 0.006，尽管权重移动了 141%）；强制把门限制在 0.1 到 0.99 之间，也没有离开随机水平。&lt;/p&gt;
&lt;p&gt;完整的诊断写成了技术报告，也做成了论文形式的 PDF：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.modelscope.cn/models/LightNeko/Jaume/resolve/master/docs/memory-report.md&quot;&gt;中文技术报告&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.modelscope.cn/models/LightNeko/Jaume/resolve/master/docs/memory-report.en.md&quot;&gt;英文技术报告&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.modelscope.cn/models/LightNeko/Jaume/resolve/master/docs/paper/Jaume-Memory-Technical-Report.pdf&quot;&gt;论文 PDF：Why a Finite-Capacity Neural Memory Does Not Help&lt;/a&gt;（853 KB）&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;负结果也是结果。至少它证明了这个设计在这个规模下不值得继续烧卡。&lt;/p&gt;
&lt;h2&gt;接下来&lt;/h2&gt;
&lt;p&gt;独立 hold-out 复核 STS 分数；修复多语言退化（往对比阶段混多语言数据）；700M 规模看 350M 的结论再决定；打分头补排序损失。&lt;/p&gt;
&lt;p&gt;权重、日志、报告都在 ModelScope 上：&lt;a href=&quot;https://www.modelscope.cn/models/LightNeko/Jaume&quot;&gt;LightNeko/Jaume&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;这是第一版，指标可能随 hold-out 复核更新。&lt;/p&gt;
</content:encoded></item><item><title>一个项目里同时有四个&quot;真相&quot;</title><link>https://neko.aliceneko.xyz/posts/hakusagent-refactor/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/hakusagent-refactor/</guid><description>Python 会话表、Rust 事件表、checkpoint、rollout 日志，四套东西都能声称自己记录了对话历史。重构要解决的就是这件事。</description><pubDate>Mon, 26 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;HakusAgent 是我做了一年多的本地 AI 工作台。它现在能跑的东西不少：桌面端、终端、Android、SSH 和 WSL 远程工作区、语音、Live2D。&lt;/p&gt;
&lt;p&gt;功能堆得越快，架构债越明显。最要命的一条是——这个项目同时有四个地方能声称自己记录了&quot;对话里到底发生了什么&quot;。&lt;/p&gt;
&lt;p&gt;Python 的会话表里有消息行和事件行；Rust 运行时有自己的事件表；checkpoint 文件是一种恢复快照；还有 rollout 日志和长任务的 JSON 状态文件。&lt;/p&gt;
&lt;p&gt;四套东西互相重叠，谁也不服谁。&lt;/p&gt;
&lt;p&gt;具体的症状是：恢复会话时可能拼出两个版本的对话历史；桌面端改了状态但侧栏没跟上；同一个工具调用在一个界面显示成功、在另一个界面显示还在跑。&lt;/p&gt;
&lt;p&gt;于是我停掉功能开发，先把这件事解决掉。&lt;/p&gt;
&lt;h2&gt;为什么会出现四个&lt;/h2&gt;
&lt;p&gt;回头看，每一个都有自己的来历。&lt;/p&gt;
&lt;p&gt;Python 那套是最早的，那时所有逻辑都在 Python 里，消息和事件写在一起很自然。&lt;/p&gt;
&lt;p&gt;Rust 是后来为了性能和进程管理加的，它需要自己掌握执行状态，于是有了第二套表。&lt;/p&gt;
&lt;p&gt;checkpoint 是为了&quot;长任务能恢复&quot;加的——一个正在跑的任务需要能快照下来，这看起来和消息历史是两回事。&lt;/p&gt;
&lt;p&gt;rollout 日志最初是给调试用的，长任务的 JSON 状态是为了让进程重启后不丢东西。&lt;/p&gt;
&lt;p&gt;单独看，每一个都解决了真问题。合在一起，问题就变成了：模型看到的历史应该从哪来，恢复的时候以谁为准，工具调用的&quot;已开始&quot;状态算谁的。&lt;/p&gt;
&lt;h2&gt;把答案定成一个&lt;/h2&gt;
&lt;p&gt;重构的核心决定只有一句：&lt;strong&gt;Rust 是唯一的执行平面，事件账本是唯一的事实源。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;具体到三个平面：&lt;/p&gt;
&lt;p&gt;Rust 负责进程生命周期、工作区传输、文件和命令执行、沙箱、会话持久化、事件排序、对外协议。它是唯一真正执行动作的地方。&lt;/p&gt;
&lt;p&gt;TypeScript 负责呈现：桌面面板、provider 和插件管理、工作流编写。它不能自己执行工作区工具。&lt;/p&gt;
&lt;p&gt;Python 退到扩展层，负责语音、VTuber、旧模型适配这类事情。它不在默认的编码路径上，也不能直接改会话存储。&lt;/p&gt;
&lt;p&gt;这个分工真正改变的是&quot;谁能定义真相&quot;。之前 Python 和 Rust 都能跑一轮对话，现在的规则是：所有模型可见的状态，必须先变成一条 Rust 侧的事件，才允许发给模型。&lt;/p&gt;
&lt;h2&gt;事件长什么样&lt;/h2&gt;
&lt;p&gt;事件信封不算复杂：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;{
  &quot;schema_version&quot;: 1,
  &quot;event_id&quot;: &quot;evt_01J...&quot;,
  &quot;event_type&quot;: &quot;tool_call_started&quot;,
  &quot;session_id&quot;: &quot;ses_01J...&quot;,
  &quot;workspace_id&quot;: &quot;ws_01J...&quot;,
  &quot;turn_id&quot;: &quot;turn_01J...&quot;,
  &quot;correlation_id&quot;: &quot;corr_01J...&quot;,
  &quot;seq&quot;: 42,
  &quot;timestamp&quot;: &quot;2026-10-02T12:00:00.123Z&quot;,
  &quot;payload&quot;: {}
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;设计里有几条约束，每一条都是针对之前踩过的坑：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;序号只能由写入方在单个事务里分配，客户端不许生成。&lt;/strong&gt; 这条的意义是：追加失败即动作没有开始。不允许出现&quot;界面显示已开始、账本里没有&quot;的状态。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;时间戳不参与排序。&lt;/strong&gt; 墙钟会跳——时区、NTP 校正、系统休眠都算。排序一律用序号。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;可见性字段只影响投影，不影响执行。&lt;/strong&gt; 模型看得见什么、界面显示什么，是渲染层的事，不能反过来改变运行时行为。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;核心事件类型是封闭集合。&lt;/strong&gt; 扩展要加事件，必须用自己的命名空间声明。否则这个账本很快会变成什么都往里塞的垃圾桶。&lt;/p&gt;
&lt;h2&gt;消息列表不是真相&lt;/h2&gt;
&lt;p&gt;这一条我花了些时间才真正接受。&lt;/p&gt;
&lt;p&gt;之前我下意识地把&quot;消息列表&quot;当成对话的载体——它就是你在界面上看到的那个东西，怎么会不是事实源？&lt;/p&gt;
&lt;p&gt;但在新模型里，消息列表、任务看板、Review 面板、用量统计、恢复摘要，全都是&lt;strong&gt;投影&lt;/strong&gt;。每一个记录自己已经应用到哪个序号，随时可以删掉重建。&lt;/p&gt;
&lt;p&gt;删掉重建这个性质很重要：如果某个界面显示错了，删掉它的状态重新投影就行，不需要去修账本。&lt;/p&gt;
&lt;p&gt;桌面端可以做乐观渲染来压延迟，但重连时必须按事件 id 对齐并丢弃——它永远不能当恢复来源。&lt;/p&gt;
&lt;h2&gt;权限也只能有一个入口&lt;/h2&gt;
&lt;p&gt;重构前有两套权限：Python 侧一套，Rust 侧一套。词表不一样，判定逻辑也不一样。&lt;/p&gt;
&lt;p&gt;同一个危险命令，走不同路径可能得到不同结论。这不是理论问题，我在实测里遇到过。&lt;/p&gt;
&lt;p&gt;新的模型把所有东西都当&lt;strong&gt;能力&lt;/strong&gt;：工具、provider、工作区传输、沙箱、MCP、Skills、子代理。每个能力必须声明副作用范围、风险等级、需要的审批模式、支持的工作区类型。&lt;/p&gt;
&lt;p&gt;决策集中在一处，只返回三种结果：允许、询问、拒绝，附带稳定的规则 id 和人类可读的理由。桌面、终端、远程 worker、Python 扩展全部走这个边界，任何适配器不得绕过。&lt;/p&gt;
&lt;p&gt;另外把几类危险操作拆成独立维度：破坏性操作、工作区逃逸、凭据访问、网络出口、远程进程控制。它们各自判定，不会因为&quot;整体模式宽松&quot;被一起放行。&lt;/p&gt;
&lt;h2&gt;给自己定的硬指标&lt;/h2&gt;
&lt;p&gt;重构如果只是&quot;把结构整理得好看一点&quot;，就没有验收标准。所以我定了一组可测量的门槛：&lt;/p&gt;
&lt;p&gt;冷启动五秒内主窗口可用；空闲内存不超过 450 MB；提交后 300 毫秒内出现第一个事件；事件序号无重复无递减；取消确认后工具不得继续修改工作区；重放产生完全相同的模型可见历史；provider 健康检查不泄露凭据；远程重连不得分叉历史。&lt;/p&gt;
&lt;p&gt;其中&quot;取消后不得继续修改工作区&quot;最麻烦，因为子进程可能已经跑起来了。要真正确认，得做 kill 加 trace 的测试，而不是只看接口返回成功。&lt;/p&gt;
&lt;h2&gt;迁移顺序不能乱&lt;/h2&gt;
&lt;p&gt;拆成六步：&lt;/p&gt;
&lt;p&gt;先稳定运行时边界，给本地工作区和 provider 健康检查补契约测试；再逐个接工作区适配器，SSH 然后 WSL 然后 Docker，每个都要先过假环境测试再上真机；然后让终端、桌面、Web 都只消费同一份账本，同时冻结新的 Python 会话格式；接着把页面式布局换成分栏工作台；再把语音、VTuber、旧 provider、Android 挪到带版本的可选协议后面；最后才删旧代码。&lt;/p&gt;
&lt;p&gt;关键是第五步和第六步不能提前。在切片跑通之前，一个旧功能都不能删；中间任何时刻主分支都要能跑。&lt;/p&gt;
&lt;h2&gt;学到的&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;先写契约再写代码。&lt;/strong&gt; 这次我先写了一份四万字的规范，把事件信封、状态机、迁移门槛、删除规则全定下来。写文档的过程本身就暴露了三处设计矛盾——如果直接写代码，这些矛盾会变成三个月后的 bug。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;参考别人的架构，但别抄目录结构。&lt;/strong&gt; 这套边界设计参考了 DeepSeek Harness 的事件、能力、审批三个契约，交互和工作区参考了 ZCode。但我没有照搬它们的插件目录组织——那是为纯 runtime 设计的，套到有桌面、语音、VTuber 的产品上会畸形。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;项目还在重构中。等垂直切片跑通、旧路径退休，再写一篇收尾。&lt;/p&gt;
</content:encoded></item><item><title>注意力窗口外的东西，模型还记不记得</title><link>https://neko.aliceneko.xyz/posts/hakus-hybrid-experiment/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/hakus-hybrid-experiment/</guid><description>用一个几百万参数的小模型做一个能&quot;物理切断&quot;注意力窗口的实验。结论比预想的少，但实验装置本身值得写下来。</description><pubDate>Tue, 20 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;现代模型的注意力窗口有限。窗口外的信息怎么办？&lt;/p&gt;
&lt;p&gt;有一类思路是在注意力之外挂一条持久状态：一个随着序列不断更新、能被后续 token 读到的小向量，相当于给模型一个容量很小的工作记忆。&lt;/p&gt;
&lt;p&gt;这个想法听起来合理。但它很容易被一种假的验证方式骗过——如果测试任务里答案其实还在窗口内，或者数据布局让关键事实恰好贴着查询，那模型表现好，你根本分不清是状态起了作用，还是注意力碰巧覆盖到了。&lt;/p&gt;
&lt;p&gt;所以这个实验的目标不是证明架构好，而是先造一个能把&quot;窗口外&quot;变成物理事实的装置。&lt;/p&gt;
&lt;h2&gt;让注意力真的看不见&lt;/h2&gt;
&lt;p&gt;第一步是硬切断。用的是带状因果掩码，窗口固定 16——当前 token 只能看到前 16 个位置，更远的直接被掩掉。这不是软限制，是物理上不可见。&lt;/p&gt;
&lt;p&gt;第二步是控制距离。任务是合成的：文档里放几个（键, 值）事实，加噪声，最后给一个查询键，要求输出对应的值。布局是这样：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[事实1][事实2][事实3] [噪声 × d] [查询键]
                                  ↑
                          恰好隔 d 个噪声
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;d=8 时事实在窗口内，d=16 刚好出窗，d≥24 完全不可见。&lt;/p&gt;
&lt;p&gt;这里有个教训值得先说。我的第一版协议把噪声插在事实前面，结果出现了&quot;最后一条事实贴着查询&quot;的伪影，读数虚高，整套数据作废重跑。控制变量这件事，在合成任务里也一样要老老实实做。&lt;/p&gt;
&lt;h2&gt;对照怎么设&lt;/h2&gt;
&lt;p&gt;五个变体，都用 CPU 训练三千步：&lt;/p&gt;
&lt;p&gt;纯注意力作为对照组；混合版是注意力加八个状态槽再加一个可学习门；固定门版把门固定成 0.5；只有状态没有注意力；以及一个经典基线 RNN 加注意力。&lt;/p&gt;
&lt;p&gt;状态层的更新大致是：路由决定写到哪个槽，门决定写多少，候选决定写什么，然后按加权方式合并进状态。&lt;/p&gt;
&lt;h2&gt;能站住的部分&lt;/h2&gt;
&lt;p&gt;距离扫描的结果（每点 192 个样本）：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;距离&lt;/th&gt;
&lt;th&gt;纯注意力&lt;/th&gt;
&lt;th&gt;混合&lt;/th&gt;
&lt;th&gt;固定门&lt;/th&gt;
&lt;th&gt;只有状态&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;8（窗内）&lt;/td&gt;
&lt;td&gt;0.333&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0.438&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;0.339&lt;/td&gt;
&lt;td&gt;0.412&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;16（窗外）&lt;/td&gt;
&lt;td&gt;0.073&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0.458&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;0.438&lt;/td&gt;
&lt;td&gt;0.307&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;24&lt;/td&gt;
&lt;td&gt;0.005&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0.422&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;0.422&lt;/td&gt;
&lt;td&gt;0.016&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;32&lt;/td&gt;
&lt;td&gt;0.000&lt;/td&gt;
&lt;td&gt;0.240&lt;/td&gt;
&lt;td&gt;0.307&lt;/td&gt;
&lt;td&gt;0.000&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;48&lt;/td&gt;
&lt;td&gt;0.000&lt;/td&gt;
&lt;td&gt;0.016&lt;/td&gt;
&lt;td&gt;0.063&lt;/td&gt;
&lt;td&gt;0.000&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;64+&lt;/td&gt;
&lt;td&gt;0.000&lt;/td&gt;
&lt;td&gt;0.000&lt;/td&gt;
&lt;td&gt;0.000&lt;/td&gt;
&lt;td&gt;0.000&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;三个读数我觉得站得住。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;装置本身有效。&lt;/strong&gt; 纯注意力在距离 16 之后精确衰减到零，说明掩码没有泄漏。距离 16 那个 0.073 是&quot;刚出窗&quot;的边界效应，符合预期。如果这条不成立，后面所有结论都不用看。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;距离 24 处 0.422 对 0.005，两次独立训练都复现了。&lt;/strong&gt; 门控版和固定门版都是 0.422，纯注意力是 0.005。这个量级的差距远超噪声，是状态在窗口外携带信息的证据——不是相关性，是&quot;把注意力物理切断之后它依然答对&quot;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;只有状态的那个在距离 24 崩了（0.016）。&lt;/strong&gt; 这个结果反而是好消息：说明状态单独不够用，需要和注意力配合。如果纯状态模型就能打平，说明测试太简单。&lt;/p&gt;
&lt;p&gt;另外做两个健全性检查：把状态完全打乱后，性能掉到盲猜水平，证明状态确实在被依赖；重置状态后与正常情况有明显差距，方向支持状态承载跨段信息。&lt;/p&gt;
&lt;h2&gt;不敢下结论的部分&lt;/h2&gt;
&lt;p&gt;这部分比上面那些数字更值得写。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;噪声很大。&lt;/strong&gt; 这个实验没有固定随机种子，每次训练的数据集都不一样。实测跨运行的方差在 0.06 到 0.09 之间——意味着所有小于 0.1 的组间差异都不可靠。上面三条结论都在 0.3 以上，稳；下面的不行。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&quot;可学习门有价值&quot;这条被我自己的数据否掉了。&lt;/strong&gt; 我原本假设门控会更好。实测下来，门控版和固定门版在距离 32 是 0.240 对 0.307，固定门反而略优。而且门的指标本身是健康的，说明门确实在被使用，只是没转化成优势。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;距离 48 归零，不代表状态做不到长程。&lt;/strong&gt; 训练时的距离分布上限只有二十几到四十几，48 是分布外。这更像是外推失败，不是架构限制。真正的长程结论必须等距离课程训练。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;RNN 加注意力的基线训练失败了&lt;/strong&gt;（准确率接近随机）。所以&quot;混合版是不是 RNN 换皮&quot;这个问题，这一轮根本没有回答——对照失效了，不能拿它下任何结论。这条我一开始想含糊过去，最后还是在报告里明确标成&quot;本轮无效&quot;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;槽数量消融没有出现容量单调增益。&lt;/strong&gt; 一到十六个槽全部弱于主模型，那个 0.25 的平台更可能是训练预算和容量的联合限制，我没有拿到支持容量假说的清晰证据。&lt;/p&gt;
&lt;h2&gt;这个实验能说什么&lt;/h2&gt;
&lt;p&gt;在合成任务的这个规模下，持久状态确实能在注意力窗口外携带信息，差距是 0.4 量级，可复现。&lt;/p&gt;
&lt;p&gt;它不能说明：门控有价值、状态能长程保持、这不是 RNN 换皮、这个结论能推广到语言建模。几百万参数、单任务，所有结论严格限定在这个协议内。&lt;/p&gt;
&lt;p&gt;下一步的清单是：距离课程训练回答真正的长程问题；固定种子、每配置三次运行报均值和标准差；修基线超参补上换皮对照；门机制重新设计或者直接删掉；槽路由从静态键改成内容寻址。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;写完回头看，这个项目最大的收获不是那个 0.422，而是学会了给自己的实验划可信边界。一个能证伪自己的装置，比一个能刷高分的装置有用。&lt;/p&gt;
</content:encoded></item><item><title>我攒了二十多个大模型算法的小实验</title><link>https://neko.aliceneko.xyz/posts/llm-algorithms-reproduction/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/llm-algorithms-reproduction/</guid><description>从零实现 SFT 和 DPO、一整套强化学习算法、跨 tokenizer 的知识蒸馏。为什么看论文不够，非得自己写一遍。</description><pubDate>Mon, 12 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;看论文的时候总觉得懂了。看别人的代码，也觉得懂了。&lt;/p&gt;
&lt;p&gt;自己动手才发现卡住的地方全在细节里：advantage 该怎么算、loss 在哪一步聚合、mask 加在哪个轴上。这些论文通常一两句话带过，而它们决定了实不work。&lt;/p&gt;
&lt;p&gt;所以我攒了一个仓库，专门复现大模型相关的算法。现在大约二十多个子项目，每个都是一个能跑的小实验。&lt;/p&gt;
&lt;h2&gt;强化学习那一块最多&lt;/h2&gt;
&lt;p&gt;这部分占比最大，基本上把主流 RLHF 算法都写了一遍：GRPO、DAPO、PPO、ReMax、RLOO、Reinforce++，还有一个不训练的 GRPO 变体。另外借 verl 做了代码推理方向的后训练实验。&lt;/p&gt;
&lt;p&gt;写完之后有个体会：这些算法之间的差异，往往就在 advantage 估计和 loss 聚合的几行代码上。但效果差异很大，而且这些差异很难从公式上看出来——得自己跑。&lt;/p&gt;
&lt;p&gt;举个具体的：PPO 里 critic 的存在与否，直接把训练分成两代方法。去掉 critic 之后，advantage 该怎么估计就成了核心问题，GRPO 用组内归一化，DAPO 又在这个基础上加了几个修正。论文里这些都是小节的篇幅，但自己实现的时候会反复遇到&quot;这里为什么这么写&quot;的疑问。&lt;/p&gt;
&lt;h2&gt;从零训练的部分&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;train_llm_from_scratch&lt;/code&gt; 是从零实现 SFT 和 DPO 全流程的。还有 MoE、多模态、SigLIP、Qwen3-Next 的从零训练。&lt;/p&gt;
&lt;p&gt;同策略知识蒸馏里有一个子项目做跨 tokenizer 的蒸馏——师生模型词表不一样的时候怎么蒸馏。这个问题比想象中有意思：logits 对不齐，就不能直接用 KL，要么做词表映射，要么用序列级的分布匹配。每种做法都有自己的代价。&lt;/p&gt;
&lt;h2&gt;Agent 和检索&lt;/h2&gt;
&lt;p&gt;RAG 和表格 RAG（结构化数据检索）。深度研究 agent，用 langgraph 加 MCP 加 searxng 串起来。还有一个 PDF 转 Markdown 的管线。&lt;/p&gt;
&lt;p&gt;最后一个可能听起来最没意思，但它是 LLM 时代绕不开的脏活。PDF 里的表格、双栏排版、公式，每一样都要单独处理。&lt;/p&gt;
&lt;h2&gt;也留下了一些训练产物&lt;/h2&gt;
&lt;p&gt;配合这些脚本，在云端跑过 SFT 微调。本地留了几个 checkpoint，其中一次训练到 loss 2.65 时刚跑完 0.13 个 epoch 就停了——云端成本所限，但足够验证管线是通的。&lt;/p&gt;
&lt;p&gt;这些 checkpoint 现在更多是&quot;我真的跑过&quot;的证据，而不是有什么使用价值。&lt;/p&gt;
&lt;h2&gt;三条体会&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;复现是最好的学习。&lt;/strong&gt; 每复现一个算法，对原论文的理解会翻新一遍。有时候会发现论文里没写清楚的地方，有时候会发现自己的理解有偏差。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;先用小模型跑通管线。&lt;/strong&gt; 我习惯先用一亿参数级别的模型验证整条链路，确认 loss 在降、梯度没问题、保存加载正常，再放大规模。省时间也省钱。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;工程细节比算法更容易出错。&lt;/strong&gt; 数据过滤、collator 对 labels 的处理、mask 的位置——这些&quot;脏细节&quot;出问题的概率，远大于算法本身写错。我在另一篇里详细写过一次因为 labels 处理错误导致模型崩溃的经历。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;这些子项目的笔记会陆续整理成单独的篇目，每篇聚焦一个算法，写清楚实现时卡在哪、怎么解决的。&lt;/p&gt;
&lt;p&gt;如果一个算法能写成一篇，希望它能比&quot;论文的翻译版&quot;多一点东西。&lt;/p&gt;
</content:encoded></item><item><title>羽汐：一个长期在线的聊天机器人是怎么做的</title><link>https://neko.aliceneko.xyz/posts/hakusai-projects/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/hakusai-projects/</guid><description>从一个 QQ 机器人开始，一路长成了本地 Agent 框架和 3D 具身角色。这是一份项目群的整体地图。</description><pubDate>Thu, 01 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;羽汐这个项目，最开始只是一个 QQ 机器人。&lt;/p&gt;
&lt;p&gt;它当时的全部功能，是在群里被 @ 的时候回一句话。没有记忆，没有性格，隔天就把前一天聊过的事忘得干干净净。&lt;/p&gt;
&lt;p&gt;后来陆续长出了别的东西：一个能管项目文件的本地 Agent 工作台，一个会动会说话的 3D 角色，一堆围绕&quot;让她更像一个人&quot;的实验。这些项目现在共享同一个名字，但各自解决不同的问题。&lt;/p&gt;
&lt;p&gt;这篇先把地图铺开。&lt;/p&gt;
&lt;h2&gt;最重要的那个：让她一直待在那里&lt;/h2&gt;
&lt;p&gt;核心项目是一套本地优先的 Agent 运行时。它做的是最常见的那类事：连接模型、管理会话、执行工具、处理权限。&lt;/p&gt;
&lt;p&gt;真正花时间的不是这些功能，而是三件为了&quot;长期在线&quot;才存在的事。&lt;/p&gt;
&lt;p&gt;第一件是成本。一个只在被提问时运转的工具，每次请求都是独立的，贵不贵无所谓；但一个每天主动开口、一天烧掉上百万 token 的进程，每一轮都在花钱。所以这个项目里投入最深的工程方向是上下文成本，而不是回答质量。&lt;/p&gt;
&lt;p&gt;第二件是&quot;什么时候闭嘴&quot;。被叫才答的系统不需要判断时机。一个像人的系统得知道现在该不该插话、群里正热闹的时候要不要忍着、深夜要不要保持安静。这催生了一套带预算上限的自主社交机制。&lt;/p&gt;
&lt;p&gt;第三件是状态连续。记忆会随时间衰减，情绪会平复，但心情不会因为时间自动变好——如果久不聊天之后突然出现，表现得像&quot;刚睡醒心情很好&quot;，那就很假。这些不是修辞，是写在状态机里的参数。&lt;/p&gt;
&lt;h2&gt;3D 的那部分&lt;/h2&gt;
&lt;p&gt;另一条线是让她有身体。&lt;/p&gt;
&lt;p&gt;它跑在浏览器里：Three.js 负责渲染，Rapier 负责物理，虚拟形象用的是 VRM 格式。后端不直接控制骨骼，而是通过 WebSocket 持续输出一组上半身的控制点，前端按这些控制点驱动动作。&lt;/p&gt;
&lt;p&gt;动作本身由一个小策略网络生成，训练数据来自动捕的 BVH 文件，推理跑在 CPU 上——因为目标场景是低算力设备，GPU 不是随时都有。&lt;/p&gt;
&lt;p&gt;语音是另一条链路：本地做识别和静音检测，云端做合成。要让她在被打断时立刻停下来，这条链路里每一段都得能取消。&lt;/p&gt;
&lt;p&gt;这个方向最费时间的地方不是模型，是数据。中文的&quot;语气—手势&quot;对应关系几乎没有现成语料，所以自建了一套中文语音和动作的配对数据集。&lt;/p&gt;
&lt;h2&gt;几个小一点的实验&lt;/h2&gt;
&lt;p&gt;有个参数只有几百万的小模型实验，试图回答&quot;在注意力之外挂一条持久状态，能不能记住窗口外的东西&quot;。这个实验做出来的结论比预想的少，但把实验装置本身做扎实了，以后可以复用。&lt;/p&gt;
&lt;p&gt;有一个早期的长期记忆图项目，想法是让记忆之间互相连接、支持多跳推理。最后因为算力消耗太大被弃用了，只留下设计思路。它没有集成进机器人——这一点之前被我写错过，这里更正一下。&lt;/p&gt;
&lt;p&gt;还有一套 Live2D 模型的自动化工具，从 PSD 分层解析到口型区域检测，用来减少手工建模的量。&lt;/p&gt;
&lt;h2&gt;它们之间的关系&lt;/h2&gt;
&lt;p&gt;这几条线看起来分散，其实都指向同一个问题：一个虚拟角色要&quot;一直在&quot;，需要什么。&lt;/p&gt;
&lt;p&gt;成本工程让她说得起，社交机制让她知道什么时候开口，状态机让她不会每隔一天重置一次，身体和语音让&quot;在&quot;这件事有可感知的形式。&lt;/p&gt;
&lt;p&gt;现在的状态是：QQ 机器人在稳定运行，每天的对话量和 token 消耗都有日志；Agent 工作台正在做一次比较大的架构重构；3D 那部分在第一阶段，室内场景的闭环还在推进。&lt;/p&gt;
&lt;p&gt;后面会分开写每一块。这篇只是个目录。&lt;/p&gt;
</content:encoded></item><item><title>Loftey：MoE 语言模型的实践记录（下）</title><link>https://neko.aliceneko.xyz/posts/loftey-moe-practice-2/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/loftey-moe-practice-2/</guid><description>分享我最近折腾的一个小项目 —— Loftey，一个基于 MoE 的 235M 参数轻量级语言模型，从架构到训练的完整实践记录。</description><pubDate>Fri, 30 Jan 2026 00:00:00 GMT</pubDate><content:encoded>&lt;h2&gt;前言&lt;/h2&gt;
&lt;p&gt;上回我们聊了聊混合专家的原理，很多朋友留言说想看看实际代码怎么实现。这篇文章就分享一下我最近折腾的一个小项目 —— Loftey，一个基于 MoE 的轻量级语言模型。&lt;/p&gt;
&lt;p&gt;这是一个 235M 参数的小模型，主要是用来学习和实验的。&lt;/p&gt;
&lt;h2&gt;为什么做这个？&lt;/h2&gt;
&lt;p&gt;起因很简单，就是想学习和研究一下大模型。市面上开源的大模型很多，但直接看代码有时候挺吃力的，不如自己写一个简单的，从零开始理解每个部分。&lt;/p&gt;
&lt;p&gt;另外，小模型也有小模型的好处：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;训练快，单卡就能跑&lt;/li&gt;
&lt;li&gt;调试方便，改了代码很快能看到效果&lt;/li&gt;
&lt;li&gt;可以大胆尝试各种想法&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;模型架构概览&lt;/h2&gt;
&lt;p&gt;Loftey 的整体结构就是一个标准的 Transformer decoder，主要改动在前馈网络（FFN）部分，换成了 MoE。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Input Tokens
    │
    ▼
Embedding Layer
    │
    ▼
┌─────────────────────────────────────┐
│ Transformer Layers (×6)             │
│ ┌─────────────────────────────┐     │
│ │ 1. RMSNorm                  │     │
│ │ 2. Self-Attention (GQA)     │     │
│ │ 3. RMSNorm                  │     │
│ │ 4. MoE FeedForward          │     │
│ └─────────────────────────────┘     │
└─────────────────────────────────────┘
    │
    ▼
Output Logits
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;参数配置：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;hidden_size: 512&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;num_layers: 6&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;num_attention_heads: 16&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;num_key_value_heads: 8&lt;/code&gt; (GQA)&lt;/li&gt;
&lt;li&gt;&lt;code&gt;expert_num: 4&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;topk: 2&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;核心代码实现&lt;/h2&gt;
&lt;h3&gt;1. 配置类&lt;/h3&gt;
&lt;p&gt;先定义一个配置类，把所有参数都放在一起：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class Config:
    model_type = &quot;loftey&quot;
    def __init__(self,
                 vocab_size: int = 151646,
                 hidden_size: int = 512,
                 intermediate_size: int = 2048,
                 num_layers: int = 6,
                 num_attention_heads: int = 16,
                 num_key_value_heads: int = 8,
                 max_seq_len: int = 512,
                 expert_num: int = 4,
                 topk: int = 2,
                 mlp_bias: bool = False,
                 use_moe: bool = True,
                 **kwargs):
        self.vocab_size = vocab_size
        self.hidden_size = hidden_size
        self.intermediate_size = intermediate_size
        self.num_layers = num_layers
        self.num_attention_heads = num_attention_heads
        self.num_key_value_heads = num_key_value_heads
        self.max_seq_len = max_seq_len
        self.expert_num = expert_num
        self.topk = topk
        self.mlp_bias = mlp_bias
        self.use_moe = use_moe
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里 &lt;code&gt;num_key_value_heads&lt;/code&gt; 小于 &lt;code&gt;num_attention_heads&lt;/code&gt;，就是 GQA（Grouped Query Attention），可以减少 KV cache 的内存占用。&lt;/p&gt;
&lt;h3&gt;2. RMSNorm&lt;/h3&gt;
&lt;p&gt;RMSNorm 是现在大模型常用的归一化方法，比 LayerNorm 简单一点：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class RMSNorm(nn.Module):
    def __init__(self, hidden_size, eps=1e-6):
        super().__init__()
        self.weight = nn.Parameter(torch.ones(hidden_size))
        self.eps = eps

    def forward(self, x):
        variance = x.pow(2).mean(-1, keepdim=True)
        x = x * torch.rsqrt(variance + self.eps)
        return self.weight * x
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其实就是计算均方根，然后归一化，没有减去均值那一步。&lt;/p&gt;
&lt;h3&gt;3. 标准前馈网络&lt;/h3&gt;
&lt;p&gt;先看普通的 FFN，用的是 SwiGLU 激活：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class FeedForward(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.gate_proj = nn.Linear(config.hidden_size, config.intermediate_size, bias=config.mlp_bias)
        self.up_proj = nn.Linear(config.hidden_size, config.intermediate_size, bias=config.mlp_bias)
        self.down_proj = nn.Linear(config.intermediate_size, config.hidden_size, bias=config.mlp_bias)

    def forward(self, x):
        gate = F.silu(self.gate_proj(x))
        up = self.up_proj(x)
        return self.down_proj(gate * up)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;SwiGLU 就是两个线性投影，一个走 SiLU 激活，然后相乘。&lt;/p&gt;
&lt;h3&gt;4. MoE 前馈网络&lt;/h3&gt;
&lt;p&gt;这是重点，上回讲原理的时候说过，MoE 的核心是路由器：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class MoEFeedForward(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.config = config
        self.expert_num = config.expert_num
        self.topk = config.topk

        # 路由器：一个简单的线性层
        self.gate = nn.Linear(config.hidden_size, self.expert_num, bias=False)
        # 专家列表：每个专家都是一个 FFN
        self.experts = nn.ModuleList([FeedForward(config) for _ in range(self.expert_num)])

    def forward(self, x):
        batch_size, seq_len, hidden_size = x.shape
        x_flat = x.view(-1, hidden_size)

        # 计算路由分数
        router_logits = self.gate(x_flat)
        router_probs = F.softmax(router_logits, dim=-1)

        # 选择 top-k 专家
        topk_probs, topk_indices = torch.topk(router_probs, self.topk, dim=-1)

        output = torch.zeros_like(x_flat)

        # 分配给专家
        for i in range(self.expert_num):
            expert_mask = (topk_indices == i).any(dim=-1)
            if expert_mask.sum() &amp;gt; 0:
                expert_input = x_flat[expert_mask]
                expert_output = self.experts[i](expert_input)
                # 获取权重
                expert_positions = (topk_indices[expert_mask] == i).nonzero(as_tuple=True)[1]
                expert_weights = topk_probs[expert_mask, expert_positions]
                # 加权求和
                output[expert_mask] += expert_output * expert_weights.unsqueeze(-1)

        return output.view(batch_size, seq_len, hidden_size)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个实现有几个关键点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;路由器&lt;/strong&gt;：就是一个线性层，输出每个专家的分数&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Top-k 选择&lt;/strong&gt;：只激活分数最高的 k 个专家&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;加权输出&lt;/strong&gt;：每个专家的输出乘以路由权重，然后求和&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;5. 注意力层&lt;/h3&gt;
&lt;p&gt;注意力部分用的是 GQA，KV 头数比 Q 头数少：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class Attention(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.hidden_size = config.hidden_size
        self.num_heads = config.num_attention_heads
        self.head_dim = self.hidden_size // self.num_heads
        self.num_key_value_heads = config.num_key_value_heads

        self.q_proj = nn.Linear(config.hidden_size, self.num_heads * self.head_dim, bias=False)
        self.k_proj = nn.Linear(config.hidden_size, self.num_key_value_heads * self.head_dim, bias=False)
        self.v_proj = nn.Linear(config.hidden_size, self.num_key_value_heads * self.head_dim, bias=False)
        self.o_proj = nn.Linear(self.num_heads * self.head_dim, config.hidden_size, bias=False)

    def forward(self, x, attention_mask=None):
        batch_size, seq_len, _ = x.shape

        q = self.q_proj(x).view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
        k = self.k_proj(x).view(batch_size, seq_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
        v = self.v_proj(x).view(batch_size, seq_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)

        # 重复 KV 头
        k = self.repeat_kv(k, self.num_heads // self.num_key_value_heads)
        v = self.repeat_kv(v, self.num_heads // self.num_key_value_heads)

        scores = torch.matmul(q, k.transpose(-2, -1)) / (self.head_dim ** 0.5)
        if attention_mask is not None:
            scores = scores + attention_mask

        attn_weights = F.softmax(scores, dim=-1)
        output = torch.matmul(attn_weights, v)
        output = output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.hidden_size)
        return self.o_proj(output)

    def repeat_kv(self, x, n_rep):
        batch_size, n_kv_h, seq_len, head_dim = x.shape
        if n_rep == 1:
            return x
        return x[:, :, None, :, :].expand(batch_size, n_kv_h, n_rep, seq_len, head_dim).reshape(
            batch_size, n_kv_h * n_rep, seq_len, head_dim
        )
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;repeat_kv&lt;/code&gt; 就是把 KV 复制多份，匹配 Q 的头数。&lt;/p&gt;
&lt;h3&gt;6. Decoder Layer&lt;/h3&gt;
&lt;p&gt;把注意力层和 MoE 层组合起来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class DecoderLayer(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.config = config
        self.self_attn = Attention(config)
        self.input_layernorm = RMSNorm(config.hidden_size)
        self.post_attention_layernorm = RMSNorm(config.hidden_size)
        self.mlp = MoEFeedForward(config) if config.use_moe else FeedForward(config)

    def forward(self, x, attention_mask=None):
        residual = x
        x = self.input_layernorm(x)
        x = self.self_attn(x, attention_mask)
        x = residual + x

        residual = x
        x = self.post_attention_layernorm(x)
        x = self.mlp(x)
        x = residual + x
        return x
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就是标准的 Pre-LN 结构。&lt;/p&gt;
&lt;h2&gt;训练记录&lt;/h2&gt;
&lt;h3&gt;数据和配置&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Tokenizer&lt;/strong&gt;：用了 Qwen 的 tokenizer，词汇量 151646&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;训练数据&lt;/strong&gt;：预训练和 SFT 都用 minimind 的中文数据集&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;设备&lt;/strong&gt;：单张 RTX 4080 (32GB)&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;训练时间&lt;/strong&gt;：大概两天&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;训练过程&lt;/h3&gt;
&lt;p&gt;训练 loss 曲线和 TensorBoard 记录同步在 ModelScope 仓库的 &lt;code&gt;logs/&lt;/code&gt; 目录下。&lt;/p&gt;
&lt;h3&gt;效果&lt;/h3&gt;
&lt;p&gt;说实话，效果一般般。毕竟是 235M 的小模型，不能指望太多。但基本的对话还是能进行的，而且推理速度还不错。&lt;/p&gt;
&lt;h2&gt;性能数据&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;项目&lt;/th&gt;
&lt;th&gt;数值&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;参数量&lt;/td&gt;
&lt;td&gt;235M&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;FP32 内存&lt;/td&gt;
&lt;td&gt;~900MB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;FP16 内存&lt;/td&gt;
&lt;td&gt;~450MB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CPU 推理&lt;/td&gt;
&lt;td&gt;~30 tokens/s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GPU 推理&lt;/td&gt;
&lt;td&gt;~200 tokens/s&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h2&gt;如何使用&lt;/h2&gt;
&lt;h3&gt;安装&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;git clone https://github.com/shironekoalice/Loftey.git
cd loftey
pip install -r requirements.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;下载模型&lt;/h3&gt;
&lt;p&gt;ModelScope：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;from modelscope import snapshot_download
model_dir = snapshot_download(&apos;LightNeko/loftey-mini-235m&apos;)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;HuggingFace：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;from huggingface_hub import snapshot_download
model_dir = snapshot_download(repo_id=&apos;Zeppesey/loftey-mini-235m&apos;)
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;推理示例&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;from transformers import AutoTokenizer
from model import LofteyForCausalLM

model = LofteyForCausalLM.from_pretrained(&apos;models&apos;)
tokenizer = AutoTokenizer.from_pretrained(&apos;models&apos;)

prompt = &quot;&amp;lt;|im_start|&amp;gt;user\n你好&amp;lt;|im_end|&amp;gt;\n&amp;lt;|im_start|&amp;gt;assistant\n&quot;
input_ids = tokenizer.encode(prompt, return_tensors=&apos;pt&apos;)
output = model.generate(
    input_ids,
    max_new_tokens=100,
    temperature=0.7,
    top_k=50,
    top_p=0.95
)
response = tokenizer.decode(output[0], skip_special_tokens=True)
print(response)
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;开源地址&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;GitHub: https://github.com/shironekoalice/Loftey&lt;/li&gt;
&lt;li&gt;ModelScope: https://www.modelscope.cn/models/LightNeko/loftey-mini-235m&lt;/li&gt;
&lt;li&gt;HuggingFace: https://huggingface.co/Zeppesey/loftey-mini-235m&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;总结&lt;/h2&gt;
&lt;p&gt;这个项目主要是为了学习。如果你也在学习大模型，希望这篇文章能给你一些参考。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;本文同步自我的微信公众号「希赛克珑CylonX」，如果觉得有帮助，欢迎点赞、在看、转发。&lt;/p&gt;
&lt;/blockquote&gt;
</content:encoded></item><item><title>分享初次构建一个 MoE 大语言模型的部分过程</title><link>https://neko.aliceneko.xyz/posts/moe-llm-build-1/</link><guid isPermaLink="true">https://neko.aliceneko.xyz/posts/moe-llm-build-1/</guid><description>目标是构建一个 ~0.8B 参数的 Decoder-only 语言模型，融入 GQA、RoPE、MoE 等当前主流设计。记录踩过的坑：数据污染、模型&quot;假死&quot;、被忽略的传参。</description><pubDate>Thu, 11 Sep 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;在开始之前，我先快速介绍一下模型所选择的技术栈。我的目标是构建一个 ~0.8B 参数的 Decoder-only 语言模型，并融入一些当前主流的设计。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;核心架构&lt;/strong&gt;：Decoder-only Transformer，类似 GPT 和 Llama。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;超参数&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;隐藏层维度 hidden_size = 2048&lt;/li&gt;
&lt;li&gt;隐藏层数量 num_hidden_layers = 8&lt;/li&gt;
&lt;li&gt;中间层维度 intermediate_size = 5632&lt;/li&gt;
&lt;li&gt;词表 vocab_size = 6400&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;核心组件&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;注意力机制 (Attention)&lt;/strong&gt;：我选择了&lt;strong&gt;分组查询注意力 (GQA)&lt;/strong&gt;（num_attention_heads=16, num_key_value_heads=8）。这是一个在性能和推理效率之间取得绝佳平衡的选择，可以显著降低 KV 缓存的显存占用。同时，加入了 Flash Attention。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;位置编码 (RotaryEmbedding)&lt;/strong&gt;：我采用了旋转位置编码 &lt;strong&gt;(RoPE)&lt;/strong&gt;。其优秀的长度外推性和对相对位置的建模能力，使其成为当前 Decoder-only 模型的标配。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;混合专家 (MoE)&lt;/strong&gt;：采用了 &lt;strong&gt;MLP 层与 MoE 层交替&lt;/strong&gt; 的结构。我的模型中，偶数层是标准的门控线性单元（SwiGLU）MLP，奇数层则是 MoE 层。每个 MoE 层包含 4 个专家，并在推理时选择 Top-2。这种设计能在不显著增加推理计算量（FLOPs）的前提下，大幅扩充模型的总参数量，提升其知识容量。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;先说说我目前遇到的一些问题吧。&lt;/p&gt;
&lt;h2&gt;1. ValueError 与长度不匹配&lt;/h2&gt;
&lt;p&gt;我一开始让 LLMDataset 只对文本进行编码和截断，而将填充（Padding）的任务交给了 DataCollatorForLanguageModeling。这是一个理论上最高效的&quot;动态填充&quot;方案。&lt;/p&gt;
&lt;p&gt;训练启动时，遇到了：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ValueError: expected sequence of length X at dim 1 (got Y)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;经过排查，发现是 LLMDataset 返回的字典中包含了 &lt;code&gt;labels&lt;/code&gt; 键，这与 DataCollatorForLanguageModeling 的内部期望产生了冲突，导致其填充逻辑失败。&lt;/p&gt;
&lt;p&gt;为了快速让训练跑起来，我采取了一种最稳健但效率较低的策略：在 LLMDataset 的 &lt;code&gt;__getitem__&lt;/code&gt; 中，就强制对所有样本进行 &lt;code&gt;padding=&apos;max_length&apos;&lt;/code&gt;，并换回了简单的 DefaultDataCollator。这确保了每个样本长度绝对一致，虽然牺牲了效率，但保证了稳定性。&lt;/p&gt;
&lt;h2&gt;2. 模型&quot;假死&quot;&lt;/h2&gt;
&lt;p&gt;在训练了 2 万步后，我尝试了一下推理。然而，模型对任何输入都只会回答句号、逗号或换行符。eval_loss 看起来很不错，我猜测模型实际上已经&quot;崩溃&quot;了。&lt;/p&gt;
&lt;p&gt;感觉可能是数据集的问题。通过审查 LLMDataset 和 DefaultDataCollator 的组合，我发现了两个潜在的问题：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;数据污染&lt;/strong&gt;：数据集中可能存在大量空文本行，导致模型学到了&quot;无输入即无输出&quot;的模式。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;错误的训练目标&lt;/strong&gt;：我的 labels 与 input_ids 完全相同，这&lt;strong&gt;强迫模型去预测句首的 &lt;code&gt;&amp;lt;s&amp;gt;&lt;/code&gt; (BOS) token&lt;/strong&gt;。这是一个不可能完成的任务（因为 &lt;code&gt;&amp;lt;s&amp;gt;&lt;/code&gt; 前没有任何上下文），这种错误的梯度信号很可能污染了整个学习过程，让模型最终选择了输出高频标点这种&quot;躺平&quot;策略来最小化平均损失。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;解决方案&lt;/strong&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;重写 LLMDataset&lt;/strong&gt;：加入了严格的文本过滤逻辑，去除所有空行和过短的文本。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;回归 DataCollatorForLanguageModeling&lt;/strong&gt;：确保 LLMDataset 只返回 &lt;code&gt;{&quot;input_ids&quot;: ...}&lt;/code&gt;，将 labels 的创建和正确的左移操作，完全交给这个专业的 DataCollator。这个组合最终被证明是&lt;strong&gt;既高效又正确&lt;/strong&gt;的。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;3. 一个被意外忽略的传参&lt;/h2&gt;
&lt;p&gt;我的 DecoderLayer.forward 的签名：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 错误的 DecoderLayer.forward 签名
def forward(self,
            hidden_states: torch.Tensor,
            past_key_value: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
            use_cache: bool = False
            ) -&amp;gt; Tuple[torch.Tensor, ...]:
    # ...
    # 它只接收了最基本的三个参数
    # ...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它在内部调用 self.self_attn 时，自然也是这样传递的:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hidden_states, present_key_value = self.self_attn(
    hidden_states=hidden_states,
    past_key_value=past_key_value,
    use_cache=use_cache
)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而 &lt;code&gt;generate&lt;/code&gt; 函数在工作时，还依赖 &lt;code&gt;attention_mask&lt;/code&gt; 和 &lt;code&gt;position_ids&lt;/code&gt; 这两个参数来正确管理 KV 缓存。&lt;/p&gt;
&lt;p&gt;此时 DecoderLayer.forward &lt;strong&gt;没有&lt;/strong&gt;在其参数签名中接收 &lt;code&gt;attention_mask&lt;/code&gt; 和 &lt;code&gt;position_ids&lt;/code&gt;，更没有把它们传递给底层的 Attention.forward。&lt;/p&gt;
&lt;p&gt;因为 Attention 层没有收到正确的 attention_mask 和 position_ids，它内部的 KV 缓存行为在 generate 的复杂调用流程中出现了未定义的行为，最终在某个环节返回了 (None, None)。都加上就解决了：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;attention_mask&lt;/strong&gt;：在 generate 的每一步，这个 mask 都会被重新计算和传递，以确保新生成的 token 不会关注到未来的 token，同时所有 token 都不会关注到 padding 位。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;position_ids&lt;/strong&gt;：这对于 KV 缓存至关重要。它告诉模型当前正在计算的 token 在整个序列中的&lt;strong&gt;绝对位置&lt;/strong&gt;。例如，在生成第 10 个 token 时，position_ids 会告诉 RotaryEmbedding (RoPE) 应该使用第 10 个位置的旋转矩阵，并告诉 Attention 层应该将新的 Key 和 Value 存放到缓存的第 10 个位置。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;暂时没发现其他问题了，目前在训练中，未完待续~&lt;/p&gt;
&lt;p&gt;就先这样，欢迎讨论~&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;本文同步自我的微信公众号「希赛克珑CylonX」，如果觉得有帮助，欢迎点赞、在看、转发。&lt;/p&gt;
&lt;/blockquote&gt;
</content:encoded></item></channel></rss>