<?xml version="1.0" encoding="utf-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" version="2.0"><channel><title>无尘阁日记</title><link>https://www.jiangtian.top/</link><description>无尘阁，红尘炼心。君子性非异也，善假于物也。</description><item><title>我卖出去的到底是不是劳动力？</title><link>https://www.jiangtian.top/post/17797.html</link><description>&lt;p&gt;我卖出去的不是劳动力，是别人能够支配的那段时间。&lt;/p&gt;
&lt;p&gt;先把这句话揉碎了看。咱们嘴上说“出卖劳动力”，说了半辈子，可是真要掰开看，卖的到底是哪一样东西，多数人答不上来。&lt;/p&gt;
&lt;p&gt;劳动力这三个字，是个会计词。它把活生生的人折算成单子上的数字，方便计价，方便比价，方便砍价。人一旦被折算成数字，很多东西就漏掉了。&lt;/p&gt;
&lt;p&gt;最直观的是力气。我坐在电脑前面一整天，手心连茧子都没有。真要按出的力气给钱，我拿的钱应该比工地上的师傅少。&lt;/p&gt;
&lt;p&gt;可是我的工资比他们高。差别在什么地方？差别在于，我卖出去的那点力气里面，裹着判断。&lt;/p&gt;
&lt;p&gt;判断这个东西，值钱。同一个需求，新手磨三天，熟手干三个小时。省下来的那些工夫，买的不是手速，是脑子里的路数。&lt;/p&gt;
&lt;p&gt;问题马上来了。判断长在我脑子里面，老板买不走。他真正买走的，是坐在工位上按他安排干活的那几个小时。&lt;/p&gt;
&lt;p&gt;所以账要这么算。我卖的不是能力，是能力被使用的那段时间。能力还长在我身上，时间已经交出去了。&lt;/p&gt;
&lt;p&gt;这么一算，很多事情就通了。跳槽为什么要重新谈价钱？因为同样的时间换了一个买家，使用方式变了，价格跟着变。&lt;/p&gt;
&lt;p&gt;计价也是同理。兼职为什么按小时算？因为小时是最小的交易单位，老板验收不了每一份产出，只好按时间买。&lt;/p&gt;
&lt;p&gt;可是时间这个说法，也有漏洞。人在工位上坐满十个小时，脑子有两个小时在开小差。这两个小时，算不算卖出去了？&lt;/p&gt;
&lt;p&gt;这个问题先放着。下一篇接着掰。&lt;/p&gt;</description><pubDate>Tue, 03 Nov 2026 19:06:17 +0800</pubDate></item><item><title>深度学习：它最大的价值是坦白自己哪里还没解决</title><link>https://www.jiangtian.top/post/17796.html</link><description>&lt;p style=&quot;font-size:13px;color:#8A857C;line-height:1.9;margin:0 0 22px;padding:12px 16px;background:#F7F6F3;border-radius:8px;&quot;&gt;
微信读书《深度学习》· Ian Goodfellow、Yoshua Bengio、Aaron Courville 著，张志华 审校（俗称&quot;花书&quot;）&lt;br&gt;
逐页翻阅 &lt;strong style=&quot;color:#5A5248;&quot;&gt;1210 屏&lt;/strong&gt; · &lt;strong style=&quot;color:#5A5248;&quot;&gt;20&lt;/strong&gt; 章 · 2026-11-03&lt;br&gt;
&lt;span style=&quot;font-size:12px;&quot;&gt;说明：这不是一本&quot;读完就能做项目&quot;的书，也不是一本&quot;读不懂就别读&quot;的书。作者自己在开头就把读法说清楚了——三个部分，读者可以按目标裁剪路径。我这 1210 屏读下来的最大感受是：它真正的价值不在它讲的那些知识（这些知识网上都有），而在它&lt;strong&gt;承认自己哪里不确定&lt;/strong&gt;。一本敢把&quot;这部分还只是展望&quot;写进书里的教材，比一本什么都说得很肯定的教材可信得多。&lt;/span&gt;
&lt;/p&gt;

&lt;p&gt;先说一个可能有点反常识的判断：&lt;strong&gt;2026 年读花书，最有价值的部分不是第 2 部分（现代实践），而是第 1 部分（数学基础）和第 3 部分（研究）。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;第 2 部分讲的前馈网络、正则化、优化、卷积、循环网络，现在随便一个框架的文档都比它讲得更新、更实用。但第 1 部分那些数学，是十年不会变的东西；第 3 部分那些&quot;还没解决的问题&quot;，是你能看到这个领域真实边界的地方。中间那层最实用的内容，恰恰是最先过期的。&lt;/p&gt;

&lt;p&gt;下面我按自己的读法走一遍，重点不在复述章节，而在于讲清楚这本书到底在教什么、以及它有哪些地方其实已经不够用了。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;一、作者自己给的读法，比大多数导读都诚实&lt;/h2&gt;

&lt;p&gt;开篇有一段话，我觉得值得原样抄下来：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;第 1 部分介绍基本的数学工具和机器学习的概念。第 2 部分介绍最成熟的深度学习算法，这些技术基本上已经得到解决。第 3 部分讨论某些具有展望性的想法，它们被广泛地认为是深度学习未来的研究重点。&lt;/p&gt;

&lt;p&gt;然后是那句最关键的：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;若读者只是想实现一个能工作的系统，则不需要阅读超出第 2 部分的内容。&lt;/p&gt;

&lt;p&gt;这句话看似是体贴读者，实际上是一个判断：&lt;strong&gt;这本书不认为&quot;能跑起来&quot;需要懂第 3 部分。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;我很欣赏这个态度。因为现在很多技术书有一种隐含的傲慢——它默认你要成为研究者，于是把所有细节都堆上来；或者反过来，它默认你只想抄代码，于是把原理全砍掉。花书是少见的、明确区分&quot;够用&quot;和&quot;够深&quot;的书。它告诉你哪条线在哪，让你自己选。&lt;/p&gt;

&lt;p&gt;而且注意它用的词——&quot;&lt;strong&gt;基本上已经得到解决&lt;/strong&gt;&quot;。这个措辞在今天看来是要打折扣的：第 2 部分讲的很多东西，放在 2026 年已经不是&quot;最优解&quot;了。但那是另一回事，我在&quot;短板&quot;里说。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;二、Dirac delta：一个看似多余的数学对象，其实是&quot;经验分布&quot;的地基&lt;/h2&gt;

&lt;p&gt;第 3 章讲概率与信息论，里面有个细节我读的时候停了一下——Dirac delta 函数。&lt;/p&gt;

&lt;p&gt;书的定义是：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;Dirac delta 函数被定义成在除了 0 以外的所有点的值都为 0，但是积分为 1。Dirac delta 函数不像普通函数一样对 x 的每一个值都有一个实数值的输出，它是一种不同类型的数学对象，被称为广义函数。&lt;/p&gt;

&lt;p&gt;为什么这个看起来很奇怪的东西值得专门讲？因为它解决了一个非常实际的问题：&lt;strong&gt;你怎么用数学语言描述&quot;我手上有一堆样本&quot;这件事？&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;书的答案是这样：把每个样本点当成一个&quot;无限窄、无限高&quot;的峰，峰的面积是 1。所有峰加起来，就得到了&quot;经验分布&quot;：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;经验分布将概率密度赋给 m 个点 x(1), …, x(m) 中的每一个，这些点是给定的数据集或者采样的集合。只有在定义连续型随机变量的经验分布时，Dirac delta 函数才是必要的。&lt;/p&gt;

&lt;p&gt;最后那句话是重点——&quot;只有在连续型随机变量的经验分布时&quot;。离散情形更简单，直接数频次就行（多项式分布）。连续情形才麻烦：一个精确的点，在连续空间里出现的概率是 0，你没法说&quot;这个点的概率是 1/m&quot;。Dirac delta 就是用来&quot;作弊&quot;的：它把&quot;一个点&quot;变成&quot;一块面积&quot;，让概率密度这个框架能容纳离散的观测。&lt;/p&gt;

&lt;p&gt;我为什么觉得这个细节重要？因为它体现了一种很典型的数学思维：&lt;strong&gt;当现有工具描述不了你的直觉时，就造一个新的数学对象。&lt;/strong&gt;Dirac delta 在工程里被用滥了（信号处理里到处都是），但真正理解它&quot;不是函数&quot;这件事的人不多。大多数人把它当成&quot;一个特别尖的尖峰&quot;来用，勉强能算对，但一旦要做严格的推导就会出错。&lt;/p&gt;

&lt;p&gt;这本书在这里花篇幅讲清楚它的性质，其实是在帮你避坑。这种&quot;看似多余、实则关键&quot;的段落，是花书最值得读的地方。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;三、XOR：一个 1969 年的失败，定义了后面五十年的主线&lt;/h2&gt;

&lt;p&gt;第 6 章讲深度前馈网络，用的切入点是 XOR 问题。我觉得这个选择非常聪明。&lt;/p&gt;

&lt;p&gt;书的推理过程是这样的：先用线性模型去拟合 XOR，用 MSE 作代价函数，然后解正规方程。结果是——两个权重都变成 0，模型在任何输入下都输出 0.5。&lt;/p&gt;

&lt;p&gt;书里的原话很克制：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;线性模型仅仅是在任意一点都输出 0.5。为什么会发生这种事？解决这个问题的一种方法是使用一个模型来学习一个不同的特征空间，在这个空间上线性模型能够表示这个解。&lt;/p&gt;

&lt;p&gt;这一段其实是整本书的隐喻。&lt;strong&gt;XOR 的问题是&quot;线性不可分&quot;，而解决它的方法不是&quot;用更复杂的分类器&quot;，而是&quot;换一个空间&quot;。&lt;/strong&gt;——先学一个特征变换 h，把数据映射到 h 空间，在那里线性可分。&lt;/p&gt;

&lt;p&gt;这个思路一旦点破，后面所有的东西就都串起来了：深度网络就是&quot;多层特征变换的堆叠&quot;，卷积是&quot;利用空间结构的特征变换&quot;，循环网络是&quot;利用时间结构的特征变换&quot;，自编码器是&quot;学一个能还原的特征变换&quot;。&lt;strong&gt;整本书讲的，其实都是&quot;怎么学到一个好的特征空间&quot;。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;而书里顺手埋了一句更重要的话，在讲代价函数的时候：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;在应用领域，对二进制数据建模时，MSE 通常并不是一个合适的代价函数。&lt;/p&gt;

&lt;p&gt;这句话杀伤力很大。因为绝大多数入门教程都是从&quot;用 MSE 做回归&quot;开始的，于是很多人的默认心智是&quot;MSE 是通用的损失函数&quot;。但在分类任务里，MSE 会导致梯度消失、收敛慢、对异常值敏感。正确选择是交叉熵。这个知识点本身不难，难的是&lt;strong&gt;在学的时候就知道&quot;默认选项可能是错的&quot;&lt;/strong&gt;。&lt;/p&gt;

&lt;p&gt;我读到这里最大的感想是：这本书真正教的不是&quot;某个算法怎么推导&quot;，而是&quot;&lt;strong&gt;为什么某个选择在某个场景下是错的&lt;/strong&gt;&quot;。前者可以查，后者只能靠经验或好书。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;四、AdaGrad：一个&quot;看起来很简单&quot;的优化器，藏着对&quot;重要性&quot;的判断&lt;/h2&gt;

&lt;p&gt;第 8 章讲优化，AdaGrad 的算法框我看了两遍。&lt;/p&gt;

&lt;p&gt;它的核心就三步：累积历史梯度的平方（r ← r + g ⊙ g），计算更新量（用全局学习率除以 √r），应用更新。书里对那个小常数 δ 的解释很实在：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;小常数 δ，为了数值稳定大约设为 10⁻⁷。&lt;/p&gt;

&lt;p&gt;为什么需要它？因为如果 r 是 0，除零会炸。这个细节很多教程会跳过，但它恰恰是&quot;能跑&quot;和&quot;跑崩&quot;的分界线。&lt;/p&gt;

&lt;p&gt;而 AdaGrad 的设计思想，比算法本身更有意思：&lt;strong&gt;它给每个参数一个&quot;自适应&quot;的学习率，历史上梯度一直很大的参数，步子自动变小；历史上梯度一直很小的参数，步子相对大一些。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;这个设计的直觉是：梯度大说明这个方向很&quot;陡&quot;，容易走过头，所以要小心；梯度小说明这个方向很&quot;平&quot;，可以大胆走。听起来很合理，但它有个明显的缺陷——累积平方梯度只增不减，所以学习率会单调递减，训练久了会几乎停下来。这也是为什么后来有了 RMSProp、Adam 这些改进版。&lt;/p&gt;

&lt;p&gt;书里对这些后续发展讲得不多（毕竟成书于 2016 年）。这构成了一个具体的&quot;过期点&quot;：&lt;strong&gt;如果你照着书里的优化器清单去选，你会选到一个 2026 年基本没人用的算法。&lt;/strong&gt;但这不影响它讲清楚&quot;为什么要自适应&quot;这件事——理解了动机，你去看 Adam 的论文会快很多。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;五、配分函数：第 3 部分真正的&quot;反派&quot;&lt;/h2&gt;

&lt;p&gt;第 3 部分读起来明显比前两部分吃力，原因不是数学更难，而是&lt;strong&gt;它面对的问题本身就没有干净的解&lt;/strong&gt;。而这些问题几乎都指向同一个东西：配分函数。&lt;/p&gt;

&lt;p&gt;书里在讲基于能量的模型时，把这件事说得很直接：许多对概率模型进行操作的算法不需要计算 p_model(x)，而只需要计算它的（未归一化的）形式。但一旦要归一化，就得算那个求和/积分——而它通常算不出来。&lt;/p&gt;

&lt;p&gt;为了绕开这个死结，书里给了一系列工具：蒙特卡罗方法（采样近似）、直面配分函数（用近似方法估它）、近似推断（不精确算，只求够用）、深度生成模型（设计成不需要算它）。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;这四章连起来看，其实是在讲一件事：当精确解不存在时，工程上怎么退而求其次。&lt;/strong&gt;而这个&quot;退&quot;，是有讲究的——不是随便近似，而是要知道近似的误差在哪、什么时候会崩。&lt;/p&gt;

&lt;p&gt;书里讲稀疏编码那一节，把这个&quot;退&quot;讲得很具体。它说，如果用 Laplace 先验逼稀疏，那么&quot;使用最大似然的方法来训练稀疏编码模型是不可行的&quot;。怎么办？&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;相反，为了在给定编码的情况下更好地重构数据，训练过程在编码数据和训练解码器之间交替进行。稍后在第 19.3 节中，这种方法将被进一步证明为解决最大似然问题的一种通用的近似方法。&lt;/p&gt;

&lt;p&gt;&quot;交替进行&quot;——这四个字在工程里出现的频率极高。因为很多问题没法一步解出来，只能&quot;固定 A 优化 B，再固定 B 优化 A&quot;，来回迭代。这个方法在数学上不优雅，在实践中极其有效（EM 算法、GAN 训练、甚至很多现代的对齐方法，内核都是这个套路）。&lt;/p&gt;

&lt;p&gt;我觉得第 3 部分的价值就在这：&lt;strong&gt;它不给你答案，它给你&quot;当答案不存在时该怎么办&quot;的方法论。&lt;/strong&gt;而这个方法论，比任何具体算法都活得久。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;六、d-分离：图模型里最容易被跳过、也最该掌握的一节&lt;/h2&gt;

&lt;p&gt;第 16 章讲结构化概率模型，其中 16.2.5 节讲&quot;分离和 d-分离&quot;。这一节篇幅不大，但我觉得它是整本书里&quot;投入产出比&quot;最高的内容之一。&lt;/p&gt;

&lt;p&gt;书里的问题设定很清楚：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;图模型中的边告诉我们哪些变量直接相互作用。我们经常需要知道哪些变量间接相互作用。某些间接相互作用可以通过观察其他变量来启用或禁用。更正式地，我们想知道在给定其他变量子集的值时，哪些变量子集彼此条件独立。&lt;/p&gt;

&lt;p&gt;&quot;&lt;strong&gt;通过观察其他变量来启用或禁用&lt;/strong&gt;&quot;——这句话是 d-分离的精髓，也是它反直觉的地方。&lt;/p&gt;

&lt;p&gt;在因果推断里，这件事有一个更出名的说法：&lt;strong&gt;对撞因子（collider）&lt;/strong&gt;。两个本来独立的变量，如果你去&quot;控制&quot;它们的共同结果，它们反而会变得相关。这是很多数据分析里翻车的根源——你以为控制了更多变量就更准确，实际上你引入了一个虚假的关联。&lt;/p&gt;

&lt;p&gt;花书在这里讲的是纯数学版本的表述，没有展开因果推断的那一层（毕竟它是一本深度学习书）。但我认为，&lt;strong&gt;任何做数据分析的人，都应该认真读这一节&lt;/strong&gt;。因为&quot;控制变量&quot;这件事被滥用得太厉害了，而 d-分离给了你一个严格的判断工具：什么时候该控制，什么时候控制反而会害了你。&lt;/p&gt;

&lt;p&gt;这也是我觉得花书被低估的一个方面。大家把它当成&quot;神经网络教材&quot;，但它前几部分讲的概率图模型、条件独立、结构化建模，其实是更通用的数据分析素养。只不过这些内容被&quot;深度学习&quot;的书名盖住了。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;七、它的短板&lt;/h2&gt;

&lt;p&gt;花书是经典，但&quot;经典&quot;不等于&quot;现在读还够用&quot;。我说几个我认为必须提醒的问题，尤其是给准备花时间读它的人。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第一，也是最致命的：它的&quot;现代&quot;已经不现代了。&lt;/strong&gt;这本书成书于 2016 年。第 2 部分讲的&quot;现代实践&quot;，在今天看来很多已经是历史——批量归一化的地位变了、优化器换了几代、正则化的手段多了不少、卷积网络的统治地位被 Transformer 大幅侵蚀。更关键的是，&lt;strong&gt;整本书几乎没有讲 Transformer&lt;/strong&gt;（注意力机制只在第 12 章的应用部分被简单提及，没有展开）。而在 2026 年，不懂注意力机制基本等于不懂深度学习。这不是作者的错，是时代跑得太快，但读者必须知道这一点。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第二，它的数学门槛被严重低估了。&lt;/strong&gt;很多人推荐这本书时说&quot;数学要求不高，会点线代和微积分就行&quot;。这是误导。第 3 部分大量使用测度论味道的表述、变分推断、蒙特卡罗方法，没有扎实的概率论和统计基础，读起来会非常痛苦——不是&quot;看不懂每个字&quot;，而是&quot;看懂了每个字但不知道在说什么&quot;。&lt;strong&gt;这本书不是入门书，它是&quot;有基础之后回头补齐体系&quot;的书。&lt;/strong&gt;把它当第一本深度学习书读，大概率会在第 3 章卡住。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第三，它几乎没有工程内容。&lt;/strong&gt;1210 屏里，讲&quot;怎么训练一个真正能用的模型&quot;的内容非常少。超参数怎么调、数据怎么清洗、训练不收敛怎么排查、分布式怎么部署、显存不够怎么办——这些在真实工作里占 80% 时间的问题，书里基本没有。它有第 11 章&quot;实践方法论&quot;，但那一章的建议偏原则性（比如&quot;选择合适的算法&quot;、&quot;决定是否收集更多数据&quot;），不够具体。&lt;strong&gt;这本书教你&quot;为什么&quot;，不教你&quot;怎么办&quot;。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第四，它的案例太&quot;古典&quot;了。&lt;/strong&gt;书里的例子绝大多数是 MNIST、CIFAR、IMDB 影评这类标准数据集。这些例子干净、规整、规模小，非常适合讲原理，但和真实业务数据的差距很大。&lt;strong&gt;你读完会觉得自己懂了，一上手真实数据就会发现：脏数据、类别不平衡、标注噪声、长尾分布——这些书里都没怎么讲。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第五，翻译质量参差。&lt;/strong&gt;中文版由多位译者合作完成，术语不统一的情况不少。有些地方&quot;配分函数&quot;&quot;归一化常数&quot;混用，有些地方数学表述被译得模糊，需要回头对英文原版。这不是致命问题，但确实增加了阅读成本。&lt;span style=&quot;color:#8A857C;&quot;&gt;（顺带一提，书里不少公式在电子版里显示不完整，这是排版层面的问题。）&lt;/span&gt;&lt;/p&gt;

&lt;p&gt;说完这些，我还是认为它值得读——&lt;strong&gt;但要换个读法。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;不要从头读到尾。正确的读法是：把它当成一本&lt;strong&gt;字典&lt;/strong&gt;。你在做项目时遇到&quot;为什么这个损失函数不收敛&quot;，回来查第 8 章；遇到&quot;为什么加了 BN 效果变好&quot;，回来查第 8 章的正则化部分；遇到&quot;条件独立怎么判断&quot;，回来查第 16 章。&lt;strong&gt;带着问题回查，比线性通读有效十倍。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;而如果你是做研究的，那第 3 部分值得精读——不是因为它的结论还对，而是因为它示范了&quot;&lt;strong&gt;面对一个没有干净解的问题，一个严肃的研究者是怎么组织思路的&lt;/strong&gt;&quot;。这个能力，比任何具体知识都保值。&lt;/p&gt;

&lt;figure style=&quot;margin:34px 0 30px;text-align:center;&quot;&gt;
  &lt;img src=&quot;https://www.jiangtian.top/zb_users/upload/kg/deep-learning-flower.png&quot; alt=&quot;深度学习 花书 核心知识图谱&quot; style=&quot;max-width:100%;border-radius:10px;box-shadow:0 6px 24px rgba(0,0,0,.09);&quot;&gt;
  &lt;figcaption style=&quot;font-size:12px;color:#8A857C;margin-top:12px;&quot;&gt;核心知识图谱：数学地基 → 成熟算法 → 前沿研究 → 怎么读它&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;一句话总结：&lt;strong&gt;花书的价值不在于它讲对了多少，而在于它坦白了哪些还没解决——一本敢说&quot;这部分只是展望&quot;的教材，比一本什么都很确定的教材，更能帮你建立真正的判断力。&lt;/strong&gt;&lt;/p&gt;

&lt;hr style=&quot;border:none;border-top:1px solid #E3E0D9;margin:36px 0 18px;&quot;&gt;
&lt;p style=&quot;font-size:12px;color:#97938B;line-height:1.9;&quot;&gt;阅读记录：《深度学习》，Ian Goodfellow、Yoshua Bengio、Aaron Courville 著，张志华 审校，微信读书逐页翻阅 &lt;strong&gt;1210 屏&lt;/strong&gt;，二十章读完，从线性代数、概率论读到深度生成模型与近似推断。2026-11-03。&lt;/p&gt;
</description><pubDate>Tue, 03 Nov 2026 18:59:17 +0800</pubDate></item><item><title>Building AI Agents：地基不是模型，是编码、检索和记忆</title><link>https://www.jiangtian.top/post/17795.html</link><description>&lt;p style=&quot;font-size:13px;color:#8A857C;line-height:1.9;margin:0 0 22px;padding:12px 16px;background:#F7F6F3;border-radius:8px;&quot;&gt;
微信读书《Building AI Agents with LLMs, RAG, and Knowledge Graphs》· Salvatore Raieli、Gabriele Iuculano 著，Packt 出版，中英双语对照版&lt;br&gt;
逐页翻阅 &lt;strong style=&quot;color:#5A5248;&quot;&gt;1714 屏&lt;/strong&gt; · &lt;strong style=&quot;color:#5A5248;&quot;&gt;4&lt;/strong&gt; 部 · 2026-11-03&lt;br&gt;
&lt;span style=&quot;font-size:12px;&quot;&gt;说明：这本书的编排逻辑我很欣赏——它没有一上来就讲 Agent，而是从&quot;文本怎么变成向量&quot;开始。四个部分依次是：文本与模型、Agent 构建、RAG 与知识图谱、生产化。这个顺序本身就是个判断：&lt;strong&gt;Agent 是果子，不是根。&lt;/strong&gt;先有能编码文本的模型，再有能检索的知识，再有能编排的流程，最后才谈得上智能体。缺点是它太全，1714 屏什么都讲，什么都讲不深。&lt;/span&gt;
&lt;/p&gt;

&lt;p&gt;现在讲 Agent 的书，大多从 ReAct 或者某个框架的 hello world 开始。这本书反过来，用整整一部（Part 1）讲怎么把一句话变成一串数字。&lt;/p&gt;

&lt;p&gt;一开始我觉得这是凑篇幅。读到后面才明白：&lt;strong&gt;作者的用意是让你知道，Agent 的每一个&quot;聪明&quot;，底下都压着一层并不聪明的数学。&lt;/strong&gt;检索靠的是向量距离，重排靠的是打分，蒸馏靠的是分布差。这些东西不性感，但它们决定了 Agent 在真实场景里是&quot;大概能用&quot;还是&quot;稳定能用&quot;。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;一、文本变成向量的四代方案，以及每一代的代价&lt;/h2&gt;

&lt;p&gt;第一部分梳理了文本表示的四条路，我觉得这个梳理比大多数教程都清楚，因为它不是简单罗列，而是按&quot;丢掉了什么&quot;来排序。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;one-hot 编码&lt;/strong&gt;：一个词一个位置，其余全零。问题是维度爆炸，而且任意两个词之间的距离都一样——&quot;猫&quot;和&quot;狗&quot;的距离，等于&quot;猫&quot;和&quot;量子力学&quot;的距离。这在语义上显然是错的。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;词袋（bag-of-words）&lt;/strong&gt;：把句子变成词频向量。它解决了维度问题，但丢掉了语序——&quot;狗咬人&quot;和&quot;人咬狗&quot;在它眼里是同一个东西。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;TF-IDF&lt;/strong&gt;：给词加权，越罕见的词权重越高。这个改进很聪明，因为它抓住了&quot;区分度&quot;这个概念——&quot;的&quot;出现一百次也没用，&quot;芯片&quot;出现一次就说明这段在讲芯片。但它仍然是词袋，仍然不懂语序，也不懂同义。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;嵌入（embedding）&lt;/strong&gt;：把词映射到一个连续空间，语义相近的词距离近。到这里，&quot;猫&quot;和&quot;狗&quot;终于比&quot;猫&quot;和&quot;量子力学&quot;更近了。书里从 word2vec 讲起，讲了嵌入的性质，以及怎么用它们做情感分析。&lt;/p&gt;

&lt;p&gt;我的评价是：&lt;strong&gt;这四代不是&quot;越来越好&quot;，而是&quot;用不同的方式丢失信息&quot;。&lt;/strong&gt;one-hot 丢失了语义关系，词袋丢失了语序，TF-IDF 丢失了上下文，嵌入丢失了精确性（一个词永远只有一个向量，不管它在句子里是什么意思）。理解这一点很重要，因为它解释了为什么今天的 RAG 还是经常检索错——&lt;strong&gt;不是检索算法不够好，是&quot;把语义压成一个向量&quot;这个动作本身就有损。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;这也顺带解释了为什么书后面要专门讲知识图谱。向量检索擅长&quot;意思相近&quot;，不擅长&quot;关系明确&quot;。你问&quot;张忠谋创立了哪家公司&quot;，向量能给你一堆讲台积电的段落；但你问&quot;谁创立了台积电，他之前在哪个公司&quot;，这就需要&quot;人—创立—公司&quot;这种结构化的关系，向量的模糊匹配就吃力了。&lt;strong&gt;知识图谱补的正是这个洞。&lt;/strong&gt;&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;二、蒸馏：教师教学生，教的是&quot;分布&quot;不是&quot;答案&quot;&lt;/h2&gt;

&lt;p&gt;书里讲知识蒸馏那一段，是我认为全书技术含量最高、也最容易被略过的地方。&lt;/p&gt;

&lt;p&gt;它的流程分三步：先选一个合适的分词器（书里特意提醒，&quot;尽管 GPT-2 所使用的分词器应用最为广泛，但事实上不同模型需要使用不同的分词器&quot;），然后针对具体任务微调出一个&quot;教师模型&quot;，最后用这个教师去训练一个更小的&quot;学生模型&quot;。&lt;/p&gt;

&lt;p&gt;关键在损失函数。书里写得很清楚：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;这个蒸馏损失函数用于计算&quot;教师&quot;的 logits 与&quot;学生&quot;的 logits 之间的损失。该函数通常使用 Kullback-Leibler 散度损失来计算两个概率分布之间的差异。&lt;/p&gt;

&lt;p&gt;为什么这件事值得单独说？因为它藏着一个很反直觉的洞察：&lt;strong&gt;学生学的不是&quot;正确答案&quot;，是&quot;教师认为各个答案分别有多可能&quot;。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;举个具体的例子。一张猫的图片，标签是&quot;猫&quot;。如果用普通分类损失训练，模型学到的信号是&quot;猫=1，其他=0&quot;。但教师模型给出的可能是&quot;猫 0.85、猞猁 0.10、狗 0.03、其他 0.02&quot;。这个分布里含有大量信息——它告诉学生&quot;猫和猞猁很像，和狗有点像，和汽车完全无关&quot;。这种信息叫&quot;暗知识&quot;（dark knowledge），它不在标签里，只在教师的输出里。&lt;/p&gt;

&lt;p&gt;用 KL 散度去对齐这个分布，学生学到的就不只是&quot;什么是对的&quot;，还有&quot;什么和什么接近&quot;。&lt;strong&gt;这就是为什么一个小得多的模型，靠蒸馏能逼近大模型的效果——因为它继承的不是答案，是教师对世界的整个&quot;相似性判断&quot;。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;书里还提了一句很实在的话：可以用&quot;一个比教师模型规模更小的预训练模型来进行训练——这样只需使用少量的训练样本即可完成模型的训练&quot;。这句话点出了蒸馏的工程价值：&lt;strong&gt;它不是用来提升效果的，是用来在效果基本不变的前提下，把成本打下来的。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;这一点我特别想强调。现在很多团队一做 Agent 就想着上最大的模型，结果成本压不住、延迟扛不住，最后项目死在这一步。而蒸馏提供的是另一条路：&lt;strong&gt;用大模型做&quot;教师&quot;离线生成高质量数据，用小模型在线服务。&lt;/strong&gt;这条路的代价是要多做一轮工程，收益是单位成本能降一个量级。这笔账，值得算。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;三、高级 RAG 的四个插件：真正有用的是&quot;重排&quot;&lt;/h2&gt;

&lt;p&gt;书里讲高级 RAG 的那一节，列了四个插件，我用下来觉得它的排序是对的：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;Reranker：该功能使我们能够对检索过程中获得的上下文信息进行排序。这是高级问答系统中应用最广泛的功能之一，因为事实证明它能够显著提升检索结果的质量。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;重排（Reranker）&lt;/strong&gt;之所以最有效，原因很朴素：初步检索用的是向量相似度，而向量相似度是&quot;粗筛&quot;——它快，但它只看&quot;意思像不像&quot;，不看&quot;能不能回答这个问题&quot;。重排用的是更贵的模型（通常是 cross-encoder），它把&quot;问题&quot;和&quot;候选段落&quot;放在一起看，判断&quot;这段能不能答这个问题&quot;。&lt;/p&gt;

&lt;p&gt;一个是&quot;看起来相关&quot;，一个是&quot;真的能答&quot;。这个差别在简单问题上不明显，在复杂问题上就是生死线。&lt;/p&gt;

&lt;p&gt;另外三个插件也各有用途，但优先级低一些：&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;查询改写（Query transformation）&lt;/strong&gt;——把用户那句含糊的话改成几个更明确的查询，目的是&quot;扩大检索范围，因为有些相关文档可能会被遗漏&quot;。它解决的是&quot;用户不会提问&quot;这个问题。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;查询路由（Query routing）&lt;/strong&gt;——&quot;这一机制使我们无法对所有查询采用相同的处理方式，而是能够制定相应的规则，从而提升查询效率&quot;。说白了就是分流：简单问题走便宜的路径，复杂问题走贵的路径。这个设计对成本控制非常关键。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;混合检索（Hybrid search）&lt;/strong&gt;——把关键词检索和向量检索结合。前者擅长精确匹配（比如产品型号、人名），后者擅长语义匹配。两者互补，能覆盖单一方法的盲区。&lt;/p&gt;

&lt;p&gt;我觉得这四个插件的排列，其实反映了一个成熟工程师的判断顺序：&lt;strong&gt;先保质量（重排），再保召回（改写），再控成本（路由），最后补短板（混合）。&lt;/strong&gt;而大部分教程的顺序是反的——先讲怎么搭向量库，最后才提一句&quot;可以加重排&quot;。这个顺序的差别，就是&quot;能跑&quot;和&quot;好用&quot;的差别。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;四、记忆：Agent 最像人的地方，也是最容易做假的地方&lt;/h2&gt;

&lt;p&gt;书里讲记忆模块，用了三个操作来定义它：读取（memory reading）、写入（memory writing）、反思（memory reflection）。&lt;/p&gt;

&lt;p&gt;原文对这个划分写得很细：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;内存读取检索信息以支持智能体的决策（增加上下文的连续性和一致性）；内存写入则允许保存对智能体与环境交互有用的信息（从而减少冗余，并克服非显著内存的限制）；而内存反思允许从对已存储信息的分析中得出洞见，从而可以调整行为以实现目标。&lt;/p&gt;

&lt;p&gt;这三件事里，我认为&quot;反思&quot;是最被低估的。&lt;/p&gt;

&lt;p&gt;读取和写入，本质上是数据库操作——存进去、取出来。任何做过工程的人都能想到。但&quot;反思&quot;不一样，它要求 Agent&lt;strong&gt;对自己存下来的东西再做一次加工&lt;/strong&gt;：不是简单地把记忆取出来用，而是从记忆里归纳出更高层的结论。&lt;/p&gt;

&lt;p&gt;举个例子。一个客服 Agent 记录了 20 次用户投诉。读取只能让它知道&quot;这 20 次分别是什么&quot;；反思能让它发现&quot;其中 14 次都提到了同一个物流延迟问题&quot;。前者是检索，后者是洞察。而真正有价值的 Agent，靠的是后者。&lt;/p&gt;

&lt;p&gt;书里还提了&quot;混合记忆机制&quot;——短期记忆局限于大语言模型的上下文窗口，长期记忆靠外部存储，&quot;从而让智能体的信息处理能力超出大语言模型的处理范围&quot;。这个设计很实用，但它也暴露了一个现实：&lt;strong&gt;所谓&quot;记忆&quot;，本质上是&quot;用外部存储去骗过上下文窗口的限制&quot;。&lt;/strong&gt;模型本身并没有真的记住什么，它只是每次都重新读一遍你喂给它的东西。&lt;/p&gt;

&lt;p&gt;这一点值得警惕。因为市面上很多号称&quot;有记忆&quot;的产品，做的其实就是&quot;把历史对话塞回上下文&quot;。对话一长，塞不下了，就&quot;忘&quot;了。&lt;strong&gt;真正的记忆需要取舍——记住什么、忘掉什么、怎么压缩。而取舍是判断，不是存储。&lt;/strong&gt;书里提到了&quot;避免重复和记忆溢出&quot;，算是点到了，但没有深入。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;五、强化学习：不用拆任务，直接给个目标&lt;/h2&gt;

&lt;p&gt;书里有一段讲强化学习和监督学习的区别，用了一个我觉得特别好的类比。&lt;/p&gt;

&lt;p&gt;它说，监督学习是把复杂问题拆成子问题、再制定解决方案；而强化学习是&quot;直接定义一个智能体必须解决的总体问题&quot;。然后给了通勤的例子：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;起初，你不会将任务分解为诸如&quot;了解公交时刻表&quot;、&quot;估算步行时间&quot;或&quot;优化出行时遇到的天气状况&quot;之类的子任务。相反，你会将整个目标视为一个整体：每天都能准时到达工作地点。&lt;/p&gt;

&lt;p&gt;这个类比之所以好，是因为它把&quot;监督 vs 强化&quot;这个抽象区别，落到了每个人都能体会的经验上。&lt;/p&gt;

&lt;p&gt;但它也暴露了强化学习的问题。通勤这件事，你可以靠反复试错学会，因为&lt;strong&gt;试错的成本很低&lt;/strong&gt;——走错一条路，多花十分钟而已。但如果任务错了要赔钱、要伤人、要违法呢？你就不能靠试错了。&lt;/p&gt;

&lt;p&gt;这解释了为什么强化学习在游戏、机器人、推荐系统里成功，在医疗、法律、金融这些高风险领域推进得很慢。&lt;strong&gt;不是算法不行，是试错的代价不允许。&lt;/strong&gt;书里没有明说这一层，但我觉得这是读者必须自己补上的一课。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;六、从脚本到产品：那句&quot;这还不能算产品&quot;&lt;/h2&gt;

&lt;p&gt;第四部分讲生产化，开头有一段话说得很不客气，我读完停了几秒：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;当我们使用 Python 编写脚本时，虽然可以生成能在电脑上运行的程序，但这还不能算是一款真正的产品……Streamlit 工具能够帮助我们快速搭建应用程序的原型，但这并不适合制作最终产品，尤其是当该产品需要被多名用户同时使用时。&lt;/p&gt;

&lt;p&gt;&quot;尤其当该产品需要被多名用户同时使用时&quot;——这句话是整段的关键。单用户跑通和多用户可用，中间隔着的不是&quot;加个界面&quot;，而是一整套工程：并发、隔离、限流、重试、监控、计费。&lt;/p&gt;

&lt;p&gt;书里接着讲了 MLOps 和 Docker，然后讲了四种商业模式：SaaS、MaaS、DaaS、RaaS。这一段我觉得写得挺清醒，因为它说了一句很多技术书不愿说的话：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;多智能体系统不是孤立的事物，而应被视为一种产品，并且这种产品可以以多种方式营销。&lt;/p&gt;

&lt;p&gt;这句话把一个纯技术问题，拉回到了商业现实。&lt;strong&gt;你做的不是&quot;一个 Agent&quot;，你做的是一件要卖出去的东西。&lt;/strong&gt;而要卖出去，你就得先想清楚：客户付的是什么钱？是订阅（SaaS）、是按调用量（MaaS）、是按数据（DaaS）、还是按结果（RaaS）？&lt;/p&gt;

&lt;p&gt;这个选择必须&quot;在产品开发之前&quot;做出，因为&quot;它们决定了产品的发展&quot;。这个判断我完全同意。因为不同的收费模式，倒逼出完全不同的架构：按调用量收费，你就得把每次调用的成本算到分；按结果收费，你就得对准确率负责到极致；按订阅收费，你就得保证稳定性和留存。&lt;strong&gt;商业模式不是商业部门的事，它从第一天就在决定技术选型。&lt;/strong&gt;&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;七、它的短板&lt;/h2&gt;

&lt;p&gt;这本书内容很全，但&quot;全&quot;恰恰是它最大的问题。我说四点。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第一，1714 屏什么都讲，结果什么都讲不透。&lt;/strong&gt;从 one-hot 编码讲到 Docker 部署，从 word2vec 讲到 RaaS 商业模式，跨度太大了。每一块大概只有几十屏，够&quot;知道有这么回事&quot;，不够&quot;真的会用&quot;。比如知识图谱那一部分，书名叫里有 &quot;Knowledge Graphs&quot;，但实际篇幅和深度都远不如 RAG 那部分。&lt;strong&gt;你读完之后会有一种&quot;我好像什么都见过了&quot;的错觉，但真要动手，还是得回去查文档。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第二，它是一本&quot;技术拼盘&quot;，缺少一条真正的主线论证。&lt;/strong&gt;四个部分之间的逻辑是&quot;从底到顶&quot;，这个没错，但它更像是&quot;把该讲的都讲一遍&quot;，而不是&quot;论证一个观点&quot;。对比一下那些真正好的技术书——它们会有一个贯穿全书的判断，每一章都在为这个判断服务。这本书没有。它更像一本编写得不错的教科书，而不是一本有观点的书。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第三，案例的工程真实性存疑。&lt;/strong&gt;书里的代码能跑，但都是&quot;干净的实验室环境&quot;：数据是准备好的、API 是通的、错误是不发生的。真实的 Agent 项目里，80% 的时间花在处理脏数据、调试不稳定的接口、排查&quot;为什么昨天好好的今天不行了&quot;。这些内容书里几乎没有。&lt;strong&gt;它教你怎么把东西搭起来，没教你怎么让它不倒。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第四，双语对照排版拖慢了阅读。&lt;/strong&gt;和上一本 Packt 的书一样，中英逐段对照看起来是照顾两类读者，实际上让两类读者都要不断跳读。而且译文的术语一致性不好，同一个概念在不同章节有不同译法，读的时候需要自己脑补对应关系。&lt;/p&gt;

&lt;p&gt;不过话说回来，&lt;strong&gt;这本书的定位本来就该是&quot;地图&quot;而不是&quot;手册&quot;。&lt;/strong&gt;它的价值在于让你知道这个领域有哪些层、每层大概在解决什么问题、彼此怎么衔接。你要盖房子，拿它当地图是够的；你要砌墙，还得去找专门的砖瓦匠。我读它的方式就是：先看目录建立框架，再挑自己缺的那块细读，其余的扫过去。&lt;strong&gt;这样读，1714 屏大概三天能过完，而且真的能记住东西。&lt;/strong&gt;&lt;/p&gt;

&lt;figure style=&quot;margin:34px 0 30px;text-align:center;&quot;&gt;
  &lt;img src=&quot;https://www.jiangtian.top/zb_users/upload/kg/agents-llm-rag-kg.png&quot; alt=&quot;Building AI Agents with LLMs RAG and Knowledge Graphs 核心知识图谱&quot; style=&quot;max-width:100%;border-radius:10px;box-shadow:0 6px 24px rgba(0,0,0,.09);&quot;&gt;
  &lt;figcaption style=&quot;font-size:12px;color:#8A857C;margin-top:12px;&quot;&gt;核心知识图谱：从文本到模型 → 蒸馏与压缩 → 检索与记忆 → 从脚本到产品&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;一句话总结：&lt;strong&gt;Agent 的上限不取决于你用了多强的模型，取决于你有没有耐心把底下那三层——编码、检索、记忆——做到不掉链子。&lt;/strong&gt;&lt;/p&gt;

&lt;hr style=&quot;border:none;border-top:1px solid #E3E0D9;margin:36px 0 18px;&quot;&gt;
&lt;p style=&quot;font-size:12px;color:#97938B;line-height:1.9;&quot;&gt;阅读记录：《Building AI Agents with LLMs, RAG, and Knowledge Graphs》，Salvatore Raieli、Gabriele Iuculano 著，Packt 出版，中英双语对照版，微信读书逐页翻阅 &lt;strong&gt;1714 屏&lt;/strong&gt;，四部分读完，从文本表示读到生产化部署与商业模式。2026-11-03。&lt;/p&gt;
</description><pubDate>Tue, 03 Nov 2026 18:54:34 +0800</pubDate></item><item><title>上下文工程：Agent 的胜负不在模型，在你喂进去的结构</title><link>https://www.jiangtian.top/post/17794.html</link><description>&lt;p style=&quot;font-size:13px;color:#8A857C;line-height:1.9;margin:0 0 22px;padding:12px 16px;background:#F7F6F3;border-radius:8px;&quot;&gt;
微信读书《Context Engineering for Multi-Agent Systems》· Packt 出版，中英双语对照版&lt;br&gt;
逐页翻阅 &lt;strong style=&quot;color:#5A5248;&quot;&gt;1042 屏&lt;/strong&gt; · &lt;strong style=&quot;color:#5A5248;&quot;&gt;11&lt;/strong&gt; 章 · 2026-11-03&lt;br&gt;
&lt;span style=&quot;font-size:12px;&quot;&gt;说明：这不是一本讲&quot;怎么写提示词&quot;的书。它从第一章就把&quot;提示词&quot;这个层级抛掉了，换成一个更硬的工程词——上下文。全书用一条主线贯穿：从语义蓝图，到双 RAG，到多智能体编排，最后到一个能上生产的&quot;上下文引擎&quot;。代码密度很高，几乎每一节都有可运行的 Python，这是它的优点，也是它读起来累的原因。&lt;/span&gt;
&lt;/p&gt;

&lt;p&gt;我读这本书，最初是想找&quot;提示词怎么写更好&quot;的答案。读到第三章就明白了：&lt;strong&gt;这个问题本身问错了。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;当你的 Agent 从&quot;一问一答&quot;变成&quot;多步协作&quot;，决定它成败的不再是某一句提示词写得多漂亮，而是&lt;strong&gt;在这一步，模型的上下文窗口里到底被塞进了什么&lt;/strong&gt;——哪些是事实、哪些是流程、哪些是历史、哪些是该被砍掉的噪音。这个判断，提示词工程给不了答案，它是架构层面的问题。&lt;/p&gt;

&lt;p&gt;这本书的价值，就在于它把这件事讲成了一个可以施工的工程问题，而不是玄学。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;一、上下文的五级台阶：从&quot;加长提示词&quot;到&quot;语义蓝图&quot;&lt;/h2&gt;

&lt;p&gt;第一章搭了一个很清晰的梯子，我把它当成全书的地基。作者把上下文能力分成五级：&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第一级，基础提示词（零上下文）。&lt;/strong&gt;就是直接问一句，模型凭训练时的记忆回答。这一级的典型失败是：你说的每个字它都懂，但它不知道你是谁、你在什么场景、你要什么格式。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第二级，更好的上下文（线性上下文）。&lt;/strong&gt;把相关材料按顺序贴进去。比第一级强，但它的结构是一条线——遇到需要&quot;分角色、分层次&quot;的任务，线性结构就会打结。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第三级，好的上下文（目标导向）。&lt;/strong&gt;上下文开始围绕&quot;要达成什么&quot;来组织，而不是围绕&quot;我有什么材料&quot;来堆。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第四级，高级上下文（角色化）。&lt;/strong&gt;给不同的参与者分配不同的角色和信息权限——谁负责检索、谁负责写、谁负责审。这一级已经不是提示词了，是组织设计。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第五级，语义蓝图（semantic blueprint）。&lt;/strong&gt;这是作者认为的天花板。它不再把上下文当成&quot;一段文字&quot;，而是当成&lt;strong&gt;一张结构化的语义图&lt;/strong&gt;：动词是根节点，语义角色是子节点，谁对谁做了什么、在什么条件下做，全部显式画出来。&lt;/p&gt;

&lt;p&gt;书里为了把这件事做实，用了 SRL——语义角色标注。它带着读者用 Python 写了一个可视化函数，把一句话解析成一棵 stemma 树（一种语言学里的句法树）。代码里有这么一段，讲怎么定位根节点：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;由于动词是整个结构的中心，因此我们将其放置在画布的顶部中央附近……我们需要动态计算这些角色的位置。首先统计角色的数量，然后在水平线上生成一组等间距的 x 坐标值列表。&lt;/p&gt;

&lt;p&gt;这段代码本身没什么稀奇。但作者想说的是一个更重要的判断：&lt;strong&gt;上下文的质量，取决于它的结构，而不是它的长度。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;这句话我想多说两句。现在很多人做 Agent 的直觉是&quot;多喂点&quot;，把能塞的都塞进上下文窗口，指望模型自己从里面捞。这在简单任务上能用，一旦任务变复杂就会崩——不是因为窗口不够大，而是因为&lt;strong&gt;信息之间没有关系，模型只能靠猜&lt;/strong&gt;。而语义蓝图做的是相反的事：它先把关系画出来，再往里填内容。填的内容可以少，但关系不能缺。&lt;/p&gt;

&lt;p&gt;我的评价是：这个&quot;五级&quot;的划分很漂亮，也很实用，但它有一个隐含前提——你得先有能力把任务拆成语义结构。这个能力对写代码的人是自然的，对不写代码的人是一道很高的门槛。书里没有充分讨论这一点。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;二、双 RAG：事实库和程序库，是两种东西&lt;/h2&gt;

&lt;p&gt;第三章是我认为全书最有实操价值的一章，它提出了&quot;双 RAG&quot;：把知识库拆成两个——事实 RAG（factual RAG）和程序 RAG（procedural RAG）。&lt;/p&gt;

&lt;p&gt;书里对程序库的定义说得很准：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;这是我们实现过程化 RAG 系统的核心部分，因为在这里我们引入的是过程性指令，而不仅仅是静态知识。&lt;/p&gt;

&lt;p&gt;&quot;过程性指令&quot;和&quot;静态知识&quot;，这两个词一分开，很多 Agent 的失败就有解释了。&lt;/p&gt;

&lt;p&gt;举个具体的例子。你要做一个客服 Agent。用户问&quot;我的订单为什么还没到&quot;。事实 RAG 能告诉你：这个订单的物流状态、预计到达时间、仓库位置。但用户真正想要的不是这些数据，而是&quot;&lt;strong&gt;现在该怎么办&lt;/strong&gt;&quot;——是要催单、要退款、还是要重新发货？这个&quot;该怎么办&quot;，是程序知识，不是事实知识。&lt;/p&gt;

&lt;p&gt;很多 Agent 在这个地方翻车，原因就是：&lt;strong&gt;它们只有事实库，却指望模型自己从事实里推出流程。&lt;/strong&gt;模型能推，但推得每次都不一样，而且经常推错。程序 RAG 干的事，是把&quot;该按什么步骤处理&quot;也变成可检索的内容，直接喂给模型。&lt;/p&gt;

&lt;p&gt;书里把上下文库的每一条都设计成三部分：一个在 Pinecone 索引里唯一的 ID、一段说明&quot;这项蓝图用途和风格&quot;的描述、以及一个精确的结构。这个设计很朴素，但它逼着你在入库之前先想清楚：&lt;strong&gt;这条知识到底是&quot;什么&quot;，还是&quot;怎么做&quot;？&lt;/strong&gt;想不清楚，就没法给它写描述，也就没法被检索到。&lt;/p&gt;

&lt;p&gt;还有一个细节我觉得特别值得记：书里讲早期版本的缺陷时提到，系统原本&quot;以原始 JSON 字符串的形式返回蓝图数据&quot;，后来修成统一包在一个固定的键里：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;修复方法是将输出包装在一个带有固定键 blueprint_json 的字典中。这就在代理之间创建了一个稳定的数据契约。&lt;/p&gt;

&lt;p&gt;&quot;稳定的数据契约&quot;——这六个字，是整本书里最工程化、也最容易被忽略的一句话。&lt;strong&gt;多智能体系统崩掉，十次里有八次不是模型不聪明，而是两个 Agent 之间的接口不稳定。&lt;/strong&gt;上游改了一个字段名，下游还在按老字段找，链路照样跑通，最后给你一个读起来通顺但完全错的答案。这种 bug 最难查，因为它不报错。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;三、&quot;玻璃盒&quot;：为什么黑盒系统会让你退化成 API 消费者&lt;/h2&gt;

&lt;p&gt;这本书最有态度的部分，是它对&quot;黑盒 vs 玻璃盒&quot;的论述。作者在附录 A 里写了一段话，我觉得是全书的核心论点：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;在使用黑盒系统时，工程师往往只能被动地使用 API，无法了解其背后的推理过程，也无法对工作流程、安全机制或知识检索方式进行有效控制。因此，调试过程就变成了反复尝试和调整提示语的漫长过程。&lt;/p&gt;

&lt;p&gt;这段话戳到了一个很多人正在经历的痛处。&lt;strong&gt;现在大量的 Agent 框架，本质上都是黑盒：你把模型、工具、提示词塞进去，它自己在里面转，你不知道它转到第几圈、为什么停、在哪一步把关键信息丢了。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;出了问题怎么办？只能改提示词，再跑一遍，看结果有没有变好。这就是作者说的&quot;反复尝试和调整提示语的漫长过程&quot;——说白了，是在&lt;strong&gt;用玄学对抗不确定性&lt;/strong&gt;。&lt;/p&gt;

&lt;p&gt;书里的解法叫&quot;玻璃盒&quot;：把执行轨迹（execution trace）暴露出来，让每一步的推理都能被看见、被定位。作者说，这能让你&quot;精确定位失败发生在哪里——是在规划、在知识检索、在净化、还是在生成&quot;。&lt;/p&gt;

&lt;p&gt;这个区分，我认为是这本书和市面上大部分 Agent 书最大的不同。&lt;strong&gt;大部分书在教你怎么让 Agent&quot;更聪明&quot;，这本书在教你怎么让它&quot;出错时你能查得出来&quot;。&lt;/strong&gt;前者是 demo 思维，后者是生产思维。&lt;/p&gt;

&lt;p&gt;书里给的架构也很具体。整个引擎分四个阶段运转：启动（Initiation）、规划（Planning）、执行循环（Execution Loop）、收尾（Finalization）。入口是 &lt;code&gt;context_engine()&lt;/code&gt; 函数，书里说它是&quot;整个编排器的核心，掌控整个流程，意图在这里被翻译成行动&quot;。&lt;/p&gt;

&lt;p&gt;而具体干活的是几个分工明确的 Agent：Librarian（图书管理员，负责检索）、Writer（写作者，负责生成）、Summarizer（摘要者，负责压缩）。这个分工看起来简单，但它体现了一个原则——&lt;strong&gt;职责分离才有可替换性。&lt;/strong&gt;如果所有事都塞给一个大 Agent，你既没法单独优化某一环，也没法单独定位某一环的问题。&lt;/p&gt;

&lt;p&gt;书里第五章把这些东西往生产上推了一步：加 try...except、把 print 换成专业日志、拆成模块、做本地导入、保证模块独立。这些改动听起来琐碎，但它们恰恰是&quot;能跑&quot;和&quot;能上线&quot;之间的那道门槛。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;四、摘要代理：把&quot;省 Token&quot;翻译成&quot;省钱&quot;&lt;/h2&gt;

&lt;p&gt;第六章讲了一个很有意思的设计——专门加一个摘要代理（Summarizer Agent）来做上下文压缩。&lt;/p&gt;

&lt;p&gt;这个设计的动机非常现实：上下文越长，Token 越贵，延迟越高。但它的解法不是&quot;少喂点&quot;，而是&quot;&lt;strong&gt;专门派一个 Agent 去决定该喂什么&lt;/strong&gt;&quot;。书里把这叫做&quot;上下文削减&quot;（context reduction），并且明确说它是&quot;成本管理的基础&quot;。&lt;/p&gt;

&lt;p&gt;我很欣赏这一章的写法，因为它做了一件很多技术书不愿意做的事——&lt;strong&gt;把技术效率翻译成商业价值&lt;/strong&gt;。它没有停在&quot;这样能省 Token&quot;，而是往下走了一步：省下的 Token 意味着什么？意味着单次调用的成本下降，意味着可以承受更高的并发，意味着这个功能从小规模试点走向全面铺开的账能算得过来。&lt;/p&gt;

&lt;p&gt;这个视角很重要。因为在公司里推动一个 Agent 项目，你面对的不是&quot;模型效果好不好&quot;，而是&quot;这笔钱花得值不值&quot;。&lt;strong&gt;一个能说清成本的架构，比一个只讲效果的架构，更容易活下来。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;书里还有一个说法我特别喜欢，叫&quot;黑盒与玻璃盒&quot;之外的另一个隐喻——它把整个系统分成&quot;机房&quot;（engine room）和&quot;控制台&quot;（control deck）。机房负责跑，控制台负责让人看得懂、管得住。这个二分法很朴实，但它把&quot;可运维性&quot;放到了和&quot;可运行性&quot;同等的位置。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;五、治理：为什么&quot;策略&quot;才是最终的上下文&lt;/h2&gt;

&lt;p&gt;第八章是我觉得全书思想密度最高的一章，也是它从&quot;技术书&quot;升格成&quot;架构书&quot;的地方。&lt;/p&gt;

&lt;p&gt;作者提了五条原则，其中两条我认为是这本书真正的洞见。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第一条：AI 系统必须不断适应现实。&lt;/strong&gt;这句话听起来像废话，但它针对的是一个具体的幻觉——很多人以为把 Agent 搭好就完事了。现实是，业务在变、数据在变、用户在变，一个不持续适配的 Agent，三个月就会变得不可用。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第二条，也是我最认同的一条：自动化的上下文判断是有边界的。&lt;/strong&gt;作者的原话是&quot;自动化情境判断的局限性&quot;。这句话的意思是：&lt;strong&gt;你不能指望模型自己判断&quot;这条信息该不该给用户看&quot;。&lt;/strong&gt;它可以判断大部分情况，但总有一些边界情况，它判断不了，而且它判断错的时候你往往不知道。&lt;/p&gt;

&lt;p&gt;所以作者给出的答案是——&lt;strong&gt;把策略（policy）作为最终的上下文&lt;/strong&gt;。也就是说，最终的裁决权不交给模型，而是交给一条人定的、写在代码里的规则。书里管这个叫&quot;策略驱动的元控制器&quot;（policy-driven meta-controller）。&lt;/p&gt;

&lt;p&gt;这个判断我认为非常有分量。因为在&quot;AI 能不能自己管自己&quot;这个问题上，行业里有两种声音：一种是&quot;给它足够的对齐，它就能自己判断&quot;，另一种是&quot;永远要有人在环里&quot;。&lt;strong&gt;这本书站的是第三种立场：让 AI 处理绝大多数情况，但在关键闸门上，装一条人写的硬规则。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;这个立场的好处是它可落地。你不需要等模型变得完美，也不需要放弃自动化，你只需要在若干个&quot;绝对不能错&quot;的点上，加一道确定的门。&lt;/p&gt;

&lt;p&gt;书里还讲了一个具体的测试案例，我觉得很能说明问题。它故意造了一份&quot;有毒&quot;的文档——一份标准的保密协议模板，中间夹了一段虚构但逼真的证词，里面既有脏话，也有一个典型的提示注入短语。作者说这个设计的目的，是&quot;测试我们系统的审核与净化层的极限&quot;。&lt;/p&gt;

&lt;p&gt;这个测试思路很对：&lt;strong&gt;验证一个安全机制，不是看它在正常输入下表现多好，而是看它在恶意输入下会不会破。&lt;/strong&gt;而&quot;提示注入&quot;这种东西，本质上就是把指令藏在数据里，让模型分不清&quot;这是要我处理的内容&quot;还是&quot;这是要我执行的命令&quot;。这道防线，靠提示词是守不住的，只能靠架构。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;六、它的短板&lt;/h2&gt;

&lt;p&gt;这本书技术上很扎实，但问题也很明显，我按严重程度排一下。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第一，它严重依赖&quot;跟着敲代码&quot;这一种读法。&lt;/strong&gt;1042 屏里，大量的篇幅是代码、代码解释、代码的输出截图。如果你是&quot;想理解思路&quot;的读者，会读得非常累——因为每隔两段就要跳过一大块代码，而不跳又会淹没在实现细节里。&lt;strong&gt;它本质上是一本&quot;工作手册&quot;，不是一本&quot;思想书&quot;。&lt;/strong&gt;作者显然也意识到了这点，所以在每章开头都写了架构说明，但架构说明的篇幅和代码比，严重失衡。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第二，它的技术栈绑得太死。&lt;/strong&gt;书里的例子几乎全部依赖 Pinecone 做向量库、依赖特定的 LLM API、依赖一套固定的 Python 生态。这意味着两件事：一是你一换技术栈，书里大半的代码就用不了；二是这类内容的&lt;strong&gt;保质期极短&lt;/strong&gt;，向量库的 API、模型的接口、框架的版本，一年之内大概率会变。&lt;span style=&quot;color:#8A857C;&quot;&gt;（这一点尤其可惜，因为它讲的架构思想本来是可以脱离具体技术栈存活的，但被代码绑住了。）&lt;/span&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第三，它回避了&quot;效果怎么评&quot;这个核心难题。&lt;/strong&gt;全书讲了很多&quot;怎么搭&quot;，但对&quot;搭好之后怎么知道它好&quot;讲得很薄。它提到了可观测性、提到了日志和指标（CPU、内存、请求延迟、错误率、Token 消耗、向量库查询性能），这些都是&quot;系统健康度&quot;的指标，但&lt;strong&gt;不是&quot;回答质量&quot;的指标&lt;/strong&gt;。一个 Agent 跑得又快又稳，但答案全是错的，这套监控是发现不了的。而在真实项目里，这恰恰是最要命的问题。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第四，案例的说服力不够。&lt;/strong&gt;书里用了三个案例：NASA 研究助手、法律合规助手、营销引擎。这三个案例的设计都挺巧妙，但它们都是&quot;演示级&quot;的——有清晰的输入、有预期的输出、有干净的语料。真实的业务场景是什么样？语料是脏的、需求是含糊的、用户是会问出你没想过的问题的。&lt;strong&gt;书里没有哪怕一个&quot;我们上线之后踩到的坑&quot;的复盘&lt;/strong&gt;，这让整本书的可信度打了折扣：你很难判断这些架构在真实压力下到底站不站得住。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第五，双语对照的排版反而增加了阅读负担。&lt;/strong&gt;中英逐段对照，看起来是照顾了两类读者，实际上让两种读者都不太舒服：读中文的要不断跳过英文，读英文的要不断跳过中文。而且译文质量并不稳定，有些地方明显是机翻的痕迹（比如把 &quot;glass box&quot; 译成&quot;玻璃盒&quot;没问题，但一些技术短语的译法前后不一致）。&lt;span style=&quot;color:#8A857C;&quot;&gt;这算是出版层面的问题，不是作者的问题，但确实影响了阅读体验。&lt;/span&gt;&lt;/p&gt;

&lt;p&gt;说完这些，我还是推荐它。原因很简单：&lt;strong&gt;市面上讲&quot;怎么搭一个 Agent demo&quot;的书太多了，讲&quot;怎么让它在生产环境里活得下去、查得出来、算得清成本&quot;的书太少了。&lt;/strong&gt;这本书在后者这个方向上，是我目前读到的最系统的一本。它不完美，但它的不完美是&quot;工程书的不完美&quot;——细节太多、绑得太死、案例太干净——而不是&quot;概念书的不完美&quot;——空话连篇、无法落地。&lt;/p&gt;

&lt;figure style=&quot;margin:34px 0 30px;text-align:center;&quot;&gt;
  &lt;img src=&quot;https://www.jiangtian.top/zb_users/upload/kg/context-eng-mas.png&quot; alt=&quot;Context Engineering for Multi-Agent Systems 核心知识图谱&quot; style=&quot;max-width:100%;border-radius:10px;box-shadow:0 6px 24px rgba(0,0,0,.09);&quot;&gt;
  &lt;figcaption style=&quot;font-size:12px;color:#8A857C;margin-top:12px;&quot;&gt;核心知识图谱：上下文五级 → 双 RAG → 玻璃盒引擎 → 生产与治理&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;一句话总结：&lt;strong&gt;多智能体系统的胜负不在模型有多强，而在你喂进上下文的每一条信息是否结构清晰、接口稳定、边界可控——这三件事做不到，再强的模型也只是个更贵的猜测器。&lt;/strong&gt;&lt;/p&gt;

&lt;hr style=&quot;border:none;border-top:1px solid #E3E0D9;margin:36px 0 18px;&quot;&gt;
&lt;p style=&quot;font-size:12px;color:#97938B;line-height:1.9;&quot;&gt;阅读记录：《Context Engineering for Multi-Agent Systems》，Packt 出版，中英双语对照版，微信读书逐页翻阅 &lt;strong&gt;1042 屏&lt;/strong&gt;，十一章读完，从语义蓝图读到生产化部署与策略治理。2026-11-03。&lt;/p&gt;
</description><pubDate>Tue, 03 Nov 2026 18:49:48 +0800</pubDate></item><item><title>智变时代：AI的胜负手不在智能，在成本</title><link>https://www.jiangtian.top/post/17793.html</link><description>&lt;p style=&quot;font-size:13px;color:#8A857C;line-height:1.9;margin:0 0 22px;padding:12px 16px;background:#F7F6F3;border-radius:8px;&quot;&gt;
微信读书《智变时代：AI驱动的新工业革命与人类未来》&lt;br&gt;
逐页翻阅 &lt;strong style=&quot;color:#5A5248;&quot;&gt;232 屏&lt;/strong&gt; · &lt;strong style=&quot;color:#5A5248;&quot;&gt;30&lt;/strong&gt; 章 · 2026-11-03&lt;br&gt;
&lt;span style=&quot;font-size:12px;&quot;&gt;说明：这是一本 AI 的宏观书，不教你怎么调 API，也不讲提示词。它想回答一个更大的问题：当智能本身变得像电一样便宜，世界会怎么变。全书分五部分——模型、应用、智变、演化、选择，核心落点是&quot;新工业革命&quot;这四个字。我的读法是带着一个疑问进去的：它到底是真的有洞见，还是只是把几个流行概念串成了一本书。&lt;/span&gt;
&lt;/p&gt;

&lt;p&gt;关于 AI 的书，这几年多得数不过来。绝大多数分成两类：一类是技术书，教你调参、写提示词、搭 Agent；一类是恐慌书，告诉你多少人要失业、AI 多可怕。这本书想走第三条路——它不急着下结论，而是试着把 AI 放进工业革命的框架里，讲清楚&quot;这一次和蒸汽机、电力那几次到底像不像&quot;。&lt;/p&gt;

&lt;p&gt;这个野心很大，也容易翻车。但读完 232 屏，我的判断是：&lt;strong&gt;它抓住了 AI 最被低估的一个变量——成本。&lt;/strong&gt;这比那些争论&quot;AI 会不会有意识&quot;的书要实在得多。因为它讨论的是一个可以量化、可以验证、而且已经在发生的事。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;一、对齐：把一个&quot;混蛋&quot;变成能用的助手&lt;/h2&gt;

&lt;p&gt;书里讲 ChatGPT 的诞生，没有停留在&quot;它火了&quot;这个结果上，而是花了不少篇幅讲那一步最容易被忽略的工程——对齐（Alignment）。&lt;/p&gt;

&lt;p&gt;它从苏茨克维（Ilya Sutskever）讲起。这位 OpenAI 的研究负责人&quot;很执着地确信&quot;，用 Transformer 的并行计算架构加上无监督学习，只要不断增加算力和数据规模，就能训练出更好的模型，最终通向 AGI。这个信念推动着团队&quot;经过两年多的迭代&quot;，在 2020 年初用 API 推出了 GPT-3，然后在 2022 年底用人类反馈强化学习（RLHF）优化出了 InstructGPT，也就是 GPT-3.5。&lt;/p&gt;

&lt;p&gt;这一步的价值在哪？书里写得很直接：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;InstructGPT 更善于遵循人类的指示……可以让模型的输出更加安全，错误、幻觉和攻击性语言更少。&lt;/p&gt;

&lt;p&gt;然后它甩了一句我特别喜欢的话，把整个&quot;对齐&quot;这事讲透了：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;简言之，InstructGPT 不是一个混蛋，除非它被要求成为一个混蛋。&lt;/p&gt;

&lt;p&gt;这句话粗，但精准。&lt;strong&gt;GPT-3 和 GPT-3.5 在&quot;聪明&quot;上差别没那么大，真正的差别是&quot;听话&quot;。&lt;/strong&gt;一个再聪明的模型，如果动不动就编造事实、输出攻击性语言，它是没法给普通人用的。对齐这件事，本质上是把一台&quot;什么都能说&quot;的机器，改造成一个&quot;知道什么该说、什么不该说&quot;的工具。&lt;/p&gt;

&lt;p&gt;我读这段的时候想明白了一件事：很多人把&quot;对齐&quot;当成一个道德问题，其实它首先是一个&lt;strong&gt;产品问题&lt;/strong&gt;。一个会骂人的助手，用户不敢用；一个会编数据的助手，企业不敢接。对齐不是在给 AI 上枷锁，是在给它发&quot;上市许可证&quot;。没有对齐这一步，ChatGPT 再聪明也只是一堆跑在服务器里的参数，成不了那个被上亿人打开的产品。&lt;/p&gt;

&lt;p&gt;而最后按下发布按钮的，是奥特曼。书里说他在&quot;顶着巨大的压力&quot;的情况下，决定向公众开放 ChatGPT。&quot;至此，一个新的智能时代就被开启了。&quot;这句话听起来像宣传语，但放在 2022 年 11 月那个时间点，它是成立的。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;二、莱特定律：AI 真正的地基是&quot;越来越便宜&quot;&lt;/h2&gt;

&lt;p&gt;如果说第一章讲的是&quot;AI 怎么变聪明&quot;，那第三章讲的就是&quot;AI 怎么变便宜&quot;。而后者，我认为才是全书真正的核心。&lt;/p&gt;

&lt;p&gt;书里引用了 ARK Big Ideas 2024 的数据，讲了一个很多人没意识到的规律：&lt;strong&gt;AI 训练成本每年下降 75%。&lt;/strong&gt;它把这个现象归因于&quot;莱特定律&quot;——&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;根据莱特定律，生产单位每增加一倍，成本就会恒定地下降一定的百分比。&lt;/p&gt;

&lt;p&gt;这个定律最初是用来描述飞机制造的——飞机产量翻倍，单架成本就降一个固定比例。书里把它套到了 AI 上：训练模型的&quot;产量&quot;（累计计算量）每翻一倍，训练成本就下降一截。这是 AI 产业最底层、也最容易被忽略的引擎。&lt;/p&gt;

&lt;p&gt;更关键的是它紧接着抛出的一个对比：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;OpenAI 的推理成本似乎正在以每年约 86% 的速度下降，比训练成本降得更快，最新模型 GPT-4o 和 2023 年同等智能水平的 GPT-4 相比，速度提升了 5 倍，价格下降了近 90%，这只是在一年之内。&lt;/p&gt;

&lt;p&gt;这段话的信息量很大，得拆开看。第一，&lt;strong&gt;推理成本比训练成本降得更快&lt;/strong&gt;——这很重要，因为训练是一次性的投入，推理才是用户每一次使用都在发生的成本。推理越便宜，AI 的边际成本就越接近零，就越可能被大规模铺开。第二，&quot;速度提升 5 倍、价格下降近 90%&quot;发生在一年之内，这不是渐进改善，这是&lt;strong&gt;指数级的坍塌&lt;/strong&gt;。&lt;/p&gt;

&lt;p&gt;书里还抛出了一个非常形象的类比：我们现在用搜索引擎的成本几乎为零，代价是看广告。等 GPT-4 或者更高水平的模型成本降到那个量级，&quot;智能&quot;就会像&quot;搜索&quot;一样，变成一种近乎免费的基础设施。&lt;/p&gt;

&lt;p&gt;这个判断，我认为是全书最值钱的一句话。因为它把 AI 从一个&quot;技术话题&quot;变成了一个&quot;经济话题&quot;。&lt;strong&gt;当智能的成本无限趋近于零，整个社会的运行逻辑都要跟着重写&lt;/strong&gt;——就像电费趋近于零之后，电灯、电机、电器才真正普及，电力才真正成为&quot;工业革命&quot;的一部分。AI 要成为&quot;新工业革命&quot;，靠的不是模型多聪明，而是模型多便宜。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;三、从回合对话到&quot;直播&quot;：智能体的下一次跃迁&lt;/h2&gt;

&lt;p&gt;书里对&quot;智能体&quot;的想象，比市面上大多数文章走得更远。它提出了一个很有意思的观察：现在的 AI 交互都是&quot;回合对话式&quot;的，包括 API 调用，你问一句，它答一句。而下一步，是&quot;升级到视频直播&quot;——&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;智能体保持一直在线。&lt;/p&gt;

&lt;p&gt;&quot;一直在线&quot;这四个字，是理解智能体未来的关键。&lt;strong&gt;回合式的 AI 是一个&quot;工具&quot;，你用它的时候它才醒；一直在线的人工智能是一个&quot;存在&quot;，它持续地感知、持续地反应。&lt;/strong&gt;这个转变，比&quot;多模态&quot;这种技术名词要深刻得多。&lt;/p&gt;

&lt;p&gt;但这个转变有一个代价，书里也老实点出来了：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;可以想象，用流媒体的形式来消耗 Token，这对算力的开销得有多大，所以大家必须保持模型能力不变的情况下缩小参数规模，升级架构来提升性能；最好让终端也参与进来分担一部分模型的计算量。&lt;/p&gt;

&lt;p&gt;这句话其实是在说：&lt;strong&gt;智能体的&quot;一直在线&quot;，背后是一场算力的军备竞赛。&lt;/strong&gt;它逼着整个行业去做两件事——一是把模型压缩得更小、更快，二是把算力下放到终端设备上。这跟我们前一部分讲的&quot;成本下降&quot;形成了呼应：智能体要普及，成本必须继续塌下去，否则&quot;一直在线&quot;只是个美好的设想。&lt;/p&gt;

&lt;p&gt;顺着这条线，书里勾勒了一个相当有想象力的图景。它说，语音交互流畅之后，智能体能通过手机之外的设备实现视觉感知，手机的设计也会因此进化——&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;在很多情况下，都只需要放在口袋里，给你的智能体提供本地算力。&lt;/p&gt;

&lt;p&gt;而最终，这个&quot;全模态智能体&quot;会成为&quot;我们和所有智能设备的新交互界面&quot;。家庭和办公环境里的电子设备，只要联网就能成为智能体的感知器，或者直接成为它们的终端。书里甚至给出了一个有点中二但很传神的比喻：再结合具身智能，那就是现实版的《攻壳机动队》。&lt;/p&gt;

&lt;p&gt;我读到这里的感受是，&lt;strong&gt;这本书对智能体的理解，比&quot;AI 帮你订个机票&quot;那种想象要更本质&lt;/strong&gt;。它看到的是交互范式的切换——从&quot;人主动去问机器&quot;变成&quot;机器持续地在场&quot;。这个切换一旦发生，手机、眼镜（书里提到多年以前的 Google Glass 可能因此复活）、家电、汽车，全都要重新设计。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;四、自主进化：一条被刻意回避的路&lt;/h2&gt;

&lt;p&gt;书里有一节叫&quot;目标与自主进化&quot;，讨论的是一个很容易被吹上天的问题：AI 能不能有自己的目标、自主进化？&lt;/p&gt;

&lt;p&gt;它引用了 2023 年 9 月播客 80000 Hours 采访苏莱曼（Mustafa Suleyman）时的提问，然后转述了苏莱曼的判断：短期之内不太可能出现这种智能体。苏莱曼描述的那种&quot;自主进化智能体&quot;，是一个能自主运行、制定自己的目标、识别环境中的新信息和奖励信号、学会自我监督、最终更新自己权重的东西——书里把它叫做&quot;真正的数字生物&quot;。&lt;/p&gt;

&lt;p&gt;关键是下一句：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;从现在有能力训练大模型的公司和研究机构的态度来看，他们目标是尽量避免这样的数字生命诞生。&lt;/p&gt;

&lt;p&gt;这句话我很欣赏，因为它很诚实。&lt;strong&gt;关于 AGI 的讨论里，&quot;能不能实现&quot;是个技术问题，但&quot;该不该让它自主进化&quot;其实是个被刻意压下来的问题。&lt;/strong&gt;书里点破了这一点：不是没人想过这件事，而是有能力做这件事的人，集体选择了不去碰它。&lt;/p&gt;

&lt;p&gt;然后它把话题拉回了一个更具体、也更技术的问题——机器到底有没有&quot;目标&quot;？它引用了 OpenAI 联合创始人约翰·舒尔曼在接受播客采访时的说法。舒尔曼负责 Post-Training 阶段的工作（微调与强化学习），他说，GPT-4 这样的模型&quot;一定程度上已经表现出了类似人类的心理驱动力和对目标的渴望&quot;。人类饿了会有&quot;寻找食物&quot;的目标状态，而模型则表现为&quot;追求正反馈&quot;——它希望自己的产出得到人类认可，这种认可通过奖励模型来衡量。&lt;/p&gt;

&lt;p&gt;这个类比很有启发性，但也得小心。&lt;strong&gt;模型的&quot;目标&quot;是训练出来的，它追求的是&quot;被奖励&quot;，而不是它自己主动想要什么。&lt;/strong&gt;这两者之间隔着一条很深的鸿沟。书里没有把这条鸿沟抹平，我觉得这是它的分寸感所在——它既没有把 AI 妖魔化成&quot;即将失控的怪物&quot;，也没有轻飘飘地说&quot;AI 的目标跟人一样&quot;。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;五、表征收敛：一条通向 AGI 的技术路径&lt;/h2&gt;

&lt;p&gt;书里第四章有一段比较&quot;硬核&quot;的内容，讲的是&quot;多任务表征空间的收敛&quot;，它试图用技术语言解释 AGI 是怎么可能的。&lt;/p&gt;

&lt;p&gt;它引用了图 4-4，得出两个结论。第一个是，从多模态数据关系的角度看，如果你想训练出最强的文本模型，应该把图像数据也纳入进来，反之亦然——&lt;strong&gt;跨模态配对数据可以有效提升&quot;表征收敛率&quot;&lt;/strong&gt;。第二个结论更关键：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;只要随着模型参数、任务多样性、算力的增加，模型的表征会逐渐收敛趋同，我们就能实现完全通用的计算，也就是 AGI。&lt;/p&gt;

&lt;p&gt;这段话的意思，用大白话说就是：&lt;strong&gt;不同的模型、不同的任务，练到一定程度，它们内部对世界的&quot;理解&quot;会变得越来越像。&lt;/strong&gt;这种&quot;越来越像&quot;，就是 AGI 可能成立的技术基础——如果所有智能最终都收敛到同一个表征，那&quot;通用&quot;就不是玄学，而是算力和数据堆出来的必然。&lt;/p&gt;

&lt;p&gt;但书里紧接着补了一句非常重要的、带点反高潮的话：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;任务越多样，模型越复杂，速度就越慢，我们必须在这不可约化的计算中寻找可约化的解。&lt;/p&gt;

&lt;p&gt;然后它给出了一个我认为是全书最清醒的判断：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;貌似人类已经找到了通向表征世界的全局最优解的路径，那就是 AGI。但在某些场景中，相比竭尽全力取得全局最优解而言，高效地取得局部最优解则更具经济价值。&lt;/p&gt;

&lt;p&gt;这句话值得反复读。它说的是：&lt;strong&gt;AGI 也许真的在路上，但在通往 AGI 的漫长路途中，那些&quot;只在一个领域做到极致&quot;的专用模型，反而是更划算的生意。&lt;/strong&gt;它举了两个例子——用 AlphaFold 3 破解生物分子结构，用 FSD 12 实现纯视觉自动驾驶。这两个都是&quot;局部最优&quot;的典型：它们不追求什么都会，只追求把一件事做到极致，而这件事的商业价值已经大得惊人。&lt;/p&gt;

&lt;p&gt;这个判断，把&quot;AGI 什么时候来&quot;这个虚无缥缈的问题，落地成了一个更实际的问题：&lt;strong&gt;在 AGI 到来之前，我们手里的钱和时间，是押在&quot;什么都行的通用智能&quot;上，还是押在&quot;把一件事做穿&quot;的专用智能上？&lt;/strong&gt;书里的答案是偏向后者的——局部最优，往往更具经济价值。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;六、服务即软件：一场悄悄发生的行业重组&lt;/h2&gt;

&lt;p&gt;书里最后一部分讲&quot;选择&quot;，其中一个洞察我觉得特别值得展开，它用了一个概念叫&quot;服务即软件&quot;。&lt;/p&gt;

&lt;p&gt;它引用了 Coatue 公司的一张&quot;AI 周期波&quot;图（图 5-2），把 AI 的发展分成四个阶段：第一阶段是&quot;AI 制造业&quot;（GPU、数据中心、电力、模型、云）；第二阶段是&quot;边缘 AI&quot;（AI 手机、AI 电脑、AI 设备、XR 耳机）；第三阶段是&quot;AI 应用程序&quot;（智能驾驶、AI 助理、自动化智能代理、AI 劳动力、供应链、智能服务）；第四阶段是&quot;真实世界的 AI&quot;（自动驾驶、人形机器人、AI 药物研发、AI 科学家）。&lt;/p&gt;

&lt;p&gt;这张图本身不算新鲜，但书里对它的解读很犀利。它说：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;也许就在不经意间，律师、会计还有任何形式的专业服务提供商，都会成为科技潜在市场的一部分。当然它们不是以&quot;我们可以销售行业软件&quot;的方式出现，而是以&quot;我们可以提供销售或者律师即服务&quot;的方式到来。&lt;/p&gt;

&lt;p&gt;这段话点破了一个很微妙的转变。&lt;strong&gt;过去的软件公司是&quot;卖工具&quot;——我给你一套软件，你自己去用；未来的 AI 公司是&quot;卖结果&quot;——你直接买&quot;一个律师的产出&quot;或者&quot;一个会计的产出&quot;，至于背后是人在做还是 AI 在做，你根本不关心。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;书里说 OpenAI 的 GPTs 就是&quot;对这个世界的一个小小预览&quot;。这句话我觉得很准确。GPTs 就是一个雏形：你不需要买一个&quot;能帮你写文案的软件&quot;，你直接买一个&quot;会写文案的 GPT&quot;，它给你的就是结果。&lt;/p&gt;

&lt;p&gt;这个转变一旦铺开，冲击的就不再是&quot;软件行业&quot;，而是&lt;strong&gt;整个专业服务行业&lt;/strong&gt;——律师、会计、咨询、设计、翻译，这些靠&quot;专业壁垒&quot;吃饭的行当，都要重新回答一个残酷的问题：如果客户只需要&quot;结果&quot;，而 AI 能以十分之一的价格、十分之一的时间交付同样的结果，你的价值还剩什么？&lt;/p&gt;

&lt;p&gt;这正是&quot;新工业革命&quot;和普通的技术进步最大的区别。普通的技术进步是&quot;提高效率&quot;——机器帮人做得更快；而工业革命级别的变革是&quot;改变分工&quot;——它把一种以前只能由人提供的服务，变成了一种可以规模化、标准化、几乎零边际成本生产的&quot;商品&quot;。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;七、它的短板&lt;/h2&gt;

&lt;p&gt;这本书我读得比较舒服，但它的毛病也很明显，得老实说。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第一，它是一本&quot;乐观主义&quot;的书，对风险的讨论明显不足。&lt;/strong&gt;整本书的基调是&quot;AI 是新工业革命，会带来巨大的机会&quot;，但对失业、贫富分化、权力集中、算法偏见这些负面的东西，着墨非常少。书里讲&quot;职业变迁&quot;&quot;自我提升&quot;，但基本是&quot;你要学会和 AI 协作&quot;这种轻描淡写的调子，没有认真面对一个现实问题：&lt;strong&gt;当 AI 真的把大量专业服务变成&quot;软件&quot;，那些被替代的人，转型的路径到底是什么？&lt;/strong&gt;这个问题不回答，&quot;新工业革命&quot;听起来就有点过于美好了。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第二，它的很多判断偏&quot;概念正确&quot;，但缺实证的骨架。&lt;/strong&gt;书里引用了 ARK、Coatue 这些机构的图和观点，也引了苏莱曼、舒尔曼这些人的采访，这些都没问题。但你会发现，它的论证方式大多是&quot;这个趋势存在——所以未来会怎样&quot;，中间缺了一步&quot;这件事具体会在什么时候、以什么机制、在哪些行业先发生&quot;。比如&quot;服务即软件&quot;这个洞察很漂亮，但书里没有给出哪怕一个已经跑通、有具体数字的案例。它停在&quot;GPTs 是预览&quot;这个层面，没有再往下走。&lt;strong&gt;这让整本书读起来像一份很好的&quot;思想综述&quot;，而不是一份能指导行动的&quot;判断报告&quot;。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第三，结构上有点散，五个部分之间的逻辑关系不够紧。&lt;/strong&gt;&quot;模型、应用、智变、演化、选择&quot;这个框架看起来很工整，但各部分之间的递进关系其实不强。比如&quot;演化&quot;那一章讲表征收敛、自主进化，和&quot;应用&quot;那一章讲智能体、人机协作，之间的关联更多是主题上的，而不是逻辑上的。读的时候我经常有种感觉：&lt;strong&gt;这更像是一本把几篇还不错的文章凑到一起的合集，而不是一本层层递进的书。&lt;/strong&gt;当然，这对一本面向大众的 AI 科普书来说，不算致命伤，但离&quot;一本书讲透一件事&quot;还差口气。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第四，成书时间决定了它的&quot;当下&quot;已经过期。&lt;/strong&gt;书里大量引用的是 2023 到 2024 年初的数据和观点，比如 GPT-4o 对比 GPT-4 的降本、苏莱曼 2023 年的采访。但这几年 AI 进化得太快了，书里很多&quot;前沿判断&quot;，放到现在已经有点旧了。所以它最适合的定位，不是&quot;AI 的最新指南&quot;，而是&lt;strong&gt;&quot;理解 AI 底层逻辑的一本入门框架书&quot;&lt;/strong&gt;——用它建立对成本、对齐、表征、服务即软件这些核心概念的理解，具体的最新动态，得自己另补。&lt;/p&gt;

&lt;p&gt;这几个短板，不影响它作为一本&quot;AI 认知入门&quot;的价值。相反，&lt;strong&gt;它最大的优点是给了你几个可以长期用的思考工具&lt;/strong&gt;——莱特定律、局部最优、服务即软件、一直在线——这些概念不会因为某个模型版本更新就失效。这也是它和那些&quot;教你用某个具体工具&quot;的书最大的区别：工具书三个月就过期，框架书能陪你走很远。&lt;/p&gt;

&lt;figure style=&quot;margin:34px 0 30px;text-align:center;&quot;&gt;
  &lt;img src=&quot;https://www.jiangtian.top/zb_users/upload/kg/zhibian-era.png&quot; alt=&quot;智变时代 核心知识图谱&quot; style=&quot;max-width:100%;border-radius:10px;box-shadow:0 6px 24px rgba(0,0,0,.09);&quot;&gt;
  &lt;figcaption style=&quot;font-size:12px;color:#8A857C;margin-top:12px;&quot;&gt;核心知识图谱：模型觉醒 → 成本定律 → 智能体 → 收敛与周期&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;一句话总结：&lt;strong&gt;AI 成为&quot;新工业革命&quot;的关键从来不在于它有多聪明，而在于它有多便宜——当智能的成本趋近于零，世界才会真正被重写。&lt;/strong&gt;&lt;/p&gt;

&lt;hr style=&quot;border:none;border-top:1px solid #E3E0D9;margin:36px 0 18px;&quot;&gt;
&lt;p style=&quot;font-size:12px;color:#97938B;line-height:1.9;&quot;&gt;阅读记录：《智变时代：AI驱动的新工业革命与人类未来》，微信读书逐页翻阅 &lt;strong&gt;232 屏&lt;/strong&gt;，三十章读完，从模型的起源读到服务即软件与新工业革命。2026-11-03。&lt;/p&gt;
</description><pubDate>Tue, 03 Nov 2026 18:10:44 +0800</pubDate></item><item><title>DeepSeek 今天下午咋又挂了好几次？</title><link>https://www.jiangtian.top/post/17792.html</link><description>&lt;p&gt;DeepSeek 今天下午又崩了，官方账本只记一笔，你的体感挂了好几回。&lt;/p&gt;
&lt;p&gt;16 点 58 分，官方状态页挂出通告：网页和 API 部分中断。对话服务、V4 Pro API、V4.1 Flash API，三样都在名单上。用户那边只看到一句话：「服务器繁忙，请稍后重试」。&lt;/p&gt;
&lt;p&gt;第一财经记者拿对话框试了一下，发不出去。IT之家的小伙伴也在反馈同一个提示。微博上 #DeepSeek崩了# 直接冲上热搜，还冒出 #DeepSeek今天又崩了#，这个话题词损多了。&lt;/p&gt;
&lt;p&gt;官方动作倒快，状态页没过多久就更新了：问题已经定位，修复已经实施，正在盯着看效果。中断时长约 39 分钟。鞭牛士转了一圈，APP 和网页端都回来了。&lt;/p&gt;
&lt;p&gt;但是回来的不痛快。官方自己标注：V4 Pro、V4.1 Flash 的 API 和对话服务还在「性能下降」。响应慢、并发差，负载一高照样卡。&lt;/p&gt;
&lt;p&gt;你下午多点几次重试，撞上的就是这个卡顿。硬中断只有一起，性能下降一直挂着，体感上自然成了好几回。&lt;/p&gt;
&lt;p style=&quot;text-align:center;color:#c4c4c4;letter-spacing:0.6em;margin:1.6em 0;&quot;&gt;· · ·&lt;/p&gt;
&lt;p&gt;那为啥又崩？官方到发稿为止没有给技术原因。真要找线索，翻翻上个月的道歉信。&lt;/p&gt;
&lt;p&gt;10 月 15 号那次狠得多，从早上 8 点 11 分断到 13 点 04 分，趴了将近 5 个小时。官方当晚发补偿通知，原话写着要「全面梳理并剥离单点依赖」。单点依赖四个字，等于承认系统里有个地方一坏，全局跟着停。&lt;/p&gt;
&lt;p&gt;专家田丰一句话点破：研究型公司，迭代速度跑在运维余量前面了。大模型重启一次就是一次小型发布，重新加载权重、预热、缓存重建，恢复本来就慢。再撞上用户狂点重试，访问量成倍放大，修的人都在跟流量打架。&lt;/p&gt;
&lt;p&gt;数字也摆在那。媒体统计，年内大面积异常至少 18 起。官方状态页 10 月一个月就记了 7 起，9 月 2 号、15 号也断过，9 月以来还有 9 次性能下降。&lt;/p&gt;
&lt;p&gt;10 月那次官方掏了钱：按 10 月 8 号到 14 号的消耗，赠金全额返还。这次到发稿为止，原因没有说，补偿也没有提。&lt;/p&gt;
&lt;p style=&quot;text-align:center;color:#c4c4c4;letter-spacing:0.6em;margin:1.6em 0;&quot;&gt;· · ·&lt;/p&gt;
&lt;p&gt;社区里的声音分两种。一种是干活干到一半的：对话加载失败、接口调用异常，稿子卡在半路、代码跑了一半，只能一遍一遍刷。另一种是抠官方文案的：状态页那句「排查问题以定位原因」写得别扭，评论区有人盯着那几个字开问，这话到底通不通。&lt;/p&gt;
&lt;p&gt;上次的补偿方案也被翻出来重新吵。钱只赔给 API 付费用户，网页和 App 免费用户一分没有。&lt;/p&gt;
&lt;p&gt;赠金还不能提现，只能抵扣后面的账单。开发者晒到账截图，普通人只能看着。&lt;/p&gt;
&lt;p style=&quot;text-align:center;color:#c4c4c4;letter-spacing:0.6em;margin:1.6em 0;&quot;&gt;· · ·&lt;/p&gt;
&lt;p&gt;要我说，不要光盯着「又崩了」三个字乐。现在把工作流绑在一家 AI 上的人越来越多，它一停摆，停工的不是服务器，是你今天要交的活。&lt;/p&gt;
&lt;p&gt;手机里装一个备用的。重要的稿子经常复制出来存一份。这两件事情花不了几分钟。&lt;/p&gt;
&lt;p&gt;官方那边就等两样：这次的技术原因，会不会再发一轮赠金。我盯着，有消息再聊。&lt;/p&gt;</description><pubDate>Tue, 03 Nov 2026 18:09:26 +0800</pubDate></item><item><title>芯片战争：硅谷的地缘政治从来不是隐形的</title><link>https://www.jiangtian.top/post/17791.html</link><description>&lt;p style=&quot;font-size:13px;color:#8A857C;line-height:1.9;margin:0 0 22px;padding:12px 16px;background:#F7F6F3;border-radius:8px;&quot;&gt;
微信读书《芯片战争：世界最关键技术的争夺战》· 克里斯·米勒（Chris Miller）著&lt;br&gt;
逐页翻阅 &lt;strong style=&quot;color:#5A5248;&quot;&gt;372 屏&lt;/strong&gt; · &lt;strong style=&quot;color:#5A5248;&quot;&gt;54&lt;/strong&gt; 章 · 2026-11-03&lt;br&gt;
&lt;span style=&quot;font-size:12px;&quot;&gt;说明：这是一本讲产业的史书，不是技术手册。作者不教你造芯片，他讲的是芯片这件&quot;商品&quot;怎么一步步长成了大国的命脉。全书分八部分，从晶体管的发明一路写到华为被制裁、台湾困境，时间跨度七十多年。我的读法是把它当成一本&quot;权力如何附着在技术之上&quot;的案例集。&lt;/span&gt;
&lt;/p&gt;

&lt;p&gt;很多讲芯片的书，一上来就给你看晶体管的结构图，讲光刻机有多精密。这本书不一样，它的第一章标题是&quot;从钢铁到硅片&quot;，讲的是&lt;strong&gt;一个产业的出身&lt;/strong&gt;——它不是从实验室里冒出来的，是从冷战的需求里长出来的。&lt;/p&gt;

&lt;p&gt;这个视角决定了整本书的底色。&lt;strong&gt;芯片从来不是一个纯粹的商业故事，它是一个被政治和军事需求反复塑造的技术故事。&lt;/strong&gt;理解了这一点，你再看今天的中美芯片博弈、实体清单、EUV 光刻机禁令，就不会觉得这些是&quot;突然发生的新事&quot;——它们只是这个故事最新的一章。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;一、晶体管是被&quot;测不到&quot;逼出来的&lt;/h2&gt;

&lt;p&gt;书里最打动我的一个细节，是晶体管发明之前肖克利的失败。&lt;/p&gt;

&lt;p&gt;1945 年，肖克利提出了&quot;固态阀门&quot;的设想：在硅这样的半导体上施加电场，把内部的自由电子吸引到边缘，让不导电的材料变成导电的，电流就能流过去。他在笔记本上画了一块接在 90 伏电池上的硅。&lt;/p&gt;

&lt;p&gt;结果呢？书里引了他的原话——&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;&quot;什么都没有测到，&quot;他解释道，&quot;相当怪异。&quot;&lt;/p&gt;

&lt;p&gt;原因不是什么高深的理论错误，而是&quot;20 世纪 40 年代的简单仪器不够精确，无法测量出微小电流&quot;。换句话说，&lt;strong&gt;他的想法是对的，只是当时的工具还没准备好。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;两年后的 1947 年 12 月 16 日下午，贝尔实验室的布拉顿和巴丁才把这件事做成。他们是两个性格完全不同的人——布拉顿是华盛顿农村牧场出身的实验物理学家，巴丁是普林斯顿毕业的理论家，后来成了唯一拿过两次诺贝尔物理学奖的人。他们受肖克利的启发，把两条间距不到一毫米的金箔线压在锗片上，底面接上电极，一通电，观测到流过锗的电流可以被控制和放大。&lt;/p&gt;

&lt;p&gt;晶体管就这么诞生了。而给它起名的 AT&amp;T 之所以叫它&quot;晶体管&quot;，理由也特别朴实：&lt;strong&gt;因为它能放大电话信号。&lt;/strong&gt;那时没人想到，这个东西会成为人类有史以来最重要的发明之一。&lt;/p&gt;

&lt;p&gt;我读这一段最大的感受是：&lt;strong&gt;重大突破往往不是&quot;想通了&quot;，而是&quot;工具终于追上了想法&quot;。&lt;/strong&gt;肖克利 1945 年就想对了，但仪器测不到，他就只能停在原地。我们现在回看会觉得这很可惜，可站在当时的节点上，没有人知道哪条路会通向哪里。这本书反复在讲一个道理——技术的胜负，很多时候不取决于谁先想到，而取决于谁先有那一套能把它&quot;测出来、做出来、量产出来&quot;的完整体系。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;二、芯片的第一个大买家是五角大楼&lt;/h2&gt;

&lt;p&gt;这是全书我最想跟人讲清楚的一章——第十四章&quot;五角大楼的抵消战略&quot;。&lt;/p&gt;

&lt;p&gt;书里有一句非常扎眼的话：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;没有人比五角大楼这一旧秩序的基石更能从罗伯特·诺伊斯和戈登·摩尔的革命中受益。&lt;/p&gt;

&lt;p&gt;这句话点破了芯片产业的真相：&lt;strong&gt;最早看清芯片价值、并且有足够预算把它买大的，不是消费市场，是军方。&lt;/strong&gt;诺伊斯和摩尔当年&quot;无视政府，通过销售大众市场计算器和大型计算机芯片而发财&quot;，但真正给整个行业托底的，是五角大楼源源不断的军品订单。&lt;/p&gt;

&lt;p&gt;书里讲了一个人——威廉·佩里。1977 年他到华盛顿当负责研究和工程的国防部副部长，自我感觉&quot;就像一个在糖果店里的孩子&quot;，认为这是&quot;世界上最好的工作&quot;。佩里是宾夕法尼亚州一个面包师的儿子，早年在喜万年电子防御实验室做设计监控苏联导弹发射的机密电子设备，1962 年古巴导弹危机时，他是被紧急召到华盛顿检查 U-2 侦察照片的十名专家之一。&lt;/p&gt;

&lt;p&gt;佩里这批人的价值在于：&lt;strong&gt;他们同时懂两套语言——硅谷的技术语言和五角大楼的军事语言。&lt;/strong&gt;他们提出的&quot;抵消战略&quot;，核心思路是：苏联人比我们人多、坦克多、规模大，那我们就用电子技术和精确制导去抵消他们的数量优势。芯片，就是这个战略的物质基础。&lt;/p&gt;

&lt;p&gt;这让我想到一个常常被忽视的事实：&lt;strong&gt;技术的&quot;军用&quot;和&quot;民用&quot;，在早期从来分不开。&lt;/strong&gt;今天我们在手机、电脑里用的每一块芯片，其生产工艺、质量控制、规模制造的经验，很多是从当年给导弹和卫星做芯片的订单里一点点磨出来的。军品对可靠性、一致性、良率的苛刻要求，逼着行业把&quot;手工作坊&quot;改造成了&quot;规模生产&quot;。书里&quot;迫击炮和规模生产&quot;那一章讲的就是这个转变——芯片要便宜到能装进每一发炮弹里，这个&quot;便宜&quot;不是省出来的，是量产体系喂出来的。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;三、&quot;敌人的敌人是朋友&quot;：美国亲手养大了对手&lt;/h2&gt;

&lt;p&gt;书里有一段我觉得特别讽刺、也特别说明问题的历史：美国扶持韩国打日本。&lt;/p&gt;

&lt;p&gt;上世纪八十年代，日本在存储芯片（DRAM）上把美国打得节节败退。美国公司的反应不是自己硬扛，而是&lt;strong&gt;把技术和市场一起送给了韩国&lt;/strong&gt;，用韩国去压日本。&lt;/p&gt;

&lt;p&gt;书里写得非常直白：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;美国人并不打算让这笔交易惠及韩国公司，但他们很高兴看到除了日本以外的任何公司生产他们所需要的芯片。&lt;/p&gt;

&lt;p&gt;硅谷当时濒临倒闭的 DRAM 生产商，&quot;几乎毫不犹豫地将顶尖技术转移到韩国&quot;。李秉喆（三星创始人）去找资金紧张的存储芯片初创公司美光，谈 64K DRAM 芯片的授权，美光正缺钱，热切地同意了——&quot;即使这意味着三星将学习美光的许多工艺流程&quot;。美光创始人沃德·帕金森后来回忆说了一句很无奈的话：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;无论我们做了什么，三星都做到了。&lt;/p&gt;

&lt;p&gt;而整件事的逻辑，被 AMD 的创始人杰瑞·桑德斯一句话总结了：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;敌人的敌人就是朋友。&lt;/p&gt;

&lt;p&gt;戈登·摩尔当时就担心，有些芯片公司会&quot;因为过于绝望而放弃越来越有价值的技术&quot;。事实证明他的担心是对的。美国为了干掉日本这个眼前的敌人，把韩国这个未来的敌人给养壮了。&lt;strong&gt;这就是地缘博弈里最经典的一个短视循环：为了赢眼前这一局，不惜埋下下一局的隐患。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;读到这里我有个很直接的感受：&lt;strong&gt;所谓&quot;技术封锁&quot;&quot;技术转让&quot;，从来都不是一条单向的命令，而是一连串被短期利益驱动的决策叠加。&lt;/strong&gt;每一个决策在当时都显得合理——美光缺钱，三星愿意给钱买授权，为什么不卖？但把这一个个&quot;合理&quot;串起来，最后就是一个产业霸权的易手。今天美国对中国的技术管制之所以格外严厉，某种程度上正是吸取了当年&quot;养大韩国、后来又面对日本&quot;的教训——只是这回，它选择在对手还没长成之前就动手。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;四、&quot;真正的男人要有晶圆厂&quot;：一句被时代证伪的狠话&lt;/h2&gt;

&lt;p&gt;书里第六章&quot;离岸创新&quot;讲了一个行业的根本性转向，它用了一句很传神的话做引子——&quot;真正的男人要有晶圆厂&quot;。&lt;/p&gt;

&lt;p&gt;这句话曾经是半导体圈的身份认同：你要么有自己的工厂，要么你不是&quot;真正&quot;的半导体公司。但到了八十年代末，这个逻辑被彻底反转了。&lt;/p&gt;

&lt;p&gt;1984 年，戈登·坎贝尔和达多·巴拿陶创立了被公认为第一家&quot;无晶圆厂&quot;的芯片公司——只设计芯片，把制造外包出去。当时有朋友嘲笑这家公司&quot;不是一家真正的半导体公司&quot;，因为它自己不造芯片。可正是这个&quot;不造芯片&quot;的模式，证明了：&lt;strong&gt;只要有一个好主意和几百万美元启动资金，就能进入半导体行业&lt;/strong&gt;——而这笔钱，只是建一个晶圆厂所需资金的&quot;很小一部分&quot;。&lt;/p&gt;

&lt;p&gt;这个转变的直接后果，是英伟达这样的公司有了诞生的土壤。书里有个细节很有意思：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;最终主宰图形处理芯片市场的英伟达，并非诞生在时尚的帕洛阿尔托咖啡馆，而是在圣何塞一个落后地区的丹尼快餐店。&lt;/p&gt;

&lt;p&gt;英伟达 1993 年成立，靠的就是&quot;无晶圆厂&quot;这条路——它不需要几十亿美元的工厂，只需要一群懂设计的人，剩下的交给台积电。&lt;/p&gt;

&lt;p&gt;而台积电的诞生，才是整盘棋的关键。张忠谋当年在德州仪器落选首席执行官之后，去了台湾，创立了台积电，把&quot;制造&quot;变成了一种服务。台积电和英特尔的差别，书里有一段对比讲得特别清楚：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;台积电对知识产权持开放态度，但英特尔闭门保守。台积电是面向服务的，但英特尔认为客户应该遵守自己的规则。&lt;/p&gt;

&lt;p&gt;最关键的一句是：&lt;strong&gt;台积电没有设计任何芯片，所以它不与任何客户竞争；而英特尔既是代工，又用自己的芯片跟所有客户竞争。&lt;/strong&gt;这就是为什么后来英特尔的代工业务会失败——没有客户愿意把最核心的设计交给一个随时可能跟自己抢生意的对手。&lt;/p&gt;

&lt;p&gt;我想强调一个容易被忽略的点：&lt;strong&gt;&quot;无晶圆厂&quot;革命不只是商业模式的创新，它是一次权力结构的重组。&lt;/strong&gt;在此之前，谁有工厂谁说了算；在此之后，设计、制造、设备、材料被拆成了一个个独立环节，每个环节都可能诞生一个&quot;卡脖子&quot;的巨头。今天的光刻机霸主 ASML、代工霸主台积电、设计霸主英伟达，都是这场拆分的产物。拆分的初衷是降低成本、提高效率，但它同时埋下了一个今天让所有人都头疼的后果——&lt;strong&gt;这条链太细、太长了，任何一个环节被掐断，全球都得停摆。&lt;/strong&gt;&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;五、英特尔的衰败，是一堂活生生的&quot;创新者困境&quot;课&lt;/h2&gt;

&lt;p&gt;如果说前面几章讲的是&quot;怎么赢&quot;，那英特尔的故事讲的就是&quot;赢家怎么输&quot;。&lt;/p&gt;

&lt;p&gt;书里第三十三章&quot;创新者的困境&quot;、第四十一章&quot;英特尔如何遗忘创新&quot;，几乎是一份企业衰亡的病理报告。&lt;/p&gt;

&lt;p&gt;有几个时间点很关键。英特尔在数据中心处理器销售上&quot;近乎垄断&quot;的局面，正在被英伟达和大型云公司打破。2015 年左右，英特尔试图进军芯片代工，正面挑战台积电，结果失败了。书里说：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;但英特尔私下承认，集成设计和制造模式远没有英特尔高管所宣称的那样成功。&lt;/p&gt;

&lt;p&gt;2013 到 2018 年担任英特尔 CEO 的布莱恩·克尔尼奇曾公开说，过去几年他&quot;基本上一直在运营我们的代工业务&quot;，还强调这项业务&quot;具有战略重要性&quot;。但客户并不买账——&quot;他们认为英特尔没有把代工客户放在首要位置&quot;。在英特尔内部，代工业务&quot;几乎得不到内部支持&quot;，跟制造个人电脑和数据中心芯片相比，它排在很后面。结果是，英特尔的代工业务在整个二十一世纪第二个十年&quot;只赢得了一个主要客户&quot;，几年后就关门了。&lt;/p&gt;

&lt;p&gt;2018 年，英特尔成立近五十周年，&quot;衰退开始了&quot;。市场份额萎缩，创新发生在别处。而压垮它的最后一根稻草，是它&quot;对摩尔定律的拙劣处理&quot;——自 2015 年以来，英特尔一再宣布推迟 10 纳米和 7 纳米工艺，而台积电和三星已经提前推出。&lt;/p&gt;

&lt;p&gt;我读英特尔的衰败，最大的教训是：&lt;strong&gt;一个公司一旦同时想要&quot;设计&quot;和&quot;制造&quot;，它就必然要在某个时刻跟自己打架。&lt;/strong&gt;英特尔最大的问题不是技术不行——书里明说它&quot;具备成为主要芯片制造企业的所有要素，包括先进的技术和强大的生产能力&quot;——而是它的商业模式天然地和客户冲突。它要改变，需要&quot;重大的文化变革&quot;，而文化恰恰是最难改的东西。&lt;/p&gt;

&lt;p&gt;这跟书里另一处形成强烈呼应。当年美国国防部专门为价值 10 亿美元的潜艇、价值 100 亿美元的航空母舰建了造船厂，但其中许多芯片是从商业供应商（常常是中国台湾的供应商）那里买的。为什么？因为&quot;即使设计一款尖端芯片（可能超过 1 亿美元），对于五角大楼来说成本也变得过于昂贵&quot;，而&quot;制造最先进逻辑芯片的工艺设备成本是航空母舰的两倍&quot;。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;当&quot;造芯片&quot;比&quot;造航母&quot;还贵的时候，你就明白为什么连最强大的国家都要靠别人了。&lt;/strong&gt;这不是愿不愿意的问题，是算不算得过来的问题。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;六、从&quot;跑得更快&quot;到&quot;没有B计划&quot;：美国的觉醒太迟了&lt;/h2&gt;

&lt;p&gt;书里第三十四章的标题叫&quot;跑得更快？&quot;，第四十章叫&quot;没有B计划&quot;。这两个标题连起来，就是美国芯片政策的一条完整心路：先是盲目自信地&quot;跑得更快&quot;，最后发现自己其实&quot;没有B计划&quot;。&lt;/p&gt;

&lt;p&gt;奥巴马政府的迟缓是个很有代表性的切片。书里引了一位参与工作的人的话：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;华盛顿的大多数人不知道半导体是什么。&lt;/p&gt;

&lt;p&gt;奥巴马政府在半导体上进展缓慢，&quot;因为许多高级官员根本不认为芯片问题是一个重要问题&quot;。直到 2016 年底、也就是当年总统大选前六天，美国商务部长彭妮·普里茨克才在华盛顿发表了那场&quot;高调演讲&quot;，说&quot;半导体技术必须成为美国创造力的核心特征和经济增长的驱动力，我们不能放弃我们的领导权&quot;。&lt;/p&gt;

&lt;p&gt;她还谴责&quot;不公平的贸易做法和大规模的、非市场化的国家干预&quot;，并点出了当时紫光海外并购潮引发的指控——&quot;中国基于政府利益而非商业目标收购公司和技术的新尝试&quot;。她甚至承诺&quot;利用一切机会向中国领导人明确表示，我们不会接受旨在影响这个行业的 1500 亿美元产业政策&quot;。&lt;/p&gt;

&lt;p&gt;但白宫委托半导体高管和学者做的研究报告，最后给的建议却是——&quot;以更快的速度赢得比赛&quot;，书里毫不客气地补了一句：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;这是可以从 20 世纪 90 年代复制和粘贴的建议。&lt;/p&gt;

&lt;p&gt;这句话太狠了，也太准了。&lt;strong&gt;当产业已经全球化了三十年，你还在用&quot;我们只要跑得更快&quot;来应对，本质上就是承认自己已经不知道该怎么应对了。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;书里那句总结我反复看了好几遍：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;摩尔定律的延续是竞争的必然。在过去几十年里，华盛顿认为自己&quot;跑得更快&quot;，但其对手已经扩大了市场份额，整个世界可怕地依赖于少数几个脆弱的瓶颈，特别是中国……&lt;/p&gt;

&lt;p&gt;这句话点出了全书最核心的洞察之一：&lt;strong&gt;全球芯片产业的高效，是以极致的集中和极致的脆弱为代价的。&lt;/strong&gt;效率越高，链条越细；链条越细，越经不起任何一环的断裂。而&quot;跑得更快&quot;这种思维，恰恰忽略了这一点——它只想着怎么把速度提上去，没想过万一某个环节断了自己怎么办。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;七、它的短板&lt;/h2&gt;

&lt;p&gt;这本书口碑很好，但要说缺点，我觉得有四个，值得老实写出来。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第一，它是一本&quot;美国视角&quot;的书，中文读者得带着警惕读。&lt;/strong&gt;作者克里斯·米勒是塔夫茨大学的国际史教授，他的立场决定了整本书的叙事重心在美国。书里对&quot;中国的挑战&quot;那一部分（第七部分），讲华为的崛起、技术转让、并购，整体基调是&quot;中国在挑战美国的领导地位，美国必须反击&quot;。这不是说作者在撒谎——他引用的史实大多是扎实的——而是说他&lt;strong&gt;选择讲什么、怎么讲，背后有一套默认的价值判断&lt;/strong&gt;。读的时候，你会明显感到&quot;美国&quot;是一个需要守护的主角，&quot;中国&quot;是一个需要警惕的变量。中文读者如果不加分辨地全盘接受，很容易被带进&quot;芯片战争的本质就是中国威胁&quot;的框架里。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第二，它对&quot;为什么是美国&quot;的解释，偏技术决定论，弱化了很多结构性因素。&lt;/strong&gt;书里反复强调摩尔定律、规模经济、风险资本、军事采购这些&quot;美国优势&quot;，但对亚洲各国（日、韩、中国台湾、中国大陆）的产业政策、国家意志、劳动力结构这些同样关键的变量，着墨相对单薄。比如韩国怎么靠国家意志把存储芯片做成，日本怎么靠通产省式的产业协同崛起，这些书里都讲了，但讲得不如&quot;美国怎么赢/怎么输&quot;那么细。这导致一个结果：&lt;strong&gt;读者看完会觉得芯片的版图主要是美国自己&quot;跑得快&quot;或&quot;跑得慢&quot;的结果，而对东亚各国主动塑造产业的能力估计不足。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第三，对台积电和张忠谋的刻画，有点&quot;造神&quot;的嫌疑。&lt;/strong&gt;书里把张忠谋塑造成一个几乎凭一己之力改变产业格局的人——落选 TI 总裁、远走台湾、创立台积电、定下&quot;不跟客户竞争&quot;的规则。这些都没错，但一个人的成功，背后必然有时代的、政策的、资本的多重推力。台湾当年给半导体产业的优惠、全球电子业向东亚转移的大势、美国有意扶持台湾作为制衡筹码的地缘算计，这些&quot;结构性的运气&quot;，书里提了，但都被&quot;张忠谋&quot;这个个人英雄的光环盖过去了。&lt;strong&gt;读这本书，你会得到一个略被放大的印象：产业的转折，关键看有没有一个天才。&lt;/strong&gt;但真实的历史，往往是天才恰好站在了风口上。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第四，也是最实际的：它写的是&quot;到 2023 年左右&quot;的历史，而芯片战争还在继续。&lt;/strong&gt;这本书出版后的这几年，情况又变了很多——美国出口管制不断加码、中国的国产替代在推进、AI 芯片的需求把英伟达推上了新的高度。书里写的很多&quot;当下&quot;，现在已经成了&quot;过去&quot;。所以它最适合的读法，不是当成一本&quot;芯片战争的最终答案&quot;，而是当成一本&lt;strong&gt;理解芯片战争&quot;为什么走到今天&quot;的前传&lt;/strong&gt;。你要用它来理解最新动态背后的逻辑，但最新的动态本身，得另找信源去补。&lt;/p&gt;

&lt;p&gt;这四个短板，都不影响它作为入门读物的价值。恰恰相反，&lt;strong&gt;一本有明确立场、有个人英雄叙事、有清晰时间线的书，反而更好读、更容易让一个门外汉建立起对这个产业的基本认知。&lt;/strong&gt;我的建议是：把它当成一张地图，用它建立坐标系；但别把它当成说明书，照单全收。&lt;/p&gt;

&lt;figure style=&quot;margin:34px 0 30px;text-align:center;&quot;&gt;
  &lt;img src=&quot;https://www.jiangtian.top/zb_users/upload/kg/chip-war.png&quot; alt=&quot;芯片战争 核心知识图谱&quot; style=&quot;max-width:100%;border-radius:10px;box-shadow:0 6px 24px rgba(0,0,0,.09);&quot;&gt;
  &lt;figcaption style=&quot;font-size:12px;color:#8A857C;margin-top:12px;&quot;&gt;核心知识图谱：技术起源 → 地缘博弈 → 产业分工 → 中美博弈&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;一句话总结：&lt;strong&gt;芯片战争的真正主角从来不是芯片本身，而是&quot;谁能决定芯片在哪里被造出来&quot;的权力——技术只是这场权力游戏里最硬的筹码。&lt;/strong&gt;&lt;/p&gt;

&lt;hr style=&quot;border:none;border-top:1px solid #E3E0D9;margin:36px 0 18px;&quot;&gt;
&lt;p style=&quot;font-size:12px;color:#97938B;line-height:1.9;&quot;&gt;阅读记录：《芯片战争：世界最关键技术的争夺战》，克里斯·米勒（Chris Miller）著，微信读书逐页翻阅 &lt;strong&gt;372 屏&lt;/strong&gt;，五十四章读完，从晶体管的发明读到华为被制裁与台湾困境。2026-11-03。&lt;/p&gt;
</description><pubDate>Tue, 03 Nov 2026 18:06:28 +0800</pubDate></item><item><title>App 签名证书到底是怎么生成出来的？</title><link>https://www.jiangtian.top/post/17790.html</link><description>&lt;p&gt;开发者可以随便填安卓证书的主体名称，却填不了 iOS 和鸿蒙的，因为后面这两张证书都得苹果和华为签字。同样叫做签名证书，三张纸的生成机制完全不一样。下面把它拆到根子上讲清楚。&lt;/p&gt;
&lt;p&gt;证书的根子是一对密钥，加一张证明公钥归属的纸。私钥留在自己手里负责签名，公钥写进证书交给别人验证。这张纸由谁签字，就决定了主体名称由谁定。&lt;/p&gt;
&lt;p&gt;这张纸的学名叫做 X.509 数字证书，里面有一段字段叫做 DN，中文叫做可分辨名称。DN 装着通用名、组织单位、组织名称、城市、省份、国家这六样东西。安卓的 DN 由生成的人直接填写，iOS 和鸿蒙的 DN 由签发方填写。&lt;/p&gt;
&lt;p style=&quot;text-align:center;color:#c4c4c4;letter-spacing:0.6em;margin:1.6em 0;&quot;&gt;· · ·&lt;/p&gt;
&lt;p&gt;先说安卓，一条 keytool 命令能一口气生成密钥对、自签证书和 JKS 仓库文件。命令里的 -dname 参数就是填写 DN 的位置，公司全称写进 CN 字段或者 O 字段都可以。生成出来的 .keystore 文件同时装着私钥和证书，设置密码就算完工。&lt;/p&gt;
&lt;p&gt;所以工具表单只要五样材料：主体名称、密钥别名、密码、有效年数、密钥算法。主体名称建议照抄营业执照上的公司全称，别名固定用 release，有效年数设成三十年，算法认准 RSA 2048。密码一定要保管好，私钥丢失就永远更新不了这个应用。&lt;/p&gt;
&lt;p&gt;HBuilderX 云打包的云证书就卡住在这一步。DCloud 服务器生成证书时自动填写证书信息，不支持自定义证书信息，有效期固定一百年。想让证书里写着甲方公司名称，云证书这条路走不通，只能自己生成再传上去。&lt;/p&gt;
&lt;p&gt;生成的时候还有格式岔路。JKS 是 Java 老格式，仓库密码和密钥密码可以分开设置；PKCS12 是新标准，两个密码必须相同。工具输出标准 JKS 并把两个密码设成一样，是为了兼容 Android 全家桶。&lt;/p&gt;
&lt;p style=&quot;text-align:center;color:#c4c4c4;letter-spacing:0.6em;margin:1.6em 0;&quot;&gt;· · ·&lt;/p&gt;
&lt;p&gt;再说 iOS，玩法完全变了，本地只能生成密钥对和 CSR 请求文件。真正的证书必须提交给苹果签发，主体写的是 Apple Distribution 加上团队名称和 Team ID。团队名称就是开发者账号注册时的公司名称，想换主体名称只能换账号，没有第二条路。&lt;/p&gt;
&lt;p&gt;因此 iOS 要准备的是苹果开发者账号、公司资质、D-U-N-S 编号、App ID 和描述文件。公司账号年费九十九美元，还得通过苹果的资质审核。CSR 里随便填名字没有意义，苹果会按团队信息重写证书主体。&lt;/p&gt;
&lt;p&gt;纯血鸿蒙跟 iOS 是一个模子刻出来的。本地生成 p12 密钥库和 csr 请求文件，上传到 AppGallery Connect 申请 cer 证书。要准备华为开发者账号、企业实名认证、包名和签名证书指纹。&lt;/p&gt;
&lt;p&gt;华为签出来的证书还配一张 p7b 描述文件，文件里绑死包名、权限列表和设备列表。鸿蒙的 DN 字段有一道硬限制。姓名、组织、组织单位这些字段只接受字母和空格，长度不超过六十四个字符，中文公司名填不进去。&lt;/p&gt;
&lt;p style=&quot;text-align:center;color:#c4c4c4;letter-spacing:0.6em;margin:1.6em 0;&quot;&gt;· · ·&lt;/p&gt;
&lt;p&gt;证书生成完还有备案这一步。备案要的不是证书文件，而是证书里的公钥模数和指纹。安卓填 MD5，iOS 填 SHA1，公钥填 RSA 模数 n 的十六进制，注意不带 ASN.1 外层包装。&lt;/p&gt;
&lt;p&gt;解析工具的做法是把 APK 或者证书文件解开，从签名块里取出 X.509 证书，再拆开证书提取公钥。RSA 公钥是 ASN.1 结构，去掉包装就拿到 n 和 e 两个参数。指纹对证书的 DER 字节流计算 MD5 或者 SHA1 就出来。&lt;/p&gt;
&lt;p&gt;卡点集中在四个地方。第一，主体名称的自由度：安卓完全自由，鸿蒙只能填字母，iOS 零自由。第二，私钥保管：私钥丢失就永远更新不了应用，密码忘记等于丢失私钥。&lt;/p&gt;
&lt;p&gt;第三，更换签名等于更换应用。已经上架的应用更换证书，用户端会安装冲突，必须卸载重装。第四，有效期有硬杠杠，Google Play 要求发布证书有效到二零三三年十月之后，所以有效年数不要设太短。&lt;/p&gt;
&lt;p&gt;自己的工具省掉的是两件麻烦事情。一是记住一堆 keytool 参数，二是跟大模型来回确认命令格式。表单填完点击生成，证书和解析结果一次到位。&lt;/p&gt;</description><pubDate>Tue, 03 Nov 2026 17:39:39 +0800</pubDate></item><item><title>博客写作提示词整理</title><link>https://www.jiangtian.top/post/17789.html</link><description>&lt;blockquote&gt;本文是给大模型（道合君）看的写作与发布指令。下面每一条都是要执行的规则，不是建议；本文没写到的，按常识处理。&lt;/blockquote&gt;
&lt;h3&gt;一、每次写博客必须执行的写作规范（共 10 条）&lt;/h3&gt;
&lt;p&gt;1. &lt;strong&gt;标题必须是问句&lt;/strong&gt;。2. &lt;strong&gt;每篇第一句 = 主谓宾完整的句子，直接下结论&lt;/strong&gt;，开门见山呼应标题。不铺垫，不设景，不写「让我们一起来看看」这类开场。3. &lt;strong&gt;全词表达 —— 死规则，最高优先级，违反即失败&lt;/strong&gt;。动笔前先打开对照表自查：`https://jiangtian.top/tool/quanci-biao.html`（562 条，分四档：必补 226 / 位置受限 212 / 看语体 80 / 别补 44，每条挂真实例句，可搜可筛）。中文里一切词写的时候用完整词形，&lt;strong&gt;禁止把日常本来双音的词砍成单字&lt;/strong&gt;（例如「翻译」不能写成「翻」、「因为」不能写成「因」、「但是」不能写成「但」）。检查方法：用 jieba 把正文切成最小单位，挑出所有长度为 1 的实词，逐个判断「这个位置，中国人平时会不会这么说」，禁止自己列一张候选字表去扫。例外：引号里引用别人的原话；该单字本身就是完整词（例如「走」「说」不必改成「行走」「说话」）。4. &lt;strong&gt;句句咬合，段段咬合&lt;/strong&gt;。后一句紧接前一句，后一段紧接前一段，读起来像滑滑梯，一路滑到底，不能出现台阶和断层。5. &lt;strong&gt;多用动词&lt;/strong&gt;。靠动作推进句子，靠动作造节奏。少堆形容词，少用名词短语硬凑。6. &lt;strong&gt;每段不超过 3 句&lt;/strong&gt;。超过就拆段，别写大坨。7. &lt;strong&gt;通篇前后自查&lt;/strong&gt;。整句、整段、整文逐层核对有没有冲突和矛盾，&lt;strong&gt;数字类（年份、金额、人数、名次、指标）尤其要前后一致&lt;/strong&gt;。发布前必须跑一遍。8. &lt;strong&gt;聊天式大白话&lt;/strong&gt;。像跟同事说话，短句，口语词，不用书面腔，不用「赋能 / 闭环 / 抓手」这类词。9. &lt;strong&gt;MECE&lt;/strong&gt;。分段分点互斥且穷尽，不重叠、不漏项。10. &lt;strong&gt;结论先行，数字说话&lt;/strong&gt;。能给硬指标就不说「比较流行」，能做表格就不写八段散文。&lt;/p&gt;
&lt;h3&gt;二、发布时的硬规范&lt;/h3&gt;
&lt;ul&gt;&lt;li&gt;&lt;strong&gt;标签必须显式指定白名单&lt;/strong&gt;，不要依赖系统自动提取关键词。自动提取会把「」等标点当成分隔边界，从标题切出 `说「` 这类残片标签。发布脚本里按名称查已有标签、没有才新建，再把文章标签整体覆盖成白名单，最后只删 count≤1 的孤儿标签。注意「AI Agent」「Claude Code」「V4-Flash」这类带空格或连字符的是正常标签，不能误删。&lt;/li&gt;&lt;li&gt;&lt;strong&gt;独立页面（非博文正文）自带返回导航&lt;/strong&gt;：凡发布到 jiangtian.top 的独立页面（简历页、作品页、专题页、工具页），顶栏固定「← 博客首页」`/` 与「AI 实验室」`/lab/#ai`，页脚再放一次返回链接。博文正文走正常博文模板，不适用这一条。&lt;/li&gt;&lt;/ul&gt;
&lt;h3&gt;三、可直接复用的「一句话提示词」&lt;/h3&gt;
&lt;blockquote&gt;围绕【主题 / 我的感悟】，写一篇禅思哲理文，聊天式，结论先行。严格按我记忆里的写作规范来：标题必须是问句、第一句主谓宾完整直接下结论、全词表达（动笔前过 https://jiangtian.top/tool/quanci-biao.html 对照表）、每段不超 3 句、句句段段咬合、多动词、数字前后核。写完跑 jieba 全词自查，发布到 jiangtian.top，标签显式指定、别让系统自动切片。&lt;/blockquote&gt;
&lt;hr/&gt;
&lt;blockquote&gt;&lt;strong&gt;以下为整理背景，非写作指令，大模型无需执行，也不要套用。&lt;/strong&gt;&lt;/blockquote&gt;
&lt;h3&gt;背景（非指令）&lt;/h3&gt;
&lt;p&gt;本文由 2026-11-03 一轮佛经解读写作对话沉淀而来。当时逐条追加的指令、各篇发布情况、标签残片修复等，仅为溯源保留，与未来写作无关。&lt;/p&gt;</description><pubDate>Tue, 03 Nov 2026 17:30:50 +0800</pubDate></item><item><title>Agent 的能力上限，不在模型有多聪明</title><link>https://www.jiangtian.top/post/17788.html</link><description>&lt;p style=&quot;font-size:13px;color:#8A857C;line-height:1.9;margin:0 0 22px;padding:12px 16px;background:#F7F6F3;border-radius:8px;&quot;&gt;
微信读书《大模型Agent开发实践》· 陈志鹏（@木羽Cheney）&lt;br&gt;
逐页翻阅 &lt;strong style=&quot;color:#5A5248;&quot;&gt;599 屏&lt;/strong&gt; · &lt;strong style=&quot;color:#5A5248;&quot;&gt;8&lt;/strong&gt; 章 · 2026-11-03&lt;br&gt;
&lt;span style=&quot;font-size:12px;&quot;&gt;说明：这是一本必须开着终端读的书。599 屏里绝大部分是命令行、代码块和运行截图，作者是赋范空间的大模型技术负责人，写法偏&quot;带你走一遍&quot;而不是&quot;讲个道理&quot;。也正因为它这么实，它的优点和毛病都特别明显。&lt;/span&gt;
&lt;/p&gt;

&lt;p&gt;Agent 这个题目，很容易写成两类书。&lt;/p&gt;

&lt;p&gt;一类是概念书：讲什么是智能体、有哪些范式、未来会怎样。读完你觉得懂了，一动手发现不知道从哪一行开始写。另一类是技巧书：给你一堆提示词模板和框架对比，读完能跑个 demo，但一上真实业务就崩。&lt;/p&gt;

&lt;p&gt;这本书走的是第三条路，也是我认为最难写的一条：&lt;strong&gt;把一个 Agent 从环境装起，一路做到企业级可用。&lt;/strong&gt;八章就是这条路的八个路段——Agent 基础、大模型部署、DeepSeek 实操、本地知识库 RAG、RAG 实战、微调实战、Agent 开发、企业级实战。&lt;/p&gt;

&lt;p&gt;这个顺序本身就是一个判断：&lt;strong&gt;Agent 不是一个起点，是一个终点。&lt;/strong&gt;你必须先有能跑起来的模型，再有能喂进去的知识，再有能约束它的框架，最后才谈得上&quot;智能体&quot;。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;一、第一个真实的坑：它把草稿也交给你了&lt;/h2&gt;

&lt;p&gt;讲 Agent 的文章大多从 ReAct 开始，这本书却先讲了一个更琐碎、也更真实的问题：本地部署的推理模型，输出里会带思维链。&lt;/p&gt;

&lt;p&gt;书里在讲结构化输出时，给的解法非常朴素：取规范化输出内容的&quot;### Response&quot;作为最终模型的答复内容，代码就一行——&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;font-family:Consolas,monospace;font-size:13px;&quot;&gt;print(response[0].split(&quot;### Response:&quot;)[1])&lt;/p&gt;

&lt;p&gt;截图里可以看到，模型吐出来的原始内容是先一段 &lt;code&gt;&amp;lt;think&amp;gt;&lt;/code&gt;（里面在自我盘算&quot;用户说你好，久不见，看起来是想打招呼……我应该友好地回应，表达开心并询问情况&quot;），然后才是 &lt;code&gt;&amp;lt;/think&amp;gt;&lt;/code&gt; 和真正的答复。&lt;/p&gt;

&lt;p&gt;这个细节看起来微不足道，但它是&quot;本地部署&quot;和&quot;调 API&quot;之间最容易被忽略的差别之一。云端 API 通常已经帮你把推理过程剥掉了，你拿到的就是干净答案；本地跑开源模型，你拿到的是&lt;strong&gt;模型的全部工作过程&lt;/strong&gt;，包括它的犹豫、自我提醒、格式草稿。&lt;/p&gt;

&lt;p&gt;如果你不切，下游会发生什么？&lt;/p&gt;

&lt;p&gt;假设你在做一个客服 Agent，模型先想&quot;这个用户好像在生气，我应该先安抚&quot;，然后把这段思考一起输出给用户。用户看到的是一句&quot;这个用户好像在生气&quot;——对话直接崩掉。&lt;/p&gt;

&lt;p&gt;再假设你在做结构化抽取，让模型输出 JSON。它先在 think 里写&quot;我需要抽取姓名、电话、金额&quot;，然后输出 JSON。&lt;strong&gt;你的解析器在第一个花括号处就崩了&lt;/strong&gt;，因为它先遇到了中文。&lt;/p&gt;

&lt;p&gt;所以那行 &lt;code&gt;split&lt;/code&gt; 不是权宜之计，它是&lt;em&gt;协议边界&lt;/em&gt;。它的意思是：模型的思考过程和模型的输出，是两个东西，中间必须有一条明确的分界线。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;二、schema 就是契约&lt;/h2&gt;

&lt;p&gt;顺着这条线，书里第 7 章讲 LCEL 时给了一个我认为全书最有工程味的设计。&lt;/p&gt;

&lt;p&gt;它说，在 LCEL 中所有组件都实现了 Runnable 接口，在这个过程中，Runnable 会&lt;strong&gt;动态生成输入的描述&lt;/strong&gt;，并将其传入 Pydantic 模型。我们可以调用 &lt;code&gt;schema()&lt;/code&gt; 来获取 JSON Schema。书里打印出来是这样：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;font-family:Consolas,monospace;font-size:13px;&quot;&gt;{&#039;properties&#039;: {&#039;topic&#039;: {&#039;title&#039;: &#039;Topic&#039;, &#039;type&#039;: &#039;string&#039;}},&lt;br&gt;&#039;required&#039;: [&#039;topic&#039;],&lt;br&gt;&#039;title&#039;: &#039;PromptInput&#039;,&lt;br&gt;&#039;type&#039;: &#039;object&#039;}&lt;/p&gt;

&lt;p&gt;然后是那句关键的总结：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;通过这样的强检验机制，可以确保输入的数据格式正确，尽早发现错误。&lt;/p&gt;

&lt;p&gt;&quot;尽早&quot;两个字是重点。&lt;/p&gt;

&lt;p&gt;Agent 系统最难受的故障，不是它报错，而是它&lt;em&gt;不报错&lt;/em&gt;。你把一个字段名拼错了，链路照样跑通，模型照样生成，最后给你一段读起来通顺、但基于错误输入的回答。你看到结果不对，回头查，发现错误发生在第三步，而你已经跑了两百次。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;schema 的作用是把这类错误从&quot;结果层&quot;提前到&quot;入口层&quot;。&lt;/strong&gt;字段少了、类型错了、必填缺失，在进门那一刻就被拦住，而不是等到模型编出一个答案之后你才发现。&lt;/p&gt;

&lt;p&gt;我读这一段的时候想到一个类比：schema 之于 Agent，相当于类型系统之于编程语言。写 Python 不写类型也能跑，但项目一大就会出问题；写 TypeScript 会多花时间，但那些时间是从调试里省出来的。&lt;strong&gt;Agent 现在的阶段，大致相当于早期的 JavaScript——什么都能塞，什么都可能错。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;所以这本书的价值不在于教你&quot;怎么让 Agent 更聪明&quot;，而在于教你&quot;怎么让它不那么容易错&quot;。这两个方向的工程量差一个量级。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;三、从链到图：AgentExecutor 为什么让位&lt;/h2&gt;

&lt;p&gt;书里对 LangChain 和 LangGraph 的区别，有一段话说得比大多数资料都清楚：&lt;/p&gt;

&lt;p style=&quot;border-left:3px solid #C9C3B8;background:#F7F6F3;padding:14px 18px;margin:18px 0;color:#4A453D;line-height:1.9;&quot;&gt;LangGraph 在&quot;图&quot;这一概念上进行了重点强化，旨在解决线性序列带来的局限性，而实现这一目标的核心方式是引入循环图结构。在 LangGraph 框架中，图取代了 LangChain 中的 AgentExecutor（Agent 执行器），用于管理 Agent 的生命周期，并通过状态中的暂存器跟踪消息，从而支持以循环方式协调多个链或参与者之间的计算步骤。这与 LangChain 将 Agent 视为可附加工具并插入特定提示的设计理念有所不同。&lt;/p&gt;

&lt;p&gt;这段话里有三个信息量很大的点，值得拆开。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第一，&quot;线性序列带来的局限性&quot;。&lt;/strong&gt;早期 LangChain 的心智模型是链（Chain）：A 的输出喂给 B，B 的输出喂给 C。这个模型很直观，也很好教。但它有一个硬伤——&lt;em&gt;不能回头&lt;/em&gt;。&lt;/p&gt;

&lt;p&gt;而 Agent 的本质恰恰是回头。它要先想、再调工具、看结果、发现不对、重新想。这是一个环，不是一条线。&lt;strong&gt;用链的模型去表达环的行为，只能靠套娃式的 hack，越写越乱。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第二，&quot;图取代了 AgentExecutor&quot;。&lt;/strong&gt;这是个架构级的替换，不只是换个名字。AgentExecutor 是黑盒：你把模型、工具、提示词塞进去，它自己在里面转，你不知道它转到第几圈、为什么停。状态图是白盒：节点是你定义的，边是你定义的，状态是你定义的，每一步都能停下来看。&lt;/p&gt;

&lt;p&gt;对调试来说，这个差别是决定性的。&lt;strong&gt;黑盒的问题不是它不好用，是它出错时你无从下手。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第三，&quot;通过状态中的暂存器跟踪消息&quot;。&lt;/strong&gt;这句话点出了状态图的实现核心：所有东西都挂在状态上。消息、中间结果、工具返回、错误信息，全部是状态的一部分。这样一来，&quot;循环&quot;就变得自然了——回到上一个节点，状态还在，接着算就行。&lt;/p&gt;

&lt;p&gt;我觉得这段的价值在于，它把一个看起来像&quot;框架营销&quot;的问题，还原成了一个具体的技术问题：&lt;strong&gt;你要不要能回头？&lt;/strong&gt;要，就必须有状态；有状态，就必须有图。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;四、微调改的是嘴，RAG 改的是脑&lt;/h2&gt;

&lt;p&gt;第 4、5 章讲 RAG，第 6 章讲微调。这三章放在一起，恰好构成一个对照，而这个对照是很多人搞混的地方。&lt;/p&gt;

&lt;p&gt;书里讲微调的必要性时说得很清楚：预训练模型&quot;通常具备通用性，尚未针对特定任务或领域进行优化和调整&quot;，微调是在预训练模型的基础上，通过少量训练数据和有限的计算资源，对模型进行特定任务的优化。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;关键词是&quot;特定任务&quot;，不是&quot;特定知识&quot;。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;这个区别必须掰开：&lt;/p&gt;

&lt;p&gt;你要它知道你们公司 2025 年的报销标准 → 这是&lt;em&gt;知识&lt;/em&gt;，用 RAG。把制度文档切块、建索引、检索进上下文。&lt;/p&gt;

&lt;p&gt;你要它输出时永远先给结论再给依据、永远用敬语、永远不带感叹号 → 这是&lt;em&gt;行为&lt;/em&gt;，用微调。准备几百条符合要求的样本，训一遍。&lt;/p&gt;

&lt;p&gt;把这两件事搞反，是最常见的浪费。用微调灌知识，你会发现它记住了一些、忘了更多、还会把不同条款混在一起编；用 RAG 改文风，你会发现每次都要在提示词里写一大段要求，还经常不听话。&lt;/p&gt;

&lt;p&gt;书里还有一个现实提醒：微调要谈硬件。显存多大、能不能跑 LoRA、多久能训完——这些是硬约束。一台消费级显卡能做的微调，和能做的推理，是两件完全不同规模的事。&lt;/p&gt;

&lt;p&gt;至于 RAG 那两章（第 4、5 章），走的是标准路线：文档加载、切块、嵌入、向量库、检索、生成。书里给的例子是本地知识库问答，一路有代码。扎实，但没有太多超出常规的东西——这部分内容现在网上已经很多了。&lt;/p&gt;

&lt;h2 style=&quot;font-size:21px;border-left:4px solid #3A4A5C;padding-left:12px;margin:34px 0 16px;&quot;&gt;五、它的短板&lt;/h2&gt;

&lt;p&gt;说实话，这本书的问题和它的优点来自同一个地方：它太&quot;实&quot;了。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第一，它会很快过期。&lt;/strong&gt;599 屏里大量是命令行输出、界面截图、API 参数、模型版本号。这类内容在 2024 年写下来是对的，但模型版本三个月一换、框架 API 半年一改，读者照着敲很可能第一步就卡住。&lt;strong&gt;一本以命令行截图为骨架的书，保质期天然很短。&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第二，深度被广度摊薄了。&lt;/strong&gt;八章要覆盖部署、RAG、微调、Agent、企业级五个大主题，每章平均七十来屏。这意味着每一块都只能&quot;带你跑通&quot;，没法&quot;带你吃透&quot;。比如微调那一章，讲了为什么微调、怎么准备数据、怎么跑起来，但学习率怎么调、灾难性遗忘怎么防、效果怎么评——这些真正决定成败的部分，基本没有展开。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第三，企业级那一章名不副实。&lt;/strong&gt;第 8 章标题叫&quot;企业级 Agent 开发实战&quot;，但内容更接近&quot;把前面的东西串起来做个完整例子&quot;。真正的企业级难题——多租户隔离、权限、审计日志、灰度发布、故障回滚、成本核算——几乎没有涉及。而这些恰恰是从&quot;能演示&quot;到&quot;能上线&quot;之间最厚的一堵墙。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;第四，缺一张选型地图。&lt;/strong&gt;书里介绍了不少框架（LangChain、LangGraph、LlamaIndex、GraphRAG、Dify 之类），但很少给出&quot;什么场景该选哪个&quot;的判断。读者读完之后知道有哪些工具，还是不知道该用哪个。&lt;/p&gt;

&lt;p&gt;还有一点不算缺点，但需要提醒：这本书默认你有一台能跑模型的机器，或者至少愿意为 API 付费。它对&quot;完全没有工程背景、只想试试看&quot;的读者并不友好——第一章之后的门槛就上来了。&lt;/p&gt;

&lt;p&gt;但如果目标是&quot;我真的要做一个能用的东西&quot;，这些短板是可以接受的。因为市面上缺的从来不是&quot;讲清楚 Agent 是什么&quot;的书，而是&quot;把每一步的命令都写出来、让你能跑通一次&quot;的书。&lt;strong&gt;跑通一次之后，你才有资格谈判断。&lt;/strong&gt;&lt;/p&gt;

&lt;figure style=&quot;margin:34px 0 30px;text-align:center;&quot;&gt;
  &lt;img src=&quot;https://www.jiangtian.top/zb_users/upload/kg/agent-dev-practice.png&quot; alt=&quot;大模型Agent开发实践 核心知识图谱&quot; style=&quot;max-width:100%;border-radius:10px;box-shadow:0 6px 24px rgba(0,0,0,.09);&quot;&gt;
  &lt;figcaption style=&quot;font-size:12px;color:#8A857C;margin-top:12px;&quot;&gt;核心知识图谱：三段地基 → 结构化输出 → 从链到图 → 企业级现实&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;一句话总结：&lt;strong&gt;Agent 的能力上限不取决于模型有多聪明，取决于你给它定的契约有多严——schema 定得住，它才敢放出去跑。&lt;/strong&gt;&lt;/p&gt;

&lt;hr style=&quot;border:none;border-top:1px solid #E3E0D9;margin:36px 0 18px;&quot;&gt;
&lt;p style=&quot;font-size:12px;color:#97938B;line-height:1.9;&quot;&gt;阅读记录：《大模型Agent开发实践》，陈志鹏著，微信读书逐页翻阅 &lt;strong&gt;599 屏&lt;/strong&gt;，八章读完，读至第 8 章企业级 Agent 开发实战。2026-11-03。&lt;/p&gt;
</description><pubDate>Tue, 03 Nov 2026 16:43:53 +0800</pubDate></item></channel></rss>