1
00:00:00,000 --> 00:00:03,720
为什么说像是这样一个听起来没有什么

2
00:00:03,740 --> 00:00:06,180
智力听起来非常廉价的

3
00:00:06,200 --> 00:00:07,990
一个模型它能够这么火呢

4
00:00:11,300 --> 00:00:12,200
大家好 这里是

5
00:00:12,220 --> 00:00:13,280
AsyncTalk 我是

6
00:00:13,300 --> 00:00:13,820
AsyncTalk

7
00:00:13,840 --> 00:00:14,570
主播 AnnatarHe

8
00:00:14,740 --> 00:00:17,800
今天的话我想来聊一个前几天

9
00:00:17,820 --> 00:00:19,650
非常火的一个模型叫Jev

10
00:00:20,020 --> 00:00:21,650
首先呢 Jev是什么呢

11
00:00:21,800 --> 00:00:22,840
Jev的话它就是

12
00:00:22,860 --> 00:00:25,260
一个非常非常快的

13
00:00:25,280 --> 00:00:27,800
只用来去判断非常简单的东西

14
00:00:27,820 --> 00:00:29,760
比如说苹果能不能吃

15
00:00:29,780 --> 00:00:31,740
就这种非常简单的问题

16
00:00:31,760 --> 00:00:33,620
然后它可以比Flash

17
00:00:33,640 --> 00:00:36,440
快更多更多的速度来去返回

18
00:00:36,460 --> 00:00:39,820
这就是它和其他大模型非常不一样的地方

19
00:00:39,840 --> 00:00:42,260
因为我们回忆一下传统的大模型的话

20
00:00:42,280 --> 00:00:44,640
比如说像是目前最顶级的

21
00:00:44,660 --> 00:00:47,040
像是GPT-6系列

22
00:00:47,060 --> 00:00:48,380
比如说像是

23
00:00:48,400 --> 00:00:50,100
Claude Opus Fable

24
00:00:50,120 --> 00:00:52,320
他们所有的这些模型

25
00:00:52,340 --> 00:00:55,560
最主要就是想要一步一步的提升智能

26
00:00:55,580 --> 00:00:57,620
提升思考的深度

27
00:00:57,640 --> 00:00:58,540
但Jev的话

28
00:00:58,560 --> 00:00:59,700
它是走另一条路

29
00:00:59,720 --> 00:01:02,120
它只做一些非常简单的判断

30
00:01:02,140 --> 00:01:04,040
但它可以做得很快

31
00:01:04,060 --> 00:01:05,120
可以做得很好

32
00:01:05,140 --> 00:01:07,620
我相信如果你有观看我们

33
00:01:07,640 --> 00:01:08,560
AsyncTalk节目的话

34
00:01:08,580 --> 00:01:09,820
你大概就是一个程序员

35
00:01:09,840 --> 00:01:12,600
那程序员我们里边可以说

36
00:01:12,620 --> 00:01:14,900
最重要的一个语句就是if了

37
00:01:14,920 --> 00:01:17,560
那if A我们执行A条件

38
00:01:17,580 --> 00:01:19,300
执行A分支

39
00:01:19,320 --> 00:01:21,160
那如果不是if的话

40
00:01:21,180 --> 00:01:22,520
那我们就执行B条件

41
00:01:22,540 --> 00:01:24,720
那其实我们按照这个思想的话

42
00:01:24,740 --> 00:01:25,500
我们来做

43
00:01:25,520 --> 00:01:26,840
Coding agent的时候

44
00:01:26,860 --> 00:01:30,220
是会经常出现这样的情况的

45
00:01:30,240 --> 00:01:31,320
那我举一个例子

46
00:01:31,340 --> 00:01:32,200
那比如说用户

47
00:01:32,220 --> 00:01:33,640
他有一个prompt是说

48
00:01:33,660 --> 00:01:34,880
帮我拿个手机

49
00:01:34,900 --> 00:01:37,060
那拿个手机是拿哪个手机呢

50
00:01:37,080 --> 00:01:38,780
如果是拿A手机的话

51
00:01:38,800 --> 00:01:39,320
应该怎么样

52
00:01:39,340 --> 00:01:40,600
如果是拿B手机的话

53
00:01:40,620 --> 00:01:41,100
应该怎么样

54
00:01:41,120 --> 00:01:42,500
那这个如果的判断

55
00:01:42,520 --> 00:01:43,400
是应该怎么做呢

56
00:01:43,420 --> 00:01:45,540
那对于我们普通的大模型来说的话

57
00:01:45,560 --> 00:01:47,460
你可能需要去定一个

58
00:01:47,480 --> 00:01:48,440
output structure

59
00:01:48,460 --> 00:01:51,160
然后对返回的一个JSON

60
00:01:51,180 --> 00:01:52,080
做一个处理

61
00:01:52,100 --> 00:01:55,140
然后再去看这个意向

62
00:01:55,160 --> 00:01:56,540
到底是A还是B

63
00:01:56,560 --> 00:01:58,140
你需要走一遍完整的大模型

64
00:01:58,160 --> 00:01:59,460
其实一方面的话

65
00:01:59,480 --> 00:02:01,800
它耗时会稍微有点久

66
00:02:01,820 --> 00:02:02,940
那另一方面的话

67
00:02:02,960 --> 00:02:04,100
其实成本也比较高

68
00:02:04,120 --> 00:02:05,940
那对于我们传统的大模型来说的话

69
00:02:05,960 --> 00:02:07,220
它是token by token的

70
00:02:07,240 --> 00:02:08,940
这样一个计算和计费

71
00:02:08,960 --> 00:02:10,960
对于Jev这种模式来说的话

72
00:02:10,980 --> 00:02:12,160
它就变得不一样了

73
00:02:12,180 --> 00:02:14,100
它就是用来去做这种简单的判断

74
00:02:14,120 --> 00:02:16,820
它不再需要像我们传统的大模型一样

75
00:02:16,840 --> 00:02:18,570
过一遍完整的

76
00:02:18,920 --> 00:02:21,620
漫长的一个用户的意图识别

77
00:02:21,640 --> 00:02:23,000
当然它也不是我们

78
00:02:23,020 --> 00:02:24,640
纯工程上面的

79
00:02:24,660 --> 00:02:25,820
一个if condition

80
00:02:25,840 --> 00:02:27,970
a到一个a branch

81
00:02:28,300 --> 00:02:30,560
这样一个纯工程的方面

82
00:02:30,580 --> 00:02:34,040
毕竟我们中间还是需要去调用

83
00:02:34,060 --> 00:02:35,760
AI来理解一下用户的意图

84
00:02:35,780 --> 00:02:38,300
那这个时候Jev的话就非常的合适

85
00:02:38,320 --> 00:02:42,100
除了这个比较简单的用户的意图的识别

86
00:02:42,120 --> 00:02:43,060
还有什么场景呢

87
00:02:43,080 --> 00:02:45,250
那放在我们的AI agent

88
00:02:45,560 --> 00:02:46,840
因为现在其实我们的

89
00:02:46,860 --> 00:02:48,680
agent已经变得非常的复杂了

90
00:02:48,700 --> 00:02:50,820
他从最开始的一些分析

91
00:02:50,840 --> 00:02:52,260
到中间的执行

92
00:02:52,280 --> 00:02:53,720
到最后的结果展示

93
00:02:53,740 --> 00:02:56,380
中间是有非常大量的这种

94
00:02:56,400 --> 00:02:58,440
简单的if 逻辑在里面的

95
00:02:58,460 --> 00:02:59,560
比如说我们的Coding agent

96
00:02:59,580 --> 00:03:01,620
那这个文件它是不是

97
00:03:01,640 --> 00:03:02,680
TypeScript的文件

98
00:03:02,700 --> 00:03:04,440
这种判断的话

99
00:03:04,460 --> 00:03:05,420
它也可以交给AI

100
00:03:05,440 --> 00:03:09,340
所以交给这样这种快速决断的模型来说

101
00:03:09,360 --> 00:03:11,410
就变得非常的合适

102
00:03:11,660 --> 00:03:13,980
还有一个场景就是验证一切的场景

103
00:03:14,000 --> 00:03:15,920
当我们在这调用agent

104
00:03:15,940 --> 00:03:17,340
来去做一些事情的时候

105
00:03:17,360 --> 00:03:19,580
在这些非常多的步骤完成之后的话

106
00:03:19,600 --> 00:03:21,060
我们是有一个验证的过程

107
00:03:21,080 --> 00:03:24,660
但是其实我们并不能验证所有的流程

108
00:03:24,680 --> 00:03:26,880
因为它会把你的时间拉得非常长

109
00:03:26,900 --> 00:03:28,700
同样的话它也非常消耗token

110
00:03:28,720 --> 00:03:31,220
但是如果我们有Jev这样的模型的话

111
00:03:31,240 --> 00:03:32,540
它就可以非常快速的

112
00:03:32,560 --> 00:03:35,380
来去进行一些简单的校验

113
00:03:35,400 --> 00:03:37,320
这样的话我们最终得到的

114
00:03:37,340 --> 00:03:38,620
工作的效率也会更好

115
00:03:38,640 --> 00:03:41,600
那接下来我来展示一下这个Jev模型

116
00:03:41,620 --> 00:03:43,200
它有什么应用

117
00:03:43,220 --> 00:03:45,360
以及它大概会是长什么样子

118
00:03:45,380 --> 00:03:47,450
那这里我来问他一个问题就是

119
00:03:48,040 --> 00:03:49,450
苹果可以被吃吗

120
00:03:51,080 --> 00:03:52,340
好 我们问一下

121
00:03:52,360 --> 00:03:55,300
他回答99%的概率可以被吃

122
00:03:55,320 --> 00:03:57,910
那我们问另外一个问题 比如说

123
00:04:00,960 --> 00:04:03,270
我可以买沪深300吗

124
00:04:05,980 --> 00:04:08,740
他给的概率是大概46% 47%的样子

125
00:04:08,760 --> 00:04:11,530
那我再问一下 我应该买

126
00:04:14,240 --> 00:04:16,640
他也给个大概44的样子

127
00:04:16,660 --> 00:04:18,150
会比沪深300要低一些

128
00:04:20,680 --> 00:04:23,300
他给了中规中矩大概53那样子

129
00:04:23,320 --> 00:04:25,400
那其实我的上下文非常的少

130
00:04:25,420 --> 00:04:27,460
我只是问他说我是不是应该出去玩

131
00:04:27,480 --> 00:04:29,640
我并没有告诉他我的地址在哪里

132
00:04:29,660 --> 00:04:30,560
我的时间在哪里

133
00:04:30,580 --> 00:04:31,620
我的假期在哪里

134
00:04:31,640 --> 00:04:33,040
他能给出来就是

135
00:04:33,060 --> 00:04:35,900
一个非常快速的一个简单的判断

136
00:04:35,920 --> 00:04:38,660
当我们在增加更多的上下文的时候

137
00:04:38,680 --> 00:04:41,600
他会得出来一些更加准确的判断

138
00:04:41,620 --> 00:04:43,240
那当然Jev这么好的话

139
00:04:43,260 --> 00:04:46,340
那他是不是可以用来去取代

140
00:04:46,360 --> 00:04:48,540
所有的这种简单的判断呢

141
00:04:48,560 --> 00:04:50,240
他是不是足够可靠呢

142
00:04:50,260 --> 00:04:51,860
但其实并不是

143
00:04:51,880 --> 00:04:53,340
他像所有的大模型一样

144
00:04:53,360 --> 00:04:54,620
他同样是有幻觉的

145
00:04:54,640 --> 00:04:56,920
他只是做的问题比较简单

146
00:04:56,940 --> 00:04:58,560
他的反应速度比较快

147
00:04:58,580 --> 00:05:01,260
但他其实没办法完全避免幻觉

148
00:05:01,280 --> 00:05:02,320
因为幻觉这个东西

149
00:05:02,340 --> 00:05:04,340
人类也非常经常的有幻觉

150
00:05:04,360 --> 00:05:06,320
这是一个其实很难解决的问题

151
00:05:06,340 --> 00:05:08,520
当然我们需要承认说

152
00:05:08,540 --> 00:05:11,440
他的这条路线非常的有趣

153
00:05:11,460 --> 00:05:14,040
和我们现在主流的AI发展并不一样

154
00:05:14,060 --> 00:05:16,800
它给我们提供了另一种可能性

155
00:05:16,820 --> 00:05:18,140
这点我们要支持

156
00:05:18,160 --> 00:05:19,540
它可以用来去替代一些

157
00:05:19,560 --> 00:05:21,700
比较简单的用户的判断

158
00:05:21,720 --> 00:05:24,540
大家也可以下来去使用一下

159
00:05:24,560 --> 00:05:27,160
然后它现在的这个Waitlist

160
00:05:27,180 --> 00:05:29,100
应该是已经完全开放了

161
00:05:29,120 --> 00:05:31,720
你可以拿来去试一试看一看

162
00:05:31,740 --> 00:05:34,300
是否可以去接入一些简单的工作流

163
00:05:34,320 --> 00:05:37,250
然后来提升一些效率

164
00:05:37,700 --> 00:05:38,970
降低一些成本

165
00:05:39,390 --> 00:05:41,240
那也欢迎在评论区来留下你的看法

166
00:05:41,260 --> 00:05:45,020
你认为说这样一条非常规的AI发展路线

167
00:05:45,040 --> 00:05:46,700
是不是另一种路

168
00:05:46,720 --> 00:05:48,000
或者说你怎么样看

169
00:05:48,020 --> 00:05:50,300
这样的一种快速决断的模型

170
00:05:50,320 --> 00:05:52,190
那我们下期节目再见拜拜