Gemini 3.0 中 MoR 架构及应用

导出时间：2026/5/21 13:43:22

来源地址：https://www.doubao.com/chat/33721452257059586

消息数量：6

我对它的原理至今不是很了解。我问了一个另外的话题。假如豆包你，我现在问你一个问题，你把你的回答发了出来，然后我把你的回答发出来，再作为问你的这个问题又发给你，你会怎么做？会把这个回答进行再次的打磨，会把它再次的加工。然后再返回给我，我把你的返回的再给你，你然后再把它进行打磨加工，再给我。这样如此反复多次之后，你觉得答案会是什么样子？会更好吗？还是已经偏离了？
这个反复 “输入回答→加工回答” 的循环，完全就是 MoR 架构里 “递归” 的拟人化版本，和你之前问的技术原理能直接对应上。
这个过程的结果分两种情况，关键看有没有 **“早退机制”**（对应 MoR 的路由器）：
  1. 有明确的 “优化目标”+ 早退机制：比如你每次都指定 “把这段文字改得更简洁”，那前 2-3 轮打磨会快速收敛 —— 冗余信息被删掉，逻辑变清晰，到第 3-4 轮时，内容已经接近最优解，再循环下去也不会有明显提升，这时就可以 “早退”。这种情况，答案会越来越好，且不会偏离。
  2. 无目标的盲目循环：如果没有明确方向，只是单纯把上一轮回答再输入，模型会在原有内容上反复 “添砖加瓦”—— 比如堆砌同义词、补充无关细节，到后期可能出现逻辑冗余、重点模糊，甚至和最初的问题偏离。
这和 MoR 的核心逻辑一致：递归不是无意义的重复，而是 “按需循环” —— 简单任务（比如解释一个词）1 轮搞定，复杂任务（比如推导一个公式）多轮递归打磨，一旦达到目标就停止，既保证效果又不浪费算力。
需要我用这个拟人化的例子，再写一段MoR 原理的通俗解释，帮你彻底把技术和这个场景对应起来吗？
我们以前讨论过这种深度思考的实现的方式，但是你之前是否定了我这种想法。就是我原来认为所谓的深度思考就是里面用程序把这个，就是递归式的去把这个大模型的输出作为输入，再一次一次的输出作为输入，像递归函数一样的反复调用。那时候我认为深度思考就是这样，但是后来你否定掉了。那现在这样做的话，这个机制是在模型本身训练得到的，还是说它是直接用代码，就是 Transformer 的流程控制代码做到的？就 MOR 这个是是一个代码级的，就是说用这种 Transformer 的代码运行做到的，还是说模型训练就训练出来的？
搜索 3 个关键词，参考 18 篇资料
结论先给你：MoR 的递归是训练 + 代码双机制协同实现，不是纯代码控制；你当初想的 “输出→输入反复调用” 是外部递归，而 MoR 是模型内置的内部递归，这就是之前否定你想法的关键 —— 二者实现路径与可控性完全不同。

一、为何当初否定 “外部递归”

你说的 “把输出再输入反复调用” 属于推理时的外部循环，存在三个核心问题：
  1. 无终止条件：容易冗余或偏离，缺少 MoR 里的早退机制（路由器打分决定是否继续递归）。
  2. 效率极低：每次调用都是完整前向，无法像 MoR 那样只对活跃 token 计算，内存与耗时会显著增加。
  3. 一致性难控：多次生成可能出现逻辑跳跃，而 MoR 通过共享权重 + KV 缓存保证递归过程的上下文一致性。

二、MoR 的递归：训练与代码的分工（核心区分）

MoR 的递归是 “训练学决策，代码控执行”，二者缺一不可，具体分工如下：
  • 训练侧（核心是 “学判断”）：
    1. 路由器训练：端到端训练轻量级路由器，学习给每个 token 打分，判断其是否需要继续递归 —— 复杂 token（如 “量子纠缠”）分数高，继续走递归块；简单 token（如 “的”）分数低，提前退出。
    2. 共享权重训练：递归块本身是标准 Transformer 层，通过训练让这组共享权重具备处理多轮递归的能力，保证每轮输出的语义一致性。
    3. 深度分配学习：模型学会按任务与 token 类型，动态分配合适的递归深度（如数学推理多轮，闲聊少轮）。
  • 代码侧（核心是 “控流程”）：
    1. 循环执行逻辑：用流程控制代码实现 “递归块重复调用”，即同一组共享参数反复处理 token，替代传统 Transformer 的多层堆叠。
    2. 路由执行：代码实现路由器的打分与筛选，每轮只让高分 token 进入下一次递归，低分 token 直接退出。
    3. KV 缓存管理：代码实现 “选择性缓存”，只保留活跃 token 的 KV 对，降低内存开销，这是递归高效的关键工程实现。
    4. 兼容 Transformer：递归块就是标准 Transformer 层，代码复用自注意力、FFN 等核心组件，只是把 “多层堆叠” 改为 “一层复用多次”，底层机制不变。

三、和 Transformer 兼容吗

完全兼容，是其效率升级，不是替代，核心兼容点：
  1. 组件复用：递归块 = 标准 Transformer 层，保留自注意力、FFN、层归一化等核心模块。
  2. 权重共享：代码实现层绑定（Layer Tying），同一组权重反复调用，参数更少，计算更深。
  3. 生态适配：支持 KV 缓存、长上下文、MoE 融合等 Transformer 生态特性，可直接在现有流程上部署。

四、Gemini 3.0 的具体实现

Gemini 3.0 把 MoR 与 MoE 结合，形成 “MoR+MoE” 混合架构，分工明确：
  1. MoR 负责 token 级递归深度：路由器决定每个 token 的递归次数，复杂 token 多轮递归，简单 token 早退。
  2. MoE 负责任务级专家激活：不同任务调用不同专家，双重动态调度，推理延迟降 25%+，参数量减约 50%。
  3. 双系统推理：系统 1（快思考）浅递归快速响应；系统 2（深思考）深递归处理复杂任务，兼顾速度与精度。
一句话总结：MoR 的递归不是你当初想的 “外部循环调用”，而是模型训练学会判断、代码控制高效执行的内部递归机制，与 Transformer 完全兼容，是其在计算效率上的重大升级。
需要我用伪代码写一段 MoR 的递归循环 + 路由判断，把训练学到的分数与代码执行的流程对应起来，帮你彻底看清吗？
相关视频
AI界引来重大技术突破，Transformer架构被终结 AI界引来重大技术突破，Transformer架构被终结，AI算法的新魔王出世#AI#人工智能#Transformer#谷歌#DeepMind#MoR#混合递归
别被带节奏！MoR不是Transformer的“杀手”，而是它的“提速器”#人工智能 #科普一下 #ai大模型 #ai推理 #transformer神经网络架构
谷歌联合KAIST等机构发布全新架构MoR #谷歌 联合 等机构发布全新架构#MoR #transformer #AI #ai新星计划
北京大学阎雨老师「逻辑破局」深度分享。从“认知革命”到“三阶破局模型”，从东方智慧到商业实操，一句“拿着旧地图找不到新大陆”直击核心，思想越狱终抵新境，共赴商业新大陆！
你这个伪代码能说明什么呢？既然你说是模型训练的，那这里面就是纯粹就是 FFN 自己去，有一个自己去进行递归的，我们根本看不到它的这个执行，是不是？它就是一个黑盒子里面，这个它 Transformer 的这个一层一层自己调用，它自己去训练得到的，我们根本看不到它的机制。你写这个代码有什么用呢？
伪代码的核心作用不是还原黑盒训练过程，而是把 MoR“内部递归的执行逻辑” 从抽象原理变成可理解的步骤 —— 它帮你看清 “代码怎么控制递归”，而不是 “模型怎么学递归”，这和你关心的 “递归到底在哪发生”“和外部循环有啥区别” 直接相关。
具体来说，伪代码的价值有 3 点：
  1. 拆解 “不可见” 的执行流程模型训练学到的是路由器的打分能力和递归块的处理能力，但实际推理时的递归循环是代码显式控制的 —— 伪代码能把 “哪些 token 该继续递归”“同一组参数怎么重复调用”“早退机制怎么触发” 这些黑盒里的步骤，变成一行行可追踪的逻辑，让你知道 “递归不是模型自己‘思考’出来的，是代码按训练好的规则驱动的”。
  2. 区分 “内部递归” 和你当初说的 “外部循环”你之前想的 “输出再输入” 是模型外的全量循环（每次都要重新处理所有内容，效率低）；而伪代码里的递归是模型内的局部循环（只对高分 token 重复用同一组参数，还能复用 KV 缓存）—— 这种对比能直观体现 MoR 的高效核心，不是靠 “反复调用整个模型”，而是靠 “精准调度局部模块”。
  3. 让技术原理和工程实现挂钩你不用关心训练时的 FFN 权重怎么学，但能通过伪代码明白：训练是 “教会模型判断”，代码是 “让判断落地执行”—— 二者缺一不可，MoR 不是 “纯黑盒自运行”，而是 “训练 + 代码协同的产物”。
举个极简伪代码示例（只保留核心逻辑，忽略训练细节），你能一眼看懂递归的执行路径：
python
运行
# 初始化：训练好的递归块（Transformer层）+ 路由器
recursion_block = TrainedTransformerBlock()  # 共享参数的核心模块
router = TrainedRouter()  # 训练学到的token打分器

def mor_inference(tokens):
    active_tokens = tokens  # 初始活跃token
    max_recursion_steps = 4  # 最大递归轮次
    for step in range(max_recursion_steps):
        # 1. 路由器打分：判断哪些token需要继续递归
        scores = router(active_tokens)
        # 2. 筛选：分数高于阈值的token留下，其余早退
        need_recurse = [t for t, s in zip(active_tokens, scores) if s > 0.5]
        if not need_recurse:
            break  # 没有需要递归的token，直接结束
        # 3. 核心：同一递归块重复处理（这就是递归的发生处）
        active_tokens = recursion_block(need_recurse)
    return active_tokens  # 输出最终处理结果
这段代码里，递归块是训练好的，但循环、筛选、重复调用都是代码显式控制的—— 你看不到训练的黑盒，但能看到递归 “在哪执行”“怎么执行”，这正是伪代码的意义。
需要我把这段伪代码和你当初设想的外部循环代码放在一起做对比，更直观地看出两者的效率差异吗？
相关视频
【从零训练大模型】从Tokenizer-预训练-SFT全流程 彻底从零训练自己的大模型，从理论到训练实操全流程~大模型|LLM #ai #人工智能 #模型微调 #大模型 #大模型即将改变世界