Demystifying the misconception of "Lossless Compression as Intelligence"

Debates on LLM compression theory reveal persistent misconceptions. Crucially, compression lies at the heart of the LLM revolution—illuminating its divine spark. Time for some clarification.

There are two interconnected core issues in the explosive growth of contemporary generative AI and large models that are most worth understanding thoroughly—otherwise, we're essentially allowing ourselves to live in medieval darkness. The first is how sequence learning unlocked universal tasks, making artificial general intelligence possible and transforming AGI from fringe science or science fiction into reality. I've written several blog posts attempting to explain this, though I'm not entirely certain I've conveyed it accurately. The second is the compression theory underlying large model intelligence. This issue has only recently become clear to me, with its context and principles finally falling into place. I feel it's worth sharing these insights.

A critical myth persists:  "Intelligence equals lossless compression" or "Lossless compression begets intelligence."

Both are false.

Compression produces intelligence—that's correct. But it's definitely not lossless compression that produces intelligence.

There's a cognitive error at play: many people conflate intelligent compression during training (lossy abstraction) with technical compression for specific applications (lossless encoding/decoding).

Compression has two distinct meanings: first, extracting every drop of insight and regularity from data, approaching theoretical optimality (K-complexity)—this is compression's true definition and intelligence's manifestation. Second, lossless compression, which requires perfect restoration of original data. Lossless compression/restoration isn't a genuine intelligence goal; at most, it's an application requirement (such as in archiving or transmission scenarios).

Lossless compression directly serves lossless restoration, where the lossless standard demands 100% restoration of input information in output (bit-level, including imperfections). Clearly, without resorting to form (instead of meaning), losslessness is ill-defined or meaningless. This differs from ultimate information compression, which targets meaning instead of form.  Semantic space embodies the true essence of teh statement "compression equals intelligence." Recognizing this distinction is key to dispelling the myth.

GPT, as a general intelligence agent, derives its core value from creative "distortion" in generation tasks (most application scenarios such as creative writing), while lossless compression is merely a technical byproduct (few application scenarios, such as for storage and transmission), and this capability only weakly correlates with intelligence level (when involving compression ratio, but unrelated to lossless restoration goals).

Attempting to prove model intelligence through lossless compression capability is inappropriate—like measuring legislators' competence by clerks' shorthand speed. These represent fundamentally different pathways:

Intelligent compression pursues minimal causal generation rules (K-complexity pathway), requiring active payment of "abstraction tax"; lossless compression pursues data restoration fidelity, leading to sacrificed model simplicity.

GPT's revolutionary nature lies in the former; the latter is merely a technical byproduct. In mainstream scenarios like generation and reasoning, creativity (or creative distortion) truly represents intelligence's brilliance, though its side effect of hallucination becomes large models' inherent challenge in some specific task scenarios (e.g. summarization, translation).

GPT uses next token prediction as its autoregressive training objective, seemingly a type of formal compression since the next token is its gold standard. But in implementation, it's unmistakably a semantic compression. At the micro level, next token prediction accuracy isn't measured by whether model output tokens match gold standards at the formal level, but through cross-entropy of internal token representations, measuring alignment between output and gold standards in semantic space. At the macro level, GPT trains on big data as a whole, not just targeting individual data points (a passage, a song, or an image). Lossless compression/restoration has clear definition for individual data points (100% formal restoration), but facing big data, this definition becomes impractical (unless for original data storage). In other words, big data compression determines it can only be semantic-level compression, mining the regularity behind big data.

Regarding GPT-enabled lossless restoration applications, large models' theoretical foundation of Kolmogorov complexity (K-complexity) supports the "lossy training-lossless application" framework. K-complexity pursues minimal generation programs, not data restoration capability. During training, lossy compression is the only path to approach K-complexity; during application, lossless restoration benefits from GPT's regularity to achieve unprecedented high compression ratios, as hes been verified by a number of researchers.

Actually, the famous scaling law for large model training emerges from this principle. This empirical observation and insight demonstrate that loss is necessary for intelligence: data must far exceed model size for intelligence improvement (otherwise the model "cheats" by memorizing and overfitting in vast parameters rather than continuously compressing and generalizing).

From another perspective, lossless restoration is an algorithmic property, not directly related to K-complexity. In fact, lossless restoration experiments show algorithms can always achieve lossless goals. Essentially: lossless restoration = model + delta. This delta represents the "abstraction tax" paid by the model—details the model didn't remember and needn't remember. In practice, powerful models yield smaller deltas; weaker models yield larger deltas. Lossless compression algorithms simply play this game. During application, model quality affects efficiency (compression ratio) but doesn't affect losslessness. Delta equals zero means the model remembered every detail, requiring the model to approach infinity or euipped with external massive storage. The other extreme is an infinitely small model or no model, degenerating the system into pure storage (hard disk). Disregarding compression ratio: white noise's K(x)≈|x| can still be precisely restored using lossless compression (like ZIP).

In textbooks, K-complexity is defined as a measure of data's intrinsic structure—"the length of the shortest program that outputs the string"—uncomputable in theory. Lossless compression is viewed as an engineering implementation for precise data restoration. Large models' emergence, verified by multiple scholars, indeed dramatically improves lossless compression ratios but doesn't change lossless compression's nature as merely an engineering tool. Of course, dramatically improved compression ratios also indicate that large models grasp data distribution regularity to unprecedented heights. However, regarding complexity theory, lossless compression/restoration often misleads. But high compression ratios during lossless restoration indeed strongly evidence large models' high intelligence, as no other knowledge system can surpass them.

Additionally, this topic has a crucial temporal dimension. Compression targets historical data, while predictive applications point toward the future (models as prophets), yet restoration only refers to historical data. This means even if lossless compression/restoration achieves ultimate compression ratios, it remains a distance from true predictive capability because there's a temporal wall between them. Crucially, intelligence's essence favors future prediction over historical restoration. Future prediction requires space for random sampling, but historical restoration precisely kills this beneficial randomness.

 

 

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

立委按:这两天跟大模型压缩理论干上了,发现,这里面目前在市面上仍然充满了迷思和误解。要命的是,压缩问题是大模型革命的首要问题,反映了大模型背后的奥秘和上帝之光。感觉到了正本清源的时候。

我以为,当代生成式AI及其大模型的大爆发,其中有两个相互关联的核心问题,最值得花时间搞明白,否则就好比允许自己生活在中世纪的黑暗中。第一个是序列学习如何解锁了万能任务,让通用人工智能成为可能,AGI不再是民科或科幻。这个问题我写过多篇博客试图解说,虽然不敢肯定是不是传达准确了。第二个就是大模型智能背后的压缩理论。这个问题直到最近才算梳理明白,脉络和原理清晰起来。觉得值得分享一下心得。

在大模型无损有损的争论中,产生了很多迷思,其中一条是:智能就是无损压缩,或,无损压缩产生智能。

错!两条都错。

压缩产生智能,没错。但绝不是无损压缩产生的智能。

存在一个认知误区:很多人把训练阶段的智能性压缩(有损抽象)和一种特定应用的技术性压缩(无损编解码)混为一谈。

压缩有两个不同的含义:一个是榨干数据的油水和所有的规律性,逼近理论最优值 (K-complexity),这才是压缩的正解,智能的体现。第二个指无损压缩,要求可以无损还原始数据。无损压缩/还原不是一个真正的智能目标,它最多不过是一个应用需求(例如在存档、传输等场景)。大模型已经证实可以高效赋能无损还原数据,智能在这里起的作用是让无损压缩提高效率,即提升压缩率。

无损压缩直接服务于无损还原,无损的标准是输入信息在输出中必须达到100% 还原(bit level,包括瑕疵)。可见,离开形式标准,谈不上无损。这与极致的信息压缩不同,极致压缩的对象可以是形式,也可以是内容。前者等价于(极高压缩率的)无损压缩,但后者才是“压缩即智能”的真谛。看清这一点是破除迷思的关键。

GPT作为通用智能体,其核心价值在于:生成任务中的创造性失真(多数应用场景),而无损压缩仅是技术副产品(少数应用场景,例如存贮和传输),且该能力与智能水平仅弱相关(与压缩率高低直接相关,但与无损还原宗旨无关)。

试图用无损压缩能力证明模型智能并不合适,如同用书记员的速记能力衡量立法者水平 —— 两者本质不同路径:

智能压缩追求最小因果生成规则(K-complexity路径),需主动支付抽象税
无损压缩追求数据还原保真度,导致牺牲模型的简洁性。

GPT的革命性在于前者,后者仅是技术副产品。在生成、推理等主流场景中,创造性失真才真正是智能的闪光点,虽然其副作用幻觉在特定任务场景成为大模型与生俱来之痛。

以下一词元预测(next token prediction)作为自回归训练目标的GPT,貌似是形式压缩,因为下一词元是其黄金标准。但实际上,它是不折不扣的意义压缩。微观层面,下一词元预测准不准并不是在形式层面看模型输出token与黄金标准能否匹配,而是通过token 内部表示的交叉熵(cross entropy),是在衡量输出与黄金标准在意义空间之间的吻合度。宏观层面,GPT的训练对象是大数据整体,而不是数据个体(一段话、一首曲子或一幅图)。无损压缩/还原在数据个体具有明确定义(100%还原形式),但面对大数据,这个定义实际上不可行(除非是原数据存贮)。换句话说,大数据压缩决定了它只能是意义层面的压缩,挖掘大数据背后的规律性。

就GPT赋能无损还原的应用而言,大模型的理论基础柯氏复杂度(Kolmogorov complexity,K-complexity)支持“有损训练-无损应用”框架。柯氏复杂度追求的是最小生成程序,而非数据还原能力。训练阶段,有损压缩是逼近柯氏复杂度的唯一路径;应用阶段,无损还原得益于GPT的规律性可以做到前所未有的高压缩率。

其实,著名的大模型训练的经验法则 scaling law 就是这么来的。这个经验观察及其洞见说明了有损是智能的必需:数据必须远大于模型才能有智能提升(否则模型就会“偷懒”,在庞大的参数里死记硬背过拟合,而不是不断压缩和泛化)。

换一个角度看,无损还原是算法属性,与柯氏复杂性并不直接相关。实际上,无损还原的实验表明,算法永远有办法达到无损的目标。本质上:无损还原 = 模型 + delta。这个 delta 就是模型缴纳的抽象税,是模型没记住也不必记住的细节。实践中,用强大的模型,delta 小一点;用弱小的模型,delta 就大一些。无损压缩算法不过就是在玩这个游戏。应用阶段,模型质量影响效率(压缩率),但不破坏无损性。delta 等于零,意味着模型记住了所有的细节,这要求模型趋向于无限大,或外挂巨大的硬盘。另一个极端是模型无限小,或没有模型,那就退化成彻头彻尾的硬盘了。不考虑压缩率:白噪声的 K(x)≈∣x∣,仍可用无损压缩(如ZIP)精确还原。

教科书中,柯氏复杂性定义为数据内在结构的度量,即“the length of the shortest program that outputs the string”,uncomputable,理论上不可计算。而无损压缩被视为一种工程实现手段,用于数据的精确还原。大模型的出现,经多位学者验证,的确大幅度提升了无损压缩的压缩率,但并不改变无损压缩只是一种工程工具的本性。当然,大幅度提升压缩率本身也表明,大模型对于数据分布规律性的把握达到了前所未有的高度。就复杂性理论而言,无损压缩/还原常常是个误导。但无损还原的时候压缩率高,的确是大模型高智能的一个很强的佐证,因为没有其他知识系统能胜过它。

另外,这个话题还有一个要点是时间维度。压缩的对象是历史数据,预测的应用指向未来(模型作为预言家),可还原却说的是历史数据。这意味着,即便无损压缩/还原做到了极致的压缩率,也与真正的预测能力有距离,因为这里面隔了一层时间的墙。关键是,智能的本质偏爱未来预测,而不是历史还原。未来预测必须有随机采样的空间,但还原历史却恰好扼杀了这种有益的随机性。

 

GPT and the Art of Compression

A Cosmic Dance of Bits and Meaning

Imagine a cosmic library, vast and infinite, housing every possible sentence—from the profound “Artificial intelligence will reshape the future” to the absurd “Cat pillow jumps blue because Wednesday.” In this library, popular sentences sit on bright, accessible shelves, found with a quick note: “Shelf 3, Book 5.” Random gibberish lurks in dusty basements, needing a word-for-word map. GPT, the AI we know as a language wizard, is the cosmic librarian, compressing texts into compact codes that can be perfectly restored. But is this compression flawless, or does it lose something along the way? Let’s embark on a journey through probability, information theory, and engineering to uncover the magic of GPT’s compression—and why it matters.

The Cosmic Library: Compressing Meaning

Picture yourself in this library, tasked with sending a sentence across the galaxy. A predictable sentence like “Artificial intelligence will reshape the future” is easy to pinpoint, requiring just a short instruction. A random jumble, like “Cat pillow jumps blue,” demands spelling out every word, taking up more space. GPT’s brilliance lies in its world model—a map of language probabilities built from vast data. It knows which sentences are “popular” (high-probability) and encodes them efficiently. Why do you think predictable text is easier to compress than random noise?

This process is called lossless compression, meaning the original text is perfectly restored, bit for bit. Unlike a compressed JPEG that blurs details, GPT’s compression ensures no loss. But some argue it’s lossy, losing information like a summary. Who’s right? To answer, we need to explore the mechanics and the theory behind it.

Arithmetic Coding: The GPS of Compression

GPT’s compression relies on arithmetic coding, a method that turns text into a number on a line from 0 to 1. Think of it as a GPS coordinate for a sentence’s location in the probability universe. Here’s how it works for “cat eats fish”:

    1. Start with [0.0, 1.0].
    2. For “cat” (P=0.5), shrink to [0.0, 0.5).
    3. For “eats” given “cat” (P=0.7), narrow to [0.0, 0.35).
    4. For “fish” given “cat eats” (P=0.4), end at [0.0, 0.14).
    5. Output a binary number, like 0.125 (0.001 in binary), within [0.0, 0.14).

Decompression reverses this, using the same GPT model to retrace the intervals, ensuring the exact sequence—“cat eats fish”—is restored. Why is using the same model crucial for perfect reconstruction?

The interval’s length (0.14 = 0.5 * 0.7 * 0.4) reflects the sequence’s probability. High-probability sequences create larger intervals, needing fewer bits to encode (e.g., -log₂(0.14) ≈ 2.84 bits). Random sequences, with lower probabilities, need more bits. This is rooted in information theory, where a word’s information content is -log₂(P(x)). A likely word (P=0.95) carries little information (0.07 bits), while a rare one (P=0.0001) carries much (13.3 bits). How does this explain why semantic text compresses better than noise?

Lossless or Lossy? Solving the Debate

The debate over whether GPT’s compression is lossless or lossy stems from a subtle distinction. Lossless compression ensures the original data is perfectly restored, like unzipping a file to its exact form. Lossy compression, like MP3s, discards details for smaller size, losing fidelity. GPT’s compression, using arithmetic coding, is lossless: the encoded binary number uniquely maps back to the original text, preserving every bit. Experiments like ts_zip by Fabrice Bellard and 2022-2023 work by Li Ming and Nick show GPT outperforming gzip by up to 10x for semantic data, with no loss. Why might some still call it lossy?

The confusion arises from GPT’s training process. When GPT learns from vast data, it abstracts patterns into a simplified world model, discarding noise and details—clearly a lossy process, much like summarizing a library. But when used as a tool for compression, there exists a lessless compression algorithm that applies the model to encode and decode specific texts deterministically, ensuring no loss. The lossy aspect lives in the model’s creation, not its application. How does this distinction change your view of GPT’s capabilities?

The Theory: Kolmogorov Complexity and Intelligence

At the heart of this lies Kolmogorov complexity (KC), the length of the shortest program to generate a dataset. An ideal compressor would find this program, but KC is uncomputable—a theoretical dream. GPT’s next-token prediction approximates this, acting like a “prophet” forecasting sequences based on learned patterns. This aligns with Solomonoff induction, where predicting the next token mirrors finding compact descriptions. Ilya Sutskever noted in a 2023 Berkeley talk that this is the secret behind GPT’s efficiency compared to models like BERT. Why might prediction be a form of compression, and how does it reflect intelligence?

For semantic data, like news articles or logs, GPT’s predictions are highly accurate, leading to compact codes. For random noise, where KC equals the data’s length, compression fails—no model can predict chaos. This highlights a limit: GPT excels where patterns exist. What types of data do you think GPT could compress best?

The Tightrope: Efficiency vs. Reliability

High compression rates are powerful but fragile. A single bit error in a highly compressed file can derail decompression, like a misstep on a tightrope. Consider the trade-offs:

Dimension High Compression Rate Low Compression Rate
Restoration Accuracy 100% (theoretical) 100% (theoretical)
Error Resistance Fragile (1-bit error can crash) Robust (local errors)
Computational Cost High (GPT + coding) Low (e.g., gzip)
Readability None (ciphertext) High (text/binary)

High rates suit scenarios where bandwidth is costly, like interstellar communication, but require error correction (e.g., CRC) to prevent crashes. Low rates are ideal for reliable archiving, like server logs, where robustness trumps size.

Why It Matters: From Stars to Servers

GPT’s compression could transform how we store and send data. In interstellar missions, where every bit is precious, it could shrink messages dramatically. In data centers, it could optimize archival storage, though computational costs (e.g., ts_zip at 1k/s) pose challenges. Future models, with sharper predictions, could push efficiency closer to the theoretical limit.

This cosmic dance of bits and meaning reveals a profound truth: compression is intelligence, and GPT is a master choreographer. By mapping language to probabilities, it turns texts into elegant codes, preserving every detail. Whether you’re an AI enthusiast or a tech expert, this opens a universe of possibilities.

Sources: Adapted from posts on liweinlp.com (13277, 13272, 13275, 13273, 13279, 13281).
About the Author: Dr. Li Wei, a senior NLP/LLM consultant, has led innovations at MobVoi, Netbase, and Cymfony, earning the TREC-8 QA Track and 17 SBIR awards.

 

 

 

Efficiency vs. Reliability: The Compression Tightrope

GPT’s compression can shrink data dramatically, but high efficiency comes with risks. A single bit error could unravel everything, like a tightrope walker losing balance. How do we balance compression’s power with reliability?

The Trade-offs

High compression rates save space but are fragile, while low rates are robust but bulky. Here’s a comparison:

Dimension High Compression Rate Low Compression Rate
Restoration Accuracy 100% (theoretical) 100% (theoretical)
Error Resistance Fragile (1-bit error can crash) Robust (local errors)
Computational Cost High (GPT + coding) Low (e.g., gzip)
Readability None (ciphertext) High (text/binary)

High rates suit costly transmission (e.g., interstellar), while low rates fit archiving. Why might a bit error be catastrophic in high compression?

Practical Solutions

Error correction (e.g., CRC) can protect high-rate compression, ensuring reliability. For archives, lower rates may suffice. What scenarios demand high efficiency, and how can we safeguard them?

 

Original post: https://liweinlp.com/13281

 

 

Arithmetic Coding for GPT’s Compression Engine

At the heart of GPT’s compression lies arithmetic coding, a method that turns text into numbers with surgical precision. Like a GPS encoding a house’s location, it captures sentences in compact codes. How does this engine work, and why is it so effective?

The Mechanics

GPT predicts probabilities for each token (e.g., P(“future” | “Artificial intelligence is”)=0.6), and arithmetic coding divides [0, 1) into subintervals:

  1. Start with [0, 1).

  2. Assign [0, 0.6) to “future,” narrowing the range.

  3. Iterate for each token, ending with a tiny interval (e.g., [0.3654321, 0.3654343]).

  4. Output a binary number as the compressed code.

Decompression uses the same GPT model to reverse the process, ensuring bit-level accuracy. Why is the same model critical?

A GPS Analogy

Compression is like encoding a villa’s address into a postal code. Decompression follows this code to the exact spot. This precision ensures no loss. How does this analogy clarify the process?

The Edge of Efficiency

GPT’s accurate predictions make intervals larger for predictable text, reducing bits needed. What limits this approach, and how might better models enhance it?

Original post: https://liweinlp.com/13273

 

 

Navigating the Probability Universe with GPT

Every sentence has a unique address in a probability universe, a number line from 0 to 1. GPT maps texts to these addresses, compressing them into compact codes. How does this cosmic navigation work, and why is it a breakthrough for compression?

Mapping Sentences to Intervals

Each sequence corresponds to a unique interval in [0, 1), with its length equaling the sequence’s probability. For “cat eats fish” (P(“cat”)=0.5, P(“eats” | “cat”)=0.7, P(“fish” | “cat eats”)=0.4), the interval is [0, 0.14), with length 0.5 * 0.7 * 0.4 = 0.14. Arithmetic coding narrows this interval step-by-step, outputting a binary number. Decompression retraces the path, ensuring perfection. Why are these intervals unique?

The Power of Information Theory

The interval’s length reflects the sequence’s probability, with high-probability sequences needing fewer bits (-log₂(0.14) ≈ 2.84 bits). This approaches Shannon’s entropy limit, where GPT’s precise predictions minimize bits for semantic data. Why does predictability reduce bit requirements?

Why It’s Revolutionary

Unlike traditional methods (e.g., Huffman coding), GPT’s approach handles continuous streams and leverages semantic patterns, making it ideal for texts. What data types might benefit most, and how could this evolve with better models?

Original post: https://liweinlp.com/13275

 

Is GPT Compression Lossless or Lossy? The Truth Revealed

The claim that “compression is intelligence” sparks debate: does GPT compress data perfectly, or does it lose something along the way? Some argue it’s lossy, like a compressed JPEG, while others insist it’s lossless, restoring every bit. The answer hinges on a key distinction: GPT’s training versus its use as a compressor. Let’s unravel this mystery.

The Heart of Compression: Kolmogorov Complexity

Kolmogorov complexity defines a data’s essence as the shortest program to generate it—an uncomputable ideal. GPT’s next-token prediction approximates this, acting like a “prophet” forecasting sequences based on its world model. This predictive power drives from compression. How does predicting the next word relate to shrinking data size?

Lossless Compression in Action

Using GPT for compressing a tring of target sequence data is lossless, meaning the original data can be perfectly restored. Experiments like ts_zip (Fabrice Bellard) and Li Ming & Nick’s 2022-2023 work show GPT with arithmetic coding outperforming gzip, sometimes by 10x, in high-transmission-cost scenarios like interstellar communication. Here’s why it’s lossless:

  • Mechanism: GPT provides probabilities (e.g., P(“will” | “Artificial intelligence”)=0.8), which arithmetic coding uses to encode input sequences into a binary number. Decompression uses the same model to reverse the process, ensuring bit-level accuracy.
  • Evidence: Even low-probability tokens are encoded with more bits, preserving all information.

Why might some confuse this with lossy compression?

Training vs. Compression

The confusion arises from GPT’s training, where it abstracts vast data into a simplified world model—a lossy process, like summarizing a library. But compression using this model encodes specific data losslessly. How does this distinction clarify the debate?

Practical Implications

This approach excels for language data (e.g., texts, logs) but struggles with random noise, where complexity equals length. Scenarios like space missions, data archives could leverage this.

Original post: https://liweinlp.com/13272

 

GPT as a Cosmic Librarian: Unlocking Lossless Compression

Imagine a cosmic library holding every possible sentence, from the profound “Artificial intelligence will reshape the future” to the absurd “Cat pillow jumps blue.” Popular sentences sit on prominent shelves, easily found with a short note like “Shelf 3, Book 5.” Random gibberish hides in dusty basements, requiring a long, word-for-word map. GPT, our cosmic librarian, navigates this library with uncanny precision, compressing texts into compact codes that can be perfectly restored. How does it work, and why is this a game-changer for data compression?

The Library of Language

In this infinite library, each sentence has a “popularity” score—its probability based on grammar, meaning, and context. GPT’s world model, trained on vast texts, assigns high probabilities to meaningful sentences, making them easier to locate. For example, “Artificial intelligence will reshape the future” is a bestseller, while “Cat pillow jumps blue” is obscure. Compression is about encoding these locations efficiently. How might GPT’s understanding of language make this possible?

Arithmetic Coding: The Magic Wand

GPT teams up with arithmetic coding to turn sentences into numbers. Here’s how it compresses “Artificial intelligence will reshape…” (tokenized as “Artificial,” “intelligence,” “will,” …):

  1. Start with [0.0, 1.0]: The entire number line as space that represents all possible sequences.
  2. Encode “Artificial”: GPT predicts a 5% chance (P=0.05) for this word to be the first token in a sentence, shrinking the interval to [0.0, 0.05].
  3. Encode “intelligence”: Given “Artificial,” GPT predicts an 80% chance (P=0.8), narrowing to [0.0, 0.04].
  4. Continue: Each token shrinks the interval further, ending with a tiny range, say [0.02113, 0.02114].
  5. Output: Convert a number like 0.02113 to binary (e.g., 0.00010101), which is the compressed result of the processed sentence.

Decompression reverses this, using the same GPT model to retrace the intervals and reconstruct the exact text. Why does this ensure no data is lost?

Information Theory: Why Predictability Saves Space

Information theory reveals why this works. A word’s information content is -log₂(P(x)). High-probability words carry little information, rare words carry more. Predictable sentences, rich in semantic patterns, form larger intervals in the line, requiring fewer bits. Why might random text, like white noise, resist compression?

Why It Matters

This approach could revolutionize data storage and transmission, from archiving logs to sending messages across galaxies. But what challenges might arise in real-world applications? How could GPT’s predictive power evolve with better models?

Original post: https://liweinlp.com/13277

 

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

1. 为什么中心节点看起来最“省比特”

在语义压缩框架里,发送端和接收端都共享一个超大的知识库(也就是大语言模型GPT本身)。只要两边都装好了这台“超级预言机”,你就只需要传那些模型无法直接预测的信息——往往是微小的差异。

    • 模型分发成本:把模型先安置到两端,是一次性“沉没成本”。

    • 消息传输成本:之后每条消息,只要剩下差分信息,就能拿到极致压缩比。
      (想象一下:家里装了电表,后来用电就只需按表读数付费,不用每次都搬来发电机。)

所以,如果你要传送海量短消息,中心节点(也就是先统一部署好那个大模型)无疑是最省每条消息比特数的做法。

2. “模型足够聪明,万物皆可压缩?”

不是的。即便有了一个近似 Solomonoff 预测器(不可计算的最优压缩器),它也只能针对有规律的数据把消息压得很小;面对真正的随机噪声或 Kolmogorov 意义上的不可压缩序列(比如纯白噪声),你依然得用与原始数据相同的位数来描述它。

    • 有损 vs. 无损:大模型做的是“无损语义压缩”的近似——理论上目标是无损,但实践里模型参数、截断长度、tokenizer 带来的误差都让它“看起来”有点像有损。或者说,语义层面上无损,但比特层面依然因截断、tokenizer 等带来轻微有损。

    • 序列号/元数据开销:举例来说,为了保证顺序和可解压,你往往需要加上序列号、checksum 等元信息。

3. Kolmogorov 复杂性的核心定义

    1. 最短描述长度
      对任意字符串 x,其 Kolmogorov 复杂度 K_U(x) 定义为:在一台通用图灵机 U 上,能输出 x 的最短程序(二进制串)长度。

      K_U(x) = min{|p| : U(p)=x}

    2. 可加常数不变性
      虽然不同的通用图灵机 U 和 U′ 会有不同的基准,但对于任意 x,都有

      |K_U(x) - K_{U'}(x)| ≤ C_{U,U'}

      其中 C_{U,U′} 与 x 无关。

    3. 朴素复杂度 vs 前缀复杂度

      朴素复杂度 C(x):

      C(x) = min{|p| : U(p)=x}

      C(x) 只关心“最短的整体长度”,不在意程序间有没有分界。把描述字符串 x 的最短程序长度,直接拿来算。就像你打电话传电话号码,但不告诉对方号码有几位,只发出一串数字:1357902468...对方不知道这串是 10 位还是 11 位,哪里断开也不清楚。这就是朴素复杂度:只在意“整个程序多短”,不管程序之间有没有清晰的分界。但没界限容易搞混:如果程序 A 是 101,程序 B 刚好是 1010,对方收到 1010 时,不知道是 A+0,还是直接 B。

      前缀复杂度 K(x):

      K(x) = min{ |p| : U(p)=x, p is prefix-free }

      在 C(x) 的基础上,多加一个要求:所有可行的程序都不能互为前缀(prefix-free),就像保证任意一段代码结尾清晰、不会和另一段代码混在一起。这让理论性质更好,也能直接对应信息熵。这次你在每个号码后面都加个“#”标记结束,比如13579# 02468# … 听者一听到“#”,就知道这一串号码完整发完了,不会跟下一个混淆。这就是前缀复杂度:所有可行程序都设计成“自己带结束标志”,永远不会是另一个程序的开头。概率总和也容易算清楚:带结束符的代码就像每个密码都有自己独立的门,能保证所有概率加起来是 1,数学上好推导,也能直接对应信息熵。

4. Solomonoff–Kolmogorov–Chaitin 框架

算法概率(Algorithmic Probability)

Solomonoff 提出“通用先验”

P(x) ≈ Σ_{p:U(p)=x}2^{-|p|} ≈ 2^{-K(x)}

意味着:字符串 x 的出现概率和它的最短程序长度成反比。

归纳推理

通过给所有可能程序打上权重(2^{-|p|}),Solomonoff 归纳理论就是在做全空间搜索 + 加权平均,推断下一个 token 的概率,完美符合 GPT “next token prediction” 的理论——只是不可计算。

不可计算性

理论上的最优 K(x)永远算不出来(停机问题),要么只能上界估计(通过各种压缩算法),要么用算术编码等手段做近似。


5. 李明教授的《Introduction to Kolmogorov Complexity》精髓

结构函数(Structure Function)

李明书中详细讨论如何分离“随机性”与“结构”:给定 x,寻找一个模型类 𝓜 (记作 ℳ)和其中的模型 M∈𝓜,使得

K(M) + log|{y : M(y)=x}|

尽可能小——这就是对数据 x 做两部编码(two-part code),也是最优压缩与模型选择的数学基础。第一部分 K(M) 是模型本身的描述长度。第二部分 log |{ y : M(y)=x }| 是给定模型 M 后,还需要的那部分随机性长度。

算法充要统计量 S(x)(Algorithmic Sufficient Statistic)

这是李明重点:一个“充要”统计量 S(x),能在最小化两部编码的同时,既把数据的“规律”压进模型,又把剩余噪声放进随机部分,做到最简洁的描述。第一部分 K(S(x)):用最短的程序描述模型 S(x) 本身;第二部分 log |{ y : S(x)(y) = x }|:在给定模型之后,为了完全还原 x,还需多少比特来区分所有被该模型映射到 x 的可能 y。

K(S(x)) + log|{y : S(x)(y)=x}|

把它们加起来,就是“用这个模型+随机补充”来描述 x 的总代价。找到能让这个和最小的 S(x),就相当于找到了对 x 最好的“充要”统计量。

随机性测度(Randomness Deficiency)

定量衡量某个样本 x 相对于模型 M 是多“典型”或多“离谱”,用于指导是否要换模型或增加模型复杂度。


6. 尼克的视角:GPT 与柯氏复杂性

学习就是“求逆”问题,训练即最短程序逼近

Nick 强调:训练一个模型,就是在可计算的程序空间中,寻找一个能够“生成”训练集的短程序——也就是在实战中做min_p K(p)的近似。

大模型的“内容压缩” vs “形式压缩”

个体压缩(Instance):像无损 ZIP,一首歌可以 100% 还原,对应形式压缩

整体压缩(Dataset):面对海量文本,关注的是文本背后的意义或“语义信息”,此时“无损”只针对意义层面,形式上允许丢弃多余噪声。这正是 LLM 做到的:内容/语义的“无损”——虽然编码字符上看似“有损”

近似最优 vs 真最优

Nick 提到:任何可实现的压缩算法(gzip、xz、算术编码加GPT…)都只能逼近K(x),而 GPT 则是在“预测分布”上进行近似,用一个固定模型去对抗所有序列,其优势是语义联想上下文填空,但仍旧受限于模型容量与截断长度。


小结

    • 李明教授给我们一整套两部编码、结构函数和充要统计量的严谨框架;

    • 尼克的大模型论:训练≈求逆,预测≈Solomonoff 归纳,压缩≈最优编码的近似实践。

    • 真正的“最优无损”只有在理论上存在,现实里每一次“预测+编码”都在做逼近,同时也承载了网络协议的元信息开销。

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

预测下一词的自回归大模型GPT早已风靡全球。压缩即智能的说法已经广为人知,但关于其无损压缩的能力貌似一直有争议。GPT压缩到底是无损还是有损呢?

这是一个非常值得打破沙锅问到底的问题,它正好切入了LLM压缩最核心、也最巧妙的部分。我们来把这个过程彻底拆解一下,让它变得清晰易懂。

一个直观的比喻:在无限的图书馆里找书

想象一个图书馆,里面包含了所有可能的句子。

    • 像 “人工智能将重塑未来产业格局” 这种符合语法、逻辑且有意义的句子,位于图书馆里非常显眼、容易找到的区域 (比如“热门新书区”)。
    • 而像 “产业未来将格局人工智能重塑” 这种语法不通的句子,位于偏僻的角落
    • 像 “猫枕头跳跃蓝色因为星期三” 这种完全随机的胡言乱语,则位于几乎无法访问的尘封地下室

现在,我需要告诉您具体是哪句话。

    • 对于那句热门句子,我不需要把整句话念给您听。我只需要给您一个极短的指令:“热门区,第3排,第5本”。这个指令就是压缩后信息 (少量比特)
    • 对于那句胡言乱语,我没有捷径可走,只能把整句话一字不差地读给您听。这个指令非常长,几乎和原文一样。

GPT的作用,就是建立了这个图书馆的终极索引系统(世界模型)。它知道每一句话“热门”的程度(概率)。算术编码就是那个高效的区间定位系统

核心机制:算术编码如何划分“区间”

现在我们进入技术细节。算术编码的精髓是把一整段信息表示成 0.01.0 之间的一个小数。

压缩:一步步“缩小”区间

我们以您的例子 “人工智能将重塑未来产业格局” 来走一遍流程。为了简化,我们假设分词是:“人工”, “智能”, “将”, “重塑”, “未来”, “产业”, “格局”。

  1. 初始状态:我们的区间是 [0.0, 1.0]
  2. 编码第一个词“人工”
    • GPT模型启动,预测第一个词的概率。假设在所有可能开头的词中,"人工" 的概率是 5% : P("人工")=0.05。
    • 算术编码器就在 [0.0, 1.0] 的区间里,把开头 5% 的位置,也就是 [0.0, 0.05],分配给"人工"。
    • 我们“放大”进入这个新区间 [0.0, 0.05]
  3. 编码第二个词“智能”
    • 现在,GPT的上下文是“人工”。它预测下一个词。因为“人工智能”是高频词,所以 P("智能" | "人工") 的概率会非常高,比如 80%。
    • 算术编码器就在当前区间 [0.0, 0.05] 里,把前 80% 的位置分配给"智能"。
    • 新的区间是 [0.0, (0.05 * 0.8)],即 [0.0, 0.04]
    • 我们再次“放大”进入这个更小的区间 [0.0, 0.04]
  4. 编码第三个词“将”
    • 上下文是“人工智能”。GPT预测 P("将" | "人工智能") 的概率也很高,比如 60%。
    • 新区间是 [0.0, (0.04 * 0.6)],即 [0.0, 0.024]
  5. ...持续这个过程...

最终结果:当整句话编码完毕,我们得到了一个非常精确定位的、极小的最终区间,比如 [0.02113, 0.02114]

关键来了:我们只需要从这个最终区间里随便挑选一个数,比如 0.02113,把它转换成二进制(比如 0.00010101...),这个二进制串就是我们的压缩结果。因为它是一个高概率句子,每一步都取了较大的百分比,所以最终区间的范围相对较大(虽然数值很小),可以用较少的二进制位数来精确表示。

解压:按图索骥,还原路径

解压过程就是上述步骤的逆向操作,像拿着藏宝图找宝藏一样。让我们用数学语言走一遍解压流程。

    • 压缩数字V = 0.02113
    • GPT模型:随时待命

第一轮:解码第一个词

  1. 获取概率:GPT预测,(无上下文时)'人工'的概率是0.05,'智能'是0.03...
  2. 划分区间[0.0, 1.0] 被划分为:
    • [0.0, 0.05] -> '人工'
    • [0.05, 0.08] -> '智能'
    • ...
  3. 定位V = 0.02113 落在 [0.0, 0.05] 区间内。
  4. 解码:输出第一个词 “人工”
  5. 更新区间:我们接下来的工作区间是 L=0.0, H=0.05

第二轮:解码第二个词 

  1. 区间归一化 (Rescaling) 
    • 我们需要更新我们的指针 V,计算它在 [0.0, 0.05] 这个新区间里的相对位置。
    • 公式:V_new = (V_old - L) / (H - L)
    • 计算:V_new = (0.02113 - 0.0) / (0.05 - 0.0) = 0.4226
    • 现在,我们用来做决策的指针变成了 0.4226
  2. 获取概率:解压器给GPT输入上下文“人工”,GPT预测下一个词的概率:
    • P("智能" | "人工") = 0.8
    • P("智慧" | "人工") = 0.1
    • ...
  3. 在新坐标系下划分区间:我们根据新概率划分标准区间 [0.0, 1.0]
    • [0.0, 0.8] -> '智能'
    • [0.8, 0.9] -> '智慧'
    • ...
  4. 定位:我们用归一化后的新指针 V_new = 0.4226 来比较。它落在 [0.0, 0.8] 这个区间内。
  5. 解码:输出第二个词 “智能”
  6. 更新区间[L, H]:为下一轮的计算定义新的边界。方:将相对的 [l,h] 区间缩小/映射回绝对坐标系中。'智能'对应的区间是 [0.0, 0.8]。映射回绝对坐标系的工作区间是 [0.0, 0.04]。这个 [0.0, 0.04] 精确地定义了“人工智能”这个词序列在整个 [0.0, 1.0] 空间中的最终位置。
    • L_new = L_prev + (l_curr * Width_Previous)
    • H_new = L_prev + (h_curr * Width_Previous)

这个过程不断重复,每一步都包含 定位 -> 解码 -> 归一化 三个动作,直到结束。具体说,更新指针 V 与 更新区间 [L, H] 这两个过程交替进行,一个负责“决策”,一个负责“更新状态”,共同驱动解码器精确地还原出原始文本。因为每一步的选择都是唯一的,所以解压结果能100%保证和原文一致。

总结:为什么高概率 = 少比特

这背后的数学原理是信息论。一个事件所包含的信息量是其概率的负对数:

I(x) = -log₂(P(x))

    • 高概率事件 (P → 1):比如GPT预测下一个词是“格局”的概率是95% (P=0.95)。它所包含的信息量就非常小(-log₂(0.95) ≈ 0.07比特)。我们只需要极少的信息就能确认这个预测。
    • 低概率事件 (P → 0):如果下一个词是个罕见词,概率只有0.01% (P=0.0001),它所包含的信息量就极大(-log₂(0.0001) ≈ 13.3比特)。我们需要很多信息才能描述这个“意外”。

算术编码巧妙地将这个理论变成了现实。对于一个高概率序列,最终的区间总大小(即所有概率的乘积)会比较“大”,从而可以用一个位数较少的二进制小数来表示。这就是“语义级消除冗余”的本质:所有符合人类知识、语法和逻辑的“意料之中”的内容,都被GPT这个“世界模型”识别出来,并用最少的信息量进行了编码。

 

 

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

GPT训练中的压缩,与拿GPT当压缩器工具不是一回事,二者有很大的关联,但不是同一个层面的问题。GPT是无损还是有损压缩的混淆与争论,就是搞错了这个层面和视角。

  1. 理论基础 (Solomonoff-Kolmogorov-Chaitin / Kolmogorov Complexity):

    • 任何数据的“最本质”信息量是其柯氏复杂性 (KC) —— 计算理论中定义为能生成该数据的最短程序的长度。

    • 理想的最优无损压缩器就是能找出这个最短程序的“预言机”。

    • GPT 的 Next Token Prediction 本质上是 Solomonoff 归纳法的近似实现:它利用在海量数据上学到的统计规律/模式(共享知识库,或曰“世界模型”),预测序列的下一个元素。预测越准,对序列的描述(压缩)就越高效。Ilya 在 Berkeley 的演讲确认的就是这点。

  2. 工程实现 (ts_zip / L3TC / GPT 算术编码):

    • ts_zip (Bellard): 早期实验,证明了利用Transformer模型预测下一个Token + 算术编码,可以超越传统压缩器(如xz),代价是慢。核心是利用模型作为“预测器”。

    • 李明 & 尼克 (2022-2023) 的 GPT 实验: 直接用GPT类模型做概率预测 + 算术编码进行无损压缩,效果显著优于gzip(极端情况好10倍),验证了理论可行性。应用场景:传输成本 >> 计算成本时(如星际通信、昂贵带宽)。

  3. 核心优势与限制:

优势: 对富含语义、符合“世界模型”的序列数据(如自然语言、结构化日志)压缩率极高。利用的是数据背后的“意义”和“规律性”

局限:

      • 计算成本高: 压缩/解压慢(如ts_zip 1k/s)。

      • 对随机噪声无效: 真正的随机数据(Kolmogorov噪音)KC等于其长度,无法被任何模型压缩。

      • 依赖模型质量: “共享知识库”(GPT模型)的质量直接影响压缩率。模型越好,对相关数据的“理解”越深,压缩越高效。

解答核心困惑:“次优无损压缩 vs 有损压缩”

这是最容易混淆的点!

李明 & 尼克的坚持:GPT压缩就是无损压缩

    • 定义层面: 只要压缩后能精确地、比特级还原原始数据,无论压缩率如何,无论是否达到理论最优(KC),无论用了什么方法(这里是GPT预测+算术编码),它就是无损压缩

    • “次优” ≠ “有损”: 一个压缩算法压缩率不够好(比如只用gzip压缩文本,远没达到KC),它依然是无损的——解压后还是原文。它的“次优”体现在压缩率不够高,而不是丢失了信息

    • GPT + 算术编码 的机制: GPT 提供下一个Token的概率分布(logits)。算术编码器利用这个分布,将输入Token序列编码成一个比特串(离散数)。解压时,同一个GPT按相同概率分布逐步解码出原始Token序列。输入输出比特完全一致。这是标准的无损压缩流程。

李飞飞强调的“有损”可能是指: 模型在学习过程中,必然会对训练数据进行抽象、泛化、丢弃个体噪声,形成一个内部的、简化的“世界模型”。这个学习过程本身可以看作是对原始训练数据的有损压缩(它丢弃了无法纳入模型的细节)。但请注意:这是指模型内部表示的形成过程,而不是指 “GPT+算术编码“作为压缩器对特定文件进行压缩的过程。后者是明确的无损过程。

结论:

  1. 严格定义上: 使用LLM进行概率预测 + 算术编码是一种无损压缩技术。它保证原始数据的精确还原,只是压缩率依赖于模型的质量和数据的性质。

  2. 理论理想 vs 现实: 任何实际无损压缩器(包括GPT)都达不到理论最优压缩率 (KC),都是“次优”的。“次优”不等于“有损”。“次优”指压缩效率不够好,“有损”指信息永久丢失

  3. 理解“有损”说法的来源:

    • 学习过程的本质: 模型从海量数据中学习形成“世界模型”的过程,本身可视为对训练数据的有损压缩(提取精华,丢弃无关细节和噪声)。

    • 压缩“意义”的模糊性: 当我们谈论压缩数据集整体的“意义”而非具体比特时,“无损”的定义变得模糊。LLM压缩的优势恰恰在于它利用了“意义”来实现对“比特”的高效无损压缩。

    • 与理论最优值KC的差距: 因为无法达到KC,总存在理论上的“浪费”,这种感觉类似有损,但本质是计算不可行性导致的效率不足,而非信息损失。

简单比喻:

    • 无损压缩 (gzip, GPT+算术编码): 把一本厚书用一种非常高效的密语(可能是基于百科全书知识的缩写)写成一个密码序列。只要有密码本和规则,就能一字不差还原原书。 密码本短(压缩率高)说明密语设计得好(模型好)。

    • 次优无损压缩: 密语设计得不够好,密码序列比别人的长(压缩率低),但依然能完全还原原书

    • 有损压缩 (jpg, mp3): 把书提炼成一篇摘要、画面或音乐降低了精度。保留了核心思想(主要特征),但永远无法还原原作的每一个token和所有细节(包括瑕疵)

    • GPT学习形成“世界模型”: 读了图书馆所有书后,模型形成了对“世界”的理解。这个理解是训练数据海量信息的高度抽象和简化(有损)。但当他用这个模型来帮你压缩某一本具体的书时(通过预测+编码),他可以做到无损

所以,回到你的话: “目标是无损,结果是有损” —— 对于利用现存GPT作为压缩器,这个说法不准确。对特定数据的GPT压缩总是无损的,但压缩率是次优的(未达KC)。对于GPT学习构建其内部模型的过程,这个说法有一定道理(内部模型是对训练数据的有损表示)。关键在于要区分 “使用工具(GPT压缩器)的过程” 和 “工具本身(GPT模型内部)的构建过程”,否则就不在同一个概念频道,鸡同鸭讲。

 

 

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

可以用GPT无损压缩的算术编码作为例示

一、最终区间的本质:概率宇宙中的精确坐标

想象一个包含所有可能文本序列的宇宙(概率空间):

[0,1) 区间 = 所有可能文本序列的总集合
    • 每个特定序列(如"人工智能将改变世界")对应宇宙中的一个专属子区间

    • 子区间长度 = 该序列出现的概率(由语言模型GPT计算得出)

    • 子区间位置 = 该序列在概率空间中的唯一坐标

二、区间长度=概率的数学证明

假设序列由3个词组成:

序列:W1 → W2 → W3
概率:P(W1) = 0.4, P(W2|W1) = 0.6, P(W3|W1,W2) = 0.8

区间变化过程:

初始: [0, 1)        长度=1.0
选W1: [0, 0.4)      长度=0.4  (1.0×0.4)
选W2: [0.16, 0.4)   长度=0.24 (0.4×0.6)
选W3: [0.16, 0.352) 长度=0.192(0.24×0.8) ← 最终区间长度=0.192

最终长度 = P(W1)×P(W2|W1)×P(W3|W1,W2) = 序列概率

三、宇宙坐标系统的运作原理

示例:压缩序列 ["猫", "吃", "鱼"]

词汇表 概率分布
初始上下文 P(猫)=0.5, P(狗)=0.3, P(鱼)=0.2

编码/压缩过程

    1. 编码"猫":

      [0, 1) → 划分:
        猫:[0, 0.5)
        狗:[0.5, 0.8)
        鱼:[0.8, 1)
      选择 [0, 0.5)
    2. 编码"吃" (上下文="猫"):

      当前区间 [0, 0.5)
      语言模型新分布:P(吃|猫)=0.7, P(睡|猫)=0.3
      划分:
        吃:[0, 0.5×0.7)= [0, 0.35)
        睡:[0.35, 0.5)
      选择 [0, 0.35)
    3. 编码"鱼" (上下文="猫吃"):

      当前区间 [0, 0.35)
      语言模型新分布:P(鱼|猫吃)=0.4, P(肉|猫吃)=0.6
      划分:
        鱼:[0, 0.35×0.4)= [0, 0.14)
        肉:[0.14, 0.35)
      选择 [0, 0.14)

最终结果

序列 ["猫","吃","鱼"] → 独占宇宙坐标 [0, 0.14)
区间长度 = 0.14 = 0.5×0.7×0.4

四、为什么这是唯一坐标?数学保证

假设存在两个不同序列A和B,它们对应的最终区间重叠:

A区间: [L_A, R_A)
B区间: [L_B, R_B)
且 [L_A, R_A) ∩ [L_B, R_B) ≠ ∅

根据算术编码原理:每个序列的区间由其唯一词路径决定

若A和B在第k个词首次不同:

    • 第k步时,A和B会选择不相交的子区间

    • 后续划分永远在分离的区间进行
      → 矛盾! 故不同序列的区间互不相交

五、解码/解压:从坐标回溯序列

给定最终区间 [0, 0.14) 和相同语言模型GPT:

当前区间 [0,1)
数值 C=0.09(区间内任意点)

步骤1:划分初始区间
   [0,0.5) → 猫
   [0.5,0.8) → 狗
   [0.8,1) → 鱼
   C=0.09 ∈ [0,0.5) → 输出"猫"

步骤2:缩放区间
   新区间 = [0,0.5)
   缩放C = (0.09-0)/(0.5-0) = 0.18
   划分:
       吃:[0,0.35) → [0,0.35)相对值→ [0,0.7)
       睡:[0.35,0.5) → [0.7,1)
   C=0.18 ∈ [0,0.7) → 输出"吃"

步骤3:再次缩放
   新区间 = [0,0.35)
   缩放C = (0.18-0)/(0.7-0)×0.35 = 0.09
   划分:
       鱼:[0,0.14) → [0,0.4)
       肉:[0.14,0.35) → [0.4,1)
   C=0.09 ∈ [0,0.4) → 输出"鱼"

完美还原序列!

六、宇宙坐标的直观展示

每个叶节点是最终区间;节点深度越深,区间越小;路径唯一性:从根到叶的每条路径对应唯一序列。

七、工程意义:为何这是革命性的

  1. 突破分组限制

    • 传统压缩(如Huffman)需将符号分组处理

    • 算术编码实现连续流式压缩,单个比特代表部分信息

  2. 逼近熵极限

    理论最小体积 = -log₂(P(序列)) 比特
    算术编码体积 ≈ ceil(-log₂(P(序列)))

    例如P=0.14 → -log₂(0.14)≈2.84 → 3比特足够

  3. 大模型赋能

    • GPT类模型提供精准的 P(word|context)

    • 对自然语言序列,P(序列)值大幅提高 → 区间长度更大 → 所需比特更少

最终区间是概率宇宙中的神圣坐标,它用数学的纯粹性证明:信息即概率,概率即几何,而完美的无损压缩,不过是在[0,1)区间为每条路径划定它应得的疆域。

 

 

GPT无损压缩小问答(3):算术编码

GPT+算术编码是对数据的无损压缩。什么是算术编码?它是怎么工作的?

算术编码:GPT压缩的“比特转换器”

算术编码 (Arithmetic Coding) 是经典的无损压缩算法。GPT作为“世界模型”为这个算法提供了前所未有的、超精准的语言数据的“概率地图”。

核心作用:把概率分布变成最短的比特流

  1. GPT内部的输出是什么?

    • 当输入一个序列 token1, token2, ... token_{i-1} 时,LLM 输出的是 下一个 token token_i 在整个词汇表上的概率分布 P(token_i | context),称为 logits。

    • 例如: 输入 “人工智能是”,LLM 可能输出 P(“未来”)=0.6, P(“趋势”)=0.3, P(“什么”)=0.05, ... P(“香蕉”)=0.0000001

  2. 算术编码器如何工作?

    • 想象一条0到1的数轴: 初始区间是 [0, 1)

    • 按概率切分区间: 根据 P(token_i) 将当前区间划分成若干子区间,每个子区间对应一个可能的 token。

      • 接上例:“未来” -> [0, 0.6), “趋势” -> [0.6, 0.9), “什么” -> [0.9, 0.95), ... “香蕉” -> [0.9999999, 1)

    • 选中真实token的区间: 如果实际的下一个 token 是 “未来”,则新的当前区间变为 [0, 0.6)

    • 迭代: 用这个新区间 [0, 0.6) 作为起点,输入下一个 token token_{i+1} 到GPT获得新的概率分布,再次切分这个新区间。如此反复直到序列结束。

    • 输出一个“代表点”: 最终得到一个非常小的区间 [low, high)选择一个该区间内的二进制小数(比如 (low + high)/2),只保留其小数点后的有效比特位。这个比特串就是压缩结果。区间越小,所需的比特数越少 (-log2(区间长度))。

这里,算术编码中区间和比特输出的转换关系容易让人困惑,这确实是理解无损压缩最烧脑的部分。需要理解“代表点”的生成逻辑。看上去有一个矛盾:区间是连续的,怎么能离散化,用有限比特精确代表?这需要从信息论和计算机表示两个层面拆解。需要彻底打通“概率→区间→比特”的转换链条,想明白为何最终输出的是有限比特而非无限小数。“区间长度对应概率”不难理解,当前瓶颈在于如何把连续区间离散化成比特流。需要重点讲清楚两点:一是-log2(概率)为何等于比特长度(香农极限),二是如何用二进制分数逼近实数而不损失信息。

最终区间:概率的结晶

假设经过对整段文本的逐词编码,算术编码器得到最终区间:

[low, high) = [0.3654321, 0.3654343)
  • 区间长度 = high - low = 0.0000022

  • 这长度就是整个文本出现的概率值!
    若每个词概率为 P1, P2, ..., Pn,则长度 = P1 × P2 × ... × Pn

我们可以这样比喻:将整个[0,1)区间看作一个序列数据的“宇宙”,每个可能的序列都对应这个宇宙中的一个子区间。序列出现的概率越大,对应的子区间就越长:长度等于概率。编码过程就是逐步缩小范围,最后定位到代表输入序列的那个子区间。一个非常简单的演示例子:

假设符号集:A(概率0.6),B(概率0.4)
要编码的序列:"AB"

步骤:

1. 初始区间[0,1)

2. 编码第一个符号'A':将[0,1)划分为 [0,0.6) 和 [0.6,1) 两个子区间。选择'A'对应的区间[0,0.6)。

3. 编码第二个符号'B':将当前区间[0,0.6)按相同比例划分:A占60%:[0,0.36),B占40%:[0.36,0.6)。选择'B'对应的区间[0.36,0.6)。最终区间为[0.36,0.6),区间长度=0.24,等于序列"AB"的概率:P(A)*P(B)=0.6*0.4=0.24。

最终区间内的任何数都可以作为代表点。通常取最终区间[0.36,0.6)的中点(0.48)可能更靠近中间,但实际中我们取最短的二进制小数,比特串011(代表数值0.375)。

解码过程:

解码器已知概率模型,初始区间[0,1)。它接收到比特串011。

第一步:将[0,1)划分为[0,0.6)和[0.6,1),0.375落在[0,0.6)内,所以第一个符号为'A'。

第二步:将当前区间[0,0.6)按比例划分:A:[0,0.36),B:[0.36,0.6)。数值0.375在[0.36,0.6)内,所以第二个符号是'B'。

因此,解码正确。

 

最终区间的概念可以总结为:

- 它是整个序列在[0,1)区间内的“身份证”,其长度等于序列的概率。
- 区间的位置和长度由序列中每个符号的概率逐步决定。
- 编码输出的是这个区间内的一个代表点的二进制表示(取足够位数以唯一确定这个区间)。

通过这种方式,算术编码实现了近乎最优的无损压缩(每个符号的编码长度接近其信息熵)。

直观比喻:GPS坐标压缩

原始文本 → 一栋精确的别墅 (目标区间 = 别墅占地)

比特串 0101110111010111001 → 别墅的 邮政编码 + 门牌号 (19位编码)

邮政编码区域 > 别墅面积 → 邮编一定能覆盖别墅

门牌号指向别墅内的一个点 (代表点)

解压 → 快递员用邮编找到区域,用门牌号送货上门
(只要地址在别墅内,就能正确无误送达)

无损的魔法如何完成?

步骤 数学动作 信息意义
区间生成 [low,high) = ∏ P(word) 文本的概率指纹
比特计算 k = ceil(-log₂(high-low)) 指纹的最短身份证位数
代表点 选区间内一个数,转k位二进制 生成身份证号 (压缩比特流)
解压 用身份证号反向追踪概率划分 凭身份证找回完整指纹 (无损还原)

最终输出的是概率空间的唯一坐标值,而非数据本身——这正是算术编码以逼近香农极限的方式实现无损压缩的魔力!

为什么这是无损的?

解压时,算术编码器反向操作

      • 从同一个初始区间 [0,1) 和同一个初始模型状态开始。

      • 读入压缩后的比特串,将其视为一个二进制小数 C

      • 用 GPT 预测第一个 token 的概率分布,切分区间。

      • 看 C 落在哪个 token 的子区间里,那个 token 就是解压出的第一个 token。

      • 用选中的子区间作为新范围,继续用 LLM 预测下一个 token 的概率分布,切分,看 C 落在哪里... 直到序列结束。

关键: 压缩和解压使用完全相同的LLM完全相同的概率预测流程。只要 C 在最终压缩区间内,就能一步步唯一确定当初编码时的每个 token 选择。输入序列和输出序列比特级一致

 

 

 

信息论科普:香农极限(Shannon Limit)

香农极限(Shannon Limit)是信息论中最深刻、最优雅的概念之一,由“信息论之父”克劳德·香农(Claude Shannon)在1948年奠基性论文《通信的数学理论》中提出。它不仅定义了通信的终极边界,更揭示了信息、噪声与可靠性的本质关系。以下从四个维度解析其内涵:


 一、核心思想:信息传输的“光速壁垒”

香农极限回答了通信领域的终极问题:在存在噪声的信道上,信息传输的速率上限是多少? 它证明:

任何通信系统都无法以超过“信道容量”的速率无错误地传输信息
一旦逼近该极限,误码率将陡增;突破则必然出错。

公式凝练宇宙法则
对于带宽为 B (Hz)、信噪比为 SNR 的高斯信道,香农极限公式为:

C = B × log₂(1 + SNR)  (比特/秒)
  • C:信道容量(理论最大无错传输速率)

  • SNR:信号功率/噪声功率(信噪比,衡量环境干扰)

  • log₂(1+SNR):每赫兹带宽能承载的比特数

直观理解

  • 带宽 B 是“水管粗细” ——越粗每秒流过水越多;

  • 信噪比 SNR 是“水质纯净度” ——噪声越小,信息“纯度”越高;

  • 容量 C 是“最大安全流量” ——超过则水管爆裂(误码爆发)。


二、为何存在极限?噪声与不确定性的囚笼

香农的革命性在于:信息即消除不确定性

    • 信息熵:度量信息的不确定性(单位:比特)。例如抛硬币有1比特不确定性。

    • 噪声干扰:在传输中引入额外不确定性(如将“0”误判为“1”)。

香农的突破
通过巧妙的编码理论,将冗余比特像“纠错盔甲”一样包裹真实信息,抵御噪声攻击。但盔甲越厚,有效信息率越低——香农极限正是“盔甲厚度”与“信息密度”的最优平衡点。


三、工程意义:人类技术的“终极标尺”

香农极限像物理中的光速,是通信工程师的圣杯:

通信技术 效率(vs 香农极限) 关键突破
2G (GSM) ≈30% 首次数字化语音
3G (CDMA) ≈50% 码分多址抗干扰
4G (LTE Turbo码) ≈90% Turbo码逼近极限
5G (LDPC/Polar码) >95% 极化码(Polar Code)理论上可达100%

四、超越通信:信息宇宙的底层逻辑

香农极限的哲学辐射远超工程:

    1. 生命与热力学
      薛定谔提出“生命以负熵为食”,生物通过信息编码(DNA)对抗环境噪声(熵增),本质是对抗香农极限的生命策略

    2. AI与压缩极限
      大模型(如GPT)本质是数据的“语义压缩”——其压缩率受柯氏复杂性(Kolmogorov Complexity)限制,可视为香农极限在认知维度的延伸。

    3. 宇宙的本质猜想
      物理学家约翰·惠勒提出“万物源自比特”(It from Bit),认为时空本身可能是信息网络,而物理定律是宇宙级的“纠错编码”。


结语:在噪声中雕刻秩序

香农极限的魅力在于:它为不完美世界中的可靠通信赋予了数学的确定性。正如香农所言:

“通信的根本问题,是在一点精确或近似地复现另一点选择的信息。”

人类至今仍在无限逼近这一极限——从5G的极化码到量子通信的曙光,每一次突破都是对香农智慧的致敬。而理解这一极限,便是理解信息时代最深邃的底层逻辑✨。

延伸阅读

  • 《信息简史》(詹姆斯·格雷克):全景式展现信息观念演变;

  • 《信息论基础》(Cover & Thomas):经典教材深入数学本质。

 

 

GPT无损压缩小问答(2):为什么说GPT是无损压缩?

GPT生成还原的不是训练数据的原文,为什么说“GPT压缩是无损压缩”?

常听到这句话,但其实这句话有歧义,不准确。GPT赋能无损压缩到对象不是训练数据,对于训练数据它的压缩毫无疑问是有损的,否则就不会有幻觉现象的存在。说GPT压缩是无损压缩的,指的是利用GPT这个庞大的知识库,用无损算法(算术编码算法)来压缩(编码)和还原(解码)输入数据。

GPT生成(inference)与用GPT对于特定数据编码解码是两回事。前者是概率采样来生成,具有不确定性。后者是利用GPT作为工具(共享知识库/世界模型)来压缩和解码特定数据,它是无损的,是确定性输出。

具体说,GPT Inference 目标是生成新内容。根据概率分布 P(token|context)采样 一个 token 输出,然后将其加入上下文,重复这个“自回归”生成过程。输出的是新 token 序列。

而GPT+算术编码 (压缩)不同, 目标是编码已有序列。利用 P(token|context) 计算真实 token 的概率值,驱动算术编码器进行区间划分和比特流生成,输出的是比特串(被压缩序列的另一种表示)。解压则使用与算术编码完全相同的GPT和完全相同的概率预测流程。只要 C 在最终压缩区间内,就能一步步唯一确定当初编码时的每个 token 选择。输入序列和输出序列比特级一致

用GPT压缩特定数据,无疑属于无损压缩。无损指的是新的输入,并不是说的训练数据。

1. 定义符合:输入 = 输出(比特级)。
2. 机制保证:算术编码是信息论证明的无损编码方法。GPT 仅提供概率分布供其使用。
3. 矛盾信息可存:低概率事件被分配更多比特编码,但信息完整保留。
4. KC差距≠信息损失:冗余比特承载着信息本身,是低效的代价而非丢弃。解压靠它们精准恢复。
5. 有损发生在别处:模型内部知识表示的形成过程(训练)的确是对训练数据的有损压缩/摘要。

总结:

GPT + 算术编码 是一个工具。这个工具利用一个(可能包含不完美/有损知识的)语言预测模型,对特定输入数据进行无损编码。工具本身的操作是无损的。

工具的效率(压缩率)高度依赖预测模型的质量。模型对数据的“理解”越深(预测概率越准),压缩率越高,越接近理论最优值KC。

模型的“理解”来源于其训练过程,该过程是对训练数据的有损抽象。这就是“有损”概念的根源所在,但它作用在模型构建阶段,而非使用该模型进行压缩的应用阶段。

GPT作为“共享知识库”的本质就是模型训练获得的有损的、泛化的世界模型。用它压缩单个数据点,无损;用它代表整个训练数据集,有损。

核心在于认清:无损性描述的是压缩/解压过程的输入输出关系;有损性描述的是模型内部知识表示对原始训练数据的近似程度。 两者作用在不同的对象和阶段。

 

 

GPT无损压缩小问答(1): 高压缩率导致系统脆弱

压缩率不够高不是更容易还原原文吗?从无损还原角度,我们其实不想模型压缩率“过高”。

这个问题非常犀利,直接点中了无损压缩理论中一个反直觉的关键点,质疑的是压缩效率与还原可靠性的关系——这恰恰是信息论最精妙的部分。

你可能正在脑补这样的场景:如果压缩率太高,就像把文件压得过于紧实,解压时反而容易出错。但无损压缩的数学基础保证了只要算法正确,100%还原与压缩率高低无关。

然而,这个问题的提出具备工程思维,是从实际系统角度质疑理论模型。“不想模型压缩率过高”,背后可能隐藏着对极端压缩场景下数据完整性的担忧——比如航天器用超高压缩率传输数据时,一个比特错误就可能导致整个文件崩溃。这种担忧很合理,但需要区分压缩算法本身和信道传输问题。

技术上需要强调两点:第一,算术编码作为熵编码,其压缩率逼近香农极限是数学特性,不会影响无损性;第二,高压缩率带来的系统脆弱性属于工程问题,可通过校验码解决。你可能混淆了算法层和系统层的可靠性。

特别要注意不要对“矛盾数据”有执念。数据集内部的矛盾不会导致信息损失,正如之前解释的,LLM压缩是通过增加比特开销来保留异常值,而非丢弃它们。这就像用高清扫描仪保存一幅有瑕疵的画作——瑕疵本身也被完整记录了。

应用层面,“压缩率不够高反而安全”的论述很有洞察。确实在工程实践中,适度冗余能提升系统鲁棒性。但理论上无损压缩的还原能力与压缩率无关这个铁律,需要用通信系统的分层模型来解释清楚。

好,这个问题触及了信息论中最精妙的反直觉点,我们一起来彻底解开这个悖论:

第一层:反直觉的真相

“压缩率不够高 ≠ 更易还原”
“高压缩率 ≠ 更难还原”

无损压缩中(包括GPT+算术编码),压缩率与还原能力完全无关。只要算法正确:
1比特压缩的文件几乎无压缩的文件,解压后都同等完美还原原始数据。这是无损压缩的定义决定的铁律

第二层:高压缩率如何实现?(无损的魔法)

    1. 核心原理:消除冗余
      高压缩率 = 找到更高效的方式描述数据 = 用更少的比特表示相同信息
      例:原始数据 "0000000000" (10字节) → 压缩为 "10个0" (4字节)。解压时完美还原10个0。

    2. GPT的威力:语义级消除冗余
      GPT发现 “人工智能将重塑未来产业格局” 这句话在它的“世界模型”中概率很高 → 用极小的区间(极少的比特)编码。
      关键:区间虽小,但精确对应这句话。解压时,靠比特流定位回这个区间,唯一还原这句话。

    3. 为什么高压缩率不伤害还原?

      压缩率 数据特性 编码动作 还原保障
      高度可预测 (如 “00000”) 分配极小区间 (比特少) 比特流精确定位到该区间 → 还原
      不可预测 (如白噪声) 分配接近整个区间 (比特多) 比特流覆盖大区间 → 还原

      第三层:担忧的本质:工程风险 vs 理论无损

      真正的顾虑是:当压缩率极高时,系统对错误的容忍度急剧下降! 这是完全正确的工程直觉:

      场景 低压缩率 (如未压缩文本) 高压缩率 (GPT极致压缩) 原因
      1比特传输错误 可能只影响1个字符 (AB) 整个文件可能报废 一个比特错误,算术编码的区间定位完全错乱,后续解码雪崩式崩塌。
      模型版本不一致 解压可能正常 解压必然失败/乱码 概率分布不同 → 区间划分不同 → 同一个比特流落在错误子区间,token全错。
      数据边界不匹配 容易发现 难以诊断 高压缩数据像密文,失去人类可读性。

      这才是“不想压缩率过高”的根源!无损压缩理论保证: 只要比特流无误+模型一致,100%还原。 工程现实: 高压缩率将系统的脆弱性放大了——它像一件极其精密的瓷器,完美但怕磕碰。

      应用场景该关心什么?

      1. 还原可靠性需求 >> 存储/带宽成本时

        • 选择低压缩率甚至不压缩。

        • 优点:抗比特错误、易调试、人类可读。

        • 代价:占用更多空间/带宽。

      2. 存储/带宽成本 >> 计算成本时

        • 选择高压缩率(如GPT+算术编码)。

        • 优点:极致节省空间/带宽(尤其对语义丰富数据)。

        • 代价:必须配套 强校验机制 (如CRC, 前向纠错码) + 严格版本控制

      3. 对抗信道噪声的黄金法则

      核心:在压缩后的密文级数据上叠加纠错层,抵御物理信道噪声。

      总结:无损压缩的“不可能三角”

      维度 高压缩率 低压缩率
      还原准确性 ✅ 100% (理论保证) ✅ 100% (理论保证)
      抗干扰能力 ❌ 极脆弱 (1比特可崩溃) ✅ 强韧 (局部错误)
      计算开销 ❌ 极高 (GPT预测+编码) ✅ 极低 (如gzip)
      人类可读性 ❌ 无 (密文) ✅ 有 (文本/二进制)

      您的直觉是对的——在需要系统鲁棒性的场景下,确实要谨慎追求极致压缩率。但这无损压缩本身的数学纯洁性,而是工程权衡的智慧。

       

      立委关于大模型与AI的博客汇总

像素值是“连续变量”,还是工程上的伪装?

 

“视觉是连续空间的模拟信号,每个像素点就是一个连续变量。”
这是很多计算机视觉教材和模型论文中默认的假设。听起来合理,似乎也和物理世界接轨。但只要稍加推敲,就会暴露出它并非科学结论,而是工程手段的一种近似表达。

我们必须首先区分几个层面:

一、在物理上,光照和颜色确实是连续信号

自然界的光波、亮度和色彩是连续的,这没错。但人类并非以连续方式感知这些物理量——我们的眼睛和大脑会自动将其量化、概念化。例如:

    • 明度被压缩进有限的亮度感知等级;
    • 色彩区分能力是有限的,大致在几千到几万种之间;
    • 空间分辨率和时间刷新频率也受到神经系统本身的限制。

也就是说,虽然世界本身是连续的,人类感知和认知所依赖的输入体验早已是量化后的结果

二、数字图像是离散化的产物

数字化图像以像素构成,通常每个通道8位,表示0到255之间的整数值。无论是JPEG、PNG还是RAW图像,底层存储都是有限精度的离散整数。模型所接收的图像本质上早已是数字化采样后的结果,并非模拟信号。

然而,在神经网络训练过程中,图像输入往往被归一化为0到1之间的浮点数。这一步并非出于感知上的真实需要,而是出于数值计算的方便性。深度学习系统依赖于梯度传播进行优化,而梯度下降算法要求输入数据分布平滑、可导、易归一化。因此,离散像素被“伪装”为连续变量,是为了解决优化问题,而非反映图像本质的必需。

三、这是一种“数学正确”的错觉

模型在训练中处理的是张量空间上的浮点向量,并依赖于连续空间的插值、卷积、归一化等操作。这使得像素在模型编码实现上被强行纳入连续数域,但这种连续性是工程层面的假设,并非信息层面的需求

人类的视觉系统并不需要那么高的分辨率。绝大多数图像中的数值精度远远超出了人类的感知极限。8-bit 表示的256级灰度中,人眼实际可分辨的亮度等级可能不超过100级。而RGB色彩空间中的1670万种组合,也远远超过人类色彩分辨能力的上限。

这意味着:我们为模型输入提供的“连续性”,大部分是感知冗余。高精度浮点表示中的大部分“细节”信息,对人类无感,也并不必然提升模型表现。它们只是方便训练,“让梯度更好传播”的工具,本身并不承载有意义的知识。从信息论角度衡量,每一个像素点的连续表示空间远远超过其必要承载的信息量。这种表征冗余本质上可能是计算资源的结构性浪费

四、重估视觉建模的基本假设

当我们把图像建模为“连续变量组成的张量”,其实是在把一个本可以紧凑表达的问题,拆成了浮点优化问题。它解决的是训练上的可微问题,而不是表达上的本质问题。

未来的视觉模型及其编码,可能应该从三个方向反思:

    • 一是重新审视离散空间在图像表示中的有效性(如 VQ-VAE, DALL·E-style tokens);
    • 二是设计与人类感知匹配的量化机制,基于视觉系统的辨识上限进行编码;
    • 三是开发混合表征体系以节省资源,在连续优化和离散认知之间建立桥梁。

归根结底,“像素是连续变量”不是对世界的解释,而是对神经网络计算架构的妥协。它解决了梯度下降的问题,却掩盖了表征效率的问题。

我们应当意识到,这种假设在科学意义上是伪装的;在工程意义上是权宜的;而在未来的表征体系中,它可能具有进一步量化的优化空间。

 

 

Yann LeCun 所鼓吹的「世界模型」与GPT+Diffusion有什么不同

Yann LeCun 所鼓吹的「世界模型」(World Model)是一種旨在模仿人類和動物學習世界運作方式的新興 AI 概念 [P1, P62]。他認為,這條路徑不同於主流的 GPT/Diffusion 模型所依賴的大數據、大參數和自迴歸 Transformer 架構,是實現通用人工智慧(AGI)的關鍵 [P1, P62]。

以下將從實際能力、優缺點等方面,對最新發布的 LeCun 世界模型(如 I-JEPA 和 V-JEPA 2)與主流 GPT/Diffusion 模型進行比較:

世界模型(I-JEPA, V-JEPA 2)能做到而主流 GPT/Diffusion 難以實現的事項:

  1. 理解與預測物理世界及因果關係
    • 世界模型的核心能力在於對真實物理世界做出反應,能夠理解觀察到的事物(包括物體、動作和運動),並預測世界將如何演變,或智能體採取行動後世界會如何變化 [P1, P32]。這種觀察有助於建立對世界運作方式的因果關係理解 [P1, P4]。
    • 例如,V-JEPA 2 是首個基於影片訓練的世界模型,它顯著提升了動作預測和物理世界建模能力 [P1, P31]。它能夠為籃球的彈跳等物理現象提供更精確的模擬結果,因為它具備了基本的物理認知 [P1, P62]。
    • 比較與主流模型: 主流的生成模型,如基於 Diffusion 和 Transformer 的 Sora目前仍難以準確學習物理規律 [P1, P71]。即使在充足的訓練數據下(可能包含 CG 生成數據),Sora 生成的影片也可能顯示出不符合物理規律之處,這表明簡單地堆砌數據並非通向更高級智能的道路 [P1, P71]。LeCun 更指出,目前的 AI 形式(生成式 AI 和大型語言模型)在缺乏對物理世界的理解、持久記憶、推理能力和複雜規劃能力方面存在限制,阻礙了機器實現真正的智能行為 [P39, P40]。
  2. 透過抽象表示進行預測與規劃,而非精確像素或文字重構
    • 世界模型(如 I-JEPA 和 V-JEPA)的關鍵優勢在於不需要精確預測世界的每一個細節,只需預測足夠抽象的表示以實現規劃目的 [P1, P4, P5, P19, P21]。這種方法比傳統的像素重構方法更注重對圖像的語義表示進行預測,而非完美重構圖像本身 [P5, P21, P73]。
    • I-JEPA 的核心思想是預測抽象表示中缺失的資訊,這更接近人類的普遍理解 [P1, P21]。透過使用抽象預測目標,它可以潛在地消除不必要的像素級細節,從而引導模型學習更具語義性的特徵 [P21]。
    • 比較與主流模型: 生成式架構(如 GPT 和 Diffusion)透過移除或扭曲輸入部分(如擦除照片或隱藏文字),然後試圖預測被破壞或缺失的像素或詞語 [P1, P19, P72]。然而,世界本質上是不可預測的,生成方法可能傾向於填補每一個缺失的資訊,這可能導致模型過度專注於不相關的細節,並犯下人類不會犯的錯誤(例如,生成人手時多出手指,即所謂的「幻覺」問題) [P1, P19, P62]。
  3. 更高的計算效率和更強的語義表示學習能力
    • I-JEPA 的預訓練計算效率很高 [P1, P25]。它不需要應用更耗費計算的資料增強來產生多個視圖,並能夠在不使用手工設計的視圖增強的情況下,學習到強大的現成語義表示 [P1, P25]。在相同的資料量下,I-JEPA 在 ImageNet 上實現最先進的低樣本分類性能時,所需的 GPU 時間比其他方法少 2 到 10 倍 [P1, P16, P25]。
    • V-JEPA 是一種非生成模型,透過預測抽象表示空間中影片的缺失或遮罩部分來學習 [P72]。它可以靈活地丟棄不可預測的資訊,從而將訓練和樣本效率提高 1.5 倍到 6 倍 [P1, P72]。
    • 比較與主流模型: 雖然未直接點出 GPT/Diffusion 的計算效率劣勢,但 World Model 聲稱其計算效率更高,暗示了主流模型在某些方面可能不如其高效。
  4. 零樣本規劃與機器人控制
    • V-JEPA 2 能夠用於在新環境中進行零樣本規劃(Zero-shot planning)和機器人控制 [P1, P32]。它能夠透過想像一系列候選動作的後果來規劃行動,並根據它們接近目標的速度對動作進行評分 [P1, P34]。
    • 這使得 AI 智能體能夠在不需要大量機器人訓練數據的情況下,幫助完成家務和體力任務 [P1, P31]。
    • 世界模型的核心作用是反事實推理(Counterfactual reasoning),即便是對於數據中未見過的決策,在世界模型中都能推斷出決策的結果 [P1, P68]。這是一種人類天然具備,而當前 AI 做得很差的能力 [P1, P68]。一旦產生突破,AI 決策能力會大幅提升,實現全自動駕駛等場景應用 [P69]。
    • 比較與主流模型: LeCun 認為當前 LLM 模式缺乏推理能力和複雜規劃能力,阻礙了真正的智能行為 [P40]。他預測,未來幾年可能成為「機器人技術的十年」,屆時 AI 和機器人技術的進步將結合,解鎖新一代智能應用 [P39, P41]。
  5. 促進開放研究與文化多樣性
    • LeCun 和 Meta 強調開源模型的重要性,認為對於基礎技術和基礎設施類技術,開源模型總能取得勝利 [P1, P5]。開源模型更可靠、安全、可客製化,並能吸引更多參與和貢獻,形成一個生態系統 [P1, P5]。
    • 開源有助於匯集更多人的智慧,避免整個資訊流被一家公司主導並受到某種偏見,這對於世界各地的文化多樣性來說非常重要 [P1, P6]。
    • 比較與主流模型: 雖然 OpenAI 等公司也發布部分開源模型,但 LeCun 強調的開源哲學似乎是更全面和深層次的,認為這能避免壟斷和濫用 [P6, P8]。

兩類模型的缺點與挑戰:

LeCun 世界模型的缺點與挑戰:

  • 複雜性與持續研究: 目前還沒有一套明確的訓練過程可以替代 JEPA 架構,需要進一步研究和發展才能找到更好的方法 [P5]。仍需要發現新的概念、新的架構來實現人類般的智能水平 [P5]。
  • 物理定律模擬的不足: 儘管在進步,但世界模型在模擬現實世界中的複雜物理現象(如流體動力學、空氣動力學等)時,其準確性和一致性仍然不足 [P51]。人類在物理理解基線測試中的表現仍明顯優於包括 V-JEPA 2 在內的頂級模型 [P34]。
  • 泛化能力(外推能力): 對於真實世界中罕見或異常事件的預測(如自動駕駛中的交通事故),模型能否超越訓練數據的記憶,發展出對原理的深刻理解以進行外推,是一個挑戰 [P52]。
  • 計算效率(針對特定應用場景): 對於某些生成式應用,如生成高質量影片,保持時間一致性會導致生成時間大大增加,例如 Sora 生成一分鐘影片可能需要一小時,這限制了大規模應用 [P52]。
  • 性能評估的挑戰: 當前世界模型研究熱點集中在生成式模型上,評估指標主要為生成質量,但這些指標不足以全面反映世界模型的預測合理性。結合人類反饋能使評估更全面,但效率和一致性有待提升 [P52]。
  • 當前模型的局限性: V-JEPA 2 目前只能在單一時間尺度上學習和進行預測,而許多任務需要跨多個時間尺度的規劃。未來重要的方向是發展分層次和多模態的 JEPA 模型,使其能夠使用視覺、音訊和觸覺等多種感官進行預測 [P36, P74]。目前 V-JEPA 適合處理相對較短的影片(可能長達 10 秒),但要在更長的時間範圍內進行預測仍是挑戰 [P74]。

主流 GPT/Diffusion 模型的缺點與挑戰:

  • 缺乏物理世界的深層理解: 如前所述,它們在準確學習和模擬物理規律方面存在明顯不足 [P1, P71]。
  • 推理和規劃能力有限: LeCun 認為當前的大型語言模型(LLMs)擅長處理語言,但不擅長思考 [P40]。它們缺乏持久記憶、推理能力和複雜規劃能力,這阻礙了機器實現真正的智能行為 [P40]。
  • 「幻覺」問題: 由於傾向於填補所有缺失資訊,即使是不可預測的細節,這類模型容易產生「幻覺」,生成看似合理但不正確的內容 [P1, P19, P62, P93]。
  • 對數據的過度依賴: 這類模型透過大量數據進行模式識別和重建學習,但對數據之外的抽象概念和因果關係的理解仍是挑戰 [P62, P68]。
  • 未來發展路線的質疑: LeCun 預測目前的 LLM 模式壽命可能只有三到五年,認為未來會出現全新的 AI 架構範式,其能力將遠遠超越現有 AI 系統 [P39]。他認為自迴歸的 Transformer 是無法通往 AGI 的 [P63]。

 

立委关于大模型与AI的博客汇总

《立委关于大模型与AI的博客汇总》

立委按:一辈子从事NLP/AI工作,已经习惯于在自己的博客频道持续写笔记,记下一路走来的观察和体会。所写貌似科普,但实际上不是为了迎合大众或普惠天下,根本动因还是为自己留下足迹,其次才是与亲友、同人、后学分享。大模型爆发是个分水岭。爆发前的博客集中在NLP的方方面面,大多是符号逻辑路线在自然语言文法方面的挣扎与进展。爆发后也没闲着,在这个有如寒武纪生物大爆发一样的让人眼花缭乱的世界,兴奋与刺激大于焦虑和恐怖,于是一路紧随,只问耕耘。现不揣拙陋,结集于此,定时更新,留下这个时代一位老兵的视界。

立委NLP频道

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): 高压缩率导致系统脆弱

像素值是“连续变量”,还是工程上的伪装?

Yann LeCun 所鼓吹的「世界模型」与GPT+Diffusion有什么不同

详述AI科学家張祥雨的大模型访谈

LLM的后训练强化学习是怎么工作的

大模型科普:探秘莎翁风格的诞生之旅(无代码版)

揭秘GPT内核之四

从零实现莎士比亚风 GPT科普解说

从0实现并理解GPT

解读EMPO全程无监督推理新范式

立委科普:揭秘AI创作视频的两种“神功”

非量化自回归视频生成模型NOVA的技术路线

生成式AI的两条视频生成路线(文献综述)

MCP:从“伪繁荣”到可落地的进化路线

中文分词的前世今生

大模型如何解锁AI各种任务成为通用引擎的?

Grok: 大力出奇迹的背后

Grok:超大数据的大模型为何能收敛?

《“蜜蜂巢”里的子弹:JFK档案解密后》

2025年肯尼迪遇刺档案解密揭示的惊人真相

2025年肯尼迪遇刺案档案解密

Gemini Deep Research:用“Logits Lens”洞察神经网络的奥秘

Sonnet3.7: 推理大模型的挑战与前景(图文版)

数学圆舞曲:欧拉恒等式(配乐诗朗诵)

检索增强(RAG)与窗口数据的互补性 (图文版)

检索增强(RAG)与窗口数据的互补性

关于颈椎病,大模型医疗建议靠谱吗?

人类 vs 恐龙:一场关于“不作不死”的滑稽短剧

deep research: 最新颈椎病手术指征与治疗概览

Xiao Hong Red:肖弘其人

万字长文解析 LLM-native Agent 及其混合计算方式

o3 deep research: LLM 驱动的 Agent 综述

Agent:数字代理的崛起与未来

Agent元年:从聊天机器人到数字员工的当代进化史

生成式AI学习中容易混淆的几个术语

思维链是大模型的符号神助攻

再谈自然模态数据是高维空间的低维流形

深度学习的局限性研究综述

o3 deep research: 深度学习局限性研究报告

深度学习的基石:多层感知机

o3 Deep Research: DeepSeek R1 多阶段训练流程问答解析

RPA 赛道与大模型Copilots早期创业者的困局

Transformer 和注意力机制简介

立委科普:如何理解自注意力机制中的QKV分工?

语言学家应该很容易理解自注意力机制

《立委科普:自注意力机制解说》

DeepSeek 笔记:推理新范式 query+cot+answer 支持新的 scaling law 吗?

DeepSeek 笔记:R1 部署阶段的推理机制

从R1幻觉谈起,大模型幻觉是缺陷还是创意火花?

推理强化学习是端到端的监督,推理过程的非监督

DeepSeek 风暴下看看它的论文

大模型风云诡谲的下半场:scaling 失效?

给奶奶讲一下AI最新物种“大模型代理”

左脚踩右脚可以飞吗,谈交替使用监督微调和强化学习的后训练

DeepSeek爆火真相:不靠“人盯”, 让AI自己学会慢思考

人类反馈是超级智能的桎梏吗?

马毅教授的演讲,值得一听

马毅教授称,已经揭开完全揭开神经网络的面纱

NLP老司机的AIGC旅程

创业邦深圳会议演讲笔记:推动AIGC商业落地,出门问问的「产模结合」实践

立委论LLM:什么是AI刚需

辣妈3笔记 以及辣妈MV与辣妈3.1传奇

符号主义被打入冷宫太久了,难道神经是AI的终结者吗?

DeepSeek R1:《少年DS之烦恼》

告诉李雪琴一个激发写段子灵感的秘诀:找deepseek R1

大模型三阶段的 scaling laws 接力赛

视觉模型生成的极限对齐

解耦才能解套:再谈视频中的人物一致性问题

挥刀董事会,OpenAI 如何解决致命难题

英伟达GTC的一小步,AI进化史的一大步

为什么说 Sora 是世界的模拟器?

立委两分钟:大模型到底有没有逻辑推理能力?

介绍尼克的最新演讲,探寻大模型的理论基础与渊源(中文版,英文字幕)

《AI潮流:开发者提示工程公开课中的二原则》

《飞哥说AI》深度系列

2023/12/09: 李维 高佳:OpenAI狂飙生态? 领域壁垒仍是大山

2023/12/09: 李志飞 高佳 李维:关于 Google Gemini 的八点启示

2024/02/19: 李志飞 李维 高佳:为什么说 Sora 是世界的模拟器?

2024/02/29: 李志飞 李维 高佳:万字长文解构中国如何复刻 Sora:模型架构、参数规模、数据规模、训练成本

2024/03/05: 李志飞 李维:Claude 3 追平或超越 GPT-4,能归纳15万单词

2024/04/01: 李维 王艺 高佳:Suno 将如何进化?

2024/04/12: 高佳 李维 王艺「产模结合」也许是AI公司更好的出路?

2024/06/04: 李维 高佳:KAN会引起大模型的范式转变吗?

2024/07/18:李维 高佳:“安全智能”的背后,Ilya 究竟看到了什么?

2023-2024关于大模型及AIGC的演讲/采访

2023-03-05:源码资本AIGC“尖峰系列”,李维博士:人类语言“通天塔”建成,ChatGPT的辉煌与挑战

2023/05/09: 腾讯科技,对话产业专家:“百模大战”愈演愈烈,地球上算力不够支撑10亿人使用

2023/07/16: 轩辕之学讲座,特邀讲座《大模型的历史、现状和挑战

2023/06/28: 中国证券报报道 360 GPT 联盟特邀演讲:李维:避免大模型行业同质化竞争 深耕领域阶段有很多“细活”可做

2023/07/21: ArchSummit 全球架构师峰会主题演讲《从架构师视角谈如何迎接/拥抱大模型及其新生态》(https://blog.csdn.net/EDDYCJY/article/details/131929057

2023/07/28: Chinajoy,中国音像与数字出版协会和上海汉威信恒展览有限公司主办,特邀演讲《AIGC时代,数字人引领内容创作新范式

2023/08/06: 亚马逊云科技和真格基金主办的闭 “机遇与挑战——生成式AI的发展趋势和落地应用”,主题演讲《AI大模型落地的前景和痛点》

2023/08/23: 江苏师范大学主办 “大语言模型离人类语言有多远”学术研讨会特邀演讲《大模型的本性及其落地痛点》

2023/10/20: 第十一届科博会,特邀主题演讲《AI和大模型趋势》

2024年3月18:英伟达 GTC2024全球开发者大会 与英伟达中国团队合作,讲演《重塑数字人互动潜能》

2024/04/22: 第十四届北京国际电影节光影未来,演讲《捕捉未来的魔术师》

2024/04/22 九派财经专访出门问问副总裁李维:两年内大模型的商业化爆发一定会发生

2023/11/11: 香蕉论坛,“百“模”大战对智能座舱发展意义与实践”,2023/12/05 汽车商业评论,《​李维:大模型技术的过去、现在与未来

2023/12/05 汽车商业评论,《​李维:大模型技术的过去、现在与未来

2024/04/22:九派财经专访出门问问副总裁李维:两年内大模型的商业化爆发一定会发生

2024/05/24: 九派财经专访出门问问副总裁李维:找产品方向是更大痛点,跑通场景是第一位

《AI浪潮博客目录:白模大战早期》

《AI浪潮:不识数的 ChatGPT》

《AI浪潮:打造中国的 ChatGPT,挑战与机会并存》

《AI浪潮:chatGPT 搞定了人类语言》

《AI浪潮:chatGPT 能写出段子吗》

《AI浪潮:chatGPT 的里程碑意义》

《AI浪潮:chatGPT 写的情书能有真情吗》

《AI浪潮:LLM 凭什么能“涌现”超级能力?》

《AI浪潮:漫谈LLM与领域对齐》

《AI浪潮:神迹与笑话齐飞,chatGPT 也是大观了》

《AI浪潮:chatGPT 帮你写应用文》

《AI浪潮:人工智能当代简史》

《AI浪潮:chatGPT 辅导精读学术论文的实验》

《AI浪潮:因为见从而信,见证奇迹的时刻》

《AI浪潮:zero shot 抽取、摘要、吟诗、阅读理解》

《AI浪潮:玩不死的 chatGPT》

《AI浪潮:关于chatGPT 的 思维链能力 》

《AI浪潮:n-shot 是训练还是指令》

随笔:AGI 迷思与反思

AIGC 潮流扑面而来,是顺应还是(无谓)抵抗呢?

漫谈AI 模型生成图像

图灵测试其实已经过时了

RPA 是任务执行器还是数字员工?

《深层解析符号模型与深度学习预训练模型》(修订文字版)

NLP 新纪元来临了吗?

推荐Chris Manning 论大模型,并附上相关讨论

《我看好超大生成模型的创造前途》

立委随笔:机器翻译,从学者到学员

《AI 随笔:观老教授Walid的神经网络批判有感》

《李白梁严127:神经的要害在数据瓶颈与定点纠错盲区》

《李白126:神经 attention 机制搞定代词指代的案例》

泥沙龙笔记:从乔姆斯基大战谷歌Norvig说起

《AI潮流:与 ChatGPT4 聊“买房送老公”背后的语言学》

《AI潮流:跟Andrew学如何调用 ChatGPT 做自己的服务前台》

【AI 浪潮:超级词匠 ChatGPT4 的百变文风】

【AI 浪潮:数据中心的大模型时代】

【AI 浪潮:大模型推理的细节编造是 feature,不是 bug】

两分钟谈谈:Moravec悖论

两分钟谈一下啊:模型训练的内推与外推

两分钟短评:大模型开始进入平台期吗?

悲观主义的视角,人类的宿命

以前的杂记,关于AGI、马斯克、奥特曼和OpenAI

语言是大一统模型里的核心和主线

AIGC时代,关于鲁迅大脑的复活

小雅系列:短视频文案

大模型短视频系列:大模型压缩与白马非马

AIGC 作品

【唐诗300首 AIGC 配乐: 白居易 琵琶行】

【唐诗300首 AIGC 配乐: 李商隐 无题】

【唐诗300首 AIGC 配乐: 杜甫 春望】

AIGC Suno:英烈颂

AI创作花絮: 《影月无痕》

大模型的落地现状和前景

大模型漫谈系列n

图片一键生成短视屏,奇妙元是时间的摄像机

奇妙元体验AIGC奇妙:《岁月如歌:神秘园》

立委微信视频号

大模型科普系列1 
系列2 知识蒸馏
系列3 自回归和扩散模型
系列4 视频生成
https://weixin.qq.com/sph/A523fBxLQ
https://weixin.qq.com/sph/Aw5lAfSoV
https://weixin.qq.com/sph/Af5j09VbP
https://weixin.qq.com/sph/AsK0Dk54l
https://weixin.qq.com/sph/AIanE0ocM
https://weixin.qq.com/sph/AbxoSWedA
https://weixin.qq.com/sph/AA6fqzTkO

English

How GPT Works: A Shakespearean Text Generator

MCP: From Flashy Boom to Real Usability — A Technical Deep Dive

03 deep research: Challenges and Prospects of Advanced Reasoning LLMs

Does the New Reasoning Paradigm (Query+CoT+Answer) Support a New Scaling Law?

Technical Deep Dive: Understanding DeepSeek R1's Reasoning Mechanism in Production

DeepSeek's R1 Paper: A Storm in AI LLM Circle

The Turbulent Second Chapter of Large Language Models: Has Scaling Stalled?

DeepSeek_R1 paper

Probabilistic Transformer: A Probabilistic Dependency Model for Contextual Word Representation

Introduction to Transformer and Its Attention Mechanism

Has Symbolism Been Sidelined for Too Long? Could Neural LLM terminate AI?

What did Ilya see? -- secret behind success of LLMs

Suno AIGC:Ode to Madam Hu

Nick tracing the AI history for theoretical foundation and sources (English)

Unified Models Surpass Single-modal Models  (Gemini Notes 2/8)

Cross-modal Knowledge Transfer of Large Models Proven (Gemini Notes 1/8)

Decoding the New EMPO Reasoning Paradigm

A Comparative Review of Autoregressive and Diffusion Models for Video Generation

Unveiling the Two "Superpowers" Behind AI Video Creation

Decoding LLM-native Agents: Bridging Compilation and Interpretation in AI

The Three-Stage Scaling Laws Large Language Models

Technical Deep Dive: Understanding DeepSeek R1's Reasoning Mechanism in Production

Professor Ma's long paper out

Professor Ma Claims to Have Fully Unveiled the Mysteries of Neural Networks

Decoupling to Resolve: Issue of Character Consistency in Video Generation

Llama 3 Notes and Llama MV with Llama 3.1 Legend

The ChatGPT Tsunami and Its Impact on IT Landscape and New Ecosystem

《科学网》博客

从0实现并理解GPT 2025-06-04

大模型科普:探秘莎翁风格的诞生之旅(无代码版) 2025-06-03

LLM的后训练强化学习是怎么工作的 2025-06-02
EMPO强化学习项目复现Claude4学习总结 2025-05-27
解读EMPO全程无监督推理新范式 2025-05-27
Decoding the New EMPO Reasoning Paradigm 2025-05-27
Q&A on NLP: Chapter I Natural Language and Linguistic Form 2025-05-22
MeanFlow: AI图像生成的降维打击 2025-05-22
Review of Autoregressive and Diffusion Models for Video Gene 2025-05-03
Unveiling the Two "Superpowers" Behind AI Video Creation 2025-05-02
生成式AI的两条视频生成路线 2025-05-02
非量化自回归视频生成模型NOVA的技术路线 2025-05-02
立委科普:揭秘AI创作视频的两种“神功” 2025-05-02
Silicon Valley Night: A Foxy Encounter 2025-04-23
《硅谷夜记:艳遇》 2025-04-23
中文分词的前世今生 2025-03-30
大模型如何解锁AI各种任务成为通用引擎的?
Grok:大模型为什么要超大数据?(4o配图)
Grok: 大力出奇迹的背后
2025年肯尼迪遇刺案档案解密 (审核未通过)
2025年肯尼迪遇刺档案解密揭示的惊人真相 (审核未通过)
《“蜜蜂巢”里的子弹:JFK档案解密后》
Grok:超大数据的大模型为何能收敛?
Gemini Deep Research:用“Logits Lens”洞察神经网络的奥秘
检索增强(RAG)与窗口数据的互补性 (图文版)
03 deep research: Challenges and Prospects of Advanced Reaso
Sonnet3.7: 推理大模型的挑战与前景(图文版)
数学圆舞曲:欧拉恒等式(配乐诗朗诵)
人类 vs 恐龙:一场关于“不作不死”的滑稽短剧
deep research: 最新颈椎病手术指征与治疗概览
关于颈椎病,大模型医疗建议靠谱吗?
给奶奶讲一下AI最新物种“大模型代理”
Decoding LLM-native Agents: Bridging Compilation and Interpr
The Agent Era: The Contemporary Evolution from Chatbots to D
o3 deep research: 智能体的应用和演进
万字长文解析 LLM-native Agent 及其混合计算方式
Xiao Hong Red:肖弘其人
Agent元年:从聊天机器人到数字员工的当代进化史
Agent:数字代理的崛起与未来
o3 deep research: LLM 驱动的 Agent 综述
【外一篇:推理范式演进中的概念】
生成式AI学习中容易混淆的几个术语
思维链是大模型的符号神助攻
再谈自然模态数据是高维空间的低维流形
The Three-Stage Scaling Laws Large Language Models
大模型三阶段的 scaling laws 接力赛
Fundamental Limitations of Deep Learning: Origins in Data-Driven...
深度学习的局限性研究综述
o3 deep research: 深度学习局限性研究报告
左脚踩右脚可以飞吗,谈交替使用监督微调和强化学习的后训练
o3 Deep Research: DeepSeek R1 多阶段训练流程问答解析
Dilemma of RPA and Early-Stage LLM Co-pilot Entrepreneurs
RPA 赛道与大模型Co-pilots早期创业者的困局
Linguists Should Find Self-Attention Intuitively Familiar
语言学家应该很容易理解自注意力机制
符号主义被打入冷宫太久了,难道神经是AI的终结者吗?
Has Symbolism Been Sidelined for Too Long?
如何理解自注意力机制中的QKV分工?
Transformer 和注意力机制简介
DeepSeek: Learning to Think Slowly Without Human Supervision
DeepSeek爆火真相:不靠“人盯”, 让AI自己学会慢思考
Reasoning Paradigm (Query+CoT+Answer) Support scaling law?
Understanding DeepSeek R1\'s Reasoning
DeepSeek 笔记:R1 部署阶段的推理机制
DeepSeek 笔记:推理新范式 query+cot+answer 支持新的 scaling law 吗?
Hallucinations in AI: Bug or Feature? A Deep Dive into DeepSeek
从R1幻觉谈起,大模型幻觉是缺陷还是创意火花?
推理强化模型中思维链的本质
R1: 《立委列传》
王菲春晚《世界赠予我的》歌词,亮点与短板
推理强化学习是端到端的监督,推理过程的非监督
RL: Supervised Outcomes, Unsupervised Processes
DeepSeek R1:《少年DS之烦恼》
告诉李雪琴一个激发写段子灵感的秘诀:找deepseek R1
DeepSeek 风暴下看看它的论文
DeepSeek's R1 Paper: A Storm in AI LLM Circle
The Turbulent Second Chapter of Large Language Models
大模型风云诡谲的下半场:scaling 失效?
Professor Ma\'s long paper out
马毅教授的演讲,值得一听
NLP老司机的AIGC旅程
解耦才能解套:再谈视频中的人物一致性问题
马毅教授称,已经揭开完全揭开神经网络的面纱
人形机器人大热,但看不到商业闭环
推动AIGC商业落地,出门问问的「产模结合」实践
转述老领导的硅谷风投现状和展望的分享
视觉模型生成的极限对齐
立委论LLM:什么是AI刚需
立委论LLM:视频生成的人物一致性问题
《AIGC图生视频:牵手》
《朝华之十九:牵手》
UBI 势在必行
姑蘇胡氏哀辭(AI作词作曲)
短视频:大模型奥秘
大模型的理论奥秘
Nick traching the AI history for LLM theoretical foundation
大模型以来,觉得可以留个记录
《谈两种复杂度》短视频科普
《介绍监督学习的数学原理》短视频科普
《谈谈端到端和大模型》短视频
古典诗词AI配乐集锦
【唐诗300首 AIGC 配乐: 白居易 琵琶行】
两分钟短评:大模型开始进入平台期吗
悲观主义的视角,人类的宿命
两分钟谈:模型训练的内插、外插
两分钟谈谈:Moravec悖论
就《Suno: 望震》与音乐大家的对话
Suno:《宋輝:人生笑话》-- 献给插队一代人 (审核未通过)
Tanya's Childhood 2: American nursery rhymes
写在巴别塔建成周年纪念日
李名杰:医学论文集(41):老爸的故事(代后记)
李名杰:医学论文集(40):纪念专辑 - 影集3
李名杰:医学论文集(39):纪念专辑 - 影集2
李名杰:医学论文集(38):纪念专辑 - 影集1
Debriefing report
My career as surgeon
The Tireless Father (Preface)
COLLECTED WORKS IN COMMEMORATION OF MINGJIE LI’S CAREER
大模型短视频系列:大模型压缩与白马非马
AI创作花絮: 《月影双剑》
数字人形象设计:为什么选她?
大模型的落地现状和前景
大模型漫谈系列n
喜欢刀郎,也喜欢那英
奇妙元体验AIGC奇妙:《岁月如歌:神秘园》
《AI浪潮: 辛顿的 AI 威胁论与马斯克如出一辙》
《AI潮流:跟Andrew学如何调用 ChatGPT 做自己的服务前台》
《AI潮流:与 ChatGPT4 聊“买房送老公”背后的语言学》
《AI潮流:开发者提示工程公开课中的二原则》
【AI 浪潮:超级词匠 ChatGPT4 的百变文风】
【AI 浪潮:自主性是人类智能的最后堡垒吗】
【AI 浪潮:GPT-4 的上下文逻辑与常识还是不够稳固】
【AI 浪潮:数据中心的大模型时代】
快讯:腾讯科技AI未来指北系列 今天直播间与鲁总唠一唠大模型(LLM)
【劳碌命论LLM:大模型推理的细节编造是 feature,不是 bug】
AIGC“尖峰系列”丨李维博士:ChatGPT海啸狂飙,谁将被取代?
ChatGPT Tsunami and Its Impact on IT Landscape and Ecosystem
AIGC“尖峰系列”丨李维博士:人类语言“通天塔”建成,ChatGPT的辉煌与挑战
[转载]与ChatGPT相关……码脑 | 张宏江、李维等顶级大咖齐聚,AIGC系列分享
《AI浪潮博客目录》
《AI浪潮:不识数的 ChatGPT》
《AI浪潮:打造中国的 ChatGPT,挑战与机会并存》 (审核未通过)
《AI浪潮:chatGPT 搞定了人类语言》
《AI浪潮:chatGPT 写的情书能有真情吗》
《AI浪潮:chatGPT 能写出段子吗》
《AI浪潮:chatGPT 的里程碑意义》
《AI浪潮:LLM 凭什么能“涌现”超级能力?》
《AI浪潮:漫谈LLM与领域对齐》
《AI浪潮:神迹与笑话齐飞,chatGPT 也是大观了》
《AI浪潮:chatGPT 帮你写应用文》
《AI浪潮:人工智能当代简史》
《AI浪潮:chatGPT 辅导精读学术论文的实验》
《AI浪潮:因为见从而信,见证奇迹的时刻》
《AI浪潮:玩不死的 chatGPT (之一)》
《AI浪潮:玩不死的 chatGPT (之二)》
《AI浪潮:关于chatGPT 的 思维链能力 》
AGI 迷思与反思
《AI浪潮:n-shot 是训练还是指令》
AIGC 潮流扑面而来,是顺应还是(无谓)抵抗呢?
美术新时代,视频展示
漫谈AI 模型生成图像
【缅怀刘倬先生特别系列】
送别恩师刘倬先生
一代宗师 刘倬先生千古!(1933-2022)
《李白宋梁130:从短语结构的词序基础约束到大模型向量空间的天马行空》
AI 正在不声不响渗透我们的生活
RPA 是任务执行器还是数字员工?
图灵测试其实已经过时了
《立委科普:自注意力机制解说》
《深层解析符号模型与深度学习预训练模型》(修订文字版)
NLP 新纪元来临了吗?
【随感:大数据时代的信息茧房和“自洗脑”】
推荐Chris Manning 论大模型,并附上相关讨论
《我看好超大生成模型的创造前途》
我的前老板的企业家创业访谈
[转载]编译 Gary Marcus 最新著述:《深度学习正在撞南墙》
老司机谈NLP半自动驾驶,欢迎光临。
立委随笔:机器翻译,从学者到学员
立委随笔:上网课也可以上瘾吗?

立委NLP频道(前大模型时代其他系列)

李维 郭进《自然语言处理答问》,商务 2020

《李白对话录》

【置顶:立委NLP博文一览】(前大模型时代符号逻辑)

立委微博的存在

立委NLP《关于系列》

《朝华午拾》电子版

《李家大院》电子版

《李老夫子遗墨》电子版

《小城青葱岁月》电子版

《江城记事》电子版

【李名杰从医67年论文专辑】(电子版)

【李名杰从医67年论文专辑(英语电子版)】

关于作者

详述AI科学家張祥雨的大模型访谈

立委按:張祥雨是一位備受推崇的AI科學家,總論文引用數已超過 37萬次。他在AI圈內口碑良好,被譽為新一代華人AI科學家中最傑出的之一。張祥雨的博士研究時期(2012年至2016年)恰逢 深度學習的爆發。他認為這個時期時間點非常好,趕上了2012年AlexNet的成功,深度学习革命的起点,而他的ResNet工作也成为了这场革命的关键推手。

張祥雨最近接受了一次深度访谈,难得他有机会自由抒发两个多小时,描述了一个深刻而完整的的大模型的研究探索旅程和一路走来的心路历程。上一次感觉精彩绝伦学到了真经受到重要启发的,还是伊利亚关于next token prediction溯源到K氏复杂性的伯克利演讲。祥雨的这个访谈听下来体感不亚于那一次的收获和叹服。虽然这次访谈的录音效果欠佳,还是强烈建议AI-ers不要错过这个充满了洞见和认知的精彩,他对十多年来在大模型研发上不断探索的心得体会,相信对后学和同仁具有启发意义。本文是这次访谈的听书笔记,可供参照。

2012年深度学习爆发

AlexNet的成功主要在於它做到了 scaling(規模化),包括模型、數據和算力。當時,數據規模化有李飞飞的ImageNet(提供的大數據集120多萬張圖),算力規模化有英伟达GPU CUDA的發展,都已經不是瓶頸。因此,最關鍵的一點是誰能先把 模型規模化 (model scale up)

張祥雨在博士階段,工作主線就是 做模型規模化 (model scaling),目標是把模型做得更大。這無非是追求更大的寬度、更大的深度以及更大的分辨率。他與何凱明和孫劍老師進行了大量的合作。在這個階段,他們提出了許多方法來解決模型規模化中的問題,尤其是在深度方面的擴展。之前的一些模型過了十幾層效果就會迅速下降,而他們提出的 ResNet(殘差網絡)是一項具有巨大影響力的工作,能夠將網絡從十幾層擴展到上百層,甚至上千層。這項工作被認為基本解決了當時模型規模化的問題,為深度學習的大爆发奠定了基礎。

2019年 NLP 大模型爆發 

張祥雨指出,在 2019 年,NLP 領域取得了非常大的進展(BERT 和 GPT)。許多人認為這得益於 Transformer 架構。然而,他強調架構並非核心,真正的關鍵是優化算法。之前的 NLP 方法與 CV 類似,依賴大量人工標註數據。但 NLP 幸運地發現了無需人工標註的自監督訓練方式,例如 BERT 使用的類似完形填空的方法,以及 GPT 使用的預測下一個 token 的方式。 這種自監督方式使得模型可以几乎無限擴展地利用數據。模型透過上游任務學習到更強的表徵。 GPT 的方式還能透過 in-context modeling 解锁許多下游任務。這種 不依賴人工標註、可以大規模利用數據 的特性,是 NLP 實現真正做大 (scale up) 的關鍵,張祥雨稱之為 NLP 領域的 「GPT 時刻」

2020年 ViT 出現,2022年底ChatGPT爆发

NLP 方法進軍 CV 到了 2020 年,領域發生了另一件大事:Transformer 架構被成功地完全應用於 CV 任務,其中最具代表性的是 ViT 架构。這使得學術研究人員自然而然地認為,可以將 NLP 領域成功的方法直接搬到 CV 中嘗試。因此,產生了許多模仿 NLP 方法的 CV 模型,例如 CV 中的 iGPT (模仿 NLP 的 GPT) 和 BEiT (模仿 NLP 的 BERT)。尤其是在何凱明提出了 MAE 系列之後,這些自監督方法在下游任務上的性能甚至能夠逼近或略超過使用全監督數據訓練的模型。這再次讓 CV 社群感到振奮。

Open AI 2022年底发布 ChatGPT(3.5) ,是大模型规模化效应的里程碑,引发了全社会的关注与震撼。此前国内小圈子也有不同的探索,但限于规模,效果都不太好,到了ChatGPT,scaling 成为广泛共识,GPT规模化高歌猛进,到GPT4发布形成AI的又一个高潮。

CV 難以復現 NLP 的規模化效應

不變性與缺乏泛化能力 儘管初期看起來很有希望,但張祥雨對此一直持謹慎態度。他發現許多這些方法 只在小模型上有效,一旦放到更大的模型上,就不具備 scale up 的特性,效果會迅速下降。 他仔細分析後認為,這些方法 (無論是 contrastive learning 還是 MIM) 本質上都在學習某種 「不變性」。不變性對於視覺表徵確實非常關鍵。然而,這些方法學到的不變性是 「人工設計的」(handcraft),而非數據驅動的。例如,contrastive learning 極度依賴圖像增強 (augmentation),學到的是透過人工設計的 augmentation 賦予的不變性。MIM 學到的是遮擋不變性。 問題在於,一旦模型學會了你所設計的特定不變性 (如旋轉、顏色變化、遮擋等),即使增加再多數據,也 沒有額外的信息增量 來激發模型學習更多的不變性。這與 NLP 不同,NLP 是真正做到了 「從數據中學習」,高品質語料越多,模型就能學習到語料中更複雜的關聯性,透過壓縮建模聯合分佈來學習更多知識。由於 CV 的這些方法學到的不變性是受限且人工注入的,它們 缺乏像 NLP 那樣的 scale up 效應。張祥雨在 2022 年初就發表觀點認為 MIM 沒有顯著的 scaling law。

當張祥雨看到關於 思維鏈 (Chain-of-Thought, CoT) 的發現和 湧現性 (emergence) 的論文後,他表示「大受震撼」。這些研究顯示,做 NLP 的同行已經開始研究推理 (reasoning)更高級別的智能特性,而他感覺自己的研究仍然停留在表徵層面。這讓他更加確信純視覺領域可能存在根本性問題。

NLP 與 CV (靜態圖像) 的根本差異

張祥雨進一步闡述了他認為純視覺領域(特別是靜態圖像)的根本問題。他從三個關鍵維度進行對比:生成 (Generation)、理解 (Understanding) 和人類對齊 (Human Alignment)

    • 自然語言:對於自然語言模型 (如 GPT),這三者是 「合三為一」或「自閉環」 的。當你訓練一個類似 GPT 的生成模型來建模聯合機率分佈時,模型同時擁有了生成 (預測後文的條件機率)、理解 (前文影響後文的條件機率分佈,可以回答前文問題),以及人類對齊 (訓練語料來自人類自然語言)。
    • 靜態圖像:相比之下,靜態圖像領域這三者是 「割裂的」(disconnected)。你可以訓練一個生成模型完美地建模圖像數據集的聯合機率分佈,但這並不代表模型能夠「理解」圖像。圖像作為客觀存在來自大自然,它不必然包含人類對它的理解方式。人類對圖像的理解是一種外部信息或注入的認知。同樣,圖像數據來自大自然,並非人類生成的,因此本質上沒有必然與人類對齊。他認為,靜態圖像之所以難以形成意義上的智能,就是因為其理解、生成和人類對齊這三點是割裂的。

張祥雨認為,正是因為靜態圖像數據在生成、理解和人類對齊這三項核心能力上不能形成自然、閉環的關係,這成為了視覺智能難以像 NLP 那樣成功復現規模化突破的 底層原因。基於這一認識,他在 2022 年停止了對靜態圖像表徵的研究。

從純視覺的悲觀到視覺與語言對齊的嘗試

張祥雨在 2022 年時,對於單純依靠視覺領域(尤其是靜態圖像)來實現智能或達到「CV 領域的 GPT 時刻」感到悲觀。他認為,與自然語言模型(如 GPT)能夠同時實現生成、理解和人類對齊的「自閉環」特性不同,靜態圖像在這三者之間是「割裂的」。圖像作為自然世界的客觀存在,其本質上不包含人類對它的理解方式或與人類對齊。意識到這個根本性問題後,他在 2022 年基本上停止了對靜態圖像表徵的研究,並構思了新的研究主題,即在短期內利用視覺和語言的對齊關係來尋求突破。

为了複刻 NLP 成功路徑,將圖像編碼為 Token 並与text進行混合訓練。張祥雨的想法是借鑑 NLP 領域成功的「next token prediction」範式。由於語言模型證明了這種基於自監督訓練(无需人工標註)的方法能夠透過大規模數據實現「scaling up」,他希望也能將這種方法應用於視覺。具體的思路是,將圖像也用 tokenizer 的方法轉換成 token,使其與語言處於同一個内部空間。然後,利用大量的圖文交錯數據(如網頁、書籍、論文等),將數據組織成文本和圖像 token 混排的形式。在預訓練階段,模型像處理純文本一樣,遇到文字就預測文字 token,遇到圖像就預測圖像 token。

Step1 模型:理解生成一體化的初步嘗試

根據這一思路,張祥雨團隊在 2023 年做出了他們的第一代大模型 Step1。這個模型從預訓練的最開始就是設計來處理多模態數據的,而非先訓練一個純文本模型再進行視覺對齊。Step1 的參數規模大約是千億級 (一百多B)。他們的目標是實現圖像的理解和生成一體化,希望能夠複刻 NLP 模型那樣,透過統一的生成任務來同時獲得理解和對齊的能力。這條路線與 Google 號稱的多模態大一統模型 Gemini 1.0 在理念上有相似之處。

遭遇瓶頸:理解與生成未能协同增效

然而,經過大半年的嘗試,張祥雨發現並沒有做到圖像的理解、生成和對齊一體化。他得到的是一個越來越強的理解模型和一個越來越強的生成模型,但兩者放到一起時並沒有產生「1+1 > 2」的叠加效果。模型實際表現起來仍然像是兩個獨立的模型,移除其中一個並不顯著影響另一個。特別是,圖片生成的可控性並沒有隨著理解能力的提升而顯著提高。他觀察到,像海外的一些知名工作(如 Gemini, GPT-4V)在那個時間點似乎也未能完全實現理解和生成的一體化,而是透過外掛模組的方式實現功能。這使得他在做了大半年之後感到迷茫。他後來分析認為,視覺生成之所以難以實現這種協同效應,根本原因在於它缺失了類似於語言模型的 CoT (思維鏈)。視覺生成過程(無論是 Auto-regressive 還是 Diffusion)本質上是一種「一口爆」或單步生成的模式,其複雜度遠超 Transformer 單步處理的能力,無法像語言 CoT 那樣進行分解和逐步推理。

Step2: 走向万亿的超大模型

在 Step1 (千億參數) 完成後,團隊很自然地想挑戰更大的模型。於是在 2024 年初上馬了 Step2 項目,目標是萬億參數規模,且激活參數規模也非常巨大(兩百多B)。這個項目前後做了九個多月,總算訓到一個他們認為比較滿意的狀態。然而,訓練這個模型的投入「簡直是一個無底洞」,一方面因為大大低估了訓練如此大模型所需的海量數據,另一方面同時擴大模型參數和數據量,對算力的需求是平方關係,使得訓練過程非常吃力。在數據不足的情況下,僅僅擴大模型參數效果并不理想。這再次凸顯了在模型規模化之後,數據規模化成為新的瓶頸,正如他當年完成 ResNet 後所觀察到的情況。

張祥雨在尋求視覺智能突破的過程中,嘗試將 NLP 的成功範式(next token prediction 和大規模預訓練)遷移到視覺領域,透過多模態混合訓練來實現圖像的理解和生成一體化。儘管在模型規模上不斷擴大(從千億到萬億),但受限於視覺數據本身的特性(生成、理解、人類對齊的割裂)以及當時技術不足的訓練範式(缺乏視覺 CoT),未能有效整合視覺理解和生成能力,並在擴大模型規模時遭遇了嚴峻的數據挑戰。

大模型预训练范式的短板

在這個进军萬億參數規模的 Step2 模型过程中,他們發現了一件「百思不得其解的怪事」:模型的通用對話能力、情商和知識量確實隨著模型變大而變得更強,但模型的推理能力(尤其是數學)表現卻是先上升後平緩,再擴大參數反而是下降。這個現象在當時業界尚未引發廣泛討論。

更深入觀察發現了一些「蛛絲馬跡」:更大的模型在做數學題時,「更傾向於跳步」,「不老實」地一步步推導。它經常會放棄一步步計算,而是直接「一口」報出最後的結果

張祥雨分析認為,這其實就是 Next Token Prediction (NTP) 的「本質缺陷」。NTP 的核心範式是點態概率建模,也是第一代大模型起飛的基礎算法。它的本質目標是最大化壓縮率

    • 然而,在數學這類問題上,存在一個「非常本質的矛盾」:更大的壓縮率其實未必對應更高的計算精度。NTP 追求的是模型輸出分布與數據分布的接近程度,即最大的壓縮率。
    • 預訓練的原生數據(尤其是來自網路的數據)中,充滿了人類省略中間計算過程或「跳步」的內容。例如,給定十幾個數字相加,網路語料可能直接給出結果,而沒有詳細步驟。較大的模型由於參數量巨大,它有能力去擬合這種「一口报」的分布峰,而且從壓縮率角度看,這也更接近原始數據分布。較小的模型反而因為能力有限,無法處理如此複雜的函數,只能學會按步驟計算的分布峰。
    • 大模型學會了「跳步」行為。雖然跳步「可能90%都是對的」,但對於複雜的數學題或推理問題,其步驟繁多,中間任何一步的跳步錯誤都會導致最終結果的錯誤。這使得大模型在處理需要長鏈推理的問題時,錯誤率反而上升,有時甚至不如更小的模型。
    • NTP 的其他問題,例如它「天生容易OOD(Out-of-Distribution)」,容易在中間出現分叉,陷入未曾見過的環境,而許多「幻覺」也由此產生。

總結來說,張祥雨的經歷驗證了在將 NTP 範式應用到極大規模模型時,其固有的「最大化壓縮率」目標與某些任務(如數學推理)所需的「最大化精度」目標會產生衝突。由於預訓練數據包含了大量省略中間步驟的「跳步」範例,追求高壓縮率的大模型學會了這種行為,進而在需要嚴謹逐步推理的任務上表現下降。這突顯了 NTP 作為底層算法在處理複雜推理任務上的局限性。

最大的問題在於缺少思維鏈

對於視覺生成,不論是擴散模型 (Diffusion Model) 還是自迴歸模型 (Auto-Regressive Model),張祥雨認為從语义角度來看,它們都屬於「一口报」的生成方式。Auto-Regressive Model 最大的特點就是「落子無悔」,需要在單步推理中決定如何繪製區域。Diffusion Model 的降噪過程主要是补充细节,虽然它看上去是一個多步過程,但其中缺乏人類理解中的语义或推理。與人類繪畫過程(打草稿、描繪輪廓、上色等)完全不同,降噪過程更像是在構造一個數學過程來擬合分布,其間沒有明確的语义或物體層次的推理。這兩種方法在他看來,都還處於語言模型NTP范式最初的「一口报」時代,最大的問題在於缺少思維鏈 (CoT)

他認為,簡單地將生成和理解做到一起難度非常大,中間缺失了重要一環——CoT。借鑑語言模型的經驗,CV 領域的方向可能是先在視覺理解上做 CoT。如果視覺理解的 CoT 能夠成功,再將方法擴展到生成上,也許最终能走通多模態理解生成一體化的道路。

為此,他們在去年年中開啟了一個新的專案,目標是做視覺理解,核心是真正在視覺空間上做思維鏈。這可以理解為視覺空間上的「慢思考」或「long thought」。這個项目做了半年的結果:並非完全沒有效果,透過這樣的方式訓練確實可以解決某些問題。但是,其泛化能力非常有限。他提到,他們造了什麼樣的數據,模型就只能解決這類數據的問題类型完全沒有展現出在語言模型上 O1 那種強大的泛化能力

O1 强化推理的新范式

回顧 O1 在語言領域的成功,張祥雨認為其要害在於学习到思維鏈的 pattern,「pattern is all you need」。O1 最吸引人的地方在於其無與倫比的推廣性,不僅能泛化到不同的領域 (domain),也看到思维pattern本身的泛化

他舉例說明了這種 pattern 的泛化能力:即使只在純數學數據上訓練一個 O1-like 的模型,當應用於需要嚴格格律和押韻的古詩詞寫作時,模型也能激發出與解數學題非常類似的思考 pattern。例如,它會先給出一個初步嘗試,然後逐字檢查不符合要求的,一個個替換,如果發現不行,會推翻前面做的部分甚至整首詩,從頭再來。在過程中,它會反复檢查格律要求以及是否符合題意。這些 pattern,如反思 (reflection)、驗算 (verify)、大循環(推翻重來)、審題等,與其在數學問題上的表現幾乎一模一樣。

他也提到存在難以泛化的領域。例如,將一個擅长數學推理的模型應用於博弈類問題(如鬥地主殘局)時,模型會顯示出很多無效思考和低級錯誤。這是因為博弈問題的思考模式與數學套路不同,它更傾向於最大最小化 (min-max) 的思路。所谓最大最小化,指的是模型需要考慮對手可能採取的最佳行動(最大化對手的收益),然後在這個基礎上,選擇自己的行動來盡可能降低對手的這個最佳收益(最小化自己的損失或對手的收益)。這是 O1 在數學數據上未能掌握的一類思維 pattern。這表明模型的泛化能力雖然強大,但仍然需要相應的數據來激發特定的思考 pattern

思維鏈不会凭空而来

針對他們在視覺空間 CoT 嘗試中遇到的泛化問題(給圖像做圈點、批注的數據訓練效果泛化不足),張祥雨分析認為,這是因為他們用合成的數據,其 pattern 過於固定。更重要的是,這種精細化的「在圖上圈點批注」類的 CoT 數據,在自然的預訓練語料中(特別是常用的圖文交錯語料)是極度缺乏的

他解釋說,O1 能激發出強大的泛化 pattern,是因為那些經驗證有效的反思 pattern,如 wait, alternative, recheck, validate 等,雖然在預訓練語料中數量非常少 (sparse),但確實存在。例如,在 MathOverflow 這樣的高品質論壇上,一些高讚答案會展示嘗試、發現問題、反思、重試、驗算等過程。當 RL 在 dataset 階段將這些 pattern 激發並強化時,由於這些 pattern 在預訓練語料中稀疏地散布且涵蓋不同領域,模型就能順帶將與這些語料相關的廣泛領域融會貫通,實現強大的泛化

相比之下,他們合成的視覺 CoT 數據因為在預訓練語料中沒有這種 pattern 的呼應,導致無法激發出預訓練模型中更廣泛的模式,因此泛化性就差。這也印證了 RL 並不能無中生有地發現新東西,所有的知識或能力都需要在預訓練中已有分布

張祥雨還強調,預訓練語料的質量非常關鍵。那些思維特別跳躍、省略大量中間步驟的語言材料(例如國內論壇上喜歡用「注意到」直接跳到結論的風格),對於模型預訓練來說可能是災難性的。這種語料阻礙了模型學習紮實的推理思維鏈

大模型螺旋式上升的挑戰

張祥雨指出,大型模型的發展可以視為由 「底層算法」或「優化方法」 (橫軸) 和 「模態」 (縱軸) 這 兩根軸 共同驅動的,並呈現一種 螺旋上升 的趨勢。

這兩個軸的 起點 分別是:優化方法的起點是「next token prediction 的發現」,而 模態的起點是「語言,自然語言」

Next Token Prediction (NTP) 這種算法最初在 文本領域非常成功,是支撐第一代大型模型 (如 GPT 系列) 崛起的基礎算法。它的核心原理是建模对下一个词元的序列条件概率,透過對數據進行壓縮,來學習知識和獲得一定的智能。

然而,這種純粹基於壓縮的 Next Token Prediction 方法,在推進大模型發展的過程中,在兩個方向上都遇到了 挑戰和瓶頸

在純語言模型 (LLM) 方面: 雖然模型的通用對話能力、情商、和知識量隨著模型變大而變強,但其 推理能力(尤其是數學和邏輯) 的表現卻呈現 先上升後平緩,再擴大反而下降 的怪現象。張祥雨認為,這是 Next Token Prediction 的 本質缺陷 所導致的。因為 更大的壓縮率未必對應更高的計算精度。模型為了提高壓縮率,傾向於 跳過中間步驟,直接「一口爆」出結果。這在複雜的數學題或其他需要長鏈推理的問題中,會累積錯誤,導致最終的正確率大幅下降。

在多模態方面: 試圖將 NTP 範式遷移到更多模態(特別是視覺)的過程中,也 反覆碰壁。雖然可以將視覺數據 Token 化並與文本交錯訓練,實現了不錯的圖像理解效果,但 圖像的生成和理解難以融合。現有的圖像生成方法 (如 Auto-regressive 或 Diffusion) 仍然處於類似於語言模型的「一口爆」時代,需要單步完成複雜的生成任務,而其所需複雜度 明顯超過了 Transformer 單步推理的上限。這導致生成的 可控性非常差,即使模型本身知道生成結果不符合常識,也無法控制。這種簡單的生成理解一體化嘗試,並未達到預期效果,视觉理解与视觉生成的效果沒有疊加,1+1没有大于2的效应,甚至可以移除生成部分而不影響理解部分。這中間 缺失了重要的一環:類似於語言模型的 CoT (思維鏈)

正因為純粹基於壓縮的 Next Token Prediction 在語言推理和多模態融合上都顯現出瓶頸,這成為了引入 強化學習 (RL) 推理模型新范式的重要背景。RL 的核心優勢在於它可以 「直接面向目標優化」,而不是間接透過擬合分布或最大化壓縮率。透過 RL,模型被鼓勵去找到最能達成目標的路徑,這能夠 克服 Next Token Prediction 的一些缺陷 (例如減少跳步、提高穩定性)。張祥雨認為,O1 系列模型之所以成功,核心就在於引入了 RL 來激發並強化了 思維鏈的 pattern,甚至是一種 Meta-CoT,這使得模型能夠在不同的思考路徑中切換以解決複雜問題。RL 這種面向目標優化的方式,使得許多之前難以解決的問題(包括語言模型的推理能力和多模態的生成理解一體化),一下子盤活了思路,有了解法

AI的智能分类及其底层算法

根據張祥雨在訪談中的觀點,他將大模型的發展和OpenAI的智能演進路徑與底層算法的迭代關聯起來。他認為,OpenAI的五級智能分類法非常有邏輯,其背後隱含著每一代分級都需要一個全新的算法產生:

  1. 第一級:Chatbot (聊天機器人)
    • 對應的算法基礎是 Next Token Prediction (NTP)
  2. 第二級:Reasoning (推理)
    • 對應的算法基礎是 強化學習 (RL),特別是激發強思維鏈(Strong CoT)和元思維鏈(Meta-CoT)的能力。O1系列模型被視為這個範式的代表。
  3. 第三級:Agent (智能體)
    • 張祥雨認為,這一級對應的算法基礎是 自主學習(Autonomous Learning)和線上學習(Online Learning)

關於 Agent 的定義,張祥雨在訪談中也對社群中現行的說法進行了澄清:

  • OpenAI 體系中的 Agent (Level 3): 強調其 自主性(autonomy)。這意味著它不需要大量人工設計的規則或環境。它能夠獨立工作、自我進化,需要自己尋找目標、探索環境並從中學習其價值。這要求的是自主學習和線上學習這樣的新算法。
  • 現在社群討論的 Agent 應用: 張祥雨認為,這類 Agent 更多的是基於强化推理的這一代模型 (即基於RL的模型),強調的是 Function Call 或 Tool Use (工具使用)。這類 Agent 仍然是根據外界的標準或 KPI (關鍵績效指標) 來優化目標。你可以將其理解為推理模型的工具,它們將一系列系統串聯起來,並有一個統一的 KPI 讓模型去最大化。
  • Chatbot 時代的早期 Agent: 屬於 Next Token Prediction (NTP) 算法的那一代。這類 Agent 通常是 Hand-crafted pipeline (手工設計的流程),透過 Prompt Engineering 來定義其中的步驟或 Agent 行為。

當前的積極趨勢和進展

張祥雨觀察到一些令人鼓舞的跡象。他提到,目前的圖像生成在可控性上已經做得不錯,例如备受欢迎的 GPT4o native 图像生成能力以及Gemini 的最新進展。他認為,如果能夠限制問題領域 (Domain),清洗好數據,並專注於不需要複雜推理、可以「一口爆」解決的指令型任務高可控的圖像生成和編輯是完全可行的。例如,執行圖片上的位移、連接線條等指令,這些任務的複雜度較低,可以在單一步驟內完成。他認為,海外同行(特別是美國)在推理模型的認知和實踐上確實走在前面。

高可控生成與視覺理解的關係

張祥雨提出,具備初步生成和理解能力、能夠執行指令型图片生成的模型可以作為起點。有了這種能夠在圖像上執行基本操作(如圈點、批註、編輯)的能力,就可以將其作為思維鏈的「動作空間」。這樣,帶有 CoT 的視覺理解就可以做了。

未來的「GPT-4 時刻」 張祥雨預見未來两年可能會有至少兩個「GPT-4 時刻」。

    • 多模態推理的 GPT-4 時刻:他認為下一個多模態的 GPT-4 時刻可能會在一年以內實現。這將是實現真正的視覺空間 CoT 和多模態理解生成一體化的關鍵一步。
    • 自主學習/在線學習的 GPT-4 時刻:他認為由 RL 引導的下一代自主學習和在線學習是一個重要的方向,並且是目前學術界的研究熱點。這是一個更大的目標,可能需要兩到三年實現,但也有可能在兩年內出现突破。自主學習被認為是實現 AGI 最重要的路徑之一。

關於 Long Context 的不同看法

張祥雨對當前業界一味強調 Long Context 建模持有不同看法。他認為:

    • 人類記憶的分層結構:人類的記憶系統是分層的,包括短期記憶(或稱工作記憶,working memory,約 2-4 秒,無損且精確但持續時間短)、具有延遲性和遺忘機制的中期記憶(海馬體記憶, semantic memory,非常重要)、以及固化在神经「參數」中的長期記憶。
    • Long Context Window 的局限性:目前的 Long Context Window 雖然增加了信息容量,但並未解決如何有效地利用信息的問題。Context 中的 token 缺乏足夠的壓縮、抽取、分層和遺忘
    • 「大海撈針」任務的誤導性:他認為 Long Context 建模經常在評估中強調像「大海撈針」這樣的 Retrieval 任務。這種任務鼓勵模型記住所有信息,這實際上是「反智」的,因為不經過壓縮就無法產生智能。
    • Long Context 阻礙智能增長:他認為一味追求超長上下文來解決問題的路線是錯誤的,這阻礙了智能的增長。相比之下,人類的記憶模式更像 RNN,有處理無限序列的能力,但不是簡單地記住越來越長的歷史。
    • 情景隔離和上下文干擾:人類擁有強大的情景隔離能力,可以隨時切換 Context。而一味追求 Long Context 的模型缺乏這種能力,上下文變長必然引起嚴重的上下文干擾,導致模型性能下降。

多模型協作與擴充思維鏈

張祥雨提出了一種替代 Long Context 的方法,尤其是在處理 Retrieval 任務時。他認為:

    • 多 Agent 協作處理 Retrieval:在當前的 Function Call 時代,Retrieval 任務應該通過多模型或 Agent 的協作來解決,而不是依賴於無限擴大的工作記憶。
    • 建議的架構思路:可以利用類似 Linear Transformer 的模型建立全局(無限長序列)的概念,同時使用一個小窗口的普通 LLM 作為工作記憶。結合擴充的思維鏈和調用工具(廣義工具,包括調用其他 LM)的能力,可以更有效地管理上下文,比直接擴大上下文窗口更節省上下文并增强性能
    • O3 長推理的推測:關於 O3 能夠連續進行數百萬甚至數千萬 Token 的長時間推理,他推測這不大可能是簡單地依賴巨大的上下文窗口。更可能是通過多模型協同在強化學習框架下實現的。例如,一個規劃模型 (Plan Model) 負責在高層次決定推理的路徑 (Pattern),將具體的計算或執行任務交給另一個計算模型 (Computation Model),這個計算模型不需要巨大的工作記憶或保留完整的歷史上下文。這種雙模型體系(或其他多模型體系)雖然看上去像是簡單的 Pipeline 或模型拼接,常被認為不如端到端方法,但實際上也可以在 RL 框架下實現端到端的訓練
    • 功能分化與上下文裁剪:多模型協作類似於人腦的不同腦區的功能分化。在 RL 訓練過程中,模型可以為了達到最終目標(例如,學會不讓單個模型的上下文「爆掉」),自然而然地學會不斷裁剪和管理上下文的模式
    • RL 面向目標優化:總之,RL 新范式面向最終目標進行優化,可以盤活很多思路,使得系統能夠學會如何有效地利用有限的資源(如上下文窗口)來解決複雜問題。

多模态大模型的发展方向

展望視覺推理和多模態 CoT 的未來,他認為有兩條主要的發展方向:

    1. 擴充預訓練語料,增加 CoT 素材。他認為視頻是一個非常確定的方向,其中包含大量的教學過程、老師的演示(使用激光筆、打草稿、連輔助線等),這些都能提供豐富的 CoT 過程數據。主要難點在於視頻數據的清洗和如何有效挖掘這些數據。
    2. 進一步擴展動作空間。他認為目前在圖像上做簡單編輯(圈點、批注、放大、裁剪等)的動作空間太有限。很多問題需要的是重新打草稿或重新生成的能力。他設想如果能有這樣一個具備初步生成和理解能力(能執行指令型 的生成)的模型作為起點,它可以在任何需要的地方產生輸出,並且輸出的結果可以被後續的思維鏈修正。這樣就能做到在視覺空間上真正的 CoT 生成,實現廣義上的理解,解決需要空間想像或畫草圖的問題。這是他想像中下一個「多模態的 GPT-4 時刻」。

自主學習的核心:實現真正的自主學習需要解決多個前置問題,其中最關鍵的是從環境中獲取和利用反饋的能力(尤其是從自然語言或其他非結構化反饋中學習如何改進)。此外,還需要無限長序列的建模能力(環境是動態無限的)和如何設計「內生獎勵」來驅動模型自我學習和進化。

RL 的挑戰與未來方向

RL(強化學習)作為推動模型發展到推理這一代的重要算法,雖然解決了 Next Token Prediction 在推理和多模態融合上的一些瓶頸(例如克服了跳步、提高了長鏈推理的穩定性、讓多模態融合的思路變得可行),但也面臨著新的挑戰:

    • Rule-based 的局限性:目前的 Rule-based RL 方法是有效的,但對於沒有明確評價標準或包含主觀性的問題存在局限性。Rule-based 的標註或獎勵是外部給予的(好比 KPI),而人類的行為並不總是在優化 KPI,它有自己的偏好,這是內在的、自驅的力量
    • 難以利用多維度反饋:目前的 RL 方法難以有效地利用人類給予的多維度、非結構化的反饋(例如老师對一篇文章多方面的評價)。這些豐富的信息往往被簡化為一個單一的分數作为奖励,这就導致模型難以理解如何改進。
    • 環境擴展的困難 (Environment Scaling):這是一個在模型規模化、數據規模化和算力規模化之后的新挑戰。基於規則的 RL需要為不同的任務或問題手動搭建環境,並構造對應的數據或評價標準。張祥雨指出,這種效率非常低,難以擴展。人類則能夠自驅地探索環境、從環境的反饋中學習
    • 丢失多維度打分細節: 目前的 RL,尤其是在處理人類反饋時,難以有效利用豐富、多維度的自然語言評價(例如老師對作文的詳細評語)。這些評價通常被簡化並加權成為一個單一的獎勵分數。模型很難從這個乾巴巴的數字中理解具體的改進方向,丟失了大量有用的信息,這使得模型學習效率低下。

空间智能与世界模型

最後,關於李飛飛的空間智能和 LeCun 的世界模型,以及與視覺生成和具身智能的關係:

    • 張祥雨認為,Yann LeCun 關於世界模型的看法很有道理。特別是 LeCun 提到 人身上沒有視覺生成器官,這點極具啟發性。人類雖然可以在大腦中想像未來,但並非必須將其視覺化生成。這與人類擁有世界模型的能力有關。學習世界模型的方式對於人類來說可能更傾向於非生成式。
    • 然而,對於當前的 AGI 發展路徑(特別是在視覺領域),生成能力 可能是一種更方便獲取訓練數據(如透過生成合成數據)或監督信號的方式。
    • 至於空間智能 (例如視覺空間上的 CoT) 及其衍生的具身智能 (Embodied Intelligence),包括機器人控制和自動駕駛,張祥雨認為目前的通用智能水平遠遠還沒有達到能夠普遍解決這些問題的程度,目前 AI 仍然在為視覺能力而掙扎。
    • 但他同時指出,具身智能領域(包括自動駕駛)正在「搶跑」(running ahead)。這並非因為通用智能已達到要求,而是因為這些領域的 問題、控制維度和應用場景相對更局限和特定。它們可以透過一些基於規則的方法或模塊化拼裝的方式先實現一些應用。然而,這些領域的趨勢也在走向端到端,當它們與未來發展的視覺推理或多模態推理徹底整合時,終將會與 AGI 的主線會合。

總結來說,大模型的發展是算法和模態螺旋上升的過程,NTP是起點但有其本質缺陷,RL解決了部分問題並引入了新的挑戰(特別是環境和反饋的scaling),而OpenAI體系中的下一代Agent將需要自主學習和線上學習的能力。雖然人類學習世界模型的方式可能非生成式,但當前AGI在視覺等領域的進展可能仍需藉助生成。具身智能等領域正在特定場景下先行發展,但最終將匯入通用AGI的洪流。

 

原访谈很精彩,有认知高度,也有第一线的实践,还有很多金句,见:
https://zhuanlan.zhihu.com/p/1913377304173872183

LLM的后训练强化学习是怎么工作的

立委按:LLM的强化学习后训练是当前热点,也是最新思维链(CoT)推理模型范式的红利期。推理强化后的模型在复杂任务的表现上普遍性能提升。强化后训练的新范式正在不断推广到不同场景,而且也在多模态方面取得进展。应该是了解一点强化学习的基本工作流程的时候了。

一、训练阶段:延迟奖励如何影响参数更新

1.1 生成一个完整序列(Trajectory)之后才拿到奖励

    • 在 基于策略梯度的强化学习( RL)里,模型先“自下而上”采样生成一段文本,一般称为一个序列或轨迹(trajectory)。
    • 当整段文本生成完毕,才传给奖励模型或人类评审打分,得到一个序列级别的总奖励 R。这个奖励是对整段生成结果的“后验评价”。

1.2 把“序列级别奖励”拆给每一步“选择词元”的策略

    • 策略梯度(Policy Gradient)方法的核心是:用“生成过程中每一步输出的 log 概率”去乘以“那个序列最终的奖励”或“优势值(advantage)”,从而形成梯度,来更新模型参数。
    • 具体公式(简化版):
    • 看起来好像“序列级别只有一个 R”,但在公式里,它会被“复制”到每个时间步,也就是说“同一个奖励”会乘以这一序列中所有 log⁡π之和,变成一个总梯度——最终作用于参数更新。换句话说:
      • 如果这整段话拿了 10 分,那每一步生成那个概率就会“拿到正向信号”;
      • 如果这整段话只拿了 2 分,那每一步概率都会“拿到负向信号”。

1.3 参数更新:一次性影响整个生成过程中的每一步

在拿到梯度之后,往往用类似 PPO(Proximal Policy Optimization)的算法做一次“裁剪式更新”:

      1. 先计算出这段轨迹里旧策略的每一步的 log π_old(a_t|s_t),也记录下 R(τ)
      2. 然后在同样的状态序列(同样的前缀)下,让新策略再次计算一次 log π_new(a_t|s_t)
      3. 用“新旧策略的比值”去乘以“奖励或优势值”,并加上 PPO 的剪切项,算出损失。
      4. 再用梯度下降/上升一次性更新参数 θ

整个过程只迭代几轮(若干个序列)就能让策略“尽量往高奖励方向”靠拢,同时保持与旧策略“不要偏差太大”以免训练不稳定。核心思路:采样→拿到 R→把奖励和每一步的 log-prob 相乘→算梯度→更新参数

完成一次更新后,策略参数 θ 变成 θ_new;下一轮又回到“冻结策略→再采样→再更新”的循环。


二、“旧策略”和“新策略”的含义

  1. 模型参数不变,策略就是“固定不变”的

——至少在一次完整的生成(rollout)或一次训练迭代里,它的参数 θ 保持不动,策略自然不变

策略=“这个 state 下网络给我的下一个 action 打了哪些分,在语言模型就是网络根据当前 context 计算出来的next token 的概率分布”

    • 在训练里,一轮 rollout/采样结束后,你会根据奖励/损失去更新参数 θ,此后策略才会变成“新的策略 π_θ。但在“采样这段对话/文本”的整个过程中,θ 不变,所以策略函数 π_θ(⋅∣s) 也是不变的。

  1. 旧策略(π_old)

    • 是“收集轨迹时”的那一套模型参数下的策略网络。

    • 换句话说,你让模型在环境(或是对话上下文)里按照 π_old 去采样,得到了 N 条“(状态₁,动作₁)→(状态₂,动作₂)→ … →(状态_T, 动作_T)”的完整轨迹。

    • 在收集完这些轨迹后,你把这些轨迹连同 π_old 在每一步的 log π_old(a_t|s_t)(或者直接存储下来的 probs)一起都记录下来。这个“旧策略”相当于一个“快照”,是收集数据时的分布。

  2. 新策略(π_new)

    • 是“在更新参数过程中所使用的那套参数”——也就是我们正在训练的、会随着梯度下降而不断变化的策略网络。

    • 一旦开始做梯度更新,就会用当前那一刻的网络参数去计算“新策略输出的 log π_new(a_t|s_t)”。随着每一次梯度步,新策略的参数都会微调,这时 π_new(a_t|s_t) 就可能和旧策略 π_old(a_t|s_t) 不再相同。

核心思路

  1. 收集轨迹阶段:

    • 在策略还是 π_old 的时候,让它去环境里跑几千个或几万个 steps,把完整的“状态→动作→奖励→下一个状态”都存下来,连同当时的 log π_old(a_t|s_t)。

    • 由于在这一步,你还未做过任何梯度更新,所以“新策略”和“旧策略”是同一个网络。此时如果你立刻比较 π_new 和 π_old,它们是完全一样的——比值。但你先把 π_old 的值记下来,后面调整参数时就有对比用。

  2. 优化阶段:

    • 接下来,你拿到这批已经收集好的轨迹,开始做多轮(多个 epoch)小批量(mini-batch)的梯度更新。

    • 在做第 1 次梯度更新时,虽然此刻的“新策略”参数 θ 与“旧策略”参数(收集时的快照)是一模一样的,但你仍然把它们区分开来

      • π_old 作为“分母”是个常数(保留收集轨迹时计算出来的概率值),不会随梯度变化。

      • π_new 作为分子,用来重新在网络里跑一遍“给定同一个 s_t,计算当前参数下采样 a_t 的概率”——也就是 log π_new(a_t|s_t)

      • 从第 1 步到第 k 步,你都会做相同流程:把“旧 log π_old” 和“新 log π_new” 一起塞进目标函数里,再做梯度更新。梯度实际上来自于“新策略”下的 log π_new(a_t|s_t) 与“旧策略” log π_old(a_t|s_t) 的比值,因为你要优化的是 让比值往有利于大优势值 A_t 的方向调整

三、推理阶段:使用训练好的策略

    • 推理(Inference)阶段的模型权重已经固定,原本训练中“等生成完整序列才给分”的那套机制,在推理时已经不再用到——你只需要让模型按学到的“策略”来采样(sampling)或贪心(greedy)或 Beam Search,就可以一步步生成文本。
    • “延迟奖励”不影响推理:模型在训练时学到的是“哪种写法往往能拿高分”,它把这些偏好都编码进了参数里。推理阶段只负责“按概率分布一步步抽词”,不再需要知道“这个序列最终打了几分”。

小结

所以,重点就在于

  • 采样:用旧策略(现策略)拿到“随机生成的具体文本”以便算 reward。在采样阶段,模型参数不变,策略自然不变。

  • reward:只能在“采样出具体文本 τ”后才能得出。

  • 更新:等到我们从多条 τ 上都获取了 reward,再去把这些“sequence-level feedback”切片到每一步,算出梯度更新策略/参数。

 

大模型科普:探秘莎翁风格的诞生之旅(无代码版)

立委按:鉴于语言大模型GPT的重要性,特此根据AI大神Karpathy的nanoGPT讲座,编纂此科普系列,计五篇,其中此篇没有代码和数学公式,是最通俗的科普。其他四篇包括一篇英文,均附带可验证的Python代码,并给予不同角度的详细解说,面对有工程背景的对象。

ChatGPT这样的大语言模型在今天已展现出惊人的能力:它们能与人对话,辅助创作,甚至独立生成颇具文采的诗篇。这不禁引人深思:大模型是如何理解并运用复杂的人类语言的呢?本文将以大模型传教士Karpathy简化的迷你版nanoGPT模型为例,揭示其学习模仿大文豪莎士比亚风格的奥秘。

核心机制:预测下一个字词

大模型学习过程核心机制之一在于对一句话或一段文字里,接下来会出现哪个字或哪个词的预测。在文本领域,这意味着当nanoGPT接收到一句话的前半部分,例如“生存还是毁灭,这是一个…”,它需要根据已有的信息,推断出最有可能紧随其后的词语,比如“问题”。我们所讨论的这个莎翁风格,其核心训练目标,就是在莎士比亚所有作品的文字里,当读到某处时,能精准地猜出下一个字是什么。

第一步:数据的数字化——AI的“识字”过程

nanoGPT的第一个挑战在于,它难以直接理解人类的文字符号。计算机系统以数字为基础进行运算。因此,首要任务是将莎士比亚的文本转化为机器能够处理的数字形式。

  1. 训练语料的准备:在这个例子中,即莎士比亚的全部剧作。这些文本数据经过收集和整理,作为nanoGPT学习的材料。
  2. 构建字符“密码本”:接下来,nanoGPT会构建一本特殊的“字典”或“密码本”。在这本“密码本”里,莎士比亚作品中出现的每一个独立字符(字母、标点符号等)都被赋予一个独一无二的数字代号。例如,“T”可能对应38,“o”对应33,空格对应0等等。通过这种方式,一句“To be or not to be”在AI内部就表示为一串特定的数字序列。反之,AI也能用这本“密码本”,把数字代码“翻译”回我们能读懂的文字。

第二步:赋予数字上下文含义——“数字档案”的建立

仅仅将字符转化为孤立的、互不相关的数字代号是不够的。nanoGPT需要一种方式来捕捉这些代号背后的“意义/特性”以及它们在特定上下文中的“角色”。这就是“嵌入”(Embedding)技术发挥作用的地方。

  1. 字符嵌入:为了让nanoGPT理解这些数字代号的“含义”和它们之间的联系,科学家们发明了一种叫做“嵌入”(Embedding)的技术。可以把它想象成,给每个字(或词)都创建了一份独特的“数字档案”。这份档案不是一个简单的数字,而是一组特定长度的、精心计算出来的数字(专业上称为向量)。这组数字就像这个字的“多维度评分”,从不同方面描述了它的特性。比如,“国王”和“王后”的数字档案,在代表“皇室”的那个维度上评分可能都比较高,而“苹果”和“香蕉”则在代表“水果”的维度上评分高。这样,意思相近的字,它们的“数字档案”也会比较相似。
  2. 位置嵌入:语言中,字词的顺序也重要。“国王杀了王后”与“王后杀了国王”的含义天差地别。因此,nanoGPT不仅要知道每个字是什么,还要知道它在句子里的位置。所以,每个位置(比如第一个字、第二个字……)也会有自己的一份独特的“位置数字档案”。

最终,输入序列中一个字符的初始信息,就是它自身的“特征数字档案”和它所在“位置数字档案”的结合。这样,nanoGPT拿到的每个字的信息,既包含了字本身的含义,也包含了它在句子中的顺序信息。

第三步:信息处理的核心——Transformer“工厂”

这是nanoGPT模型进行复杂信息处理和上下文理解的核心部件。你可以把它想象成一个多层加工的“工厂”,每一层流水线都对输入信息进行更深一步的加工和理解。

nanoGPT内一层流水线通常包含以下关键环节:

  1. 掩码自注意力机制:这是Transformer结构的一大亮点。当nanoGPT读到一个字时,它会回顾前面所有读过的字,判断哪些字对理解当前这个字最重要,然后给予这些重要的字更多的“关注”。“掩码”则是因为在猜下一个字是什么的时候,nanoGPT不能“偷看”答案,它只能关注已经出现的字,保证预测的单向性。
  2. 前馈神经网络:这个模块会对信息进行进一步的加工和提炼,让AI的理解更透彻,能够学习到更复杂的文字模式。
  3. “快速通道”与“信息质检”(残差连接与层归一化):这些是帮助AI工厂高效运转的辅助设计。
    • 为了防止信息在多层工厂的传递中失真或减弱,工厂里还有“快速通道”(专业上叫残差连接),允许一部分原始信息直接“跳”到后面的工序,保证重要信息不丢失,使得AI可以构建更深的工厂层级有效学习。
    • 同时,每一道工序后,还有“质检员”(专业上叫层归一化)会把信息“整理”一下,让信息更“规整”,加速学习过程。

在nanoGPT中,通常会堆叠多个这样的加工层。每一层都在前一层的基础上进行更抽象的规律性提取,并把它们和上下文联系起来进行综合理解。

第四步:生成预测——输出结果

经过多层的深度处理后,nanoGPT对输入序列的每个字符都生成了一个包含了丰富上下文信息的数字总结。现在,需要将这个内部总结转化为对下一个字符的具体预测。

这通常通过以下步骤完成:

  1. 一个“最终决策转换器”(专业上叫线性层)会将这个数字总结转换成对词汇表中所有候选字的“原始打分”。每个字都有一个分数,分数高低代表nanoGPT判断它作为下一个字的可能性。
  2. 然后,另一个部件(专业上叫Softmax函数)会把这些“原始打分”转换成每个候选字作为正确答案的“可能性百分比”。可能性越高的字,模型就越认为它应该是正确的下一个字。

第五步:从经验中学习——模型的训练过程

nanoGPT模型并非一开始就能准确预测。它需要通过一个称为“训练”的过程,从大量的样本数据中学习规律。

  1. 数据准备(输入与目标):从训练语料(莎士比亚剧作)中,选取一段文本序列作为模型的输入(例如,“To be or not to b”),并将其真实的下一个字符(“e”)作为期望的输出(标准答案)。
  2. 损失计算(衡量差距):GPT根据输入序列进行预测,得到一个关于下一个字符的“可能性百分比”列表。然后,将这个预测结果与标准答案进行比较,一个叫“损失函数”的裁判来打分,衡量nanoGPT的答案和标准答案之间的“差距”或“错误程度”。差距越大,说明GPT错得越厉害。
  3. 参数优化(“复盘”与调整):训练的目标是让这个“差距”尽可能小。nanoGPT会启动一个“复盘机制”(专业上叫反向传播算法),仔细分析这次错误是哪些内部环节没做好导致的,并计算出每个内部“小齿轮”(即模型中可调整的参数)应该朝哪个方向、调整多少才能减少错误。接着,一个“总工程师”(专业上叫优化器)会根据分析结果,对nanoGPT内部的这些“小齿轮”进行微小的调整,目标是让nanoGPT下次遇到类似情况时表现得更好一些。

这个“输入-预测-计算差距-复盘调整”的迭代过程会重复进行成千上万甚至上亿次。每一次迭代,模型都会从错误中学习,逐渐提升其预测的准确性,从而更好地捕捉莎士比亚文本的语言模式。

第六步:文本生成

当nanoGPT训练到一定程度后,就可以用它来生成新的、具有莎士比亚风格的文本了。

  1. 起始提示(Prompt):可以给nanoGPT一个初始的文本片段(prompt)作为生成的起点,例如“ROMEO:”。
  2. 迭代生成过程
    • 模型接收当前已生成的文本序列作为上下文。
    • 模型进行一次完整的处理和计算过程(如第四步所述),预测下一个最可能的字符,即从“可能性百分比”列表中按概率抽取一个字符。
    • 将新生成的字符追加到当前序列的末尾。
    • 重复以上步骤,直到达到预设的生成长度或遇到特定的终止标记。
  3. 控制生成的多样性与质量
    • 温度(Temperature):在计算“可能性百分比”之前,可以对“原始打分”进行调整。调低“温度”,AI会更倾向于选择那些分数最高的字,写出来的东西更确定、更保守。调高“温度”,GPT则会更大胆,愿意尝试不那么常见的字,可能会更有创意,但也可能更容易“跑题”。
    • Top-K采样 / Top-P (Nucleus) 采样:这些技术像是给AI的选择加了个“筛选器”。比如,只允许nanoGPT从分数最高的K个字里选,或者从那些加起来可能性超过一定百分比(P)的一小撮字里选。这有助于避免nanoGPT选到非常不靠谱的字,让生成的文本更连贯。

通过这些机制,nanoGPT模型就能够一句句模仿莎士比亚风格的文本。

从简化模型nanoGPT到大型语言模型

本文描述的模仿莎士比亚风格的nanoGPT是一个高度简化的示例。现实中的大型语言模型(LLMs),如OpenAI GPT系列,其核心原理(如Transformer结构、预测下一个词元等)与此相同,但有着显著的量级和复杂度差异:

  • 模型规模:内部“小齿轮”(参数)的数量可达千亿甚至万亿级别,远超简化模型的规模。
  • 数据规模:训练数据量是TB乃至PB级别(1 PB = 1024 TB,1 TB = 1024 GB),来源极其广泛,不仅仅是单一作者的作品,几乎涵盖了互联网上公开的绝大部分文字。
  • 词元化(Tokenization):它们处理的单位比字符大,叫做“词元”(token)。一个词元可能是一个完整的词,也可能是一个词的一部分(比如英语中的“un-”、“-able”这样的前后缀),甚至是单个字母。这种方式更灵活,能更有效地处理各种词汇、生僻词和复杂词形。
  • 训练技术与资源:涉及更复杂的训练策略、使用成百上千台计算机协同工作(分布式计算)、海量的计算资源以及更长的训练周期(数周甚至数月)。
  • 对齐技术:大型模型还会经过更高级的后续“特训”,比如让它们学习理解并遵循人类给出的各种指令(这叫指令微调),或者根据人类对它们生成内容的评价好坏来不断改进(这叫基于人类反馈的强化学习)。这些步骤能让大型GPT的行为更符合我们的期望、指令和社会的价值观。

结语

通过对这个简化AI模型nonoGPT的剖析,我们可以看到,GPT这类模型基于对大量文本数据中复杂模式的统计学习,基于这些规律进行的语言接龙的概率预测。从简单的字符预测任务出发,nanoGPT借助Transformer结构、莎士比亚全集数据和强大的计算能力,AI能够学习并模仿出高度复杂的语言风格。理解GPT背后的机制,有助于我们更理性地看待AI大模型的能力边界,并思考其在未来社会和文化领域中可能扮演的角色。

 

GPT科普系列

揭秘GPT内核之四

Karpathy's nanoGPT:从零理解莎士比亚生成器

立委按:鉴于语言大模型GPT的重要性,特此根据AI大神Karpathy的nanoGPT讲座,编纂此科普系列,计五篇,一篇没有代码和数学公式,是最通俗的科普。其他四篇包括一篇英文,均附带可验证的Python代码,并给予不同角度的详细解说,面对有一定工程背景的对象。

你可能已经听说过GPT(Generative Pre-trained Transformer)的鼎鼎大名,无论是能与你流畅对话的ChatGPT,还是能帮你写代码、写诗歌的AI助手,它们背后都有GPT的强大身影。但是,这个神奇的“黑箱”究竟是如何运作的呢?

今天,我们就以一个“迷你版”的莎士比亚风格文本生成器为例,一步步拆解GPT的构造,让你从零开始,彻底搞懂它的核心原理。别担心,我们会用最通俗易懂的语言,结合具体的代码示例,让你看清这背后的“魔法”。

核心思想:预测下一个“词”(词元或字符)

GPT最核心的任务,说白了就是预测序列中的下一个元素。对于文本来说,就是预测下一个单词或下一个字符。我们给它一段话,它会猜接下来最可能出现什么。

在我们的莎士比亚生成器中,模型学习的就是预测莎士比亚剧本中的下一个字符是什么。比如,看到 "To be or not to b",它应该能预测出下一个字符是 "e"。

# 训练数据中,y 就是 x 的下一个字符序列
# input x: "To be or not to b"
# output y: "o be or not to be"
# 比如 train_data[i:i+block_size] 是输入 x
# train_data[i+1:i+block_size+1] 就是目标 y

第一步:让计算机“认识”文字 - 数据与词汇表

计算机不认识人类的文字,它们只懂数字。所以,第一步就是把文字转换成计算机能理解的格式。

  1. 准备“教材”(输入数据):
    我们首先需要大量的文本数据作为模型的“教材”。在这个例子中,就是莎士比亚的剧作 (input.txt)。这些数据会被预处理并保存为二进制格式 (train.bin) 以便高效加载。
  2. 构建“字典”(词汇表与编码):
    我们需要一个包含所有可能出现的字符的“字典”(词汇表)。对于莎士比亚的文本,这个词汇表可能包含英文字母、数字、标点符号等。
  3. # data/shakespeare_char/input.txt 包含了所有莎士比亚文本

    chars = sorted(list(set(open(os.path.join(data_dir, 'input.txt'), 'r').read())))

    stoi = {ch: i for i, ch in enumerate(chars)} # 字符到索引的映射 (string to integer)

    itos = {i: ch for i, ch in enumerate(chars)} # 索引到字符的映射 (integer to string)

    vocab_size = len(chars) # 词汇表大小,比如65个唯一字符

    ```stoi` (string to integer) 将每个字符映射到一个唯一的数字索引(比如 'a' -> 0, 'b' -> 1)。`itos` (integer to string) 则反过来。

    # 这样,我们就可以用 `encode` 函数将一串字符转换成数字列表,用 `decode` 函数再转换回来。

    ```

    def encode(s): # "hello" -> [40, 37, 44, 44, 47] (假设的映射)

        return [stoi[c] for c in s]

    def decode(l): # [40, 37, 44, 44, 47] -> "hello"

        return ''.join([itos[i] for i in l])

    # 加载训练数据时,train.bin 文件中的内容已经是被 encode 过的数字序列了。

    train_data = torch.frombuffer(

        open(os.path.join(data_dir, 'train.bin'), 'rb').read(),

        dtype=torch.uint16 # 每个数字用16位无符号整数表示

    ).long() # 转换为PyTorch常用的长整型

第二步:赋予字符“意义” - 嵌入层 (Embedding)

虽然我们把字符变成了数字,但这些数字本身并没有“意义”。比如,数字5和数字10之间并没有“更像”或“更不像”的关系。我们需要一种方式来表示字符的含义及其在序列中的位置。这就是嵌入(Embedding)的作用。意义的本质体现在系统关系之中,正如马克思提到人的意义时所说:人是社会关系的总和。数字化实现就是建立一个高维向量的意义空间,用来定义每个词元相对于其他词元的位置,关系则以距离来表示。

  1. 字符嵌入 (Token Embedding):
    我们为词汇表中的每个字符学习一个固定长度的向量(一串数字),这个向量就代表了这个字符的“意义”或“特征”。想象一下,在一个高维空间中,意思相近的字符它们的向量也可能更接近。
    # n_embd 是嵌入向量的维度,比如128

    self.embedding = nn.Embedding(vocab_size, n_embd)

    # 输入一个字符索引,输出一个128维的向量
    例如,字符 'a' (索引可能是0) 会被映射成一个128维的向量 [0.1, -0.2, ..., 0.5]。
  2. 位置嵌入 (Positional Embedding):
    在语言中,顺序会影响意义。“国王杀了王后”和“王后杀了国王”意思完全不同。因此,我们还需要告诉模型每个字符在句子中的位置。位置嵌入就是为每个位置(比如第0个字符,第1个字符……)学习一个向量。
    # 假设句子最长不超过1000个字符

    self.pos_embedding = nn.Embedding(1000, n_embd)

    # 输入一个位置索引,输出一个128维的向量。
    # 最终,一个字符在特定位置的表示,是它的字符嵌入向量和它所在位置的嵌入向量相加得到的。
    # x 是输入的字符索引序列,形状为 (批量大小, 序列长度)
    # pos 是位置索引序列,形状为 (1, 序列长度)
    # 结果 x_embedded 的形状是 (批量大小, 序列长度, 嵌入维度)

    x_embedded = self.embedding(x) + self.pos_embedding(pos)

第三步:神奇的“思考机器” - Transformer 

这是GPT的核心部件,负责理解上下文信息并进行“思考”。我们的莎士比亚生成器用的是Transformer的解码器层 (Decoder Layer)

一个Transformer解码器层主要包含以下几个部分:

  1. 因果掩码 (Causal Mask):

    在预测下一个字符时,模型只能看到它前面的字符,不能“偷看”答案。因果掩码就像给模型戴上了“眼罩”,确保它在预测第 t 个字符时,只使用第 0 到 t-1 个字符的信息。
    # t 是序列长度

    # mask 是一个上三角矩阵,对角线以上为True (masked)

    # [[False,  True,  True,  True],
    #  [False, False,  True,  True],
    #  [False, False, False,  True],
    #  [False, False, False, False]]

    mask = torch.triu(torch.ones(t, t), diagonal=1).bool()
  2. 计算注意力权重的过程

    在自注意力层,每个token的Query矩阵与上下文窗口中所有tokens的Key 矩阵转置相乘,这样就得到了该token对所有tokens的注意力权重(如果掩码,则与下文的tokens权重全部置零)。对于一个包含 B 个序列、每个序列 T 个 token 的批次输入,Query 矩阵形状是 B * T * head_size,Key 矩阵转置后是 B * head_size * T。两者相乘得到一个形状为 B * T * T 的权重矩阵。这个 B * T * T 的矩阵,对于批次中的每一个序列(B 维度),都有一个 T * T 的子矩阵,其中的每一个元素 (i, j) 代表位置 i 的 Query 与位置 j 的 Key 的点积结果,也就是token-i 关注token-j 的原始“亲和力”或“相谐度”。

    上述描述解释了计算注意力分数的核心数学操作:
    Query 矩阵与 Key 矩阵的转置相乘 (Q @ K.transpose(-2, -1)),我们来拆解一下:
     
    假设你有一个序列,长度为 T。对于这个序列中的每一个 token,我们都计算得到一个 Query 向量和一个 Key 向量。假设每个 Q 和 K 向量的维度是 head_size (记为 D)对于整个序列,我们可以把所有 token 的 Query 向量堆叠起来形成一个 Query 矩阵,形状是 (T * D)。同样,所有 Key 向量堆叠形成一个 Key 矩阵,形状也是 (T * D)。
     
    我们想要计算的是:序列中每一个位置 i 的 Query 向量 (Q_i) 与序列中每一个位置 j 的 Key 向量 (K_j) 之间的点积。这个点积 (Q_i . K_j) 就是位置 i 对位置 j 的“注意力分数”或“亲和力”
     
    如果你熟悉矩阵乘法,矩阵 A 乘以矩阵 B 的结果矩阵 C,其元素 C_ij 是 A 的第 i 行与 B 的第 j 列的点积我们想让结果矩阵 C 的元素 C_ij 等于 Q 矩阵的第 i 行 (Q_i) 与 K 矩阵的第 j 行 (K_j) 的点积。要做到这一点,我们需要 Q 矩阵乘以 K 矩阵的转置 (K^T)。
     
    如果 Q 是 (T * D),K 是 (T * D),那么 K 的转置 K^T 就是 (D x T)。进行矩阵乘法
    Q @ K^T: (T * D) @ (D * T) = (T * T)。结果矩阵 (T * T) 的元素在第 i 行、第 j 列的值,正是 Q 矩阵的第 i 行 (Q_i) 与 K^T 矩阵的第 j 列的点积。由于 K^T 的第 j 列就是 K 矩阵的第 j 行 (K_j) 沿列方向排列,这个点积正是我们所要的 Q_i . K_j
     
    考虑批次 (Batch):  当处理多个序列(一个批次)时,PyTorch 中的张量会增加一个批次维度 B。所以 Query 矩阵形状是 (B * T * D),Key 矩阵形状是 (B * T * D)。为了对批次中的每一个序列独立进行上述 (T * D) @ (D * T) 的矩阵乘法,我们需要将 Key 矩阵进行转置,使其形状变为 (B * D * T)。 PyTorch 的批次矩阵乘法 (@torch.bmm) 可以处理这种形状的乘法:(B * T * D) @ (B * D * T) = (B * T * T)
     
    转置的维度: 转置倒数两个维度 (transpose(-2, -1)),这是因为 PyTorch 中批次张量的维度通常是 (Batch, Time, Feature)。Query 和 Key 的形状是 (B, T, head_size)。要得到 (B, head_size, T),我们需要交换 Time (维度 -2) 和 head_size (维度 -1) 这两个维度
     
    所以,转置 Key 矩阵是为了通过标准的矩阵乘法操作,高效地并行计算序列中每一个 Query 向量与每一个 Key 向量之间的点积,从而得到一个表示所有位置之间的 T * T 注意力分数矩阵 (对于每个批次中的序列而言)。

  3. 多头自注意力机制 (Multi-Head Self-Attention):

    这是Transformer的精髓!“自注意力”机制允许模型在处理一个字符时,去关注输入序列中所有其他字符,并判断哪些字符对当前字符的理解最重要。想象一下你在阅读 "The cat sat on the mat." 当你读到 "mat" 时,注意力机制可能会告诉你 "cat" 和 "sat on" 对理解 "mat" 的上下文很重要。

    “多头”则意味着模型可以从多个不同的“角度”或“子空间”去关注信息,捕捉更丰富的关系。比如一个头可能关注语法关系,另一个头可能关注语义关系。
    在解码器中,由于因果掩码的存在,注意力机制只会关注当前位置之前的字符。

    QKV 的分工(Query 用于寻找、Key 用于匹配、Value 用于承载信息)怎么实现的?

    Q, K, V 的分工
    是在自注意力机制的计算公式和结构中实现的。这个结构是固定的:计算 Query 和 Key 的点积得到注意力分数,然后用这些分数加权 Value 向量。这个数学操作本身定义了它们的角色。
     
    如何自然得到分工? 它们具体的“能力”(例如,某个 Query 如何有效地找到相关的 Key,某个 Key 如何有效地表明自身的内容,某个 Value 如何有效地编码有用的信息)是在训练过程中自然学习到的。模型的参数,包括 Q, K, V 线性投影层的权重,会通过反向传播和优化器进行调整,以最小化预测下一个 token 的损失。在这个过程中,这些投影层会学习到权值,使得输入表示 (X) 被投影到能够有效支持注意力计算以提高预测准确性的 Q, K, V 向量空间
     
    这些投影层的权重是在训练开始时初始化的,并且在训练过程中为所有 token 共享(即同一个线性层应用于所有 token 的 X 向量)。所以,不是每个 token 自身有一个固定的初始 Q, K, V 向量,而是每个 token 的初始表示 (X) 通过共享的、已初始化的线性层被投影成 Q, K, V。


  4. 前馈神经网络 (Feed-Forward Network):

    在注意力机制处理完信息后,每个位置的输出会再经过一个简单的前馈神经网络进行进一步的非线性变换,增强模型的表达能力。
    # d_model 是嵌入维度 (n_embd)
    # nhead 是注意力头的数量
    # dim_feedforward 通常是 d_model 的4倍

    nn.TransformerDecoderLayer(
      d_model=n_embd,
      nhead=n_head,
      dim_feedforward=n_embd * 4,
      batch_first=True, # 输入数据的维度顺序是 (批量, 序列, 特征)
      dropout=0.1      # 防止过拟合
    )
  5. 残差连接 (Residual Connections) 和层归一化 (Layer Normalization):

    这些是帮助深度神经网络更好训练的技巧。残差连接允许信息直接“跳过”某些层,避免梯度消失;层归一化则将每层的数据分布稳定在一定范围内,加速训练。

在我们的SimpleGPT模型中,我们堆叠了多个这样的Transformer解码器层 (n_layer个)。信息会逐层传递并被更深入地处理。

self.transformer = nn.ModuleList([
    nn.TransformerDecoderLayer(...) for _ in range(n_layer)
])

# 在前向传播中:
for transformer_layer in self.transformer:
    x = transformer_layer(x, x, tgt_mask=mask) # 注意这里 query, key, value 都是 x
 
 
Transformer 每一个组块的具体计算流程(基于nn.TransformerDecoderLayer 的结构)如下:
 
输入: 每个块的输入是前一个块的输出表示向量(对于第一个块,输入是 token embedding 和 positional embedding 的叠加)。我们称之为 X_input
 
自注意力层: X_input 首先进入自注意力层。在这里,X_input 被投影为 Q, K, V 向量。通过 Q 与 K 的点积、因果掩码、Softmax 和与 V 的乘法(加权求和),自注意力机制输出了一个向量。这个输出向量融合了该 token 自身以及其之前所有 token 的 Value 信息,权重取决于 Query-Key 的相似度
 
自注意力层的输出会加回到原始输入 X_input 上(残差连接),然后进行层归一化。这一步的结果是一个新的表示,我们称之为 X_attn_out这个 X_attn_out 就是经过上下文信息聚合(通过自注意力)后,该 token 位置的表示。
 
X_attn_out 接着进入前馈网络 (FFN)。FFN 是一个简单的、独立作用于每个 token 位置的多层感知机。它允许模型在聚合了上下文信息后,对这些信息进行进一步的、独立的非线性处理和特征转换
 
FFN 的输出会加回到 X_attn_out 上(残差连接),然后再次进行层归一化。这一步的结果就是该 token 位置经过当前 Transformer 块处理后的最终输出表示。这个输出表示会成为下一个 Transformer 块的输入
 
总结来说,token 的表示更新是通过一个层叠的处理管道实现的:输入表示 -> 自注意力层(QKV 投影、点积、掩码、Softmax、加权 Value 聚合)-> 残差连接 + 层归一化 -> 前馈网络 -> 残差连接 + 层归一化 -> 输出表示。每一个块都对 token 的表示进行这样的转换,使其逐步吸收更多上下文信息并进行更复杂的特征提取。

第四步:做出最终预测 - 输出层

经过多层Transformer的“深思熟虑”后,模型对每个输入位置都得到了一个丰富的上下文表示(一个n_embd维的向量)。现在,我们需要将这个表示转换成对下一个字符的预测。

  1. 最后的层归一化:
    x = self.ln_f(x) # self.ln_f = nn.LayerNorm(n_embd)

  2. 线性层 (Linear Layer) / 头部 (Head):
    一个线性层会将Transformer输出的n_embd维向量映射回词汇表大小(vocab_size)的维度。这个输出的每个维度对应词汇表中的一个字符,其值(称为logits)可以看作是模型认为该字符是下一个字符的“原始分数”或“置信度”。
    # self.head = nn.Linear(n_embd, vocab_size)

    logits = self.head(x)

    # logits 的形状是 (批量大小, 序列长度, 词汇表大小)

    例如,对于输入序列的最后一个字符位置,logits中与字符'a'对应的分数可能是2.5,与'b'对应的分数是-0.1,等等。分数越高的字符,模型认为它越有可能是下一个。

第五步:从错误中学习 - 训练模型

模型一开始是“随机”的,它需要通过学习大量的例子来提升预测能力。

  1. 准备输入和目标:
    我们从训练数据中随机抽取一批序列(x)以及它们对应的正确下一个字符序列(y)。
    block_size = 32 # 模型一次处理的序列长度
    # ix: 随机选择8个起始位置
    ix = torch.randint(len(train_data) - block_size, (8,))

    # x: 8个长度为32的输入序列
    x = torch.stack([train_data[i:i+block_size] for i in ix])

    # y: 对应的8个目标序列 (x中每个字符的下一个字符)
    y = torch.stack([train_data[i+1:i+block_size+1] for i in ix])
  2. 计算损失 (Loss):
    模型根据输入 x 得到预测的 logits。我们需要一个方法来衡量这个预测与真实目标 y 之间的差距。这就是损失函数 (Loss Function),常用的是交叉熵损失 (Cross-Entropy Loss)。损失越小,说明模型预测得越准。
    logits = model(x) # 通过模型得到预测

    # logits.view(-1, len(chars)) 将形状变为 (批量*序列长度, 词汇表大小)
    # y.view(-1) 将形状变为 (批量*序列长度)

    loss = nn.functional.cross_entropy(logits.view(-1, vocab_size), y.view(-1))
  3. 优化参数 (Optimization):
    我们的目标是最小化损失。优化器 (Optimizer)(如Adam)会根据损失值,通过反向传播 (Backpropagation) 算法计算出模型中每个参数(权重和偏置)应该如何调整,才能让损失变小一点。
    optimizer = torch.optim.Adam(model.parameters(), lr=3e-4) # lr是学习率
    optimizer.zero_grad() # 清除上一轮的梯度
    loss.backward()       # 计算梯度
    optimizer.step()        # 更新参数
    这个过程会重复很多次(很多step),模型逐渐学会莎士比亚的语言模式。

第六步:生成莎士比亚风格文本 - 推理 (Inference)

当模型训练到一定程度后,我们就可以用它来生成新的文本了。

    • 起始提示 (Prompt):

      我们可以给模型一个起始的文本片段(prompt),比如 "HAMLET: To be or not to be"。如果没给,就从一个默认字符开始。
      tokens = encode(prompt) # 将提示词编码成数字序列
    • 迭代生成:

      模型会根据当前的 tokens 序列(只取最后 block_size 个作为上下文),预测下一个最可能的字符。
      context = torch.tensor([tokens[-block_size:]])
      logits = model(context)[0, -1, :] # 取最后一个时间步的logits
      与训练不同,这里的 [0, -1, :] 表示我们只关心这个批次中(虽然推理时批次大小通常是1)最后一个字符位置的预测,因为我们要预测的是 下一个 字符。
  • 控制生成的多样性:

    直接选择概率最高的字符可能会让生成的文本很单调。我们用一些技巧来增加多样性:
      • Temperature (温度):
        logits = logits / temperature
        温度较低(<1)时,概率分布更“尖锐”,模型倾向于选择高概率字符,生成结果更保守、更像训练数据。
        温度较高(>1)时,概率分布更“平滑”,模型可能选择一些低概率字符,生成结果更有创意,但也可能更混乱。
      • Top-K 采样:
        只从概率最高的 k 个字符中进行采样。这可以避免选到非常不靠谱的字符。
        if top_k > 0:

          # 找到第k大的logit值
            kth_value = torch.topk(logits, top_k)[0][..., -1, None]

          # 将所有小于该值的logit设为负无穷 (采样概率为0)
            indices_to_remove = logits < kth_value

            logits[indices_to_remove] = float('-inf')
      • 让我们解说代码:
    kth_value = torch.topk(logits, top_k)[0][..., -1, None]

torch.topk(logits, top_k):  这个函数会从logits中找出分数最高的top_k个值,并且返回它们的值和它们在原始logits中的位置(索引)。它返回的是一个元组(values, indices)values: 包含了这top_k个最高的分数,默认是降序排列的(从高到低)。indices: 包含了这些最高分数对应的原始位置。 例如,如果logits如上例,top_k = 3,那么torch.topk(logits, 3),可能返回:values = torch.tensor([3.0, 2.5, 1.5])(最高的3个分数),indices = torch.tensor([3, 1, ...]) (这3个分数在原logits中的位置)。[0]: 因为torch.topk返回的是(values, indices)这个元组,我们只关心分数本身,所以用[0]来取出values部分。 现在,我们得到的是values这个张量,即torch.tensor([3.0, 2.5, 1.5])[..., -1, None]:

        • 采样与解码:

          根据调整后的 logits 计算概率分布 (torch.softmax),然后从这个分布中随机采样一个字符作为下一个字符,torch.multinomial(probs, 1) 中的 1 就表示我们只进行一次这样的抽取。将采样到的字符(数字形式)添加到 tokens 序列中。
          probs = torch.softmax(logits, dim=-1)
          next_token = torch.multinomial(probs, 1).item()
          tokens.append(next_token)
          重复这个过程,直到达到最大长度 (max_tokens) 或生成了特定的结束标记(比如换行符)。最后,用 decode 函数将整个 tokens 数字序列转换回人类可读的文本。

    我们的莎士比亚GPT在行动

    脚本中通过调整 temperature 和 top_k 参数,展示了不同风格的生成结果:

        • 保守生成: temperature=0.5, top_k=10 -> 更接近原文,但可能缺乏新意。
        • 平衡生成: temperature=0.8, top_k=20 -> 在忠实和创意间取得平衡。
        • 创意生成: temperature=1.2, top_k=30 -> 可能产生惊喜,也可能不那么连贯。

    由于我们的模型只训练了非常少的步数(50步),生成的质量不会很高,但足以让你看到它学习语言模式的过程。

    从迷你GPT到巨型GPT

    这个莎士比亚生成器是一个非常简化的字符级GPT。现实中的大型语言模型(如ChatGPT)与它的核心原理是相似的,但在以下方面有差异:

        • 模型规模: 参数量可能达到千亿甚至万亿级别(我们的例子只有几十万参数)。
        • 数据量: 训练数据是TB级别的海量文本和代码,远不止莎士比亚全集。
        • Tokenization: 通常使用更高级的词元化方法(如BPE或WordPiece),处理的是词或子词(subword),而不是单个字符,能更好地捕捉语义。
        • 训练技巧: 使用了更复杂的训练策略、更长的训练时间以及巨量的计算资源。
        • 架构细节: 可能包含更精巧的架构调整。
        • 对齐技术: 通过指令微调 (Instruction Fine-tuning) 和人类反馈强化学习 (RLHF) 等技术,使模型输出更符合人类期望、更有用、更无害。

    结语

    通过解剖这个小小的莎士比亚生成器,我们窥见了GPT内部运作的冰山一角。从简单的字符预测任务出发,通过嵌入、强大的Transformer层、巧妙的训练和生成策略,GPT能够学习并模仿复杂的语言模式。

    希望这篇科普能帮你揭开GPT的神秘面纱,理解它并非遥不可及的魔法,而是一系列精妙算法和海量数据共同作用的产物。下一次当你与AI对话时,或许就能想到它背后那些默默计算着的数字和向量了!

    GPT科普系列

How GPT Works: A Shakespearean Text Generator

following Karpathy's Video

Have you ever wondered how a computer can write poetry like Shakespeare? By exploring a simplified GPT (Generative Pre-trained Transformer) model, we can uncover the magic behind text generation. This article guides you through the process with questions to spark curiosity and understanding, using a Python script that generates Shakespearean text as our example.

What’s the Big Idea Behind GPT?

Imagine reading “To be or not to…” and guessing the next word. You’d likely say “be,” right? GPT models predict the next character or word in a sequence based on patterns in the text they’ve seen. Our script uses Shakespeare’s works to train a model to predict the next character. Why characters? They’re simpler than words, with a small vocabulary (65 characters like letters, spaces, and punctuation). What does a model need to turn raw text into predictions?

Turning Text into Numbers

Computers don’t understand letters, so how do we make text “machine-readable”? The script:

  • Reads Shakespeare’s text and lists all unique characters (e.g., ‘a’, ‘b’, ‘,’).
  • Creates mappings: stoi (e.g., ‘a’ → 0) and itos (e.g., 0 → ‘a’).
  • Encodes text into numbers (e.g., “hello” → [7, 4, 11, 11, 14]) and decodes numbers back to text.

Why numbers? Neural networks use math, and numbers are their language. What if two characters had the same number?

Feeding the Model Data

The script loads a preprocessed file (train.bin) with Shakespeare’s text as numbers. Why preprocess? It’s faster than encoding text during training. The model trains on chunks of 32 characters (e.g., “To be or not to be, t”) to predict the next chunk (e.g., “o be or not to be, th”). Why shift by one character? This teaches the model to predict what comes next, like guessing the next word in a sentence.

Building the Brain: The Model’s Architecture

The SimpleGPT model, built with PyTorch, has three key parts:

  1. Embedding Layer: Converts each character into a 128-dimensional vector, like giving it a “personality.” It also adds positional information to track where characters appear in a sequence. Why care about position? Without it, “dog bites man” and “man bites dog” would seem identical.
  2. Transformer Layers: Three layers analyze relationships between characters using:
    • Self-Attention: Focuses on relevant characters (e.g., noticing “to” often follows “be”).
    • Causal Mask: Ensures the model only sees past characters, mimicking how we write. Why prevent “seeing the future”?
    • Feedforward Network: Refines the attention results.
  3. Output Layer: Produces probability scores (logits) for each of the 65 characters, predicting the next one.

How do these parts work together to understand context?

Training the Model

Training teaches the model to make better predictions. The script runs 50 steps, where:

  • It picks eight random 32-character chunks.
  • The model predicts the next character for each position.
  • A loss function measures errors, and an optimizer (Adam) tweaks the model to improve.

Why only 50 steps? It’s a demo—real models train much longer. What might more training achieve?

Generating Shakespearean Text

To generate text, the model:

  • Starts with a prompt (e.g., “HAMLET: To be or not to be”) or a single character.
  • Encodes it into numbers and predicts the next character’s probabilities.
  • Uses temperature (controls creativity) and top-k sampling (limits choices to the k most likely characters) to pick the next character.
  • Repeats until it generates 200 characters or hits a newline.

Why use temperature and top-k? They balance predictable and creative output. What if temperature was very high or top-k was 1?

What Makes It Shakespearean?

The model learns Shakespeare’s patterns—like “thou” or dramatic phrasing—during training. The script shows outputs with different settings:

  • Conservative (temperature=0.5, top_k=10): Mimics common patterns.
  • Balanced (temperature=0.8, top_k=20): Mixes predictability and creativity.
  • Creative (temperature=1.2, top_k=30): Takes risks, possibly less coherent.

Which setting would you choose for a Shakespearean play?

Key Takeaways

This simple GPT shows how larger models like ChatGPT work:

  • Data: Encodes text into numbers.
  • Architecture: Uses embeddings, attention, and masks to process context.
  • Training: Optimizes predictions via loss and updates.
  • Generation: Samples from probabilities to create text.

What are the model’s limits? With brief training and a small size, it’s basic. How could you make it better? More training, larger layers, or more data could help.

Try running the script yourself! Tinker with temperature or top-k to see how the text changes. What kind of text would you want to generate?

立委按:鉴于语言大模型GPT的重要性,特此根据AI大神Karpathy的nanoGPT讲座,编纂此科普系列,计五篇,一篇没有代码和数学公式,是最通俗的科普。其他四篇包括一篇英文,均附带可验证的Python代码,并给予不同角度的详细解说,面对有一定工程背景的对象。

GPT科普系列

从零实现莎士比亚风 GPT科普解说

立委按:鉴于语言大模型GPT的重要性,特此根据AI大神Karpathy的nanoGPT讲座,编纂此科普系列,计五篇,一篇没有代码和数学公式,是最通俗的科普。其他四篇包括一篇英文,均附带可验证的Python代码,并给予不同角度的详细解说,面对有一定工程背景的对象。

下面这篇科普文章,以Karpathy讲座“从零实现莎士比亚风 GPT”为例,把每一行代码背后的思路拆透,感受“技术硬核”的魅力。


一、引子:为什么要自己写一个“小 GPT”?

  • 脚踏实地:商用 GPT 模型动辄上百亿参数,看不清内部;自己写一个小模型,才有机会把每个细节掰开了啃。
  • 入门示范:字符级模型更轻量,50 步训练就能出点儿“莎士比亚味”,足以演示 Transformer 的核心套路。
  • 学习曲线:从准备数据、编码、搭网络、训练到采样生成,完整跑一趟,就能圆满理解 GPT 的「流水线」。

二、数据篇:把“文字”编码成“数字”

  1. 原始文本
    把莎士比亚全集放到 data/shakespeare_char/input.txt,整个文本可能上百万字符。
  2. 字符表(Vocabulary)
    python
    chars = sorted(list(set(open(...).read())))
    stoi = {ch:i for i,ch in enumerate(chars)}
    itos = {i:ch for i,ch in enumerate(chars)}
  3. 代码解释:
    • set (字符集合)自然去重后有 65 个字符,包括字母、标点、换行符等。
    • stoiitos 分别是一一映射,可做「文字 ↔ 索引」互转,即编码解码。
  4. 高效加载
    训练前把所有文本编码成 uint16 二进制文件 train.bin,运行时直接:
    train_data = torch.frombuffer(open(…,'rb').read(), dtype=torch.uint16).long()
    一次性读入张量,快又省事。

三、模型篇:一个“小型 GPT”长啥样

class SimpleGPT(nn.Module):
    def __init__(self, vocab_size, n_embd=128, n_head=4, n_layer=3):
        super().__init__()
        # 1. Token 嵌入 & 位置嵌入
        self.embedding     = nn.Embedding(vocab_size, n_embd)
        self.pos_embedding = nn.Embedding(1000, n_embd)
        # 2. N 层 TransformerDecoderLayer
        self.transformer = nn.ModuleList([
            nn.TransformerDecoderLayer(
                d_model=n_embd, nhead=n_head,
                dim_feedforward=n_embd*4,
                batch_first=True, dropout=0.1
            ) for _ in range(n_layer)
        ])
        # 3. 归一化 + 线性头
        self.ln_f = nn.LayerNorm(n_embd)
        self.head = nn.Linear(n_embd, vocab_size)
  • Embedding
    • Token 嵌入:把每个字符索引映射成 128 维向量;
    • 位置嵌入:告诉模型「这个字符是句子中的第几位」。
  • TransformerDecoderLayer
    • 多头自注意力(Multi-Head Self-Attention):在无掩码时,让每个位置都能「看」到其他位置,用不同的“视角”捕捉语义关联;
    • 前馈网络 FFN:FFN内部是两层全连接,扩大特征维度后再压回增强非线性表达:第一层linear1把维度从 n_embd(128)→ dim_feedforward(512);Relu激活;第二层linear2把维度再从 dim_feedforward(512)→ n_embd(128));
    • 残差连接 + LayerNorm + Dropout:保证信息流通、稳定训练、防止过拟合。
    • 两层全连接(Feed-Forward Network, FFN)和残差连接(Residual Connection)部分被 PyTorch 的 nn.TransformerDecoderLayer 给封装起来了。
    • 每个 block 里总共是两层前馈线性变换(加一个激活);*4 把隐藏层的宽度调成原来的 4 倍(128*4=512)。 n_head=4 是指 注意力头 数量是 4 个。
  • 输出头
    最后把每个位置的 128 维特征 → 65 个字符的分数(logits),为下一步采样做准备。

每个 TransformerBlock(TransformerDecoderLayer)内部:

# 注意力子层(Self-Attention)
_attn_output = self.self_attn(x, x, x, attn_mask=tgt_mask)
x = x + self.dropout1(_attn_output)    # 残差 + Dropout
x = self.norm1(x)                      # LayerNorm

# 前馈全连接子层(Feed-Forward)
_ffn_output = self.linear2(self.dropout(self.activation(self.linear1(x))))
x = x + self.dropout2(_ffn_output)     # 残差 + Dropout
x = self.norm2(x)                      # LayerNorm

残差连接(Residual Connection)在哪里?

同样,TransformerDecoderLayer 在每个子层的输出上都做了:

x = x + SubLayer(x)

也就是将子层(注意力/前馈)的输出与原输入相加,然后再做 LayerNorm。这能让梯度更容易向前/向后流动,避免深层网络训练困难。


为什么常常用这样的封装?

  • 代码简洁:把注意力、FFN、残差、归一化、Dropout——所有常见操作都打包好,调用一行就能用。
  • 可配置:你可以在构造时传参数,比如 activation='gelu'norm_first=True(预归一化)等。

想要完全掌握内部细节,你可以自己写一个自定义的 DecoderLayer,大概长这样:

class MyDecoderLayer(nn.Module):
    def __init__(self, d_model, nhead, dim_ff):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(d_model, nhead, batch_first=True)
        self.linear1   = nn.Linear(d_model, dim_ff)
        self.linear2   = nn.Linear(dim_ff, d_model)
        self.norm1     = nn.LayerNorm(d_model)
        self.norm2     = nn.LayerNorm(d_model)
        self.dropout   = nn.Dropout(0.1)
        self.act       = nn.ReLU()

    def forward(self, x, mask=None):
        # 注意力 + 残差 + 归一化
        attn_out, _ = self.self_attn(x, x, x, attn_mask=mask)
        x = x + self.dropout(attn_out)
        x = self.norm1(x)
        # FFN + 残差 + 归一化
        ffn_out = self.linear2(self.dropout(self.act(self.linear1(x))))
        x = x + self.dropout(ffn_out)
        x = self.norm2(x)
        return x

把 N 层这样的 MyDecoderLayer 串起来,就和 nn.TransformerDecoderLayer 是一模一样的套路。

这样你就明确地知道:GPT 的每一层都是「注意力→残差→LayerNorm→前馈→残差→LayerNorm」的循环组合。希望这下彻底搞明白了!

四、前向传播:一步步把输入变预测

def forward(self, x):
    b, t = x.shape                  # batch 大小 b,序列长度 t
    pos  = torch.arange(t).unsqueeze(0)
    x = self.embedding(x) + self.pos_embedding(pos)
    mask = torch.triu(torch.ones(t, t), diagonal=1).bool()
    for layer in self.transformer:
        x = layer(x, x, tgt_mask=mask)
    x = self.ln_f(x)
    return self.head(x)             # (b, t, vocab_size)
  1. 拼接嵌入
    每个字符向量 + 对应位置向量,融合语义与顺序信息。
  2. 因果掩码
    用上三角布尔矩阵屏蔽未来位置,确保模型只能用“历史”信息预测“下一步”。
  3. 层叠计算
    N 层解码器层交替执行「注意力→前馈→残差→归一化」,不断提炼上下文特征。
  4. 输出 logits
    每个位置都对应一个 vocab_size 维的分数向量,代表模型对下一个字符的「喜好程度」。

五、训练篇:教模型学“接龙文字”

optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
model.train()
for step in range(50):
    # 1. 随机抓 8 段长度为 block_size 的序列
    ix = torch.randint(len(train_data)-block_size, (8,))
    x  = torch.stack([train_data[i:i+block_size]       for i in ix])
    y  = torch.stack([train_data[i+1:i+block_size+1]   for i in ix])
    # 2. 前向 + 损失
    logits = model(x)
    loss   = nn.functional.cross_entropy(
                logits.view(-1, vocab_size), y.view(-1)
             )
    # 3. 反向 + 更新
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if step%10==0: print(f"Step {step}: loss={loss.item():.4f}")
  • 随机采样:每次从不同起点取小段,让模型见识多种上下文,避免只学到固定模式。
  • 交叉熵损失:衡量预测分布 vs. 真实下一个字符的差距。
  • Adam 优化器:智能调整各参数的学习率,加快收敛。

六、生成篇:让模型「写莎翁诗」

def generate_text(prompt="", max_tokens=200, temperature=0.8, top_k=20):
    model.eval()
    tokens = encode(prompt) if prompt else [encode("ROMEO:")[0]]
    with torch.no_grad():
        for _ in range(max_tokens):
            ctx    = torch.tensor([tokens[-block_size:]])
            logits = model(ctx)[0, -1]       # 取最新位置的 logits
            logits = logits / temperature    # 温度调节
            if top_k>0:
                kth, _ = torch.topk(logits, top_k)
                logits[logits < kth[-1]] = -float('inf')
            probs = torch.softmax(logits, dim=-1)
            nxt   = torch.multinomial(probs, 1).item()
            tokens.append(nxt)
            if nxt==encode('\n')[0] and len(tokens)>10: break
    return decode(tokens)
  • 温度(Temperature)
    • <1:分布更陡峭,生成更“保守”;
    • >1:分布更平坦,生成更“大胆”。
  • Top-k 采样
    只保留概率最高的 k 个候选,把其余置零,然后再做随机采样,平衡“连贯”与“创造”。

七、核心技术要点小结

技术环节功能与作用
嵌入层离散字符→连续向量,便于神经网络处理
位置编码注入顺序信息,让模型区分“先后”
自注意力动态计算序列各位置间的相互影响,捕捉长程依赖
因果掩码严格屏蔽「未来信息」,模拟人写作时只能一步步推进
前馈网络增加非线性表达能力
残差+LayerNorm保持梯度稳定,助力深层网络收敛
温度 & Top-k控制生成文本的“保守度”与“多样性”

八、结语

  • 小模型 ≠ 小原理:虽然参数量小,但骨架设计、数据流程、采样策略与大规模 GPT 完全一致。
  • 动手才真懂:自己从头跑一遍,不仅能看懂代码,更能体会每一层、每一个技巧为何如此设计。
  • 一路上升:掌握这些基础,你就拥有了阅读和改造任何 Transformer-based 模型的「通行证」。

下次想要扩充到单词级、加上多 GPU、混合精度训练,或者接入更大语料,就能顺理成章地在这些模块之上“造船”了。Go build your own GPT!

GPT科普系列

从0实现并理解GPT

根据Karpathy莎士比亚为例创建一个快速的文本生成演示

立委按:鉴于语言大模型GPT的重要性,特此根据AI大神Karpathy的nanoGPT讲座,编纂此科普系列,计五篇,一篇没有代码和数学公式,是最通俗的科普。其他四篇包括一篇英文,均附带可验证的Python代码,并给予不同角度的详细解说,面对有一定工程背景的对象。

cat > shakespeare_generator.py << 'EOF'
import torch
import torch.nn as nn
import pickle
import os

print("莎士比亚风格文本生成器")
print("=" * 50)

加载数据和词汇表

data_dir = 'data/shakespeare_char'
with open(os.path.join(data_dir, 'meta.pkl'), 'rb') as f:
meta = pickle.load(f)

获取编解码函数

chars = sorted(list(set(open(os.path.join(data_dir, 'input.txt'), 'r').read())))
stoi = {ch: i for i, ch in enumerate(chars)}
itos = {i: ch for i, ch in enumerate(chars)}

print(f"词汇表大小: {len(chars)}")
print(f"字符集: {''.join(chars[:20])}…")

def encode(s):
return [stoi[c] for c in s]

def decode(l):
return ''.join([itos[i] for i in l])

加载训练数据

train_data = torch.frombuffer(
open(os.path.join(data_dir, 'train.bin'), 'rb').read(),
dtype=torch.uint16
).long()

print(f"📖 训练数据长度: {len(train_data):,} tokens")

超简单的字符级语言模型

class SimpleGPT(nn.Module):
def init(self, vocab_size, n_embd=128, n_head=4, n_layer=3):
super().init()
self.embedding = nn.Embedding(vocab_size, n_embd)
self.pos_embedding = nn.Embedding(1000, n_embd)
self.transformer = nn.ModuleList([
nn.TransformerDecoderLayer(
d_model=n_embd,
nhead=n_head,
dim_feedforward=n_embd * 4,
batch_first=True,
dropout=0.1
) for _ in range(n_layer)
])
self.ln_f = nn.LayerNorm(n_embd)
self.head = nn.Linear(n_embd, vocab_size)

def forward(self, x):
    b, t = x.shape
    pos = torch.arange(0, t, dtype=torch.long).unsqueeze(0)

    x = self.embedding(x) + self.pos_embedding(pos)

    # 创建因果mask
    mask = torch.triu(torch.ones(t, t), diagonal=1).bool()

    for transformer in self.transformer:
        x = transformer(x, x, tgt_mask=mask)

    x = self.ln_f(x)
    logits = self.head(x)
    return logits

创建和训练模型

print("\n 创建模型…")
model = SimpleGPT(vocab_size=len(chars))
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)

print(f"模型参数: {sum(p.numel() for p in model.parameters()):,}")

快速训练

print("\n 快速训练…")
block_size = 32
model.train()

for step in range(50): # 只训练50步,快速看效果
ix = torch.randint(len(train_data) - block_size, (8,))
x = torch.stack([train_data[i:i+block_size] for i in ix])
y = torch.stack([train_data[i+1:i+block_size+1] for i in ix])

logits = model(x)
loss = nn.functional.cross_entropy(logits.view(-1, len(chars)), y.view(-1))

optimizer.zero_grad()
loss.backward()
optimizer.step()

if step % 10 == 0:
    print(f"  Step {step:2d}: loss = {loss.item():.4f}")

print("\n 开始生成莎士比亚风格文本…")

def generate_text(prompt="", max_tokens=200, temperature=0.8, top_k=20):
model.eval()

# 编码提示词
if prompt:
    tokens = encode(prompt)
else:
    tokens = [encode("ROMEO:")[0]]  # 默认以ROMEO开始

with torch.no_grad():
    for _ in range(max_tokens):
        # 取最后block_size个tokens
        context = torch.tensor([tokens[-block_size:]])
        logits = model(context)[0, -1, :]

        # 应用temperature
        logits = logits / temperature

        # Top-k采样
        if top_k > 0:
            indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
            logits[indices_to_remove] = float('-inf')

        probs = torch.softmax(logits, dim=-1)
        next_token = torch.multinomial(probs, 1).item()
        tokens.append(next_token)

        # 如果生成了换行符,可能是一个好的停止点
        if len(tokens) > 10 and next_token == encode('\n')[0]:
            break

return decode(tokens)

生成不同风格的文本

print("\n" + "="60) print(" 生成结果展示") print("="60)

print("\n1️⃣ 保守生成 (temperature=0.5, top_k=10):")
torch.manual_seed(42)
text1 = generate_text("HAMLET: To be or not to be", max_tokens=100, temperature=0.5, top_k=10)
print(f"'{text1}'")

print("\n2️⃣ 平衡生成 (temperature=0.8, top_k=20):")
torch.manual_seed(42)
text2 = generate_text("JULIET: Romeo, Romeo", max_tokens=100, temperature=0.8, top_k=20)
print(f"'{text2}'")

print("\n3️⃣ 创意生成 (temperature=1.2, top_k=30):")
torch.manual_seed(42)
text3 = generate_text("KING: What news", max_tokens=100, temperature=1.2, top_k=30)
print(f"'{text3}'")

print("\n4️⃣ 无提示生成:")
torch.manual_seed(123)
text4 = generate_text("", max_tokens=150, temperature=0.8, top_k=25)
print(f"'{text4}'")

print(f"\n 参数解释:")
print(f"• temperature越低 → 更保守,更像训练数据")
print(f"• temperature越高 → 更有创意,但可能更乱")
print(f"• top_k越小 → 只从最可能的k个字符中选择")
print(f"• 对于65字符的词汇表,top_k=5到30比较合理")

print(f"\n 注意: 由于只训练了50步,质量不会很高")
print(f" 但您可以看到模型学习语言模式的过程!")
EOF

运行莎士比亚生成器

python shakespeare_generator.py

下面逐行详细解释这个莎士比亚生成器脚本,好理解GPT的实现原理。

🔍 逐行代码解析:莎士比亚GPT生成器

1. 导入和基础设置

import torch
import torch.nn as nn
import pickle
import os

详细解释

  • torch: PyTorch核心库,提供张量计算和神经网络功能
  • torch.nn: 神经网络模块,包含各种层(Linear, Embedding等)
  • pickle: Python序列化库,用于加载.pkl格式的数据文件
  • os: 操作系统接口,用于文件路径操作

2. 打印标题和设置

print(" 莎士比亚风格文本生成器")
print("=" * 50)

解释:简单的用户界面,"=" * 50创建50个等号的分隔线

3. 数据加载部分

# 加载数据和词汇表
data_dir = 'data/shakespeare_char'
with open(os.path.join(data_dir, 'meta.pkl'), 'rb') as f:
    meta = pickle.load(f)

详细解释

  • data_dir: 设置数据目录路径
  • os.path.join(): 跨平台的路径连接,相当于 data_dir + '/' + 'meta.pkl'
  • with open(..., 'rb'): 以二进制读取模式打开文件,with确保文件自动关闭
  • pickle.load(f): 加载.pkl文件,读取之前保存的字符对应表

4. 字符编码设置

# 获取编解码函数
chars = sorted(list(set(open(os.path.join(data_dir, 'input.txt'), 'r').read())))
stoi = {ch: i for i, ch in enumerate(chars)}
itos = {i: ch for i, ch in enumerate(chars)}

逐行解析

# 第1行:获取所有唯一字符
chars = sorted(list(set(open(...).read())))
  • open(...).read(): 读取整个莎士比亚文本文件
  • set(...): 创建集合,自动去除重复字符
  • list(...): 转换为列表
  • sorted(...): 按ASCII码排序,确保字符顺序固定
# 第2行:创建字符到索引的映射stoi(string2integer)
stoi = {ch: i for i, ch in enumerate(chars)}
  • enumerate(chars): 产生 (索引, 字符) 对
  • 字典推导式创建映射:{'a': 0, 'b': 1, 'c': 2, ...}
# 第3行:创建索引到字符的映射itos(integer2string)
itos = {i: ch for i, ch in enumerate(chars)}
  • 反向映射:{0: 'a', 1: 'b', 2: 'c', ...}

5. 编解码函数

def encode(s):
    return [stoi[c] for c in s]

def decode(l):
    return ''.join([itos[i] for i in l])

详细解释

def encode(s):
    return [stoi[c] for c in s]
  • 输入:字符串 "hello"
  • 过程:['h', 'e', 'l', 'l', 'o'][104, 101, 108, 108, 111]
  • 输出:数字列表
def decode(l):
    return ''.join([itos[i] for i in l])
  • 输入:数字列表 [104, 101, 108, 108, 111]
  • 过程:[104, 101, 108, 108, 111]['h', 'e', 'l', 'l', 'o']
  • 输出:字符串 "hello"

6. 加载训练数据

train_data = torch.frombuffer(
    open(os.path.join(data_dir, 'train.bin'), 'rb').read(), 
    dtype=torch.uint16
).long()

逐步解析

  1. open(..., 'rb').read(): 以'rb'(read-binary)二进制模式读取train.bin文件,得到的是二进制原始字节
  2. torch.frombuffer(..., dtype=torch.uint16): 将二进制数据转换为16位无符号整数张量,uint16 = 16位无符号整数 = 0到65535的数字
  3. .long(): 转换为长整型张量(64位),long() = 64位长整数,训练时常用

为什么这样做?

  • train.bin是预处理好的数字化文本数据
  • 每个字符已经被转换为对应的索引数字
  • 直接加载比重新编码要快得多
  • train.bin文件 → 读出字节 → 变成数字列表 → 转换成PyTorch能用的格式

7. GPT模型定义

class SimpleGPT(nn.Module):
    def __init__(self, vocab_size, n_embd=128, n_head=4, n_layer=3):
        super().__init__()

详细解释

  • nn.Module: PyTorch中所有神经网络模块的基类
  • super().__init__(): 调用父类构造函数
  • 参数:
    • vocab_size: 词汇表大小(65个字符)
    • n_embd=128: 嵌入维度(每个字符用128维向量表示)
    • n_head=4: 注意力头数量
    • n_layer=3: Transformer层数

嵌入层

self.embedding = nn.Embedding(vocab_size, n_embd)
self.pos_embedding = nn.Embedding(1000, n_embd)

详细解释

self.embedding = nn.Embedding(vocab_size, n_embd)
  • 创建一个查找表:vocab_size × n_embd 的矩阵
  • 每个字符索引对应一个128维向量
  • 例如:字符 'a' (索引0) → 128维向量 [0.1, -0.2, 0.3, ...]
self.pos_embedding = nn.Embedding(1000, n_embd)
  • 位置嵌入:告诉模型每个字符在序列中的位置
  • 支持最大1000个位置
  • 位置0 → 向量1,位置1 → 向量2,...

Transformer层

self.transformer = nn.ModuleList([
    nn.TransformerDecoderLayer(
        d_model=n_embd,
        nhead=n_head,
        dim_feedforward=n_embd * 4,
        batch_first=True,
        dropout=0.1
    ) for _ in range(n_layer)
])

详细解释

  • nn.ModuleList: 存储多个神经网络层的容器
  • nn.TransformerDecoderLayer: PyTorch内置的Transformer解码器层
  • 参数详解:
    • d_model=n_embd: 输入维度(128)
    • nhead=n_head: 多头注意力的头数(4)
    • dim_feedforward=n_embd * 4: 前馈网络维度(512)
    • batch_first=True: 维度顺序以批次维度在前 (batch, seq, feature),先选句子,再选词元,数据排列像 [句子1][句子2][句子3]
    • 数据的三个维度batch = 同时处理几个句子;seq = 每个句子有多少个词元;feature = 每个词元用多少个数字表示(例如128个数字)
    • dropout=0.1: 10%的dropout防止过拟合

输出层

self.ln_f = nn.LayerNorm(n_embd)
self.head = nn.Linear(n_embd, vocab_size)

详细解释

  • nn.LayerNorm(n_embd): 层归一化,数据清洗,稳定训练。数据'洗干净' - 平均值接近0,标准差接近1,避免数字太大或太小,给数据做标准化处理。
  • nn.Linear(n_embd, vocab_size): 线性层把特征变成字符概率,将128维特征映射到65个字符的概率

8. 前向传播函数

def forward(self, x):
    b, t = x.shape
    pos = torch.arange(0, t, dtype=torch.long).unsqueeze(0)

详细解释

  • 标量(0维),向量(1维),矩阵(2维),张量(n维向量)
  • x.shape: 输入张量的形状,例如 (batch_size=8, seq_len=32)
  • b, t = x.shape: 解包得到批次大小和序列长度
  • torch.arange(0, t): 创建位置索引 [0, 1, 2, ..., t-1]
  • .unsqueeze(0): 增加一个维度,变成 (1, t)
x = self.embedding(x) + self.pos_embedding(pos)

详细解释

  • self.embedding(x): 字符嵌入,形状 (b, t, n_embd)
  • self.pos_embedding(pos): 位置嵌入,形状 (1, t, n_embd)
  • 相加得到最终嵌入:字符信息 + 位置信息
# 创建因果mask
mask = torch.triu(torch.ones(t, t), diagonal=1).bool()

详细解释

  • torch.ones(t, t): 创建全1的 t×t 矩阵
  • torch.triu(..., diagonal=1): 取上三角矩阵(对角线上方)
  • .bool(): 转换为布尔值
  • 作用:防止模型"偷看"未来的字符

举例:如果t=4,mask矩阵是:

[[False, True,  True,  True ],
 [False, False, True,  True ],
 [False, False, False, True ],
 [False, False, False, False]]
for transformer in self.transformer:
    x = transformer(x, x, tgt_mask=mask)

详细解释

  • 循环通过每个Transformer层
  • transformer(x, x, tgt_mask=mask):
    • 第一个x: 查询(query)
    • 第二个x: 键值(key, value)
    • tgt_mask=mask: 应用因果掩码
x = self.ln_f(x)
logits = self.head(x)
return logits

详细解释

  • self.ln_f(x): 最终层归一化
  • logits = self.head(x): 线性变换,输出每个字符的未归一化概率(logits),表示模型对next token的"偏好程度",logits[0, 31, :] 就是第0个句子第31个位置对65个字符的评分
    等价于:logits = x @ W + b
    输入特征: [0.2, -0.1, 0.8, 0.3] (128维)
    权重矩阵: W (128×65)
    偏置向量: b (65维)
    输出logits: [2.1, -0.5, 1.3, ...] (65维)
  • 返回形状:(batch_size, seq_len, vocab_size)
  • head层就像一个"翻译器"
    输入:复杂的上下文特征表示(模型的"理解")
    输出:简单直观的字符选择评分(具体的"预测")
    作用:将模型的智慧转换为可操作的概率分布
  • head层是模型的"最后一公里",将前面所有层的计算结果汇总成最终的字符选择,决定了模型生成文本的质量和多样性
  • 关键:logits不是最终答案,而是为后续采样提供的概率性依据,通过softmax转换和采样策略,最终生成具体的字符。
  • 预测流程:
    输入: "hello wor" ↓
    嵌入层: 转换为向量序列 ↓
    Transformer: 处理上下文,每个位置得到特征向量 ↓
    最后位置(即next token)特征: [0.2, -0.1, 0.8, 0.3, ...] (128维) ↓
    head层: 线性变换 ↓
    logits: 对每个字符的评分 [2.1, -0.5, 1.3, ...] (65维) ↓
    softmax: 转换为概率分布 ↓
    采样: 选择下一个字符 "l"

9. 模型创建和训练

model = SimpleGPT(vocab_size=len(chars))
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)

详细解释

  • SimpleGPT(vocab_size=len(chars)): 创建模型实例
  • torch.optim.Adam: Adam优化器,自适应学习率,根据梯度历史智能调整
  • model.parameters(): 获取所有可训练参数
  • lr=3e-4: 学习率 0.0003,默认经验值
block_size = 32
model.train()

详细解释

  • block_size = 32: 序列长度(训练窗口大小),模型一次处理32个字符
  • model.train(): 设置模型为训练模式(启用dropout等)

10. 训练循环

for step in range(50):
    ix = torch.randint(len(train_data) - block_size, (8,))
    x = torch.stack([train_data[i:i+block_size] for i in ix])
    y = torch.stack([train_data[i+1:i+block_size+1] for i in ix])

逐行解析

ix = torch.randint(len(train_data) - block_size, (8,)) 
  • 随机选择8个起始位置,假设len(train_data) = 1000block_size = 32:torch.randint(1000-32=968, (8,)), 这里,(8,) 是张量的 shape
  • 确保不超出数据边界,每个位置都在 [0, 967] 范围内
  • 假设在随机起始位置156:
    输入x = train_data[156:188] # 32个token
    目标y = train_data[157:189] # 下一个32个token
为什么需要随机采样?
优势:
避免顺序偏见:不总是从头开始训练
增加数据多样性:每个epoch看到不同的序列组合
提高泛化能力:模型学会处理各种上下文
加速收敛:随机性帮助跳出局部最优

对比: 
❌ 顺序采样起始位置: [0, 32, 64, 96, 128, 160, 192, 224]
总是相同的序列,缺乏多样性

✅ 随机采样  
起始位置,例如: [156, 743, 12, 891, 445, 623, 88, 334]
# 每次都不同,增加训练多样性



x = torch.stack([train_data[i:i+block_size] for i in ix])
  • 从每个起始位置取32个字符作为输入
  • torch.stack: 将列表转换为张量
y = torch.stack([train_data[i+1:i+block_size+1] for i in ix])
  • 取下一个字符作为目标(预测目标)
  • 这是语言模型的核心:预测下一个字符

举例

  • 输入x: "To be or not to be, that is th"
  • 目标y: "o be or not to be, that is the"
logits = model(x)
loss = nn.functional.cross_entropy(logits.view(-1, len(chars)), y.view(-1))

详细解释

  • model(x): 前向传播得到预测
  • view/reshape = 重新排列相同的数据
  • 为什么要reshape:交叉熵函数期望输入格式:
    • logits: (N, C) - N个样本,码本中的C个类别
  • logits.view(-1, len(chars)): 重塑为 (batch*seq, vocab_size),在形状参数中,-1 作为维度大小本来就无意义,PyTorch定义它为自动计算维度大小,相当于 auto
  • y.view(-1): 重塑为 (batch*seq,)
  • cross_entropy: 计算交叉熵损失
optimizer.zero_grad()
loss.backward()
optimizer.step()

详细解释

  • zero_grad(): 清零之前的梯度
  • backward(): 反向传播计算梯度
  • step(): 更新模型参数

11. 文本生成函数

def generate_text(prompt="", max_tokens=200, temperature=0.8, top_k=20):
    model.eval()

详细解释

  • model.eval(): 设置为评估模式(关闭dropout)
if prompt:
    tokens = encode(prompt)
else:
    tokens = [encode("ROMEO:")[0]]  # 只要'R',让模型自由发挥

详细解释

  • 如果有提示词,编码为数字列表作为上文(为了预测下一个token)
  • 否则用"ROMEO:"的第一个字符开始编码为上文,也可以不加[0]:则用"ROMEO:" 开始生成
with torch.no_grad():
    for _ in range(max_tokens):
        context = torch.tensor([tokens[-block_size:]])
        logits = model(context)[0, -1, :]

详细解释

  • torch.no_grad(): 这是推理阶段不是训练阶段,禁用梯度计算(节省内存),只要结果,不存历史
  • tokens[-block_size:]: 取最后32个字符作为上下文
  • logits = model(context)[0, -1, :]:
    • [0, -1, :]: 取第一个批次的最后一个位置的所有词汇概率,为了 next token prediction 采样,next token 即最后一个位置。
# 应用temperature
logits = logits / temperature

详细解释

  • temperature < 1: 让分布更尖锐,更保守
  • temperature > 1: 让分布更平坦,更随机
  • temperature = 1: 不改变分布
# Top-k采样
if top_k > 0:
    indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
    logits[indices_to_remove] = float('-inf')

详细解释

  • torch.topk(logits, top_k): 找到最大的k个值
  • indices_to_remove: 标记要移除的索引
  • logits[indices_to_remove] = float('-inf'): 设置为负无穷(概率为0)
probs = torch.softmax(logits, dim=-1)
next_token = torch.multinomial(probs, 1).item()
tokens.append(next_token)

详细解释

  • torch.softmax: 将logits转换为概率分布
  • torch.multinomial: 根据概率分布随机采样
  • .item(): 将张量转换为Python数字
  • tokens.append(): 添加到生成序列

12. 生成展示

torch.manual_seed(42)
text1 = generate_text("HAMLET: To be or not to be", max_tokens=100, temperature=0.5, top_k=10)

详细解释

  • torch.manual_seed(42): 设置随机种子确保可重现
  • 不同参数组合展示不同的生成风格

核心概念总结

GPT的本质

  1. 输入:字符序列 → 数字序列
  2. 处理:Transformer层处理上下文信息
  3. 输出:预测下一个字符的概率分布
  4. 生成:根据概率分布采样下一个字符

关键技术

  • 嵌入:字符 → 向量
  • 位置编码:告诉模型字符位置
  • 自注意力:字符之间的关系
  • 因果掩码:防止看到未来
  • 温度采样:控制创造性
  • Top-k采样:控制选择范围

这就是GPT的完整实现,每一行代码都有其特定的作用,组合起来就能生成连贯的莎士比亚文风的文本。

GPT科普系列

Decoding the New EMPO Reasoning Paradigm

The Right Question is Half the Answer,
The Other Half lies in LLM's Semantic Coherence

Large Language Models (LLMs) are constantly rewriting the rules of AI with their astonishing reasoning abilities. Yet, the path to even stronger reasoning is often paved with expensive "gold"—manually labeled reasoning steps, verified answers, or bespoke reward models. These reinforcement methods, rooted in supervised learning, work, but they hit bottlenecks in cost and scalability.

Rewind to this Lunar New Year, when DeepSeek's R1-Zero, a result-driven, supervised reinforcement approach, made waves. We debated its underlying mechanics, converging on a shared understanding: The essence of technologies like Chain-of-Thought (CoT) is to build a "slow-thinking" information bridge between a query and a response in complex tasks. Think of it as a gentle "ramp", designed to lower perplexity, transforming problems with daunting information gaps—unsolvable by "fast thinking"—into something smooth and solvable.

Now, a new paper from Tianjin University and Tencent AI Lab, "Right Question is Already Half the Answer: Fully Unsupervised LLM Reasoning Incentivization," takes this line of thought a step further—a step both radical and elegant. It introduces EMPO (Entropy Minimized Policy Optimization), a fully unsupervised framework for reinforcement reasoning. And the kicker? Its performance reportedly rivals methods that do rely on golden answers.

This paper is a refreshing read. No black magic, no convoluted theories. It’s like a fresh breeze blowing through the landscape of unsupervised learning. It further validates our hunch: give the model a "field" to play in, and it will autonomously find the smoothest path towards entropy reduction.

Frankly, DeepSeek R1-Zero was stunning enough, proving machines could learn autonomously, generating their own data to boost their intelligence. This work feels like "Zero-Squared": Machines can now seemingly learn answers just from questions. It's a bit scary if you think about it. Unsupervised learning has been around for years, but after fueling the pre-trained LLM storm via self-supervised learning, seeing it reach this level of magic in reasoning is truly eye-opening.

EMPO's Midas Touch: Minimizing Semantic Entropy

The core idea behind EMPO is simple: Instead of telling the model "what is right," why not let it pursue "what is consistent"? It posits that a powerful reasoning model should produce outputs that are stable and semantically aligned. How do we measure this alignment? Through Semantic Entropy.

This isn't your classic Shannon entropy, which focuses on the surface token string and can be easily thrown off by phrasing variations. Semantic entropy operates at the level of meaning. Here’s how EMPO does it:

  1. Sample: For a single question, let the current model generate multiple (say, G) reasoning processes and answers, step-by-step.
  2. Cluster: Using simple rules (like regex for math) or a compact verifier model, cluster these G outputs based on their meaning. For example, "The answer is 42" and "Final result: 42" land in the same bucket, regardless of the path taken.
  3. Calculate Entropy: Based on these clusters, calculate the probability distribution of each "meaning bucket" and calculate the overall semantic entropy. If all answers converge to one meaning, entropy is minimal; if they're all over the place, it's high.
  4. Reinforce: Use this "semantic consistency" (low entropy) as an intrinsic reward signal within an RL framework (like GRPO). The model gets a pat on the back if its output belongs to the most "mainstream," most consistent cluster. Optimization then incentivizes the model to generate outputs that lower the overall semantic entropy.

In short, EMPO encourages the model: "Within your own answer space, find the most 'popular' view, the one you're most sure about, and double down on it!"

Piercing the Veil: Wisdom and Real-World Gotchas

EMPO's elegance doesn't mean it's without its nuances. The paper highlights a few key insights and practicalities:

  • Entropy Thresholding (The "Catch"): This is crucial. Just blindly minimizing entropy could lead the model down a rabbit hole, overfitting. EMPO therefore introduces an entropy threshold: it only applies CoT reinforcement to questions with moderate entropy. This filters out cases where the model is either too uncertain (high entropy, too chaotic to learn from) or already too confident (low entropy, no need to push further and risk overconfidence). This ensures stability and effectiveness.
  • The Power of the Base Model: EMPO is more of an elicitor than a creator of abilities. The potential for these reasoning paths is likely laid down during pre-training. EMPO's success hinges heavily on a strong base model. The contrast between Qwen (where EMPO worked directly, likely due to pre-training with QA pairs, seeding its potential) and Llama (which needed an SFT "warm-up" before EMPO works) drives this point home. Unsupervised post-training isn't a magic wand; it builds only on a solid foundation.
  • No <cot> Tags Required: EMPO doesn't even need explicit <cot> tags as format rewards. A simple prompt like, Please resolve it step by step and put the final answer in {...}. is enough to provide the "space" for the model to explore thinking and refine its reasoning.

The Unsupervised Dividend: Why EMPO Matters

EMPO shows that even without any external answers, we can significantly boost LLM reasoning through a simple, elegant, and intrinsically motivated mechanism. It's like unlocking a universal "data quality dividend". The only entry fee is feeding the system questions and applying simple clustering – and most likely, accuracy improvements become possible.

The paper's title begins, "Right question is already half the answer." We can extend that: "...the other half is embodied in LLM's internal semantic coherence." By minimizing semantic entropy, EMPO guides the LLM to generate CoT and answers with greater harmony and order, helping it find that "other half."

Given its underlying mechanism of information theory and its generality, we believe EMPO's minimalist, unsupervised approach will spark a wave of follow-up research. It will push boundaries, find applications in diverse tasks, and likely become a cornerstone of future LLM post-training pipelines.

P.S. Rarely is a paper this interesting also this accessible. For those keen on diving into the details, the original paper recently published is just a click away: https://arxiv.org/pdf/2504.05812. Enjoy!

解读EMPO全程无监督推理新范式

提问即成功的一半,另一半藏于LLM的语义一致性

大型语言模型(LLM)在推理任务上的惊人表现,正不断刷新我们对人工智能的认知。然而,通往更强推理能力的道路往往铺满了昂贵的“黄金”——人工标注的推理过程、验证过的答案或是定制的奖励模型。这些基于监督学习的强化方法,虽然有效,却也带来了成本和可扩展性的瓶颈。

就在今年春节期间,DeepSeek 推出的结果驱动/监督强化推理方案引发热议,大家探讨其背后机理。一个普遍的共识是,思维链(Chain-of-Thought, CoT)这类技术的本质,是在处理复杂任务时,于用户提问(Query)和模型回应(Response)之间,构建一座“慢思维”的信息桥梁。这就像一个平缓的斜坡(Ramp),旨在降低困惑度(Perplexity),将那些对于“快思维”而言存在信息鸿沟、难以一步到位的复杂问题,变得“丝滑可解”。

而今,来自天津大学和腾讯 AI Lab 的一篇新论文 Right Question is Already Half the Answer: Fully Unsupervised LLM Reasoning Incentivization,则沿着这条思路,迈出了更为激进而优雅的一步。它提出了 EMPO (熵最小化策略优化),一个全程无监督的强化推理框架,其效果据报道竟能与那些依赖答案的监督方法相媲美。

这篇论文读起来异常轻松,没有任何故弄玄虚的复杂理论,却如同一缕清风,推进了无监督学习的深入。它进一步证实了我们之前的猜想:只要给模型一个“场”,系统就能自发地选择那条通往更平滑、熵减的推理路径。

春节那阵,随着鞭炮声迎来 DeepSeek R1 zero 已经够震撼了,说明机器可以自主学习,自己再生数据强化自己的智力。这个工作等于是 zero 的“平方”:机器原来还可以从问题就能学到答案。细思有点恐。无监督学习这个概念有很久了吧,继发展到自(监督)学习带来的预训练大模型风暴后,现在发展到推理这份上也是让人开眼了。

EMPO 的“点石成金”之术:语义熵最小化

EMPO 的核心思想极其单纯:与其告诉模型“什么是对的”,不如让模型自己追求“什么是自洽的”。它认为,一个强大的推理模型,其输出应该是稳定且在语义上一致的。如何衡量这种一致性?答案是语义熵(Semantic Entropy)

与关注词汇层面、容易受到表述方式干扰的经典香农熵不同,语义熵关注的是意义层面。EMPO 的做法是:

  1. 采样 (Sample): 对同一个问题,让当前的模型 step-by-step 生成多个(比如 G 个)推理过程和答案。
  2. 聚类 (Cluster): 使用简单的规则(如数学题中的正则表达式)或一个小型验证模型,将这 G 个答案按照最终表达的意义进行聚类。比如,无论推理过程如何,“答案是 42” 和 “最终结果:42” 都会被归为一类。
  3. 计算熵 (Calculate Entropy): 根据聚类结果,计算出每个“意义簇”的概率分布,并由此算出语义熵。如果所有答案都指向同一个意义,熵就最低;如果答案五花八门,熵就很高。
  4. 强化 (Reinforce): 将“语义一致性”(即低熵)作为内在奖励信号,应用到强化学习框架(如 GRPO)中。模型会得到奖励,如果它生成的答案属于那个最“主流”、最一致的意义簇。通过优化,模型被激励去产生那些能让整体语义熵降低的输出。

简单来说,EMPO 就是在鼓励模型:“在你自己的答案空间里,找到那个最‘合群’、最‘确定’的观点,并强化它!”

“窗户纸”背后的智慧与现实考量

EMPO 的简洁优雅并不意味着它的实现毫无挑战。论文中也提到了一些关键点和发现:

  • 熵阈值 (Entropy Thresholding): 一个重要的 “catch”!直接最小化熵可能会让模型“钻牛角尖”,出现过拟合。因此,EMPO 引入了熵阈值——只对那些熵值处于中等范围的问题进行COT强化优化。它排除了模型极度不确定(高熵,可能过于混乱无法学习)或极度自信(低熵,无需再强化优化)的情况,确保了训练的稳定性和效果。
  • 基座模型的重要性 (Importance of Base Model): EMPO 更像是在激发而非创造能力。推理路径的潜力很可能是在预训练阶段就已经埋下的。EMPO 的成功很大程度上依赖于强大的基座模型。这一点在 Qwen 和 Llama 上的对比实验中得到了印证:Qwen 因为预训练中包含了大量 QA 数据,具备了“指令跟随”和推理的“潜能”,EMPO 能直接在其上生效;而 Llama 基座则需要先进行一些 SFT “预热”,才能有效应用 EMPO。这提醒我们,无监督后训练并非万能药,它建立在坚实的预训练基础之上。
  • 无需<cot>标签奖励: 这种方法甚至不需要 <cot> 这样的显式标签来引导。一句简单的提示,如 Please resolve it step by step and put the final answer in {...},就足以提供一个让模型探索和优化其推理路径的伸缩“空间”。

意义与展望:无监督的“数据红利”

EMPO 的价值在于它捅破了一层窗户纸。它证明了,即使在完全没有外部答案的情况下,我们也能通过一个简单、优雅且内在驱动的机制,有效提升 LLM 的推理能力。这就像是提供了一波通用性极强的增强数据质量的红利——获取这份红利的唯一条件,就是只要把问题喂给系统进行强化学习(并辅以简单的聚类),就有可能获得准确率的提升。

论文标题的前半句是 “Right question is already half the answer”(好问题是答案的一半),我们可以接龙说:“the other half is embodied in LLM's internal semantic coherence” (另一半则蕴藏于 LLM 内部的语义一致性之中)。EMPO 正是通过最小化语义熵,让 LLM 在生成 CoT 和答案的过程中,更加和谐有序,从而找到那“另一半”答案。

基于这个研究的机理及其普适性,我们有理由相信,EMPO 所代表的这种极简无监督强化思路,将激发更多后续研究,去探索其边界,应用于更广泛的任务,并可能成为未来 LLM 后训练流程中的一个重要环节。


论文原文少有地亲民易懂,想进一步了解细节的同学,出门向左:https://arxiv.org/pdf/2504.05812

MeanFlow: AI图像生成的降维打击

何恺明团队最新力作,MeanFlow无需预训练、无需蒸馏,仅需一次函数评估 (1-NFE) 即可实现SOTA性能,为高效高质量图像生成开辟新道路。

MeanFlow的核心思想是引入“平均速度场”来直接建模数据点和噪声点之间的转换路径,摆脱了传统扩散模型和流匹配方法对多步迭代的依赖。这项研究在ImageNet 256x256数据集上取得了惊人的 FID 3.43 (1-NFE) 的成绩。核心概念解析

MeanFlow的创新根植于对生成过程基本原理的深刻洞察。它通过引入“平均速度场”和“MeanFlow恒等式”,为单步高效生成提供了坚实的理论基础,有效解决了传统方法的诸多痛点。平均速度场 (Mean Velocity Field)

传统流匹配 (Flow Matching) 方法依赖于建模瞬时速度场𝑣(𝑧𝑡,𝑡),即在特定时间点𝑡状态𝑧𝑡的变化速率。而MeanFlow首创性地引入了平均速度场𝑢(𝑧𝑡,𝑟,𝑡)的概念。

平均速度定义为在时间间隔[𝑟,𝑡]内的平均位移速率:𝑢(𝑧𝑡,𝑟,𝑡)=𝑧𝑡−𝑧𝑟𝑡−𝑟=1𝑡−𝑟∫𝑟𝑡𝑣(𝑧𝑠,𝑠)𝑑𝑠

这里的𝑧𝑠是在时间𝑠的状态。这个定义表明,平均速度不仅取决于当前状态和时间,还取决于一个参考的起始时间𝑟。通过直接建模平均速度,网络学会了预测整个时间段内的“平均路径”,而非瞬时方向。MeanFlow 恒等式

基于平均速度的定义,研究者推导出了一个连接平均速度𝑢和瞬时速度𝑣的核心数学关系——MeanFlow恒等式:𝑣(𝑧𝑡,𝑡)−𝑢(𝑧𝑡,𝑟,𝑡)=(𝑡−𝑟)(𝜕𝑢(𝑧𝑡,𝑟,𝑡)𝜕𝑡+∇𝑧𝑡𝑢(𝑧𝑡,𝑟,𝑡)𝑣(𝑧𝑡,𝑡))

这个恒等式为神经网络的训练提供了理论依据。通过设计损失函数,引导网络学习满足此内在关系,而无需引入额外的启发式方法。由于存在明确定义的目标速度场,理论上最优解与网络的具体结构无关,有助于训练过程更加稳健和稳定。一步生成如何实现?

通过训练神经网络𝑢𝜃直接建模平均速度𝑢,从初始噪声𝑧0(时间𝑡=0) 到目标图像𝑧1(时间𝑡=1) 的生成过程可以简化为单步操作:

𝑧1=𝑧0+𝑢𝜃(𝑧0,0,1)⋅(1−0)

这意味着在推理阶段无需显式计算时间积分,这是传统建模瞬时速度方法所必需的步骤。MeanFlow通过学习平均速度,有效地隐式处理了瞬时速度场可能存在的复杂非线性问题(“弯曲轨迹”),避免了多步ODE求解中累积离散化误差的风险。性能表现 SOTA

MeanFlow 在多个标准图像生成基准上均取得了当前最佳 (SOTA) 或极具竞争力的结果,尤其是在单步或少步生成设定下,其性能提升显著。ImageNet 256x256 (类别条件生成)

在ImageNet 256x256数据集上,MeanFlow展现了卓越的性能。仅需1次函数评估 (1-NFE),FID分数即达到3.43,较之前同类最佳方法有50%到70%的相对提升。在2-NFE设定下,FID进一步降至2.20,已可媲美许多多步方法。

下表详细对比了MeanFlow与其他模型在ImageNet 256x256上的表现 (数据源自论文表2):

MeanFlow (MF)13.43XL/2级骨干
MeanFlow (MF)22.20XL/2级骨干
Shortcut110.601.0B-
IMM2 (含引导)7.771.0B-
iCT1>10 (图示估计)1.0B-
代表性多步SOTA~250x2<2.20XL/2级通常有

CIFAR-10 (无条件生成)

在CIFAR-10 (32x32) 数据集上,MeanFlow同样表现出色。在1-NFE采样下,FID-50K分数为1.95。值得注意的是,MeanFlow在取得此成绩时并未使用任何预处理器,而其他对比方法均使用了EDM风格的预处理器。

下表详细对比了MeanFlow与其他模型在CIFAR-10上的表现 (数据源自论文表3):

MeanFlow (MF)1.95U-Net
EDM2.01EDM风格U-Net
Consistency Models (CM)2.05EDM风格U-Net

创新的CFG集成

无分类器引导 (Classifier-Free Guidance, CFG) 是提升条件生成模型质量的关键技术,但传统应用方式常导致采样计算量翻倍。MeanFlow巧妙地解决了这一问题。作为真实速度场一部分的CFG

MeanFlow将CFG视为底层“真实速度场”的一部分属性进行建模,而非在采样阶段临时组合。研究者定义了一个新的、带引导的真实瞬时速度场𝑣𝑐𝑓𝑔:𝑣𝑐𝑓𝑔(𝑧𝑡,𝑐,𝑡)=𝑤⋅𝑣(𝑧𝑡,𝑐,𝑡)+(1−𝑤)⋅𝑣(𝑧𝑡,∅,𝑡)

其中𝑐是类别条件,𝑤是引导强度。神经网络𝑢𝑐𝑓𝑔,𝜃被训练来直接预测由这个𝑣𝑐𝑓𝑔所诱导出的平均速度场。保持1-NFE的高效引导

由于网络直接学习的是包含了引导信息的平均速度𝑢𝑐𝑓𝑔,因此在采样阶段,无需再进行额外的线性组合计算。只需一次网络调用即可完成带引导的单步生成。这使得MeanFlow在保留CFG效果的同时,依然维持了理想的1-NFE采样性能,真正做到了兼顾效率与质量。意义与价值

MeanFlow的提出不仅仅是一次技术迭代,它对整个生成式AI领域都可能产生深远的影响,有望引领新的研究方向和应用范式。性能飞跃,效率革新

MeanFlow显著缩小了一步与多步扩散/流模型之间的性能差距,证明了高效生成模型同样能达到顶尖质量。挑战传统,简化范式

其“从零开始”训练且无需预训练、蒸馏的特性,极大简化了高性能生成模型的开发流程,有望挑战多步模型的主导地位。降低门槛,普惠AI

更低的计算和开发成本,使得SOTA级别的生成技术能惠及更广泛的研究者和开发者,催生更多创新应用。启迪未来,重塑基础

MeanFlow的成功可能激励学界重新审视生成模型的基础理论,探索更根本、更高效的建模方法。关于本研究

这项名为 MeanFlow: Efficient Flow Matching with Mean Velocity Fields 的开创性研究由以下学者共同完成:

耿正阳 (Zhengyang Geng), 邓明阳 (Mingyang Deng), 白行健 (Xingjian Bai), J. Zico Kolter, 何恺明 (Kaiming He)

他们分别来自卡内基梅隆大学 (CMU) 和麻省理工学院 (MIT) 两所顶尖科研机构。

阅读完整论文 (arXiv:2405.13447)

Q&A on NLP: Chapter I Natural Language and Linguistic Form

Guo: Professor Li, to ease into the discussion, let us begin with some foundational concepts. What exactly do we mean by natural language? What falls under the scope of the field, and where does it sit within the broader discipline of Artificial Intelligence (AI)?

Li:  Natural language refers to the everyday languages we humans speak—English, Russian, Japanese, Chinese, and so on;  in other words,  human language writ large.  It is distinct from computer languages.  Because human conversation is rife with ellipsis and ambiguity,  processing natural language on a computer poses formidable challenges.

Within AI, natural language is defined both as a problem domain and as the object we wish to manipulate.  Natural Language Processing (NLP) is an essential branch of AI, and parsing is its core technology—the crucial gateway to Natural Language Understanding (NLU). Parsing will therefore recur throughout this book.

Computational linguistics is the interdisciplinary field at the intersection of computer science and linguistics.  One might say that computational linguistics supplies the scientific foundations, whereas NLP represents the applied layer.

AI is often divided into perceptual intelligence and cognitive intelligence.  The former includes image recognition and speech processing.  Breakthroughs in big data and deep learning have allowed perceptual intelligence to reach—and in some cases surpass—human‑expert performance.  Cognitive intelligence, whose core is natural language understanding, is widely regarded as the crown jewel of AI.  Bridging the gap from perception to cognition is the greatest challenge—and opportunity—facing the field today.

The rationalist tradition formalises expert knowledge using symbolic logic to simulate human intellectual tasks.  In NLP, the classical counterpart to machine‑learning models comprises linguist‑crafted grammar rules, collectively called a computational grammar.  A system built atop such grammars is known as a rule‑based system. The grammar school decomposes linguistic phenomena with surgical precision, aiming at a deep structural analysis.  Rule‑based parsing is transparent and interpretable—much like the diagramming exercises once taught in a language school.

Figure 1‑1 sketches the architecture of a natural‑language parser core engine.  Without dwelling on minutiae, note that every major module—from shallow parsing through deep parsing—can, in principle, be realised via interpretable symbolic logic encoded as a computational grammar.  Through successive passes, the bewildering diversity of natural language is reduced first to syntactic relations and then to logical‑semantic structure.  Since Chomsky’s distinction between surface structure and deep structure in late 50s, this layered view has become an orthodoxy within linguistics.

Guo: These days everyone venerates neural networks and deep learning. Does the grammar school still have room to live? Rationalism seems almost voiceless in current NLP scholarship. How should we interpret this history and the present trend?

Li:  Roughly thirty years ago, the empiricist school of machine learning began its ascent, fuelled by abundant data and ever‑cheaper computation.  In recent years, deep neural networks have achieved spectacular success across many AI tasks.  Their triumph reflects not only algorithmic innovation but also today’s unprecedented volumes of data and compute.

By contrast, the rationalist programme of symbolic logic has waned.  After a brief renaissance twenty years ago—centred on unification‑based phrase‑structure grammars (PSGs)—computational grammar gradually retreated from the mainstream.  Many factors contributed; among them, Noam Chomsky’s prolonged negative impact warrants sober reflection.

History reveals a pendulum swing between empiricism and rationalism. Kenneth Church famously illustrated the motion in his article A Pendulum Swung Too Far (Figure 1-2).

For three decades, the pendulum has tilted toward empiricism (black dots in Figure 1‑2); deep learning still commands the spotlight. Rationalism, though innovating quietly, is not yet strong enough to compete head‑to‑head.  When one paradigm dominates, the other naturally fades from view.

Guo:  I sense some conceptual confusion both inside and outside the field.  Deep learning, originally just one empiricist technique, has become synonymous with AI and NLP for many observers.  If its revolution sweeps every corner of AI, will we still see a rationalist comeback at all? As Professor Church warns, the pendulum may already have swung too far.

Li:  These are two distinct philosophies with complementary strengths and weaknesses; neither can obliterate the other.

While the current empiricist monoculture has understandable causes, it is unhealthy in the long run.  The two schools both compete and synergise.  Veterans like Church continue to caution against over‑reliance on empiricism, and new scholars are probing deep integrations of the two methodologies to crack the hardest problems in NLU.

Make no mistake: today’s AI boom largely rests on deep‑learning breakthroughs, especially in image recognition, speech, and machine translation.  Yet deep learning inherits a fundamental limitation of the statistical school—its dependence on large volumes of labelled data.  In many niche domains—for instance, minority languages or e‑commerce translation—such corpora are simply unavailable.  This knowledge bottleneck severely constrains empiricist approaches to cognitive NLP tasks.  Without data, machine learning is a bread‑maker without flour; deep learning’s appetite as we all know is insatiable.

Guo: So deep learning is no panacea, and rationalism deserves a seat at the table.  Since each paradigm has its merits and deficits, could you summarise the comparison?

Li: A concise inventory helps us borrow strengths and shore up weaknesses.

Advantages of machine learning

    1. Requires no domain experts (but does require vast labelled data).
    2. Excels at coarse‑grained tasks such as classification.
    3. High recall.
    4. Robust and fast to develop.

Advantages of the grammar school

    1. Requires no labelled data (but does require expert rule writing).
    2. Excels at fine‑grained tasks such as parsing and reasoning.
    3. High precision.
    4. Easy to localise errors; inherently interpretable.

Li: Rule‑based systems shine at granular, line‑by‑line dissection, whereas learned statistical models are naturally strong at global inference. Put bluntly, machine learning often "sees the forest but misses the trees," while computational grammars "see each tree yet risk losing the forest." Although data‑driven models boast robustness and high recall, they may hit a precision ceiling on fine‑grained tasks. Robustness is the key to surviving anomalies and edge cases. Expert‑coded grammars, by contrast, attain high precision, but boosting recall can require many rounds of iterative rule writing. Whether a rule‑based system is robust depends largely on its architectural design. Its symbolic substrate renders each inference step transparent and traceable, enabling targeted debugging—precisely the two pain‑points of machine learning, whose opaque decisions erode user trust and hamper defect localisation. Finally, a learning system scales effortlessly to vast datasets and its breakthroughs tend to ripple across an entire industry. Rule‑based quality, by contrast, hinges on the individual craftsmanship of experts—akin to Chinese cuisine, where identical ingredients may yield dishes of very different calibre depending on the chef.

Both routes confront knowledge bottlenecks. One relies on mass unskilled labour (annotators), the other on a few skilled artisans (grammar experts). For machine learning, the bottleneck is the supply of domain‑specific labelled data. The rationalist route simulates human cognition and thus avoids surface‑level mimicry of datasets, but cannot escape the low efficiency of manual coding. Annotation is tedious yet teachable to junior workers; crafting and debugging rules is a costly skill to train and hard to scale. Talent gaps exacerbate the issue—three decades of empiricist dominance have left the grammar school with a thinning pipeline.

Guo: Professor Li, a basic question: grammar rules are grounded in linguistic form. If semantics is derived from that form, then what exactly is linguistic form?

Li: This strikes at the heart of formalising natural language. All grammar rules rest on linguistic form, yet not every practitioner—even within the grammar camp—has a crisp definition at hand.

In essence, natural language as a symbolic system expresses meaning through form. Different utterances of an idea vary only in form; their underlying semantics and logic must coincide, else communication—and translation—would be impossible. The intuition is commonplace, but pinning down "form" propels us into computational linguistics.

Token & Order — The First‑Level Abstraction
At first glance a sentence is merely a string of symbols—phonemes or morphemes. True, but that answer is too coarse. Every string is segmented into units called tokens (words or morphemes). A morpheme is the smallest pairing unit of sound and meaning. Thus our first abstraction decomposes linguistic form into a sequence of tokens plus their word order. Grammar rules define patterns that match such sequences. The simplest pattern, a linear pattern, consists of token constraints plus ordering constraints.

Guo: Word order seems straightforward, but tokens and morphemes hide much complexity.

Li: Indeed. Because tokens anchor the entire enterprise, machine‑readable dictionaries become foundational resources. (Here "dictionary" means an electronic lexicon.)

If natural language were a closed set—say only ten thousand fixed sentences—formal grammar would be trivial: store them all, and each complete string would serve as an explicit pattern. But language is open, generating unbounded sentences. How can a finite rule set parse an infinite language?

The first step is tokenisation—dictionary lookup that maps character strings to lexicon words or morphemes. Unlimited sentences decompose into a finite vocabulary plus occasional out‑of‑dictionary items. Together they form a token list, the initial data structure for parsing.

We then enter classic linguistic sub‑fields. Morphology analyses the internal structure of multi‑morphemic words. Some languages exhibit rich morphology—noun declension, verb conjugation—e.g., Russian and Latin; others, such as English and Chinese, are comparatively poor. Note, however, that Chinese lacks inflection but excels at compounding. Compounds sit at the interface of morphology and syntax; many scholars treat them as part of "little syntax" rather than morphology proper.

Guo: Typologists speak of a spectrum—from isolating languages such as Classical Chinese (no morphology) to polysynthetic languages like certain Native American tongues (heavy morphology). Most languages fall between, with Modern Chinese and English leaning toward the isolating side: minimal morphology, rich syntax. Correct?

Li: Exactly. Setting aside the ratio of morphology to syntax, our first distinction is between function words/affixes versus content words. Function words (prepositions, pronouns, particles, conjunctions, original adverbs, interrogatives, interjections) and affixes (prefixes, suffixes, endings) form a small, closed set.

Content words—nouns, verbs, adjectives, etc.—form an open set forever producing neologisms; a fixed dictionary can hardly keep up.

Because function words and affixes are frequent yet limited, they can be enumerated as literals in pattern matching. Hence we have at least three grain‑sizes of linguistic form suitable for rule conditions: (i) word order; (ii) function‑word literals or affix literals; (iii) features.

Features — The Implicit Form
Explicit tokens are visible in the string, but parsers also rely on implicit features—category labels. Features encode part‑of‑speech, gender, number, case, tense, etc. They enter pattern matching as hidden conditions. Summarising: automatic parsing rests on (i) order, (ii) literals, (iii) features—two explicit, one implicit. Every language weaves these three in different proportions; grammar is but their descriptive calculus.

Guo: By this metric, can we say European languages are more rigorous than Chinese?

Li: From the standpoint of explicit form, yes. European tongues vary internally—German and French more rigorous than English—but all possess ample explicit markers that curb ambiguity. Chinese offers fewer markers, increasing parsing difficulty.

Inflectional morphology supplies visible agreement cues—gender‑number‑case for nouns, tense‑aspect‑voice for verbs. Chinese lacks these. Languages with rich morphology enjoy freer word order (e.g., Russian). Esperanto’s sentence "Mi amas vin" (I love you) can permute into six orders because the object case ‑n never changes.

Chinese, conversely, evolved along the isolating path, leveraging word order and particles. Even so, morphology provides tighter agreement than particles. Hence morphology‑rich languages are structurally stringent, reducing reliance on implicit semantics.

Guo: People call Chinese a "paratactic" language—lacking hard grammar, leaning on meaning. Does that equate to your notion of implicit form?

Li: Precisely. Parataxis corresponds to semantic cohesion—especially collocational knowledge within predicate structures. For example, the predicate "eat" expects an object in the food category. Such commonsense often lives in a lexical ontology like HowNet (founded by the late Professor Dong Zhendong).

Consider how plurality is expressed. In Chinese, "brother" is a noun whose category is lexically stored. Esperanto appends ‑o for nouns and ‑j for plural: frato vs. fratoj. Chinese may add the particle (‑men), but this marker is optional and forbidden after numerals: "三个兄弟" (three brothers) not "*三个兄弟们". Here plurality is implicit, inferred from the numeral phrase.

Guo: Lacking morphology indeed complicates Chinese. Some even claim Chinese has no grammar.

Li: That is hyperbole. All languages have grammar; Chinese simply relies more on implicit forms. Overt devices—morphology, particles, word order—are fewer or more flexible.

Take omission of particles as an illustration. Chinese frequently drops prepositions and conjunctions. Compare:

      1. 对于这件事, 依我的看法, 我们应该听其自然。
        As for this matter, in my opinion, we should let nature take its course.
      2. 这件事我的看法应该听其自然。
        * this matter my opinion should let nature take its course.
        (Unacceptable as a word‑for‑word English rendering.)

Example 2 is ubiquitous in spoken Chinese but would be ungrammatical in English. Systematic omission of function words exacerbates NLP difficulty.

Guo: What about word order? Isolation theory says morphology‑poor languages have fixed order—Chinese is labelled SVO.

Li: Alas, reality defies the stereotype. Despite lacking morphology and often omitting particles, Chinese exhibits remarkable word‑order flexibility. Consider the six theoretical permutations of S, V, and O. Esperanto, with a single object case marker ‑n, allows all six without altering semantics. Compare English (no case distinction for nouns, but marking subject pronouns from obect cases) and Chinese (no case at all):

Order Esperanto English Chinese
SVO Mi manĝis fiŝon I ate fish 我吃了鱼
SOV Mi fiŝon manĝis * I fish ate 我鱼吃了
VOS Manĝis fiŝon mi * Ate fish I ?吃了鱼我
VSO Manĝis mi fiŝon * Ate I fish * 吃了我鱼
OVS Fiŝon manĝis mi * Fish ate I ?鱼吃了我
OSV Fiŝon mi manĝis Fish I ate 鱼我吃了

Chinese sanctions three orders outright, two marginally (marked “?”), and forbids one (“*”). English allows only two. Thus Chinese word order is about twice as free as English, even though English possesses case distinction on pronouns. Hence morphology richness does not always guarantee order freedom.

Real corpora confirm that Chinese is more permissive than many assume. Greater flexibility inflates the rule count in sequence‑pattern grammars: every additional order multiplies pattern variants. Non‑sequential constraints can be encoded inside a single rule; order itself cannot.

A classic example is the elastic placement of argument roles around "哭肿" (cry‑swollen):

张三眼睛哭肿了。
眼睛张三哭肿了。
哭肿张三眼睛了。
张三哭肿眼睛了。
哭得张三眼睛肿了。
张三哭得眼睛肿了。
…and so on.

Such data belie the notion of a rigid SVO Chinese. Heavy reliance on implicit form complicates automatic parsing. Were word order fixed, a few sequence patterns would suffice; flexibility forces exponential rule growth.

壹 自然语言与语言形式

郭: 李老师, 由浅入深, 我们还是从一些基本概念开始谈 起吧。什么是自然语言? 自然语言领域包括哪些内容? 它在人工智能里面的定位是怎样的呢?

李: 自然语言 (natural language) 指的是我们日常使用的语言, 英语、俄语、日语、汉语等, 它与人类语言是同义词。自 然语言有别于计算机语言。人脑处理的自然语言常有省略和歧义, 这给电脑 (计算机) 的处理提出了挑战。

在人工智能界, 自然语言是作为问题领域和处理对象提出来的。自然语言处理是人工智能的重要分支, 自然语言解析是其核心技术和通向自然语言理解的关键。语言解析是我 们接下来要探讨的、贯穿全书始终的话题。

计算语言学是计算机科学与语言学的交叉学科. 计算语言学和自然语言处理是同一个专业领域的两个剖面. 可以 说, 计算语言学是自然语言处理的科学基础, 自然语言处理是计算语言学的应用层面。

人工智能主要有感知智能 (perceptual intelligence) 和认 知智能 (cognitive intelligence) 两大块. 前者包括图像识别  (image recognition) 和语音处理 (speech processing)。随着 大数据和深度学习 (deep learning) 算法的突破性进展, 感知智能很多方面已经达到甚至超过人类专家的水平。认知智能的核心是自然语言理解, 被一致认为是人工智能的皇冠。从感知跃升到认知是当前人工智能所面临的最大挑战和机遇。

理性主义直接把领域专家的经验形式化, 利用符号逻辑来模拟人的智能任务。在自然语言处理领域, 与机器学习模型平行的传统方法是语言学家手工编码的语言规则。这些规则的 集合称为计算文法。由计算文法支撑的系统叫作规则系统 (rule system)。文法学派把语言学家总结出来的语言规则形式化, 从而对语言现象条分缕析, 达到对自然语言深层次的结构 解析. 规则系统试图模拟人的语言分析理解过程。规则系统解析自然语言是透明的、可解释 (interpretable) 的。这个过程很 像是外语文法老师在课堂上教给学生的句子分析方法。

图1—1是一张自然语言解析器 (parser) 核心引擎 (core engine) 的架构图。不必深究细节, 值得说明的是, 从浅层解析 (shallow parsing) 到深层解析 (deep parsing) 里面的各主要模块, 都可以用可解释的符号逻辑 (symbolic logic) 以计算文法的形式实现。千变万化的自然语言表达, 就这样一步一 步地从句法关系 (syntactic relation) 的解析, 进而求解其深层 的逻辑语义 (logic semantics) 关系。这个道理早在1957年乔 姆斯基 (Chomsky) 语言学革命中提出表层结构 (surface structure) 到深层结构 (deep structure) 的转换之后, 就逐渐成为语言学界的共识了。

郭: 现在大家都在推崇神经网络 (neural network) 深度学习, 文法学派还有生存空间吗?  理性主义在自然语言领域已经听不到什么声音了。怎样看待这段历史与趋向呢?

李: 大约从30年前开始到现在, 经验主义机器学习这一 派, 随着数据和计算资源的发展, 天时地利, 一直在向上走。尤其是近年来深层神经网络的实践, 深度学习在不少人工智能任务上取得了突破性的成功。经验主义的这些成功, 除了 神经网络算法的创新, 也得益于今非昔比的大数据和大计算的能力。

与此对照, 理性主义符号逻辑则日趋式微。符号逻辑在自然语言领域表现为计算文法。文法学派在经历了20年前 基于合一 (unification) 的短语结构文法 (Phrase Structure  Grammar, PSG) 创新的短暂热潮以后, 逐渐退出了学界的主 流舞台。形成这一局面的原因有多个, 其中包括乔姆斯基对于文法学派长期的负面影响, 值得认真反思。

回顾人工智能和自然语言领域的历史, 经验主义和理性 主义两大学派此消彼长, 呈钟摆式跌宕起伏。肯尼斯丘吉 (Kenneth Church) 在他的「钟摆摆得太远」(A Pendulum  Swung Too Far) 一文中, 给出了一个形象的钟摆式跌宕图 (图1—2).

最近30年来, 经验主义钟摆的上扬趋势依然不减 (见图 1—2的黑点表示)。目前来看, 深度学习仍在风头上。理性主义积蓄多年, 虽然有其自身的传承和创新, 但还没有到可以与经验主义正面争锋的程度。当一派成为主流时, 另一派自然淡出视野。

郭: 我感觉业内业外有些认知上的混乱。深度学习本来只是经验主义学派的一种方法, 现在似乎在很多人心目中等价于人工智能和自然语言处理了。如果深度学习的革命席卷 人工智能的方方面面, 会不会真地要终结理性主义的回摆呢? 正如丘吉教授所言, 经验主义的钟摆已经摆得太远了。

李: 我的答案是否定的。这是两个不同的哲学和方法论, 各自带有其自身的天然优势和劣势, 不存在一派彻底消灭另 一派的问题。

当前学界经验主义一面倒的局面虽然事出有因, 但并不 是一个健康的状态。其实, 两派既有竞争性, 也有很强的互补 性。丘吉这样的老一辈有识之士一直在警示经验主义一边倒的弊端, 也不断有新锐学者在探索两种方法论的深度融合, 以 便合力解决理解自然语言的难题。

毫无疑问, 这一波人工智能的热潮很大程度上是建立在深度学习的突破上, 尤其是在图像识别、语音处理和机器翻译方面取得的成就上。但是, 深度学习的方法仍然保留了统计学派的一个根本局限, 就是对海量标注数据 (labeled data) 的依赖。在很多细分领域和任务场景, 譬如, 少数族裔语言的解 析、电商数据的机器翻译, 海量标注或领域翻译数据并不存 在。这个知识瓶颈严重限制了经验主义方法在自然语言认知任务方面的表现。没有足够的标注数据, 对于机器学习就是无米之炊。深度学习更是如此, 它的胃口比传统机器学习 更大。

郭 : 看来深度学习也不是万能的, 理性主义理应有自己的一席之地。说它们各有长处和短板, 您能够给个比较吗?

李: 归纳一下两派各自的优势与短板是很有必要的, 可以取长补短。

机器学习的优势包括:

(1) 不依赖领域专家 (但需要大量标注数据);
(2) 长于粗线条的任务, 如分类 (classification);
(3) 召回 (recall) 好;
(4) 鲁棒 (robust), 开发效率高。

与此对照, 文法学派的优势包括:

(1) 不依赖标注数据 (但需要专家编码);
(2) 长于细线条的任务, 譬如解析和推理;
(3) 精度(precision)好;
(4) 易于定点排错, 可解释。

专家编码的规则系统擅长逐字逐句的条分缕析, 而学习出来的统计模型则天然长于全局结论。如果说机器学习往往是见林不见木的话, 计算文法则是见木不见林。大数据驱动的机器学习虽然带来了鲁棒和召回的长处, 但对细线条的任务较易遭遇精度的天花板。所谓鲁棒, 是robust的音译, 也 就是强壮、稳健的意思, 它是在异常和危险情况下系统生存的关键。专家编写规则虽然容易保障精度, 但召回的提升则是一个漫长的迭代过程。鲁棒性则决定于规则系统的架构设计。规则系统的基础是可解释的符号逻辑, 容易追踪到出错的现 场, 并做出有针对性的排错。而这两点正是机器学习的短板。机器学习的结果不论是对是错, 都难以解释, 因而影响用户的体验和信赖。难以定点排错更是开发现场的极大困扰, 其原因是学习模型缺乏显性符号与结构表示 (structure representation)。最后, 学习系统能较快地规模化到大数据的应用场景, 成功易于复制, 方法的突破往往可带动整个行业的提升。相对而言, 规则系统的质量很大程度上取决于专家的个体经 验。这就好比中餐, 同样的食材, 不同的厨师做出来的菜肴品质常常相差很大。

两条路线各有自身的知识瓶颈。打个比喻, 一个是依赖海量的低级劳动, 另一个是依赖少数专家的高级劳动。对于 机器学习, 海量标注是领域化落地 (grounding,即落实到应 用) 的知识瓶颈。理性主义路线模拟人的认知过程, 无需依赖海量数据在表层模仿。但难以避免手工编码的低效率。标注 工作虽然单调, 可一般学生稍加培训即可上手。而手工编制、 调试规则, 培训成本高, 难以规模化。还有, 人才的断层也算是文法学派的一个现实的局限。30年正好是一代人。在过 去的30年, 经验主义在主流舞台的一枝独秀, 客观上造成了 理性主义阵营人才青黄不接。

郭: 李老师,我有个基本问题: 文法规则依据的是语言形式 (linguistic form)。那么, 通过这个形式解析出语义 (semantics), 到底什么是语言形式呢?

李: 这是自然语言形式化的根本问题。所有的文法规则都建立在语言形式的基础之上, 可并不是每个人, 包括从事文 法工作的人, 都能对语言形式有个清晰的认识。

不错, 自然语言作为符号系统, 说到底就是以语言形式来表达语义。话语的不同只是形式的不同, 背后的语义和逻辑一定是相同的, 否则人不可能交流思想, 语言的翻译也会失去根基。这个道理老少咸知, 那什么是语言形式的定义呢? 回答这个问题就进入计算语言学了。

语言形式, 顾名思义, 就是语言的表达手段。乍一看语言, 不就是符号串吗? 语音流也好, 文字串也好, 都可以归结为符号串。所以, 符号串就是语言形式。这个答案不算错, 但失之笼统。这个“串”是有单位的, 其基本单位叫 token (可译 作“文本符号”), 也就是单词或语素 (morpheme)。语素, 其定义是音义结合的最小符号单位。因此, 作为第一级抽象, 我们可以把语言形式分解为文本符号及其语序 (word order)。计算文法中的规则都要定义一个条件模式 (pattern), 就是为 了与语言符号串做匹配。最基本的条件模式叫线性模式 (linear pattern), 其构成的两个要素就是符号条件和次序条件。

郭 : 好, 语言形式的基本要素是词/语素和语序。语序就是符号的先后顺序, 容易界定; 但词和语素里面感觉有很多 学问。

李: 不错, 作为语言符号, 词和语素非常重要, 它们是语言学的起点。收录词和语素的词典因此成为语言解析的基础资源。顺便提一下, 我们在这所说的“词典”是指机器词典, 它是 以传统词典为基础的形式化资源。

如果自然语言表达是一个封闭的集合, 譬如, 一共就只有一万句话, 语言形式文法就简单了。建个库把这些语句词串全部收进去, 每个词串等价于一条“词加语序”的模式规则。全词串的集合就是一个完备的文法模型。但是, 自然语言是 一个开放集, 无法枚举无穷变化的文句。形式文法是如何依据语言形式形成规则, 并以有限规则完成对无限文句的自动解析呢?

以查词典为基础的分词 (tokenization), 是文句解析的第 一步。查词典的结果是“词典词” (lexicon word), 包括语素。无限文句主要靠查词典分解为有限的单位。词典词加上少量 超出词典范围的生词, 一起构成词节点序列 (tokenlist)。词节点序列很重要, 它是文句的形式化表示 (formalized representation)。作为初始的数据结构, 词节点序列是自动解析的 对象。

接 下来就进入语言学的基本分支了, 通常叫词法 (morphology), 目的是解析多语素词 (multi-morphemic word) 的内部结构。对于有些语种, 词法很繁复, 包括名词变格 (declension)、动词变位 (conjugation) 等, 譬如俄语、拉丁语; 有些语种的词法则较贫乏, 譬如英语、汉语。值得注意的是, 词法的繁简只是相对而言。譬如汉语缺乏形态 (inflection), 单词不变形, 但是汉语的多语素复合造词的能力却很强。不过, 语 言学里的复合词 (compound word) 历来有争议, 它处于词法与句法 (syntax) 接口的地带, 其复合方式也与句法短语的方式类似。所以, 很多人不把词的复合当成词法, 而是看成句法的前期部分, 或称小句法。

郭: 以前看语言类型方面的文章, 说有一个频谱, 一个极端叫孤立语 (isolating language), 以古汉语为代表。孤立语没有词法, 只有句法。另一个极端好像叫多式综合语 (poly-synthetic language), 以某些印第安语为代表, 基本上只有词 法, 没有句法。多数语言处在两个极端之间, 现代汉语和英语更多偏向孤立语这边, 小词法大句法. 是这样吗?

李: 对, 是这样的。撇开词法句法比例的差别, 我们在研究词和语素的时候, 第一眼看到的是它的两大类别: 一类是小 词 (function word) 和形态, 是个较小的封闭集合; 一类叫实词  (notional word), 是个开放集合。实词范畴永远存在“生词”, 词典是收不住口的。

小词, 其实只是俗称, 术语应该叫功能词、封闭类词或虚词, 指的是介词、代词、助词、连词、原生副词 (original adverb)、疑问词、感叹词之类。形态包括前缀 (prefix)、后缀  (suffix)、词尾 (ending) 等材料, 也是一个小的集合。小词和形态出现频率高, 但数量有限。作为封闭类语素, 小词和形态需要匹配的时候, 原则上可以直接枚举它们, 软件界称其为匹配直接量 (literal)。至此, 我们至少得到了下面几种语言形式可以作为规则的条件: ①语序; ②小词; ③形态。不同的语言类型对这些形式的倚重和比例不同。例如, 俄语形态丰富, 对于语序和小词的依赖较少; 英语形态贫乏, 语序就相对固 定, 小词也比较丰富。

那么实词呢? 实词当然也是语言形式, 也可以尝试在规 则模式中作为直接量来枚举。但是, 因为实词是个开放集, 最好给它们分类, 利用类别而不是直接量去匹配实词, 这样做才会有概括性。人脑对于实词也主要靠分类来总结抽象的. 给词分类并在词典中标注分类结果是形式化的基础工作。

形式系统里面, 分类结果通常以特征 (feature) 来表示和标注。特征是系统内部定义的隐性语言形式。隐性形式 (implicit form) 是相对于前面提到的显性形式 (explicit form) 而 言。很显然, 无论语序还是语素, 它们都是语言符号串中可以看得见的形式。分类特征则不然, 它们是不能直接感知的。这些特征作为词典查询的结果提供给解析器, 支持模式匹配  (pattern matching) 的形式条件。

总结一下自动解析所依据的语言形式, 主要有三种: ①语序; ②直接量 (尤其是小词和形态); ③特征。前两种是显性形式, 特征是隐性形式。语言形式这么一分, 自然语言一下子就豁然开朗了。管它什么语言, 不外乎这三种形式的交错使用, 搭配的比例和倚重不同而已。所谓文法, 也不外乎用这三种形式形成规则, 对语言现象及其背后的结构做描述而已。

三种语言形式可以嫁接。显性形式的嫁接包括重叠式 (reduplication), 如: “高高兴兴”“走一走”。它是语序与直接量嫁接的模式 (AABB、V 一V), 是中文词法句法中常用的形式手段。显性形式也可以特征化。特征化可以通过词典标注实现, 也可以通过规则模块或子程序赋值得出。例如, “形态特征” (如单数、第三人称、现在时等) 就是通过词法模块得出 的特征。形态解析所依据的条件主要是作为直接量的形态词尾 (inflectional ending) 以及词干 (stem) 的类型特征, 例如, 英语词尾“-ly”与形容词词干结合成为副词 (beautiful-ly)。可见, 形态特征也是显性形式与隐性形式的嫁接结果。

郭: 从语言形式的使用看, 可以说欧洲语言比汉语更加严 谨吗?

李: 是的。从语言形式的角度来看, 欧洲语言确实比汉语严谨。欧洲语言内部也有不小的区别, 例如, 德语、法语就比英语严谨, 尽管从语言形成的历史上看, 可以说英语是从德 语、法语杂交而来的。

这里的所谓“严谨”, 是指这些语言有比较充分的显性形式来表达结构关系, 有助于减少歧义。汉语显性形式不足, 因此增加了汉语解析 (Chinese parsing) 的难度。形态是重要的显性形式, 如名词的“性数格” (gender, number and case), 动词的“时体态”(tense, aspect and voice), 这些词法范畴是以显性的形态词尾来表达的。但是这类形态汉语里没有。形态丰富的语言语序比较自由, 譬如俄语。再如世界语 (Esperanto) 的“我爱你”有三个词, 可以用六种语序任意表达, 排列组合。为什么语序自由呢? 因为有宾格 (object case) 这样的形态形式, 它跑到哪里都逃不出动宾 (verb-object) 关系, 当然就不需要依赖固定的语序了。

汉语在发展过程中, 没有走形态化的道路, 而是利用语序和小词在孤立语的道路上演化. 英语的发展大体也是这个模式。从语言学的高度看, 形态也好, 小词也好, 二者都是可以感知的显性形式。但是, 形态词尾的范畴化, 比起小词 (主要是介词), 要发达得多。动词变位、名词变格等形态手段, 使得有结构联系的语词之间产生一种显性的一致关系  (agreement)。譬如, 主谓 (subject predicate) 在人称和数上的一致关系, 定语与中心词在性数格上的一致关系等。关系有形式标记, 形态语言的结构自然严谨得多, 减少了结构歧义的可能。丰富的形态减低了解析对于隐性形式和知识的依赖。

郭 : 常听人说,中文是“意合”式语言, 缺少硬性的文法规范, 是不是指的就是缺乏形态, 主要靠语义手段来分析理解它?

李: 是的. 从语言形式化的角度看, 语义手段表现为隐性形式。所谓“意合”, 其实就是关联句词之间的语义相谐, 特别是谓词 (predicate word) 结构里面语义之间的搭配  (collocation) 常识。譬如, 谓词“吃”的对象是“食品”。这种 常识通常编码在本体知识库 (ontology) 里面。董振东先生创立的“知网 (HowNet)”∗ 就是这样一个本体常识的知识库。

∗ “知网” (HowNet) 是中国自然语言处理前辈董振东先生发明的跨语言的语义机器词典。这套词典为词义的本体概念及其常识编码, 旨在设立一套形式化语义概念网络, 以此作为自然语言处理的基础支持。

再看形态与小词的使用。譬如, “兄弟”在汉语里是名词, 这个词性是在词典标注的。但是世界语的“frato (兄弟)”就不需要词典标注, 因为有名词词尾“-o”。再如复数, 汉语的 “兄弟们”用了小词“们”来表示复数的概念; 世界语呢, 用词尾 “-j”表示, 即“fratoj (兄弟们)”。乍一看, 这不一样么? 都是 用有限的语言材料, 做显性的表达。但是, 有“数”这个词法范 畴的欧洲语言 (包括世界语), 那个形态是不能省略的。而汉语的复数表达, 有时显性有时隐性,这个“们”不是必需的, 如:

三个兄弟没水喝。

这里的兄弟复数就没有小词“们”。实际上, 汉语文法规定了不允许在数量结构后面加复数的显性形式, 譬如不能说 “三个兄弟们”。换句话说, 中文“(三个)兄弟”里的复数是隐性的,需要前面的数量结构才能确定。

郭: 看来缺乏形态的确是中文的一个挑战。中文学起来难, 自动解析也难。有人甚至说, 中文根本就没有文法。

李: 那是偏激之词了。不存在没有文法的语言。假如语 言没有“法”, 那么人在使用时如何把握, 又如何理解呢? 只不 过是, 中文的文法更多地依赖隐性形式。

汉语文法的确比较宽松, 宽松表现在较少依赖显性形式。语句的顺畅靠的是上下文语义相谐, 而不是依靠严格的显性文法规则。譬如形态、小词、语序, 显性形式的三个手段, 对于 汉语来说, 形态基本上没有, 小词常常省略, 语序也很灵活。

先看小词,譬如, 介词、连词, 虽然英语有的汉语基本都有, 但是汉语省略小词的时候远远多于英语。这是有统计根据的, 也符合我们日常使用的感觉: 中文, 尤其是口语, 能省则省,显得非常自由。对比下列例句, 可见汉语中省略小词是普遍性的:

① 对于这件事, 依我的看法, 我们应该听其自然.
As for this matter, in my opinion, we should leave it to nature.

② 这件事我的看法应该听其自然.
∗ This matter my opinion should leave it to nature.

类似句子②在汉语口语里极为常见, 感觉很自然。如果尝试词对词译成英语, 则完全不合文法。汉语和英语都用介词短语 (prepositional phrase, PP) 做状语, 可是汉语介词常可 省略。这种缺少显性形式标记的所谓“意合”式表达, 确实使得中文的自动化处理比英文处理难了很多。

郭: 汉语利用语序的情况如何? 常听人说, 形态丰富的语言语序自由。汉语缺乏形态, 因此是语序固定的语言。中文一般被认为是“主谓宾(SVO)”固定的语言。

李: 可惜啊, 并非如此。按常理来推论, 缺乏形态又常常省掉小词, 那么, 语序总该固定吧? 可实际上, 汉语并不是持孤立语语序固定论者说的那样语序死板, 其语序的自由度常超出一般人的想象。

拿最典型的主谓宾句型的变式来看, SVO 三元素, 排列的极限是六种组合。世界语的形态不算丰富, 论变格只有一 个宾格“-n”的词尾, 主格 (subject case) 是零形式。它仍然可以采用六种变式的任意一个语序, 而不改变“SVO”的逻辑语义关系 (logic semantic relation)。比较一下形态贫乏的英语 (名词没有格变, 但是代词有) 和缺乏形态的汉语 (名词代词都没有格变), 是很有意思的。世界语、英语、汉语三种语言 SVO 句型的自由度对比如下:

①SVO:

Mi manĝis fiŝon.
I ate fish.
我吃了鱼。

②SOV:

Mi fiŝon manĝis.
∗ I fish ate.
我鱼吃了。

③VOS:

Manĝis fiŝon mi.
∗ Ate fish I.
? 吃了鱼我。(口语可以)

④VSO:

Manĝis mi fiŝon.
∗ Ate I fish.
∗ 吃了我鱼。(解读不是VSO, 而是“吃了我的鱼”)

⑤OVS:

Fiŝon manĝis mi.
∗ Fish ate I.(不允许, 尽管“I”有主格标记)
? 鱼吃了我。(合法解读是SVO,与OVS正好相反)

⑥OSV:

Fiŝon mi manĝis.
fish I ate.
鱼我吃了。

总结一下, 在六个语序中, 汉语有三个是合法的, 有两个在灰色地带 (前标“? ”, 口语中似可存在), 有一个是非法的 (前标 “∗ ”),英语呢? 只有两个合法, 其余皆非法。可见, 汉语的语序自由度在最常见的SVO句式中,  比英语要大一倍。虽然英语有代词的格变(I/me), 而汉语没有, 英语的语序灵活性反而不如汉语。可见, 形态的丰富性与语序自由度并非必然呼应。

汉语其实比很多人想象得具有更大的语序自由度和弹 性。常常是, 思维里什么概念先出现, 就可以直接蹦出来。再看一组例子:

张三眼睛哭肿了。
眼睛张三哭肿了。
哭肿张三眼睛了。
张三哭肿眼睛了。
哭得张三眼睛肿了。
张三哭得眼睛肿了。
张三眼睛哭得肿了。
张三的眼睛哭肿了。
............

若不研究实际数据的话, 我们很难相信汉语语序如此任性。汉语依赖隐性形式比显性形式更多, 这对自动解析显然不利。我们当然希望语言都是语序固定的, 这该省多少力气啊!  序列模式规则就是由符号加次序构成的, 语序灵活了, 规 则数量就得成倍增长。非语序的其他形式约束可以在既定的模式里面调控, 唯有语序是规则编码绕不过去的坎儿。

李维 郭进《自然语言处理答问》(商务印书馆 2020)