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

2
00:00:06,382 --> 00:00:07,908
这一集聊钱。

3
00:00:07,908 --> 00:00:14,170
不是聊报价，是聊那些你以为很便宜、上线之后才发现账单对不上的地方。

4
00:00:14,170 --> 00:00:22,331
很多人工智能产品的成本失控，都不是发生在模型选型那一刻，而是发生在日复一日的调用里。

5
00:00:22,331 --> 00:00:33,834
一张图多传了几十个像素，一个智能体多转了几圈，一段提示词里多写了几个星号，单次看都是零头，乘上百万次调用就是一整块预算。

6
00:00:33,834 --> 00:00:36,165
为什么产品经理要关心。

7
00:00:36,165 --> 00:00:41,250
因为降本这件事，一半是工程决策，另一半是产品决策。

8
00:00:41,250 --> 00:00:49,218
分辨率给多少、任务拆几步、失败要不要重试，这些决定只有产品能做，工程师拿不到这个权限。

9
00:00:49,218 --> 00:00:51,021
这一集分三段。

10
00:00:51,021 --> 00:00:56,670
第一段讲图片的词元怎么算，以及三十二像素对齐这个跳档陷阱。

11
00:00:56,670 --> 00:01:01,586
第二段讲智能体为什么是输入主导，以及四个成本陷阱。

12
00:01:01,586 --> 00:01:04,375
第三段讲提示词里的词法税。

13
00:01:04,375 --> 00:01:07,307
每段都给可直接落地的红线。

14
00:01:07,307 --> 00:01:08,882
先说个前提。

15
00:01:08,882 --> 00:01:13,990
这一集不讨论怎么跟供应商谈价，也不讨论该选哪个模型。

16
00:01:13,990 --> 00:01:16,658
那些是采购和选型的问题。

17
00:01:16,658 --> 00:01:26,562
这一集只盯一件事，同样的模型、同样的任务，为什么你的账单比别人厚，以及那些多出来的钱具体花在了哪里。

18
00:01:26,716 --> 00:01:28,156
先说图片。

19
00:01:28,106 --> 00:01:32,841
文字那边的做法是合并字符，图片这边是切割像素。

20
00:01:32,841 --> 00:01:38,587
视觉模型把图片切成固定大小的像素块，每块对应一个词元。

21
00:01:38,587 --> 00:01:48,466
以通义千问的视觉模型为例，核心公式就一句话，图像词元等于缩放后的高乘宽，除以每个词元对应的像素数，再加二。

22
00:01:48,466 --> 00:01:51,976
这个二是视觉起止标记的固定开销。

23
00:01:51,976 --> 00:01:54,176
关键在缩放这两个字。

24
00:01:54,176 --> 00:01:58,875
你以为传的是原图，其实模型按缩放对齐后的分辨率计费。

25
00:01:58,875 --> 00:02:04,392
高和宽会被强制对齐到三十二的整数倍，有的模型是二十八。

26
00:02:04,392 --> 00:02:06,760
这就埋了一个跳档陷阱。

27
00:02:06,760 --> 00:02:22,316
一千乘一千的图，和一千零二十五乘一千零二十五的图，后者只大了百分之二点五，但它跨过了一千零二十四这个三十二的整数倍边界，对齐之后直接跳到一千零五十六，词元数跳了百分之六点五。

28
00:02:22,316 --> 00:02:28,663
这和文字那边三万二的全量结算是同一个逻辑，都是跨过阈值之后的断崖。

29
00:02:28,663 --> 00:02:31,740
每个词元对应的像素数也值得记。

30
00:02:31,740 --> 00:02:43,578
通义千问较新的视觉模型是三十二乘三十二，也就是一千零二十四个像素一个词元；更早的版本是二十八乘二十八，七百八十四个像素一个词元。

31
00:02:43,578 --> 00:02:48,566
更大的像素块等于更高的压缩效率，等于更少的词元。

32
00:02:48,566 --> 00:02:55,730
类比一下，文字那边是词表大小决定压缩率，图片这边是像素块大小决定压缩率。

33
00:02:55,730 --> 00:02:58,278
也有不走切割这条路线的。

34
00:02:58,278 --> 00:03:08,518
两个主流闭源模型用的是图块机制，五百一十二见方的图块约一百七十个词元，七百六十八见方的图块约二百五十八个词元。

35
00:03:08,518 --> 00:03:12,917
算法不一样，但结论一样，尺寸决定账单。

36
00:03:13,060 --> 00:03:17,757
那么传四开图是不是比一千零八十的效果更好。

37
00:03:17,707 --> 00:03:20,171
不一定，而且大概率不值。

38
00:03:20,171 --> 00:03:21,818
看一组数字。

39
00:03:21,818 --> 00:03:26,181
五百一十二见方，二百五十八个词元，算一倍成本。

40
00:03:26,181 --> 00:03:30,351
一千零八十，两千零四十二个词元，七点九倍。

41
00:03:30,351 --> 00:03:34,173
二开，三千六百零二个词元，十四倍。

42
00:03:34,173 --> 00:03:38,645
四开，八千一百六十二个词元，三十一点六倍。

43
00:03:38,645 --> 00:03:44,582
八开会触发缩放上限，大约一万六千三百八十四个词元，六十多倍。

44
00:03:44,582 --> 00:03:51,806
从五百一十二到一千零八十，词元涨八倍，识别精度有明显提升，这笔钱花得值。

45
00:03:51,806 --> 00:03:57,431
从二开到四开，词元再涨一倍多，精度提升可能肉眼不可见。

46
00:03:57,431 --> 00:04:07,010
你以为在为更清晰付费，实际上在为更多像素块付费，而这些多出来的像素块，对模型理解内容的帮助是递减的。

47
00:04:07,010 --> 00:04:12,310
研究表明，视觉语言模型的视觉词元冗余高达百分之八十五。

48
00:04:12,310 --> 00:04:14,330
多图场景更危险。

49
00:04:14,330 --> 00:04:20,039
五张四开图大约四万个词元，直接把你从标准档踢进高价档。

50
00:04:20,039 --> 00:04:24,570
这和检索增强里五个文档拼到三万三是同一个坑。

51
00:04:24,570 --> 00:04:27,779
策略是按任务分级匹配分辨率。

52
00:04:27,779 --> 00:04:34,474
粗粒度分类，比如判断这是猫还是狗，词元预算三百以内，五百一十二见方就够。

53
00:04:34,474 --> 00:04:40,135
场景理解，判断图里在干什么，一千以内，大约一千乘一千。

54
00:04:40,135 --> 00:04:44,750
文字识别和图表分析，四千以内，大约两千见方。

55
00:04:44,750 --> 00:04:51,902
高精度检测比如医疗影像，一万六以内，才需要四开以上，并且要按需开启高清开关。

56
00:04:51,902 --> 00:04:53,921
落地动作有三个。

57
00:04:53,921 --> 00:04:58,717
前端预压缩，上传前先把图片压到目标词元数以内。

58
00:04:58,717 --> 00:05:01,625
任务分级，别拿四开去做分类。

59
00:05:01,625 --> 00:05:06,481
多图预算池，批量图片累计词元接近三万二就截断。

60
00:05:06,481 --> 00:05:13,741
顺带说一句，前端预压缩不只是省词元，它同时省了上传带宽和用户等待时间。

61
00:05:13,741 --> 00:05:19,065
同一件事，三个角色都受益，这种改动最该优先做。

62
00:05:19,204 --> 00:05:22,134
第二段，讲智能体的账单。

63
00:05:22,084 --> 00:05:25,041
普通聊天机器人是一问一答。

64
00:05:25,041 --> 00:05:32,457
你问讲个笑话，输入十个词元，输出一百五十个，输入输出比大约一比十五，输出主导。

65
00:05:32,457 --> 00:05:34,464
智能体完全相反。

66
00:05:34,464 --> 00:05:47,878
它是思考、行动、观察、再思考的循环，而每一轮的输入都包含了全部历史信息，系统提示词、工具返回、历史输出，全都要在每一轮里重新读一遍。

67
00:05:47,878 --> 00:05:56,399
一个代码修复任务跑三轮，总输入一万六千七百九十，总输出二百七十，输入输出比六十二比一。

68
00:05:56,399 --> 00:06:02,229
为了得到二百七十个字的结果，你付了一万六千七百九十个字的阅读费。

69
00:06:02,229 --> 00:06:04,981
课程里有个更直观的例子。

70
00:06:04,981 --> 00:06:15,630
帮我把这个表格里销售额最高的产品找出来，再生成一个图表，就这么一句话，跑了五轮，累计输入三万一千四百六十，输出四百五十。

71
00:06:15,630 --> 00:06:17,553
合计不到三分钱。

72
00:06:17,553 --> 00:06:25,209
看着很便宜，但请注意，这只是一次成功的执行，隐形成本还有失败重试、调试和迭代。

73
00:06:25,209 --> 00:06:27,168
膨胀为什么这么快。

74
00:06:27,168 --> 00:06:35,774
假设任务要若干轮完成，系统提示词长度固定，每轮新增输出加工具返回大概五百个词元。

75
00:06:35,774 --> 00:06:47,553
第 n 轮的输入等于系统提示词加问题，再加前面所有轮次的新增，而总输入是所有轮次的累加，里面藏着一个一加二加三一直加下去的等差数列。

76
00:06:47,553 --> 00:06:51,952
所以轮次翻倍，成本接近翻两番，是平方级的。

77
00:06:51,952 --> 00:06:54,801
不同框架的比例差别很大。

78
00:06:54,801 --> 00:07:02,854
简单的检索型智能体十到二十比一，代码修复类二十到五十比一，开放式任务三十到一百比一。

79
00:07:02,854 --> 00:07:07,373
这也解释了为什么键值缓存对智能体是决定性的。

80
00:07:07,373 --> 00:07:13,503
既然每轮都要重读同样的前缀，能不能命中缓存，就是五倍的价差。

81
00:07:13,503 --> 00:07:17,325
所以要把输入输出比当健康指标盯着。

82
00:07:17,325 --> 00:07:27,024
比率超过五十比一，往往说明智能体在空转，该优化流程或者降级任务了，而不是先想着换更便宜的模型。

83
00:07:27,024 --> 00:07:31,964
还有一句必须说，单次执行看着便宜，规模化才见真章。

84
00:07:31,964 --> 00:07:38,671
零点零二元的任务，乘上失败重试，再乘上百万次调用，就是账单窒息现场。

85
00:07:38,671 --> 00:07:46,808
所以别拿单次成本做决策，要拿单次成本乘失败率乘调用量，那个数才是你真正要管的。

86
00:07:46,948 --> 00:07:50,227
刚才看的还只是一次成功的执行。

87
00:07:50,177 --> 00:07:53,686
真实世界里的账单事故来自四个方向。

88
00:07:53,686 --> 00:07:57,100
陷阱一，工具返回值的信息爆炸。

89
00:07:57,100 --> 00:08:05,405
用户说帮我查一下数据库里所有用户的订单，智能体调查询工具，返回一万条记录，大约五十万词元。

90
00:08:05,405 --> 00:08:12,004
这五十万会被塞进下一轮输入，直接触发高价区，甚至撑爆上下文窗口。

91
00:08:12,004 --> 00:08:17,713
更要命的是，模型还会因为信息过载而迷失，输出质量反而下降。

92
00:08:17,713 --> 00:08:30,718
解法是给所有工具套一层截断保护，上限设两千词元，超了就保留前后各一段、中间标记已截断，同时告诉模型总共有多少条，请缩小查询范围。

93
00:08:30,718 --> 00:08:33,554
保留前后各一段是有讲究的。

94
00:08:33,554 --> 00:08:44,348
前一段让模型知道数据结构长什么样，字段名有哪些；后一段让它知道最新的几条是什么；中间截掉的部分，真需要了再要一次。

95
00:08:44,348 --> 00:08:50,742
全部截掉只留一句太长，模型会瞎猜；只截尾巴，它又看不到结构。

96
00:08:50,742 --> 00:08:54,047
陷阱二，思考词元的隐形账单。

97
00:08:54,047 --> 00:09:02,941
带思考模式的模型会生成思考过程，用户可能根本看不到，但全部按输出计费，而且单价还翻四倍。

98
00:09:02,941 --> 00:09:12,653
同一个任务开启思考模式后，可见输出不变，还是四百五十个词元，思考过程加两千个，输出费用暴涨百分之两千以上。

99
00:09:12,653 --> 00:09:15,117
所以要按任务分级开关。

100
00:09:15,117 --> 00:09:20,489
简单检索关掉，数据清洗关掉，因为规则明确，不需要想。

101
00:09:20,489 --> 00:09:24,011
复杂推理开启，值得为准确率付费。

102
00:09:24,011 --> 00:09:28,747
代码生成视情况，简单函数关掉，复杂架构开启。

103
00:09:28,747 --> 00:09:39,492
进阶做法是用六亿参数级别的极小模型做前置分诊，先花几厘钱判断这个请求需不需要深度思考，再决定路由到哪个模式。

104
00:09:39,492 --> 00:09:41,860
陷阱三，死循环。

105
00:09:41,860 --> 00:09:46,920
修一个错，引出另一个错，再修回去，十五轮还在转。

106
00:09:46,920 --> 00:09:55,261
每轮输入膨胀一千词元的话，二十轮下来成本涨十三倍，更糟的是用户等了五分钟任务还没完成。

107
00:09:55,261 --> 00:09:57,569
陷阱四，历史雪球。

108
00:09:57,569 --> 00:10:04,684
标准但错误的做法是每轮都把完整历史塞进输入，第十轮的输入大约五万个词元。

109
00:10:04,684 --> 00:10:10,850
改用滑动窗口只留最近五轮，降到一万二，但丢了早期上下文。

110
00:10:10,850 --> 00:10:18,674
而固定左侧加压缩历史加保留最近三轮，大约六千，既保关键信息又控制长度。

111
00:10:18,674 --> 00:10:29,432
原则是，系统提示词永不压缩，这样才能保住缓存前缀；最近三轮保留完整细节；更早的历史用小模型压成一句摘要。

112
00:10:29,572 --> 00:10:35,832
死循环这一条值得单独展开，因为它既是成本问题，更是体验问题。

113
00:10:35,782 --> 00:10:40,565
解法是强制熔断，三个条件任一命中就优雅退出。

114
00:10:40,565 --> 00:10:43,534
第一，轮次上限，比如十轮。

115
00:10:43,534 --> 00:10:46,467
第二，词元预算，比如五万。

116
00:10:46,467 --> 00:10:52,464
第三，死循环检测，连续三轮输出相似度超过九成就判定。

117
00:10:52,464 --> 00:10:55,229
优雅退出这三个字很关键。

118
00:10:55,229 --> 00:11:01,911
退出时要带上已执行轮次、已消耗词元，以及最重要的，半成品结果。

119
00:11:01,911 --> 00:11:03,967
半成品也比黑洞强。

120
00:11:03,967 --> 00:11:10,409
用户至少知道跑到哪一步了、拿到了什么，而不是盯着一个转圈的图标。

121
00:11:10,409 --> 00:11:13,606
把这一段的控制点收成一份清单。

122
00:11:13,606 --> 00:11:17,657
工具返回值截断加摘要，上限两千词元。

123
00:11:17,657 --> 00:11:22,428
历史管理固定左侧加压缩旧历史，输入降一半以上。

124
00:11:22,428 --> 00:11:25,806
循环控制上熔断，防止无底洞。

125
00:11:25,806 --> 00:11:29,736
思考模式按任务分级，输出成本降四倍。

126
00:11:29,736 --> 00:11:33,125
简单子任务用小模型，降单价。

127
00:11:33,125 --> 00:11:38,270
固定系统提示词命中键值缓存，输入成本降九成。

128
00:11:38,270 --> 00:11:40,169
三条红线记住。

129
00:11:40,169 --> 00:11:47,224
单轮输入小于三万二，总轮次小于十轮，输入输出比超过五十比一就报警。

130
00:11:47,380 --> 00:11:50,034
第三段，讲提示词本身。

131
00:11:49,984 --> 00:12:01,414
很多产品早期为了调试方便，或者干脆是让人工智能代写的提示词，习惯用井号做标题、用星号加粗、用花括号嵌套展示数据。

132
00:12:01,414 --> 00:12:06,667
这些对人类友好的排版，在模型的计费逻辑里全是词法税。

133
00:12:06,667 --> 00:12:08,421
这笔税有多重。

134
00:12:08,421 --> 00:12:18,313
课程作者做了一个词元可视化分析工具，把一段提示词丢进去分析，光是加粗用的那两个星号，就吃掉了百分之八点五的词元。

135
00:12:18,313 --> 00:12:25,609
算上列表符号、标题符号、缩进换行，这份提示词百分之十三都是格式性内容。

136
00:12:25,609 --> 00:12:31,450
一般产品的提示词里，百分之十到百分之二十都是这种装饰性词元。

137
00:12:31,450 --> 00:12:38,662
千万级调用量下，每月百分之十到二十的预算，花在了让产品经理看起来舒服一点上。

138
00:12:38,662 --> 00:12:40,272
结论很简单。

139
00:12:40,272 --> 00:12:44,719
提示词是写给机器的指令，最终版本不需要美观。

140
00:12:44,719 --> 00:12:47,556
机器关注的是逻辑，不是排版。

141
00:12:47,556 --> 00:12:51,318
强调符号只用在真正需要强调的地方。

142
00:12:51,318 --> 00:12:53,241
自查方法也不难。

143
00:12:53,241 --> 00:12:58,229
把你的提示词丢进分析工具，看一眼装饰性词元的占比。

144
00:12:58,229 --> 00:13:02,772
超过百分之十，就说明有一笔最容易拿的钱还没拿。

145
00:13:02,772 --> 00:13:10,897
改起来很轻，把星号和井号删掉、把多余的换行缩进压掉，逻辑一个字不动，账单立刻变脸。

146
00:13:11,044 --> 00:13:16,330
把五十条用户记录喂给模型，三种格式的账单差别很大。

147
00:13:16,280 --> 00:13:23,684
第一条经验，复杂对象用缩进代替闭合符号的那种格式，别用花括号嵌套的那种。

148
00:13:23,684 --> 00:13:32,133
后者的信噪比太低，每个键都要双引号包裹，每层嵌套都要闭合，而这些符号往往独立计费。

149
00:13:32,133 --> 00:13:39,345
前者用缩进代替闭合符号，词元通常省百分之十到十五，多的能到百分之四十。

150
00:13:39,345 --> 00:13:45,222
也有专为省词元设计的新格式，但作为新格式，模型不一定支持得好。

151
00:13:45,222 --> 00:13:50,835
所以更稳的组合是，复杂对象用缩进格式，扁平列表用表格。

152
00:13:50,835 --> 00:13:56,845
第二条，扁平列表用带表头的逗号分隔表格，别用花括号数组。

153
00:13:56,845 --> 00:14:03,251
表头只写一遍，键名重复五十遍的那种写法，是检索场景的重灾区。

154
00:14:03,251 --> 00:14:09,874
长列表场景能砍百分之三十到六十，同样的上下文窗口还能塞更多数据。

155
00:14:09,874 --> 00:14:14,345
第三条，后台输出强制压成一行的紧凑格式。

156
00:14:14,345 --> 00:14:20,042
这里要先记住一个容易被忽略的事实，输出端的词元比输入端更贵。

157
00:14:20,042 --> 00:14:25,691
所以它既影响账单，也直接影响接口返回速度，两头都在烧。

158
00:14:25,691 --> 00:14:34,898
面向用户的流式输出可以宽松点，但纯后台任务，提取标签、情感分析、数据清洗，不需要任何排版。

159
00:14:34,898 --> 00:14:42,891
在系统提示词里显式约束一句，输出必须是紧凑格式，不换行、不缩进、不加代码块标记。

160
00:14:42,891 --> 00:14:46,508
机器读数据不需要美观，只需要合法。

161
00:14:46,508 --> 00:14:51,388
批量任务加上这条约束后，生成耗时显著下降。

162
00:14:51,532 --> 00:14:54,342
最后给你四条可以带走的判断。

163
00:14:54,292 --> 00:14:59,460
第一，图片按缩放对齐后的分辨率计费，不是按你传的原图。

164
00:14:59,460 --> 00:15:13,871
记住三十二像素对齐这个跳档点，前端先压缩再上传，并按任务分级匹配分辨率，粗分类给五百一十二，场景理解给一千，文字识别给两千，只有医疗影像这类才开四开以上。

165
00:15:13,871 --> 00:15:18,078
多图场景做预算池，累计接近三万二就截断。

166
00:15:18,078 --> 00:15:21,456
第二，把输入输出比当健康指标。

167
00:15:21,456 --> 00:15:28,030
智能体是输入主导，每轮都重读全部历史，成本按轮次平方级膨胀。

168
00:15:28,030 --> 00:15:33,703
比率超过五十比一，说明它在空转，先查流程再谈换模型。

169
00:15:33,703 --> 00:15:36,804
第三，四个陷阱各配一道闸。

170
00:15:36,804 --> 00:15:55,858
工具返回值截断到两千词元；思考模式按任务分级开关，别让看不见的内心戏按四倍单价烧钱；轮次、词元预算、死循环检测三选一命中就熔断，并且优雅退出时带上半成品；历史用固定左侧加摘要加最近三轮。

171
00:15:55,858 --> 00:15:58,635
第四，先量一下你的提示词。

172
00:15:58,635 --> 00:16:04,044
装饰性词元通常占百分之十到二十，这是最容易拿的一笔钱。

173
00:16:04,044 --> 00:16:09,500
复杂对象用缩进格式，扁平列表用表格，后台输出压成一行。

174
00:16:09,500 --> 00:16:15,690
成本不是财务月底给的那个数字，是你在需求评审时一个个决定累加出来的。

175
00:16:15,690 --> 00:16:20,354
这一集给的这些红线，值得贴在设计文档的第一页。