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

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

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

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

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

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

这就是柯尔莫哥洛夫复杂度(Kolmogorov complexity):

    • 对一个二进制串 xK(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 上的论文以及刘群老师的观点都指出,大模型可以极大地赋能无损压缩。实验证明,利用大模型对文本进行预测,其压缩率远高于传统的 gzipzip 等无损压缩算法。

    • 原理是这样的: 传统的压缩算法(好比步枪)只利用统计规律;而大模型(好比核武器)“吃透”了自然语言的深层规律(语法、逻辑、世界知识)。
    • 在还原数据时,大模型预测的概率分布与真实数据深度吻合,因此只需要极少量的额外信息(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,工作原理都是这样的。