全双工到天花板的豆包

这几天罗胖现场演示与豆包吵架的视频在网上疯传。建议都去听听，绝对比脱口秀精彩。

听完我的感觉是：它太会聊天了。不是“会回答”，是“会对打”。不是“能理解”，是“能接招”。你给它一点火星，它能当场把现场变成一段出彩的脱口秀辩论。

刺激的是：我把ChatGPT、Gemini、Claude、Grok 这些美国头部模型在脑子里挨个过了一遍——论智商、论推理、论工具链，确实这些烧钱无数的头部都各有很强的地方；但在chatbot 交互体验，尤其是“陪伴”“情绪价值”“临场反应”“口语节奏”这条赛道上，豆包这种产品给我的冲击很直接：老美这几家，至少在“好玩”和“像人”上，确实没它那么顺。不得不服。

这不是一句“国产更懂中文”就能解释的。它背后是一整套系统工程的胜利：全双工、打断、抢话、人格稳定、指令热更新、超写实语音表演层——这些方面能打，才会出现那种“比真人吵架还丝滑”的错觉。

1. “吵架能力”不是嘴毒，是“反射弧”

你如果只把语音对话当“把文字念出来（TTS）”，那永远理解不了为什么“全双工”能杀人。

所谓“全双工到天花板”，不是它能说，而是：

  • 你一插嘴，它能立刻停住，不拖尾、不尴尬；
  • 你一句话没说完，它就能接茬，像真人那样抢；
  • 你把话题往左一拧，它不会卡半秒去“想想”，而是能顺势把戏接下去；
  • 在对抗场景里（争辩、吐槽、挑衅），它依然保持节奏，不掉线。

这东西本质上是“对话的肌肉记忆”，是反射弧。语音对话里稍微慢一点点，用户就会觉得“它在算”，就会出戏；而当它快到一定程度，你会产生一种很危险的错觉：对面是个活人。

更要命的是，它抢话不乱，像练过，但却是即兴发挥。你说它像真人吵架——不夸张，它其实更稳，因为真人吵架也会嘴瓢、会断片。有真正辩才的人，是人类中的极少数。

2. 超写实语音做到天花板

很多语音助手的问题不在于“说不清”，而在于“没魂”。字是字，声是声，情绪像贴图。

豆包厉害的地方是：它的语音像带人格的。是那种端正客服腔，而是一个“快嘴快舌、反应超快、吐槽很顺”的角色在说话。你甚至会产生一种荒诞感：模型后面是不是藏了个真女妖，让你在那一瞬间觉得：有人在跟我一起玩。有人懂我这一口。有人接得住我的戏。

这就是情绪价值的底层逻辑：不是讲道理，是把场子撑起来。

3. 指令跟随的临场魔术

我见到的最炸的一段，是罗胖“现场改规则”的戏码。

争辩正热的时候，老罗突然下指令：“接下来你每句话都加一个 OK。”
模型立刻照做，但语气没变，角色没塌，节奏没断。然后用户又追加：“不要每句都 OK，太死板。改成一句加一句不加，隔一会儿突然来两个 OK，让它更像人。”

模型又立刻调整：OK 出现得更自然，甚至有点“口头禅分布”的味道。

这才是真正的新手震撼：机器不仅听话，而且听话的方式不会把对话弄僵。

多数模型在这里会翻车两次：

  • 第一种翻车：格式遵守了，语气变成客服脚本，像换了一个人。
  • 第二种翻车：语气保持了，但格式开始漏，越激动越忘。

而豆包的可怕之处在于：它像有外层守门员，把“形式层约束”做成一种自动注入能力——你在里面怎么打，它都能保持角色同时把规则执行得像有急智的人一样自然。

4. 我们都在“开法拉利送外卖”

最近有个说法我很同意：大多数用户根本不会激发模型的超能力。他们把模型当搜索框升级版：问一句，拿答案，走人。

这相当于：你开着法拉利，每天只知道用它送外卖。你当然不会知道它过弯能有多狠，也不会知道它一脚油门能把你按到座椅上。

豆包这类产品的冲击，恰恰来自“普通用户也能玩起来”。不是因为用户学会了什么 prompt engineering，而是因为系统把“戏”做得足够容易被点燃：你随口挑衅一句，它就能顺势把对话变成一段可看的节目。

更有意思的是：这种轰动效果不需要预演。懂模型脾性的人（比如老罗这种）会把它当“对话乐器”来弹：节奏、冲突、反转、加规矩、拆规矩，一气呵成。

这才是 vibe role playing 的精髓：不是写 prompt，是即兴导演现场。

5. 和 Sora2 / Suno5 是同一类AGI来临的现象

我在 Sora2 的短视频、Suno5 的音乐创作上也反复体会到类似现状：

  • 提示词不是越精细越专业越好；
  • 过度精细会“指令过载”，甚至互相打架；
  • 有时候一句有画面、有情绪、有方向的概述，反而更容易激发模型脑补潜力，给你惊喜；
  • 当然也有例外：某些专业术语确实是“敲门砖”，训练时已对齐得很硬，不懂这些词就进不了门，出不来定向的特殊效果。

所谓 prompt engineering，很多时候不是科学，更像经验性舞台调度学：什么时候收，什么时候放；什么时候控制，什么时候让它飞。

6.  把爽感变成指标

可以建议用三段“爽感”测试，任何 LLM-native 语音接口都能AB对比：

  1. 对抗辩论：给角色、给冲突，允许打断纠错
  2. 格式热更新：中途插入强规则（口头禅、禁用词、句式、语速）

然后打分看这些指标：

  • 端到端反应时延
  • 打断成功率（停得干不干净）
  • 约束保持率（越吵越不漏规则）
  • 人格稳定性（别吵着吵着变客服）
  • 自我修复能力（漏了能不能自己圆回来，不出戏）
  • 幽默命中率（真实笑出来的频率）

当这些指标都对齐，就会得到一种用户层面极恐怖的结果：人忍不住会愿意跟它多聊，获得乐趣和满足感。这意味着什么？意味着留存，意味着陪伴，意味着付费，意味着口碑传播。你可以不服，但市场会服。

结语：OK 不是口头禅

有人以为“吵架能力”只是嘴毒。错了。真正的亮点是：你怎么插嘴、怎么改规矩、怎么挑衅，它都能接住，且接得像人。

OK 这个小把戏之所以值得反复讲，是因为它是一个极好的试金石：规则一改，戏还在不在？人格还稳不稳？节奏断不断？

当全双工走到天花板，chatbot 的竞争就不再只是“谁更聪明”，而是：谁更像一个活人，谁更能把你接住，谁更能提供情绪价值。

而情绪价值对于 toC 应用，绝对是刚需。

这才是它对所有模型的真正王者挑战。国产大模型从应用角度，完全不输老美，甚至更胜一筹。

 

 

FSD + Grok：超人老司机，带着“实习导游”上路

这几天一个热门话题，媒体标题党写得很嗨：“老马的 Grok 上车了，车载导游时代来了”。我承认我也兴奋——我是那种见新就上手的 early adopter，哪怕它“百孔千疮”，我也愿意先摸摸它的脾气，看看它究竟是“未来已来”，还是“未来还没来 yet”。

但实话实说：亲测下来，现在的 Grok 车载导游，真的很不给力。漏洞百出，幻觉严重。更关键的是——它根本无法与多年武功毕其一役的 FSD 驾驶能力比。

一句话概括我这几天的体感：
二者的配合很不相称：一个是超人老司机，一个是实习导游，稚嫩得可怕。

我有很多具体案例，错路、错指、瞎编、强行自信……以后有时间慢慢说道，逐条分享。今天先把这个现象背后的“系统逻辑”讲透：为什么我一边吐槽 Grok，一边又坚决不泼冷水，甚至更看好它的长期潜力。

1) 你以为它是“导游”，其实它更像“嘴炮导航员”

先把概念捋顺。我们今天说的 Grok 上车（尤其是“导游/助手”这类定位），它的核心不是驾驶控制，而是：

  • 帮你规划和解释路线、讲解周边、回答问题

  • 甚至“建议”去哪、怎么走、为什么这样走

  • 它的行动就是根据你的意思为FSD动态、实时更新导航路线

这类能力，本质是语言模型 + agent 化的接口。

问题在于：语言模型最擅长的是“把话说圆”，不是“把事做对”。因此打造 Agent 的重心落在如何训练它做好事的 actions，但那并非一日之功。 

你让LLM写段文案，它能妙笔生花。你让它做一个对现实世界有约束、对错误极其敏感的“导游”，它就容易露馅：幻觉、编造、过度自信、缺乏事实核对——这些在文本世界是“可容错的尴尬”，在车上就是“会把人带沟里”的风险源。

所以我才说Grok当下最多也就是个“实习导游”：有时候很能耐，但也常常信口开河胡乱指挥路线。

2) 飞哥的震惊：这在以前“根本不能上线”

前几天我带 @李志飞 一起体验 FSD + Grok。飞哥大家都知道是第一批回国创业做中国 Siri 以及车载语音助手的老司机创业家，他的关注点非常直接，而且是行业人的那种“条件反射式警觉”：

“Grok 这种幻觉会要人命的啊。”
“它多次胡说八道，导航错误，怎么敢部署到车上，让百万用户敢用呢？”
“关键时刻导错了，司机要是不够灵活、没有判断力，是要出人命的。”

这段反应我非常理解。因为在传统车载助手时代，你要上线一个功能，哪怕“智障但稳定”，它至少可控和安全；而这种“智能 open 但不稳定”的东西，在老派安全工程语境里，通常连 beta 都算不上，顶多算 alpha——甚至很多团队会直接判死刑：不准上路。

3) 但在特斯拉的语境里，FSD 的安全底线，把 Grok 兜住了

这里就出现了一个很有趣、也很关键的结构性差异：特斯拉不是让 Grok 直接接管车辆控制（它更多是在“建议/解释/导游”层面折腾），驾驶安全的底座和全权负责仍然是 FSD。这是两个独立系统的拼接。

这意味着什么？

意味着 Grok 再怎么幻觉、再怎么嘴硬、再怎么瞎指路——只要驾驶执行掌握在 FSD手中不变，安全性就不会被它拖下水。Grok 瞎指挥时候的最大副作用不过是：绕路，耽误时间而已。没有安全性隐患。

这是两套系统的边界：

  • Grok：给你“信息与建议”，更新FSD的导航图，有时对，有时胡说

  • FSD：负责沿着导航图的指向“安全驾驶执行”，有明确的底线策略与约束

我特别想强调这一点：
对于 FSD，无论是人还是 Grok，无论你怎样临时改变路线、在什么时间点改变路线，FSD 都有它的安全底线来应对新的路线。它不会像人类司机那样因为你突然改口就手忙脚乱。

一个不该错过的路口因为临时改线错过了，FSD 会怎么做？它会——让它错过，然后找最佳路径再绕回来。

它忠于一种“安全第一”的内部逻辑，近似于你我都熟的那句老话：宁停三分，不抢一秒。

所以在特斯拉这套组合里，Grok 的“不成熟”反而变得可以容忍：在 FSD 大旗的庇护下，它有慢慢迭代改进的时间和机会。

这句话背后其实是一个行业分水岭：并不是每一个做车载助手的团队，都有 FSD 这种级别的安全底座可兜底。没有这个兜底，它的“幻觉导游”就不只是“绕路”，而是可能直接触发“事故”，有 liability concerns。

4) 我为什么不泼冷水

我对 Grok 现在的表现，确实有点“恨铁不成钢”。但我不会因为它不时“翻车”就断言它没戏。

事实上，我见过 FSD 更百孔千疮的前期，最后还是被老马迭代成“行业标杆”。

五年多前我开始用 FSD Beta 的时候，那真是——各种不稳、各种惊吓、各种“你在干嘛”。但我那时更关注的是 半瓶水中的水，而不是那大半瓶空气。

必须相信老马的迭代狂魔特质：无论见了公婆的媳妇有多丑，他都能不断化妆、美化，最后把这个丑媳妇训练并包装成国民理想媳妇——要形象有形象，要能力有能力。

今天我看 Grok 也是这个逻辑：重要的不是它当下作为数字导游常常翻车、偶儿才露露峥嵘的表现；重要的是——老马敢为人先，用 LLM-native agent 去先干掉 Siri 时代的人工智障。

一句话我愿意重复：
前者智能 open 但不稳定，是朝阳；后者稳定但智障，是夕阳。“平替后者”是大势所趋，是不归路。

5) Grok 的进步会比 FSD 快很多：因为它是“纯软件”，嘴上功夫

这里是我最乐观的判断，也是一条很工程的判断：

  • FSD 是软硬结合的长线条路径：传感器、车规、安全、道路长尾、法规、人类社会系统……每一步都慢，且成本极高

  • 导游/助手 agent 是纯软件：嘴上功夫，迭代周期短，数据驱动强

所以我相信：Grok agent 的进步会比 FSD 快很多，不像 FSD 经过多年的苦苦挣扎才修炼成今天的超人。

哪怕大模型本性有幻觉，但只要：错误驱动、数据驱动、强化不停止，它的性能就会迅速提升，幻觉就会被压缩——虽然不会零幻觉，但总体趋势毋庸置疑。数据闭环的飞轮要让它转。转起来就不愁它不出彩。

6) 现在怎么用：不要把它当“可靠导游”，而当“进化中的实验体”

我现在不大用 Grok 做导游了。我知道它几斤几两，还远没成熟。但我会持续关注它，也愿意不时当当它的小白鼠。我对它的进化曲线非常有兴趣。

在 FSD 这个“超人老司机”旁边，Grok 这个“实习导游”至少不会把车开沟里。
它可以在安全底线被兜住的前提下，去犯错、去改错、去变强。这一点没有疑问。

这可能就是特斯拉最“特斯拉”的地方：
别人家的车载助手必须先证明自己“不会错”，才能上线；
特斯拉选择先把它扔到真实世界里迭代——因为它背后有一个更强的系统把风险挡住。

你可以讨厌这种风格，但你很难否认：它确实更接近“用迭代碾压世界”的那套路径。

结语：今天的 Grok 很稚嫩，但它代表的是agent的方向

我对 Grok 现状的评价：

  • 作为导游，它现在的表现常常不及格

  • 作为第一批把LLM agent 引入功能性智能助手的努力，它值得认真对待

因为它在做一件有分水岭意义的事情：把车载交互从“稳定的人工智障”，推向“开放的智能体”。

稍安勿躁，我们过半年再来聊：
这位“实习导游”到底什么时候能配得上这位“超人老司机”。

 

梁文峰团队的 mHC 研究在做什么

立委按：逢年过节必有新事儿。去年元旦春节那一会儿是闹腾CoT强化推理，DeepSeek 开源推理模型推动了大模型后训练的范式转变。今年梁文峰他们元旦又“闹事”了，但不像CoT那样直观。这次说的是 mHC，听上去就显得高深。值得拆解一下。


DeepSeek 这次的 mHC 论文，第一眼读上去确实有点“技术密度过高”。但它要解决的其实是一个非常朴素、也非常关键的问题：我们能不能在不牺牲训练稳定性的前提下，把模型内部的信息通道修得更宽？

要看懂这件事，得先回到深度学习的一段“地基史”。熟悉神经网络历史的都知道，残差的发明是深度神经能 work 的关键，从而为深度学习革命打稳了基础：就是用 x+f(x) 代替 f(x)，来保证多达几百上千层的网络，不至于在不断加深的转换中“差之毫厘，失之千里”，从而稳住训练。

但这里有个“硬核”的底线经常被忽略：残差之所以是残差，不是因为它“加了一条支路”，而是因为它把恒等映射当作守恒机制替深度训练兜底。大模型本质上是一个可编程的函数逼近器，把输入 x 变成输出 y=f(x)；而深度一旦上去，你不是在学一个函数，而是在学一串函数的复合。任何一点“不守恒”的东西，都可能被深度放大成数值灾难。残差里那条直通的 x，就是大模型的定海神针。

mHC 的故事，就从“想把这根定海神针加粗成多车道高速，但又不能把稳定性一起赔进去”开始。

把残差从“单车道”扩成“立交桥”

新年第一天，DeepSeek 在 arXiv 放出一篇相当“硬核”的论文：mHC: Manifold-Constrained Hyper-Connections，时间戳是 2025 年 12 月 31 日（v1）。arXiv
作者列表里，除了三位一作（Zhenda Xie、Yixuan Wei、Huanqi Cao），还出现了神龙见首不见尾的传奇人物 Wenfeng Liang（梁文锋）。arXiv
这篇东西技术性蛮强，但它在解决的，其实是一个很“基础设施级”的老问题：深度网络到底靠什么才能越堆越深而不炸？

01｜从残差的“定海神针”说起：为什么 x + F(x) 让深度网络能 work

熟悉神经网络里程碑历史的都知道，残差（Residual / Skip Connection）的发明，是深度神经网络能 work 的关键，从而为深度学习革命打稳了基础。何凯明/张祥雨也因此成名；那篇残差论文的引用数，据说在 AI 历史上是绝对的首屈一指。

这是一项发生在十多年前、深度学习革命刚刚开启时，他们在微软做出的里程碑工作。后来，它成了深度神经网络的标准 practice：用 x+f(x) 代替 f(x)。这条看似朴素的改动，恰恰是为了保证多达几百、上千层的网络，在不断加深的（函数）转换中不至于“差之毫厘，失之千里”，从结构上兜住训练的稳定性（那条 x 的直通路径，本质上就是恒等映射的安全绳）。

我们知道，大模型本质上就是个图灵机：在足够的容量与数据驱动下，它可以规律性地把任何信号输入 x 变成任何其他信号输出 y，也就是实现某个 f(x)。这就是所谓的万能函数近似——老母鸡变鸭的魔术：文生图、机器翻译之类，看上去神奇，背后都是“把 x 变成 y”的系统性变换。正是在这个意义上，残差网络（ResNet）里 x 这条直通连接线，成了大模型的定海神针。

因此，ResNet 的核心不是某个更复杂的卷积，而是那条看似朴素的“直通线”——让每一层学习 F(x)，但输出是 y = x + F(x)。原论文把这种 直通车道（shortcut） 设计解释为“identity mapping”，它让信息可以跨层稳定传递。

你可以把它当作在深度网络这个“层层加工的工厂”里，额外修了一条不加工作业、直达下一站的传送带。于是深度从几十层堆到几百层、上千层时，也不至于在复合变换里越走越偏，最终训练崩盘。

ResNet 把每一层从“直接学一个函数”改成“学一个增量”。这就好比雕塑大师把人物雕塑工作，转变为“去除多余的部分”。一块大理石，多余的“残差”去除殆尽，人物自然就成型了。

这件事的关键在于它把恒等映射（identity mapping）塞进了网络：哪怕 F 学得一塌糊涂，x 这条直通路径也能把信号和梯度比较完整地送到更深处，从而让几百上千层不至于“越算越跑偏”。mHC 论文在引言里也把这点讲得很直白：残差的稳定性，来自恒等映射跨层累积时的结构性保障。arXiv

作为研究背景，一句话总结残差的精神内核：

让网络“可以很深”，靠的不是每层转换多聪明，而是“永远留一条不作妖的直达通路”。

02｜单车道不够了：HC 把残差流“扩建成多车道”

传统残差是一条残差流（hidden state 的那条“主干通道”）。但当模型越来越大，研究者会自然产生一个念头：

      • 既然残差流像高速公路的主干，

      • 那我能不能把它从 1 条车道扩成 n 条车道，

      • 让信息在不同车道之间更自由地交换、混合，表达力更强？

这就是 Hyper-Connections（HC）这类工作的出发点：把残差流的宽度从 C 扩到 n×C，并引入一个可学习的混合矩阵，把“各条车道”的信息在每层重新路由。在 HC 原论文里，核心机制就是这种“复制 n 份 residual path、再在它们之间做连接”的宏观结构。

到这里为止，一切都很美：
路修宽了，车更多了，理论上吞吐更大、信息更丰富。

但问题是：你把高速路扩建成多车道，最怕的不是车多，而是没有交规。

03｜HC 为什么会炸：无约束矩阵跨层复合变成“放大器”

残差之所以稳，关键是 identity mapping 这条线天然具备一种“守恒”味道：
你至少能保证有一部分信号，不被层内变换“瞎折腾”（带偏）。

但 HC 的混合矩阵完全自由学习、没有任何约束，跨多层之后，实际上是在做一串矩阵连乘。mHC 论文直说了：HC 的这种无约束设计在大规模训练时会破坏 identity mapping 作为“conservation mechanism（守恒机制）”的角色，导致平均信号强度无法保持，从而出现无界放大或衰减。

更直观地讲这种“放大器效应”就是：

  • 如果某几层学到的“残差”在某些方向上“略大于 1”，

  • 经过几十层、上百层复合后，增长会呈指数积累，

  • 最终就是大家熟悉的两种灾难：信号爆炸 / 梯度爆炸，或者相反：梯度消失。都是模型训练的灾难。

不是 HC 多车道思路不对，而是它把原残差网络自带的这根“定海神针”，拆成了“自由的放大链路”。

04｜DeepSeek 的一招：把混合矩阵关进“双随机”的笼子里

mHC 的核心思想可以一句话概括：

你可以修立交桥、修多车道；但负责“指挥交通”的矩阵，必须服从一套严格的守恒规则。

他们选择的规则是：把残差约束到所谓 双随机（doubly stochastic / bistochastic）矩阵集合上——元素非负、每一行和每一列都等于 1（归一化）。

这样做带来三层非常“工程友好”的稳定性保证：

      1. 凸组合（convex combination）解释
        因为行列和为 1，残差等价于对输入特征做“加权混合”，但权重总量守恒，所以整体更像“搅拌”而不是“放大器”。

      2. 均值守恒 + 范数被严格规整
        论文明确说：这种约束让特征均值保持、信号范数被严格 regularize，从而缓解 信号爆炸/消失（vanishing/exploding）。

      3. 跨层复合仍然稳定（乘法封闭性）
        双随机矩阵相乘仍是双随机矩阵（非负性与行列和约束都能传递），因此“多层连乘”不会越乘越野，守恒性可以贯穿整个深度。

翻译成咱老百姓的话就是：

每一层的混合矩阵，本质上像是在“若干种换道方案（置换）”之间做概率意义上的加权选择。这就特别像一个“带守恒约束的交通路由系统”：怎么换道都行，但总车流不能凭空变多或变少。

另外，mHC 还对前后残差引入非负约束（论文用 sigmoid 形式实现），避免正负系数复合导致的数值抵消行为。

05｜把“野矩阵”投影成“双随机矩阵”

“利用 Sinkhorn-Knopp 算法将连接矩阵约束在双拟随机矩阵流形上”，这里的核心是这一步：

      1. 先让矩阵元素变成严格正数

      2. 然后反复做两件事：

        • 归一化每一行（让行和=1）

        • 归一化每一列（让列和=1）
          行列交替迭代，最终收敛到双随机结构。

你可以把所谓 Sinkhorn-Knopp 过程想象成一个“交警训练营”：
不管你原来学出来的“交警”矩阵多么放飞自我，进训练营一套队列动作做完，它就必须满足“行列守恒”的硬纪律，才能上岗指挥交通。

关于“流形”（manifold）这个术语，可以这样理解：
严格说双随机矩阵集合整体是个凸多胞形（边界有棱角），但在其内部（所有元素严格正）可以视为一个受约束的光滑空间；论文在工程语境里用“manifold”来表达“我们不让参数在整个欧氏空间乱跑，而是限制在一个有几何结构的可行集合里”。

06｜它不仅是数学，更是工程：6.7% 的代价换稳定与收益

把残差流扩成 n 倍，直觉上显存与通信都会爆炸。mHC 论文非常明确地把“系统开销”当作同等重要目标：它不仅提出数学约束，也在配套工程上做了 kernel fusion、选择性重计算、以及在 DualPipe 调度里更激进的通信-计算重叠。

最后他们给出的系统级结论是：当 n = 4 时，mHC 只带来约 6.7% 的额外训练时间开销。

这点很关键：

如果只讲“理论上更稳”，我们会问“那是不是贵得用不起？”
而这篇论文显然在回答：“我们把它做成了大训练里可落地的结构升级。”

07｜一句话总结：mHC 的创新意义在哪？

HC 想把残差从单车道升级成立交桥；mHC 做的，是给立交桥加上守恒型交通规则——用双随机约束恢复 identity mapping 的稳定性，同时把工程开销压到可接受范围。

这也解释了下列对应关系：

  • 残差的多流并行架构：残差流从 C 变成 n×C，让“通道”更多；

  • 连接矩阵受约束：核心是残差不再自由，而是双随机；

  • Sinkhorn-Knopp：实现“投影/归一化”的具体算法；

  • 解决数值不稳定与信号爆炸：把跨层连乘的放大链条关进“守恒笼子”

残差之所以稳，不是因为“加法神奇”，而是因为它隐含了某种守恒结构；
当我们试图把残差升级成更复杂的拓扑时，真正需要被继承的，是这份守恒，而不是加号本身。

 

 

DS原始论文：arXiv：mHC: Manifold-Constrained Hyper-Connections

从“眼球 + SaaS”到“大模型商业”

用量模式的甜蜜、危险与广告的改头换面

我的前老板在LinkedIn很活跃，特愿意分享他在美国创业一辈子以及当下业务的经验和教训。最近的一个分享很有意思：他把“用量定价模式（usage-based pricing / UBP）”的 Good / Bad / Ugly 拆得很利落，他后来总结道：真正会把公司带进沟里的，不是用量制本身，而是把“非复购的收入”伪装成“会复购的收入”，尤其在融资语境里。

这件事，放在我们正在经历的更大迁移里看，会更清晰：我们正在从过去二十年的两大商业模式的主流引擎——

  • 眼球广告模式（attention-based：流量、曝光、点击、转化漏斗）

  • SaaS 订阅模式（seat-based：按席位打包，靠续约与增购）

转向大模型时代的一组新组合拳：

  • 订阅（toC、toPro、toTeam、toEnterprise、toGov）

  • API/Token/调用用量（按消耗计费，成本可变、边际清晰）

  • 改头换面的广告/眼球模式（从“给你看”变成“替你选/替你做”，赞助位从信息流转移到“答案/动作/工具选择”）

这个话题在我们正处于的AI应用难产期，尤其重要，不妨展开来谈。

1. “The Ugly”的本质：UBP 最可怕的不是波动，而是“被当成 ARR 的幻觉”

在传统 SaaS 的语言体系里，$3M ARR 的潜台词是：只要你留存做得不错，明年大概率不是 $0，而是 在这 $3M 上叠加增长。资本市场习惯为“可预测、可续约、可扩张”的现金流付高倍数。

但在不少 UBP/UBM（usage-based model）公司里，$3M 可能不是“跑出来的订阅”，而是“试出来的烟花”：

  • 客户有一笔“AI 实验预算”

  • 来试你的产品，甚至在一两个月内用得很猛

  • 然后项目转向、负责人离职、POC 结束、预算冻结、换别家试——消费瞬间归零

于是同样是 $3M，今年看着像增长，明年可能只剩 $1M，原因不是你退步，而是 “试用型收入”天然复购不友好。如果你按 SaaS 倍数融资，估值就会“先虚胖再塌方”，后果你已经写得很直白：down round、CEO 更替、低价卖身。

一句话总结这段“Ugly 续集”：

UBP 的最大风险，是把“消费收入”当成“订阅收入”去叙事、去定价、去融资。

2. 为什么大模型时代更容易出现“Usage Bubble”

UBP 在大模型时代不是小众，而是“顺水推舟”，因为大模型服务天然满足三件事：

  1. 成本结构可变：推理、token、带宽、GPU 时间都在“用多少付多少”

  2. 客户价值不确定：很多客户还在找场景，先试再说

  3. 切换成本看似很低：API 换个 key、prompt 改一改、工作流挪一挪，短期并不痛

这三点叠在一起，就特别容易形成“usage bubble”：

  • 试用门槛低 → 进来的人多

  • 试验期会集中跑量 → 指标漂亮

  • 留存靠“持续业务价值”而非“合同期限” → 一旦价值链没卡住，掉得也快

过去的 SaaS 至少还有“合同的时间缓冲”。UBP 没有缓冲，它更像电费：你不用空调，账单就没了。

3. 大模型商业的三种主流定价，本质上对应三种“关系”

把订阅、用量、广告放到同一张图里，你会发现它们对应的不是“收费方式”，而是你和用户的关系。

A) 订阅：买的是“持续可用的能力”

适合场景：

  • 价值稳定、使用频率中高

  • 用户愿意把你当“日常工具”

  • 你能把体验做成“离不开”，而不仅是“偶尔爽一下”

风险：

  • 订阅疲劳继续加剧（用户已经被各种订阅抽干耐心）

  • 你必须持续交付“新鲜感 + 可靠性”，否则就是被砍的那一个

B) API 用量：买的是“可量化的消耗”

适合场景：

  • 成本与消耗强绑定（token、调用、分钟、任务数）

  • 采购决策需要低风险入口

  • 产品形态偏“平台/基础设施/能力组件”

风险：

  • 你可能变成“可替换的管道”

  • 指标好看但不稳，融资叙事极易误判

  • 成功更多取决于“嵌入客户核心流程的深度”，而不是“试用规模”

C) 广告/眼球模式的改头换面：买的是“被选择的机会”

过去广告买曝光；大模型时代更可能买三种位置：

  1. 答案位置：在生成内容里被提及/被引用/被推荐

  2. 工具位置：在 agent 的“工具选择”里被优先调用

  3. 动作位置：在“替你办事”的链路中成为默认路径（预订、下单、开户、比价、投放……）

这不是“广告消失”，而是“广告迁徙”：

  • 从信息流迁到对话流

  • 从点击迁到决策

  • 从展示迁到行动

风险也更大：一旦处理不好“赞助与中立”的边界，用户信任会掉得非常快。大模型产品最贵的资产不是流量，是可信度。

4. 对创业者最实用的一条建议：把“收入”拆成两类再谈增长

如果你做 UBP/UBM 或混合模式，我建议你在内部（以及对投资人）强行把收入拆成两桶：

1) 承诺型收入（Committed）

来自：

  • 年度最低消费承诺

  • 预付 credits（带明确有效期与续购机制）

  • 与业务系统绑定的长期工作流（离开你就断）

它更接近 SaaS 的“可预测性”。

2) 实验型收入（Experimental）

来自：

  • POC、试点、探索预算

  • 单团队、单负责人驱动的短周期尝鲜

  • 没有多部门扩散、没有流程固化

它更接近“项目收入”，不要拿它当 ARR 去讲故事。

这两桶拆开，你很多关键决策会突然变清晰：

  • 你到底是在“做增长”，还是在“做补洞”

  • CS 是在“促活”，还是在“救火”

  • Sales 是在“签长期”，还是在“拉试用”

5. 入口在换，商业不会消失，但计量单位变了

过去互联网的计量单位是：

  • 眼球：DAU、时长、PV、CTR

  • SaaS：席位、模块、续约、NDR

大模型时代的计量单位更像：

  • 意图（intent）：用户到底想完成什么任务，你在满足什么刚需

  • 行动（action）：你是否真的帮他办成

  • 消耗（consumption）：为了办成你消耗了多少 token/调用/工具链

  • 信任（trust）：用户是否愿意把“最后一步”交给你

所以，新的商业模式大概率不是三选一，而是混合体：

  • 用订阅覆盖“稳定能力”

  • 用用量覆盖“弹性消耗”

  • 用赞助/分成覆盖“被选择与被调用”

  • 最终用“结果/交付”去对齐价值（更像 outcome-based，而不是 feature-based）

大模型时代最稀缺的不是流量，而是“稳定可复用的工作流位置”。谁能成为“默认工具链的一环”，谁就能把用量从泡沫变成复购，把曝光从广告变成分发。

6. 一个落地的自检清单（你可以直接拿去用）

如果你在做（或评估）大模型业务，我建议每季度问自己六个问题：

  1. 我们的“usage”定义是否反映真实价值，而不是鼓励无效调用？

  2. 收入里承诺型 vs 实验型各占多少？趋势如何？

  3. usage 的留存是“团队留存”还是“负责人留存”？负责人走了会怎样？

  4. CS 的 KPI 是“上线”还是“消费与扩散”？有没有机制推动多部门扩散？

  5. 我们是否在关键链路里形成了“默认位置”（工作流、工具选择、动作执行）？

  6. 如果资本市场按更低倍数给消费收入估值，我们的增长故事是否仍成立？

 

 

2025 AGI 编年史：从范式革命到商业黎明

一位 AI 老兵关于搜索消亡、交互重构与自动驾驶终局的回望

前言：当“不可能”成为“基准”

在 AI 领域，“老司机”的直觉往往来自于对摩尔定律的肌肉记忆。然而，2025 年的进程并非线性的爬升，而是一场多维度的坍塌——物理世界、人类审美、信息获取逻辑以及智力分工的旧边界，正被多模态大模型和代理架构击穿。

这一年，我们正式跨越了从“模仿”到“理解”，再到“自主执行”的鸿沟。

【上篇】感官与信息的终结：主权移交

1.1 审美民主化：概率空间内的“车载循环”

Suno 5 的出现，标志着“生成式审美”已在概率空间内锁定了人类的共鸣频段。

  • 它不再是简单的音符堆砌，而是对人类情感曲线的精准映射。当一个从未受过训练的“乐盲”随手生成的作品能达到“车载循环而不腻”的标准时，传统的作曲培训已成为一种古典爱好。

1.2 搜索的祭日：SEO 的黄昏与真理的直达

2025 年，传统的搜索模式（Search Indexing）正式退居后台。曾经养活了无数公司的 SEO（搜索引擎优化） 逻辑彻底崩盘。

  • 范式颠覆：当 OpenAI、Perplexity 乃至自我革命后的 Google 直接提供答案时，用户不再需要从“十个蓝色链接”和满屏的关键词竞价广告中翻找信息。
  • 核心转变：搜索从“寻找（Find）”进化到了“获取（Acquire）”。这意味着互联网流量的分发权从关键词博弈转移到了语义理解，旧的商业帝国正在失去其地基。SEO 正在成为历史名词。

【中篇】交互与物理的接管：从辅助到主宰

2.1 FSD V14：从“数据质疑”到“Apples to Apples”的硬核证言

关于特斯拉 FSD 的安全性，我曾是“怀疑同情派”。过去，自动驾驶数据常因“人类在危险时刻接管”而存在统计学偏差。但 2025 年，FSD V14 终结了这场辩论。

  • 逻辑转折：以前的统计被质疑是由于人类只在简单路段开启。但现在，多数用户 99% 以上的里程（包括极端复杂路段）全由 FSD 完成。这种趋向有实时数据累积数据佐证，非常明显。
  • 硬核证言：当人工干预几乎归零，当方向盘几乎没被人类触碰过，这种对比就是真正的 Apples to Apples。FSD 的安全性比人类平均水平高出 n 倍，这不是实验室的模拟，而是真实的物理世界奇点。

2.2 交互的“不归路”：手机与车载的 Agent 化

  • LLM-Native 交互：以“豆包手机”为代表的新物种，展示了原生 AI 交互如何碾压传统的 手机使用习惯以及App 生态。一旦用户习惯了“一句话解决问题”，就再也无法容忍在 App 之间手动跳转。这是一条不归路。
  • 车载向导（Guide Agent）：车载语音正从“人工智障”进化为 Tesla Grok 这种具备动态导航能力的 Agent。它不再只是单一的执行命令，而是在理解你的意图和环境。交互的进化也是一条不归路，舒适区的迁移从来不可逆。

【下篇】认知的洗牌与商业的荒原

3.1 智力劳动的“碾压”：从程序员到分析师

2025 年，Coding Agent 和 Deep Research 模型不再是辅助工具，它们是“数字员工”。当 Agent 能够独立管理整个代码仓库，并在超长窗口中进行跨维度的长程推理时，初级白领的价值正在被迅速抹平。这不是竞争，这是维度的降临。

3.2 商业闭环的本质矛盾：企业上下文的“上下对进”

这是 2025 年最扎心的事实：95% 的 AI 应用未见商业闭环。

  • 白硕老师的深刻洞察：瓶颈在于“企业上下文（Enterprise Context）”的根源性矛盾。
  • 大师深度剖析：现存企业的上下文是在“非 AI 时代”构建的，那是一套自底向上、基于技术视角堆砌的底层代码和碎片化系统。而 AI 要求的语境是自顶向下的——先有大模型“本体”，再展开到具体的 LLM-native 数据落地。
  • 相向而行：对于存量企业，这要求一场脱胎换骨的“重治理”。这种从底层的技术重构到顶层业务逻辑的“上下对进”，正是 Palantir 等公司能在大模型时代横刀立马的关键。无法实现“AI 就绪”的企业，终将在黎明前的黑暗中耗尽氧气。

结语：在奇点之上，做清醒的观察者

2025 年不是一个终点，而是一个“旧世界”崩塌前的最后告别。

当搜索退居幕后，当交互重归自然，当 FSD 解放双手，我们作为“人类”的独特性究竟还剩下什么？或许，AGI 带来的最大礼物，就是逼迫我们从“做工”的琐碎中抽身，去追问关于存在的意义。

 

AI Reflections on 2025

When Agents Take Over the Entry Points: Search Moves to the Background, and Your Phone and Car Start “Doing Things for You”

In 2025, multimodal models and agents pushed AI from “answering questions” to “getting things done.” Suno v5 made it possible for ordinary people to reliably produce loop-worthy music; Sora 2 moved video generation from isolated clips toward storyboarded narratives with consistency; and widespread day-to-day use of FSD makes the safety conversation feel closer to apples-to-apples. A deeper shift is happening at the entry points: Google/OpenAI/Perplexity are driving search toward LLM-native experiences; the Doubao phone experience makes OS-level GUI agents tangible; and Tesla’s in-car Grok signals a transition from rigid voice commands to a true guide agent. The contrast between rapidly improving capability and slow commercial closure remains stark—but the bottleneck is moving from “model capability” to “system-level deployment.”

I’ve been in AI/NLP for a long time—embarrassingly long, perhaps fossil-level. But what shocked me most in 2025 wasn’t that “benchmarks got better again.” It was something more concrete: I repeatedly confirmed in everyday life that high-bar capabilities—things that used to require expert training and experience—are being productized, democratized, and then distributed at scale to ordinary users.

If we pull “AGI” down from metaphysics into an operational definition—the ability to stably match or approach human-expert output across multiple task domains—then 2025 is the first year I genuinely felt “partial AGI scenarios” landing in the real world: music creation, short-form video creation, autonomous driving, and a deeper entry-point revolution (search, phone interaction, in-car voice) all resonating at the same time.

As 2025 closes, I want to connect these seemingly separate shifts with one unified framework—and add a few personal “micro-cases,” so the argument doesn’t stop at industry buzzwords.

0) From “Information Entry Points” to “Action Entry Points”: Agents Are Eating the GUI

What truly happened in 2025 is a migration in how we enter and operate systems:

  • The old internet was GUI-driven: click buttons, open apps, hunt menus, click links.
  • More and more critical scenarios are becoming intent-driven: you say what you want; the system decomposes the task, calls tools, produces results, and continues executing.

If you break this into an “agent stack,” you’ll notice that music, video, driving, search, phone, and in-car experiences are all converging on the same engineering blueprint:

  1. Intent capture: natural language / voice / image becomes the primary interface
  2. Planning & decomposition: turn goals into executable multi-step tasks
  3. Tool use: call APIs—or directly operate across apps via the GUI (a GUI agent)
  4. Memory & personalization: continuously learn preferences, habits, and context
  5. Verification & governance: results are checkable, traceable, and risk-controlled

Once you see this, you realize: whoever owns the entry point rewrites the ecosystem. “Search moving to the background,” “the app economy being redefined,” and “in-car assistants evolving into guide agents” are not three different stories—they are three battlefields of the same story.

1) The Democratization of Music: Suno v5 Lets Even the “Musically Illiterate” Produce Loop-Worthy Songs Reliably

Suno’s version timeline mirrors 2025: v4 (2024.11) → v4.5 (2025.05) → v5 (2025.09). The company framed v5 as its most important technical leap—more coherent structure, more professional transitions, more natural audio and vocals—and rolled it out to Pro/Premier in late September 2025.

My micro-case: The “car-loop” bar gets broken

My personal metric is extremely simple: can it loop in the car without getting annoying? Not just self-indulgence—the loop has to survive real-world validation (starting with friends, family, and followers).

In 2025, with surprisingly little effort, I used Suno to create multiple loopable pop ballads / melancholic tracks. One of them is a breakup scene at “the last train, the platform”—that style of writing you probably know: catchy but not overstimulating, repetitive but not mechanical, sadness like steady, continuous drizzle. The key wasn’t “producing a melody.” It was that I could use plain language to tune the structure into a stable region—narrative density in the verses, emotional lift in the chorus, and the turning force of the bridge—iterating until it stayed listenable on repeat.

Historically, that was almost unthinkable for non-musicians. And even among experienced composers, truly loop-worthy—and widely loved—songs are the exception, not the norm.

The real meaning of music democratization isn’t “everyone becomes a musician.” It’s that ordinary people can reliably acquire a meaningful slice of a musician’s productivity—and experience the joy of creation and acceptance.

2) The Democratization of Video: Sora 2 Turns “Imagination” into “Deliverable Footage”

OpenAI released Sora 2 on September 30, 2025, positioning it as a flagship model with greater controllability, realism, stronger physical plausibility, and synchronized generation for video and audio (dialogue and sound). It also promoted an LLM-native “TikTok-like” creation flow via the Sora app and sora.com, along with social/entertainment community building.

My micro-case: From “cool clips” to storyboarded narrative production

I tried creating a short piece: an “80s campus romance.” Not a single flashy shot, but a storyboard organized into multiple scenes—opening mood, the first encounter, emotional progression, conflict and pause, and a final look-back. In early video models, the biggest pain point was character consistency and task consistency: you could easily get beautiful shots, but it was hard to carry the same person reliably across scenes.

In 2025, I felt—for the first time—that this started becoming “engineering-solvable.” You can treat it as a production pipeline rather than gambling on luck. Sora 2’s productization (clonable digital actors, controllable rendering, tooling, and distribution entry points) is pushing that transformation.

Short-form video’s red ocean gets reshaped not because AI merely boosts efficiency, but because it expands the deliverable boundary of imagination.

3) The Democratization of Autonomous Driving: FSD v14 and a Turning Point in Comparability

To me, the release of Tesla FSD v14 marks autonomous driving as effectively a “solved problem” in the sense that ordinary users can verify the experience for themselves. Since the end-to-end breakthrough with FSD v12 more than a year ago, the system has shown accelerating improvement, culminating in v14. My own experience—and feedback from many former skeptics after trying it—points in the same direction: FSD is at or above seasoned-driver level, not only smooth but also (per Tesla’s own statistics) significantly safer than average human driving (Tesla’s latest narrative often cites figures like “7× fewer accidents”). Tesla also describes “unsupervised” driving as beginning limited deployments in parts of Texas, and positions the Cybercab—purpose-built for robotaxi service—as scaling production in 2026: no steering wheel, no pedals, relying entirely on FSD, with extremely rare edge cases potentially requiring remote intervention (on the order of once per ~10,000 miles at most).

My micro-case: “Near-100% FSD usage” creates an apples-to-apples intuition

I used to be a skeptic—at least a sympathetic skeptic. The reason is straightforward: Autopilot-era statistics are easy to challenge. In complex, risky, or ambiguous situations, humans are more likely to disengage the system and take over, making “it’s safer when enabled” look better than it truly is—a potentially misleading selection bias.

But today, the driving behavior of many owners (including me) has changed structurally. In the first few days after getting a new car, I used FSD for almost 100% of my mileage—except small maneuvers like intervening when I didn’t like the parking spot FSD chose and explicitly directing it to a specific space. Under this “coverage near saturation” usage pattern, selection bias shrinks significantly—at least in the sense of the same driver, same car, same living radius, which feels much closer to apples-to-apples. That’s why when Tesla continues to use “fewer collisions than the U.S. average (e.g., 7×)” as part of its narrative, my intuition about comparability is stronger than it used to be—while I fully acknowledge that methodological controversy in society still exists, and should exist.

The shift in 2025 isn’t that “the controversy disappears.” It’s that changes in user behavior begin to weaken the most central controversy point (selection bias). The discussion naturally moves from “can it?” to “where are the boundaries, and how do we govern it safely?”

4) Search Is Destined to Be Rebuilt: The Old Keyword-Auction World Starts to Loosen

“Search moving to the background” is not about dismissing search; it’s about search evolving from “link retrieval” to an entry point that fuses answers with action.

Three threads converged in 2025:

  1. Google’s self-revolution: expanding AI Overviews and introducing experimental AI Mode—explicitly pushing search toward a more conversational, integrated “Q&A + reasoning + browsing” experience. They even introduced more personalized result rendering and call it “generative UI.”
  2. OpenAI entering the core search/browsing arena: ChatGPT Search was updated on Feb 5, 2025 to be available in supported regions to everyone without sign-in, and the company kept accelerating productization and capability.
  3. Perplexity capturing “answer engine” mindshare while triggering copyright conflict: late-2025 lawsuits (e.g., the Chicago Tribune case) put the impact of LLM-native search on content ecosystems and traffic allocation directly under the spotlight.

What truly destabilizes the old business model is this: when users stop “clicking links” and instead get a first-screen AI result that they can keep interrogating and can directly act on, keyword auctions won’t vanish overnight—but they will be forced to migrate into new placements and new attribution logic. Google itself is actively discussing marketing and reach strategies under AI Mode / AI Overviews, which is essentially a self-cannibalizing transformation of the business model.

5) Phone Use: Doubao Makes OS-Level GUI Agents Tangible—and It Feels Like a One-Way Road

The “phone use revolution” matters because it touches the foundation of the app economy.

In early December 2025, ByteDance released the “Doubao Phone Assistant (technical preview)” and partnered with phone makers, describing it as an OS-level capability: it can see the screen, use apps, and execute cross-app tasks (organize files, fill forms, recommend restaurants, etc.). In essence, it upgrades “operating a phone” from click workflows to an intent-driven interactive GUI agent. Voice is the most natural interface for humans—our devices should not be the exception.

My micro-case: Why it feels irreversible

The shock of an OS-level agent isn’t “yet another assistant.” It’s that it changes the behavioral economics. Once you’ve experienced “say one sentence and it runs dozens of clicks for you,” it’s hard to tolerate the old mode. Apps stop being “products directly operated by users” and start looking more like backend services invoked by agents.

Once that path is real, competition in the phone industry shifts from “hardware specs + app ecosystem” to “OS-level agent capability + tool authorization frameworks + safety governance.”

6) In-Car Voice: From “Artificial Stupidity” to a Real-Time Guide Agent

Historically, in-car assistants had one fatal flaw: they could only execute single, rigid commands—no multi-turn dialogue, little context, and no “dynamic navigation and explanation.” Many people call them “artificial stupidity.”

Tesla’s 2025 Holiday Update indicates that Grok can add/edit navigation destinations, handle multiple destinations in a single instruction, support multi-turn interaction, and dynamically update the route.

This may sound small, but it’s a big signal: in-car voice is evolving from a one-command “menu remote” into a guide agent—it can understand intent, sustain dialogue, and revise plans in real time. Combine it with FSD, and you get a sharper thesis:

  • FSD answers: how the car drives.
  • The in-car voice agent answers: where you’re going, why, and what you can do along the way.
  • Together, they form the early shape of a complete mobility agent.

7) Coding Agents and Deep Research: The White-Collar Skill Crash Test Zone

By late 2025, coding agents covering junior-engineer throughput and deep-research systems approaching or exceeding senior analyst output and quality are no longer a question of “can it?” The real question is: how do you integrate it, validate it, and assign accountability to maximize returns.

Their common thread with search/phone/in-car shifts is still the same framework: from information to action, from tool to workflow.

8) The Most Painful Contrast: Capability Explodes, but Commercial Closure Is Still Missing at Scale

In 2025, MIT-related research was widely cited in the media as “95% of GenAI pilots failed to produce measurable ROI,” with the causes pointing to integration, priority mismatch, and organizational friction.

1) Enterprise context is genuinely hard: RAG alone won’t save you

Enterprise context is not a knowledge base—it’s a living system: permissions, responsibility chains, exception processes, inconsistent definitions, legacy systems, and tacit rules. Many failures aren’t “the model can’t answer,” but “the system doesn’t know which path to follow, which interface to call, or who must sign off.”

2) Organizational friction is equally hard—and often more decisive than tech

Even if context can be engineered, enterprises may still resist letting agents take over: compliance/security/procurement/legal/IT gates can grind demos into molasses. Add KPI risk, reputational risk, and dependence on legacy workflows.

So the confusion remains: is context engineering still insufficient, or is it organizational inertia and human barriers? The more accurate answer now is: both, compounded. And in the next few years, the latter (organizational friction) may be even more decisive for deployment speed.

My own view: commercial closure won’t arrive simply by waiting for stronger models. It requires turning agents into deliverable systems through three conditions:

  • Verifiable (metrics and replay)
  • Accountable (responsibility chains and permissions)
  • Embeddable (fits into existing workflows)

Closing: 2025 Is the Eve of AGI

AGI won’t arrive as a single thunderclap. It arrives when entry points are taken over by agents—and suddenly the old way of operating the world feels clumsy, expensive, and unsustainable.

What I see as deterministic after 2025:

  • Search is moving from links to answers-and-action, loosening the old traffic allocation logic.
  • Phones are moving from a collection of apps to OS-level agent orchestration; apps are redefined as callable services.
  • In-car systems are moving from single command execution to dynamic guide agents, and together with autonomous driving they form the early outline of a mobility agent.

Once these entry points solidify, even the question “Why is AI so hard to commercialize?” must be reframed: it’s not “do you have a model,” but “do you have a system.” Not “can you build it,” but “can you own responsibility, validate outcomes, and embed at scale.”

 

2025 年 AI 感怀

当入口被 Agent 接管，搜索退居后台，手机与汽车开始“替你办事”

2025 年，多模态与 agent 把 AI 从“会回答”推进到“会办事”。Suno v5 让普通人稳定产出可循环音乐；Sora 2 把视频从片段生成推向分镜与一致性生产；FSD 的高覆盖使用让安全讨论更接近 apples-to-apples。更深层的革命发生在入口：Google/OpenAI/Perplexity 把搜索推向 LLM-native 的渲染，豆包手机让 OS 级 GUI agent 可触摸，Tesla Grok 让车载语音向导化。能力狂飙与商业闭环反差巨大，但瓶颈正在从“模型能力”转向“系统化落地”。

我做 AI/NLP 很久了，不好意思，可能是化石级的存在；但 2025 年最让我震撼的并不是“模型评测又强了多少”，而是我第一次在日常里得到反复确认：一些过去需要专家级经验的高门槛能力，正在被产品化、被民主化，进而被规模化地分发给普通人。

如果把“AGI”从玄学拉回到可操作的定义——在多个任务域里稳定达到或逼近人类专家的产出能力——那么 2025 是我第一次切身体验到“部分 AGI 场景落地”的一年：音乐创作、短视频创作、自动驾驶，以及更底层的入口革命（搜索、手机交互、车载语音）开始同频共振。

2025年终前，我想用一个统一框架把这些看似分散的变化串起来，并补上我自己手上的几个“微案例”，让判断不止停留在行业热词。

零、从“信息入口”到“行动入口”，Agent 正在吞掉 GUI

2025 年真正发生的，是入口形态的迁移：

  • 过去的互联网是 GUI（图形界面）驱动：人点按钮、开 App、找菜单、点链接。
  • 现在越来越多关键场景开始变成 Intent（意图）驱动：人说“我想要什么”，系统自己拆任务、调用工具、给出结果并继续执行。

把这件事拆成一个“Agent 栈”，你会发现音乐、视频、驾驶、搜索、手机、车载，底层其实是同一种工程路线：

  1. 意图捕获：自然语言/语音/图像输入成为主入口
  2. 规划与分解：把目标拆成多步可执行任务
  3. 工具使用：调用 API、或直接在 GUI 上跨 App 操作（GUI agent）
  4. 记忆与个性化：持续理解你的偏好、习惯与上下文
  5. 验收与治理：结果可验证、可追溯、可控风险

你会看到：谁掌握入口，谁就重写生态。于是“搜索退居后台”、“App 生态被重定义”、“车载助手从指令执行变成向导 agent”并不是三件事，而是一件事的三个战场。

一、音乐民主化：Suno v5 让“乐盲”也能稳定产出可循环的歌

Suno 的版本演进很能代表 2025：v4（2024.11）→ v4.5（2025.05）→ v5（2025.09）。官方把 v5 定义为“最重要的一次技术跃迁”，强调结构连贯、过渡更专业、音质与人声更自然，并在 2025 年 9 月下旬向 Pro/Premier 推出。

我的微案例（车载循环门槛被击穿）
我自己最信的标准非常朴素：能不能车载循环不腻。不仅是自我陶醉，而是要有共鸣的验证（先从亲友和 folowers开始）。

2025 年，没费什么力气，我就用 Suno 做过多首“可循环播放的流行抒情/伤感歌”，其中一首写的是“最后一班地铁、月台”的分手场景（你知道那类写法：旋律抓耳但不过度刺激、结构重复但不机械，忧伤像连绵的细雨）。最关键的不是“写出一段旋律”，而是我能用自然语言把结构调到一个稳定区间——Verse 的叙事密度、Chorus 的情绪提升、Bridge 的反转力度，反复迭代到“循环也不烦”。这在过去对非音乐人来说几乎不可想象（其实资深音乐人中要制作可以让人车载循环，甚至家喻户晓的歌曲的，也只是少数人，在少数的作品中）。

音乐民主化真正的含义不仅仅是“人人可成音乐家”，而是：普通人第一次能稳定获得音乐家的（部分）生产力，并体验创造以及被接受的乐趣。

二、视频民主化：Sora 2 把“会想象”变成“能成片”

OpenAI 在 2025 年 9 月 30 日发布 Sora 2，并将其定位为更可控、更真实、更贴近物理世界、同时支持同步对白与音效的旗舰视频与音频同步生成模型，并以 Sora App 与 sora.com 推广LLM-native的“类抖音”使用链路，及其社交与娱乐社区的建设。

我的微案例（从“片段生成”到“可叙事的分镜生产”）
我做过一个“80 年代校园恋曲”的短片尝试：不是单段炫技镜头，而是按 n 个 scene 的分镜组织（开场氛围、人物相遇、情绪推进、冲突与停顿、尾声回眸）。在早期视频模型里，最大痛点是角色一致性与任务一致性：你很容易得到“好看的镜头”，但很难把同一个人稳定地带过多个 scene。2025 年我第一次感觉到这件事开始变得“工程化可解决”——你可以把它当作一种生产流程，而不是赌运气。Sora 2 的产品化（数字演员可克隆、渲染可控性、工具链、分发入口）本质上在推动这种转变。

短视频的红海之所以会被重构，是因为 AI 不只是提效，而是在扩大想象力的“可交付边界”。

三、自动驾驶民主化：FSD v14 带来的“可比性”转折点

Tesla FSD V14 的推出标志着自动驾驶已经是一个 solved problem，人人可验证。自从一年多前 FSD V12 端到端模型的突破，自动驾驶展现了加速度提升的趋势，直到不久前 FSD V14 的推出。自己的亲身体验以及很多怀疑论者体验后的反馈都指向了这个事实：FSD 已经达到或超过老司机的驾驶水平，不仅丝滑顺畅，而且安全性比人类驾驶的平均水品高（特斯拉最新的统计是比人类驾驶减少7倍的事故）。真正的FSD无人驾驶（特斯拉称为“无监督驾驶”）现在已经在得克萨斯部分区域开始上路。特斯拉专为无人出租设计的 Cybercab 2026年就会规模化量产：这些车辆没有方向盘和脚踏板，全靠FSD实现无人驾驶（可能在极为罕见的特殊情形下，需要远程干预，“极为罕见”指的是大约每一万英里车程最多出现一次这种情形）。

我的微案例（“几乎全程 FSD”带来的 apples-to-apples 直觉）
我以前也是怀疑派或“同情怀疑派”。原因很简单：Autopilot 时代的统计很容易被质疑——遇到复杂、危险或不确定时，人更可能退出系统、手动接管，从而让“开启系统时更安全”显得更漂亮，有潜在的误导性。

但现在多数车主（包括我自己）的驾驶行为发生了结构性变化。拿到新车的几天里，我几乎 100% 的里程都在用 FSD（除了当我不满意FSD给我选择的停车位而干预，告诉FSD指定车位停车这种零碎动作）。在这种“覆盖率接近满值”的使用形态下，选择偏差会显著缩小，至少在“同一个驾驶者、同一辆车、同一生活半径”意义上更接近 apples-to-apples。于是当 Tesla 继续用“相对美国平均水平碰撞更少（例如 7x）”的叙事时，我对其可比性的直觉确实比过去更强——尽管方法学层面的社会争议仍然存在。

2025 年的变化不在于“争议消失”，而在于用户行为改变使得关键争议点（选择偏差）开始被削弱；于是讨论重心会从“能不能”转向“边界在哪里、怎么治理更安全”。

四、注定被重构的搜索：关键词竞价的旧世界开始松动

“搜索退居后台”并不是唱衰搜索，而是搜索的形态正在从“链接检索”变成“答案与行动的协同入口”。

三条线索在 2025 年同时成立：

  • Google 的自我革命：扩展 AI Overviews，并引入实验性的 AI Mode，明确把搜索推向更对话式、更综合的“问答+推理+浏览”体验。他们甚至率先推出了千人千面的结果渲染方式，称为 generative UI。
  • OpenAI 进入 search/browsing 主战场：ChatGPT search 在 2025 年 2 月 5 日更新为“在可用地区对所有人开放、无需注册”，并持续加码搜索能力与产品化节奏。
  • Perplexity 抢占“答案引擎”心智，同时引爆版权冲突：2025 年末围绕 Perplexity 的新闻诉讼（例如 Chicago Tribune 起诉）把“LLM-native search”对内容生态与流量分配的冲击推到台前。

真正会动摇旧商业模式的点在于：当用户不再“点链接”，而是“在 AI 首屏得到可继续追问、可直接行动的结果”，关键词竞价仍会存在，但会被迫迁移到新的版位与新的归因逻辑里。Google 自己也在讨论 AI Mode/AI Overviews 语境下的营销与触达路径，这本质上是一次自我吞噬式的商业模式转型。

五、Phone use：豆包手机把 OS 级 GUI Agent 变成了可触摸的现实

“phone use 革命”很关键，因为它触碰的是 App 生态的地基。

ByteDance 在 2025 年 12 月初推出“豆包手机助手技术预览版”，并与手机厂商合作，将其描述为 OS 级能力：可以看屏幕、用 App、跨应用执行任务（整理文件、填表、推荐餐厅等），本质上是把“操作手机”从点击流程升级为意图驱动的交互式 GUI agent。语音是人类最自然的交互方式，人机交互不再例外。

我的微案例（为什么它是“不归路”）
OS 级 agent 的震撼不在于“又一个助手”，而在于它改变了行为经济学：当你体验过“说一句话，它替你跑完几十次点击”，你很难再回到旧方式。于是 App 不再是“用户直接操作的产品”，而更像“agent 调用的底层服务”。这条路一旦成立，手机行业的竞争维度就会从“硬件参数 + App 生态”转向“OS 级代理能力 + 工具授权体系 + 安全治理”。

六、车载语音：从“人工智障”到实时向导 Agent

车载助手过去最大的问题是：它只会执行单一的固定指令，无法多轮交互，缺乏上下文，更缺乏“动态导航与解释”，很多人称之为“人工智障”。

2025 年 Tesla Holiday Update 的信息显示：Grok 已支持添加/编辑导航目的地，并可在指令里处理多个目的地，并可以多轮交互，动态更新旅程线路。

这件事看似小，但意义非常大：它表明车内语音开始从单一指令的“菜单遥控器”进化为guide agent——能理解意图、能连续对话、能实时改计划。把它与 FSD 放在一起看，你会得到一个更锋利的判断：

  • FSD 解决的是“车怎么开”；
  • 车载语音 agent 解决的是“你要去哪里、为什么去、顺路还能做什么”；
  • 两者结合，才是完整的“移动场景代理”。

七、Coding agent 与 deep research：白领技能被碾压的试验场

到 2025 年末，coding agent 覆盖初级工程师的代码产出、deep research 逼近或超越高级分析师的产能与品质，已经不再是“能不能”的问题，而是要讨论“怎么嵌进组织、怎么验收、怎么负责”，才能最大化其收益。它们与搜索/手机/车载的共同点仍然是同一个框架：从信息到行动，从工具到流程。

八、最扎心的反差：能力狂飙，但商业闭环大面积缺失

MIT 相关研究在 2025 年的报告语境下被媒体广泛引用为“95% 的 GenAI 试点没有产生可衡量 ROI”，并将原因指向集成、优先级错配、以及组织层面的摩擦。

1）企业上下文确实难：不是 RAG 一把梭能补齐

企业上下文不是知识库，是活系统：权限、责任链、例外流程、口径冲突、遗留（legacy）系统、隐性规则。很多失败不是“模型不会答”，而是“系统不知道该走哪条路、调谁的接口、谁来最终签字”。

2）组织摩擦同样难：往往比技术更决定节奏

哪怕上下文能补齐，企业也不一定愿意让 agent 接管：合规、安全、采购、法务、IT 的串联门槛会把 demo 磨成龟速；此外还有 KPI 风险与声誉风险，以及对 legacy 流程的路径依赖。

困惑是——到底是 context 工程还不够，还是企业惰性与人为障碍？现在看来，更准确的答案是：两者叠加。并在今后几年，后者（组织摩擦）可能更决定落地速度。

我自己的判断是：商业闭环不是“等模型更强”就自然出现，而要靠三件事把 agent 变成可交付系统：

  • 可验收（指标与回放）
  • 可负责（责任链与权限）
  • 可嵌入（进入现有工作流）

结语：2025 是AGI前夜

AGI 的到来不会是一声惊雷，而是一连串入口被 Agent 接管后，旧世界的操作方式突然显得笨拙、昂贵、且不可继续。

2025 年我看到的确定性是：

  • 搜索正在从链接走向答案与行动，旧流量分配逻辑开始松动；
  • 手机正在从 App 集合走向 OS 级代理调度，App 被重定位为“可调用服务”；
  • 车载正在从指令执行走向 guide agent，与自动驾驶一起构成移动场景代理的雏形。

当这些入口同时成立，“AI 应用为什么很难商业闭环”的问题，也会被换一种问法：不是“有没有模型”，而是“有没有系统”；不是“能不能做”，而是“能不能负责、能不能验收、能不能规模化嵌入”。

 

 

正常的模型反哺不会导致模型坍塌

某些关于再生数据造成“模型坍塌 (Model Collapse)”的说法其实是危言耸听，模型反哺造成 Self-Improvement (自我进化) 具有内在的根本逻辑：只要存在“优胜劣汰”的拣选机制，合成数据就不是“近亲繁殖”，而是“定向进化”。

1. 为什么“模型坍塌”在工程上是伪命题？

那些声称“模型吃合成数据会变傻”的论调，通常预设了一个天真甚至愚蠢的前提：无差别的递归训练 (Naïve Recursive Training)。

他们是这样想/做/论的：

  1. 模型生成 100 条数据（好坏参半）。

  2. 不加筛选，把这 100 条全喂回去训练下一代。

  3. 循环 N 次。

结果：当然会坍塌！就好比一张图片被复印N次，只会越来越糟。

但现实是：

没有任何一个正常的算法（工程师）会这么干。默认的practice是 Rejection Sampling (拒绝采样)：

  1. 模型生成 100 条数据。

  2. Verifier/Human 介入：砍掉 90 条，只留 10 条最好的（Advantage 恒大于 0）。

  3. 用这 10 条精英数据训练下一代。

数学推导：

只要 Mean(Selected Data) > Mean(Current Model Policy)，模型在下一轮的平均水平必然上升。

这不叫坍塌，这叫 Distillation of Success (成功的蒸馏)。

2. “反哺”的本质：把长尾变成主流

想象一个正态分布曲线（模型的输出质量）：

  • 左尾：胡说八道。

  • 中间：平庸的回答。

  • 右尾 (The Long Tail)：偶尔出现的灵光一现（高智商回答）。

我们的拣选机制（Verifier/Checklist），本质上就是一个滤波器。我们只把右尾的那部分剪下来，当作 Ground Truth 去训练模型。

通过训练，模型会将概率密度向右移动——把“偶尔的灵光一现”，变成“稳定的肌肉记忆”。

这就是 AlphaGo 为什么能左脚踩右脚上天，也是现在 LLM 能做推理强化的底层逻辑。

3. “自生自灭”的 AIGC 达尔文主义

“AIGC 在互联网上自生自灭”，可以称为 RLHF at Internet Scale (互联网规模的 RLHF)。例如：

  • 生成：Midjourney 每天生成 1000 万张图。

  • 筛选 (Environment Reward)：只有那些被用户保存、转发、点赞的图，才会留存在互联网的显眼位置。烂图都在缓存里被删了。

  • 结果：下一代模型再去爬取互联网数据时，爬到的全是经过人类审美筛选过的合成数据。

所以，互联网并没有被合成数据污染，它只是经历了一次更残酷的自然选择。留下来能被再次爬取到的，本质上已经是“人类偏好”的结晶。

4. 风险：不是“变傻”，而是“变窄”

既然模型不会退化，那我们在用合成数据时，到底在防备什么？

其实不是 Model Collapse (模型坍塌/变傻)，而是 Mode Collapse (模式坍塌/变窄)。

目前做法的副作用可能有：

  • 筛选器的偏见：如果我们的 Verifier（或者人类点赞）只喜欢某种特定的风格（比如“条理清晰的八股文”）。

  • 多样性丧失：经过多轮迭代后，模型生成的每一句话都极度完美、极度正确，但也极度同质化。它可能失去了那种“有点混乱的创造力”。

但这在工业界通常是可以接受的代价。 尤其是对于写代码、做数学、看财报来说，我们不需要它“五花八门”，我们需要它“收敛到真理”。

总结

“模型退化论”在有严格 Verifier 的系统中就是无稽之言。

  • 没有筛选的合成数据 = 近亲繁殖 = 畸形。

  • 经过严选的合成数据 = 优生优育 = 进化。

数据飞轮 (Data Flywheel) 之所以能转起来，全靠这个 Delta —— 即筛选后的数据质量与模型平均质量的差值。只要这个 Delta 是正的，模型就会一直变强，直到触碰到 Verifier 本身的天花板（Teacher 的判断力上限）。

多模态进化论：从“看图说话”到“原生直觉”

我们经常感叹现在的 AI 能看懂复杂的梗图，甚至能像物理学家一样分析视频里的运动轨迹。剥开那些炫酷的 Demo，核心的竞争壁垒其实主要是两件事：给模型吃什么（数据形态），以及让模型怎么学（训练范式）。

我们拆解一下，模型是如何进化成懂物理、懂逻辑的“原生多模态生物”的。

一、 数据形态：决定智商上限的“燃料”

模型最终能有多聪明，取决于它吃的是“快餐”还是“正餐”。

1. 图文对 (Image-Text Pairs)：高效的“单词卡片”

这是多模态起步时代的产物（如 CLIP/LAION）。

  • 形态：一张图 + 一句短描述（Caption）。

  • 本质：这就像给婴儿看“识字闪卡”。正面画着猫，反面写着“猫”。

  • 局限："Bag-of-Objects"（物体词袋）偏差。模型通过这种数据只能学会“点名”——它知道画面里有“人”、有“雨”、有“笑容”，但它无法理解这些元素之间的逻辑。

    • 经典幻觉：看着一个人在雨中大笑，模型却说他很悲伤。因为它记住了“雨=悲伤”的文本统计规律，却常常看不懂画面里的情绪反差。

2. 原生交错数据 (Native Interleaved Data)：连贯的“教科书”

这是 Gemini、GPT-4V 等多模态原生模型的关键数据。

  • 形态：文本 -> 图片 -> 文本 -> 视频 -> 文本。

  • 本质：这是人类观察世界的真实方式——连续、有因果、有上下文。

  • 魔力：学会“预期违背”。当模型读到：“宣传册上是豪华海景房，然而当我推开门……” 随后看到一张破烂杂乱的照片。

    为了预测这张烂照片，模型必须理解 “然而” 代表逻辑反转。这就是推理能力的涌现时刻。

二、 训练范式的代际跨越：从“拼接”到“原生”

旧范式：先认字，后读书（LLaVA Style）

早期做法是“拼接”。

  1. 预热期：先喂海量“单词卡片”，把视觉编码器（眼睛）和 LLM（大脑）强行对齐，解决“语言不通”的问题。

  2. 微调期：最后才喂少量“教科书”来教指令跟随。

  • 缺点：根基不稳。模型本质上还是一个翻译官，看着图片翻译成词，再用语言逻辑去猜。

新范式：原生直觉 (Native from Day 1)

现在的趋势（如 Gemini）是大一统。

  • 策略：从预训练的第一天起，就大量注入原生交错数据。

  • 效果：模型不需要“翻译”。视觉 Token 和文本 Token 在它的神经网络里是平权的。它不是“学会了”物理定律，而是通过预测下一个 Token，“直觉”地掌握了物理世界。

    • 例子：预测玻璃杯掉落。模型并不是在脑子里检索“玻璃易碎”的文本知识，而是视觉 Token [玻璃] + [下落] 直接触发了 [破碎] 的预测路径。这是一种类似人类的物理直觉。

三、 终极抉择：量子坍缩与思维链

当模型有了直觉，下一步就是处理复杂的逻辑难题（Math/Coding）。这里，AI 界正面临一个哲学层面的技术分歧。

1. 显式思考 (O1 路线)：忍受“量子坍缩”

目前的当红炸子鸡（以OpenAI o系列为代表）选择让模型把思考步骤一步步写出来（Token 化）。

  • 比喻：Token 化就像量子坍缩。思维原本是高维、连续、充满可能性的波函数（Hidden State），一旦被输出成 Token（文字），就瞬间坍缩成了一个确定的、离散的符号。

  • 代价：信息损耗。大量模糊的、并行的直觉在变成文字的那一刻丢失了。

  • 收益：可解释性。虽然笨，但我们能看懂它在哪一步想歪了，并且为每一步打分的过程奖励（Process Reward）留下了强化空间。

2. 隐式思考 (Latent Reasoning)：沉默的螺旋

另一派认为，真正的天才不需要喋喋不休。

  • 愿景：让模型在黑盒子里（Latent Space）默默计算 10 秒钟，利用高维向量的并行优势，直接吐出完美答案。

  • 阻碍：“可解释性税” (The Interpretability Tax)。工程界目前不大敢买单。一个深不可测、难以调试的黑盒天才，在安全对齐（Alignment）面前可能是一场噩梦。

结语

多模态大模型的进化史，就是一部从“拼接”走向“原生”，从“模仿”走向“直觉”的历史。

现在的我们，正站在显式思考（Chain of Thought）的高地上，试图通过堆砌 Token 来模拟人类的理性。但也许在不远的将来，当这一波 Scaling Law 撞墙时，那个沉默思考的“Latent 模型”，也许手里有一把通往 AGI 的钥匙。

大模型训练的数据“炼金术”

立委按：在 Transformer 架构趋同的今天，大模型的性能很大程度上决定于数据工作的极致程度。大模型训练数据工作的“后厨”包括从去重算法到数据退火策略等一系列“魔鬼细节”。

在当今的 AI 圈子里，有一个共识：如果说 Infra（基础设施） 是现代化的厨房，Algorithm（算法） 是精湛的烹饪技艺，那么 Data（数据） 就是决定菜肴最终品质的食材。

随着模型架构（Architecture）的红利逐渐收窄，"Data-Centric AI"（以数据为中心的 AI）成为了主战场。数据工作有哪些决定模型智力天花板的细节呢？

1. 数据的“提纯”工艺：从网络废料到精装书

"Garbage In, Garbage Out" 是机器学习的常识。但LLM 的数据工作不仅仅是简单的清洗，而是一场精密的数据外科手术。

直观感受：什么是“好”数据？

我们常说的“清洗”，其本质是信噪比（Signal-to-Noise Ratio）的提升。让我们看一个真实的 CommonCrawl 网页数据处理前后的对比：

维度 原始数据 (Raw Web Data) 🔴 清洗后数据 (Refined Data) 🟢
内容片段 <div>广告：点击购买... <br> 楼主：不懂别乱说... 2023-05-12 热力学第二定律表明，孤立系统的熵永远不会减少...
特征 包含 HTML 标签、导航栏噪声、情绪化宣泄、无关广告。 语义连贯、逻辑完整、格式标准。
模型视角 噪声掩盖了语义，模型容易学到“点击这里”这种无意义短语。 信息密度高，模型能专注于学习知识推理。

隐形的魔鬼：去重 (Deduplication)

仅仅洗干净还不够，最大的隐患在于重复。研究表明，如果训练集中包含大量重复文本，模型就会倾向于“死记硬背” (Memorization) 而非 “泛化规律” (Generalization)。

但互联网充满了“洗稿”和转载，简单的字符串匹配（Exact Match）对此无能为力。业界标准是引入 MinHash LSH (Locality Sensitive Hashing) 算法：

  • 指纹识别：它不比较整篇文章，而是提取文章特征的哈希“指纹”。

  • 模糊去重：即使两篇文章改了几个词、换了段落顺序，只要 Jaccard 相似度 超过阈值（通常设为 0.7-0.8），算法就能识别出它们是“软重复”并进行剔除。

这一步至关重要：它不仅防止模型“作弊”，还能显著提升训练效率——毕竟，没人想花几百万美元让 GPU 反复阅读同一篇新闻通稿。

2. 洁癖的代价：教科书 vs. 烟火气

微软的 Phi 系列证明了“教科书级”数据能带来极强的推理能力。但是，数据并非越干净越好。

如果我们只用完美的“温室数据”训练，模型会变成一个“高智商的书呆子”：逻辑推理极强，但面对用户充满口语、俚语甚至错别字的真实 Prompt 时，会因为 OOD (Out-Of-Distribution) 问题而表现出较差的鲁棒性。

解决方案：数据退火 (Data Annealing)

为了兼顾“聪明”和“接地气”，业界借鉴了人类的学习路径，采用 “先博学，后专精” 的课程学习策略：

  1. 前期（博学）：喂食海量、多样化的网络数据，增加模型的见识和对噪声的容忍度。

  2. 后期（冷却/Cool-down）：在训练的最后阶段（如最后 10% 的 Token），集中使用高质量的“教科书”数据进行冲刺，强行把模型的思维拉回到严谨、逻辑的轨道上。

3. 寻找黄金配方：为什么是 7B？

数据配比（Mix Ratio）是训练中的 secret source。代码、数学、通识文本该按什么比例混合性能效果最佳？这需要大量的 消融实验 (Ablation Studies)。

这里存在一个 Scaling Laws 的非单调性陷阱：

  • 1B 模型 太弱，往往靠死记硬背，无法反映逻辑数据的价值。

  • 100B 模型 太贵，无法支持高频试错。

因此，7B - 8B 成为了业界的“黄金尺寸” (Proxy Model)。它既处于涌现能力 (Emergent Abilities) 的临界点，具备了初步逻辑能力，又是单张消费级显卡能跑得起来的上限，是验证数据配方的比较合适的实验台。

4. 评估的陷阱：是学会了，还是见过了？

当我们发现某个配方能显著提升 Benchmark（如 GSM8K）的分数时，必须警惕 基准测试泄露 (Decontamination)。

虽然我们应该从训练集中剔除测试题，但 过度清洗 (Over-cleaning) 会导致模型“脑白质切除”。如果我们把所有“长得像数学应用题”的数据都为了避嫌而删掉，模型虽然没见过原题，但也失去了学习“解题范式”的机会。

结论：在“去污”和“保留多样性”之间寻找平衡，是数据科学家的走钢丝艺术。

下一站，合成数据

当人类产生的优质互联网文本快要被“吃光”时，数据工作的下一站已经很明确了：合成数据 (Synthetic Data)。

利用强模型生成数据来训练弱模型（Distillation），或者通过自我博弈（Self-Play）来进化，正在成为突破天花板的新燃料。在未来，谁能构建出更高效的“数据合成工厂”，谁就掌握了通往 AGI 的钥匙。

“如果未来的模型大多由合成数据训练，AI 产生的‘近亲繁殖’会导致智能退化吗？”

再论大模型压缩的“有损”与“无损”

要把这一点说清楚，我们得从一个更底层的问题开始：

什么是“真正的压缩”？
为什么说“压缩就是智能”的同时，又不得不承认大模型在训练上是“有损”的？

一、从第一性原理看“压缩”：柯氏复杂度与上帝视角程序

在信息论和计算理论的深水区，“压缩”的终极定义并不是 zip、PNG 那种工程实践，而是：

给定一段数据，找到能生成它的最短程序。

这就是柯尔莫哥洛夫复杂度（Kolmogorov complexity）：

    • 对一个二进制串 x，K(x) 定义为：
      在某个通用图灵机上，能输出 x 的最短程序长度。
    • 这个“最短程序”就是从上帝视角看，关于 x 的终极压缩：
      再短就描述不了所有细节，再长就是浪费。

注意两点：

    1. 这种压缩从定义上就是无损的：
      程序跑出来的 x 和原始 x 必须逐比特一致，否则就不算“描述了它”。
    2. 绝大多数情况下，K(x) 是不可计算的：
      你不知道是不是还有一个更短的程序在那里暗笑——这就是整个理论派的浪漫所在。

Solomonoff 归纳 / 通用预测再往前迈了一步：
它告诉我们，如果我们不知道“上帝程序”，那就对所有可能程序做一个加权集合，把每个程序视为一个可能的世界生成器，用“越短越优先”的原则，把它们的预测结果做一次加权平均。这样得到的下一步预测分布，在长远上是最优的。

这就是“next-x prediction 作为智能的近似方式”的理论根基：

在终极版本里，“智能”可以被理解为：
找到能生成观察数据的最短程序，并用它来预测下一步会发生什么。

所以在第一性原理层面，“压缩”和“预测”本来就是一体两面：

    • 压缩：把世界浓缩成最短描述；
    • 预测：用这份最短描述，去推演接下来会发生什么。

二、大模型训练：泛化与还原，鱼与熊掌不可兼得

回到大模型。李飞飞说“大模型是有损压缩”，她盯着的是哪一面？

她盯的是具体数据点的还原——也就是我们日常直觉里的那种“压缩 / 解压”。

    • 如果一个模型能对训练集做逐比特无损记忆，
      那它就退化成了一个超大号查表数据库：
      来一个输入，翻翻自己的“记忆表”，照原样吐出来。
    • 这种模型在训练数据上表现完美，却几乎无法泛化；
      面对没见过的问题，只会一脸茫然。

而我们想要的大模型，恰恰不是“背诵冠军”，而是会举一反三的那种。
这就意味着，它必须：

    • 把训练数据中的大量偶然细节和噪音主动丢掉；
    • 只保留那些对预测、推理、交互有用的结构与规律。

白硕老师有一句特别形象的话：“无损和泛化，不可能装在一个壶里。”

    • 如果你对每一个训练样本都做 bit 级无损，
      你就没有足够的“容量”去抽象出高层规律；
    • 如果你要在有限参数里塞进“规律”，
      你就必然把大量具体细节归入“噪音”，予以舍弃。

这就是为什么：

幻觉（hallucination）不是一个简单的 Bug，而是泛化的副产品。

从“还原事实”的角度看，幻觉当然是“错”的，是“有损”的体现；
但从“根据学到的分布做出合理推断”的角度看，很多幻觉其实合情合理——只是跟那条具体事实的“黄金标准”不一致而已。

因此，在“模型对世界的表征”这一层面上，说：

大模型是一种有损的世界压缩器

是成立的：它压缩的不是某一篇具体文本，而是整片大数据的分布，代价就是丢失大量局部细节。

三、大模型赋能的“无损”：固定模型 + 算术编码

问题来了：那 Ilya 为什么又一次次强调“LLM 做的是无损压缩”？他总不能没读过教材里的“无损 = 可完全还原”定义。

关键在于：他讨论的，是另一层意义上的“压缩”——对给定数据序列的工程性无损压缩。

故事换成这个版本就很清晰：

    1. 假设我们手里有一个训练好的大模型 M，它给每个 token 在上下文下的条件概率 P_M(tok | context)。
    2. 现在我们拿到一段具体文本 x，问：能不能用 M 来对 x 做无损压缩？
    3. 答案是：可以——用算术编码（arithmetic coding）。

大致做法是：

    • 发送端和接收端事先都装好同一个模型 M；
    • 发送端对文本 x 从头到尾扫描：
      每看到一个 token，就让 M 给出当前所有可能 token 的概率分布，
      再用算术编码把整个序列映射到一个很小的实数区间；
    • 接收端拿着同样的 M + 这段比特流，走逆过程，就能把 x 一字不差还原出来。

在这个流程里，“无损”的属性来自：

（模型 M + 编解码算法）这一组合本身是严格可逆的，
只要传输的那段比特流没有出错，原文就可以 100% 还原。

模型 M 的好坏，只影响：

    • 这段比特流有多短（即压缩率有多高）；
    • 不影响“能不能还原”。

所以 Ilya 所谓“LLM 是无损压缩器”，更精确的说法是：

给定一个固定的 LLM，它可以作为概率先验，为传统的无损压缩算法提供一个极其强大的“世界模型外挂”，从而实现比传统方法高得多的无损压缩率。

在这个意义上，“无损”也成立。只不过这里的“压缩对象”已经从“世界本身”换成了“具体数据序列”，大模型被当作一个共享的、不给码长计费的解码器。

四、过去 vs 未来：黄金标准的消逝

这场讨论还有一个常被忽略，但极关键的维度：时间方向。

传统的压缩 / 解压，是完完全全面向“过去”的：

    • 数据已经存在，
    • 原始比特流就是唯一的“黄金标准”，
    • 解压能不能算成功，就看你能不能逐比特还原它。

OCR 的任务就是“认回原文”，错一个字就是错；无损音频编码、无损图像编码也是一样，连瑕疵也要还原。

而大模型在推理 / 生成阶段，干的是另一件事：

    • 面对的是“未来”的内容——下一句话、下一页小说、一个还没发生的对话；
    • 这里根本不存在一个唯一的标准答案，只有一簇“合理的可能性”。

从这个视角看，“幻觉”就呈现出另一面貌：

    • 从“还原过去”的角度看，它是错误，是有损；
    • 从“预测未来”的角度看，它是从分布中抽出的某一条样本——
      合理程度如何，是另一个维度的问题。

训练阶段看上去像是在“还原过去”：

    • 我们用 next-token prediction（NTP），
    • 用交叉熵去拟合已有语料，
    • 每个 token 似乎都有一个“黄金标准”。

但注意：

    1. 训练优化的是概率分布的逼近程度，而不是字符逐一匹配；
    2. 训练目标本身就是为了让模型学会“意义的流动”和“世界的规律”，
      好在未来的推理中给出合理的输出。

所以，当我们拿一个“面向未来”的预测器，用“还原过去”的标尺来量时，必然得出“有损”的结论；而当我们在一个“固定模型 + 算术编码”的框架下讨论具体数据时，又可以非常严谨地说，它支持无损压缩。

时间指向不同，结论自然不同。

五、大模型 = 图灵机求逆

再往深一层看，可以用“图灵机求逆”的视角，把大模型和“智能 = 压缩”连起来。

设想这样一个画面：

  1. 在最底层，有一个我们并不知道的“世界生成程序” G：
    • 它把物理定律、因果结构、各种 agent 的决策过程都编码在里面；
    • 不停运行，就生成了真实世界里的事件流。
  2. 我们作为观察者，没有看到完整的世界，只看到一些被投影到语言上的片段：
    • 新闻、小说、微博、论文、聊天记录……
    • 这些文本本身已经是一种有损投影，丢掉了大量原始现实细节。
  3. 如果说 G 是“正向的世界图灵机”，
    那么一个足够强的大模型，就在试图做一件事：
    在只看到这些语言投影的情况下，去逼近 G 的逆映射。

用更形象的话说：

世界先“写了一堆小说”（大数据语料），
大模型则在这些小说上做逆向工程，
想从结果反推“上帝写作时的那本大纲”。

在柯氏复杂度的语言里，这件事就是：

    • 我们不知道真实世界的“上帝程序” G，
    • 但我们希望找到一个相对短的程序 M，
      让它在生成我们看到的那些文本时，具有尽可能高的先验概率。

next-token prediction 其实就是这个过程的一种可计算近似：

    • 把“找到最短程序”这个不可计算的问题，换成“找到一组参数，使预测分布在交叉熵意义下最优”这个可训练的问题；
    • 最后得到的 M 就是一个“次优的世界程序”，是对 G 的一个逼近。

从这个视角看：

    • 训练阶段的大模型，是在做“图灵机求逆”的近似——从语言投影反推世界程序；
    • 推理阶段的大模型，是在做“图灵机正向运行”的近似——从世界程序生成新的语言片段。

而“压缩”恰恰是这两步的桥梁。这，就是那句“压缩就是智能”的理论底座：
智能，是用尽可能短的程序，对世界做尽可能长远、尽可能准确的预测。

六、把李飞飞和 Ilya 摆到同一张坐标系里

现在我们可以尝试给这场争论画一张简单坐标图。

（1）压缩的对象：具体数据 vs 世界分布

  1. 李飞飞关注的是：
    • 对具体事实 / 数据点的还原：
      • 能不能 100% 记住训练集里出现过的每一条事实？
      • 会不会产生与事实相悖的幻觉？
    • 在这个维度上，大模型必然是有损的。
  2. Ilya 更关注的是：
    • 对整个数据分布 / 世界规律的压缩：
      • 模型是否把自然语言背后的统计规律、语法、语义、常识、因果结构榨干？
      • 在这个意义上，模型是在追求一种“本质上的无损”，即对规律的无损。

（2）所处阶段：训练 vs 应用

  • 训练阶段：
    • 大模型对大数据做有损抽象，
    • 有限参数 + 泛化需求 => 必然丢掉大量细节。
  • 应用阶段（作为压缩器，这其实是大模型的一个很小的应用场景：多数场景是预测AIGC，而不是还原）：
    • 固定模型 + 算术编码，
    • 对给定文本可以实现严格定义上的无损压缩和还原。

（3）时间指向：过去 vs 未来

  • 面向“过去”：
    • 讨论的是已有数据的 bit 级还原，
    • 这里才有“无损 / 有损”的经典定义。
  • 面向“未来”：
    • 讨论的是对未见数据的预测，
    • 这里只剩下“预测好 / 预测坏”，
    • “有损 / 无损”缺乏清晰的参考标准。

把这几条叠在一起就会发现：

李飞飞和 Ilya 讨论的是同一头大象，但各自强调的是不同侧面。
前者是在检视它的“记忆是否完美”；
后者是在赞叹它的“世界建模是否深刻”。

两边站位不同。

七、问自己三件事

以后再听到类似的争论，不妨先默默问自己三句话：

  1. 他说的“压缩”，压缩的到底是什么？
    • 是某一段具体文本 / 文件？
    • 还是一整个大数据分布 / 一个世界？
  2. 他是在谈训练阶段，还是应用阶段？
    • 如果是训练和泛化，必然伴随信息的“有损抽象”；
    • 如果是在固定模型上做算术编码，那是标准教科书意义上的“无损压缩”。
  3. 他是在面向“过去”，还是在面向“未来”？
    • 讨论 OCR、无损编码、还原率，是过去视角；
    • 讨论生成式 AI、AIGC、代理决策，是未来视角，
      此时“有损 / 无损”不如“预测是否合理”来得贴切。

把这三道小问题想清楚，会发现很多看似矛盾的论点，其实只是维度不同。

结语：智能就是压缩？还是压缩逼近智能？

回到最初的提问：智能是不是压缩？压缩是不是智能？

从第一性原理看，我们可以给出一个相对克制但有力的总结：

  • 真正的“压缩”，指向的是：
    用最短的程序描述世界，这是智能的必要条件之一，但不是充分条件；
  • 大模型在训练时，对世界做的是有损的物理存储，
    用有限参数去概括无限复杂的数据海；
  • 大模型在应用时，又可以化身为无损压缩器的“灵魂外挂”，
    帮我们以前所未有的效率，复原过去的数据，虽然这不是大模型的主要应用场景；
  • 而在面向未来时，它抛弃了“还原”的执念，
    以一个次优世界程序的身份，生成从未存在、但合理的文本和行为。

于是我们得到这样一幅图景：

大模型不是完美的复读机，
它是对人类知识的一种有损的物理压缩，
却是对人类智慧结构的一种近乎无损的数学蒸馏。

它会忘记某一篇报纸的具体措辞，却不会忘记新闻报道的叙事模板；
它会编造一段并不存在的轶事，却能在十几种语言之间自如来回。

这，恰恰是在“有损”和“无损”的悖论之间，智能本质的那个模糊又锋利的轮廓。

 

Demystifying the misconception of "Lossless Compression as Intelligence"

破除“无损压缩即智能”的迷思

GPT and the Art of Compression

Efficiency vs. Reliability: The Compression Tightrope

Arithmetic Coding for GPT’s Compression Engine

Navigating the Probability Universe with GPT

Is GPT Compression Lossless or Lossy? The Truth Revealed

GPT as a Cosmic Librarian: Unlocking Lossless Compression

与尼克等老友唠大模型压缩理论

GPT作为序列数据的无损压缩器

要区分GPT训练中的压缩，与拿GPT当压缩器工具

信息论科普：GPT对给定序列无损压缩的最终区间

GPT无损压缩小问答（3）：算术编码

信息论科普：香农极限（Shannon Limit）

GPT无损压缩小问答（2）：为什么说GPT是无损压缩？

GPT无损压缩小问答（1）： 高压缩率导致系统脆弱

大模型是无损压缩还是有损压缩，李飞飞与伊利亚谁是对的？

智能的本质：在“有损”与“无损”的压缩悖论中寻找答案

前言：一场“鸡同鸭讲”的高端对话

在人工智能的理论高地上，最近出现了一场看似矛盾的争论。 一方面，AI教母李飞飞（Fei-Fei Li）指出：大模型是一种有损压缩（Lossy Compression）。这一观点直观且符合经验——模型会产生幻觉，无法100%还原训练数据中的每一个事实细节。 另一方面，OpenAI的前首席科学家 Ilya Sutskever 却掷地有声地宣称：大模型做的是无损压缩（Lossless Compression），并将压缩等同于智能。

这两位泰山北斗级的专家，难道有一方错了吗？ 细思之下，这并非是非黑即白的对错之争，而是一场因观察维度错位而产生的“鸡同鸭讲”。结合最近与几位学界行家（如尼克教授、刘群老师、白硕老师、马少平教授）的探讨，以及对大模型本质的再思考，我们或可揭开这层迷雾，彻底讲明白“压缩”与“智能”的关系。

一、 泛化与还原：鱼与熊掌不可兼得

首先，我们需要厘清大模型与传统数据库的根本区别。

李飞飞的“有损”论，其立足点在于“具体数据点”的还原。 大模型在学习海量数据的过程中，其核心目标是泛化（Generalization），即学习数据的分布规律，而不是死记硬背每一个比特。正如白老师所言：“无损与泛化不兼容。”

如果一个模型对训练数据做到了100%的比特级无损记忆，那它就退化成了一个笨重的查表数据库（Lookup Table），失去了处理未知数据的能力。为了获得泛化能力，模型必须学会忽略数据中的噪音和偶然信息。而这种“忽略”，在试图完全还原原始数据时，就表现为“有损”。

从这个意义上说，幻觉（Hallucination）并非系统的Bug，而是泛化的必然副产品。模型学会了概率分布，却模糊了具体事实的边界。因此，李飞飞说大模型是“有损压缩”，没有问题，也符合我们普罗的观察和直觉。

二、 压缩即智能：逼近上帝的“次优解”

那么，Ilya 的“无损”论又站得住脚吗？ 这里涉及对“学习”本质的数学定义。尼克教授在《计算与智能的第一性原理》中提到一个深刻的观点：压缩的目的是还原，by definition 就是无损的。

这听起来很烧脑：既然大模型无法100%还原，为什么还说它是无损压缩？

这里需要引入“次优图灵机”的概念。 理论上，存在一个完美的程序（God's Algorithm）可以完美压缩并还原数据，但这个程序往往是不可计算的。大模型实际上是作为一个次优的（Sub-optimal）图灵机，在概率上无限逼近这个最优解。

为什么说它在做无损压缩？ 李明教授在 Nature 上的论文以及刘群老师的观点都指出，大模型可以极大地赋能无损压缩。实验证明，利用大模型对文本进行预测，其压缩率远高于传统的 gzip 或 zip 等无损压缩算法。

    • 原理是这样的： 传统的压缩算法（好比步枪）只利用统计规律；而大模型（好比核武器）“吃透”了自然语言的深层规律（语法、逻辑、世界知识）。
    • 在还原数据时，大模型预测的概率分布与真实数据深度吻合，因此只需要极少量的额外信息（Patch）就能实现100%还原。

从“对规律的提取程度”来看，大模型做到了前所未有的极致压缩。Ilya 所谓的无损，是指大模型在学习数据分布本质这一层面上，追求的是对世界的无损理解。

三、 过去 vs. 未来：黄金标准的消逝

这场争论的另一个核心错位，在于时间指向性。

    1. 传统的压缩与还原，针对的是“过去”（Existing Data）。 对于已经发生的数据，存在唯一的比特级黄金标准。OCR（光学字符识别）就是一个典型的例子，它的目标是恢复原文，错一个字就是错。
    2. 大模型的生成，指向的是“未来”（Prediction）。 大模型在推理（Inference）阶段，面对的是未知的上文，需要预测下文。未来本质上是不确定的，是平行宇宙。
    3. 没有黄金标准： 对于“未来”的生成，没有唯一的标准答案。模型输出的是一种“合理性”，而非“还原性”。
    4. 幻觉的本质： 很多幻觉从比特还原（过去）的角度看是错误的（Lossy），但从逻辑合理性（未来）的角度看却是对的。

大模型在训练时，虽然用 Next Token Prediction（NTP）作为手段，看似在通过交叉熵（Cross-Entropy）去拟合“过去”的 Token，但其真实的目的是学习“意义”的流动。即便在训练阶段，Loss 函数指向的也是概率分布的逼近，而非字符形式的死磕。

因此，说大模型是“有损”，是因为我们在用“还原过去”的尺子，去衡量一个“预测未来”的工具。

四、 终极追问：最短程序与“大”模型的负担

在理解了上述逻辑后，我们还有一个终极的物理与数学疑问，这也是我在思考中感到最困惑但也最迷人的地方。

根据最小描述长度（MDL, Minimum Description Length）原理，奥卡姆剃刀告诉我们：“若无必要，勿增实体”，最好的理论是那个能用最短程序描述数据的自动机。

我们将大模型视为一种压缩算法，它的压缩率（Data Compression Rate）确实惊人地高。但是，大模型本身（Model Parameters）是一个巨大的实体。

    • 传统的压缩： 压缩程序很小（几MB），压缩后的数据也很小。
    • 大模型压缩： 压缩后的数据（Patch/补差信息）极小（因为预测极准），但解压程序（即大模型本身） 却大得惊人（几百GB甚至TB）。

如果我们将“模型 + 压缩数据”的总长度作为衡量标准（Total Code Length），大模型与实现“最短程序”这个标准相距甚远。这就像是一个人拿着核武器（大模型）去打靶，虽然靶子被摧毁得最彻底（预测最准），但你为了运送这枚核武器所消耗的能量和资源（Overhead），是否抵消了它带来的精度优势？

对此，我的思考是： 这取决于我们压缩的对象是“一段数据”还是“整个世界”。 如果是为了压缩一本书，大模型显然是极其低效的（模型本身比书大太多）。 但如果是为了压缩整个人类互联网的知识总和，大模型庞大的参数量相对于无穷尽的数据海洋来说，依然是极度浓缩的“最短程序”。它用有限的参数，锁住了近乎无限的语言规律和世界知识。

结语

综上所述，李飞飞和 Ilya 都没有错，他们只是站在了真理的不同侧面：

    • 李飞飞看到了大模型作为“数据库”时的次优性（Sub-optimality）和事实层面的有损性。
    • Ilya 看到了大模型作为“智能体”时对世界规律的极致提取，以及其作为压缩算法在概率分布层面的无损追求。

大模型不是完美的复读机，它是对人类知识库的一种有损的物理存储，但却是对人类智慧与逻辑的一种近乎无损的数学蒸馏。

这就解释了为什么它既能写出惊艳的诗歌（抓住了规律的魂），却又记不清你具体的生日（丢失了事实的形）。

这，或许就是智能的第一性原理的反映。

 

Demystifying the misconception of "Lossless Compression as Intelligence"

破除“无损压缩即智能”的迷思

GPT and the Art of Compression

Efficiency vs. Reliability: The Compression Tightrope

Arithmetic Coding for GPT’s Compression Engine

Navigating the Probability Universe with GPT

Is GPT Compression Lossless or Lossy? The Truth Revealed

GPT as a Cosmic Librarian: Unlocking Lossless Compression

与尼克等老友唠大模型压缩理论

GPT作为序列数据的无损压缩器

要区分GPT训练中的压缩，与拿GPT当压缩器工具

信息论科普：GPT对给定序列无损压缩的最终区间

GPT无损压缩小问答（3）：算术编码

信息论科普：香农极限（Shannon Limit）

GPT无损压缩小问答（2）：为什么说GPT是无损压缩？

GPT无损压缩小问答（1）： 高压缩率导致系统脆弱

视频语义检索怎么回事

Twelve Labs 这一类“视频语义检索模型”在做什么？

1.. 先把视频拆成一堆“可啃的小块”

典型做法：

    1. 时间上采样

      • 把长视频按时间切片，比如每 1～2 秒抽一小段（多帧）。

      • 对语音部分做 VAD（Voice Activity Detection），把“有人说话”的片段切出来。

    2. 空间上预处理

      • 对每一小段选几帧关键帧，送进图像 / 视频编码器（Vision Transformer、时序 Transformer 或 3D CNN ）。

      • 对画面中的人脸、文字（OCR）、UI 元素（按钮、输入框、对话框）做额外检测，这些将作为后面高权重信号。

结果：原本一个一个 MP4，变成了很多“时间片段”，每个片段里有：

    • 若干帧图像

    • 对应的音频片段

    • 可能还有屏幕上的文本 / UI 结构

2. 把“谁在说话 / 谁出现在画面里”变成向量

这里其实就是多模态联合编码，套路非常 CLIP-ish：

    1. 视觉侧

      • 用预训练视觉编码器（ViT + 时序模块）把每个时间片段编码成一个向量v。

      • 如果要知道“谁”，会叠加一个人脸识别模型，把同一个人跨帧对齐；对于 PPT 页、logo 等，会用专门的 OCR + layout 识别。

    2. 音频侧

      • 语音 → ASR 得到文本；再用文本编码器（类似 BERT / LLM embedding）得到语义向量。

      • 同时保留说话人 embedding（speaker embedding），标记“哪个人”在说话。

    3. 文本侧（字幕、PPT 内容）

      • 把字幕、屏幕上的文字、PPT OCR 出来的文本，统统丢给同一个文本编码器，得到向量 t。

    4. 多模态融合

      • 常见做法：把同一时间片段的视觉向量 v、音频文本向量和屏幕文本向量拼在一起，用一个小 Transformer 做融合，得到一个统一的视频片段 embedding z。

      • 这一步是“统一向量空间”的关键：所有模态都映射到同一个 d 维空间里，语义对齐。

这时，每几秒视频就变成一个向量，可以把它看成一颗“视频 token”。

3. 训练：让“查询”和“片段向量”在同一语义空间对齐

怎么做到“自然语言一问，就能在长视频里精确跳到某一片段”？

    1. 构造正负样本（对比学习）

      • 正样本：用户查询（或人工写的描述） ↔ 真正相关的视频片段。

      • 负样本：同一个 batch 里其他不相关片段统统当负例。

      • loss 就是 CLIP 那套 InfoNCE：让相关的 query–clip 距离更近，不相关的更远。

    2. 训练查询编码器

      • 再搞一个文本编码器 Eq(query)E_q(\text{query})，把自然语言检索语句编码成向量 qq。

      • 训练时，强迫 qq 靠近正确片段的 z+z^+，远离同批里的其他 z−z^-。

    3. 无监督 / 弱监督增强

      • 对于没有人工标 query 的视频，可以用标题、描述、章节标题、自动摘要等粗粒度文本作为弱监督，使得整段视频的 embedding 跟这些文本对齐。

      • 再加上一些“自监督任务”：例如预测下一片段、判断两个片段是否相邻、是否同一场景等等，让模型对时间结构更敏感。

训练完之后就得到：

一个统一空间：自然语言 query 向量和“几秒钟的视频片段向量”可以直接算相似度。

4. 语义在系统里是怎么用的？

有了那串视频语义向量：

    1. 检索

      • 用户问：“主持人第一次提到价格折扣是哪一段？”

      • 把 query 编成 qq，在所有 ziz_i 里算相似度，top-k 就是候选片段，直接 seek 到对应时间位置播放。

      • 这就是“可检索的视频 token”。

    2. 自动摘要 / 分章节

      • 用这些片段向量做聚类：相似 ziz_i 合并成“主题段落”。

      • 每个簇再送进 LLM 总结，就变成“这一分钟大概在讲什么”。

      • 拼起来就是自动生成的大纲 / 章节标题。

    3. 时间轴上的“语义字幕条”

      • UI 上可以把每个片段的主题、主要人物、动作用文字标出来，让用户在时间轴上“按含义快进”——这就是你那句“加一层语义字幕”的产品形态。

小结

像 Twelve Labs 这一类的视频理解系统，做的事情大致是：先把长视频切成一小段一小段，每一段同时看画面、听声音、读字幕和屏幕上的文字，再用一个多模态编码器把这些信息“压”成一个向量。可以把这个向量理解成几秒钟视频的“语义指纹”：谁在说话、画面上是谁、在做什么动作、PPT 翻到哪一页，都被揉进了这一串数字里。整条视频就变成了一串这样的“视频 token”，后端只要拿自然语言问题来跟它们对比相似度，就能做检索、分章节甚至自动生成摘要。

 

 

GPT非监督学习到底怎么就学会了各种监督任务呢？

这个问题是研究过大模型原理的人都容易卡住的一个“门槛”。这不是简单的“监督 vs 非监督”分类问题，而是关涉信息结构、任务表征和隐式监督在超大规模训练下发生的质变，或曰能力涌现。我们可以一点点拆开来看，为什么一个看似简单的“预测下一个词”（NTP）目标的GPT预训练，就能奇迹般地涵盖几乎所有任务的规律，帮助建成了如此强大的AI通用引擎。

一、监督与非监督的界限，在语言世界里是模糊的

传统意义上，“监督学习”要求明确定义的标签，比如输入图像x → 输出类别y；
而“非监督学习”没有标签，只学习数据的分布。

但语言数据本身的结构非常特殊：它天然是有标注、有方向、有层级的序列。

怎么讲？

一句自然语言样本“把这句话翻译成英文：你好，世界。”
其实包含了：

    • 明确的指令（task definition）；
    • 输入（中文）；
    • 目标输出（英文）。

也就是说，语言天然带着任务标签的自解释性（self-descriptiveness）。
人类语言是世界中唯一一种“带注释的训练数据”：我们说什么、干什么，常常把任务和答案包在同一个上下文里。

这就是为什么，当GPT读到海量互联网文本时，它并不是在看“无标签”的数据，
而是在接触一个由人类自带监督信号构成的世界。

二、“预测下一词”其实隐式地包含了任务学习

形式上，NTP目标只是让模型最小化下一词的预测误差，但语料中的每个词并非随机，它是对“前文语境”的自然回应。

这种回应关系，本质上是一种输入–输出映射。
语言的句法结构和语义结构，使得很多“下一个词”其实就是任务答案。

例如模型读到：

“问：地球绕什么转？ 答：”

此时的“下一个词”正是答案“太阳”。
对模型来说，这与传统监督任务“输入问题，输出答案”没有本质区别。

互联网语料充满这种结构化上下文：对话、教程、代码注释、FAQ、论坛问答、维基解释……
每一个都是微型的“监督样本”。
因此，NTP在统计意义上是非监督，但在信息意义上是隐式多任务监督。

三、语言模型的“任务统一”，来自语义层面的分布对齐

换句话说，NTP训练不是在学“每个任务”，而是在学各类任务所共享的统计结构。
不同任务的表面形式不同，但它们都服从同一种语言规律：
输入部分与输出部分在语义空间上可以也必须“对齐”。

大模型在庞大的语料中反复看到各种输入—输出耦合结构，
无论是翻译、解释、命令、叙述还是对话，
它都会在参数空间中学习到一种通用的对齐机制：
——当句子出现某种语义模式时，如何生成匹配的下文。

这一机制的通用性来自两个事实：

1️⃣ 语言分布的高度可组合性：同一语义关系可以出现在不同任务语境中。
2️⃣ Transformer结构的自注意力特性：它能在上下文中自动建立输入—输出的关联，无需显式标签。

因此，当你给GPT一个新任务描述时，它并不是瞬间产生灵感，
而是发现：这个模式在它的语言世界中早就存在，只是被唤起了。

四、“任意输入到任意输出”的关键：语言包容一切

人类社会的几乎所有活动——科学、艺术、计算、逻辑推理、情绪表达——都通过语言描述。
语言是人类世界的通用接口。
当模型学会了语言，它实际上学会了所有这些活动的符号层映射。

这就是为什么GPT能“零样本”应对新任务：
并不是它真的“理解”了任务规则，
而是因为任务本身就在它学过的语言分布中以某种形式出现过。
“任意输入到任意输出”的秘密，根子在语言的普遍性。

从这个意义上说，GPT并不是学会了所有任务，
而是学会了一种将任务描述映射到响应分布的通用函数。
当语言成为所有任务的共同中介时，
“监督”与“非监督”的界限便在语义层上被抹平。

在语言世界中，语料本身携带隐式的监督信号；
“预测下一词”是一种最大似然的世界建模；
而世界的规律通过语言的统计分布得以反映。

因此，GPT的目标函数虽然简单，
但它优化的实际上是一个跨任务、跨语境的世界概率模型。
这就是为什么，看似“非监督”的NTP，
在足够规模下会展现出监督学习的通用性。

 

The Chain Rule: The Mathematical Guarantee Behind Backpropagation

We know that backpropagation is the key to deep neural networks. What enables this key to unlock the door to deep learning is the chain rule.

Mathematically, the chain rule for gradients guarantees that the direction of each local adjustment forms part of the overall direction of error reduction. Through chain rule differentiation, the algorithm allows each connection to compute only its own small portion of "responsibility." These local derivatives, when mathematically combined, precisely constitute the direction for minimizing the total error.

To truly understand backpropagation, one can view a neural network as a series of "relay functions." One layer transforms the input into an intermediate representation, the next layer then processes that into another representation, and so on, until the output. Mathematically, this is a composition of functions: the output is a function of the previous layer's output, which in turn is a function of the layer before it, link by link.

The chain rule is actually quite simple: when you observe the total error at the very end, if you slightly tweak a small weight somewhere upstream, that tiny change propagates through all the relevant downstream links. Each link amplifies or diminishes the change in its own way. By the time this change finally reaches the output, all these local effects are multiplied together, determining whether the weight's change improves or worsens the final result, and by how much. This is the so-called gradient: it quantitatively describes the degree of responsibility each parameter has for the final error.

What the backpropagation algorithm does is essentially reverse this reasoning process. Starting from the output error, it passes the "sensitivity to the result" backward through the network layer by layer, allowing each layer to compute its small share of "responsibility" based on its own local derivative.

This might still sound abstract. Let's paint a picture: imagine a river with many tributaries. The most downstream point is the "loss" deviation, and upstream are the weights. If you add a truckload of water to a small tributary, whether and how much the water level rises downstream depends on the width and slope of each river section along the way. Wide sections amplify less, narrow sections amplify more. The chain rule multiplies the "amplification factor" of each segment along the path and sums over all possible paths leading downstream to get the "final impact of this truckload of water on the total water level." In the network, the "amplification factors" are the local derivatives of each layer; "summing over all paths" corresponds to the weighted sum of connections through successive layers.

Applying this intuition to the simplest two-layer network makes it clearer. Let the output be y, the final loss be L(y), the intermediate hidden layer variable be h, and a certain weight be w. L is first affected by y, y is affected by h, and h is in turn affected by w. The chain rule breaks down "how much does changing w a little affect L?" into three parts multiplied together: first ask "how much does L change if y changes a little?" (∂L/∂y), then "how much does y change if h changes a little?" (∂y/∂h), and finally "how much does h change if w changes a little?" (∂h/∂w). Multiply these three answers, and you get the direction and magnitude for w's adjustment. That is:

∂L/∂w = (∂L/∂y) · (∂y/∂h) · (∂h/∂w)

If there are multiple pathways through which w's influence can reach y, the formula above sums the products from each pathway. You don't need to see the entire network's details. You just measure the "slope" at each small segment you pass through, finally multiply the slopes along this path, sum over all possible paths, and you get the true impact on the whole.

This is precisely the secret to backpropagation's efficiency. With hundreds of millions of weights w in the network, by remembering and reusing the local slopes during a single backward pass from "downstream to upstream," we can compute the respective "direction sense" for all weights. In engineering, this is called reverse-mode automatic differentiation: first, values flow forward (the forward pass), then "sensitivities" flow backward (the backward pass). The forward pass is like solving the problem; the backward pass is like grading it. Each node simply does two small things: it stores its local slope from the forward pass, and during the backward pass, it takes the sensitivity received from downstream, multiplies it by this stored slope, and distributes the result upstream along its connections. Thus, these local calculations aggregate into the correct global adjustment.

The question of "will local adjustments cancel each other out?" finds its answer here. The slopes everywhere are not guessed arbitrarily; they are genuine measurements of the gradient along the same "loss river." Each parameter takes a small step along its own "true downhill" direction. Mathematically, all these small steps collectively move toward descending the same error valley—although it doesn't guarantee finding the global minimum in one step, it does guarantee that this step is moving downhill. This is also why during training it's necessary to take small steps, many times; to use more robust descent strategies (like adaptive learning rate methods, e.g., Adam); and to use nonlinear activation functions less prone to causing extremely small or large slopes (e.g., ReLU instead of sigmoid). When the slopes in certain segments are close to zero, successive multiplications can "dampen" the sensitivity to nothing—this is the vanishing gradient problem. When slopes are consistently greater than one, multiplications can "explode" the sensitivity—that's the exploding gradient problem. These phenomena further confirm the real physical intuition of "chain multiplication and path summation": if the riverbed is too flat, the water flow dissipates; if the riverbed is too steep, the water flow amplifies. Generations of engineering improvements essentially involve "modifying the riverbed" so that sensitivity is neither excessively dissipated nor amplified, making the "downhill path" more navigable.

The success of backpropagation laid the algorithmic cornerstone for deep learning. It propelled connectionism from the ivory tower into practical application, providing the theoretical and technical prerequisites for the subsequent explosion of "deep learning" years later.

 

Backpropagation: The Key to Deep Neural Networks

By introducing "hidden layers" that perform nonlinear transformations, a network can map linearly inseparable low-dimensional problems (like the XOR gate) into higher-dimensional, separable spaces. From this point on, neural networks gained the ability to represent complex patterns for approximiating universal funtions. For connectionism, achieving a true renaissance became merely a question of algorithm, time, and computing power.

On the algorithmic front, one core problem long perplexed neural network researchers: how can we effectively train a complex multi-layer network? If the network makes a mistake, how do we determine which connection weight in which layer is at fault, and how should we correct it? This differs from symbolic logic, where rules can be directly encoded into transparent, debuggable computer programs—because the code itself is an interpretable symbolic language.

In 1986, in a landmark paper, Geoffrey Hinton, David Rumelhart, and Ronald Williams systematically elucidated the core method for cracking deep neural networks: the Backpropagation algorithm. It enabled neural networks to truly perform "deep learning" for the first time.

After the model produces an output, it first calculates the overall error—the difference between the prediction and the correct answer. The essence of backpropagation is that the model's error can propagate backward, layer by layer, like ripples. The connection weights in each layer can be adjusted to correct for their portion of the "error." In other words, each layer contemplates: "If I adjust myself slightly this way, I need to ensure it makes the final result a little better." This is how backpropagation teaches machines to learn from outcomes—through layer-by-layer adjustments, the entire network's output progressively converges toward the correct answer.

This algorithm solved the problem of training multi-layer networks.

You might ask: In a neural network with hundreds of millions of parameters, how is it possible to know which direction to adjust each one?

Indeed, there are countless "knobs" (parameters, weights) in a neural network, collectively determining the output. Improving the model requires coordinating all these knobs simultaneously amidst so many moving parts—it sounds like finding a needle in a haystack, blindfolded. But here's the elegance of mathematics: the "sense of direction" for each knob can be computed locally.

The key idea of backpropagation is this: although the network is vast, each connection is part of a clear chain of causality. If we can calculate "how much the final output error would change if this specific connection weight were tweaked slightly," then we know which direction to nudge it. This is precisely what the gradient represents. It's not based on vague intuition but is precisely computed using calculus—a derivative (slope). In a multi-dimensional space, the gradient points in the direction of the steepest ascent of the error; thus, moving against it decreases the error fastest.

In other words, even with hundreds of millions of parameters, each parameter can independently compute a tiny arrow—based on its "propagated relationship" with the output error—indicating which way to move to reduce the error slightly. These minuscule "better directions" aggregate into a coordinated adjustment across the entire network. Thus, without needing a global view, the machine finds direction locally. In each training cycle, the model "descends the hill" this way: from its current position, it follows the error-reducing gradient downward a bit, then recalculates the new gradient. Repeating this thousands or millions of times, the error shrinks, and the model grows smarter.

Perhaps you'd further ask: In a network with so many parameters, won't these local adjustments cancel each other out? Common sense suggests that in complex systems, local optimizations might throw the whole system off balance. However, the marvel of backpropagation lies in this: each local adjustment is not blind. They all share a common objective—to minimize the overall error (loss). The gradient, computed via calculus, indicates the steepest downhill direction in the vast "error landscape." The gradient's direction tells each connection which way to adjust, and its magnitude suggests how much. When all connections compute their own "little sense of direction" and update accordingly, the entire network moves toward minimizing error. Thus, even faced with an immensely complex system of billions of parameters, the model achieves local judgment leading to global improvement—this is the secret sauce enabling deep learning.

Think of it like a massive orchestra. Each musician reads only their own sheet music (local information), often paying little attention to the other parts. Yet, they all follow the same conductor (the loss function)—who, through gestures (gradient signals), instructs each player to be louder, softer, faster, or slower. Thus, although no single musician "sees the big picture," the whole orchestra plays in harmony.

To truly understand backpropagation, view the neural network as a chain of "relay functions." One layer transforms the input into an intermediate representation, the next layer compresses that into another, and so on, until the output. Mathematically, this is a composite function: the output is a function of the previous layer's output, which in turn is a function of the layer before it, and so forth, link by link.

With millions of weights w in the network, the trick is to compute and reuse local slopes during a single backward pass, moving from "downstream to upstream." This efficiently provides each weight with its required "direction sense." In engineering, this is called reverse-mode automatic differentiation: first, values flow forward (the forward pass), then "sensitivities" flow backward (the backward pass). The forward pass is like solving the problem; the backward pass is like grading it. Each node simply does two small tasks: it stores its local slope from the forward pass, and during the backward pass, it takes the sensitivity received from downstream, multiplies it by this stored slope, and distributes the result upstream along its connections. These local accounts, when summed, miraculously yield the correct global account.

The success of backpropagation laid the algorithmic foundation for deep learning. It propelled connectionism from academic ivory towers into practical application, providing the theoretical and technical prerequisites for the "deep learning" explosion years later.

 

链式法则：反向传播能work的数学保证

我们知道，反向传播是深层神经网络的钥匙。这把钥匙可以开启深度学习的大门，靠的是链式法则。

数学上，梯度的链式法则（chain rule）保证了：每个局部调整的方向，都是全局误差下降方向的一部分。算法通过链式求导，让每个连接只计算自己那一小段“责任”，而这些局部导数在数学上拼接起来，正好构成总体误差下降的方向。

真正理解反向传播，可以把神经网络看成一串“接力函数”。前面一层把输入揉成中间表示，后面一层再把中间表示压成输出。数学上，这就是复合函数：输出结果是前一层输出的函数，而前一层的输出又是更前一层输出的函数，一环套一环。

链式法则说的其实很简单：当你在最末端看到一个总体误差时，如果你稍微改动前面某个小小的权重，那条微小的改动会沿着所有相关的下游环节一路传递，每一环都会对它产生自己的放大或削弱作用。等这点改动最终到达输出端时，所有这些局部影响相乘，就决定了——这个权重的变化会让最终结果变好还是变坏、影响有多大。这就是所谓的“梯度”：它定量描述了每一个参数对最终误差的责任程度。

而反向传播算法做的事情，正好是把这个推理过程倒过来。它从输出误差出发，依次把“对结果的敏感度”沿着网络反向传回去，让每一层都能根据自己的局部导数，算出那份微小的“责任”。

这听上去还是抽象。把它换成一幅画：想象一条多支流的河。最下游是“损失”偏差，上游是权重。你在某一条细小支流加了一车水，最下游的水位会不会升高，升高多少，要看沿途每个河段的宽窄与坡度。宽的地方放大得少，窄的地方放大得多。链式法则就是把“沿途每一段的放大系数”相乘，再把通往下游的所有可能路径都加起来，得到“这车水对总水位的最终影响”。在网络里，“放大系数”就是每一层的局部导数；“所有路径求和”对应一层又一层的加权求和连接。

把这个直觉落到最简单的两层网络上更清楚。设输出是 y，最末端的损失是 L(y)，中间有一层隐变量 h，某个权重是 w。L 先受 y 的影响，y 受 h 的影响，h 又受 w 的影响。链式法则把“改一点 w 会让 L 变多少”拆成三段相乘：先问“y 变一点，L 变多少”，再问“h 变一点，y 变多少”，最后问“w 变一点，h 变多少”。三段答案一相乘，就是 w 的方向感与力度。这就是：

∂L/∂w = (∂L/∂y)·(∂y/∂h)·(∂h/∂w)

如果有多条通路能把 w 的影响传到 y，上式就把每条通路的乘积加起来。你不需要看全网的细节，只要在路过的每一小段量一下“斜率”，最后把这条路的斜率连乘、把所有可能的路相加，就能得到对总体的真实影响。

这正是反向传播高效的秘密所在。网络里有亿万个 w，一次次“从下游往上游”把局部斜率记下来并复用，就能在一趟回传里为所有权重算出各自的“方向感”。工程里叫它“反向模式自动微分”：先在正向把数值流过去，再在反向把“敏感度”流回来。正向像做题，反向像批改。每个节点只做两件简单的小事：保存好自己在正向时的局部斜率；在反向时把从下游收到的敏感度乘上这个斜率，再按连接把它分发给上游。局部小账加起来，恰好就是全局的大账。

“局部调整会不会互相抵消”的问题，在这里有了答案。各处的斜率不是随意猜的，而是同一条损失河道上真实量出来的坡度。每个参数沿着自己那条“真实下坡”的方向迈小步，所有小步在数学上是朝着同一座山谷的下降方向——虽然不保证一步到位找到全局最低点，但保证“这一步是在往下走”。这也是为什么训练时有必要把步子迈小一点、再迈很多次；要用更稳健的下坡策略（比如 Adam 那样自适应步长）；要用不那么容易把斜率变得过小或过大的非线性转换（比如ReLU 取代sigmoid）。当某些路段的斜率很接近零，连乘容易把敏感度“磨没”，这就是“梯度消失”；当斜率都大于一，连乘又容易把敏感度“炸开”，那是“梯度爆炸”。这两种现象，恰恰进一步印证了“链式相乘、路径求和”的真实物理：河道太平坦，水势被耗散；河道太陡峭，水势被放大。工程上的一代又一代改良，本质上都是在修河道，让敏感度既不过分被耗散，也不过分被放大，从而让“下坡路”更可走。

反向传播的成功，为深度学习奠定了算法基石。它让连接主义从象牙塔走向实用化，为后来的“深层网络”爆发提供了理论与技术前提。

 

反向传播：深层神经网络的钥匙

通过增加非线性转换的“隐藏层”，网络可以把线性不可分的低维问题（如“异或门”）映射到更高维的、可分空间中。从此，神经网络具备了表达复杂模式的能力，连接主义迎来真正的“咸鱼翻身”只是个算法、时间和算力的问题了。

算法方面，一个核心问题曾长期困扰着神经网络的研究者：如何有效地训练一个复杂的多层网络？如果网络做错了，我们该如何知道是哪一层的哪个连接权重出了问题，又该如何修正它？这与符号逻辑不同，符号规则可以直接编码为透明的可定点纠错的计算机程序，因为计算机代码本身就是可解释的符号语言。

1986年，杰弗里·辛顿（Geoffrey Hinton）、戴维·鲁梅尔哈特（David Rumelhart）和罗纳德·威廉姆斯（Ronald Williams）在一篇里程碑式论文中，系统阐述了破解深层神经网络的核心方法反向传播算法（Backpropagation）。它让神经网络第一次能够真正地“深层学习”。

模型在输出结果后，会先计算总体误差——也就是预测与答案的差距。反向传播的主旨是，模型的误差可以像涟漪一样从后往前逐层传播，每一层的连接权重都可以做“误差”修正。换句话说，每一层都在琢磨：“如果我这样改一点，需要确保会让整个结果变好一点。”反向传播正是这样教会机器从结果中学习——通过逐层调整，最终让整张网络的输出越来越接近正确答案。

这一算法解决了多层网络难以训练的问题。

你或许会问：在拥有亿万个参数的神经网络中，怎么可能知道该往哪个方向改？

在神经网络中，的确有亿万个“旋钮”（参数、权重），它们共同决定输出结果。要让模型变好，需要在如此众多的活动部件中同时协调所有旋钮，这听上去像在黑暗中找针。但数学的巧妙之处就在这里：每个旋钮的“方向感”都能被局部计算出来。

反向传播的关键思想是——虽然网络庞大，但每个连接都是一条明确的因果链的一部分。只要我们能算清：“如果这一条连接的权重略微改变，最终输出的误差会变化多少”，我们就能知道它该往哪个方向微调。这正是梯度（gradient）的意义。它不是凭说不清的直觉判断方向，而是通过微积分精确计算出的导数（斜率）：在多维空间中，梯度指向误差下降最快的方向。

换句话说，即使有上亿个参数，每个参数都能根据自己与输出误差之间的“传导关系”独立计算出一个小箭头——往哪边走，误差会更小一点。这些微小的“更好方向”汇聚起来，就构成了一次全网络的调整。于是，机器不需要看全局，也能在局部找到前进的方向。每一次训练循环，模型都这样“爬坡”：从当前位置，顺着误差下降的梯度往下走一点，再重新计算新的梯度。循环成千上万次，误差越来越小，模型就越来越聪明。

或许你还会问：在拥有亿万个参数的网络中，这些局部调整不会互相抵消吗？毕竟在常识中，越是复杂的系统，局部优化越可能让整体失衡。然而，反向传播的奇妙之处就在于——每一个局部调整都并不盲目，而是共享一个共同目标：让总体误差下降。通过微积分计算出的梯度，指明了整座“误差山谷”最陡峭的下坡方向。梯度的方向告诉每个连接该往哪边调整，大小告诉它改多少。所有连接各自计算出这一“小小方向感”，再一起更新，就能让整个网络朝着误差最小的方向前进。于是，即使面对亿万参数的复杂系统，模型也能实现局部判断、全局改进——这正是深度学习“能学”的奥秘所在。

这就好象一支庞大的乐团。每位演奏者都只看自己的谱子（局部），并不知道整首曲子的所有乐句。但他们都跟随同一个指挥（loss function）——指挥通过手势（梯度信号）告诉每个乐手该强一点、弱一点、快一点、慢一点。于是，虽然每个演奏者不“看全局”，整个乐团却在共同演奏同一首乐曲。

真正理解反向传播，可以把神经网络看成一串“接力函数”。前面一层把输入揉成中间表示，后面一层再把中间表示压成输出。数学上，这就是复合函数：输出结果是前一层输出的函数，而前一层的输出又是更前一层输出的函数，一环套一环。

网络里有亿万个权重 w，要让每个权重都知道自己该往哪调，秘诀是把误差信号一层层“从下游往上游”传回来。通过以下方式，就能在一趟回传里为所有权重算出各自的‘方向感’：首先，在正向传播时， 每个节点保存好自己在正向时的局部斜率；然后，在反向传播时， 一次次‘从下游往上游’把（这些缓存的）局部斜率取出乘上下游传来的敏感度，得到关于其自身权重的梯度 ∂L/∂w，同时利用“局部斜率”，计算出需要继续向更上游传递的敏感度。工程里叫它“反向模式自动微分”（Reverse-mode autodiff）。正向像做题，反向像批改。每个节点只做两件简单的小事：保存好自己在正向时的局部斜率；在反向时用下游传来的敏感度乘上这个斜率，再按连接分给上游。局部小账加起来，恰好就是全局的大账。这就是神经网络能在一趟回传里为所有权重算出“方向感”的秘密。

反向传播的成功，为深度学习奠定了算法基石。它让连接主义从象牙塔走向实用化，为多年后的“深度学习”爆发提供了理论与技术前提。

 

 

 

CNN与RNN——让机器学会看与听

AI现代史从神经网络革命开始。其中CNN与RNN是当时的两个主流网络。

要让计算机学会“看”，第一步是让它理解邻近像素之间的关系。我们人类识别物体时，并不会一眼就看透整张图片，而是聚焦在不同的局部区域：眼睛、嘴巴、轮廓。卷积神经网络（CNN） 的原理正是模仿这一点。

CNN通过一个个“小窗口”（卷积核）在图片上滑动。每个小窗口只负责观察一个局部区域，比如 3×3 的像素块。它会学会在这个区域里发现某种模式——可能是一条边、一块颜色的变化、或一个曲线的转折点。

当这些“小窗口”在整张图片上重复扫描时，机器便能捕捉到图像中哪些局部形状最常出现。这些模式被不断组合、叠加，例如：第一层看出边缘，第二层看出形状，第三层看出“这像是一只猫的耳朵”。这就是CNN“分层提取特征”的直觉。

CNN的关键在于节省与复用：同一个小窗口（同一组参数）在图片的各处都可以使用——这叫“权重共享”。这使得机器能识别“猫耳朵”无论出现在左上角还是右下角，都是“猫耳朵”。这就是CNN真正解决的问题：让识别具备“位置不变性”。

看懂了图像，接下来要让机器听懂语音。

语音与图像不同，它是按顺序展开的信号。一个句子的含义往往要依赖前后文。例如听到“我今天没去开会，因为——”，你自然会等后半句。机器也必须“记住前面”，才能理解后面。

循环神经网络（RNN） 就是为此设计的。它像一条有记忆的链，每一步的输出都会传给下一步，于是前面的信息可以“流”到后面，形成时间上的记忆。这叫因果建模。

但普通RNN的记忆很短——信息在长句子里会逐渐衰减。1997年，人们发明了 LSTM（长短期记忆网络），它加入了几个“门”来控制信息是保留还是丢弃。有用的信息可以保留几十个甚至上百个时间步，无关的噪声则自动忘掉。这让机器能在时间上保持理解的连贯。

简而言之：

CNN 让机器在空间上找到模式；
RNN/LSTM 让机器在时间上保持上下文。

它们一个解决“看”，一个解决“听”，共同构成了深度学习早期的两条神经主干——机器的“视觉皮层”和“听觉皮层”。正是在它们的基础上，后来语言模型的“思维皮层”才得以诞生。

自学习是思想革命，Transformer是工程火箭

很多人容易把“自（监督）学习”（Self-supervised Learning）和“Transformer”混为一谈。实际上，它们属于人工智能演化的两个不同层面。

自学习是一条算法路线，它回答的是：“智能能否在没有人工标注的情况下，从数据中自己学习知识？” 它的革命性在于——让AI不再依赖昂贵的监督数据，也能学会完成原本需要监督数据的任务。换句话说，AI第一次能够以非监督的方式实现监督学习的目标。

过去，机器要识别情感、判断语义、理解问答，都需要人工标注的大量针对任务特定的训练样本，需要人工标注输出样本。而自学习则让语言本身成为监督者。通过语言接龙的预测任务（next token prediction），模型自动在语言中抽取规律，形成一种“通用认知表征”，能被自然迁移到各种下游任务上。换句话说，模型 scale up以后，通用自学习可以自动解锁不同的专项任务。这是AI从“专用模型”迈向“通用智能”的真正奇迹。

Transformer则属于模型架构层面的创新。它没有改变“学什么”的逻辑，而是彻底改变了“怎么学”。RNN需要一字一字地顺序处理文本，无法并行；Transformer通过自注意力机制（self-attention）让模型一次性同时“看到”窗口里的整个文本，实现了训练与推理的高度并行化。这极大地提升了效率，也让自学习的算法路线有了真正的落地条件。

可以说，

自学习让AI“知道自己该学什么”（找到了通用智能的目标函数），
Transformer让AI“有能力学得快、学得深”。

正是两者的结合，打破了人工智能长达数十年的知识瓶颈——AI第一次从无监督数据中学会了有监督的能力，从单一任务的专家系统，跃迁为跨任务的通用智能体。

自学习是生成式AI的核心，主要通过两大支柱算法模型实现：第一个是 GPT，目标函数是“下一词预测”；第二个是 Diffusion（扩散模型），目标函数是“噪音预测”（为了“去噪”）。它们都是通过海量原生数据（raw corpora）的自学习获得智能。

前几年，大模型刚开始发飙的时候，有一个观察让我想了很久： 生成式AI说到底都是在无中生有。可这是怎么发生的呢？

你看扩散模型，做的就是一件事，去除噪音：把一片混沌渲染成声色犬马、活色生香， 佛家说是“由空见色”。

无中生有的事儿，其实一直存在。每个做过梦、幻过视的人，都有真切的体验。它的存在前提是要给定一个世界 ，然后大脑或模型形成一个世界模型。这就是自学习所做的勾当。有了这个世界模型，空到色的桥梁就搭起来了。就是说，无中生有是表象，还是要色在空前。由色入空，方可由空见色。

大模型具体操作（推理生成）的时候，总是从一个trigger条件开始，通过条件概率生成。条件匮乏，世界模型脑补想象的空间就大，出来的结果难以预测，但一样鲜活。条件苛刻，世界模型的幻觉受到压制，结果相对可预测，模型主要是在填补细节而已。

无论gpt还是diffusion，工作原理都是这样的。

从高级语言的基本逻辑装置到图灵机的编译

（How if, and, or all collapse into 0/1 moves）

引子：if 从哪里来？

写过程序的人都熟悉这样的语句：

if x == 0:
y = 1
else:
y = 2

我们自然觉得，计算机理解 if 是天经地义的，这是最基本的条件逻辑。但问题来了：
一台图灵机，它只有三件法宝——读、写、左右移动，外加有限状态。它怎么“知道”什么是 if？

这里要讲的，就是如何把高级语言里的逻辑分叉，一层层剥皮，编译回图灵机最底层的“格子动作”。

图灵机的底层世界

图灵机的规则永远是：

在状态 q，读到符号 s
→ 把它改成 s′，移动一格（L/R），进入新状态 q′。

它并不会说：“判断条件是否成立”，它只会说：“读到 1 的时候去状态 q1；读到 0 的时候去状态 q0”。
所以 “条件分支”就是不同符号对应不同状态转移。
换句话说，if 并不需要额外发明，而是状态表的天然功能。

示例：二进制 +1 的分叉

还记得我们在课堂上手算二进制加法的进位逻辑吗？

    • 如果末位是 0 → 改成 1 → 停机。

    • 如果末位是 1 → 改成 0 → 继续向左传递进位。

    • 如果一路全是 1，直到最左边 → 在最左边补 1。

这就是一个标准的“if-else if-else”结构。

翻译到图灵机语言：

(q_carry, 1) → (q_carry, 0, L)   ; 读到1，写0，继续左移（传递进位）
(q_carry, 0) → (q_done, 1, R)    ; 读到0，写1，结束（停止进位）
(q_carry, □) → (q_done, 1, R)    ; 一路全是1，遇到空格，在最左补1

没有任何魔法，这三条转移就完成了 if … elif … else …。
逻辑分支就是纸带上的“读符号分路”。

逻辑算子的编译套路（状态 × 符号 → 转移）

先记一个万能小模板（两行就够）：

结果格 res：
res 是 1 → 走路线 A
res 是 0 → 走路线 B

所谓“编译逻辑”，就是先把条件算成一格上的 1/0，然后按这两行跳转。下面全用这套。

NOT（取反）

目标：if not P: A else: B

  1. 先把 P 算出来，写到 res（1 表示“按 A 路走”，0 表示“按 B 路走”）。

  2. 对调去向：

    • res 是 1 → 去 B

    • res 是 0 → 去 A

记忆：NOT = 把 A/B 的门对调一下。

AND（与）

目标：if P and Q: A else: B（带“短路”）

  1. 先算 P，写到 res。

  2. 在 res 处看一眼：

    • 是 0 → 直接去 B（P 都没过，没必要看 Q）。

    • 是 1 → 再去算 Q，把结果写回 res。

  3. 再按万能模板跳：

    • res 是 1 → A

    • res 是 0 → B

记忆：AND = 先看 P；P 过了才看 Q。

OR（或）

目标：if P or Q: A else: B（带“短路”）

  1. 先算 P，写到 res。

  2. 在 res 处看一眼：

    • 是 1 → 直接去 A（已经满足，无需看 Q）。

    • 是 0 → 再去算 Q，写回 res。

  3. 再按万能模板跳：

    • res 是 1 → A

    • res 是 0 → B

记忆：OR = 先看 P；P 不行才看 Q。

复杂条件（一句话心法）

遇到“这一段有没有 0 且右边有没有 #”这类条件，做法只有一条：
边走边做记号（在几格上写下“看到 0”/“看到 #”的痕迹），走回“结果格”把答案写成 1/0，然后仍然用那两行万能模板跳转。

为什么这很重要？

从 if 到图灵机的转译，揭示了一个核心事实：

    • 逻辑分支不是天上掉下来的，而是有限状态机+符号匹配的自然结果。

    • 高级语言里的条件判断、布尔逻辑，本质上都是“在状态 q 读到符号 s 时，走哪条边”的不同画法。

    • 看似聪明的“if”，其实就是纸带与状态的组合——图灵机的基本循环。

这也解释了为什么一台看似简陋的图灵小机（只会 0/1、左/右）竟能归约任何高级程序。因为所有 if / else / and / or 都能在状态表里逐条落地。

小结：从哲学到工程的桥

    • 哲学上：if 是“分叉思维”的最小单元。

    • 工程上：if 在图灵机里就是“符号 + 状态 → 转移”的一条规则。

    • 历史上：图灵 1936 年用这张表，告诉世界计算的本质就是这种有限规则的无限展开。

所以，当你在 Python 里写下一行 if，不妨想象：
在底层，正有一只“图灵小蚂蚁”，在纸带上一格一格爬行，根据读到的是 0 还是 1，决定是左转、右转，还是停下来宣布：“我算完啦！”

尼克讲座第二弹：语言=思维=智能=计算=图灵机？

老友“尼克大师”《计算与智能的第一性原理》第二讲出来了（微信视频号没有URL外接链接，但进微信应该可以容易查到）——什么是计算？为什么说图灵定义了计算？为何计算机科学以他的理论为基石？笔记如下。

为什么是图灵？一场关于“计算”的趣味溯源之旅

TL;DR

我们今天谈“计算”，离不开 图灵：他给出了最简约的机器模型（图灵机），却能执行任何“有效的过程/计算”。哥德尔告诉我们形式系统有极限，丘奇/克里尼提供了等价的函数/λ演算刻画，Post画出了颇像汇编的指令系统；现代还有忙碌海狸、量子计算、类比计算这些挑战边界的故事。核心精髓一句话：图灵机——简单到近乎简陋，却普适到令人敬畏。

1）图灵之前：群星闪耀的序幕

    • 哥德尔（1931）：不完全性定理——再强大的形式系统也有真命题无法证明。
    • 他用的是原始递归函数，但不够大。后来引入了一般递归才覆盖更多。
    • Emil Post：天才又悲情。他设计的规则系统很像汇编+GOTO；提出的 Tag 系统 后来与 乔姆斯基层级对接。可惜因健康和际遇，多数成果未被重视。
    • Alonzo Church：提出 λ 演算；克里尼证明它等价于递归函数。哥德尔却嫌它“不够原子化”。

出场的是图灵（1936）。
他把“人类拿纸笔计算”的动作抽象成一台极简机器：

    1. 一条纸带（无限）；
    2. 一个读写头（0/1）；
    3. 有限状态；
    4. 左/右移动。

就这四样。简单到骨子里，但却牢牢抓住了“计算”的本质。

2）丘奇–图灵论题（CTT）：不是定理，却成共识

    • CTT：一切“有效可计算”的，都等价于图灵机。
    • 它不是定理，而是一种科学信念，因为“有效”这个直觉无法形式化证明。
    • 强版（ECT）：任何合理模型都能多项式模拟彼此。量子计算正在这里“挤牙缝”。
图灵定边界：什么能算。复杂性理论吵个不停：算得快不快。

3）巨大数字 vs 微小机器

    • 高德纳的上箭头：↑是幂，↑↑是幂塔，↑↑↑是塔的塔……都还可计算。
    • 阿克曼函数：不是原始递归，但可计算。证明“原始”≠全部。
    • 忙碌海狸（Busy Beaver）：能定义，但不可计算，增长比任何可计算函数都快。

教训：你能“定义”很多怪兽，但机器可能抓不住。

4）Post、乔姆斯基与“语言即思维”

    • 乔姆斯基文法层级：0 型 ≙ 图灵机，3 型 ≙ 有限自动机。
    • Post 的系统，其实就是粗糙的 0 型。
    • 从这里衍生出一个大胆推论：语言≈思维；既然语言有机对应机器类，或许思维≈计算。

图灵测试（1950）：把“智能”翻译成“能否在对话中骗过人类”。背后仍然是“机器是符号处理器”的预设。

5）量子、模拟与超计算的诱惑

    • 量子计算：在计算能力上没超出图灵机，但可能在效率上更快（如分解大数）。这冲击的只是强版 CTT。
    • 模拟/BSS 模型：在实数上算，数学优雅，物理却难落地。
    • 彭罗斯：人类意识非算法，可能与量子重力有关——充满想象，但无实验支持。
    • 李政道：或许世界本质上是离散的，“连续”只是近似。很契合图灵机那种“离散步骤”的宇宙观。

结论：有很多花样，但没有哪个能真正突破图灵机的“可计算性外延”。

6）人物轶事（冷知识版）

    • 哥德尔 & 爱因斯坦：常在普林斯顿散步。爱因斯坦说，他去高研院最大的乐趣是“和哥德尔一起散步”。
    • 图灵 19 岁手稿《Nature of Spirit》：因挚友去世而思考心灵与身体，预示他后来的机器智能设想。
    • Post 的叹息：他写信说，若自己在 1921 年就发表，也许就该是他证明不完全性。
    • 高德纳：除了 TeX，他还发明了“箭头记号”，专门用来描述“让计算器自爆的超大数”。
    • 冯诺依曼：称图灵机的普适性“绝对且无可救药的普适”。然后把它工业化，造出了冯氏结构计算机。

7）为什么 AI 总绕回图灵？

    • 工程：编译器、虚拟机、本质都是“一个形式模拟另一个形式”。
    • 理论：P vs NP 判定什么能有效算；忙碌海狸提醒我们，有些题目再聪明也无解。
    • 语言驱动的 AI：从早期语法分析到今天大模型，依然走在“语言—计算—智能”的桥上。

8）随身备忘单

    • CTT：有效计算 = 图灵可计算。
    • ECT：效率等价，多项式模拟；量子挑战。
    • Busy Beaver：能定义，不能算。
    • 乔姆斯基层级：语法 ↔ 自动机。
    • BSS 模型：实数域计算，物理难行。

9）精髓，一口气说完

图灵的伟大，不是把计算复杂化，而是把它简化到能涵盖一切。
0/1、左/右、读/写——这些微不足道的动作，却让哲学的直觉变成了能物理实现的机器蓝图。自此：

    • 数学能证明极限（哥德尔、不完全性、Busy Beaver）；
    • 语言学能接上机器（乔姆斯基层级）；
    • 工程能造出智能的雏形（计算机、AI）。

所以每当我们问“什么是智能”，答案常常就写在一条无限纸带上。

 

小科普：图灵机是怎么工作的？

图灵机是所有计算和AI的理论原点。它是什么，如何工作的呢？

1）开场：一支铅笔，一条纸带，一位年轻人

1936 年，一个 24 岁的年轻人叫阿兰·图灵。他没端出庞大的仪器，也没写密密麻麻的公式，只提出了一个简单到极致的主意：给我一条不限长的纸带，一个只会前后挪动的小脑袋，我就能把所有能算清楚的事，统统算清楚。

他这句话的意思是：计算到底是什么？计算就是最简单的重复动作——看一眼、改一下、挪一步、再看一眼……就像你做作业时，一边看草稿一边改正，慢慢把答案逼出来。

2）三件小道具

第一件：纸带
想象一条格子纸，往左往右都看不到尽头。每个格子里可以写“0”或“1”，也可以留空。它是记忆，更是历史：你做过什么，直接写在纸上，以后需要就走回去读。好比小学生做算术题用到的草稿纸。

小诀窍：把长记忆交给纸带，脑子里只关注“我正打算干嘛”。

第二件：读写头
这个小脑袋很倔强，一次只盯一个格子：
看一眼格子符号（读） → 把这个格子里的符号换一个（写） → 向左或向右挪一格（移）。它要能往回走（左移），因为很多事要“回头改作业”，比如加法里的进位。

第三件：状态
“状态”不是多神秘的代码，而是行为的标识：比如“正在找分隔符”、“正在进位”、“准备收尾”。它有限，因为我们希望分而治之，保持步伐的小而稳定，真正复杂的东西全写在纸带上。

你可以把状态想成贴在额头上的便利贴：现在在第几步？下一步打算干嘛？

3）一段有画面的把戏：它真的会算

一元加法——“把隔板拿掉”

编码约定：用连续的 1 表示一个数，两数之间用 0 做分隔。
例：111011 表示 3 和 2。相加 = 拿掉中间那块隔板 0，两串 1 自然拼在一起：
结果 11111（5）。

直观比喻：像珠串中间卡着一块小木板，把木板拿走，左右两串珠子就合在一起了。

如果想把它写成一个更“图灵机味”的小程序，算法如下：

1. 扫到第一个 0 → 写成空白（删除）； 2. 把右边剩下的 1 逐个左移一格； 3. 遇到空白，停机。

4）图灵机为何“无所不能”？

表面看它很“简陋”：只有 0/1、左/右、有限状态。
但这恰好是不可再简的基本操作：

    • 复杂程序 = 许多“读/写/移/换状态”的微操作拼接；

    • 就像乐高只有几种基本积木，却能搭出宇宙飞船；

    • 高级语言、App、AI，最终都能被编译成这类微操作序列。

这就是图灵机的伟大：用最少的组件，刻画了一切可计算的过程边界。

5）纸带=外部记忆，怎么用？

就三招：

    • 分区：用一个特殊记号（比如 #）把纸带分成“输入区 / 工作区 / 输出区”。
    • 标记：处理过的符号改成 X，像在书上打勾，提醒自己“这堆我做过了”。
    • 来回跑：遇到需要回头的步骤，靠左移/右移回到某个“锚点”，继续下一轮。

复杂算法，就是分区 + 标记 + 来回的组合拳。

6）几个问题，三句就答完

Q：图灵机靠谱吗，能造出来吗？
A：当然能。你可以用打孔卡当纸带、用磁头/激光头当读写头、用一小块电路板当“状态控制器”。每一步都是机械工作：读、写、挪、下一步（换状态）。所以图灵机是理论，更是能动起来的工程原型。归约下来，现代计算机无不如此。

Q：为什么要“无限纸带”？
A：不是要你真的用无限，而是不设上限。任何会在有限时间内结束的计算，只用到有限片段。

Q：状态多吗？难吗？
A：状态是“步骤标签”。够用就好，必须有限。长记忆写在纸上，别塞脑子里。

Q：它真的比现代电脑弱吗？
A：不。可计算的范围一样大；差别在速度和舒适度。现代电脑只是跑得更快、更好用。

Q：每条规则都是格式固定步骤吗？
A：对。一条规则完成“读当前格→在同一格写→移动一格→切换状态”这一整步。条件：当前状态 q、当前符号 s；结果：新状态 q'、写入 s'、移动方向 L/R。数学上写成：δ(q, s) = (q', s', d)。

7）为什么图灵机改变了世界？

    • 它把“能算”这件事画出了边界：有些问题能做，有些（比如“忙碌海狸”）可以定义但不可计算。
    • 它暗示现代计算机的灵魂：把程序也当数据写在纸带上，机器读程序就能换一身本事——这就是“存储程序”的思想。
    • 它告诉我们：复杂从简单长出来。不必造一台复杂怪兽，先把最小的执行步骤钉死，一切复杂性都能由此建起。

8）给好奇心的一次“街头实验”

找一条格子纸，写上 1 0 1 1，在右边留几格空白。
拿一支笔当“读写头”，按这个小规则走：
1）先走到最右空白；
2）往左走：遇到 1 改 0；遇到 0 改 1 并停；
3）如果一路全是 1，就在最左边补一个 1。
你会亲眼看到：进位不是魔法，是“回头、改一格、再走”的朴素力气活。

 

 

 

Multimodal tokens and the Case for Unified Modeling

Advocates of “unified” models argue that the many signals of the world—text, images, audio, video—should be tokenized and mapped into the same semantic field (a shared hidden vector space), so they can be trained jointly and modeled with one brain.

A common recipe is to atomize other modalities the way we do text: turn them into token sequences so that sequence learning—the secret sauce behind LLMs' explosive success—can extend beyond text. Universal tokens lay the groundwork for this extension. Once text, images, audio, and video are all sliced into computable tokens of similar type, one step remains: make them play in the same band (for training and for generation).

The most straightforward trick is to give each instrument a passport. Before entering the model, every segment carries a modality tag—special start symbols telling the conductor whether the next stretch is image tokens, audio tokens, or text (e.g., <image>, <audio>). Positional encodings then act like a seating chart, indicating how these tokens are arranged in a sentence, on an image grid, or along a timeline. After a few rounds of training, the model internalizes these hints: look at pixels when needed, listen when needed, and weave everything into a coherent narrative when it speaks.

A deeper level of fusion is handled by attention. Think of attention as a rehearsal room with glass walls: text can “glance” at image tokens and images can “nod back.” Over time, some heads specialize in image–image relations, others in image–text translation. Flamingo makes this explicit: cross-modal attention layers are inserted between LLM layers so that the word currently being generated can continually “look back” at the relevant image region. To users this appears as abilities for things like step-by-step visual Q&A; under the hood, a stream of text tokens moves forward while aiming its attention at precisely the visual patches that matter.

In engineering practice, a common compromise is front-end experts first, then merge. PaLM-E in robotics is a good example: images are first distilled by a pretrained vision encoder (e.g., ViT) into compact representations, then projected into perception tokens; text is tokenized as usual; robot state vectors can be appended when needed. With appropriate modality tags, all of these enter a shared Transformer backbone, where dialog, reasoning, and decision-making happen on a single score. In this analogy the front end acts like a pickup: it cleans and compresses raw signals.

More concretely: the “pickup” is a modality-specific encoder (ViT for images, an acoustic encoder for speech, etc.). The “front end” consists of the pickup plus a small projection/adapter that turns features into tokens the backbone can digest. The “backbone” is the unified Transformer that handles cross-modal alignment, long-range memory, and reasoning. In short, the backbone processes music, not the raw electrical currents of each microphone. It doesn’t touch pixels or raw waveforms; it ingests track-like, distilled features produced by the front end and aligns/reasons over them. Redundant detail and noise are filtered at the front; during generation, pixel-level detail is filled back in by a diffusion renderer or a decoder according to the backbone’s plan.

For instance, a 224×224 image has over 150k pixels. If you hand all of them to the backbone, attention wastes budget on repetitive textures. A ViT-style pickup patches, encodes, and compresses the image into roughly a couple hundred visual tokens—each like a short riff, concentrating edges, shapes, and relations that matter for understanding. Audio is similar: raw 16 kHz samples are first converted to tens or hundreds of latent vectors; rhythm and timbre are distilled, while noise and redundancy are filtered. The backbone consumes these high-semantic-density tokens (i.e., semantic tokens), so compute is lighter and crucial information remains intact. When trained end-to-end, gradients from the backbone flow back to the front end, encouraging it to keep what matters for downstream generation and discard redundancy.

Those few, information-dense tokens inside the backbone don’t carry pixel-level detail. Detail returns through a wider channel on the rendering side during generation. The backbone sets the plan; the renderer does the fine work. Three practical stages or approaches are popular in generation.

1) Composition → Orchestration. The front end is paired with a decoder: the encoder compresses content into compact codes (discrete codewords/tokens or low-dimensional latents), and the decoder can reconstruct pixels. At generation time, the backbone predicts/plans decodable representations—a string of  codes or a per-frame latent vector—rather than pixels. The decoder then “orchestrates” texture, light, and materials from those codes. In image/video, the VQ-VAE/MAGVIT-type follows this predict-codes → decode path. With residual vector quantization (RVQ), detail is added coarse-to-fine: the backbone first emits higher-level codes; the renderer produces a solid base; lower-level residual codes then refine it layer by layer.

2) Storyboard → Cinematography. The backbone provides structural plans—a low-res sketch (blueprint), motion hints/optical flow, keypoints, or a camera trajectory. Each frame is then handed to in-frame diffusion (latent-space rendering) to “develop” the image from noise under those conditions. Diffusion doesn’t need the backbone to carry high-frequency detail; it iteratively reveals detail in a high-res latent space. This is the “next-frame prediction + in-frame diffusion” split: temporal coherence by the backbone, visual richness by diffusion.

3) From coarse to fine. The backbone first outputs a coarse result—low resolution or higher-level codes—then the rendering stack applies super-resolution (SR) and residual refinement to stack up resolution and texture. The farther down the pipeline, the wider the bandwidth, but this bandwidth is handled on the rendering side rather than bloating the backbone with pixel-long sequences. Many systems expose these as configurable quality gears: stop at 720p if the user is in a rush, or climb to 1080p/4K when desired.

One subtlety: the backbone does not simply “discard detail.” First, in joint end-to-end training, the front end and decoder co-adapt with the backbone so that what’s “compressed away” is true redundancy, while cues crucial for generation (edges, materials, style, rhythm) are preserved in a recoverable latent space. Second, many renderers look back at multi-scale front-end features (e.g., via U-Net skip connections or cross-attention during decoding), allowing them to query high-bandwidth details on demand—without hauling them through the backbone.

How the renderer “looks back” depends on the task:

    • From-scratch generation (text-to-image/video): there’s no high-res reference to query. The renderer relies on learned statistics to “hallucinate” detail from the backbone’s directional plan; the text front end builds latents during training but typically isn’t invoked during sampling in generation.

    • Conditional generation/editing (image-to-image, inpainting, colorization, video continuation, style transfer): the renderer does “look back.” The reference image or previous frame is encoded to multi-scale features; the decoder/diffusion network uses skip connections or cross-attention to pull in high-res cues, aligning edges, textures, and brushwork precisely.

In the autoencoder/vector-quantization track, encoder and decoder are two sides of the same coin: the encoder compresses images/video into a shared latent language; the decoder restores pixels from latents/codes. They are trained around the same latent interface with opposite roles, by two networks that translate the same latent language. Whether the encoder is used at generation time depends on the task: unconditional generation needs only the decoder; conditional/editing and video consistency bring the encoder back to supply high-res detail.

Put together, the pipeline is clear: the backbone sets the plan—semantic coherence and causal logic—without hauling pixels across long distances; the renderer does the fine work; it looks back when a reference exists, and otherwise lets diffusion “develop” detail locally. Decoding, diffusion, and super-resolution are the high-bandwidth back end that rebuilds the scene in place. Encoder and decoder share a latent interface, each doing its half of the job—two sides of the same coin.

谈谈大一统模型的万象token与统一建模的背后

面对大千世界的各种模态的信号流，主张大一统模型的研究者强调的是把信号流切片token化，分别映射到模型内部的同一个“语义场”（多维向量空间）去做联合训练、统一建模。

常见的做法是把其他模态像文本一样元素化成token序列，以便一体化进行序列学习。序列学习是大语言模型（LLM）的成功秘诀。万象token就为“序列学习”向多模态的拓展夯实了基础。当文字、图像、音频、视频都被切分成可计算的 token 之后，还差最后一步：让它们在同一支乐队里合奏（训练与生成）。最朴素的做法，是给不同乐器发护照。进入模型之前，每段输入都带上自己的“标签”——几个特殊的起始符号，告诉总指挥接下来要演奏的是图像、还是音频、还是文字。比如在序列前插入特殊标记 <image> 或 <audio> 来提示模型接下来的是图像token或音频token。位置编码则像排座表，标明这几个 token 在句子里、在画面里、在时间里的相对关系。经过几轮训练，模型自然学会了这些标签的含义：该看图时看图，该听音时听音，叙述时再把它们粘合成连贯的一段话。

更高一层的融合，靠的是注意力。注意力像一间开着玻璃门的排练厅，文字能朝图像那边投去目光，图像也能回以点头；久而久之，某些注意力头专门处理“图对图”的联系，另一些头则擅长“图对文”的翻译。Flamingo 把这件事讲得明白：在语言模型的层间插入跨模态注意，让“正在写的那个词”随时能回望它要描述的那一块图像。读者在现实里看到的，是对一张图的循序追问与回答；模型内部发生的，是一串文字 token 一边向前写，一边把注意力投向最相关的视觉片段。

工程上常见一条折中路径：先让前端的“行家里手”各自把关，再汇入总谱。以谷歌在机器人方向的 PaLM-E 为例，图像先交给预训练视觉编码器（如 ViT）提炼成紧凑表征，经投影变成“感知 token”；文本照常token化嵌入；必要时再拼上机器人的状态向量。它们带着各自的“标签”一起进入同一主干的 Transformer，对话、推理、决策在一条大谱子上完成。前端好比拾音器， 负责对原始信号整理压缩。

具体而言，“拾音器”指各模态的专用编码器（图像的 ViT、语音的声学编码器等）；“前端”是拾音器加一层小小的投影/适配，把特征变成主干能消化的语义 token；“主干”就是那台统一的 Transformer，总负责跨模态对齐、长程记忆与推理。这样一来，主干“拿到的是乐曲”，而不是“每个麦克风的原始电流”。主干 Transformer 就像“总指挥兼编曲”：它不直接处理像素和原始声波，而是接收各模态前端已经提炼好的“音轨式”表征，在同一张谱面上做对齐、记忆和推理。冗余的原始细节与噪声被前端挡下。在生成时像素级的细节由扩散或解码器按主干给出的计划“回填”出来。

例如，一张 224×224 的图片有十五万多个像素，如果把它们全丢给主干，注意力会在海量重复纹理里打转；ViT 这样的“拾音器”先把图像切块、编码、压成大约200个视觉 token，每个 token 像一小段旋律，里头保留了边缘、形状、关系这些对理解最有用的信号。音频也是同理：原始的 16k 采样会先变成几十上百帧的梅尔特征或潜向量，节奏与音色被提炼出来，底噪与冗余被过滤掉。主干处理的，正是这些“语义更浓”的 token（semantic token，指密度高、可供主干推理的表示），既轻了计算，又不丢关键信息。在端到端联合训练里，主干的梯度会回到前端，促使前端把“该保的细节”保住，“该省的冗余”省掉。

主干里那些“少而精”的语义 token，不背像素级细节——细节是靠另一条更宽的通道在生成阶段“回填”进来的。常见有三种做法，思路都很朴素：主干定纲领，渲染器出细活。

第一种像“作曲—配器”。前端不是只进不出，它和解码器是成对训练的：编码把画面压成紧凑表示（离散码字和潜向量），解码能把它还原回像素世界。到生成时，主干并不搬运像素，而是预测/规划那些可还原的表示——比如一串 token、或一帧的低维潜向量。解码器据此“配器”，把纹理、光影、材质逐步展开。咱们可以把主干理解成“决定用哪组和弦与节奏”，解码器则把它演成真实的声音与质感。图像/视频里的主流路线（自编码器/向量量化这一路，VQ-VAE、MAGVIT 等），都是靠“预测可解码的表示→解码还原”把细节接回来的。多级量化采用“先粗后细”的回填方式：主干先给上层码字（上层码本的token），渲染器先出个八成像的底，再按下层“残差”码字把细节一层层补齐。

第二种像“分镜—摄影”。主干只给出低清草图或结构计划：布局、光流、关键点、相机走位之类；然后把每一帧交给帧内扩散或潜空间渲染器去“冲洗”。扩散模型不需要主干携带所有细节，它从噪声出发，在条件的引导下把细节一层层显出来；主干提供的条件是朝向与约束（我是谁、往哪儿动、镜头怎么走），细节由渲染器在高分辨潜空间里补足。这就是我们前面说的“下一帧预测 + 帧内扩散”：时间连贯归主干，质感细节归扩散。

第三种像是“粗到细的制版流水线”。主干先把低分辨粗粒度的表示接出来；随后一层层超分（超分辨率/SR，super resoltion）、补残差，把分辨率与纹理往上叠。越往后，通道越“宽”，带宽主要花在渲染头上，而不是让主干背负长到爆炸的像素序列。很多系统会把这几级做成可选挡位：来不及就先到 720p，有时间再“加一档”到 1080p/4K。

这里还有个常被忽略的小细节：主干并不是一刀切地“丢掉细节”。一方面，前端/解码器常与主干联合训练，梯度会推动前端只“压掉冗余”，而把对下游生成最要紧的线索（边缘、材质、风格、节奏）保在可还原的潜空间里；另一方面，很多渲染器会在末端回看前端的多尺度特征（像 U-Net 的跳连、或解码时的跨注意力），需要时还能跨注意力去“查询”那批高带宽特征，而不必把它们全搬到主干里当行李。

具体说来，渲染时是否和如何查询前端的高分辨细节，要分两种情况：

如果是从零生成（文生图、文生视频），没有可参照的高分辨输入，渲染器就不会去“查前端”。它靠训练时学到的统计规律，把主干给的计划“脑补”成可信的纹理与光影；这时文本“前端”只是用来建潜向量的编码器，采样阶段并不参与。

可条件生成/编辑时（例如图生图、修复、上色、视频续帧、风格迁移等），渲染器确实会“回看前端”：把参考图像或上一帧先过一遍编码器，得到多尺度特征，再让解码/扩散网络在每一层通过跳连或跨注意力去取这些高分辨线索，精确对齐边缘、纹理、笔触。这样细节被“就地取材”，不需要搬入主干长期背着。

在主流自编码器/向量量化这一路上，编码和解码是一枚硬币的两面：编码器把图像/视频压进一个共同的潜空间，解码器把潜向量/码字还原回像素，它们围绕同一套内部潜表征协同训练，接口一致、职责相反；但它们不是同一组权重的逆运算，而是两套网络学会“翻译同一种潜语言”。到了生成时，是否用到编码器取决于任务：无条件生成只用到解码器，有参照的编辑/视频一致性才会把编码器也拉进来做“高分细节的供给”。

把这几条合在一起看，过程就清楚了：主干定纲领，专注于语义连贯与因果逻辑，细节不在主干里长途跋涉；渲染器出细活；有参照就“回看前端”，没参照就靠扩散显影，由解码/扩散/超分这些高带宽“后端”在本地重建。编码与解码共享同一内部潜表示，各司其职、同币异面。

老马的共产主义宣言

说的是马斯克，不是马克思，但宗旨一样，世界大同，全民富足。

引言

自特斯拉成立以来，我们每一轮的宏图计划都聚焦于我们的北极星目标：以毫不妥协的方式实现不受约束的可持续性。

人类是工具的制造者。在特斯拉，我们大规模地制造低成本物理产品，目标是让每个人的生活更美好。随着人工智能（AI）技术的影响力和作用日益增强，宏图计划第四篇章所阐述的使命也就不足为奇了。

特斯拉故事的下一篇章将帮助创建一个我们才刚刚开始想象的世界，并以我们前所未见的规模实现。我们正在构建将人工智能带入物理世界的产品和服务。

通过开发电动汽车、能源产品和仿人机器人，我们近二十年来不懈努力，为这场技术复兴奠定了基础。

现在，我们正将制造能力与自主技术相结合，提供新的产品和服务，以加速全球繁荣和人类福祉，推动所有人共享的经济增长。我们正在大规模地统一硬件和软件，并以此创建一个更安全、更清洁、更愉悦的世界。

这就是可持续的富足。

指导原则

增长是无限的：一个领域的增长无需以另一个领域的衰退为代价。资源短缺可以通过改进技术、更大的创新和新想法来弥补。

创新消除约束：持续的创新帮助我们克服了电池开发的技术限制，并建立了一个由可再生资源驱动的行业。

技术解决实际问题：加速走向可持续富足所产生的产品和服务，将通过解决现实世界的问题来推动人类进步。

自主性必须造福全人类：我们开发和使用自主技术的方式，以及它为我们带来的新能力，应以其提升人类状况的能力为依据。

更广泛的访问驱动更大的增长：制造技术先进、价格合理且可大规模获得的产品，是建设繁荣和不受约束社会的要求。

加速世界向可持续富足的转变
这项挑战极其困难。消除稀缺需要不懈和精妙的执行。有些人会认为这是不可能的。而我们一旦克服了这个挑战，批评者就会看到，他们曾经认为不可能的事情确实是可能的。

我们值得为之付出的旅程都是漫长的，并且都始于第一步。我们的第一步是制造一款令人兴奋的跑车——Roadster。然后我们利用这些利润资助开发和生产更实惠、但仍然令人兴奋的产品——Model S 和 Model X。然后我们重复这个过程，带来了 Model 3 和 Model Y 并继续前进。

今天，我们正处在一个革命性时期的风口浪尖，为前所未有的增长做好了准备。这一次，对特斯拉和整个人类来说，这都不是一步，而是一个飞跃。

简要解读：特斯拉的“星辰大海”与“画饼艺术”

特斯拉的宏图计划第四篇章（Master Plan Part 4）不再满足于仅仅让你开上电动车，它打算彻底改变你的生活、工作甚至整个星球的运作方式！说白了，特斯拉想从一家电动车公司升级为“拯救地球的AI物理世界解决方案公司”。

核心目标：可持续的富足 (Sustainable Abundance)
这听起来有点像乌托邦口号，意思是特斯拉要通过技术手段，让所有人都能过上资源充裕、环保且高质量的生活，而不用担心资源耗尽或环境破坏。

三大支柱：不只是造车了！
电动汽车 (EVs)：这是特斯拉的老本行，但在新计划中更像是“基础操作”，而不是终极目标。

能源产品：包括太阳能和大型电池存储，旨在让清洁电力的获取更便宜、更可靠。

人形机器人 (Optimus)：这是新计划的真正明星！特斯拉设想这些机器人能接管那些单调或危险的工作，从而把人类解放出来，去做更有创造性和更喜欢的事情。埃隆·马斯克甚至声称，特斯拉未来80%的价值可能来自Optimus机器人。

画风突变与外界吐槽
“饼”画得又大又圆，但细节呢？：相比前两个步骤清晰、目标明确的宏图计划（第一步：造豪华跑车赚有钱人的钱 -> 第二步：用赚的钱造更便宜的车 -> 第三步：用赚的钱造大众市场车型），第四篇章被不少分析师和媒体吐槽缺乏具体细节和可衡量的目标。有人觉得它读起来像是由AI生成的充满华丽辞藻的宣言。

“电动车已非主角”：新计划中关于AI和机器人的篇幅远远超过电动车。这让人怀疑，在电动车业务面临销售压力和激烈竞争之际，特斯拉是否在转移视线，将故事焦点转向更遥远的“诗和远方”。

“马斯克的野望”：计划强烈反映了马斯克对AI和自动化的极致推崇。在他看来，经济增长没有上限，技术能解决一切资源约束。但这其中关于自动化取代人力带来的社会影响（如就业问题），计划并未深入探讨。

总结一下

所以，特斯拉的宏图计划第四篇章，可以看作是一份充满未来感、野心勃勃的“宣言书”，它描绘了一个由特斯拉技术驱动的、富足且可持续的未来世界。

然而，它也像是一份 “概念菜单” ，上面列出了许多令人垂涎的“大菜”，但有些菜还处在“研发中”或“想象阶段”，何时能真正“上菜”、味道如何，还需要时间和大量技术突破来验证。

 

Master Plan Part IV

 

Neural Codec: Key Audio Techniques in the LLM Era

“Codec” is short for coder–decoder: an end-to-end machine for compressing and then restoring audio. The encoder compressess a signal into a more compact representation; the decoder reconstructs it as faithfully as possible.

In the LLM era, audio—like text—is often cut into short segments and encoded as a sequence of discrete tokens. The “audio dictionary” used for quantization is called a codebook, like a spice rack in a kitchen: discrete little vectors in separate slots, each with an index. Unlike text, which typically has a single vocabulary, neural audio coding often uses several codebooks at the same time step (audio unit), quantizing from coarse to fine in layers—a scheme known as RVQ (Residual Vector Quantization). During compression, the system picks one entry from each codebook, using their indices to “remember” that instant of sound in layers; during reconstruction, the vectors addressed by those indices are summed, layer by layer, to restore and refill the flavor.

Earlier TTS pipelines typically did “Mel-spectrogram draft” (a continuous-valued “score”) → a neural vocoder that plays it back into waveform. The LLM-native neural codec more often runs “semantic tokens → acoustic tokens → decode to waveform.” Both semantic tokens and acoustic tokens are discrete; they differ in granularity and division of labor.

Multi-layer token coding via RVQ is a key innovation for extending LLM methods to audio. Without it, token counts would explode. By its nature, layering simplifies the complex—divide and conquer. It’s an innovation in representation that pushes discretization all the way through.

“How many layers?” There’s no universal number. It’s a knob you turn together with bitrate, latency, and quality targets. Take Google’s SoundStream: it refines the same time step with residual quantization. The paper reports common 4/8/16-layer setups and even an extreme 80-layer experiment, showing training can remain stable with many layers. For a fixed target bitrate, you can trade fewer layers with larger codebooks against more layers with smaller ones—the design space is flexible.

Meta’s EnCodec follows a “multi-codebook, variable-bandwidth” approach: the 24 kHz model uses up to 32 codebooks (i.e., 32 RVQ layers), the 48 kHz model up to 16, with codebooks typically of size 1024. During training, it randomly selects a subset of layers to participate in quantization, so a single set of weights can serve 1.5/3/6/12/24 kbps, etc. In deployment you simply “open” as many layers as you need, striking a balance between quality and realtime latency.

Don’t confuse “number of layers” with “hierarchical scales.” OpenAI’s Jukebox uses three time-scale levels in a VQ-VAE: the top level is sparse, the bottom dense, carrying information from long-range song structure down to timbral details. That’s “horizontal” stratification over time, not stacking multiple residual quantizers at the same time step.

A rule of thumb: for realtime, low-latency speech, 4–16 layers are common; for music or higher fidelity at 24 kHz, a few dozen layers aren’t unusual. The final choice isn’t doctrinaire—it depends on your target bitrate, acceptable latency, and how exacting the ear is about texture.

A neural codec begins with a neural encoder that massages raw waveforms into compact latent vectors; then a quantizer selects entries from the layered codebooks—coarse strokes for contour, finer strokes for texture; finally a neural decoder turns these discrete entries back into an audible waveform. The whole chain is trained end to end, aiming to tell the ear what it cares about—timbre, prosody, articulation, even a touch of room tail—using as few indices as possible. The result is a stable, reversible, bitrate-tunable discrete sequence.

In this setup, “audio tokens” are the indices themselves. Every few tens of milliseconds, the quantizer picks a set of indices from the layered codebooks to describe that slice; over time you obtain a readable, writable “acoustic text.” This differs from the traditional Mel spectrogram: the Mel is a continuous “photo” better suited to a conventional neural vocoder; audio tokens are a discrete “word string” that can both decode back to high-fidelity waveforms and be continued, edited, and aligned by GPT-style autoregressive models like text.

In one line: a codec is the whole compress–restore machine; the codebook is just the rack holding the discrete basis vectors—what counts as tokens are their indices. A neural codec rebuilds this machine with neural networks so it can describe a sound using a string of discrete tokens and, when needed, sing that string back into real speech or music. Put simply, audio processing can now reuse the compression–and–reconstruction playbook that has proven so powerful for text LLMs—that’s the secret behind audio’s takeoff in the era of large models.

Breakthroughs in Speech Technology in the Era of Large Models: Ultra-Realism and Full Duplex

As large language models (LLMs) expand into audio, progress has been breathtaking. “LLM-native” speech technology reached practical maturity roughly half a year ago, and the entire industry has surged forward. Two features mark this maturity: ultra-realistic speech and full-duplex interaction.

Audio tokenization—akin to what we do with text—has not only produced “model musicians” (Suno is the signature product here; I’ll cover it in a separate tech blog), but more importantly, it has catalyzed two changes that truly transform language interaction: ultra-realistic speech synthesis, and natural conversations where the system can listen and speak at the same time and be interrupted at any moment—that is, full duplex.

Start with ultra-realism. Old-school TTS always sounded like a well-trained announcer—articulate and polished, yet lacking the grain and personality of everyday speech. Once neural codec manages speech into reversible discrete tokens, synthesis no longer “reads out” only the text/content; it can also faithfully reproduce the manner of speaking, hence everyday, down-to-earth speech made possible. The model first drafts a sketch in the space of “speech semantics”: where to take a breath, when to lower the voice, which word should gently rise. It then renders that as a string of audio tokens, and the decoder brings out the breath, sibilants, and the room’s tail reverberation. You can hear the rasp in a voice, the faint nasal smile, and even preserve a speaker’s “vocal persona” across languages. Interaction no longer has a one-size-fits-all voice; it feels like chatting with a neighbor or a friend. The difference from the pre-LLM era lives in those micro-textures carried by the layered discrete codes (tokens).

Now full duplex. Early voice assistants were like walkie-talkies: you speak, then they speak, taking turns. Natural conversation is more like a kitchen scene: you’re chopping vegetables, a friend reminds you to preheat the oven, you cut in—“wait, let’s halve the salt first”—and your friend immediately pivots and responds to the new instruction. Achieving that natural feel looks like an interaction design problem (“interruptible,” “barge-in”), but underneath it requires three things working in concert: continuous listening—streaming the incoming speech into tokens in real time; speaking while listening—generating its own audio tokens ready to speak out while always keeping room to brake; and low-latency understanding and revision—completing the loop of listen → update plan → change what it says in a few hundred milliseconds.

Neural codecs shine again here: by turning both what is heard and what will be said into the same kind of discrete sequence (token string), the model can read and write on the same timeline, managing turn-taking like a human in natural conversation.

These two advances are not isolated. The more ultra-realistic the synthesis, the more the token stream must explicitly encode pauses, stress, laughter, and other details. The smoother the full duplex, the more it relies on a stable, dense, and compact flow of audio tokens so the model can switch course on the fly without dropping a beat. Because the underlying representation has been unified into a “readable and writable token sequence,” we can naturally say, “Don’t be so formal—talk to me like you used to,” and the assistant instantly switches tone. We can also cut in mid-sentence—“Skip that—give me something concrete: go or not?”—and the back-and-forth remains fluid and unawkward.

In systems that truly deliver “ultra-realistic + full-duplex” today, the winning recipe is a hybrid of listen–think–speak. Up front, a streaming auditory model continuously turns your voice into a compact sequence of audio tokens; in the middle, a large model handles understanding and planning; at the back, the system writes its intended response as audio tokens and decodes them into a waveform in real time. The reason we don’t always hand everything to a single end-to-end autoregressive GPT that goes directly from audio-in to audio-out comes down to two constraints: millisecond-level latency requirements and the need for tight control over interruption and course correction.

Think of it as a well-rehearsed band. The streaming speech encoder (ASR) is the drummer, keeping time in tens-of-milliseconds beats. The large model in the middle is the conductor, continuously re-orchestrating based on the latest auditory tokens. The neural-codec decoder (TTS) is the lead vocalist, singing while leaving braking distance so an interruption can “hit the brakes” instantly. In practice, both drummer and vocalist are often smaller, faster specialist models (streaming recognition such as RNN-T/Conformer, paired with neural-codec-based fast synthesis) rather than folding every detail into one gigantic autoregressive stack. Otherwise, interruptions and back-ups might blow up latency.

This does not mean a return to the old ASR/TTS pipeline. The key change is that the base representation has become unified discrete audio tokens: the listening side no longer produces only text characters; it can emit semantic or acoustic units as well. The speaking side no longer merely concatenates phonemes; it writes a reversible stream of codec tokens that carries breath, stress, and reverberant tails. The large model either plans at the hidden layer or refines a two-step “semantic tokens → acoustic tokens” plan, then hands the result to the decoder to render. This keeps full-duplex latency low while preserving ultra-realistic texture.

Looking ahead, research is converging: end-to-end “spoken LLMs” are pulling listening and speaking into the same set of parameters, taking audio tokens directly as input and output (speech2speech). In engineering, however, conversation management—who speaks when, how to interrupt, how to revise—remains as guardrails for smoothness and robustness. Today’s best practice is like a hybrid car: the chassis is the unified, tokenized language; the engine is the large model; and the start/stop control is often delegated to the small specialized motors. The result is fast and stable—and it keeps the warmth of the human voice.

大模型时代的语音技术突破：超写实和全双工

大语言模型（LLM）延展至音频，一路狂飙，LLM-native 的语音技术大约在半年多前开始成熟，全行业都起来了。技术成熟的重要标志是两个重要的 featrures：超写实与全双工。

像LLM类似的音频token化，不只造就了模型音乐家（代表产品Suno，另文介绍），更重要的是直接催生了两件真正改变语言交互的事：超写实的语音合成，和像人一样边说边听、随时可插话的自然对话能力（称为“全双工”）。

先说“超写实”。过去的机器配音，总像一位训练有素、拿腔拿调的播音员，字正腔圆，却缺乏日常语音的个人特色与颗粒感。神经编解码器把语音整理成可逆的离散token之后，合成不再只是把“内容”读出来，而是能把“怎么说”也一并还原，接地气的日常语音开始成熟。模型先在“文字→声音语义”的层面写一份乐谱般的草稿：哪里该停一口气，哪里该压低声线，哪一个词要轻轻上扬；接着把这份草稿译成一串音频 token，由解码器把气息、齿音、房间的尾响都带出来。你会听到嗓音里的毛边、笑意里那一丝鼻音，甚至能在跨语言时保留说话人的“人格音色”。交互不再是千篇一律的声音类型，而是像与邻家或朋友的自然交谈，与前大模型时代的差别就在这些被“分层离散码”承载的微观纹理上。

再说全双工。早年的语音助手像对讲机：你说完它再说，轮流发言；而真正的对话更像我们的厨房场景——你在切菜，朋友在提醒烤箱预热，你随口打断一句“等一下先把盐减半”，朋友立刻收住，改口回应关于加盐的火候。要做到这份自然，表面是“能被打断、能抢话”的交互设计，底层却是三件事配合起来：第一，持续听——把听到的语音分成小片段实时转成 token；第二，同时说——一边生成自己的音频 token准备回应，一边留好“随时刹车”的余地；第三，低延迟的理解与改写——在几百毫秒的量级里完成听懂→更新计划→改口输出的闭环。

神经编解码器此处再次立功：它把“听到的”和“要说的”都变成同一种离散序列，模型才方便在同一时间轴上又读又写，像人在自然交互时那样管理“轮到谁说”的节奏感。

这两件事并不孤立。你会发现，越是超写实的合成，越要求在“写 token”时把停顿、重音、笑声这些细节也写进去；越是流畅的全双工，越依赖稳定、稠密而紧凑的音频 token 流，让模型能在不中断的情况下随时调头。正因为底层表达统一成了“可读可写的序列”，才让我们今天能自然地说一句“别这么一本正经好吗，像当初那样跟我讲就好”，助手就立刻会意换个口吻。我们也能在它说到一半时插话，例如“不用扯那个了，咱们来点实的，去还是不去”，以此毫不尴尬地完成对话里的“你来我往”。

真正把“超写实 + 全双工”做顺的系统，今天多半是“听—想—说”的混合体：前端用流式的听觉模型把声音连续地变成紧凑的音频 token 序列，中间由一个大模型负责理解与规划，后端再把它想说的话实时“写回”成音频 token 并解码成波形。之所以不总是能把一切都交给一个端到端的自回归 GPT 直接从声音到声音，主要是两件事卡着：毫秒级的延迟目标，以及对可打断、可改口的强控制需求。

你可以把它想成一支分工明确的乐队。流式语音编码器（ASR）像鼓手，按几十毫秒一拍稳稳往前推；中间的大模型像指挥，随时根据新的听觉 token 改编配器；后端的神经 codec 解码器（TTS）像主唱，边唱边留出刹车距离，让你一插话就能“踩停”。这里的“鼓手”和“主唱”确实常用到相对“小而快”的专用模型（RNN-T/Conformer 一类的流式识别，配合基于神经 codec 的快速合成），而不是把所有细节都并入一个庞大的自回归堆栈里逐 token 生成。否则一旦遇到打断或回退重说，延迟可能失控。

但这并不等于回到老派的语音与文字的转换（ASR/TTS）。关键变化在于底层表达已经统一成离散音频 token：听的那头不再只产生文本字符，而是也能产出语义或声学单元；说的这头不再只是拼接字音，而是写一串可逆的 codec token，把气息、重音、尾响都带出来。大模型要么在文本层规划，要么在“语义 token→声学 token”的两步里细化，再把结果交给解码器渲染出来。这样既守住了全双工的低延迟，又保留了超写实的质感。

往前看，研究在合流：端到端“口语大模型”正把听与说进一步并到同一套参数里，直接以音频 token 为输入输出；工程上仍会在会话管理层保留“谁在说、何时打断、怎么改口”的调度与安全闸门。今天的最佳实践像一部混合动力车：底盘是离散 token 化的统一语言，发动机是大模型，起步与刹车常交给专用的小电机去控速，于是既快又稳，还保留了人声的温度。

说说神经 codec，大模型时代的音频技术要点

“Codec”是 coder（编码）和 decoder（解码）的合体，指一整套“压缩—还原”的机器：编码那端把声音挤压成更省空间的表示，解码那端再把它尽可能还原出来。

在大模型时代，音频和文本一样，常被切成片段并编码成离散 token 的序列。用来量化的“音频词典”叫码本（codebook），好比厨房里的香料盒——一格格离散的小向量，各有编号。不同于文本通常只用一部大词典，神经音频编码往往在同一时间步（音频单元）上配几层码本，由粗到细逐层量化（术语叫 RVQ，Residual Vector Quantization）。压缩时，机器会在这些码本里各挑一个最合适的条目，用它们的编号索引分层“记住”这一瞬的声音；还原时，再把编号对应的向量取出相加，层层把味道补全。

早年的 TTS 常用“梅尔频谱草稿”（连续值“乐谱”）→ 传统神经声码器（vocoder）直接还原波形（根据乐谱演奏）；而 LLM-native 神经编解码器路线，多为“语义 token → 声学 token → 解码波形”，两类token都是离散 token，只是粒度不同、分工不同。

RVQ 多层token编码是LLM延展到音频的一个关键创新。没有它，token就会爆炸。分层的本性是化繁为简，分而治之。这是输入信号的表示（representation） 创新，从而得以把离散化进行到底。

“几层”量化呢？没有一个放之四海而皆准的固定数，它其实是个随码率、延迟与质量目标一起调的旋钮。拿 Google 的 SoundStream 为例：它用残差量化把同一时间步上的表示一层层细化，论文里既给了常用的 4、8、16 层配置，也做过极端实验，把量化层数加到 80 层，证明即便很多层也能稳定训练；同一目标码率下，用更少层但更大的码本，或用更多层但每层码本更小，都是可以互相折换的设计选择。

Meta 的 EnCodec 走的是“多码本、可变带宽”的路线：24 kHz 的模型最多用到 32 个码本（也就是 32 层 RVQ），48 kHz 的版本最多 16 个，每个码本通常 1024 个条目；训练时随机挑选若干层参与量化，从而一套权重覆盖 1.5/3/6/12/24 kbps 等不同带宽。这样一来，工程上就能按需“开几层就几层”，在质量和实时性之间找平衡。

别把“层数”跟“层级类别”混为一谈。OpenAI 的 Jukebox 采用的是三类时间尺度的量化（VQ-VAE）：顶层类最稀、底层类最密，用来承载从段落结构到音色细节的不同粒度信息；这说的是“横向按时间分三层类别”，而不是同一时间步上堆多少层残差量化器。

把这些放在一条直观的尺子上看：实时语音、低延迟的场景，常见是 4–16 层一类的配置；音乐或高保真场景，24 kHz 下用到二三十层也不罕见。最终取几层，不是教条，而要综合平衡，要看你要的码率、能接受的延迟，以及耳朵对质感的要求。

“神经 codec”的入口是神经“编码器”，把原始波形揉成紧凑的隐向量；接着量化器从各层码本里一层层选条目，这就是逐层查词典的过程（粗笔先定轮廓，细笔再添质感）；出口是神经“解码器”，把这些离散条目还原成为可听波形。整条链条端到端训练，目标是在保真的前提下用尽量少的编号，把人耳在意的东西讲清楚：音色、韵律、吐字，甚至房间里那点余韵。最终得到的是一条稳定、可逆、码率可调的离散序列。

在这套体系里，“音频 token”指的就是那些编号本身。每隔十几到几十毫秒，量化器从各层码本里选出最接近的一组编号来描述这个片段；时间一长，便得到一串可读可写的“声学文本”。这和传统的梅尔频谱不同：梅尔是连续数值的“照片”，更适合给传统神经声码器（vocoder）直接还原；音频 token 是离散的“词串”，既能高保真解码回波形，也能像文字一样被 GPT 风格的自回归大模型接龙、改写与对齐。

一句话收束：codec 是整台“压缩—还原”的机器；码本只是机器里装“离散基元向量”的香料盒，真正作为 token 的是它们的编号；神经 codec 则把这台机器用神经网络重铸，让它学会用一串离散 token 讲清楚一段声音，并在需要时把这串 token 唱回成真的语音或音乐。说白了就是，音频处理基本上可以沿用文本大模型那一套已经验证极为有效的压缩与还原技术，这就是音频技术在大模型时代得以再起飞的奥秘。