實際影片長度:9:57.217。原文、繁中、雙語可點擊句子跳轉影片。
0:00.000–0:02.349
zh最近,硅谷出了一个非常特别的模型,
0:02.349–0:03.316
zh叫做JEFF。
0:03.316–0:04.145
zh他发布以后,
0:04.145–0:05.803
zh很快就在开发者圈里刷屏。
0:05.803–0:07.599
zh但如果只看网上的随便信息,
0:07.599–0:08.980
zh很容易产生两个误解。
0:08.980–0:09.947
zh第一个误解是,
0:09.947–0:14.092
zhJEFF又是一个准备去挑战CHIGBT Cloud的全能模型。
0:14.092–0:15.197
zh另一个误解就是,
0:15.197–0:17.131
zh他不就是一个普通的分类器吗?
0:17.131–0:18.927
zh为什么突然有这么多人讨论?
0:18.927–0:19.427
zh所以,
0:19.427–0:20.309
zh今天这期内容,
0:20.309–0:22.934
zh我把整个JEFF的来龙去脉都梳理一遍。
0:22.934–0:25.145
zh然后想从八个方面给大家去讲清楚。
0:25.145–0:25.697
zh第一个,
0:25.697–0:27.079
zhJEFF到底是什么?
0:27.079–0:27.631
zh第二个,
0:27.631–0:28.598
zh他开源了没有?
0:28.598–0:29.151
zh第三个,
0:29.151–0:29.980
zh能不能写的?
0:30.000–0:31.831
zh第四个,为什么突然就火了?
0:31.831–0:32.394
zh第五个,
0:32.394–0:33.521
zh他的优势在哪里?
0:33.521–0:34.085
zh第六个,
0:34.085–0:35.915
zh这条技术路线到底成不成立?
0:35.915–0:36.479
zh第七个,
0:36.479–0:38.451
zh开发者现在想用它来去做什么?
0:38.451–0:39.014
zh第八个,
0:39.014–0:40.141
zh如果你想试一试,
0:40.141–0:41.268
zh又该怎么去上手?
0:41.268–0:41.768
zh首先,
0:41.768–0:44.930
zh如果理解JEFF可以从我经常推荐的一本书讲起,
0:44.930–0:47.465
zh就是丹尼尔·卡尼曼的《思考快与曼》。
0:47.465–0:47.965
zh书里,
0:47.965–0:50.141
zh他把人的思考方式分成了两套系统。
0:50.141–0:51.690
zh系统一负责去快速判断,
0:51.690–0:53.239
zh看到前面有东西飞过来,
0:53.239–0:54.930
zh我们可能就本能的会躲开,
0:54.930–0:56.197
zh看到一个人的表情,
0:56.197–0:58.592
zh我们就能很快的判断他是不是生气了。
0:58.592–1:00.000
zh而系统二负责的是慢,
1:00.000–1:01.370
zh做一道复杂的数学题,
1:01.370–1:02.603
zh分析一份商业计划,
1:02.603–1:04.247
zh或者权衡一个重要的决定,
1:04.247–1:05.890
zh都需要去投入更多的注意。
1:05.890–1:06.575
zh过去几年,
1:06.575–1:09.315
zh大模型的发展其实主要都在不断的加强系统,
1:09.315–1:11.096
zh模型要学会去理解复杂问题,
1:11.096–1:11.781
zh展开推理,
1:11.781–1:12.466
zh量用工具,
1:12.466–1:14.110
zh然后生成一段完整的答案。
1:14.110–1:16.438
zh而TypeSafe提出的问题就是,
1:16.438–1:19.589
zh一个AI系统里的每一步都需要这样的认证思考吗?
1:19.589–1:22.055
zh很多时候程序需要的其实不是一篇文章,
1:22.055–1:23.014
zh而是一个判断,
1:23.014–1:24.932
zh这个就是JEFF出现的原因。
1:24.932–1:28.493
zhTypeSafe把它叫做System-1 Model,
1:28.493–1:30.000
zh也就是这个屏幕上写的。
1:30.000–1:30.914
zh这个名字呢,
1:30.914–1:32.893
zh就借鉴了思考快一慢的概念,
1:32.893–1:34.873
zh但更多的是一种产品的类比,
1:34.873–1:36.853
zh它并不是说复现了人的直觉,
1:36.853–1:38.985
zh而是专门去处理那些范围明确,
1:38.985–1:40.812
zh需要快速完成判断的任务。
1:40.812–1:44.924
zh你可以把JEFF理解成一个专门去给程序使用的决策模型。
1:44.924–1:45.838
zh穿透大模型,
1:45.838–1:46.904
zh接受一段文字,
1:46.904–1:48.426
zh然后继续去生成文字。
1:48.426–1:49.492
zh那JEFF呢,
1:49.492–1:52.234
zh接受一段材料和几个体型定义好的问题,
1:52.234–1:53.299
zh返回的是选项,
1:53.299–1:53.909
zh是分数,
1:53.909–1:55.127
zh以及相应的概率。
1:55.127–1:55.736
zh比如说,
1:55.736–1:56.954
zh用户发来一句话,
1:56.954–1:58.934
zh我买的东西一个星期还没到,
1:58.934–2:00.000
zh现在不想要了。
2:00.000–2:00.708
zh去写回复,
2:00.708–2:02.406
zh而是需要搞清楚几件事情。
2:02.406–2:03.821
zh这个用户是在查物流,
2:03.821–2:04.953
zh还是在准备退款。
2:04.953–2:06.085
zh情绪是不是激烈,
2:06.085–2:07.642
zh要不要去转给人工客服?
2:07.642–2:08.491
zhJEFF呢,
2:08.491–2:10.896
zh会从开发者给定的选项里面去做选择,
2:10.896–2:13.302
zh并且告诉程序每一个答案有多大概率,
2:13.302–2:14.717
zh那程序拿到结果以后,
2:14.717–2:16.557
zh就可以继续执行对应的流程。
2:16.557–2:17.057
zh所以,
2:17.057–2:19.387
zh有一句话就可以很直观的去概括它了。
2:19.387–2:21.226
zhCHATGPT负责写答案,
2:21.226–2:22.783
zhJEFF负责去做判断。
2:22.783–2:23.283
enOK,
2:23.283–2:24.198
zh那第二个问题,
2:24.198–2:25.613
zhJEFF开源了没有?
2:25.613–2:26.604
zh目前是没有的。
2:26.604–2:28.019
zhType Safe呢,
2:28.019–2:30.000
zh没有公开JEFF的模型权重,
2:30.000–2:30.826
zh和核心实现,
2:30.826–2:31.514
zh开发者呢,
2:31.514–2:33.716
zh主要还是通过云端API去调用它。
2:33.716–2:37.569
zh所以它和LAMA这一类可以去下载权重自己部署的开源模型,
2:37.569–2:38.394
zh不是一回事。
2:38.394–2:39.908
zh它更像是一种模型服务,
2:39.908–2:41.422
zh你把材料和问题发给它,
2:41.422–2:42.798
zh它把决策结果反回来。
2:42.798–2:43.624
zh那第三问题,
2:43.624–2:45.138
zh就是它能不能去携代码。
2:45.138–2:45.638
zh首先,
2:45.638–2:47.477
zh它不能替你去写Python,
2:47.477–2:48.440
zh不能生成网页,
2:48.440–2:50.505
zh也不能帮你写邮件或者营销文案。
2:50.505–2:51.330
zh更准确的讲,
2:51.330–2:53.394
zh它就没有自由文本生成这个能力。
2:53.394–2:53.894
zh但呢,
2:53.894–2:55.596
zh这不代表它和编程没有关系。
2:55.596–2:58.073
zh一个编程agent在执行任务的时候,
2:58.073–3:00.000
zh可能要不断的判断下一步该对,
3:00.000–3:00.928
zh读哪个文件,
3:00.928–3:02.165
zh该掉用哪个工具,
3:02.165–3:03.402
zh测试是不是通过,
3:03.402–3:04.639
zh要不要继续修改。
3:04.639–3:06.495
zh那Jeff不能生成代码,
3:06.495–3:08.814
zh但可以去参与这些流程里的选择。
3:08.814–3:10.825
zh所以他不是一个写代码的人,
3:10.825–3:13.608
zh更像是站在流程里面去做不断分流的人。
3:13.608–3:16.082
zh这也能解释他为什么就突然火起来。
3:16.082–3:18.402
zh你看过去大家评价一个新的模型,
3:18.402–3:20.258
zh习惯会看他会不会写代码,
3:20.258–3:21.495
zh数学能力有多强,
3:21.495–3:22.887
zh推理链到底有多长。
3:22.887–3:25.515
zh而Jeff反过来去做了另一件事情,
3:25.515–3:27.526
zh他主动放弃自由的文本生成,
3:27.526–3:28.454
zh只优化判断,
3:28.454–3:29.227
zh优化选择,
3:29.227–3:30.000
zh优化打分。
3:30.000–3:33.053
zh他正好击中了agent正在遇到的一个现实问题。
3:33.053–3:36.239
zh我们经常会看到一个agent最后生成了一份报告,
3:36.239–3:37.832
zh好像他只完成了一次任务,
3:37.832–3:40.487
zh但这个过程中他可能做了成千上百次的选择。
3:40.487–3:42.345
zh比如说这条搜索结果有没有用,
3:42.345–3:44.867
zh这两份资料是不是在重复表达同一个观点,
3:44.867–3:46.062
zh现在的信息够不够,
3:46.062–3:47.389
zh下一步应该掉用工具,
3:47.389–3:48.451
zh还是开始去写作,
3:48.451–3:50.177
zh这段结论有没有证据的支持。
3:50.177–3:53.628
zh如果每一个小判断都需要去掉用一次非常强的通用大模型,
3:53.628–3:55.221
zh延迟和成本会一层层累积。
3:55.221–3:56.018
zh更麻烦的是,
3:56.018–3:58.009
zh大模型明明只需要返回一个选项,
3:58.009–3:59.336
zh但可能会顺手的减法,
3:59.336–4:00.000
zh但他正好击
4:00.000–4:03.484
zh写一段解释或者输出一个不完全符合要求的json。
4:03.484–4:04.355
zh那jef呢,
4:04.355–4:07.114
zh试图就是把这些小的判断单独拿出来解决。
4:07.114–4:08.420
zh所以这么一看下来,
4:08.420–4:09.727
zh其实我们就知道了,
4:09.727–4:11.178
zh他第一个优势就是快。
4:11.178–4:13.501
zh按照type safe公开的信息,
4:13.501–4:16.695
zhjef处理一次决策通常需要70-500毫秒。
4:16.695–4:18.002
zh对于浏览器的操作、
4:18.002–4:18.727
zh实时审核、
4:18.727–4:21.050
zhagent路由这类连续决策任务,
4:21.050–4:23.373
zh这个差别会直接影响到产品体验了。
4:23.373–4:23.873
zh好,
4:23.873–4:24.680
zh第二个优势呢,
4:24.680–4:25.405
zh就是便宜。
4:25.405–4:29.180
zh官方价格大约是每百万输入的token是4.2美分啊。
4:29.180–4:31.620
zh单次调用省下来的钱可能没那么明显,
4:31.620–4:34.778
zh但当系统每天都需要完成几万次几十万次判断时,
4:34.778–4:36.644
zh成本差距就会无限的被放大。
4:36.644–4:38.367
zh第三个优势就是输出稳定。
4:38.367–4:40.663
zh如果开发者只给出了5个候选选项,
4:40.663–4:42.960
zh他就只会在这5个选项里返回结果,
4:42.960–4:44.969
zh不会突然说创造出第6个答案,
4:44.969–4:48.127
zh也不需要程序再从一段自然语言里面去提取结论。
4:48.127–4:49.993
zh但这里一定要区分两件事情,
4:49.993–4:52.577
zh输出格式稳定不等于判断是一定正确的。
4:52.577–4:54.730
zhjef不会在格式上去胡乱发挥,
4:54.730–4:56.309
zh但他在这些什么情况下,
4:56.309–4:56.883
zh就是说,
4:56.883–4:59.180
zh如果开发者只给出了5个候选项,他
4:59.180–5:01.596
zh完全可能在合法选项里面去选错,
5:01.596–5:03.530
zh所谓不产生自由闻闻幻觉,
5:03.530–5:04.980
zh解决的是接口问题,
5:04.980–5:06.429
zh不是准确性的问题。
5:06.429–5:08.685
zh第4个优势就是它会返回概率。
5:08.685–5:11.424
zh普通分类器往往只告诉你答案是什么,
5:11.424–5:14.323
zh那jef希望去把置信程度也交给程序,
5:14.323–5:16.740
zh这样系统就可以设计不同的策略,
5:16.740–5:17.545
zh把握很高,
5:17.545–5:18.995
zh而且操作风险很低,
5:18.995–5:20.123
zh可以自动执行。
5:20.123–5:20.928
zh把握一般,
5:20.928–5:23.184
zh那就交给更强的大模型做复合,
5:23.184–5:24.150
zh把握太低的,
5:24.150–5:25.761
zh或者涉及到退款付款,
5:25.761–5:27.533
zh商库这类高风险动作的,
5:27.533–5:28.500
zh就转给人工。
5:28.500–5:30.938
zh另外,jef还可以读取一次材料,
5:30.938–5:33.071
zh同时回答多个相互独立的问题。
5:33.071–5:34.595
zh还是前面的客服消息,
5:34.595–5:36.424
zh他可以同时判断用户意图,
5:36.424–5:36.924
zh情绪,
5:36.924–5:37.643
zh紧急程度,
5:37.643–5:39.167
zh和是否需要人工介入,
5:39.167–5:41.300
zh不用反复的去读取一段上下文。
5:41.300–5:43.352
zhOK,那这条路线到底对还是不对?
5:43.352–5:44.250
zh其实我的理解,
5:44.250–5:45.532
zh在他适合的任务里面,
5:45.532–5:46.943
zh这条路线肯定是成立的,
5:46.943–5:48.866
zh大原模型通常要采用自回归生成,
5:48.866–5:50.277
zh他需要一个token,
5:50.277–5:52.073
zh接着一个token生成答案。
5:52.073–5:52.842
zh这个机制呢,
5:52.842–5:53.740
zh给予了他协作,
5:53.740–5:55.279
zh编程和开放式推理的能力,
5:55.279–5:57.074
zh但如果程序只需要一个不而直,
5:57.074–5:58.100
zh或者一个没举项,
5:58.100–5:59.993
zh完整走一遍文本生成的流程,
5:59.993–6:00.867
zh确实比较重。
6:00.867–6:03.197
zh而jef把输出空间提前的限制住,
6:03.197–6:04.653
zh不再去生成任意文字,
6:04.653–6:06.983
zh而是直接围绕候选答案去计算概率,
6:06.983–6:08.585
zh他失去了自由表达能力,
6:08.585–6:10.333
zh也因此换来了更低的延迟,
6:10.333–6:11.207
zh更低的成本,
6:11.207–6:13.100
zh和更容易被代码处理的结果。
6:13.100–6:15.203
zh但他也不是所谓问题的答案,
6:15.203–6:17.144
zh如果任务需要长链条推理,
6:17.144–6:18.276
zh需要精确计算,
6:18.276–6:20.218
zh需要理解复杂的日期关系,
6:20.218–6:22.321
zh或者需要模型给出完整理由,
6:22.321–6:24.100
zhjef都不是合适选择。
6:24.100–6:25.972
zh他的官方文档也明确提出,
6:25.972–6:28.311
zh他在算术记住日期比较多部推理,
6:28.311–6:31.274
zh以及包含大量无关信息的任务上存在短板,
6:31.274–6:34.082
zh他同样可能也会受到提示词注入的影响。
6:34.082–6:35.953
zh所以讨论这条路线的时候,
6:35.953–6:38.917
zh我觉得不能问jef和cloud更聪明,
6:38.917–6:41.100
zh他们解决的就不是同一种问题。
6:41.100–6:43.900
zhcloud和gbt擅长的是开放式任务,
6:43.900–6:46.111
zh传统分类模型适合类别长期固定,
6:46.111–6:46.847
zh数据充足,
6:46.847–6:48.321
zh可以专门训练的任务,
6:48.321–6:49.647
zh那jef想占据的,
6:49.647–6:50.826
zh其实中间那一层,
6:50.826–6:52.447
zh问题由开发者临时定义,
6:52.447–6:55.100
zh但输出必须限制在明确的类型和选项里。
6:55.100–6:57.016
zh这一层以前经常交给大模型,
6:57.016–6:59.816
zh现在终于有人开始为他单独去设计模型了。
6:59.816–7:03.647
zh另外开发者也已经在尝试把jef放进不少的场景里面了,
7:03.647–7:04.532
zh想客服系统,
7:04.532–7:05.711
zh来判断用户意图,
7:05.711–7:07.184
zh把消息转到查询订单,
7:07.184–7:07.684
zh退款,
7:07.684–7:08.184
zh投诉,
7:08.184–7:09.100
zh或者人工客服。
7:09.100–7:12.460
zh其他系统可以用他先来判断检查回来的资料到底是不是相关的,
7:12.460–7:13.540
zh先过滤掉无关内容,
7:13.540–7:15.100
zh再把剩下的材料交给大模型。
7:15.100–7:17.218
zh内容平台也可以用他来做垃圾信息,
7:17.218–7:17.879
zh辱骂内容,
7:17.879–7:19.203
zh风险文本的前置判断。
7:19.203–7:22.115
zhagent可以用他来选择下一步调用哪个工具,
7:22.115–7:23.041
zh或者决定任务,
7:23.041–7:24.100
zh是不是已经完整。
7:24.100–7:28.778
zhBlozer Use 社区还做了一个jef ultrafast浏览器agent。
7:28.778–7:31.813
zhjef负责从网页元素去选择该点击的按钮和输入框,
7:31.813–7:33.962
zh只有遇到真实需要填写的文字的时候,
7:33.962–7:35.100
zh才去调用生成模型。
7:35.100–7:40.100
zh他们的结果呢,一次疏离室到伦敦的航班搜索演示,只用了7.1秒。
7:40.100–7:43.298
zhType Safe自己也演示过让jef去玩Doom。
7:43.298–7:44.449
zh输入不是游戏画面,
7:44.449–7:45.088
zh而是血量、
7:45.088–7:45.728
zh敌人位置、
7:45.728–7:47.774
zh弹药数量等已经整理好的游戏状态。
7:47.774–7:49.821
zhjef不断从有限动作中去做选择,
7:49.821–7:51.100
zh实现每秒的多次决策。
7:51.100–7:52.884
zh这些案例表面上差别很大,
7:52.884–7:54.519
zh但他们其实有个共同点,
7:54.519–7:55.559
zh任务边界清楚,
7:55.559–7:56.600
zh后选动作明确,
7:56.600–7:57.641
zh请求频率很高,
7:57.641–7:59.870
zh而且程序不需要一段漂亮的文字,
7:59.870–8:02.100
zh只需要知道下一步到底该做什么。
8:02.100–8:04.100
zh这个才是jef真正适合的位置。
8:04.100–8:04.978
zh如果你想自己上手,
8:04.978–8:05.856
zh流程其实也不复杂,
8:05.856–8:08.978
zh可以直接去用Type Safe提供的Pregground和API,
8:08.978–8:12.100
zh也可以通过VSL AI Gateway或者CloudFair去调用。
8:12.100–8:13.946
zh一次请求里主要可以放两个东西,
8:13.946–8:15.054
zh一份是State,
8:15.054–8:17.023
zh也就是模型做判断需要看到的材料,
8:17.023–8:18.746
zh另一份是Questions,
8:18.746–8:20.100
zh也就是你希望他回答了。
8:20.100–8:23.100
zh也就是你希望他回答了问题,候选选项,或者评分范围。
8:23.100–8:24.833
zhjef读完State以后,
8:24.833–8:26.700
zh会返回每个问题的答案和概率,
8:26.700–8:29.100
zh你的程序再根据概率去决定下一个动作。
8:29.100–8:35.100
zh不过真正困难的地方,往往不是API的接通,而是去把你的问题给定义清楚。
8:35.100–8:37.100
zh还是那句话,我买的东西一个星期没到,现在不想要了。
8:37.100–8:42.100
zh如果选项只有物流的延迟和申请退款,知道单选题本身就设计得太好。
8:42.100–8:46.100
zh物流延迟是原因,申请退款是诉求,它们可以同时成立。
8:46.100–8:48.742
zh模型不会提开发者修复一套混乱的业务标准,
8:48.742–8:49.930
zh给他的信息不完整,
8:49.930–8:50.723
zh问题不明确,
8:50.723–8:51.911
zh或者选项互相重叠,
8:51.911–8:53.100
zh速度再快也没有用。
8:53.100–8:57.100
zh所以比较稳妥的使用方法就是先选择一个范围很小,答案比较清楚的任务。
8:57.100–8:59.784
zh哪一批已经有人工处理过的历史数据,
8:59.784–9:01.363
zh让jef在旁边运行,
9:01.363–9:03.100
zh暂时不要参加真实操作。
9:03.100–9:04.715
zh观察他在哪些任务上稳定、
9:04.715–9:06.735
zh智信度和真实正确率是不是匹配,
9:06.735–9:08.350
zh再根据风险设定自动通过,
9:08.350–9:10.100
zh模型复合和人工处理的预知。
9:10.100–9:14.100
zh低风险,高频,可设销的动作,可以更积极地去做状况。
9:14.100–9:19.100
zh而退款,资金,权限和删除数据这些操作,仍然去保留代码规则和人工审批。
9:19.100–9:24.100
zh所以我认为,jef真正有意思的地方,不只是说把原本的一次调查做便宜了。
9:24.100–9:28.100
zh他可能让原本因为成本太高而没有发生的判断,开始大量出现。
9:28.100–9:30.691
zh当然更多判断不一定自动带来更好的结果,
9:30.691–9:32.055
zh如果标准本身就错了,
9:32.055–9:34.100
zh系统值在更快更便宜的重复错误。
9:34.100–9:39.100
zh但我始终认为jef至少提出了一个很值得观察的方向。
9:39.100–9:41.569
zh未来的软件未必需要一个模型包办所有事情,
9:41.569–9:43.051
zh复杂推理可以交给强模型,
9:43.051–9:44.409
zh内容生成交给生成模型,
9:44.409–9:45.520
zh范围明确的小判断,
9:45.520–9:47.495
zh再去交给jef这一类的决策模型,
9:47.495–9:49.100
zh再配合代码规则和人工审核。
9:49.100–9:50.177
zh不是每一道题,
9:50.177–9:51.715
zh都需要一皮A篇作文,
9:51.715–9:54.792
zh有些时候程序员真正需要的只是一个足够快,
9:54.792–9:55.562
zh带着概率,
9:55.562–9:57.100
zh可以立刻执行的答案。
0:00.000–0:02.349
最近,硅谷出了一个非常特别的模型,
0:02.349–0:03.316
叫做JEFF。
0:03.316–0:04.145
他发布以后,
0:04.145–0:05.803
很快就在开发者圈里刷屏。
0:05.803–0:07.599
但如果只看网上的随便信息,
0:07.599–0:08.980
很容易产生两个误解。
0:08.980–0:09.947
第一个误解是,
0:09.947–0:14.092
JEFF又是一个准备去挑战CHIGBT Cloud的全能模型。
0:14.092–0:15.197
另一个误解就是,
0:15.197–0:17.131
他不就是一个普通的分类器吗?
0:17.131–0:18.927
为什么突然有这么多人讨论?
0:18.927–0:19.427
所以,
0:19.427–0:20.309
今天这期内容,
0:20.309–0:22.934
我把整个JEFF的来龙去脉都梳理一遍。
0:22.934–0:25.145
然后想从八个方面给大家去讲清楚。
0:25.145–0:25.697
第一个,
0:25.697–0:27.079
JEFF到底是什么?
0:27.079–0:27.631
第二个,
0:27.631–0:28.598
他开源了没有?
0:28.598–0:29.151
第三个,
0:29.151–0:29.980
能不能写的?
0:30.000–0:31.831
第四个,为什么突然就火了?
0:31.831–0:32.394
第五个,
0:32.394–0:33.521
他的优势在哪里?
0:33.521–0:34.085
第六个,
0:34.085–0:35.915
这条技术路线到底成不成立?
0:35.915–0:36.479
第七个,
0:36.479–0:38.451
开发者现在想用它来去做什么?
0:38.451–0:39.014
第八个,
0:39.014–0:40.141
如果你想试一试,
0:40.141–0:41.268
又该怎么去上手?
0:41.268–0:41.768
首先,
0:41.768–0:44.930
如果理解JEFF可以从我经常推荐的一本书讲起,
0:44.930–0:47.465
就是丹尼尔·卡尼曼的《思考快与曼》。
0:47.465–0:47.965
书里,
0:47.965–0:50.141
他把人的思考方式分成了两套系统。
0:50.141–0:51.690
系统一负责去快速判断,
0:51.690–0:53.239
看到前面有东西飞过来,
0:53.239–0:54.930
我们可能就本能的会躲开,
0:54.930–0:56.197
看到一个人的表情,
0:56.197–0:58.592
我们就能很快的判断他是不是生气了。
0:58.592–1:00.000
而系统二负责的是慢,
1:00.000–1:01.370
做一道复杂的数学题,
1:01.370–1:02.603
分析一份商业计划,
1:02.603–1:04.247
或者权衡一个重要的决定,
1:04.247–1:05.890
都需要去投入更多的注意。
1:05.890–1:06.575
过去几年,
1:06.575–1:09.315
大模型的发展其实主要都在不断的加强系统,
1:09.315–1:11.096
模型要学会去理解复杂问题,
1:11.096–1:11.781
展开推理,
1:11.781–1:12.466
量用工具,
1:12.466–1:14.110
然后生成一段完整的答案。
1:14.110–1:16.438
而TypeSafe提出的问题就是,
1:16.438–1:19.589
一个AI系统里的每一步都需要这样的认证思考吗?
1:19.589–1:22.055
很多时候程序需要的其实不是一篇文章,
1:22.055–1:23.014
而是一个判断,
1:23.014–1:24.932
这个就是JEFF出现的原因。
1:24.932–1:28.493
TypeSafe把它叫做System-1 Model,
1:28.493–1:30.000
也就是这个屏幕上写的。
1:30.000–1:30.914
这个名字呢,
1:30.914–1:32.893
就借鉴了思考快一慢的概念,
1:32.893–1:34.873
但更多的是一种产品的类比,
1:34.873–1:36.853
它并不是说复现了人的直觉,
1:36.853–1:38.985
而是专门去处理那些范围明确,
1:38.985–1:40.812
需要快速完成判断的任务。
1:40.812–1:44.924
你可以把JEFF理解成一个专门去给程序使用的决策模型。
1:44.924–1:45.838
穿透大模型,
1:45.838–1:46.904
接受一段文字,
1:46.904–1:48.426
然后继续去生成文字。
1:48.426–1:49.492
那JEFF呢,
1:49.492–1:52.234
接受一段材料和几个体型定义好的问题,
1:52.234–1:53.299
返回的是选项,
1:53.299–1:53.909
是分数,
1:53.909–1:55.127
以及相应的概率。
1:55.127–1:55.736
比如说,
1:55.736–1:56.954
用户发来一句话,
1:56.954–1:58.934
我买的东西一个星期还没到,
1:58.934–2:00.000
现在不想要了。
2:00.000–2:00.708
去写回复,
2:00.708–2:02.406
而是需要搞清楚几件事情。
2:02.406–2:03.821
这个用户是在查物流,
2:03.821–2:04.953
还是在准备退款。
2:04.953–2:06.085
情绪是不是激烈,
2:06.085–2:07.642
要不要去转给人工客服?
2:07.642–2:08.491
JEFF呢,
2:08.491–2:10.896
会从开发者给定的选项里面去做选择,
2:10.896–2:13.302
并且告诉程序每一个答案有多大概率,
2:13.302–2:14.717
那程序拿到结果以后,
2:14.717–2:16.557
就可以继续执行对应的流程。
2:16.557–2:17.057
所以,
2:17.057–2:19.387
有一句话就可以很直观的去概括它了。
2:19.387–2:21.226
CHATGPT负责写答案,
2:21.226–2:22.783
JEFF负责去做判断。
2:22.783–2:23.283
OK,
2:23.283–2:24.198
那第二个问题,
2:24.198–2:25.613
JEFF开源了没有?
2:25.613–2:26.604
目前是没有的。
2:26.604–2:28.019
Type Safe呢,
2:28.019–2:30.000
没有公开JEFF的模型权重,
2:30.000–2:30.826
和核心实现,
2:30.826–2:31.514
开发者呢,
2:31.514–2:33.716
主要还是通过云端API去调用它。
2:33.716–2:37.569
所以它和LAMA这一类可以去下载权重自己部署的开源模型,
2:37.569–2:38.394
不是一回事。
2:38.394–2:39.908
它更像是一种模型服务,
2:39.908–2:41.422
你把材料和问题发给它,
2:41.422–2:42.798
它把决策结果反回来。
2:42.798–2:43.624
那第三问题,
2:43.624–2:45.138
就是它能不能去携代码。
2:45.138–2:45.638
首先,
2:45.638–2:47.477
它不能替你去写Python,
2:47.477–2:48.440
不能生成网页,
2:48.440–2:50.505
也不能帮你写邮件或者营销文案。
2:50.505–2:51.330
更准确的讲,
2:51.330–2:53.394
它就没有自由文本生成这个能力。
2:53.394–2:53.894
但呢,
2:53.894–2:55.596
这不代表它和编程没有关系。
2:55.596–2:58.073
一个编程agent在执行任务的时候,
2:58.073–3:00.000
可能要不断的判断下一步该对,
3:00.000–3:00.928
读哪个文件,
3:00.928–3:02.165
该掉用哪个工具,
3:02.165–3:03.402
测试是不是通过,
3:03.402–3:04.639
要不要继续修改。
3:04.639–3:06.495
那Jeff不能生成代码,
3:06.495–3:08.814
但可以去参与这些流程里的选择。
3:08.814–3:10.825
所以他不是一个写代码的人,
3:10.825–3:13.608
更像是站在流程里面去做不断分流的人。
3:13.608–3:16.082
这也能解释他为什么就突然火起来。
3:16.082–3:18.402
你看过去大家评价一个新的模型,
3:18.402–3:20.258
习惯会看他会不会写代码,
3:20.258–3:21.495
数学能力有多强,
3:21.495–3:22.887
推理链到底有多长。
3:22.887–3:25.515
而Jeff反过来去做了另一件事情,
3:25.515–3:27.526
他主动放弃自由的文本生成,
3:27.526–3:28.454
只优化判断,
3:28.454–3:29.227
优化选择,
3:29.227–3:30.000
优化打分。
3:30.000–3:33.053
他正好击中了agent正在遇到的一个现实问题。
3:33.053–3:36.239
我们经常会看到一个agent最后生成了一份报告,
3:36.239–3:37.832
好像他只完成了一次任务,
3:37.832–3:40.487
但这个过程中他可能做了成千上百次的选择。
3:40.487–3:42.345
比如说这条搜索结果有没有用,
3:42.345–3:44.867
这两份资料是不是在重复表达同一个观点,
3:44.867–3:46.062
现在的信息够不够,
3:46.062–3:47.389
下一步应该掉用工具,
3:47.389–3:48.451
还是开始去写作,
3:48.451–3:50.177
这段结论有没有证据的支持。
3:50.177–3:53.628
如果每一个小判断都需要去掉用一次非常强的通用大模型,
3:53.628–3:55.221
延迟和成本会一层层累积。
3:55.221–3:56.018
更麻烦的是,
3:56.018–3:58.009
大模型明明只需要返回一个选项,
3:58.009–3:59.336
但可能会顺手的减法,
3:59.336–4:00.000
但他正好击
4:00.000–4:03.484
写一段解释或者输出一个不完全符合要求的json。
4:03.484–4:04.355
那jef呢,
4:04.355–4:07.114
试图就是把这些小的判断单独拿出来解决。
4:07.114–4:08.420
所以这么一看下来,
4:08.420–4:09.727
其实我们就知道了,
4:09.727–4:11.178
他第一个优势就是快。
4:11.178–4:13.501
按照type safe公开的信息,
4:13.501–4:16.695
jef处理一次决策通常需要70-500毫秒。
4:16.695–4:18.002
对于浏览器的操作、
4:18.002–4:18.727
实时审核、
4:18.727–4:21.050
agent路由这类连续决策任务,
4:21.050–4:23.373
这个差别会直接影响到产品体验了。
4:23.373–4:23.873
好,
4:23.873–4:24.680
第二个优势呢,
4:24.680–4:25.405
就是便宜。
4:25.405–4:29.180
官方价格大约是每百万输入的token是4.2美分啊。
4:29.180–4:31.620
单次调用省下来的钱可能没那么明显,
4:31.620–4:34.778
但当系统每天都需要完成几万次几十万次判断时,
4:34.778–4:36.644
成本差距就会无限的被放大。
4:36.644–4:38.367
第三个优势就是输出稳定。
4:38.367–4:40.663
如果开发者只给出了5个候选选项,
4:40.663–4:42.960
他就只会在这5个选项里返回结果,
4:42.960–4:44.969
不会突然说创造出第6个答案,
4:44.969–4:48.127
也不需要程序再从一段自然语言里面去提取结论。
4:48.127–4:49.993
但这里一定要区分两件事情,
4:49.993–4:52.577
输出格式稳定不等于判断是一定正确的。
4:52.577–4:54.730
jef不会在格式上去胡乱发挥,
4:54.730–4:56.309
但他在这些什么情况下,
4:56.309–4:56.883
就是说,
4:56.883–4:59.180
如果开发者只给出了5个候选项,他
4:59.180–5:01.596
完全可能在合法选项里面去选错,
5:01.596–5:03.530
所谓不产生自由闻闻幻觉,
5:03.530–5:04.980
解决的是接口问题,
5:04.980–5:06.429
不是准确性的问题。
5:06.429–5:08.685
第4个优势就是它会返回概率。
5:08.685–5:11.424
普通分类器往往只告诉你答案是什么,
5:11.424–5:14.323
那jef希望去把置信程度也交给程序,
5:14.323–5:16.740
这样系统就可以设计不同的策略,
5:16.740–5:17.545
把握很高,
5:17.545–5:18.995
而且操作风险很低,
5:18.995–5:20.123
可以自动执行。
5:20.123–5:20.928
把握一般,
5:20.928–5:23.184
那就交给更强的大模型做复合,
5:23.184–5:24.150
把握太低的,
5:24.150–5:25.761
或者涉及到退款付款,
5:25.761–5:27.533
商库这类高风险动作的,
5:27.533–5:28.500
就转给人工。
5:28.500–5:30.938
另外,jef还可以读取一次材料,
5:30.938–5:33.071
同时回答多个相互独立的问题。
5:33.071–5:34.595
还是前面的客服消息,
5:34.595–5:36.424
他可以同时判断用户意图,
5:36.424–5:36.924
情绪,
5:36.924–5:37.643
紧急程度,
5:37.643–5:39.167
和是否需要人工介入,
5:39.167–5:41.300
不用反复的去读取一段上下文。
5:41.300–5:43.352
OK,那这条路线到底对还是不对?
5:43.352–5:44.250
其实我的理解,
5:44.250–5:45.532
在他适合的任务里面,
5:45.532–5:46.943
这条路线肯定是成立的,
5:46.943–5:48.866
大原模型通常要采用自回归生成,
5:48.866–5:50.277
他需要一个token,
5:50.277–5:52.073
接着一个token生成答案。
5:52.073–5:52.842
这个机制呢,
5:52.842–5:53.740
给予了他协作,
5:53.740–5:55.279
编程和开放式推理的能力,
5:55.279–5:57.074
但如果程序只需要一个不而直,
5:57.074–5:58.100
或者一个没举项,
5:58.100–5:59.993
完整走一遍文本生成的流程,
5:59.993–6:00.867
确实比较重。
6:00.867–6:03.197
而jef把输出空间提前的限制住,
6:03.197–6:04.653
不再去生成任意文字,
6:04.653–6:06.983
而是直接围绕候选答案去计算概率,
6:06.983–6:08.585
他失去了自由表达能力,
6:08.585–6:10.333
也因此换来了更低的延迟,
6:10.333–6:11.207
更低的成本,
6:11.207–6:13.100
和更容易被代码处理的结果。
6:13.100–6:15.203
但他也不是所谓问题的答案,
6:15.203–6:17.144
如果任务需要长链条推理,
6:17.144–6:18.276
需要精确计算,
6:18.276–6:20.218
需要理解复杂的日期关系,
6:20.218–6:22.321
或者需要模型给出完整理由,
6:22.321–6:24.100
jef都不是合适选择。
6:24.100–6:25.972
他的官方文档也明确提出,
6:25.972–6:28.311
他在算术记住日期比较多部推理,
6:28.311–6:31.274
以及包含大量无关信息的任务上存在短板,
6:31.274–6:34.082
他同样可能也会受到提示词注入的影响。
6:34.082–6:35.953
所以讨论这条路线的时候,
6:35.953–6:38.917
我觉得不能问jef和cloud更聪明,
6:38.917–6:41.100
他们解决的就不是同一种问题。
6:41.100–6:43.900
cloud和gbt擅长的是开放式任务,
6:43.900–6:46.111
传统分类模型适合类别长期固定,
6:46.111–6:46.847
数据充足,
6:46.847–6:48.321
可以专门训练的任务,
6:48.321–6:49.647
那jef想占据的,
6:49.647–6:50.826
其实中间那一层,
6:50.826–6:52.447
问题由开发者临时定义,
6:52.447–6:55.100
但输出必须限制在明确的类型和选项里。
6:55.100–6:57.016
这一层以前经常交给大模型,
6:57.016–6:59.816
现在终于有人开始为他单独去设计模型了。
6:59.816–7:03.647
另外开发者也已经在尝试把jef放进不少的场景里面了,
7:03.647–7:04.532
想客服系统,
7:04.532–7:05.711
来判断用户意图,
7:05.711–7:07.184
把消息转到查询订单,
7:07.184–7:07.684
退款,
7:07.684–7:08.184
投诉,
7:08.184–7:09.100
或者人工客服。
7:09.100–7:12.460
其他系统可以用他先来判断检查回来的资料到底是不是相关的,
7:12.460–7:13.540
先过滤掉无关内容,
7:13.540–7:15.100
再把剩下的材料交给大模型。
7:15.100–7:17.218
内容平台也可以用他来做垃圾信息,
7:17.218–7:17.879
辱骂内容,
7:17.879–7:19.203
风险文本的前置判断。
7:19.203–7:22.115
agent可以用他来选择下一步调用哪个工具,
7:22.115–7:23.041
或者决定任务,
7:23.041–7:24.100
是不是已经完整。
7:24.100–7:28.778
Blozer Use 社区还做了一个jef ultrafast浏览器agent。
7:28.778–7:31.813
jef负责从网页元素去选择该点击的按钮和输入框,
7:31.813–7:33.962
只有遇到真实需要填写的文字的时候,
7:33.962–7:35.100
才去调用生成模型。
7:35.100–7:40.100
他们的结果呢,一次疏离室到伦敦的航班搜索演示,只用了7.1秒。
7:40.100–7:43.298
Type Safe自己也演示过让jef去玩Doom。
7:43.298–7:44.449
输入不是游戏画面,
7:44.449–7:45.088
而是血量、
7:45.088–7:45.728
敌人位置、
7:45.728–7:47.774
弹药数量等已经整理好的游戏状态。
7:47.774–7:49.821
jef不断从有限动作中去做选择,
7:49.821–7:51.100
实现每秒的多次决策。
7:51.100–7:52.884
这些案例表面上差别很大,
7:52.884–7:54.519
但他们其实有个共同点,
7:54.519–7:55.559
任务边界清楚,
7:55.559–7:56.600
后选动作明确,
7:56.600–7:57.641
请求频率很高,
7:57.641–7:59.870
而且程序不需要一段漂亮的文字,
7:59.870–8:02.100
只需要知道下一步到底该做什么。
8:02.100–8:04.100
这个才是jef真正适合的位置。
8:04.100–8:04.978
如果你想自己上手,
8:04.978–8:05.856
流程其实也不复杂,
8:05.856–8:08.978
可以直接去用Type Safe提供的Pregground和API,
8:08.978–8:12.100
也可以通过VSL AI Gateway或者CloudFair去调用。
8:12.100–8:13.946
一次请求里主要可以放两个东西,
8:13.946–8:15.054
一份是State,
8:15.054–8:17.023
也就是模型做判断需要看到的材料,
8:17.023–8:18.746
另一份是Questions,
8:18.746–8:20.100
也就是你希望他回答了。
8:20.100–8:23.100
也就是你希望他回答了问题,候选选项,或者评分范围。
8:23.100–8:24.833
jef读完State以后,
8:24.833–8:26.700
会返回每个问题的答案和概率,
8:26.700–8:29.100
你的程序再根据概率去决定下一个动作。
8:29.100–8:35.100
不过真正困难的地方,往往不是API的接通,而是去把你的问题给定义清楚。
8:35.100–8:37.100
还是那句话,我买的东西一个星期没到,现在不想要了。
8:37.100–8:42.100
如果选项只有物流的延迟和申请退款,知道单选题本身就设计得太好。
8:42.100–8:46.100
物流延迟是原因,申请退款是诉求,它们可以同时成立。
8:46.100–8:48.742
模型不会提开发者修复一套混乱的业务标准,
8:48.742–8:49.930
给他的信息不完整,
8:49.930–8:50.723
问题不明确,
8:50.723–8:51.911
或者选项互相重叠,
8:51.911–8:53.100
速度再快也没有用。
8:53.100–8:57.100
所以比较稳妥的使用方法就是先选择一个范围很小,答案比较清楚的任务。
8:57.100–8:59.784
哪一批已经有人工处理过的历史数据,
8:59.784–9:01.363
让jef在旁边运行,
9:01.363–9:03.100
暂时不要参加真实操作。
9:03.100–9:04.715
观察他在哪些任务上稳定、
9:04.715–9:06.735
智信度和真实正确率是不是匹配,
9:06.735–9:08.350
再根据风险设定自动通过,
9:08.350–9:10.100
模型复合和人工处理的预知。
9:10.100–9:14.100
低风险,高频,可设销的动作,可以更积极地去做状况。
9:14.100–9:19.100
而退款,资金,权限和删除数据这些操作,仍然去保留代码规则和人工审批。
9:19.100–9:24.100
所以我认为,jef真正有意思的地方,不只是说把原本的一次调查做便宜了。
9:24.100–9:28.100
他可能让原本因为成本太高而没有发生的判断,开始大量出现。
9:28.100–9:30.691
当然更多判断不一定自动带来更好的结果,
9:30.691–9:32.055
如果标准本身就错了,
9:32.055–9:34.100
系统值在更快更便宜的重复错误。
9:34.100–9:39.100
但我始终认为jef至少提出了一个很值得观察的方向。
9:39.100–9:41.569
未来的软件未必需要一个模型包办所有事情,
9:41.569–9:43.051
复杂推理可以交给强模型,
9:43.051–9:44.409
内容生成交给生成模型,
9:44.409–9:45.520
范围明确的小判断,
9:45.520–9:47.495
再去交给jef这一类的决策模型,
9:47.495–9:49.100
再配合代码规则和人工审核。
9:49.100–9:50.177
不是每一道题,
9:50.177–9:51.715
都需要一皮A篇作文,
9:51.715–9:54.792
有些时候程序员真正需要的只是一个足够快,
9:54.792–9:55.562
带着概率,
9:55.562–9:57.100
可以立刻执行的答案。
0:00.000–0:02.349
zh最近,硅谷出了一个非常特别的模型,
最近,硅谷出了一个非常特别的模型,
0:02.349–0:03.316
zh叫做JEFF。
叫做JEFF。
0:03.316–0:04.145
zh他发布以后,
他发布以后,
0:04.145–0:05.803
zh很快就在开发者圈里刷屏。
很快就在开发者圈里刷屏。
0:05.803–0:07.599
zh但如果只看网上的随便信息,
但如果只看网上的随便信息,
0:07.599–0:08.980
zh很容易产生两个误解。
很容易产生两个误解。
0:08.980–0:09.947
zh第一个误解是,
第一个误解是,
0:09.947–0:14.092
zhJEFF又是一个准备去挑战CHIGBT Cloud的全能模型。
JEFF又是一个准备去挑战CHIGBT Cloud的全能模型。
0:14.092–0:15.197
zh另一个误解就是,
另一个误解就是,
0:15.197–0:17.131
zh他不就是一个普通的分类器吗?
他不就是一个普通的分类器吗?
0:17.131–0:18.927
zh为什么突然有这么多人讨论?
为什么突然有这么多人讨论?
0:18.927–0:19.427
zh所以,
所以,
0:19.427–0:20.309
zh今天这期内容,
今天这期内容,
0:20.309–0:22.934
zh我把整个JEFF的来龙去脉都梳理一遍。
我把整个JEFF的来龙去脉都梳理一遍。
0:22.934–0:25.145
zh然后想从八个方面给大家去讲清楚。
然后想从八个方面给大家去讲清楚。
0:25.145–0:25.697
zh第一个,
第一个,
0:25.697–0:27.079
zhJEFF到底是什么?
JEFF到底是什么?
0:27.079–0:27.631
zh第二个,
第二个,
0:27.631–0:28.598
zh他开源了没有?
他开源了没有?
0:28.598–0:29.151
zh第三个,
第三个,
0:29.151–0:29.980
zh能不能写的?
能不能写的?
0:30.000–0:31.831
zh第四个,为什么突然就火了?
第四个,为什么突然就火了?
0:31.831–0:32.394
zh第五个,
第五个,
0:32.394–0:33.521
zh他的优势在哪里?
他的优势在哪里?
0:33.521–0:34.085
zh第六个,
第六个,
0:34.085–0:35.915
zh这条技术路线到底成不成立?
这条技术路线到底成不成立?
0:35.915–0:36.479
zh第七个,
第七个,
0:36.479–0:38.451
zh开发者现在想用它来去做什么?
开发者现在想用它来去做什么?
0:38.451–0:39.014
zh第八个,
第八个,
0:39.014–0:40.141
zh如果你想试一试,
如果你想试一试,
0:40.141–0:41.268
zh又该怎么去上手?
又该怎么去上手?
0:41.268–0:41.768
zh首先,
首先,
0:41.768–0:44.930
zh如果理解JEFF可以从我经常推荐的一本书讲起,
如果理解JEFF可以从我经常推荐的一本书讲起,
0:44.930–0:47.465
zh就是丹尼尔·卡尼曼的《思考快与曼》。
就是丹尼尔·卡尼曼的《思考快与曼》。
0:47.465–0:47.965
zh书里,
书里,
0:47.965–0:50.141
zh他把人的思考方式分成了两套系统。
他把人的思考方式分成了两套系统。
0:50.141–0:51.690
zh系统一负责去快速判断,
系统一负责去快速判断,
0:51.690–0:53.239
zh看到前面有东西飞过来,
看到前面有东西飞过来,
0:53.239–0:54.930
zh我们可能就本能的会躲开,
我们可能就本能的会躲开,
0:54.930–0:56.197
zh看到一个人的表情,
看到一个人的表情,
0:56.197–0:58.592
zh我们就能很快的判断他是不是生气了。
我们就能很快的判断他是不是生气了。
0:58.592–1:00.000
zh而系统二负责的是慢,
而系统二负责的是慢,
1:00.000–1:01.370
zh做一道复杂的数学题,
做一道复杂的数学题,
1:01.370–1:02.603
zh分析一份商业计划,
分析一份商业计划,
1:02.603–1:04.247
zh或者权衡一个重要的决定,
或者权衡一个重要的决定,
1:04.247–1:05.890
zh都需要去投入更多的注意。
都需要去投入更多的注意。
1:05.890–1:06.575
zh过去几年,
过去几年,
1:06.575–1:09.315
zh大模型的发展其实主要都在不断的加强系统,
大模型的发展其实主要都在不断的加强系统,
1:09.315–1:11.096
zh模型要学会去理解复杂问题,
模型要学会去理解复杂问题,
1:11.096–1:11.781
zh展开推理,
展开推理,
1:11.781–1:12.466
zh量用工具,
量用工具,
1:12.466–1:14.110
zh然后生成一段完整的答案。
然后生成一段完整的答案。
1:14.110–1:16.438
zh而TypeSafe提出的问题就是,
而TypeSafe提出的问题就是,
1:16.438–1:19.589
zh一个AI系统里的每一步都需要这样的认证思考吗?
一个AI系统里的每一步都需要这样的认证思考吗?
1:19.589–1:22.055
zh很多时候程序需要的其实不是一篇文章,
很多时候程序需要的其实不是一篇文章,
1:22.055–1:23.014
zh而是一个判断,
而是一个判断,
1:23.014–1:24.932
zh这个就是JEFF出现的原因。
这个就是JEFF出现的原因。
1:24.932–1:28.493
zhTypeSafe把它叫做System-1 Model,
TypeSafe把它叫做System-1 Model,
1:28.493–1:30.000
zh也就是这个屏幕上写的。
也就是这个屏幕上写的。
1:30.000–1:30.914
zh这个名字呢,
这个名字呢,
1:30.914–1:32.893
zh就借鉴了思考快一慢的概念,
就借鉴了思考快一慢的概念,
1:32.893–1:34.873
zh但更多的是一种产品的类比,
但更多的是一种产品的类比,
1:34.873–1:36.853
zh它并不是说复现了人的直觉,
它并不是说复现了人的直觉,
1:36.853–1:38.985
zh而是专门去处理那些范围明确,
而是专门去处理那些范围明确,
1:38.985–1:40.812
zh需要快速完成判断的任务。
需要快速完成判断的任务。
1:40.812–1:44.924
zh你可以把JEFF理解成一个专门去给程序使用的决策模型。
你可以把JEFF理解成一个专门去给程序使用的决策模型。
1:44.924–1:45.838
zh穿透大模型,
穿透大模型,
1:45.838–1:46.904
zh接受一段文字,
接受一段文字,
1:46.904–1:48.426
zh然后继续去生成文字。
然后继续去生成文字。
1:48.426–1:49.492
zh那JEFF呢,
那JEFF呢,
1:49.492–1:52.234
zh接受一段材料和几个体型定义好的问题,
接受一段材料和几个体型定义好的问题,
1:52.234–1:53.299
zh返回的是选项,
返回的是选项,
1:53.299–1:53.909
zh是分数,
是分数,
1:53.909–1:55.127
zh以及相应的概率。
以及相应的概率。
1:55.127–1:55.736
zh比如说,
比如说,
1:55.736–1:56.954
zh用户发来一句话,
用户发来一句话,
1:56.954–1:58.934
zh我买的东西一个星期还没到,
我买的东西一个星期还没到,
1:58.934–2:00.000
zh现在不想要了。
现在不想要了。
2:00.000–2:00.708
zh去写回复,
去写回复,
2:00.708–2:02.406
zh而是需要搞清楚几件事情。
而是需要搞清楚几件事情。
2:02.406–2:03.821
zh这个用户是在查物流,
这个用户是在查物流,
2:03.821–2:04.953
zh还是在准备退款。
还是在准备退款。
2:04.953–2:06.085
zh情绪是不是激烈,
情绪是不是激烈,
2:06.085–2:07.642
zh要不要去转给人工客服?
要不要去转给人工客服?
2:07.642–2:08.491
zhJEFF呢,
JEFF呢,
2:08.491–2:10.896
zh会从开发者给定的选项里面去做选择,
会从开发者给定的选项里面去做选择,
2:10.896–2:13.302
zh并且告诉程序每一个答案有多大概率,
并且告诉程序每一个答案有多大概率,
2:13.302–2:14.717
zh那程序拿到结果以后,
那程序拿到结果以后,
2:14.717–2:16.557
zh就可以继续执行对应的流程。
就可以继续执行对应的流程。
2:16.557–2:17.057
zh所以,
所以,
2:17.057–2:19.387
zh有一句话就可以很直观的去概括它了。
有一句话就可以很直观的去概括它了。
2:19.387–2:21.226
zhCHATGPT负责写答案,
CHATGPT负责写答案,
2:21.226–2:22.783
zhJEFF负责去做判断。
JEFF负责去做判断。
2:22.783–2:23.283
enOK,
OK,
2:23.283–2:24.198
zh那第二个问题,
那第二个问题,
2:24.198–2:25.613
zhJEFF开源了没有?
JEFF开源了没有?
2:25.613–2:26.604
zh目前是没有的。
目前是没有的。
2:26.604–2:28.019
zhType Safe呢,
Type Safe呢,
2:28.019–2:30.000
zh没有公开JEFF的模型权重,
没有公开JEFF的模型权重,
2:30.000–2:30.826
zh和核心实现,
和核心实现,
2:30.826–2:31.514
zh开发者呢,
开发者呢,
2:31.514–2:33.716
zh主要还是通过云端API去调用它。
主要还是通过云端API去调用它。
2:33.716–2:37.569
zh所以它和LAMA这一类可以去下载权重自己部署的开源模型,
所以它和LAMA这一类可以去下载权重自己部署的开源模型,
2:37.569–2:38.394
zh不是一回事。
不是一回事。
2:38.394–2:39.908
zh它更像是一种模型服务,
它更像是一种模型服务,
2:39.908–2:41.422
zh你把材料和问题发给它,
你把材料和问题发给它,
2:41.422–2:42.798
zh它把决策结果反回来。
它把决策结果反回来。
2:42.798–2:43.624
zh那第三问题,
那第三问题,
2:43.624–2:45.138
zh就是它能不能去携代码。
就是它能不能去携代码。
2:45.138–2:45.638
zh首先,
首先,
2:45.638–2:47.477
zh它不能替你去写Python,
它不能替你去写Python,
2:47.477–2:48.440
zh不能生成网页,
不能生成网页,
2:48.440–2:50.505
zh也不能帮你写邮件或者营销文案。
也不能帮你写邮件或者营销文案。
2:50.505–2:51.330
zh更准确的讲,
更准确的讲,
2:51.330–2:53.394
zh它就没有自由文本生成这个能力。
它就没有自由文本生成这个能力。
2:53.394–2:53.894
zh但呢,
但呢,
2:53.894–2:55.596
zh这不代表它和编程没有关系。
这不代表它和编程没有关系。
2:55.596–2:58.073
zh一个编程agent在执行任务的时候,
一个编程agent在执行任务的时候,
2:58.073–3:00.000
zh可能要不断的判断下一步该对,
可能要不断的判断下一步该对,
3:00.000–3:00.928
zh读哪个文件,
读哪个文件,
3:00.928–3:02.165
zh该掉用哪个工具,
该掉用哪个工具,
3:02.165–3:03.402
zh测试是不是通过,
测试是不是通过,
3:03.402–3:04.639
zh要不要继续修改。
要不要继续修改。
3:04.639–3:06.495
zh那Jeff不能生成代码,
那Jeff不能生成代码,
3:06.495–3:08.814
zh但可以去参与这些流程里的选择。
但可以去参与这些流程里的选择。
3:08.814–3:10.825
zh所以他不是一个写代码的人,
所以他不是一个写代码的人,
3:10.825–3:13.608
zh更像是站在流程里面去做不断分流的人。
更像是站在流程里面去做不断分流的人。
3:13.608–3:16.082
zh这也能解释他为什么就突然火起来。
这也能解释他为什么就突然火起来。
3:16.082–3:18.402
zh你看过去大家评价一个新的模型,
你看过去大家评价一个新的模型,
3:18.402–3:20.258
zh习惯会看他会不会写代码,
习惯会看他会不会写代码,
3:20.258–3:21.495
zh数学能力有多强,
数学能力有多强,
3:21.495–3:22.887
zh推理链到底有多长。
推理链到底有多长。
3:22.887–3:25.515
zh而Jeff反过来去做了另一件事情,
而Jeff反过来去做了另一件事情,
3:25.515–3:27.526
zh他主动放弃自由的文本生成,
他主动放弃自由的文本生成,
3:27.526–3:28.454
zh只优化判断,
只优化判断,
3:28.454–3:29.227
zh优化选择,
优化选择,
3:29.227–3:30.000
zh优化打分。
优化打分。
3:30.000–3:33.053
zh他正好击中了agent正在遇到的一个现实问题。
他正好击中了agent正在遇到的一个现实问题。
3:33.053–3:36.239
zh我们经常会看到一个agent最后生成了一份报告,
我们经常会看到一个agent最后生成了一份报告,
3:36.239–3:37.832
zh好像他只完成了一次任务,
好像他只完成了一次任务,
3:37.832–3:40.487
zh但这个过程中他可能做了成千上百次的选择。
但这个过程中他可能做了成千上百次的选择。
3:40.487–3:42.345
zh比如说这条搜索结果有没有用,
比如说这条搜索结果有没有用,
3:42.345–3:44.867
zh这两份资料是不是在重复表达同一个观点,
这两份资料是不是在重复表达同一个观点,
3:44.867–3:46.062
zh现在的信息够不够,
现在的信息够不够,
3:46.062–3:47.389
zh下一步应该掉用工具,
下一步应该掉用工具,
3:47.389–3:48.451
zh还是开始去写作,
还是开始去写作,
3:48.451–3:50.177
zh这段结论有没有证据的支持。
这段结论有没有证据的支持。
3:50.177–3:53.628
zh如果每一个小判断都需要去掉用一次非常强的通用大模型,
如果每一个小判断都需要去掉用一次非常强的通用大模型,
3:53.628–3:55.221
zh延迟和成本会一层层累积。
延迟和成本会一层层累积。
3:55.221–3:56.018
zh更麻烦的是,
更麻烦的是,
3:56.018–3:58.009
zh大模型明明只需要返回一个选项,
大模型明明只需要返回一个选项,
3:58.009–3:59.336
zh但可能会顺手的减法,
但可能会顺手的减法,
3:59.336–4:00.000
zh但他正好击
但他正好击
4:00.000–4:03.484
zh写一段解释或者输出一个不完全符合要求的json。
写一段解释或者输出一个不完全符合要求的json。
4:03.484–4:04.355
zh那jef呢,
那jef呢,
4:04.355–4:07.114
zh试图就是把这些小的判断单独拿出来解决。
试图就是把这些小的判断单独拿出来解决。
4:07.114–4:08.420
zh所以这么一看下来,
所以这么一看下来,
4:08.420–4:09.727
zh其实我们就知道了,
其实我们就知道了,
4:09.727–4:11.178
zh他第一个优势就是快。
他第一个优势就是快。
4:11.178–4:13.501
zh按照type safe公开的信息,
按照type safe公开的信息,
4:13.501–4:16.695
zhjef处理一次决策通常需要70-500毫秒。
jef处理一次决策通常需要70-500毫秒。
4:16.695–4:18.002
zh对于浏览器的操作、
对于浏览器的操作、
4:18.002–4:18.727
zh实时审核、
实时审核、
4:18.727–4:21.050
zhagent路由这类连续决策任务,
agent路由这类连续决策任务,
4:21.050–4:23.373
zh这个差别会直接影响到产品体验了。
这个差别会直接影响到产品体验了。
4:23.373–4:23.873
zh好,
好,
4:23.873–4:24.680
zh第二个优势呢,
第二个优势呢,
4:24.680–4:25.405
zh就是便宜。
就是便宜。
4:25.405–4:29.180
zh官方价格大约是每百万输入的token是4.2美分啊。
官方价格大约是每百万输入的token是4.2美分啊。
4:29.180–4:31.620
zh单次调用省下来的钱可能没那么明显,
单次调用省下来的钱可能没那么明显,
4:31.620–4:34.778
zh但当系统每天都需要完成几万次几十万次判断时,
但当系统每天都需要完成几万次几十万次判断时,
4:34.778–4:36.644
zh成本差距就会无限的被放大。
成本差距就会无限的被放大。
4:36.644–4:38.367
zh第三个优势就是输出稳定。
第三个优势就是输出稳定。
4:38.367–4:40.663
zh如果开发者只给出了5个候选选项,
如果开发者只给出了5个候选选项,
4:40.663–4:42.960
zh他就只会在这5个选项里返回结果,
他就只会在这5个选项里返回结果,
4:42.960–4:44.969
zh不会突然说创造出第6个答案,
不会突然说创造出第6个答案,
4:44.969–4:48.127
zh也不需要程序再从一段自然语言里面去提取结论。
也不需要程序再从一段自然语言里面去提取结论。
4:48.127–4:49.993
zh但这里一定要区分两件事情,
但这里一定要区分两件事情,
4:49.993–4:52.577
zh输出格式稳定不等于判断是一定正确的。
输出格式稳定不等于判断是一定正确的。
4:52.577–4:54.730
zhjef不会在格式上去胡乱发挥,
jef不会在格式上去胡乱发挥,
4:54.730–4:56.309
zh但他在这些什么情况下,
但他在这些什么情况下,
4:56.309–4:56.883
zh就是说,
就是说,
4:56.883–4:59.180
zh如果开发者只给出了5个候选项,他
如果开发者只给出了5个候选项,他
4:59.180–5:01.596
zh完全可能在合法选项里面去选错,
完全可能在合法选项里面去选错,
5:01.596–5:03.530
zh所谓不产生自由闻闻幻觉,
所谓不产生自由闻闻幻觉,
5:03.530–5:04.980
zh解决的是接口问题,
解决的是接口问题,
5:04.980–5:06.429
zh不是准确性的问题。
不是准确性的问题。
5:06.429–5:08.685
zh第4个优势就是它会返回概率。
第4个优势就是它会返回概率。
5:08.685–5:11.424
zh普通分类器往往只告诉你答案是什么,
普通分类器往往只告诉你答案是什么,
5:11.424–5:14.323
zh那jef希望去把置信程度也交给程序,
那jef希望去把置信程度也交给程序,
5:14.323–5:16.740
zh这样系统就可以设计不同的策略,
这样系统就可以设计不同的策略,
5:16.740–5:17.545
zh把握很高,
把握很高,
5:17.545–5:18.995
zh而且操作风险很低,
而且操作风险很低,
5:18.995–5:20.123
zh可以自动执行。
可以自动执行。
5:20.123–5:20.928
zh把握一般,
把握一般,
5:20.928–5:23.184
zh那就交给更强的大模型做复合,
那就交给更强的大模型做复合,
5:23.184–5:24.150
zh把握太低的,
把握太低的,
5:24.150–5:25.761
zh或者涉及到退款付款,
或者涉及到退款付款,
5:25.761–5:27.533
zh商库这类高风险动作的,
商库这类高风险动作的,
5:27.533–5:28.500
zh就转给人工。
就转给人工。
5:28.500–5:30.938
zh另外,jef还可以读取一次材料,
另外,jef还可以读取一次材料,
5:30.938–5:33.071
zh同时回答多个相互独立的问题。
同时回答多个相互独立的问题。
5:33.071–5:34.595
zh还是前面的客服消息,
还是前面的客服消息,
5:34.595–5:36.424
zh他可以同时判断用户意图,
他可以同时判断用户意图,
5:36.424–5:36.924
zh情绪,
情绪,
5:36.924–5:37.643
zh紧急程度,
紧急程度,
5:37.643–5:39.167
zh和是否需要人工介入,
和是否需要人工介入,
5:39.167–5:41.300
zh不用反复的去读取一段上下文。
不用反复的去读取一段上下文。
5:41.300–5:43.352
zhOK,那这条路线到底对还是不对?
OK,那这条路线到底对还是不对?
5:43.352–5:44.250
zh其实我的理解,
其实我的理解,
5:44.250–5:45.532
zh在他适合的任务里面,
在他适合的任务里面,
5:45.532–5:46.943
zh这条路线肯定是成立的,
这条路线肯定是成立的,
5:46.943–5:48.866
zh大原模型通常要采用自回归生成,
大原模型通常要采用自回归生成,
5:48.866–5:50.277
zh他需要一个token,
他需要一个token,
5:50.277–5:52.073
zh接着一个token生成答案。
接着一个token生成答案。
5:52.073–5:52.842
zh这个机制呢,
这个机制呢,
5:52.842–5:53.740
zh给予了他协作,
给予了他协作,
5:53.740–5:55.279
zh编程和开放式推理的能力,
编程和开放式推理的能力,
5:55.279–5:57.074
zh但如果程序只需要一个不而直,
但如果程序只需要一个不而直,
5:57.074–5:58.100
zh或者一个没举项,
或者一个没举项,
5:58.100–5:59.993
zh完整走一遍文本生成的流程,
完整走一遍文本生成的流程,
5:59.993–6:00.867
zh确实比较重。
确实比较重。
6:00.867–6:03.197
zh而jef把输出空间提前的限制住,
而jef把输出空间提前的限制住,
6:03.197–6:04.653
zh不再去生成任意文字,
不再去生成任意文字,
6:04.653–6:06.983
zh而是直接围绕候选答案去计算概率,
而是直接围绕候选答案去计算概率,
6:06.983–6:08.585
zh他失去了自由表达能力,
他失去了自由表达能力,
6:08.585–6:10.333
zh也因此换来了更低的延迟,
也因此换来了更低的延迟,
6:10.333–6:11.207
zh更低的成本,
更低的成本,
6:11.207–6:13.100
zh和更容易被代码处理的结果。
和更容易被代码处理的结果。
6:13.100–6:15.203
zh但他也不是所谓问题的答案,
但他也不是所谓问题的答案,
6:15.203–6:17.144
zh如果任务需要长链条推理,
如果任务需要长链条推理,
6:17.144–6:18.276
zh需要精确计算,
需要精确计算,
6:18.276–6:20.218
zh需要理解复杂的日期关系,
需要理解复杂的日期关系,
6:20.218–6:22.321
zh或者需要模型给出完整理由,
或者需要模型给出完整理由,
6:22.321–6:24.100
zhjef都不是合适选择。
jef都不是合适选择。
6:24.100–6:25.972
zh他的官方文档也明确提出,
他的官方文档也明确提出,
6:25.972–6:28.311
zh他在算术记住日期比较多部推理,
他在算术记住日期比较多部推理,
6:28.311–6:31.274
zh以及包含大量无关信息的任务上存在短板,
以及包含大量无关信息的任务上存在短板,
6:31.274–6:34.082
zh他同样可能也会受到提示词注入的影响。
他同样可能也会受到提示词注入的影响。
6:34.082–6:35.953
zh所以讨论这条路线的时候,
所以讨论这条路线的时候,
6:35.953–6:38.917
zh我觉得不能问jef和cloud更聪明,
我觉得不能问jef和cloud更聪明,
6:38.917–6:41.100
zh他们解决的就不是同一种问题。
他们解决的就不是同一种问题。
6:41.100–6:43.900
zhcloud和gbt擅长的是开放式任务,
cloud和gbt擅长的是开放式任务,
6:43.900–6:46.111
zh传统分类模型适合类别长期固定,
传统分类模型适合类别长期固定,
6:46.111–6:46.847
zh数据充足,
数据充足,
6:46.847–6:48.321
zh可以专门训练的任务,
可以专门训练的任务,
6:48.321–6:49.647
zh那jef想占据的,
那jef想占据的,
6:49.647–6:50.826
zh其实中间那一层,
其实中间那一层,
6:50.826–6:52.447
zh问题由开发者临时定义,
问题由开发者临时定义,
6:52.447–6:55.100
zh但输出必须限制在明确的类型和选项里。
但输出必须限制在明确的类型和选项里。
6:55.100–6:57.016
zh这一层以前经常交给大模型,
这一层以前经常交给大模型,
6:57.016–6:59.816
zh现在终于有人开始为他单独去设计模型了。
现在终于有人开始为他单独去设计模型了。
6:59.816–7:03.647
zh另外开发者也已经在尝试把jef放进不少的场景里面了,
另外开发者也已经在尝试把jef放进不少的场景里面了,
7:03.647–7:04.532
zh想客服系统,
想客服系统,
7:04.532–7:05.711
zh来判断用户意图,
来判断用户意图,
7:05.711–7:07.184
zh把消息转到查询订单,
把消息转到查询订单,
7:07.184–7:07.684
zh退款,
退款,
7:07.684–7:08.184
zh投诉,
投诉,
7:08.184–7:09.100
zh或者人工客服。
或者人工客服。
7:09.100–7:12.460
zh其他系统可以用他先来判断检查回来的资料到底是不是相关的,
其他系统可以用他先来判断检查回来的资料到底是不是相关的,
7:12.460–7:13.540
zh先过滤掉无关内容,
先过滤掉无关内容,
7:13.540–7:15.100
zh再把剩下的材料交给大模型。
再把剩下的材料交给大模型。
7:15.100–7:17.218
zh内容平台也可以用他来做垃圾信息,
内容平台也可以用他来做垃圾信息,
7:17.218–7:17.879
zh辱骂内容,
辱骂内容,
7:17.879–7:19.203
zh风险文本的前置判断。
风险文本的前置判断。
7:19.203–7:22.115
zhagent可以用他来选择下一步调用哪个工具,
agent可以用他来选择下一步调用哪个工具,
7:22.115–7:23.041
zh或者决定任务,
或者决定任务,
7:23.041–7:24.100
zh是不是已经完整。
是不是已经完整。
7:24.100–7:28.778
zhBlozer Use 社区还做了一个jef ultrafast浏览器agent。
Blozer Use 社区还做了一个jef ultrafast浏览器agent。
7:28.778–7:31.813
zhjef负责从网页元素去选择该点击的按钮和输入框,
jef负责从网页元素去选择该点击的按钮和输入框,
7:31.813–7:33.962
zh只有遇到真实需要填写的文字的时候,
只有遇到真实需要填写的文字的时候,
7:33.962–7:35.100
zh才去调用生成模型。
才去调用生成模型。
7:35.100–7:40.100
zh他们的结果呢,一次疏离室到伦敦的航班搜索演示,只用了7.1秒。
他们的结果呢,一次疏离室到伦敦的航班搜索演示,只用了7.1秒。
7:40.100–7:43.298
zhType Safe自己也演示过让jef去玩Doom。
Type Safe自己也演示过让jef去玩Doom。
7:43.298–7:44.449
zh输入不是游戏画面,
输入不是游戏画面,
7:44.449–7:45.088
zh而是血量、
而是血量、
7:45.088–7:45.728
zh敌人位置、
敌人位置、
7:45.728–7:47.774
zh弹药数量等已经整理好的游戏状态。
弹药数量等已经整理好的游戏状态。
7:47.774–7:49.821
zhjef不断从有限动作中去做选择,
jef不断从有限动作中去做选择,
7:49.821–7:51.100
zh实现每秒的多次决策。
实现每秒的多次决策。
7:51.100–7:52.884
zh这些案例表面上差别很大,
这些案例表面上差别很大,
7:52.884–7:54.519
zh但他们其实有个共同点,
但他们其实有个共同点,
7:54.519–7:55.559
zh任务边界清楚,
任务边界清楚,
7:55.559–7:56.600
zh后选动作明确,
后选动作明确,
7:56.600–7:57.641
zh请求频率很高,
请求频率很高,
7:57.641–7:59.870
zh而且程序不需要一段漂亮的文字,
而且程序不需要一段漂亮的文字,
7:59.870–8:02.100
zh只需要知道下一步到底该做什么。
只需要知道下一步到底该做什么。
8:02.100–8:04.100
zh这个才是jef真正适合的位置。
这个才是jef真正适合的位置。
8:04.100–8:04.978
zh如果你想自己上手,
如果你想自己上手,
8:04.978–8:05.856
zh流程其实也不复杂,
流程其实也不复杂,
8:05.856–8:08.978
zh可以直接去用Type Safe提供的Pregground和API,
可以直接去用Type Safe提供的Pregground和API,
8:08.978–8:12.100
zh也可以通过VSL AI Gateway或者CloudFair去调用。
也可以通过VSL AI Gateway或者CloudFair去调用。
8:12.100–8:13.946
zh一次请求里主要可以放两个东西,
一次请求里主要可以放两个东西,
8:13.946–8:15.054
zh一份是State,
一份是State,
8:15.054–8:17.023
zh也就是模型做判断需要看到的材料,
也就是模型做判断需要看到的材料,
8:17.023–8:18.746
zh另一份是Questions,
另一份是Questions,
8:18.746–8:20.100
zh也就是你希望他回答了。
也就是你希望他回答了。
8:20.100–8:23.100
zh也就是你希望他回答了问题,候选选项,或者评分范围。
也就是你希望他回答了问题,候选选项,或者评分范围。
8:23.100–8:24.833
zhjef读完State以后,
jef读完State以后,
8:24.833–8:26.700
zh会返回每个问题的答案和概率,
会返回每个问题的答案和概率,
8:26.700–8:29.100
zh你的程序再根据概率去决定下一个动作。
你的程序再根据概率去决定下一个动作。
8:29.100–8:35.100
zh不过真正困难的地方,往往不是API的接通,而是去把你的问题给定义清楚。
不过真正困难的地方,往往不是API的接通,而是去把你的问题给定义清楚。
8:35.100–8:37.100
zh还是那句话,我买的东西一个星期没到,现在不想要了。
还是那句话,我买的东西一个星期没到,现在不想要了。
8:37.100–8:42.100
zh如果选项只有物流的延迟和申请退款,知道单选题本身就设计得太好。
如果选项只有物流的延迟和申请退款,知道单选题本身就设计得太好。
8:42.100–8:46.100
zh物流延迟是原因,申请退款是诉求,它们可以同时成立。
物流延迟是原因,申请退款是诉求,它们可以同时成立。
8:46.100–8:48.742
zh模型不会提开发者修复一套混乱的业务标准,
模型不会提开发者修复一套混乱的业务标准,
8:48.742–8:49.930
zh给他的信息不完整,
给他的信息不完整,
8:49.930–8:50.723
zh问题不明确,
问题不明确,
8:50.723–8:51.911
zh或者选项互相重叠,
或者选项互相重叠,
8:51.911–8:53.100
zh速度再快也没有用。
速度再快也没有用。
8:53.100–8:57.100
zh所以比较稳妥的使用方法就是先选择一个范围很小,答案比较清楚的任务。
所以比较稳妥的使用方法就是先选择一个范围很小,答案比较清楚的任务。
8:57.100–8:59.784
zh哪一批已经有人工处理过的历史数据,
哪一批已经有人工处理过的历史数据,
8:59.784–9:01.363
zh让jef在旁边运行,
让jef在旁边运行,
9:01.363–9:03.100
zh暂时不要参加真实操作。
暂时不要参加真实操作。
9:03.100–9:04.715
zh观察他在哪些任务上稳定、
观察他在哪些任务上稳定、
9:04.715–9:06.735
zh智信度和真实正确率是不是匹配,
智信度和真实正确率是不是匹配,
9:06.735–9:08.350
zh再根据风险设定自动通过,
再根据风险设定自动通过,
9:08.350–9:10.100
zh模型复合和人工处理的预知。
模型复合和人工处理的预知。
9:10.100–9:14.100
zh低风险,高频,可设销的动作,可以更积极地去做状况。
低风险,高频,可设销的动作,可以更积极地去做状况。
9:14.100–9:19.100
zh而退款,资金,权限和删除数据这些操作,仍然去保留代码规则和人工审批。
而退款,资金,权限和删除数据这些操作,仍然去保留代码规则和人工审批。
9:19.100–9:24.100
zh所以我认为,jef真正有意思的地方,不只是说把原本的一次调查做便宜了。
所以我认为,jef真正有意思的地方,不只是说把原本的一次调查做便宜了。
9:24.100–9:28.100
zh他可能让原本因为成本太高而没有发生的判断,开始大量出现。
他可能让原本因为成本太高而没有发生的判断,开始大量出现。
9:28.100–9:30.691
zh当然更多判断不一定自动带来更好的结果,
当然更多判断不一定自动带来更好的结果,
9:30.691–9:32.055
zh如果标准本身就错了,
如果标准本身就错了,
9:32.055–9:34.100
zh系统值在更快更便宜的重复错误。
系统值在更快更便宜的重复错误。
9:34.100–9:39.100
zh但我始终认为jef至少提出了一个很值得观察的方向。
但我始终认为jef至少提出了一个很值得观察的方向。
9:39.100–9:41.569
zh未来的软件未必需要一个模型包办所有事情,
未来的软件未必需要一个模型包办所有事情,
9:41.569–9:43.051
zh复杂推理可以交给强模型,
复杂推理可以交给强模型,
9:43.051–9:44.409
zh内容生成交给生成模型,
内容生成交给生成模型,
9:44.409–9:45.520
zh范围明确的小判断,
范围明确的小判断,
9:45.520–9:47.495
zh再去交给jef这一类的决策模型,
再去交给jef这一类的决策模型,
9:47.495–9:49.100
zh再配合代码规则和人工审核。
再配合代码规则和人工审核。
9:49.100–9:50.177
zh不是每一道题,
不是每一道题,
9:50.177–9:51.715
zh都需要一皮A篇作文,
都需要一皮A篇作文,
9:51.715–9:54.792
zh有些时候程序员真正需要的只是一个足够快,
有些时候程序员真正需要的只是一个足够快,
9:54.792–9:55.562
zh带着概率,
带着概率,
9:55.562–9:57.100
zh可以立刻执行的答案。
可以立刻执行的答案。

影片筆記:10分钟讲清楚火爆全网的JEV

<!-- VIDEONOTE_PUBLICATION_WARNINGS_BEGIN -->

⚠️ 可先使用,仍有待修正項目

本筆記已完成可閱讀的逐字稿與時間跳轉;下列為待處理問題,建議播放原片確認。

  • 待修正:逐字稿全文快速校讀未完成(已保留自動字幕/原始逐字稿並繼續生成筆記。;未完成的全文速讀項目可在精進模式回聽確認。)
  • 待修正:逐字稿可先使用,但有待校正清單(segment=161 unnatural_sentence_boundary: 標點出現在句首或停在逗號位置,斷句可能不符合文法/口語;segment=162 unnatural_sentence_boundary: 標點出現在句首或停在逗號位置,斷句可能不符合文法/口語)

<!-- VIDEONOTE_PUBLICATION_WARNINGS_END -->

一句話總結

影片解析了由 TypeSafe 推出的 AI 模型 JEFF,指出其並非通用生成模型,而是定位為 System-1 Model(系統一模型),專注於低延遲、低成本的判斷與決策任務(如分類、路由、打分),透過返回選項與概率協助程式分流,填補了開放式生成與傳統固定分類模型之間的市場空白。

核心重點

  1. 核心定位:System-1 Model
  • 借鑒丹尼爾·卡尼曼《思考快與慢》中的「系統一」概念,JEFF 被定義為處理快速、直覺判斷的模型。
  • 區別於 ChatGPT:ChatGPT 負責生成自由文本(寫答案),JEFF 負責做判斷(返回選項、分數或概率)。
  • 不生成代碼:JEFF 不能寫 Python、生成網頁或營銷文案,它不直接參與代碼生成,而是作為 Agent 執行任務時的「決策者」,負責流程分流。
  1. 技術優勢:快、便宜、穩定、帶概率
  • 速度極快:處理一次決策僅需 70-500 毫秒,適合瀏覽器操作、實時審核等高頻場景。
  • 成本低廉:官方價格約每百萬輸入 token 4.2 美分,高頻調用下成本優勢巨大。
  • 輸出穩定:若給定 5 個候選選項,僅返回這 5 個選項,不創造第 6 個答案,解決了通用模型可能輸出非標準 JSON 或解釋的問題。
  • 返回概率:提供置信程度,允許系統設計不同策略(高把握自動執行、一般把握交給強模型複合、低把握轉人工)。
  1. 應用場景與限制
  • 適用場景:客服意圖判斷、Agent 路由、內容預篩(垃圾信息、風險文本)、瀏覽器 Agent 操作分流。
  • 不適用場景:長鏈條推理、精確計算、理解複雜日期關係、需要完整理由的任務。
  • 市場定位:介於「開放式任務」(ChatGPT)與「傳統固定分類模型」(需大量數據訓練)之間,適合開發者臨時定義問題但輸出必須限制在明確類型和選項裡的場景。
  1. 未來架構展望
  • 未來軟體架構可能走向協同模式:強模型負責推理與生成,JEFF 此類決策模型負責快速判斷,並配合代碼規則和人工審核。
  • 核心觀點:不是每道題都需要一篇作文,程序員有時只需要一個足夠快、帶概率、可立即執行的答案。

詳細大綱

一、 JEFF 的定義與核心概念

  • 背景來源:借鑒丹尼爾·卡尼曼《思考快與慢》中的「系統一」(快速、直覺判斷)概念。
  • 核心定位:
  • 被 TypeSafe 定義為 System-1 Model。
  • 不是復現人類直覺,而是專門處理範圍明確、需快速完成判斷的任務。
  • 對比:ChatGPT 負責寫答案(生成文本),JEFF 負責做判斷(返回選項/分數/概率)。
  • 輸入輸出機制:
  • 輸入:材料(State)+ 定義好的問題/選項(Questions)。
  • 輸出:選項、分數、相應概率。
  • 示例:用戶發送「買的東西一週沒到,不想要了」,JEFF 判斷是查物流還是退款,情緒是否激烈,是否轉人工,並返回概率。

二、 開源狀態與調用方式

  • 開源情況:目前沒有開源。
  • TypeSafe 未公開模型權重和核心實現。
  • 開發者主要通過雲端 API 調用。
  • 性質區別:
  • 不同於 LAMA 等可下載權重自行部署的開源模型。
  • 更像是一種模型服務(Model Service)。

三、 代碼生成能力與 Agent 關係

  • 代碼生成:不能寫 Python、生成網頁、寫郵件或營銷文案。
  • 沒有自由文本生成能力。
  • 與編程/Agent 的關係:
  • 不直接生成代碼,但參與 Agent 執行任務時的流程選擇。
  • 角色定位:不是寫代碼的人,而是站在流程裡做不斷分流的「決策者」。
  • 解決 Agent 在讀文件、調用工具、測試結果時的判斷問題。

四、 走紅原因與優勢分析

  • 走紅原因:
  • 主動放棄自由文本生成,只優化判斷、選擇、打分。
  • 擊中 Agent 遇到的現實問題:通用大模型用於單一判斷時,延遲和成本過高,且可能輸出不符合要求的 JSON 或解釋。
  • 四大優勢:
  1. 快:處理一次決策需 70-500 毫秒,影響瀏覽器操作、實時審核、Agent 路由的產品體驗。
  2. 便宜:官方價格約每百萬輸入 token 4.2 美分,高頻調用下成本差距巨大。
  3. 輸出穩定:
  • 若給定 5 個候選選項,僅返回這 5 個選項,不創造第 6 個答案。
  • 區分:輸出格式穩定 ≠ 判斷一定正確。可能選錯,但解決的是「接口問題」而非「準確性問題」。
  1. 返回概率:
  • 提供置信程度,讓系統設計不同策略(高把握自動執行、一般把握交給強模型複合、低把握轉人工)。
  • 支持一次讀取材料,同時回答多個相互獨立的問題(如意圖、情緒、緊急程度、是否人工介入)。

五、 技術路線可行性與定位

  • 路線成立條件:
  • 適合任務邊界清楚、候選動作明確、請求頻率高的場景。
  • 不需要漂亮文字,只需知道下一步該做什麼。
  • 侷限性:
  • 不適合長鏈條推理、精確計算、理解複雜日期關係、需要完整理由的任務。
  • 官方文檔指出其在算術、日期、多步推理及包含大量無關信息任務上存在短板。
  • 可能受到提示詞注入影響。
  • 市場定位:
  • 非「更聰明」,而是解決不同問題。
  • ChatGPT/GPT:擅長開放式任務。
  • 傳統分類模型:適合類別長期固定、數據充足、可專門訓練的任務。
  • JEFF:佔據中間層——問題由開發者臨時定義,但輸出必須限制在明確類型和選項裡。

六、 開發者應用場景

  • 客服系統:判斷用戶意圖(查詢訂單、退款、投訴、人工客服)。
  • 其他系統:前置判斷檢查資料相關性,過濾無關內容後再交給大模型。
  • 內容平台:垃圾信息、辱罵內容、風險文本的前置判斷。
  • Agent:選擇下一步調用哪個工具,或決定任務是否完整。
  • 具體案例:
  • Blozer Use 社區:JEFF Ultrafast 瀏覽器 Agent。從網頁元素選擇點擊按鈕和輸入框,僅在需填寫文字時調用生成模型。演示搜索倫敦航班僅用 7.1 秒。
  • TypeSafe 演示:讓 JEFF 玩 Doom 遊戲。輸入整理好的遊戲狀態(血量、敵人位置、彈藥),從有限動作中選擇,實現每秒多次決策。

七、 上手指南與使用建議

  • 調用方式:
  • 使用 TypeSafe 提供的 Pregground 和 API。
  • 或通過 VSL AI Gateway 或 CloudFair 調用。
  • 請求結構:
  • State:模型做判斷需要看到的材料。
  • Questions:希望回答的問題、候選選項或評分範圍。
  • 核心難點:定義清楚問題。
  • 示例錯誤:選項僅設「物流延遲」和「申請退款」,但兩者可能同時成立,導致設計不佳。
  • 若信息不完整、問題不明確或選項重疊,速度再快也無用。
  • 穩妥使用方法:
  1. 選擇範圍小、答案清楚任務。
  2. 使用已有人工處理過的歷史數據,讓 JEFF 旁路運行,暫不參加真實操作。
  3. 觀察穩定性、智信度與真實正確率是否匹配。
  4. 根據風險設定策略:
  • 低風險、高頻、可撤銷動作:積極自動執行。
  • 退款、資金、權限、刪除數據:商庫這類高風險動作:保留代碼規則和人工審批。

八、 結論與未來展望

  • JEFF 的意義不僅在於降低調查成本,更在於讓原本因成本太高而未發生的判斷開始大量出現。
  • 更多判斷不一定帶來更好結果,若標準錯誤,系統會更快更便宜地重複錯誤。
  • 未來軟體架構方向:
  • 複雜推理:交給強模型。
  • 內容生成:交給生成模型。
  • 範圍明確的小判斷:交給 JEFF 此類決策模型。
  • 配合代碼規則和人工審核。
  • 核心觀點:不是每道題都需要一篇作文,程序員有時只需要一個足夠快、帶概率、可立即執行的答案。

工具 / 模型 / 名詞整理

  • JEFF:影片討論的核心模型,被稱為 System-1 Model。
  • TypeSafe:JEFF 的開發方/公司。
  • ChatGPT:被作為對比的全能生成模型。
  • CHIGBT Cloud:逐字稿中提及的潛在挑戰對象(疑點,可能指代特定雲端服務或模型,需查證)。
  • LAMA:逐字稿中提及的可下載權重開源模型類別(疑點,可能指 Llama 或其他,需查證)。
  • 丹尼爾·卡尼曼:《思考快與慢》作者,其理論被借鑒。
  • 《思考快與慢》:書籍名稱,區分系統一與系統二。
  • System-1 Model:JEFF 的技術定位名稱。
  • Pregground:TypeSafe 提供的調用平台或工具(疑點,需查證正確拼寫,可能為 Playground)。
  • VSL AI Gateway:調用 JEFF 的網關服務。
  • CloudFair:調用 JEFF 的網關服務(疑點,可能指 Cloudflare,需查證)。
  • Blozer Use:社區名稱,製作 JEFF Ultrafast 瀏覽器 Agent(疑點,可能指 Browser Use,需查證)。
  • JEFF Ultrafast:Blozer Use 社區基於 JEFF 製作的瀏覽器 Agent 名稱。
  • Doom:遊戲名稱,TypeSafe 演示 JEFF 玩遊戲的案例。

操作流程整理

  1. 準備輸入材料 (State):整理需要模型判斷的基礎數據(如用戶對話、網頁狀態、遊戲數據)。
  2. 定義問題與選項 (Questions):明確希望模型回答的問題,並設定固定的候選選項或評分範圍。
  • *注意*:選項設計需互斥或明確,避免重疊導致判斷失效。
  1. 調用 API:通過 TypeSafe API、Pregground 或第三方網關(如 VSL AI Gateway, CloudFair)發送請求。
  2. 接收輸出:獲取模型返回的選項、分數及對應的概率。
  3. 執行策略:
  • 高置信度:自動執行對應動作。
  • 中置信度:交給強模型(如 ChatGPT)進行複合判斷或生成。
  • 低置信度:轉交人工客服或保留代碼規則審批。
  1. 監控與優化:觀察穩定性、置信度與真實正確率的匹配情況,逐步將旁路運行的結果接入真實操作。

值得注意的限制或風險

  • 非通用模型:JEFF 不能生成自由文本,無法寫代碼或文案,僅限於判斷與決策。
  • 準確性不保證:輸出格式穩定不代表判斷正確,模型可能選錯,但解決的是接口一致性問題。
  • 特定任務短板:不適合長鏈條推理、精確計算、複雜日期關係理解及需要完整理由的任務。
  • 提示詞注入風險:可能受到提示詞注入的影響。
  • 標準錯誤風險:若判斷標準錯誤,系統會更快、更便宜地重複錯誤,因此高風險動作(如退款、刪除數據)仍需人工審批。

逐字稿辨識疑點

警告:以下片段存在可讀性檢核問題(標點斷句異常)或疑似辨識錯誤,請謹慎參考,不得視為確定事實。

  • 標點斷句異常片段:
  • Segment 161: unnatural_sentence_boundary — 標點出現在句首或停在逗號位置,斷句可能不符合文法/口語
  • Segment 162: unnatural_sentence_boundary — 標點出現在句首或停在逗號位置,斷句可能不符合文法/口語
  • Segment 275: unnatural_sentence_boundary — 標點出現在句首或停在逗號位置,斷句可能不符合文法/口語
  • Segment 276: unnatural_sentence_boundary — 標點出現在句首或停在逗號位置,斷句可能不符合文法/口語
  • Segment 314: unnatural_sentence_boundary — 標點出現在句首或停在逗號位置,斷句可能不符合文法/口語
  • 疑似名稱/詞彙辨識錯誤:
  • CHIGBT Cloud:逐字稿提及「挑戰 CHIGBT Cloud」,此名稱不常見,可能為聽寫錯誤或特定內部/新興產品,需查證。
  • LAMA:逐字稿提及「和 LAMA 這一類可以去下載權重自己部署的開源模型」,通常指代 Llama 系列或其他,需查證是否為特定模型名稱或聽誤。
  • Pregground:逐字稿提及「Type Safe 提供的 Pregground 和 API」,可能為拼寫錯誤,常見為「Playground」,需查證。
  • CloudFair:逐字稿提及「CloudFair 去調用」,可能為「Cloudflare」的聽誤或特定服務名稱,需查證。
  • Blozer Use:逐字稿提及「Blozer Use 社區」,可能為「Browser Use」的聽誤,需查證。
  • 一皮A篇作文:結尾處「不需要一皮A篇作文」,疑為「一篇作文」的聽寫錯誤。
  • 智信度:文中提及「穩定、智信度和真實正確率」,疑為「置信度」的聽寫錯誤。
  • 預知:文中提及「預知」,結合上下文可能指「預設」或「預警」,需查證。
  • 一而直:文中提及「只需要一個不而直」,疑為「一個選項」或類似詞彙的聽誤。
  • 沒舉項:文中提及「或者一個沒舉項」,疑為「一個選項」的聽誤。
  • 自由聞聞幻覺:文中提及「不產生自由聞聞幻覺」,疑為「自由文本幻覺」或類似概念的聽誤。
  • 减法:文中提及「順手的减法」,疑為「順手的解釋」或「順手的輸出」的聽誤。
  • 商庫:文中提及「商庫這類高風險動作」,疑為「商務」或「商城」的聽誤。
  • 一皮A篇:結尾「一皮A篇作文」,疑為「一篇作文」。

可延伸追問

  1. JEFF 的「System-1」定位在技術實現上與傳統小語言模型(SLM)或分類器有何具體架構差異?
  2. 在實際開發中,如何有效設計「Questions」參數以應對選項重疊或互斥性不足的問題?
  3. 對於高風險操作(如退款、刪除數據),如何結合 JEFF 的概率輸出與人工審批流程以平衡效率與安全?
  4. JEFF 的開源計劃何時公布?若開源,其權重大小與部署成本將如何影響其普及度?
  5. 除了客服和 Agent 路由,還有哪些高頻、低延遲的業務場景適合引入 JEFF 此類決策模型?

尚未產生學習筆記

請在 Telegram 指令最後加上「學習」,例如:videonote 網址 英文 雙語 學習