1
00:00:00,100 --> 00:00:06,432
本内容改编自小山学堂《学 AI 产品，从入门到精通》，为二次演绎配音版。

2
00:00:06,382 --> 00:00:10,036
这一集讲三件事，一件比一件落地。

3
00:00:10,036 --> 00:00:19,242
第一件是个现象，有些能力在模型小的时候接近零分，参数量跨过某个量级之后，短时间内就有了，这叫涌现。

4
00:00:19,242 --> 00:00:25,793
第二件是个矛盾，既然越大越强，为什么整个行业还在拼命把模型做小。

5
00:00:25,793 --> 00:00:31,262
第三件是解法，蒸馏，让大模型去教小模型，具体怎么做。

6
00:00:31,262 --> 00:00:35,360
先把这个矛盾摆出来，因为它才是这一集的主线。

7
00:00:35,360 --> 00:00:41,598
上一件说明规模能换来能力，可现实是，能力不是唯一的约束条件。

8
00:00:41,598 --> 00:00:49,399
成本、延迟、数据能不能出门，这三件事会在真实项目里直接把旗舰模型挡在门外。

9
00:00:49,399 --> 00:00:55,036
所以行业一边往上堆规模，一边往下压尺寸，两条路同时跑。

10
00:00:55,036 --> 00:01:00,432
最后的落点很实际，蒸馏省的是钱和时间，它不创造新能力。

11
00:01:00,432 --> 00:01:03,750
这句话是理解整件事的关键。

12
00:01:03,890 --> 00:01:09,368
模型越大越强，这句话听起来很自然，真实情况要复杂一点。

13
00:01:09,318 --> 00:01:15,304
把参数量放在横轴，某项任务的成绩放在纵轴，会看到两种走势。

14
00:01:15,304 --> 00:01:20,172
一种随规模稳步抬升，每加一倍参数就多拿一点分。

15
00:01:20,172 --> 00:01:25,881
另一种在很长一段区间里贴着地面，然后在某个位置突然抬头。

16
00:01:25,881 --> 00:01:28,165
麻烦的地方在左半段。

17
00:01:28,165 --> 00:01:33,369
跳升发生之前，这条曲线和这条路走不通看起来一模一样。

18
00:01:33,369 --> 00:01:41,506
手里只有前半段数据的时候，你没有办法外推出后面会不会抬头，也没有办法预测抬头的位置。

19
00:01:41,506 --> 00:01:47,131
目前也没有一套理论能提前算出某项能力会在哪个规模出现。

20
00:01:47,131 --> 00:01:51,145
这件事读起来平淡，但它的工程含义很重。

21
00:01:51,145 --> 00:01:57,936
你在小模型上试了很久没成，不代表这条路不通，可能只是还没到那个位置。

22
00:01:57,936 --> 00:02:04,427
反过来，你在小模型上看到一点苗头，也不能推断再大一点就一定行。

23
00:02:04,427 --> 00:02:10,652
曲线的前半段不携带关于后半段的信息，这是这件事最麻烦的地方。

24
00:02:10,800 --> 00:02:23,959
下面这些能力都在公开研究和行业讨论里被当作涌现的例子，括号里的规模只是量级参考，换架构、换批训练数据、换种评测方式，位置就会明显偏移。

25
00:02:23,909 --> 00:02:25,663
多步数学推理。

26
00:02:25,663 --> 00:02:34,498
单步算术小模型也能做对一部分，但要求它连着推好几步再给答案，小模型的正确率长期贴着零。

27
00:02:34,498 --> 00:02:36,288
约一百亿量级。

28
00:02:36,288 --> 00:02:37,815
多语言迁移。

29
00:02:37,815 --> 00:02:43,620
在英文语料上学会的推理方式，能用到训练里出现得很少的语种上。

30
00:02:43,620 --> 00:02:47,106
规模不够的时候，换个语种成绩就崩。

31
00:02:47,106 --> 00:02:48,921
约七十亿量级。

32
00:02:48,921 --> 00:02:51,553
结构化输出与工具调用。

33
00:02:51,553 --> 00:02:56,661
稳定吐出合法 JSON，按函数签名填对参数类型。

34
00:02:56,661 --> 00:03:01,745
这项能力没有被专门设计进去，是训练完之后发现它有的。

35
00:03:01,745 --> 00:03:03,560
约七十亿量级。

36
00:03:03,560 --> 00:03:05,075
思维链推理。

37
00:03:05,075 --> 00:03:08,428
让模型先写出推理过程再给答案。

38
00:03:08,428 --> 00:03:13,716
这招在小模型上拿不到收益，有时还会把原本能答对的题带偏。

39
00:03:13,716 --> 00:03:15,435
约一千亿量级。

40
00:03:15,435 --> 00:03:16,781
理论心智。

41
00:03:16,781 --> 00:03:21,469
判断对话里的另一个人掌握了哪些信息、会怎么想。

42
00:03:21,469 --> 00:03:28,079
这一项争议最大，有研究把测试题改写几个字，能力就消失了，目前还在争议中。

43
00:03:28,079 --> 00:03:30,279
长对话角色一致性。

44
00:03:30,279 --> 00:03:37,803
几十轮之后仍然守住设定好的身份、语气和边界，中途不跑偏，也不被用户几句话带走。

45
00:03:37,803 --> 00:03:39,966
约一百三十亿量级。

46
00:03:39,966 --> 00:03:45,375
注意这些数字的使用方式，它们是量级参考，不是精确阈值。

47
00:03:45,375 --> 00:03:50,111
行业内没有统一的权威数字，别拿去做容量规划。

48
00:03:50,260 --> 00:03:56,472
这件事在学术上还没有定论，而这一节可能是整集最有实用价值的部分。

49
00:03:56,422 --> 00:04:01,734
有一派研究认为，相当一部分涌现是评测指标造出来的假象。

50
00:04:01,734 --> 00:04:08,585
换一种打分方式，同一批模型在同一批题目上画出来的曲线会变成平滑上升。

51
00:04:08,585 --> 00:04:10,376
论证是这样的。

52
00:04:10,376 --> 00:04:16,554
多步数学题通常按答案完全正确判分，中间错一步，整题算零。

53
00:04:16,554 --> 00:04:22,587
这种打分方式是离散的，它把模型的连续进步压成了一个二值结果。

54
00:04:22,587 --> 00:04:27,660
模型从错得离谱进步到只差最后一点，分数照样是零。

55
00:04:27,660 --> 00:04:32,239
等它跨过最后那点门槛，分数才一次性从零跳起来。

56
00:04:32,239 --> 00:04:41,241
把判分换成连续指标，比如逐个词看正确答案的对数概率，同一组实验的曲线就变成一条平滑上升的线。

57
00:04:41,241 --> 00:04:46,878
跳变消失了，说明跳变来自尺子，模型本身一直在稳步变好。

58
00:04:46,878 --> 00:04:49,955
这个反驳没有把现象整个推翻。

59
00:04:49,955 --> 00:04:58,188
它说明的是一件更具体的事，看到一条阶跃曲线时，先确认阶跃来自模型，还是来自你的尺子。

60
00:04:58,188 --> 00:05:02,335
对做产品的人来说，这个提醒比争论本身有用。

61
00:05:02,335 --> 00:05:14,270
你的验收标准如果是一次跑通才算过，那你在自己的数据上大概率也会看到阶跃，而这个阶跃是你的验收口径造出来的，不是模型突然开窍了。

62
00:05:14,430 --> 00:05:16,591
三条，都很具体。

63
00:05:16,541 --> 00:05:20,760
第一，换更大的模型之前，先自己测一遍。

64
00:05:20,760 --> 00:05:26,192
跑分榜测的是通用任务，你的场景可能正好卡在某个阈值附近。

65
00:05:26,192 --> 00:05:30,447
换一档规模也许立刻就通了，也许毫无变化。

66
00:05:30,447 --> 00:05:37,779
花半天做一个二三十条样本的小测试集，用真实数据跑一遍，比读十篇评测有用。

67
00:05:37,779 --> 00:05:42,430
第二，小模型做不到的事，别急着用提示词硬凑。

68
00:05:42,430 --> 00:05:47,082
遇到怎么改提示词都做不对的任务，先换一档规模试试。

69
00:05:47,082 --> 00:05:53,043
如果大一档立刻就对了，那之前那些复杂提示词只是在补规模的缺口。

70
00:05:53,043 --> 00:05:58,656
这类提示词通常又长又脆，换个模型、换个版本就失效。

71
00:05:58,656 --> 00:06:02,563
第三，看到突然会了，也别急着下结论。

72
00:06:02,563 --> 00:06:06,325
上面那个争议在自己的测试里同样成立。

73
00:06:06,325 --> 00:06:12,587
加一个宽松一点的判分口径做交叉验证，比如按步骤给分、按字段给分。

74
00:06:12,587 --> 00:06:16,529
两把尺子都显示跳升，这个结论才站得住。

75
00:06:16,529 --> 00:06:20,712
一句话记住，规模是一个自变量，值得单独测。

76
00:06:20,712 --> 00:06:24,906
它可能给你带来没预期过的能力，也可能什么都不给。

77
00:06:24,906 --> 00:06:33,500
这件事只有在你自己的任务上才能问出答案，别人的曲线和榜单都替代不了你自己的那三十条样本。

78
00:06:33,650 --> 00:06:35,450
换到第二件事。

79
00:06:35,400 --> 00:06:40,809
把模型做小，是被现实逼出来的，跟追求能力上限无关。

80
00:06:40,809 --> 00:06:45,280
第一个理由是成本，而且差的是数量级，不是几成。

81
00:06:45,280 --> 00:06:50,737
参数量小一个量级，一次推理要动用的算力通常也小一个量级。

82
00:06:50,737 --> 00:06:57,672
行业里的常见口径是，小模型的推理成本可以比旗舰模型低一到两个数量级。

83
00:06:57,672 --> 00:07:03,393
具体差多少取决于尺寸、量化档位、批量大小和部署方式。

84
00:07:03,393 --> 00:07:07,925
别记死数字，记住这是量级上的差距，不是打个折。

85
00:07:07,925 --> 00:07:09,848
第二个理由是速度。

86
00:07:09,848 --> 00:07:17,804
调用远端旗舰模型，要走一次网络往返，还要排队，然后逐字生成，等上几秒是常态。

87
00:07:17,804 --> 00:07:27,275
这段延迟里真正属于计算的其实不多，大头在网络往返和排队等待，而这两项恰恰是你本地部署能直接省掉的。

88
00:07:27,275 --> 00:07:32,444
本地跑的小模型省掉了网络这一段，首字出来得快得多。

89
00:07:32,444 --> 00:07:39,187
对话类产品对这一段特别敏感，用户等三秒和等零点三秒，是两种体验。

90
00:07:39,187 --> 00:07:42,600
这个差别不改变能力，但改变留存。

91
00:07:42,600 --> 00:07:45,425
第三个理由是私有化与合规。

92
00:07:45,425 --> 00:07:52,696
病历、卷宗、内部代码、未公开的财务数据，这类内容的合规要求是不出内网。

93
00:07:52,696 --> 00:07:57,768
这时候对面的模型能力再强也用不上，因为第一步就过不去。

94
00:07:57,768 --> 00:08:01,170
本地部署的小模型是唯一一条路。

95
00:08:01,170 --> 00:08:06,398
前面讲权重时说的那个控制权，在这里变成了硬约束。

96
00:08:06,550 --> 00:08:12,822
小到什么程度才算小，判断标准很具体，能不能塞进手上这块显卡。

97
00:08:12,772 --> 00:08:16,714
公式是显存约等于参数量乘精度系数。

98
00:08:16,714 --> 00:08:21,834
十六位浮点取二点六，四比特整数量化取零点六五。

99
00:08:21,834 --> 00:08:26,005
系数里已经含了运行时开销，不要在外面再乘一次。

100
00:08:26,005 --> 00:08:28,745
按这个口径算几个尺寸。

101
00:08:28,745 --> 00:08:36,101
六亿参数，十六位浮点一点六 GB，四比特量化零点四 GB，轻松，端侧设备也带得动。

102
00:08:36,101 --> 00:08:43,697
八十亿参数，十六位浮点二十点八 GB，四比特量化五点二 GB，很宽裕，八 GB 卡也能跑。

103
00:08:43,697 --> 00:08:51,954
三百二十亿参数，十六位浮点八十三点二 GB，四比特量化二十点八 GB，勉强，上下文一长就会溢出。

104
00:08:51,954 --> 00:09:02,363
两千三百五十亿参数的混合专家型号，十六位浮点六百一十一 GB，四比特量化一百五十二点八 GB，跑不动，不是量化能解决的。

105
00:09:02,363 --> 00:09:10,656
注意混合专家模型的显存按总参数量算，激活参数量只影响速度，这一点特别容易算错。

106
00:09:10,656 --> 00:09:19,755
很多人看到激活参数只有总参数的一小部分，就按激活参数去估显存，结果下单的显卡根本装不下。

107
00:09:19,755 --> 00:09:27,135
另外判定时留了约百分之十五余量，所以二十点八 GB 在二十四 GB 卡上算勉强，不算可以。

108
00:09:27,135 --> 00:09:34,238
这个余量不是保守，是因为实际运行中上下文一长，KV Cache 那块开销还会往上走。

109
00:09:34,238 --> 00:09:43,216
结论很直白，八 B 这个尺寸量化之后，一块几年前的游戏显卡就跑得动；旗舰尺寸不管怎么量化都进不去。

110
00:09:43,216 --> 00:09:48,397
于是问题变成了另一个，小尺寸的能力能不能补上来。

111
00:09:48,550 --> 00:09:50,735
第三件事，蒸馏。

112
00:09:50,685 --> 00:10:01,599
补能力有两条路，一条是让小模型自己从头学，数据、算力、试错全部重来一遍；另一条是找一个已经学会的大模型来教它。

113
00:10:01,599 --> 00:10:03,978
后一条就是知识蒸馏。

114
00:10:03,978 --> 00:10:05,349
流程五步。

115
00:10:05,349 --> 00:10:14,591
第一，准备问题集，收集覆盖目标领域的问题，这一步决定了学生能力的上限，没被问到的领域学生就学不到。

116
00:10:14,591 --> 00:10:18,762
第二，教师模型作答，保留完整推理过程。

117
00:10:18,762 --> 00:10:28,017
关键在完整两个字，只保留最终答案，学生学到的是背结论；保留中间的推理链条，学生才有机会学到怎么想。

118
00:10:28,017 --> 00:10:31,935
第三，取出概率分布而不只是最终答案。

119
00:10:31,935 --> 00:10:38,425
第四，用这批材料训练学生，目标是让自己的输出分布尽量贴近老师的。

120
00:10:38,425 --> 00:10:42,260
第五，评估并迭代，通常要来回好几轮。

121
00:10:42,260 --> 00:10:45,325
第三步为什么重要，看个例子。

122
00:10:45,325 --> 00:10:48,906
假设一道图片分类题，正确答案是猫。

123
00:10:48,906 --> 00:10:54,940
传统训练的做法是告诉模型，猫对，其他全错，狗和兔一样错。

124
00:10:54,940 --> 00:10:59,832
可狗跟猫比较像，兔子差得远，这层信息完全丢失了。

125
00:10:59,832 --> 00:11:07,692
蒸馏的做法是把老师的判断原样交给学生，猫百分之七十二，狗百分之二十，兔百分之八。

126
00:11:07,692 --> 00:11:13,125
学生除了知道答案是猫，还知道了老师眼中这三者的远近关系。

127
00:11:13,125 --> 00:11:19,1000
一句话概括，硬标签只告诉学生答案，软标签还告诉学生老师是怎么权衡的。

128
00:11:19,1000 --> 00:11:26,851
同样一条数据，携带的信息量大得多，这就是蒸馏比从零训练省钱的根本原因。

129
00:11:26,851 --> 00:11:29,844
还有个操作技巧叫温度系数。

130
00:11:29,844 --> 00:11:39,062
老师如果太自信，概率分布会非常尖锐，比如百分之九十八、百分之一、百分之一，这跟硬标签就没多大区别了。

131
00:11:39,062 --> 00:11:47,248
做法是在计算概率时除以一个数，这个数越大分布越平缓，词与词之间的相对关系就越明显。

132
00:11:47,248 --> 00:11:56,154
这跟采样时的温度是同一个机制，只是用途不同，那里是为了让输出多样，这里是为了让信息更充分地传给学生。

133
00:11:56,154 --> 00:11:58,882
看一个公开的例子落地一下。

134
00:11:58,882 --> 00:12:08,834
二零二五年一月，深度求索发布 R1 的时候，同时开源了六个蒸馏版模型，从十五亿一直到七百亿，覆盖多个尺寸。

135
00:12:08,834 --> 00:12:16,695
这个清单里有一处值得留意的细节，学生模型的底座不是自家的，是从别人开源的模型里挑的。

136
00:12:16,695 --> 00:12:20,913
六个里四个选了千问二点五，两个选了拉玛三。

137
00:12:20,913 --> 00:12:23,726
为什么这么挑，官方没有解释。

138
00:12:23,726 --> 00:12:26,070
但可以反推出几个条件。

139
00:12:26,070 --> 00:12:39,724
底座必须权重开放且许可允许再训练，否则做出来不能发布；尺寸谱系要足够全，才能一次覆盖多个档位；社区工具链要成熟，训练和部署才不用重造轮子。

140
00:12:39,724 --> 00:12:43,305
这三条同时满足的选项当时并不多。

141
00:12:43,305 --> 00:12:55,505
为什么这件事值得单独讲，因为厂商自己说的开源程度可以有水分，但另一家公司愿意把自己的旗舰成果建在你的底座上，是拿真金白银的算力投的票。

142
00:12:55,505 --> 00:12:59,111
看第三方的选择，比看官方介绍可靠。

143
00:12:59,111 --> 00:13:01,514
效果方面要留个心眼。

144
00:13:01,514 --> 00:13:11,863
官方公布的评测里，三百二十亿的蒸馏版在数学和代码几项基准上超过了某个闭源小模型，官方称达到同期最好成绩。

145
00:13:11,863 --> 00:13:17,873
但社区在自己的测试集上复现时，结果并不总和官方数字一致。

146
00:13:17,873 --> 00:13:25,120
这不一定是谁造假，更常见的原因是评测集选择、提示词写法和采样参数的差异。

147
00:13:25,120 --> 00:13:32,452
结论还是老规矩，官方跑分只能当参考，真正要用之前，拿自己的任务测一遍。

148
00:13:32,590 --> 00:13:34,583
最后收几条原则。

149
00:13:34,533 --> 00:13:38,223
第一，规模是一个自变量，值得单独测。

150
00:13:38,223 --> 00:13:44,869
换模型之前花半天做一个二三十条样本的小测试集，比读十篇评测有用。

151
00:13:44,869 --> 00:13:49,653
你的场景可能正好卡在某个阈值附近，也可能完全不在。

152
00:13:49,653 --> 00:13:53,102
第二，看到阶跃先怀疑自己的尺子。

153
00:13:53,102 --> 00:14:02,381
如果你的验收标准是一次跑通才算过，那你在自己的数据上大概率也会看到阶跃，而这个阶跃是口径造出来的。

154
00:14:02,381 --> 00:14:07,682
加一个宽松的判分口径做交叉验证，两把尺子都跳才算数。

155
00:14:07,682 --> 00:14:11,264
第三，别用提示词硬补规模缺口。

156
00:14:11,264 --> 00:14:15,915
遇到怎么改提示词都做不对的任务，先换一档规模试试。

157
00:14:15,915 --> 00:14:23,235
大一档立刻就对了，说明之前那些复杂提示词只是在补缺口，它们通常又长又脆。

158
00:14:23,235 --> 00:14:30,843
第四，算显存用参数量乘精度系数，系数里已经含了运行时开销，别在外面再乘一次。

159
00:14:30,843 --> 00:14:36,444
混合专家模型按总参数量算，激活参数量只影响速度。

160
00:14:36,444 --> 00:14:39,292
另外记得留百分之十五余量。

161
00:14:39,292 --> 00:14:43,872
第五，蒸馏省的是钱和时间，它不创造新能力。

162
00:14:43,872 --> 00:14:54,917
小模型在长链条推理、多步规划、跨大量上下文做取舍这类任务上仍然显著弱于旗舰，这个差距不会因为换个更强的老师就消失。

163
00:14:54,917 --> 00:15:03,391
做选型时别指望一个小模型接管所有场景，先把任务拆开，看清楚哪些环节真的用得上小模型。

164
00:15:03,391 --> 00:15:16,456
还有一个容易忽略的前提，蒸馏的问题集决定了学生能力的上限，没被问到的领域学生就学不到，所以做蒸馏之前先把覆盖面想清楚，这比调训练参数重要。

165
00:15:16,456 --> 00:15:21,179
最后一条是代价，学生会把老师的毛病一起学过去。

166
00:15:21,179 --> 00:15:27,982
老师的偏见、知识盲区、表达习惯，学生都会继承，而且自己分辨不出来。

167
00:15:27,982 --> 00:15:34,208
当大量小模型都从同一批老师那里学，整个生态会朝同一个方向漂。

168
00:15:34,208 --> 00:15:37,970
选底座的时候，把这件事纳入考虑。