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

2
00:00:06,382 --> 00:00:17,283
这一集是原理篇的收口，我们要把前面散着讲的东西串成一条线，然后落到一个很实在的问题上，学完这些，你今天到底能动手做什么。

3
00:00:17,283 --> 00:00:19,663
先说本集解决什么问题。

4
00:00:19,663 --> 00:00:25,685
很多产品经理对大模型的理解，是若干条各自正确的结论拼起来的。

5
00:00:25,685 --> 00:00:31,069
它很聪明但有幻觉，上下文有窗口，提示词要写得讲究。

6
00:00:31,069 --> 00:00:38,064
这些都对，但它们之间没有连接，所以一到做判断的时候就用不上，只能凭感觉。

7
00:00:38,064 --> 00:00:45,985
这一集给你一条主线，从它是什么，到它为什么会错，到怎么缓解，再到你怎么把一件事交代清楚。

8
00:00:45,985 --> 00:00:48,822
再说为什么产品经理要关心。

9
00:00:48,822 --> 00:00:51,838
因为这条主线直接决定三件事。

10
00:00:51,838 --> 00:00:59,591
第一是你能承诺什么，幻觉是不可消除的先天局限，你承诺零错误就等于承诺做不到的事。

11
00:00:59,591 --> 00:01:05,564
第二是你要花多少钱，上下文是有限而且有价格的资源，不是免费的水。

12
00:01:05,564 --> 00:01:12,031
第三是你能不能验收，大多数需求停在一句愿望上，根本没法判断做没做对。

13
00:01:12,031 --> 00:01:14,423
还有一层更现实的考虑。

14
00:01:14,423 --> 00:01:22,247
现在团队里关于人工智能的分歧，很少是真的技术分歧，多半是大家对同一个词的理解不在一层。

15
00:01:22,247 --> 00:01:28,533
有人说的「它懂了」是概率上说得通，有人说的「它懂了」是能承担责任。

16
00:01:28,533 --> 00:01:34,651
这一集把这几层分开，以后开会你可以直接说清楚，我们到底在争哪一层。

17
00:01:34,800 --> 00:01:36,733
先回到最底层。

18
00:01:36,683 --> 00:01:40,937
大模型的本质是一台超大型的概率预测机器。

19
00:01:40,937 --> 00:01:47,139
训练的过程，是在海量文本上反复做一件事，预测下一个词元是什么。

20
00:01:47,139 --> 00:01:50,781
参数记住的是统计规律，不是理解。

21
00:01:50,781 --> 00:02:00,144
推理的时候参数是冻结的，它只是在做条件概率计算，也就是给定已经出现的所有词，算出下一个最可能出现的词。

22
00:02:00,144 --> 00:02:04,050
这句话有两个推论，做产品的人必须记住。

23
00:02:04,050 --> 00:02:09,315
第一，它产出的是最可能的续写，而最可能不等于最准确。

24
00:02:09,315 --> 00:02:16,851
第二，训练结束后参数就冻住了，知识不会自动更新，这是幻觉无法根除的根本原因。

25
00:02:16,851 --> 00:02:19,555
再说词元和上下文窗口。

26
00:02:19,555 --> 00:02:27,716
词元不等于字，中文大约每个字一颗，常用词更省，生僻字会多占几颗；英文大约每个词一颗。

27
00:02:27,716 --> 00:02:36,238
上下文窗口是模型一次能看到的所有文字，超出就彻底忘了，连模糊印象都没有，是完全看不见。

28
00:02:36,238 --> 00:02:46,875
二零二五年的主流容量，不同模型差异很大，大约分成三档，约二十万字、约三十二万字、约八十万字，个别还能往上再扩。

29
00:02:46,875 --> 00:02:49,808
还有一条演进路径值得知道。

30
00:02:49,808 --> 00:02:58,005
从基座模型只会续写文字，到指令微调学会对话格式，再到对话接口模拟多轮对话。

31
00:02:58,005 --> 00:03:05,733
你每次调用接口，本质上是在构造一个精心设计的消息列表，让模型续写出你想要的内容。

32
00:03:05,733 --> 00:03:12,680
想明白这一点，你就知道所谓「调模型」很多时候调的只是那段开头的系统设定。

33
00:03:12,680 --> 00:03:15,132
这里还有个容易被忽略的点。

34
00:03:15,132 --> 00:03:21,106
既然参数是冻结的，那么在某个时间点之后发生的事情，它其实一无所知。

35
00:03:21,106 --> 00:03:29,928
你问它一项刚发布的政策，它多半不会说不知道，而是按照最可能的模式，给你编一段听起来很像真的内容。

36
00:03:29,928 --> 00:03:36,623
这就是为什么「不确定就说不知道」这类提示词只能降低概率，不能消除问题。

37
00:03:36,770 --> 00:03:40,554
幻觉分四种，分开认，才能分开治。

38
00:03:40,504 --> 00:03:45,540
第一种是事实性幻觉，捏造不存在的事实、数据和引用。

39
00:03:45,540 --> 00:03:50,780
第二种是来源幻觉，引用了不存在的论文、链接或者作者。

40
00:03:50,780 --> 00:03:55,696
第三种是推理幻觉，前提是对的，但推理的步骤错了。

41
00:03:55,696 --> 00:04:00,732
第四种是代码幻觉，调用了不存在的接口或者函数。

42
00:04:00,732 --> 00:04:02,523
根因主要两条。

43
00:04:02,523 --> 00:04:10,792
一条是参数知识本身有误，训练数据里本来就有错误信息，而知识截止日期之后的内容它一无所知。

44
00:04:10,792 --> 00:04:22,751
另一条是上下文理解偏差，提示词不清晰，模型只能猜你的意图；上下文互相矛盾的时候，它总是选最可能的续写，而最可能不等于最准确。

45
00:04:22,751 --> 00:04:27,559
四条缓解的路，按场景选，组合使用效果最好。

46
00:04:27,559 --> 00:04:35,287
第一条是提示词工程，用角色、约束、示例和让它一步步想，成本最低，应当优先用。

47
00:04:35,287 --> 00:04:39,602
它的局限是无法注入模型本来不知道的新知识。

48
00:04:39,602 --> 00:04:50,395
第二条是检索增强，完整链路是四步，把资料切成小块，把每块转成向量，按问题做向量检索，把命中的段落注入提示词。

49
00:04:50,395 --> 00:04:55,371
它不是让模型学习文档，而是运行时临时给一份小抄。

50
00:04:55,371 --> 00:04:59,458
代价是延迟、检索质量和维护成本。

51
00:04:59,458 --> 00:05:05,912
要提醒的是，它解决的是模型不知道的问题，解决不了模型推理方式不对的问题。

52
00:05:05,912 --> 00:05:13,508
所以如果你的痛点是格式老飘、语气不对，挂再多的资料也没用，那属于提示词那一路。

53
00:05:13,508 --> 00:05:17,691
第三条是调整随机性的参数，也就是温度。

54
00:05:17,691 --> 00:05:22,907
调到零每次都一样，调到一是正常采样，大于一更随机。

55
00:05:22,907 --> 00:05:29,867
这里有个高频误区，不是越高越聪明、越低越蠢，它控制的是随机性，不是智能。

56
00:05:29,867 --> 00:05:35,504
第四条是人工审核，模型生成、人工过一遍、用户才看到。

57
00:05:35,504 --> 00:05:41,333
高风险和强合规场景的必备兜底，代价是人力成本和响应延迟。

58
00:05:41,470 --> 00:05:46,504
怎么选，看你的活儿会在哪儿出错，这不是四选一的偏好题。

59
00:05:46,454 --> 00:05:52,427
知识已经在训练数据里、问题出在格式风格语气上，改提示词就够。

60
00:05:52,427 --> 00:05:59,482
涉及私有知识库、实时数据、或者知识截止日期之后的内容，需要检索增强。

61
00:05:59,482 --> 00:06:05,636
要固定某个专业领域的风格、或者推理范式本身要改变，才考虑微调。

62
00:06:05,636 --> 00:06:12,728
输出风险高、牵涉品牌声誉、有医疗法律这类合规要求，必须上人工审核。

63
00:06:12,728 --> 00:06:15,973
四个最常见的误会，值得单独说。

64
00:06:15,973 --> 00:06:20,480
第一，以为调高温度就更聪明，其实只是更随机。

65
00:06:20,480 --> 00:06:27,415
第二，以为检索增强等于让模型学习文档，其实只是运行时临时注入上下文。

66
00:06:27,415 --> 00:06:36,105
第三，以为模型在调用接口，其实它只是输出了一段格式化的文字，真正去调用的是你写的那层代码。

67
00:06:36,105 --> 00:06:43,918
第四，以为重新训练就能修复错误，正确的顺序永远是先试提示词，成本差着一百倍。

68
00:06:43,918 --> 00:06:45,745
还有个实用提醒。

69
00:06:45,745 --> 00:06:51,766
有些对话产品里根本没有温度这个开关，但少这一条不代表少了一条路。

70
00:06:51,766 --> 00:06:57,716
四种办法本来就彼此独立，缺这一个，另外三个照样单独成立。

71
00:06:57,716 --> 00:07:06,141
想把格式钉死，就在提示词里给一份模板加一个完整例子，写明只输出这几个字段、不要解释。

72
00:07:06,141 --> 00:07:11,502
同一句话连跑三遍看它稳不稳，比拧参数更能暴露问题。

73
00:07:11,502 --> 00:07:16,862
真到了非精确控制不可的程度，那本身就是该走接口的信号。

74
00:07:16,862 --> 00:07:25,192
带走一句话，大模型本质是超大型概率预测机器，理解它的局限，才能正确发挥它的优势。

75
00:07:25,340 --> 00:07:28,751
上下文窗口就是模型的工作记忆。

76
00:07:28,701 --> 00:07:38,377
一次请求的上下文通常由五块构成，系统提示词、对话历史、上传的文档、当前问题、以及给回复预留的空间。

77
00:07:38,377 --> 00:07:42,451
这几块加在一起，就是那个不能超的额度。

78
00:07:42,451 --> 00:07:46,826
关键在于，这个额度不只是技术限制，它是钱。

79
00:07:46,826 --> 00:07:50,011
模型按输入加输出的词元数计费。

80
00:07:50,011 --> 00:07:57,090
放一份一百页的文档进去，大约五万词元，每一次对话都要额外多花大约五毛钱。

81
00:07:57,090 --> 00:08:01,249
多轮对话之后，历史记录也会累积占满窗口。

82
00:08:01,249 --> 00:08:07,367
所以上下文是有限的、有价格的资源，用了就要付钱，超了就会截断。

83
00:08:07,367 --> 00:08:11,465
窗口溢出之后，工程上有三种主流处理策略。

84
00:08:11,465 --> 00:08:19,506
第一种是直接截断，把最早的内容直接丢掉，最简单，代价是前面的关键信息可能就这样没了。

85
00:08:19,506 --> 00:08:27,655
第二种是摘要压缩，把历史对话压成一段摘要再放回窗口，省地方，但压缩本身可能丢细节。

86
00:08:27,655 --> 00:08:34,735
第三种是选择性保留，只留下跟当前任务相关的部分，效果最好，实现也最复杂。

87
00:08:34,735 --> 00:08:37,463
三种策略各有适用场景。

88
00:08:37,463 --> 00:08:44,422
直接截断最省事，适合前后两轮本来就没什么关系的场景，比如一问一答的客服。

89
00:08:44,422 --> 00:08:53,473
摘要压缩适合长任务，但压缩这一步本身也可能漏掉关键数字，所以压缩时要显式保留那些不能丢的硬信息。

90
00:08:53,473 --> 00:09:03,701
选择性保留效果最好，适合有明确主题的长对话，代价是你要额外写一套判断相关性的逻辑，而这套逻辑本身也会出错。

91
00:09:03,701 --> 00:09:10,624
对产品经理来说，这一节的意义在于，长对话产品不能只想着把窗口开到最大。

92
00:09:10,624 --> 00:09:14,795
你要设计的是一套溢出策略，并且让用户看得见。

93
00:09:14,795 --> 00:09:26,477
什么时候该提醒开新对话，什么时候该自动摘要，哪些设定必须一直保留在窗口里，这些都要在方案里写清楚，而不是等用户发现它突然忘了才补救。

94
00:09:26,640 --> 00:09:33,392
先说一个反直觉的事实，为什么主流模型默认输出的都是那种轻量标记语言。

95
00:09:33,342 --> 00:09:41,972
因为模型是纯文本模型，它逐词元输出，每个词元就是一段文字，它不懂颜色、不懂字号、不懂对齐。

96
00:09:41,972 --> 00:09:50,181
但用户期待有排版，标题、加粗、列表、代码块、链接，没有排版的纯文本体验极差。

97
00:09:50,181 --> 00:09:53,583
几种方案推演下来，结论很清楚。

98
00:09:53,583 --> 00:09:57,056
用网页标签，太重，浪费词元。

99
00:09:57,056 --> 00:10:02,297
用文档或者便携式文档格式，是二进制，没法逐字输出。

100
00:10:02,297 --> 00:10:06,540
用排版公式语言，语法复杂，模型容易出错。

101
00:10:06,540 --> 00:10:17,537
最后胜出的是那种标记语言，文本自带排版标记，标题前面加个井号、加粗两边加星号，只占几颗词元，前端还有成熟的渲染库。

102
00:10:17,537 --> 00:10:22,525
这不是碰巧，是纯文本模型加上排版需求的最优解。

103
00:10:22,525 --> 00:10:23,943
再说角色。

104
00:10:23,943 --> 00:10:29,857
通过系统提示词指定角色，同一个模型可以变成完全不同的助手。

105
00:10:29,857 --> 00:10:38,775
角色扮演是最基础也最有效的技巧，而所有的产品，本质上都是在系统提示词里写了不同的角色定义。

106
00:10:38,775 --> 00:10:41,263
换角色，就换产品。

107
00:10:41,263 --> 00:10:46,600
然后是万能公式，角色加任务加上下文加约束加示例加格式。

108
00:10:46,600 --> 00:10:49,797
缺少任何一项，质量就会打折扣。

109
00:10:49,797 --> 00:10:54,761
把提示词当代码写，加约束、加示例、加测试用例。

110
00:10:54,761 --> 00:10:57,489
四个进阶技巧值得单独练。

111
00:10:57,489 --> 00:11:06,684
第一个是少样本示例，与其花一百字描述你要什么，不如直接给它两三个完整的例子，质量的提升往往更明显。

112
00:11:06,684 --> 00:11:14,244
第二个是让它一步步想，把推理过程先写出来再给结论，复杂问题上错误率明显下降。

113
00:11:14,244 --> 00:11:20,350
第三个是写清约束，把边界条件、字数、不能出现什么都明确下来。

114
00:11:20,350 --> 00:11:27,128
第四个是任务拆解，一个大任务拆成几步分步执行，比一次性让它做完要稳得多。

115
00:11:27,128 --> 00:11:29,592
最后是输出格式的取舍。

116
00:11:29,592 --> 00:11:35,842
没有最好的格式，只有最适合场景的格式，流式返回时差别格外明显。

117
00:11:35,842 --> 00:11:41,467
键值格式要等全文到达才能解析，用户看到的是转圈等待。

118
00:11:41,467 --> 00:11:47,345
标记语言逐字显示，最有打字感，但没法可靠地提取结构化字段。

119
00:11:47,345 --> 00:11:54,280
标签格式两全其美，捕获到闭合标签就能立刻渲染，既流式又结构化。

120
00:11:54,410 --> 00:12:00,814
原理讲完，最容易发生的事是你觉得学到了很多，合上电脑手上什么都没多。

121
00:12:00,764 --> 00:12:06,148
所以这一节只回答一个问题，学完这些，你今天能动手做什么。

122
00:12:06,148 --> 00:12:20,547
这门课有一条实战主线，做出一个真能干活的智能体，分六个里程碑推进，想清楚它替你干什么、能稳定说人话、能动手干活、改好改坏能量化、长跑不失忆、过程可复现。

123
00:12:20,547 --> 00:12:22,627
你现在站在第一格。

124
00:12:22,627 --> 00:12:27,987
每章结尾推进一格，六个填满，你手上就是一份完整的设计说明。

125
00:12:27,987 --> 00:12:31,617
先看清需求要收敛到什么程度才算数。

126
00:12:31,617 --> 00:12:37,843
大多数人给模型布置任务，停在第一段就交卷了，比如一句「帮我处理一下周报」。

127
00:12:37,843 --> 00:12:45,463
这句话没错，只是它没法验收，你不知道什么样的输出算成功，自然也不知道该不该改提示词。

128
00:12:45,463 --> 00:12:48,805
往下推三段，它才变成一个真需求。

129
00:12:48,805 --> 00:12:50,788
第一段是一句愿望。

130
00:12:50,788 --> 00:12:57,735
第二段是定输入输出，进的是一周的零碎记录，出的是三段结论加一份下周计划。

131
00:12:57,735 --> 00:13:03,540
第三段是定什么算对，比如三段都能直接发给老板、一个字不用改。

132
00:13:03,540 --> 00:13:10,439
第四段是挑压幻觉的方案，要引具体数字那就走检索增强，别让它凭记忆编。

133
00:13:10,439 --> 00:13:12,879
最常见的卡点是第二段。

134
00:13:12,879 --> 00:13:19,310
输入是什么、输出长什么样，你自己都没想清楚，后面两段根本没机会跑。

135
00:13:19,310 --> 00:13:23,011
所谓「试了一下感觉不行」，原因通常就在这儿。

136
00:13:23,011 --> 00:13:26,016
动手清单有三档，挑一个开始。

137
00:13:26,016 --> 00:13:34,610
第一档十五分钟，所有人都能做，把那件事写成四行，一句愿望、输入是什么、输出长什么样、什么算对。

138
00:13:34,610 --> 00:13:43,853
验收方法是把这四行念给一个不了解你工作的人听，他能复述出模型要交出什么，做不到说明中间两段还太虚。

139
00:13:43,853 --> 00:13:53,360
第二档一小时，翻出五份真实材料丢给它，一次一份，提示词保持一模一样，重点是看它在哪一类输入上开始胡说。

140
00:13:53,360 --> 00:14:01,317
验收标准是你能说出一句具体的话，输入里一旦出现某某它就开始编，笼统的「有时候不太准」不算。

141
00:14:01,317 --> 00:14:07,639
第三档半天，把这件事拆成模型做和你做两半，写清交接点长什么样。

142
00:14:07,639 --> 00:14:14,502
验收标准是你答得上来，如果它那一半出错，你在哪一步、用什么方式会发现。

143
00:14:14,640 --> 00:14:18,916
最后给你一份可以马上用的判断清单，一共五条。

144
00:14:18,866 --> 00:14:23,265
第一条，把幻觉当成默认前提，而不是意外。

145
00:14:23,265 --> 00:14:29,419
它不可完全消除，因为它是概率预测的必然产物，训练结束参数就冻住了。

146
00:14:29,419 --> 00:14:35,465
你要设计的不是消灭幻觉，而是让幻觉在到达用户之前被发现。

147
00:14:35,465 --> 00:14:41,054
第二条，按出错位置选缓解方案，而不是按熟悉程度选。

148
00:14:41,054 --> 00:14:51,559
格式风格问题改提示词，私有知识和实时数据走检索增强，改推理范式才考虑微调，高风险和强合规必须加人工审核。

149
00:14:51,559 --> 00:14:55,537
顺序永远是先提示词，成本差着一百倍。

150
00:14:55,537 --> 00:14:58,999
第三条，把上下文当成预算来管。

151
00:14:58,999 --> 00:15:08,746
系统提示词、对话历史、上传文档、当前问题、预留回复，这五块都在抢同一个额度，而且每一颗词元都要付钱。

152
00:15:08,746 --> 00:15:17,472
长对话产品必须提前设计溢出策略，直接截断、摘要压缩、选择性保留，选一个并让用户看得见。

153
00:15:17,472 --> 00:15:20,537
第四条，把提示词当代码写。

154
00:15:20,537 --> 00:15:26,378
角色加任务加上下文加约束加示例加格式，缺一项就掉一档质量。

155
00:15:26,378 --> 00:15:35,213
输出格式要按场景选，要程序处理就用键值格式，要打字感就用标记语言，两个都要就用标签格式。

156
00:15:35,213 --> 00:15:39,083
第五条，需求不收敛到第四段就不要开工。

157
00:15:39,083 --> 00:15:44,648
一句愿望、输入输出、什么算对、压幻觉的方案，四行写下来。

158
00:15:44,648 --> 00:15:52,713
验收看两句话，不了解你工作的人能不能复述出要交出什么，以及它出错时你在哪一步会发现。

159
00:15:52,713 --> 00:15:56,318
答不上来，说明这条线划得太靠后了。

160
00:15:56,318 --> 00:16:01,727
这五条的共同点是，把对模型的期待，换成对流程的要求。

161
00:16:01,727 --> 00:16:05,549
模型负责生成，你负责让它可验收。