<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>残差流 on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/tags/%E6%AE%8B%E5%B7%AE%E6%B5%81/</link>
    <description>Recent content in 残差流 on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/tags/%E6%AE%8B%E5%B7%AE%E6%B5%81/</link>
    </image>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <lastBuildDate>Thu, 19 Nov 2026 00:00:00 +0000</lastBuildDate>
    <atom:link href="https://blog.lvxinrong.com/tags/%E6%AE%8B%E5%B7%AE%E6%B5%81/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>当权重也开始需要一种高级语言</title>
      <link>https://blog.lvxinrong.com/ai/when-weights-need-a-high-level-language/</link>
      <pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
      <guid>https://blog.lvxinrong.com/ai/when-weights-need-a-high-level-language/</guid>
      <description>从残差流的数据总线比喻出发，讨论通道分组、条件计算与高级权重语言：如何把不可读的数值张量，逐步变成可解释、可编辑、可回溯的能力模块。</description>
      <content:encoded><![CDATA[<p>今天和 Kimi 脑暴，从 DeepSeek 的配置聊到了残差流，又从残差流聊到了通道划分，最后聊到了一个有点远的问题：<strong>如果权重也是一种语言，它的高级形式会是什么？</strong></p>
<p>这些想法还没有经过实验验证，但背后其实有一条很连贯的主线：</p>
<blockquote>
<p><strong>怎样让有限的残差流承载更多有效的计算？又怎样让这些计算从不可读的数值组合，逐渐变成可解释、可编辑、可回溯的能力模块？</strong></p>
</blockquote>
<p>这篇文章先把这条思路留下来。</p>
<h2 id="一残差流更像-llm-的数据总线">一、残差流更像 LLM 的数据总线</h2>
<p>我之前理解残差流，更多停留在 shape 上：不同组件之间传递的张量，为什么最后还能做加法？</p>
<p>现在我觉得，残差流更像是 LLM 这个操作系统里的<strong>逻辑数据总线</strong>。</p>
<p>假设一个张量的形状是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">(B, T, C)
</span></span></code></pre></div><p>其中 <code>B</code> 是 batch，<code>T</code> 是当前序列位置数，<code>C</code> 是残差流的宽度，也就是 <code>hidden_dim</code>。</p>
<p>在标准的 Pre-Norm Block 中：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">x = x + Attention(norm(x))
</span></span><span class="line"><span class="cl">x = x + FFN(norm(x))
</span></span></code></pre></div><p>Attention 和 FFN 最终都要把结果投影回 <code>C</code>，这样才能与原来的 <code>x</code> 做加法。</p>
<p>但它们内部完全可以自由变化：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Attention：拆成多个 head，做注意力计算，再合并投影回来
</span></span><span class="line"><span class="cl">FFN：先扩展到更大的中间维度，经过激活，再投影回来
</span></span><span class="line"><span class="cl">MoE：把 token 分给不同专家，再把专家输出组合回来
</span></span></code></pre></div><p>所以，残差流的宽度约束的是<strong>组件之间的接口</strong>，并不限制组件内部怎样计算。</p>
<p>这个比喻很好用：</p>
<ul>
<li>权重像程序；</li>
<li>残差流像运行时传递状态的数据总线；</li>
<li>各组件从总线上读取、计算，再按规定接口把增量写回去。</li>
</ul>
<p>这里的 <code>hidden_dim</code> 是逻辑特征宽度，不等于硬件显存带宽。数据总线只是帮助理解接口和数据流的比喻，不能直接拿来做硬件性能换算。</p>
<h2 id="二如果数据总线不能无限加宽接下来怎么办">二、如果数据总线不能无限加宽，接下来怎么办</h2>
<p>现在的模型看起来越来越复杂，但大多数仍然没有逃出 Transformer 的主干。</p>
<p>真正变化的是主干内部：Attention 怎样压缩，KV 怎样表示，FFN 是否改成 MoE，位置如何编码，上下文如何扩展，量化与推理成本怎样控制。</p>
<p>但有一个问题始终存在：<code>hidden_dim</code> 不可能无限增大。</p>
<p>它受到硬件、算力、显存、通信和训练成本的共同制约。于是我开始想，除了不断加宽这条数据总线，还有一个方向：<strong>对这条总线进行更精细的划分。</strong></p>
<p>假设 <code>C=256</code>，是否一定要用一个统一的 FFN 处理全部 256 维？能不能把它拆成 4 组，每组 64 维，分别经过不同的 FFN？</p>
<p>形式上看，它可以写成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">x₁, x₂, x₃, x₄ = channel_split(x)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">y₁ = FFN_1(x₁)
</span></span><span class="line"><span class="cl">y₂ = FFN_2(x₂)
</span></span><span class="line"><span class="cl">y₃ = FFN_3(x₃)
</span></span><span class="line"><span class="cl">y₄ = FFN_4(x₄)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">y = concat(y₁, y₂, y₃, y₄)
</span></span><span class="line"><span class="cl">x = x + out_proj(y)
</span></span></code></pre></div><p>如果不同通道组真的可以承担不同功能，那么通道划分就可能带来一种新的条件计算结构。</p>
<p>通道划分越细，理论上可组织的并行组件就越多。一个分支处理位置，一个分支处理语义，另一个分支处理其他模式，听起来很有吸引力。</p>
<p>但这里有一个不能跳过的问题：<strong>语义真的会按照我们指定的通道号自然隔离吗？</strong></p>
<h2 id="三通道可以切开语义未必按切线分开">三、通道可以切开，语义未必按切线分开</h2>
<p>残差流中的每个通道只是一个特征维度。</p>
<p>Linear、Attention、FFN 都在不断混合这些维度，所以位置、句法、语义、数值和上下文很可能是分布式表示的，而不是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">前 64 维负责位置
</span></span><span class="line"><span class="cl">接下来 128 维负责语义
</span></span><span class="line"><span class="cl">剩下维度负责其他能力
</span></span></code></pre></div><p>如果我们硬性地预先指定每个分组的职责，可能会切断跨组信息交流。</p>
<p>尤其是位置。RoPE 作用在 Q/K 的部分通道上，不是简单地在残差流里划出一块区域，交给一个“位置 FFN”。如果要为位置专门划分通道，需要先定义：位置如何进入注意力，怎样与内容交互，怎样通过实验判断 64 维是否真的够用。</p>
<p>更合理的做法也许不是先规定每组负责什么，而是：</p>
<ol>
<li>先让模型自己学习；</li>
<li>用探针检查不同通道组是否自然形成分工；</li>
<li>再比较硬分组、随机分组、可学习分组和共享混合的效果。</li>
</ol>
<p>分组结构也不等于整个模型都没有先后依赖。通常仍然需要：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">分支处理 → 合并 → 进入下一个 Block
</span></span></code></pre></div><p>而且分支越多，不一定越快。每个分支的 GEMM 会变小，硬件利用率可能下降；输出保存、合并与同步也有成本。小模型上，调度开销甚至可能比计算本身更显眼。</p>
<p>所以要把两个问题分开：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">分支结构是否有效
</span></span><span class="line"><span class="cl">分支结构是否提速
</span></span></code></pre></div><p>它们不是一回事。</p>
<h2 id="四一个值得验证的小实验">四、一个值得验证的小实验</h2>
<p>如果以后要验证这个想法，我会先做一版非常克制的对照实验。</p>
<p>比如固定 <code>C=256</code>，保留以下三组：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Baseline：
</span></span><span class="line"><span class="cl">普通 Dense FFN
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Grouped：
</span></span><span class="line"><span class="cl">4 组 × 64 维，每组独立 FFN，最后 concat + out_proj
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Grouped + Shared：
</span></span><span class="line"><span class="cl">4 组 × 64 维，同时保留一个共享 FFN 或周期性的全局混合
</span></span></code></pre></div><p>实验时尽量控制：</p>
<ul>
<li>相同训练数据、训练步数和优化器；</li>
<li>尽量匹配总参数量和激活计算量；</li>
<li>相同的位置任务、语义任务和 held-out 数据；</li>
<li>相同的测量环境。</li>
</ul>
<p>然后分别观察：</p>
<ul>
<li>held-out loss 和任务能力；</li>
<li>位置外推能力；</li>
<li>语义任务表现；</li>
<li>参数量与激活 FLOPs；</li>
<li>实际吞吐、显存和分支调度开销；</li>
<li>不同随机种子的波动。</li>
</ul>
<p>如果想研究“64 维是否足够”，也只能得出当前模型、数据与任务范围内的结论，不能直接推广成所有模型都只需要 64 维。</p>
<p>先在小模型上验证结构，再决定是否扩大到 0.6B。0.6B 可以作为实验床，但如果从随机初始化完整预训练，也不能把它当成没有成本的小玩具。</p>
<p>我认为这个实验最有价值的地方，不是预先证明“切分一定更好”，而是回答：</p>
<blockquote>
<p><strong>在相同参数与计算预算下，通道分组能否形成比统一 FFN 更有效的条件计算结构？</strong></p>
</blockquote>
<p>即使最后发现硬切分无效，也能帮助我们理解：问题究竟来自分组本身，还是跨组通信不足，或者只是硬件调度代价太高。</p>
<h2 id="五从通道分组想到权重的高级语言">五、从通道分组，想到权重的“高级语言”</h2>
<p>这条思路继续往前，就碰到了另一个更大的问题：权重到底能不能被读懂？</p>
<p>今天的权重，对大多数人来说像机器码。单个权重给一个数值，我们很难说出它意味着什么。</p>
<p>但单独看 CPU 中的一个晶体管开和关，也看不出什么意义。只有一组晶体管组成与门、或门和触发器以后，计算结构才开始变得可理解。</p>
<p>权重也许有类似的层级：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">单个权重
</span></span><span class="line"><span class="cl">→ 权重向量
</span></span><span class="line"><span class="cl">→ 激活方向
</span></span><span class="line"><span class="cl">→ 神经元或注意力头
</span></span><span class="line"><span class="cl">→ 跨层计算电路
</span></span><span class="line"><span class="cl">→ 可观察的模型行为
</span></span></code></pre></div><p>一组权重的高维组合，可能形成一个语义特征。例如某组参数满足：</p>
<ul>
<li>某类输入出现时，对应激活明显增强；</li>
<li>其他输入出现时，激活很弱；</li>
<li>压低这个方向后，某个行为明显消失。</li>
</ul>
<p>那么这组参数或这个激活方向，就可能是某种可解释的“门电路”。</p>
<p>但这里仍然需要谨慎：<strong>探针相关不等于因果机制。</strong></p>
<p>一个方向与某类行为相关，不代表它就是这个行为的开关。还需要做消融、干预和因果验证，确认它是否真正参与了对应计算，并检查其他能力有没有被误伤。</p>
<p>语义也可能叠加在同一个神经元或方向上，不一定存在一一对应的语义开关。</p>
<p>所以，可解释的单位未必只是“几个权重”，还可能是：</p>
<ul>
<li>权重向量；</li>
<li>低秩子空间；</li>
<li>激活方向；</li>
<li>注意力头；</li>
<li>MLP 神经元组合；</li>
<li>跨层计算电路。</li>
</ul>
<h2 id="六高级权重语言可能不是把权重翻译成代码">六、高级权重语言，可能不是把权重翻译成代码</h2>
<p>如果机器码中的每条指令都有相对稳定的语义，而单个权重通常没有独立语义，那么所谓“高级权重语言”，大概率不是把每个参数翻译成一句自然语言。</p>
<p>它更可能是一种<strong>能力抽象</strong>。</p>
<p>我们不再主要描述：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">第 17 层第 386 个参数等于多少
</span></span></code></pre></div><p>而是描述：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">这个模型具有什么能力
</span></span><span class="line"><span class="cl">这个能力来自哪个模块、数据、训练或适配器
</span></span><span class="line"><span class="cl">怎样增加、限制、组合或撤销一个行为
</span></span><span class="line"><span class="cl">修改后需要满足哪些行为约束
</span></span></code></pre></div><p>一种未来的声明可能更像：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">capability JavaNullCheck {
</span></span><span class="line"><span class="cl">    implementation: adapter/java-null-v1
</span></span><span class="line"><span class="cl">    verify: tests/java-null-check
</span></span><span class="line"><span class="cl">    preserve: general-code-baseline
</span></span><span class="line"><span class="cl">    rollback: disable adapter/java-null-v1
</span></span><span class="line"><span class="cl">}
</span></span></code></pre></div><p>这时，开发者操作的是：</p>
<ul>
<li>能力模块；</li>
<li>架构与配置；</li>
<li>数据与训练血缘；</li>
<li>LoRA / adapter / task vector；</li>
<li>行为约束；</li>
<li>评估协议；</li>
<li>checkpoint、diff 与回滚记录。</li>
</ul>
<p>编译器可能对应训练、微调、合并、剪枝和权重编辑算法；机器码对应权重张量；运行时对应推理引擎；版本控制对应 checkpoint、adapter diff 和数据血缘。</p>
<p>而评估系统则像类型系统和单元测试：检查我声明的能力是否真的被满足。</p>
<p>最难的不是发明一套语法，而是建立可靠的语义保持：</p>
<blockquote>
<p><strong>我只想增加能力 A，编译之后，模型是否真的增加了 A，同时没有破坏 B、C、D？</strong></p>
</blockquote>
<p>如果这个问题不能回答，所谓权重编程仍然只是碰运气。</p>
<h2 id="七它未必取代传统代码但会改变工程分工">七、它未必取代传统代码，但会改变工程分工</h2>
<p>权重语言擅长感知、语言、图像和模糊模式，也擅长表达那些很难逐条写成规则的隐式行为。</p>
<p>传统代码擅长精确控制、确定性算法、权限、事务、并发和资源管理。</p>
<p>所以我更倾向于认为，未来是一种混合结构：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">权重负责可学习的行为
</span></span><span class="line"><span class="cl">代码负责控制、验证和确定性边界
</span></span></code></pre></div><p>高级权重语言真正可能改变的，不是让我们彻底抛弃传统编程，而是让模型能力开始像普通工程模块一样，被组织、编辑、验证和回滚。</p>
<h2 id="八把这几件事放回同一张图">八、把这几件事放回同一张图</h2>
<p>今天这些脑暴看起来跳得有点远，但其实能连成一条线：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">残差流是数据总线
</span></span><span class="line"><span class="cl">→ 数据总线的宽度有限
</span></span><span class="line"><span class="cl">→ 可以尝试通道分组与条件计算
</span></span><span class="line"><span class="cl">→ 分组或激活方向可能形成可解释特征
</span></span><span class="line"><span class="cl">→ 可解释特征可能进一步成为可编辑的能力模块
</span></span><span class="line"><span class="cl">→ 高级权重语言需要评估、版本和回滚作为基础
</span></span></code></pre></div><p>这条线上，每一步都有大量未验证的问题：</p>
<ul>
<li>硬通道分组是否有效？</li>
<li>分组会不会自然形成语义分工？</li>
<li>激活方向与语义之间是否存在稳定的因果关系？</li>
<li>编辑一个子空间后，其他能力会不会受损？</li>
<li>评估能否真正约束能力编译的结果？</li>
</ul>
<p>所以这篇文章不是结论，只是一张后续研究地图。</p>
<p>但我越来越觉得，真正值得追求的并不只是“把模型训练出来”，而是逐渐获得这几种能力：</p>
<blockquote>
<p><strong>看懂它怎样计算，验证它为什么有效，解释它形成了什么特征，最后再用可控的方式编辑它。</strong></p>
</blockquote>
<p>如果哪一天这些能力真的连成闭环，权重就不只是训练结束后保存下来的一堆数字，而可能成为一种全新的工程材料。</p>
<p>而我们现在从残差流、通道分组和评估系统开始做的小实验，也许就是在为那一天的“高级权重语言”，先补上几个最底层的接口。</p>
]]></content:encoded>
    </item>
  </channel>
</rss>
