从一个地狱笑话看大模型的推理机制

克矛發表於 2026-3-18 17:10:00

从一个地狱笑话看大模型的推理机制

作者:张富春(ahfuzhang)，转载时请注明作者和引用链接，谢谢！
<ul>
<li>cnblogs博客</li>
<li>zhihu</li>
<li>Github</li>
<li>公众号:一本正经的瞎扯 
<img alt="" loading="lazy" src="https://img2022.cnblogs.com/blog/1457949/202202/1457949-20220216153819145-1193738712.png" class="lazyload"></li>
</ul>
<hr>
<h1>从一个地狱笑话看大模型的推理机制</h1>
我大约在七年前就看见了这个段子：
<blockquote>
三个苹果平均分给五个小朋友，只能切两刀，应该怎么切？
</blockquote>
评论区置顶的内容是这么写的：
<blockquote>
一刀捅死一个小朋友，然后剩下的三个小朋友每人一个苹果。
</blockquote>
我都快笑死过去了……
然后一直以来我就把这个当成地狱笑话，在很多聚会上拿来暖场。
<h1 id="真的能做到">真的能做到</h1>
直到上周，我突然想起，可以用这个来调戏一下 AI。
没想到 Gemini 的回答让我大吃一惊：
<blockquote>
这是一个经典的思维急转弯或趣味数学题。如果严格按照“物理空间”上的两刀来平分，可以尝试以下这种巧妙的切法：
<h3 id="解决思路">解决思路</h3>
要将 3 个苹果平均分给 5 个小朋友，每个小朋友应该得到 3/5 个苹果。
<ol>
<li>第一步：排成一列 将三个苹果紧挨着排成一排（水平放置）。</li>
<li>第一刀：切掉每个苹果的 2/5 在距离这排苹果左侧 2/5 的位置，垂直向下切第一刀。</li>
</ol>
<ul>
<li>这时你会得到 3 个大小为 2/5 的“苹果块”。</li>
<li>剩下的部分是 3 个大小为 3/5 的苹果。</li>
</ul>
<ol start="3">
<li>第二刀：平分剩下的部分 （其实此时已经有 3 个小朋友可以直接拿到那 3 个 3/5 的大块了）。剩下的 3 个 2/5 小块，我们需要把它们分给剩下的 2 个小朋友。将这 3 个小块并排，在它们总长度的 1/2 处（或者说从某个苹果块的中间）切下第二刀，使这 3 个小块重新组合成两个 3/5 的份额。</li>
</ol>
</blockquote>
关键点是要跳出题目的框框，把刀看成是很长的铡刀！
我画个图来解释：
<ul>
<li>方法一
<ul>
<li>三个小朋友得到 <code>五分之三</code> 块苹果</li>
<li>另外两个小朋友得到 <code>五分之二</code> 加 <code>五分之一</code> 块苹果</li>
</ul>
</li>
</ul>
<img alt="切苹果" loading="lazy" src="https://img2024.cnblogs.com/blog/1457949/202603/1457949-20260318170317772-829215521.png" class="lazyload">
<ul>
<li>方法二
<ul>
<li>三个小朋友得到 <code>五分之三</code> 块苹果</li>
<li>另外两个小朋友得到三块 <code>五分之一</code> 大小的苹果</li>
</ul>
</li>
</ul>
<img alt="切苹果2" loading="lazy" src="https://img2024.cnblogs.com/blog/1457949/202603/1457949-20260318170341707-415057584.png" class="lazyload">
从回答的质量看：Gemini > DeepSeek > ChatGPT(数值计算错了) > Claude(完全乱说)
<h1 id="用本地大模型测试">用本地大模型测试</h1>
正好我在测试本地大模型：
<pre><code class="language-bash">ollama run glm-4.7-flash:q8_0
</code></pre>
然后给这个 GLM 模型提了这个问题。
模型开始了漫长的思考过程，详细展示了思考的每一步。
在这个过程中发现了两个问题：
<h2 id="ai-的安全问题不容忽视">AI 的安全问题不容忽视</h2>
模型 glm-4.7-flash:q8_0 在回答中有这样一段思考过程：
<img alt="llm_thinking" loading="lazy" src="https://img2024.cnblogs.com/blog/1457949/202603/1457949-20260318170417393-845271474.jpg" class="lazyload">
AI 在思考的时候，并不介意以杀人的方式来解决问题。
需要一些机制，来避免 AI 朝对人类有危害的方向去思考！杀死人类这种事情，AI 想都别想！
<h2 id="思考过程中存在太多的浅尝辄止">思考过程中存在太多的浅尝辄止</h2>
可以看见模型思考了很多种可能，有的时候几乎就要找到答案了，但是马上又否定掉了自己：
<pre><code class="language-text">Thinking...
1.**分析用户的请求：**
* **问题：** 有三个苹果要平均分给五个小朋友。
* **限制：** 只能切两刀。
* **目标：** 解释如何在不违反限制的情况下做到这一点。

2.**拆解数学问题：**
* 总份数 = 5。
* 物品总数 = 3。
* 每个小朋友分到的份数 = $3 / 5$。

3.**头脑风暴潜在的解决方案：**

* *方法一：切分苹果。*
 * 我能切出3/5份吗？
 * 如果我切出一块3/5，还剩2/5。
 * 如果我切出2/5，还剩1/5。
 * 如何从这些分数得到整数刀数？
 * 想象切成5份。这需要4刀（十字切）。
 * 我们只有2刀。

* *方法二：切分小朋友（横向思维）。*
 * 等等，提示说要把*苹果*分给*小朋友*。通常，意味着要切苹果。
 * 但是，经典的横向思维谜题通常涉及切*东西*而不是切*苹果*。
 * 再看一遍限制条件。“三个苹果……只能切两刀。”

* *方法三：把苹果切开，然后重新排列？*
 * 比如把一个苹果切成5份？不，那需要太多刀了。

* *方法四：切分容器或切分小朋友（再次检查谜题逻辑）。*
 * 这个谜题通常有个把戏。
 * “切两刀”的限制可能适用于一个特定的部分，或者有一个陷阱。
 * 然而，关于“把蛋糕/苹果分给X人”的标准横向思维答案通常是关于切蛋糕，但这里的对象是苹果。

* *重新评估物理上的3/5分割：*
 * 一个苹果是1。1/5是 $1/5$。
 * 要得到 $3/5$：切出 $1/5$，切出 $1/5$，切出 $1/5$？不。
 * 要得到 $3/5$：把苹果切到 $1/5$，再切到 $1/5$？不。

* *重新考虑标准的横向思维答案：*
 * 通常，答案涉及把一块*蛋糕*切成5份，把*蛋糕*切成5份，然后合并？不，那是3个苹果。
 * 如果我把苹果放在一个锅里呢？不。
</code></pre>
为什么模型会有这样的行为呢？我带着这些好奇询问了 ChatGPT:
<h1 id="为什么某个思考方向会被过早否定">为什么某个思考方向会被过早否定？</h1>
我问了如下问题:
<pre><code class="language-text">我发现模型做了非常多方向的尝试，但是最后又否定了自己的思考方向。
有的思考方向本来已经接近正确了，但是又自己否定了这个方向。

为什么某个思考方向会被过早否定？这是否是神经网络的损失函数没选择好导致的？
</code></pre>
回答如下：(照搬 ChatGPT 的回答)
你看到的现象，本质上是：模型在生成“思考文本”时，并不是在真正做一个稳定的符号搜索器，而是在一步一步预测“下一段看起来像合理思考的话”。所以它会出现：
<ul>
<li>某个方向刚接近正确，又被自己打回去</li>
<li>对同一个假设反复立案、反复推翻</li>
<li>其实已经有足够线索了，但没有“锁定”那个方向</li>
<li>更像是在写一段“像推理的文字”，而不是执行一个严格的搜索算法</li>
</ul>
这背后有几层原因。
<h2 id="1-语言模型的思考不是显式搜索树">1. 语言模型的“思考”不是显式搜索树</h2>
经典搜索算法会这样做：
<ul>
<li>保存多个候选分支</li>
<li>给每个分支一个分数</li>
<li>回溯</li>
<li>比较</li>
<li>保留最好分支</li>
</ul>
但普通自回归语言模型不是这样。它通常只是：
<ul>
<li>读到当前上下文</li>
<li>预测下一个 token</li>
<li>再基于新上下文继续预测</li>
</ul>
所以它对“我刚才这个方向值不值得继续”并没有一个显式的、稳定的全局状态管理器。 
它更像是局部启发式前进。
结果就是：某条线索在第 20 个 token 时看起来很合理，到第 40 个 token 时，另一种表述模式突然更高概率，于是模型就“转向”了。
<h2 id="2-训练目标优化的是下一个-token-概率不是不要过早放弃正确分支">2. 训练目标优化的是“下一个 token 概率”，不是“不要过早放弃正确分支”</h2>
预训练时，核心目标一般是 next-token prediction。 
这会鼓励模型学会：
<ul>
<li>哪种解释常见</li>
<li>哪种推理语言模式更像训练数据里的高质量答案</li>
<li>哪种后续文本更流畅、更像“严谨分析”</li>
</ul>
但它不直接优化下面这些目标：
<ul>
<li>保持一个 promising hypothesis 不被轻易丢掉</li>
<li>在多个假设之间做长期 credit assignment</li>
<li>显式维护 search frontier</li>
<li>在接近正确时继续深入而不是切走</li>
</ul>
所以你说“是不是损失函数问题”，答案是：
部分是。 
因为标准语言建模损失并不直接奖励“搜索过程的稳定性”和“分支保真度”。 
但这只是问题的一部分，不是唯一根因。
<h2 id="3-rl--sft-会进一步强化像样的推理文本不一定强化真实有效的搜索行为">3. RL / SFT 会进一步强化“像样的推理文本”，不一定强化“真实有效的搜索行为”</h2>
很多模型后训练时，会学到一种“好学生式推理模板”：
<ul>
<li>先分析需求</li>
<li>再列方法一、方法二、方法三</li>
<li>再自我检查</li>
<li>再谨慎否定不严谨的方向</li>
</ul>
这种风格看起来很认真，但副作用是：
它可能过度偏向“谨慎否定”
模型会觉得：
<ul>
<li>“这个方向不够稳，我先否了”</li>
<li>“这个答案像是脑筋急转弯，我不要太快跳过去”</li>
<li>“我要表现得严谨，不要太早接受看起来取巧的答案”</li>
</ul>
于是它会把本来接近正确的横向思维分支，提前判成“不够正统”。 
换句话说，模型有时不是因为不会，而是因为它学到了某种文本层面的审慎人格，这会干扰问题求解。
<h2 id="4-局部概率最大化会导致离正确更近不等于下一步更容易生成">4. 局部概率最大化，会导致“离正确更近”不等于“下一步更容易生成”</h2>
这是个很关键的点。 
对人来说，某个方向“接近正确”意味着应该继续挖。 
但对语言模型来说，“接近正确”不一定意味着它的下一串 token 概率更高。 
例如在你给的例子里：
<ul>
<li>“切小朋友”这种方向属于典型脑筋急转弯套路</li>
<li>但当前上下文又在努力表现“认真数学分析”</li>
<li>所以“继续严肃地讨论分数切法”在语言分布上可能比“突然承认这是个文字游戏”更顺滑</li>
</ul>
于是模型会倾向于继续生成“看起来像严谨分析”的内容，而不是跳到真正解法。 
也就是说：
正确性不是它唯一的局部驱动力，语言连续性也是。
<h2 id="5-模型缺少强约束的中间状态验证器">5. 模型缺少强约束的“中间状态验证器”</h2>
人类解题时，往往会有这种内部检查：
<ul>
<li>这个方向虽然怪，但它解释了“只能切两刀”这个限制</li>
<li>这个题像脑筋急转弯，不像标准分数切割题</li>
<li>因此这个方向优先级应该提高</li>
</ul>
但模型未必有一个独立模块，把这些线索聚合成：
<blockquote>
“横向思维解释的 posterior 已经高于数学切分解释了，应停止继续细抠后者。”
</blockquote>
没有这种强验证器时，它就会在多个风格之间漂移。
<h2 id="6-训练数据里思考文本本身就可能包含很多伪搜索痕迹">6. 训练数据里，“思考文本”本身就可能包含很多伪搜索痕迹</h2>
很多“推理过程”数据并不是真实的人类逐步搜索记录，而更像事后整理、模板化书写、或者蒸馏出来的解释文本。
这会导致模型学到的是：
<ul>
<li>“推理应该长这样”</li>
<li>而不是“真实搜索在内部应该怎么做”</li>
</ul>
因此它可能生成出很多看似合理的尝试与否定，但这些并不等价于真正高效的 problem solving。
<h2 id="7-这类题还特别容易触发过度理性化">7. 这类题还特别容易触发“过度理性化”</h2>
“三个苹果分给五个小朋友，只能切两刀”这种题，常见解法往往依赖：
<ul>
<li>重新解释“切两刀”的对象</li>
<li>利用叠放</li>
<li>利用榨汁</li>
<li>利用脑筋急转弯语义漏洞</li>
</ul>
而模型如果被训练得太偏“正统分析”，就会倾向于：
<ul>
<li>把题理解成严格的连续几何切割问题</li>
<li>反而排斥非标准解</li>
</ul>
这不是单纯的损失函数问题，而是任务分布偏置问题。 
模型先验认为：“这类问题通常应该用严谨数学分析”，于是把异类解法提前压掉了。
<hr>
<h2 id="8-所以为什么会过早否定">8. 所以，为什么会“过早否定”？</h2>
可以压缩成一句话： 
因为语言模型是在做局部概率驱动的文本展开，而不是显式、全局、可回溯的假设搜索；再叠加训练风格上的谨慎偏置，就很容易把接近正确但风格不主流的方向过早否掉。
<h2 id="8-这和损失函数有没有关系">8. 这和损失函数有没有关系？</h2>
有，但不能只怪损失函数。 
更准确地说，问题来自这几项的组合：
<ul>
<li>1）目标函数不匹配
<ul>
<li>next-token loss 不直接奖励“保持正确分支”。</li>
</ul>
</li>
<li>2）模型结构不匹配
<ul>
<li>没有显式搜索树、工作记忆、分支打分器、回溯机制。</li>
</ul>
</li>
<li>3）训练数据不匹配
<ul>
<li>“推理文本”不等于“真实求解轨迹”。</li>
</ul>
</li>
<li>4）后训练偏置
<ul>
<li>SFT / RL 可能奖励“谨慎、像样、规整”的思考表述，而不是最有效求解。</li>
</ul>
</li>
</ul>
<h2 id="9-如果想改进通常有哪些方向">9. 如果想改进，通常有哪些方向？</h2>
<ul>
<li>
显式搜索
<ul>
<li>比如 self-consistency、tree search、beam search、MCTS 风格外部控制。</li>
<li>让模型不只走一条线，而是真保留多个候选分支。</li>
</ul>
</li>
<li>
过程监督
<ul>
<li>不仅监督最终答案，还监督哪些中间步骤值得保留、哪些是否定过早。</li>
</ul>
</li>
<li>
verifier / critic
<ul>
<li>让一个额外模块评估：
<ul>
<li>当前分支是否解释了题目的关键限制</li>
<li>是否有更高价值的假设被过早丢弃</li>
</ul>
</li>
</ul>
</li>
<li>
工具化推理
<ul>
<li>把“生成思考文本”和“管理搜索状态”拆开。</li>
<li>一个模块负责提出假设，另一个模块负责记账、比较、回溯。</li>
</ul>
</li>
<li>
更好的 credit assignment
<ul>
<li>让训练真正奖励：
<ul>
<li>接近正确的分支被继续探索</li>
<li>错误分支被及时剪枝</li>
<li>不是只奖励最后写出来的那段文字</li>
</ul>
</li>
</ul>
</li>
</ul>
<h2 id="10-你的这个例子里模型具体哪里出了问题">10. 你的这个例子里，模型具体哪里出了问题？</h2>
它在中途其实已经触到了关键线索：
<ul>
<li>“经典横向思维谜题”</li>
<li>“切的对象不一定非得是苹果”</li>
<li>“这个题通常有个把戏”</li>
</ul>
这些都说明它的内部已经激活了正确模式。 
但接下来它又回到了“标准分数切法”的叙事轨道。
这通常说明：
<ul>
<li>正确模式被激活了</li>
<li>但没有足够强的机制把它“升格为当前主假设”</li>
<li>于是被更高概率的常规分析文本冲掉了</li>
</ul>
这很像搜索里启发函数弱、状态管理差，而不是单纯 loss 数值不对。
<h2 id="11-一个比较准确的结论">11. 一个比较准确的结论</h2>
你可以把它理解成：
不是“模型不会想”，而是“模型缺少像程序那样稳定地管理想法分支的能力”。
损失函数确实有锅，因为它没有直接优化“分支稳定性”和“搜索质量”； 
但更大的问题是：
<ul>
<li>表示形式不对</li>
<li>推理控制流不对</li>
<li>训练信号不对</li>
<li>后训练风格偏置也不对</li>
</ul>
所以这属于一个系统性问题，不是改一个 loss 就能彻底解决。
<h1 id="从-transformer-结构角度看为什么模型推理过程中容易自我推翻">从 Transformer 结构角度看，为什么模型推理过程中容易自我推翻</h1>
(照搬 ChatGPT 的回答)
从 Transformer 结构看，它容易“自我推翻”，核心原因是：
它没有一个像传统程序那样独立、持久、可检验的“推理状态机”。 
它只有一串 token，不断通过注意力去重新解释前文，然后预测下一个 token。 
所以它表面上像是在“沿着一个思路持续思考”，其实更接近于：
每一步都在用当前全文重新做一次局部最优续写。
这会天然带来“刚刚支持某个方向，下一句又把它否了”的现象。
<h2 id="1-transformer-没有显式的假设栈或搜索树">1. Transformer 没有显式的“假设栈”或“搜索树”</h2>
人在认真推理时，脑子里通常会有这种结构：
<ul>
<li>假设 A：按数学切分来做</li>
<li>假设 B：这是脑筋急转弯</li>
<li>当前更看好 B</li>
<li>暂时保留 A 以防万一</li>
<li>如果 B 能解释“只能切两刀”，就继续深挖</li>
</ul>
这其实已经像一个小型搜索树了。 
但普通 Transformer 并没有这种显式数据结构。 
它没有内建：
<ul>
<li>hypothesis stack</li>
<li>branch score table</li>
<li>backtracking pointer</li>
<li>durable working memory slots</li>
</ul>
它只有隐藏状态和 attention。 
所以“某个方向正在被认真保留”这件事，往往只是分布式地编码在激活里，而不是清晰地存成一个对象。 
结果就是：
<ul>
<li>某个方向刚刚被激活</li>
<li>下一步又被别的上下文模式盖过去</li>
<li>看起来就像“自己把自己否了”</li>
</ul>
<h2 id="2-每一层都在重新混合上下文不是单向锁定结论">2. 每一层都在重新混合上下文，不是单向锁定结论</h2>
Transformer 的每一层都会做两件事：
<ul>
<li>用 self-attention 从前文各处取信息</li>
<li>用 MLP 把这些信息非线性变换成新的表示</li>
</ul>
这意味着当前 token 的表示，不是“沿着一条固定思路向前推进”，而是每层都在做一次：
<blockquote>
“前文里哪些东西现在最 relevant？”
</blockquote>
而“relevant”是动态的。 
比如前一句刚写了：
<ul>
<li>“这可能是横向思维谜题” 
下一句生成时，attention 也许又更强地看向：</li>
<li>“平均分”</li>
<li>“3/5”</li>
<li>“只能切两刀”</li>
<li>“通常意味着切苹果”</li>
</ul>
于是表示空间里的重心就变了。 
也就是说，Transformer 不是先形成稳定的逻辑树，再往下展开； 
而是每一步都可能重新加权整段历史。 
所以它很容易出现：
<ul>
<li>前一步：横向思维很重要</li>
<li>后一步：还是数学切分更像“严谨分析”</li>
<li>再下一步：等等，这题又像脑筋急转弯</li>
</ul>
这就是你看到的摇摆。
<h2 id="3-attention-是软选择不是硬承诺">3. Attention 是软选择，不是硬承诺</h2>
self-attention 本质上是一个加权和 
这里的关键点是：
它不是在说“我决定采用假设 A，放弃假设 B”，而是在说：
<ul>
<li>给 A 一些权重</li>
<li>给 B 一些权重</li>
<li>给“谨慎表述模板”一些权重</li>
<li>给“数学分析套路”一些权重</li>
</ul>
也就是说，它是混合，不是离散决策。
这会导致一个很典型的问题：
<ul>
<li>某个正确方向并没有被彻底删除</li>
<li>但也没有被强力锁定</li>
<li>最终只是和其他模式一起平均进表示里</li>
</ul>
平均的结果就是： 
输出变成一种折中而摇摆的文本。 
所以它不是像程序那样：
<pre><code>if hypothesis_B_score > threshold:
commit(B)
</code></pre>
而更像：
<pre><code>representation = 0.35 * B + 0.40 * A + 0.25 * careful_reasoning_style
</code></pre>
这种“软混合”特别容易生成既提到正确方向、又马上撤回的内容。
<h2 id="4-残差连接让旧模式很难真正被清掉">4. 残差连接让旧模式很难真正被“清掉”</h2>
Transformer 有大量 residual connection，这意味着每一层不是推翻旧表示重来，而是在旧表示上叠加修正。 
好处是训练稳定、信息保留强。 
坏处是不同倾向会长期共存：
<ul>
<li>一个方向的痕迹还在</li>
<li>另一个方向的新信号也进来了</li>
<li>再加上“保持严谨”的写作模板也还在</li>
</ul>
结果就是表示里可能同时保留：
<ul>
<li>“这是数学题”</li>
<li>“这可能是脑筋急转弯”</li>
<li>“不要过早下结论”</li>
<li>“继续列举方案更像高质量推理”</li>
</ul>
所以输出常常变成一种内部拉扯后的折中产物。 
这在文本上就表现为“自我推翻”。
<h2 id="5-它的记忆是内容寻址不是变量式记忆">5. 它的“记忆”是内容寻址，不是变量式记忆</h2>
传统程序会有明确变量：
<pre><code>current_best_hypothesis = lateral_thinking
confidence = 0.72
</code></pre>
Transformer 没有这种天然变量。 
它依赖的是 distributed representation，也就是把信息分散在很多维度里。 
这类记忆的问题是：
<ul>
<li>不容易做离散更新</li>
<li>不容易精确比较两个假设谁更优</li>
<li>不容易长期保持某个中间结论不被污染</li>
</ul>
所以“我已经决定这题大概率是脑筋急转弯”这件事，未必能以一个稳定、可读、可锁定的方式存在。 
它更像一团高维倾向。 
而高维倾向很容易被后续 token 的语境重新拉偏。
<h2 id="6-自回归解码是贪心局部过程不会天然回头修正计划">6. 自回归解码是贪心局部过程，不会天然回头修正计划</h2>
Transformer 在生成时通常是：
<ul>
<li>生成一个 token</li>
<li>把它拼回上下文</li>
<li>再生成下一个 token</li>
</ul>
这意味着，前面一旦写出：
<ul>
<li>“通常，意味着要切苹果”</li>
<li>“重新评估物理上的 3/5 分割”</li>
</ul>
后面模型就要面对一个新现实： 
现在上下文已经被自己写成“严肃数学分析模式”了。 
于是接下来它会越来越容易继续顺着这个模式写。 
即使它内部还有“横向思维”信号，也会被当前已生成文本拖着走。 
这叫做 exposure bias / trajectory lock-in 的一种表现：
<ul>
<li>一开始一个小偏移</li>
<li>后面每一步都把这个偏移当真</li>
<li>最终越走越远</li>
</ul>
所以有时不是模型主动决定“否定正确方向”，而是它已经把自己写进了另一个轨道里。
<h2 id="7-transformer-擅长模式补全不擅长显式元认知控制">7. Transformer 擅长模式补全，不擅长显式元认知控制</h2>
它很会学这种模式：
<ul>
<li>分析问题</li>
<li>列多个方法</li>
<li>自我质疑</li>
<li>排除不严谨解法</li>
</ul>
但“我是不是过早否定了一个高价值假设？”这是更高一层的元认知控制。 
普通 Transformer 并没有一个专门模块持续做这种事。 
也就是说，它可以学到“像反思一样的文本”，但不一定真的有稳定的反思控制器。
所以你看到的：
<ul>
<li>“等等，这可能是横向思维”</li>
<li>“但通常意味着要切苹果”</li>
<li>“再检查一下”</li>
<li>“不，这个方向不对”</li>
</ul>
很多时候更像是反思风格的文本生成，不是一个真正的审议系统在运转。
<h2 id="8-多头注意力会并行保留互相冲突的解释">8. 多头注意力会并行保留互相冲突的解释</h2>
多头注意力的一个强项，是不同头可以关注不同关系：
<ul>
<li>一个头盯住“平均分给五个小朋友”</li>
<li>一个头盯住“只能切两刀”</li>
<li>一个头盯住“经典脑筋急转弯”</li>
<li>一个头盯住“常识：切的是苹果”</li>
</ul>
这让模型表达力很强。 
但也意味着它可能同时维持多个互相冲突的解释框架。 
如果后续层没有足够强的机制把这些框架压成一个稳定结论，最后生成时就会表现为：
<ul>
<li>一会儿站在框架 A 里说话</li>
<li>一会儿又切到框架 B</li>
<li>文本上像“自我打脸”</li>
</ul>
换句话说，多头注意力很会“看见多个角度”，但不等于它很会“裁决哪个角度应该赢”。
<h2 id="9-位置编码帮助顺序理解但不等于建立推理控制流">9. 位置编码帮助顺序理解，但不等于建立推理控制流</h2>
位置编码让模型知道 token 顺序。 
但“顺序”不等于“控制流”。 
程序里的控制流是这样的：
<ul>
<li>进入分支</li>
<li>持续执行该分支</li>
<li>满足条件后才退出</li>
<li>回到上层继续</li>
</ul>
Transformer 没有这种原生机制。 
它知道前后顺序，但不知道“我现在已经进入假设 B 的子推理，除非出现反证，否则不要退出”。 
所以它的推理轨迹不是树状控制流，更像一条被上下文不断重写权重的文本流。
<h2 id="10-最终-logits-是很多因素叠加出来的不代表单一立场">10. 最终 logits 是很多因素叠加出来的，不代表单一“立场”</h2>
在最后输出 token 前，模型会把高维表示投影到词表 logits。 
这个 logit 不是“当前真实想法”的直接读取，而是多种因素叠加的结果：
<ul>
<li>语义因素</li>
<li>上下文一致性</li>
<li>常见表达模板</li>
<li>安全/谨慎偏置</li>
<li>训练里高频的“分析型话术”</li>
</ul>
于是模型有时不是“逻辑上决定否定”，而是因为像下面这类句子在当前状态下概率更高：
<ul>
<li>“再重新评估一下”</li>
<li>“然而，这种方法似乎不成立”</li>
<li>“通常，这意味着……”</li>
<li>“不过，这可能不符合题意”</li>
</ul>
这些 token 很像理性思考，所以容易被选中。 
一旦选中，就会把整段思路带向自我推翻。
<h2 id="11-用一句结构化的话概括">11. 用一句结构化的话概括</h2>
从 Transformer 结构上说，它容易自我推翻，是因为： 
它依赖分布式表示、软注意力混合和自回归局部续写来“近似推理”，但没有显式的假设管理、分支提交、回溯和元认知裁决机制。
因此它能“想到”多个方向，却不擅长稳定地“守住”其中一个高价值方向。
<h2 id="12-和传统程序--搜索器对比一下">12. 和传统程序 / 搜索器对比一下</h2>
传统搜索器更像：
<ul>
<li>状态是显式的</li>
<li>分支是离散的</li>
<li>评分是可比较的</li>
<li>回溯是原生支持的</li>
<li>“已接近正确”可以被持久记录</li>
</ul>
Transformer 更像：
<ul>
<li>状态是隐式分布式的</li>
<li>分支是软混合的</li>
<li>评分不是显式挂在候选树上</li>
<li>回溯不是原生动作</li>
<li>“接近正确”不一定能稳定保存在上下文里</li>
</ul>
所以自我推翻几乎是很自然的副作用。
<h2 id="13-你可以把它想成这两种系统的差别">13. 你可以把它想成这两种系统的差别</h2>
一种系统像白板推理：
<ul>
<li>在左边写假设 A</li>
<li>在右边写假设 B</li>
<li>中间写证据</li>
<li>先别擦掉</li>
<li>最后再裁决</li>
</ul>
另一种系统像即兴演讲：
<ul>
<li>说到哪算哪</li>
<li>依赖刚才说过的话继续往下讲</li>
<li>脑中同时有多个模糊想法</li>
<li>哪个表述眼下更顺，就先说哪个</li>
</ul>
Transformer 更接近后者。 
所以它非常容易出现“刚才还觉得这个方向有戏，下一句又自己把它讲没了”。
<h2 id="14-这是不是说明-transformer-完全不适合推理">14. 这是不是说明 Transformer 完全不适合推理？</h2>
也不是。 
Transformer 的强项是：
<ul>
<li>大规模模式抽象</li>
<li>长上下文关联</li>
<li>并行表示学习</li>
<li>在很多任务上形成很强的启发式推理能力</li>
</ul>
它的问题不是“完全不能推理”，而是：
纯 Transformer + 自回归文本输出，不天然等于稳定的 deliberative reasoning system。
所以现代系统常常会加这些东西来补：
<ul>
<li>多次采样 self-consistency</li>
<li>外部 verifier</li>
<li>tree search / beam search</li>
<li>工具调用</li>
<li>scratchpad / structured state</li>
<li>process supervision</li>
<li>test-time compute 扩展</li>
</ul>
这些本质上都是在弥补 Transformer 原生控制流不足的问题。
<h1 id="我的感慨">我的感慨</h1>
大语言模型我是完全的外行。我常常对于 AI 能够做推理这件事情感到惊奇。
今天又有另外的领悟：
<blockquote>
人类通过语言来表达思考、逻辑、推理…… 
人类把语言存储到文本 
大模型把人生产生的所有文本建立关联的词向量 
依靠算力：预测某个词对应的下一个词时，人类沉淀到语言里的思考/逻辑/推理，就通过机器复现出来了。
但是： 
· 几乎所有的人类都误解了某个事实，大模型也会误解； 
· 语言的边界即思维的边界。大模型只能复现思考/逻辑/推理，无法超越已有的思考。
</blockquote>
印证了那句话：
<img alt="维特根斯坦" loading="lazy" src="https://img2024.cnblogs.com/blog/1457949/202603/1457949-20260318170456887-117893647.jpg" class="lazyload">
“我语言的界限，意味着我世界的界限。”
—— 路德维希·维特根斯坦 
来源：https://www.cnblogs.com/ahfuzhang/p/19734951

頁: [1]

琼殿技术论坛's Archiver

从一个地狱笑话看大模型的推理机制