WEBVTT

00:00:00.000 --> 00:00:07.000
來,各位家人們,最近幾天,整個硅谷都被一款叫做Jill的模型刷屏了。

00:00:07.000 --> 00:00:14.000
然後呢,發布前三天已經被Wassel,Cloudflare,LongChang等主流平台迅速給集成了。

00:00:14.000 --> 00:00:16.000
這個模型有什麼特點呢?

00:00:16.000 --> 00:00:23.000
這款模型,它相比普通的模型推理速度,最高可以提升200倍,最高可以高到200倍。

00:00:23.000 --> 00:00:27.000
然後呢,這個成本可以降低,最高可以降到400倍。

00:00:27.000 --> 00:00:28.880
是一个非常非常恐怖的数字啊

00:00:28.880 --> 00:00:31.220
而且是可以组合的前沿之冷

00:00:31.220 --> 00:00:34.280
那么这种牛扮的东西到底是一个什么东西呢

00:00:34.280 --> 00:00:38.500
它会不会把open AI把这个Athrope给颠覆掉呢

00:00:38.500 --> 00:00:40.440
别张奇哈我们来认识一下

00:00:40.440 --> 00:00:41.380
J5这个模型

00:00:41.380 --> 00:00:44.260
那么J5这个模型呢一句话来干口啊

00:00:44.260 --> 00:00:46.020
J5呢是一个决策模型

00:00:46.020 --> 00:00:47.520
决策模型有什么特点呢

00:00:47.520 --> 00:00:48.800
它不生成文本

00:00:48.800 --> 00:00:50.360
不生成图片

00:00:50.360 --> 00:00:53.080
只做结果化判断输出概率

00:00:53.080 --> 00:00:54.500
也就是它只输出概率啊

00:00:54.500 --> 00:00:57.840
专门给agent的程序做高频快判断

00:00:57.840 --> 00:00:59.340
它是一个什么东西啊

00:00:59.340 --> 00:01:00.960
它其实是一个决策模型

00:01:00.960 --> 00:01:02.300
或者是一个判断模型

00:01:02.300 --> 00:01:05.500
它其实跟GPT跟Cloud

00:01:05.500 --> 00:01:07.620
跟GP9是有本质的区别的

00:01:07.620 --> 00:01:08.760
GPT这种模型呢

00:01:08.760 --> 00:01:10.180
其实是一个生成式模型

00:01:10.180 --> 00:01:11.220
生成文本

00:01:11.220 --> 00:01:12.180
生成图片

00:01:12.180 --> 00:01:15.100
但是GP呢只做决策

00:01:15.100 --> 00:01:16.960
它们是有本质的区别的

00:01:16.960 --> 00:01:18.340
所以它们之间并不是一个

00:01:18.340 --> 00:01:20.040
谁替代是这么一种关系

00:01:20.040 --> 00:01:21.820
还是一种互补的关系

00:01:21.820 --> 00:01:23.380
那么有种人讲

00:01:23.380 --> 00:01:25.540
现在是生成式的天下

00:01:25.540 --> 00:01:27.320
你这个东西有什么用呢

00:01:27.320 --> 00:01:28.960
这个生成式模型

00:01:28.960 --> 00:01:30.140
GPT

00:01:30.140 --> 00:01:31.140
Cloat

00:01:31.140 --> 00:01:33.100
真来也可以做决策对吧

00:01:33.100 --> 00:01:36.460
你这个Jill有什么特点呢

00:01:36.460 --> 00:01:36.820
对不对

00:01:36.820 --> 00:01:40.220
凭什么这么招扬

00:01:40.220 --> 00:01:40.600
是吧

00:01:40.600 --> 00:01:41.300
也别着急

00:01:41.300 --> 00:01:43.100
他其实有非常非常多的场景

00:01:43.100 --> 00:01:44.540
我们稍后会来进行介绍

00:01:44.540 --> 00:01:46.140
那我们再来看一下

00:01:46.140 --> 00:01:47.780
Jill这个模型到底是怎么来的

00:01:47.780 --> 00:01:49.080
这个模型呢

00:01:49.080 --> 00:01:50.060
其实是由

00:01:50.060 --> 00:01:52.720
前欧巴亚的研究员叫Digo

00:01:52.720 --> 00:01:56.200
他这个创办的TypeSafe AI公司

00:01:56.200 --> 00:01:58.120
在前几天发布的

00:01:58.120 --> 00:01:59.180
在9月15号发布的

00:01:59.180 --> 00:02:00.020
也前几天发布的

00:02:00.020 --> 00:02:01.400
那么这个创始人

00:02:01.400 --> 00:02:02.820
是非常非常厉害的一个人物

00:02:02.820 --> 00:02:05.160
他参与了ChairGPT的创造

00:02:05.160 --> 00:02:07.560
是一个非常非常有经验的

00:02:07.560 --> 00:02:08.900
这么一个大佬

00:02:08.900 --> 00:02:10.060
然后他自己呢

00:02:10.060 --> 00:02:12.940
就是说在创造完ChairGPT之后

00:02:12.940 --> 00:02:14.460
他一直在问自己一个问题

00:02:14.460 --> 00:02:16.640
就是说这些超人的聊天模型

00:02:16.640 --> 00:02:18.380
为什么没有带来这个AGI

00:02:18.380 --> 00:02:19.960
那过去的两年

00:02:19.960 --> 00:02:20.920
我一直在眼神

00:02:20.920 --> 00:02:21.940
抓大家做两件事情

00:02:21.940 --> 00:02:24.240
就是一种新的模型训练方法

00:02:24.240 --> 00:02:26.480
就是它提出了一种新的训练方法

00:02:26.480 --> 00:02:27.980
叫RLCD

00:02:27.980 --> 00:02:31.220
然后呢和一种新内心的情形配安模型

00:02:31.220 --> 00:02:32.320
就是JIL

00:02:32.320 --> 00:02:33.320
这个东西

00:02:33.320 --> 00:02:34.460
那

00:02:34.460 --> 00:02:36.480
好了那么重点再来介绍这个JIL

00:02:36.480 --> 00:02:39.500
那么JIL和这个一般的模型有什么区别呢

00:02:39.500 --> 00:02:40.940
那么一般的模型啊

00:02:40.940 --> 00:02:42.460
像这个GPT是什么呢

00:02:42.460 --> 00:02:43.800
竹子生成Token

00:02:43.800 --> 00:02:44.940
是自回归

00:02:44.940 --> 00:02:46.760
那么它是呢

00:02:46.760 --> 00:02:48.360
高延迟高成本

00:02:48.360 --> 00:02:49.900
就是你问它一个问题

00:02:49.900 --> 00:02:52.080
他呢就基于你这个问题

00:02:52.080 --> 00:02:53.220
这个问题就是一个提示词

00:02:53.220 --> 00:02:54.060
基于这个问题

00:02:54.060 --> 00:02:56.340
他一个一个的生成这个token

00:02:56.340 --> 00:02:57.980
把这个token拼在一起

00:02:57.980 --> 00:03:00.080
他其实就是一个完整的这个回答

00:03:00.080 --> 00:03:01.840
这么这样子来的

00:03:01.840 --> 00:03:02.680
可以生成文本

00:03:02.680 --> 00:03:03.340
可以生成逐变

00:03:03.340 --> 00:03:05.000
但只有这个模型呢

00:03:05.000 --> 00:03:06.500
他是一次效情计算

00:03:06.500 --> 00:03:08.560
直接输出判断概率

00:03:08.560 --> 00:03:10.340
他的特点是什么呢

00:03:10.340 --> 00:03:11.880
延迟极低成本极低

00:03:11.880 --> 00:03:12.440
记住啊

00:03:12.440 --> 00:03:13.600
延迟极低

00:03:13.600 --> 00:03:14.680
也就是说啊

00:03:14.680 --> 00:03:16.320
你给一个问题

00:03:16.320 --> 00:03:19.240
他基本上在500毫秒之内

00:03:19.240 --> 00:03:21.220
可以得到这个结果啊

00:03:21.220 --> 00:03:23.500
500毫秒之内其实是非常非常快的

00:03:23.500 --> 00:03:25.180
非常非常快啊

00:03:25.180 --> 00:03:26.080
那个说实话

00:03:26.080 --> 00:03:27.100
你像使用GPT

00:03:27.100 --> 00:03:28.460
那基本上几秒啊

00:03:28.460 --> 00:03:29.760
十几秒才得到这个结果

00:03:29.760 --> 00:03:30.060
对不对

00:03:30.060 --> 00:03:31.240
它的延迟极低

00:03:31.240 --> 00:03:33.200
500毫秒之内

00:03:33.200 --> 00:03:34.100
就可以得到这个结果

00:03:34.100 --> 00:03:35.240
成本极低啊

00:03:35.240 --> 00:03:37.240
我们后面会介绍的成本

00:03:37.240 --> 00:03:39.740
然后再来看一下啊

00:03:39.740 --> 00:03:41.020
这个东西怎么使用啊

00:03:41.020 --> 00:03:43.080
就是说你怎么去使用这个东西呢

00:03:43.080 --> 00:03:45.820
使用这个Jill这个模型呢

00:03:45.820 --> 00:03:47.140
使用Jill这个模型呢

00:03:47.140 --> 00:03:47.820
通常啊

00:03:47.820 --> 00:03:50.760
其实它是开放这个API给大家去使用

00:03:50.760 --> 00:03:52.920
就大家通常都是调这个API的方式啊

00:03:52.920 --> 00:03:54.000
去使用这个模型

00:03:54.000 --> 00:03:55.680
那么它呢

00:03:55.680 --> 00:03:57.800
主要提供两个东西

00:03:57.800 --> 00:03:58.720
第一个就是state

00:03:58.720 --> 00:04:01.800
这个什么东西呢

00:04:01.800 --> 00:04:03.360
大家可以把它看作是一个context

00:04:03.360 --> 00:04:04.060
一个上下文

00:04:04.060 --> 00:04:06.520
然后第二个就是问题

00:04:06.520 --> 00:04:09.240
就是开发者预先定义好的派对的任务

00:04:09.240 --> 00:04:10.100
主要是两个东西

00:04:10.100 --> 00:04:12.080
然后呢交给这个这个模型

00:04:12.080 --> 00:04:13.980
这个模型然后再发挥一个结果

00:04:13.980 --> 00:04:15.980
那发挥的结果会是个什么东西呢

00:04:15.980 --> 00:04:17.300
这个结果啊

00:04:17.300 --> 00:04:20.720
跟一般大模型还是有些区别的

00:04:20.720 --> 00:04:21.380
一般大模型呢

00:04:21.380 --> 00:04:23.600
其实是输出一个啊

00:04:23.600 --> 00:04:25.040
会输出一道文本

00:04:25.040 --> 00:04:25.460
对不对

00:04:25.460 --> 00:04:26.400
那它这里呢

00:04:26.400 --> 00:04:28.960
其实是输出一种强烈性的结构化JSON

00:04:28.960 --> 00:04:31.340
是一种强烈性的结构化JSON

00:04:31.340 --> 00:04:32.740
是一种JSON的文本

00:04:32.740 --> 00:04:33.740
啊

00:04:33.740 --> 00:04:34.580
JSON文本

00:04:34.580 --> 00:04:36.440
它不包含这个自然语言文本

00:04:36.440 --> 00:04:38.000
是一种纯JSON的文本

00:04:38.000 --> 00:04:40.220
大概是变形结构预测

00:04:40.220 --> 00:04:42.040
模型一次性返回所有概率

00:04:42.040 --> 00:04:44.720
也就是说你丢给它几个问题啊

00:04:44.720 --> 00:04:46.640
它是一次性给你返回所有的概率

00:04:46.640 --> 00:04:48.480
它是变形预测的

00:04:48.480 --> 00:04:50.940
第三个就是程序可以直接解析

00:04:50.940 --> 00:04:52.740
才是反过一个接测文本嘛

00:04:52.740 --> 00:04:53.940
是可以解析的

00:04:53.940 --> 00:04:55.420
所以我们总结来的话

00:04:55.420 --> 00:04:57.440
总结来这个这个这个这个模型

00:04:57.440 --> 00:05:00.300
它的输入就是state加预定的question

00:05:00.300 --> 00:05:02.460
然后呢输出一个回答对象

00:05:02.460 --> 00:05:03.480
是这样子

00:05:03.480 --> 00:05:06.260
好那么它的输出呢有三种类型啊

00:05:06.260 --> 00:05:07.780
第一种类型呢是no啊

00:05:07.780 --> 00:05:09.500
只有三种类型啊

00:05:09.500 --> 00:05:11.060
第一个是no啊

00:05:11.060 --> 00:05:12.200
no是一个概率类型

00:05:12.200 --> 00:05:13.980
这个类型有什么特点呢

00:05:13.980 --> 00:05:15.560
也就是不完类型判断

00:05:15.560 --> 00:05:17.760
它是返回0到1的伏点数

00:05:17.760 --> 00:05:19.960
数值代表成立概率

00:05:19.960 --> 00:05:23.220
无需单独设置置信度

00:05:23.220 --> 00:05:24.960
这段数字即为置信度

00:05:24.960 --> 00:05:26.180
好 我们来看一下

00:05:26.180 --> 00:05:28.520
就是它返回一个什么样的东西

00:05:28.520 --> 00:05:31.480
这里是它返回的一个结构的一个实例

00:05:31.480 --> 00:05:33.280
因为我先说过

00:05:33.280 --> 00:05:35.060
它其实是它的使用

00:05:35.060 --> 00:05:36.580
它使用的方式

00:05:36.580 --> 00:05:38.880
其实跟contract GPT

00:05:38.880 --> 00:05:40.180
跟GPT还是有些区别

00:05:40.180 --> 00:05:40.600
对吧

00:05:40.600 --> 00:05:43.840
通常是以结构的方式对外使用

00:05:43.840 --> 00:05:45.840
你直接给他一个

00:05:45.840 --> 00:05:46.840
你直接呢

00:05:46.840 --> 00:05:50.840
通过这个机构的方式提供这个task需要的内容

00:05:50.840 --> 00:05:52.840
state和这个question

00:05:52.840 --> 00:05:55.840
然后他返回的是一个json的这样一个sultrime

00:05:55.840 --> 00:05:56.840
这个sultrime里面呢

00:05:56.840 --> 00:05:57.840
有两个重要的东西

00:05:57.840 --> 00:05:59.840
第一个就是类型

00:05:59.840 --> 00:06:00.840
类型就是no

00:06:00.840 --> 00:06:02.840
它是概率类型

00:06:02.840 --> 00:06:05.840
然后这个呢就是它的这个值

00:06:05.840 --> 00:06:06.840
0.95

00:06:06.840 --> 00:06:07.840
我们前面说过

00:06:07.840 --> 00:06:10.840
它这里是0到1的这么一个伏点数

00:06:10.840 --> 00:06:11.840
对不对

00:06:11.840 --> 00:06:14.280
那么这个0.9.5其实就是表示一个概率

00:06:14.280 --> 00:06:16.040
大家可以反而看作是一个概率

00:06:16.640 --> 00:06:18.800
那么这个时候同学就会问了

00:06:18.800 --> 00:06:19.880
这个这里有什么用呢

00:06:20.080 --> 00:06:20.600
对吧

00:06:20.600 --> 00:06:22.240
嗯反正0.95是吧

00:06:22.440 --> 00:06:24.000
其实场景是非常多的

00:06:24.000 --> 00:06:24.680
比如说

00:06:25.880 --> 00:06:27.640
检测用户退款对不对

00:06:27.840 --> 00:06:29.000
检测用户退款的话

00:06:29.000 --> 00:06:29.800
其实呢

00:06:30.000 --> 00:06:30.600
这个东西啊

00:06:30.600 --> 00:06:32.680
当然你用XenGPT其实也可以回答

00:06:32.680 --> 00:06:33.280
是不是

00:06:33.400 --> 00:06:35.280
你丢给一个啊

00:06:35.280 --> 00:06:37.800
就是用户的这个用户的信息啊

00:06:38.200 --> 00:06:39.680
直接给到这个GPT

00:06:39.680 --> 00:06:41.000
他也可以回答

00:06:41.000 --> 00:06:43.000
说这个用户到底会不会退款

00:06:43.000 --> 00:06:43.600
对不对

00:06:43.900 --> 00:06:45.000
但是呢其实呢

00:06:45.300 --> 00:06:46.700
那个东西有点什么

00:06:46.800 --> 00:06:48.500
有点这个杀鸡又牛肉的感觉

00:06:48.500 --> 00:06:50.200
其实这种需求呢

00:06:50.200 --> 00:06:52.200
其实有更简单的方式去实现

00:06:52.200 --> 00:06:55.100
就是所谓的Jell这种方式对吧

00:06:55.400 --> 00:06:57.500
那么检测用户退款请求

00:06:57.500 --> 00:06:59.600
这用户呢可能是一个信息发过来

00:06:59.800 --> 00:07:02.100
那么给到Jell这个模型

00:07:02.200 --> 00:07:03.100
那么Jell呢

00:07:03.500 --> 00:07:06.100
直接就回答一个概率就可以了

00:07:06.400 --> 00:07:07.200
比如说

00:07:07.600 --> 00:07:08.800
用户呢不会退款

00:07:08.800 --> 00:07:10.000
他就可能就返回给你

00:07:10.000 --> 00:07:10.300
对不对

00:07:10.300 --> 00:07:10.980
如果会退款

00:07:10.980 --> 00:07:12.100
那么就返回这个

00:07:12.100 --> 00:07:14.380
比如说0.9或者1就可以了

00:07:14.380 --> 00:07:14.620
对不对

00:07:14.620 --> 00:07:18.600
那么这样子其实非常方便的解决这个问题

00:07:18.600 --> 00:07:20.580
那么它这个

00:07:20.580 --> 00:07:22.980
它的成本会远远的低于这个

00:07:22.980 --> 00:07:24.280
用GPT来解决这个问题

00:07:24.280 --> 00:07:27.820
而且这个速度也会快很多

00:07:27.820 --> 00:07:30.460
它的这个延迟的时间是500毫秒

00:07:30.460 --> 00:07:33.440
它那个GPT那是几秒钟

00:07:33.440 --> 00:07:33.780
对不对

00:07:33.780 --> 00:07:35.920
所以它用它这种方式来解决

00:07:35.920 --> 00:07:36.520
这个问题的话

00:07:36.520 --> 00:07:38.440
其实是成本更低

00:07:38.440 --> 00:07:40.000
然后那速度呢更好

00:07:40.000 --> 00:07:41.340
是不是速度更快

00:07:41.340 --> 00:07:42.080
效率更高

00:07:42.942 --> 00:07:46.942
然後我們再來看第二個類型,就是Close類型。

00:07:46.942 --> 00:07:56.942
這個什麼意思呢?也就是說,我們在去提供上下文的時候,其實是會帶好幾個選項過去的。

00:07:56.942 --> 00:07:58.222
然后呢

00:07:58.222 --> 00:08:00.542
这个这个模型说到这个

00:08:00.542 --> 00:08:03.722
这个上下和和这个问题之后呢

00:08:03.722 --> 00:08:06.182
他会选择其中的一个来作为回答

00:08:06.182 --> 00:08:07.942
就是做选择题嘛

00:08:07.942 --> 00:08:09.082
就ABC第四个选项

00:08:09.082 --> 00:08:10.382
他选一个告诉你

00:08:10.382 --> 00:08:11.602
好那么其实这个呢

00:08:11.602 --> 00:08:12.682
就是他换回的结果

00:08:12.682 --> 00:08:14.882
假设他这个提供的选项

00:08:14.882 --> 00:08:16.942
有三个选项啊

00:08:16.942 --> 00:08:17.782
一个是binim

00:08:17.782 --> 00:08:20.302
这个是结算

00:08:20.302 --> 00:08:21.522
然后这个是技术

00:08:21.522 --> 00:08:22.502
然后是销售

00:08:22.502 --> 00:08:24.202
就是三百三个部门啊

00:08:24.202 --> 00:08:25.182
对吧

00:08:25.182 --> 00:08:26.762
然后这里面他会选一个

00:08:26.762 --> 00:08:29.002
他选择这个billion这个部门

00:08:29.002 --> 00:08:30.302
就他选一个

00:08:30.302 --> 00:08:31.122
你给他三个选项

00:08:31.122 --> 00:08:31.882
他选一个出来

00:08:31.882 --> 00:08:33.682
那这有时候这个东西

00:08:33.682 --> 00:08:36.702
哪里有这个场景多不多呢

00:08:36.702 --> 00:08:37.622
这个很多嘛

00:08:37.622 --> 00:08:38.082
对不对

00:08:38.082 --> 00:08:39.662
很多重要的场景

00:08:39.662 --> 00:08:41.402
比如说这个三件商品

00:08:41.402 --> 00:08:42.102
让他选一个

00:08:42.102 --> 00:08:42.502
是不是

00:08:42.502 --> 00:08:44.442
那其实这种场景是非常多的

00:08:44.442 --> 00:08:44.602
是不是

00:08:44.602 --> 00:08:46.422
OK我们来看一下

00:08:46.422 --> 00:08:47.002
这个关键

00:08:47.002 --> 00:08:49.242
只有关键的这个字段

00:08:49.242 --> 00:08:50.902
这个是truth

00:08:50.902 --> 00:08:52.562
就是概率最高的选项名称

00:08:52.562 --> 00:08:53.262
就这个

00:08:53.262 --> 00:08:55.042
就概率最高的

00:08:55.042 --> 00:08:57.022
他选一个出来

00:08:57.022 --> 00:08:58.142
就是ABCD四个选项

00:08:58.142 --> 00:08:58.822
他选一个出来

00:08:58.822 --> 00:09:01.402
他说不一定是ABCD四个选项

00:09:01.402 --> 00:09:03.322
他最多可以255个选项

00:09:03.322 --> 00:09:04.542
选项可以很多

00:09:04.542 --> 00:09:05.722
你把它列出来

00:09:05.722 --> 00:09:07.202
他会选一个出来

00:09:07.202 --> 00:09:08.922
然后这个呢

00:09:08.922 --> 00:09:10.942
就是概率的总和

00:09:10.942 --> 00:09:14.982
就是所有或选项的完整的概率分布

00:09:14.982 --> 00:09:17.082
那如果说是255个选项呢

00:09:17.082 --> 00:09:20.462
那么就会列出255个选项

00:09:20.462 --> 00:09:21.342
每一个选项的概率

00:09:21.342 --> 00:09:24.162
那么这个trose这里呢

00:09:24.162 --> 00:09:25.462
其实概念最高的那一个

00:09:25.462 --> 00:09:27.522
那么这个是confidence

00:09:27.522 --> 00:09:28.482
自信度啊

00:09:28.482 --> 00:09:30.982
模型对本次分类结果的自信度

00:09:30.982 --> 00:09:32.642
那么数值越高呢

00:09:32.642 --> 00:09:34.162
就分类呢越确定

00:09:34.162 --> 00:09:36.202
好那我们看一下这个自信度是0.8

00:09:36.202 --> 00:09:37.442
对吧这是比较高的

00:09:37.442 --> 00:09:39.802
是不是当然我们在进行

00:09:39.802 --> 00:09:41.122
决策的时候呢

00:09:41.122 --> 00:09:43.322
你可以跟这个自信度来进行

00:09:43.322 --> 00:09:44.542
评估哈

00:09:44.542 --> 00:09:46.722
就是如果自信度高于0.8

00:09:46.722 --> 00:09:48.242
或者说高于0.7

00:09:48.242 --> 00:09:50.242
我们就可以选择这样的一个结果

00:09:50.242 --> 00:09:52.262
就是所谓的决策模型的

00:09:52.262 --> 00:09:53.662
价值在这里面

00:09:54.162 --> 00:09:56.162
好让我们再看第三个啊

00:09:56.162 --> 00:09:57.162
就是score啊

00:09:57.162 --> 00:09:58.522
打分啊

00:09:58.522 --> 00:09:59.342
打个分数

00:09:59.342 --> 00:10:00.782
啊

00:10:00.782 --> 00:10:02.362
那么它的特点就是连续打分

00:10:02.362 --> 00:10:04.102
各级别概率分布啊

00:10:04.102 --> 00:10:05.162
confidence 知性度

00:10:05.162 --> 00:10:07.262
我们来看一下这个结果啊

00:10:07.262 --> 00:10:07.462
那么

00:10:07.462 --> 00:10:10.022
通常它会去

00:10:10.022 --> 00:10:12.002
比如说你给它三个选项啊

00:10:12.002 --> 00:10:12.622
你给它一个问

00:10:12.622 --> 00:10:14.142
就是说你给给问

00:10:14.142 --> 00:10:15.622
给上下文给问题

00:10:15.622 --> 00:10:16.842
然后提供选项

00:10:16.842 --> 00:10:18.602
好那么它反而结果里面呢

00:10:18.602 --> 00:10:20.382
它就会对三个选项呢

00:10:20.382 --> 00:10:21.682
每个选项打一个分数

00:10:21.682 --> 00:10:22.602
我们来看一下啊

00:10:22.602 --> 00:10:23.322
好

00:10:23.322 --> 00:10:24.262
它的分数是

00:10:24.262 --> 00:10:26.462
非诊数打分值

00:10:26.462 --> 00:10:27.322
这个是I.86

00:10:27.322 --> 00:10:27.722
对不对

00:10:27.722 --> 00:10:29.022
知情度是0.94

00:10:29.022 --> 00:10:32.322
然后它提供了三个选项

00:10:32.322 --> 00:10:33.622
这三个选项

00:10:33.622 --> 00:10:34.202
评鉴

00:10:34.202 --> 00:10:35.322
轻微不满

00:10:35.322 --> 00:10:35.822
生气

00:10:35.822 --> 00:10:37.502
极度愤怒

00:10:37.502 --> 00:10:37.902
对吧

00:10:37.902 --> 00:10:39.222
好上面就是分数

00:10:39.222 --> 00:10:41.182
这个第一个评鉴

00:10:41.182 --> 00:10:41.962
就是0.0分

00:10:41.962 --> 00:10:42.622
就是不评鉴

00:10:42.622 --> 00:10:43.242
对吧

00:10:43.242 --> 00:10:43.502
OK

00:10:43.502 --> 00:10:45.202
这里是0.0爱

00:10:45.202 --> 00:10:46.622
这个轻微不满

00:10:46.622 --> 00:10:48.342
对应的分数是0.0爱

00:10:48.342 --> 00:10:49.962
然后这个是0.1

00:10:49.962 --> 00:10:50.822
好

00:10:50.822 --> 00:10:51.502
这个生气

00:10:51.502 --> 00:10:52.682
然后极度愤怒

00:10:52.682 --> 00:10:53.742
是年点88

00:10:53.742 --> 00:10:55.042
那么这个分数最高了

00:10:55.042 --> 00:10:55.282
对不对

00:10:55.282 --> 00:10:57.922
那如果说你是基于这个分数来进行

00:10:57.922 --> 00:10:58.362
啊

00:10:58.362 --> 00:10:58.982
决策的话

00:10:58.982 --> 00:11:00.462
那么你可能会选这个是不是

00:11:00.462 --> 00:11:01.162
啊

00:11:01.162 --> 00:11:02.482
这个其实就是对于

00:11:02.482 --> 00:11:03.462
多个选项

00:11:03.462 --> 00:11:04.622
进行打一个分数

00:11:04.622 --> 00:11:05.282
啊

00:11:05.282 --> 00:11:06.582
这个其实也是长期很多

00:11:06.582 --> 00:11:06.942
啊

00:11:06.942 --> 00:11:08.282
这个是

00:11:08.282 --> 00:11:08.862
呃

00:11:08.862 --> 00:11:10.902
我们的Jill这个模型啊

00:11:10.902 --> 00:11:11.302
它的

00:11:11.302 --> 00:11:14.262
返回结果的三个可能性

00:11:14.262 --> 00:11:15.362
OK啊

00:11:15.362 --> 00:11:16.102
三种结果

00:11:16.102 --> 00:11:17.342
好

00:11:17.342 --> 00:11:18.362
那么先怎么总结一下

00:11:18.362 --> 00:11:20.902
Jill输出的关键的特性啊

00:11:20.902 --> 00:11:22.082
第二点就是

00:11:22.082 --> 00:11:23.002
年文本幻觉

00:11:23.002 --> 00:11:25.162
它输出结构是强制约定的

00:11:25.162 --> 00:11:26.342
宁格式错误

00:11:26.342 --> 00:11:27.302
不乱增自断

00:11:27.302 --> 00:11:29.842
然后是拼尿变形计算的

00:11:29.842 --> 00:11:31.382
一次请就变形处理所有

00:11:31.382 --> 00:11:34.742
然后校准级概念

00:11:34.742 --> 00:11:36.302
直接预计分支

00:11:36.302 --> 00:11:38.262
那么低分支可以人工复制

00:11:38.262 --> 00:11:40.222
它会有一个知性度给你

00:11:40.222 --> 00:11:41.442
然后输出你的费用

00:11:41.442 --> 00:11:44.262
它这个模型输出是不收费的

00:11:44.262 --> 00:11:45.962
你用它这个模型输出是不收费的

00:11:45.962 --> 00:11:48.482
而且输入的成本也是非常低

00:11:48.482 --> 00:11:50.902
它是我们使用

00:11:50.902 --> 00:11:54.842
GPT的成本大概就是100万Token

00:11:54.842 --> 00:11:55.202
对吧

00:11:55.202 --> 00:11:55.842
就一兆

00:11:55.842 --> 00:11:58.922
大概就是10美元

00:11:58.922 --> 00:12:00.002
10美元

00:12:00.002 --> 00:12:01.142
那么他这个

00:12:01.142 --> 00:12:03.922
大概就是100万

00:12:03.922 --> 00:12:12.342
大概就是0.0.4万美元

00:12:12.342 --> 00:12:14.062
就是他这个10美元

00:12:14.062 --> 00:12:15.282
他这个年纪年4万美元

00:12:15.282 --> 00:12:17.142
所以他的成本低很多

00:12:17.142 --> 00:12:19.522
那么也就是说

00:12:19.522 --> 00:12:21.682
我们在实际上面进行

00:12:21.682 --> 00:12:23.842
在做应用的时候呢

00:12:23.842 --> 00:12:25.742
那么其实就给了我们很多的选择

00:12:25.742 --> 00:12:28.542
有些场景其实并不完全需要

00:12:28.542 --> 00:12:31.242
由GPT或者说

00:12:31.242 --> 00:12:33.122
Close这种模型来进行处理

00:12:33.122 --> 00:12:34.922
我们完全可以把它交给什么

00:12:34.922 --> 00:12:37.082
交给我们的JP这种模型来处理

00:12:37.082 --> 00:12:37.542
对不对

00:12:37.542 --> 00:12:39.502
所以他们这其实是这样写的关系

00:12:39.502 --> 00:12:42.802
并不是说替代的关系

00:12:42.802 --> 00:12:43.562
并不是这样子

00:12:43.562 --> 00:12:46.642
好那么接下来我们给大家看一个案例

00:12:46.642 --> 00:12:47.842
就是到底它是怎么用的

00:12:47.842 --> 00:12:48.302
这个东西

00:12:48.302 --> 00:12:49.382
我们来看一下

00:12:49.382 --> 00:12:51.042
官网上面提供了一个案例

00:12:51.042 --> 00:12:52.702
我们直接来看到官网就可以了

00:12:52.702 --> 00:12:52.862
好吧

00:12:52.862 --> 00:12:54.382
就是汉缩入门

00:12:54.382 --> 00:12:56.882
大家可以到这个网站

00:12:56.882 --> 00:12:59.042
去看一下它的官网上面提供了一个案例

00:12:59.042 --> 00:13:00.362
那么当然首先呢

00:13:00.362 --> 00:13:02.382
我们需要去申请

00:13:02.382 --> 00:13:03.022
申请

00:13:03.022 --> 00:13:04.142
如果说你要使用的话

00:13:04.142 --> 00:13:07.862
你需要到它的控制台去申请一个API-KIT

00:13:07.862 --> 00:13:10.182
申请还是比较容易的

00:13:10.182 --> 00:13:10.822
OK

00:13:10.822 --> 00:13:13.862
然后得到一个接口之后呢

00:13:13.862 --> 00:13:16.262
你就可以来进行使用了

00:13:16.262 --> 00:13:17.142
好

00:13:17.142 --> 00:13:17.802
那么这里呢

00:13:17.802 --> 00:13:22.562
是CURL这个方式来去发行一个请求

00:13:22.802 --> 00:13:24.802
你需要提供的是一个API-K

00:13:25.102 --> 00:13:26.102
这是它的接口

00:13:26.902 --> 00:13:28.402
然后你提供哪些数据呢

00:13:28.402 --> 00:13:29.502
这个数据是State

00:13:29.602 --> 00:13:31.602
大家可以把State看作是上线文

00:13:32.002 --> 00:13:32.602
OK

00:13:32.802 --> 00:13:34.302
这个是它的上线文

00:13:34.302 --> 00:13:35.102
是在英文是吧

00:13:35.102 --> 00:13:36.602
我们把它翻译一下

00:13:36.602 --> 00:13:37.502
什么意思

00:13:39.002 --> 00:13:39.502
OK

00:13:41.402 --> 00:13:41.802
好

00:13:41.802 --> 00:13:43.102
这个上线文是这样子

00:13:43.102 --> 00:13:43.502
你好

00:13:43.502 --> 00:13:45.902
我已经尝试您借我的strip账户三天了

00:13:45.902 --> 00:13:47.102
但其实一直失败

00:13:47.102 --> 00:13:48.742
我的销售正在锦上

00:13:49.102 --> 00:13:51.142
请尽快帮我帮助我

00:13:51.142 --> 00:13:51.662
对吧

00:13:51.662 --> 00:13:52.062
这个东西

00:13:52.062 --> 00:13:53.742
这个内容应该是一个

00:13:54.302 --> 00:13:56.142
是一个street的客户是吧

00:13:56.142 --> 00:13:57.942
在在咨询对吧

00:13:57.942 --> 00:13:59.462
在向客户进行咨询啊

00:13:59.462 --> 00:14:00.462
或者说储藏

00:14:00.742 --> 00:14:01.702
储藏这么一个信息啊

00:14:01.702 --> 00:14:02.262
ok

00:14:02.262 --> 00:14:02.422
好

00:14:02.422 --> 00:14:03.342
现在我们来看一下啊

00:14:03.862 --> 00:14:04.462
这个模型呢

00:14:04.462 --> 00:14:06.302
是Jill latest的这个模型

00:14:06.302 --> 00:14:07.342
然后问题是什么呢

00:14:08.342 --> 00:14:09.542
问题是这样子啊

00:14:09.862 --> 00:14:10.862
在下面啊

00:14:11.462 --> 00:14:12.502
这个是那个类型

00:14:13.022 --> 00:14:16.142
就是你希望用什么类型来回复你这个问题啊

00:14:16.222 --> 00:14:17.062
是no 是吧

00:14:17.102 --> 00:14:18.442
也就是给个概率就可以了

00:14:18.442 --> 00:14:19.822
我们看一下的问题是什么

00:14:19.822 --> 00:14:22.402
这个信息的紧迫度

00:14:22.402 --> 00:14:25.922
就是表达一下信息的紧迫度

00:14:25.922 --> 00:14:29.082
这个内容的紧迫度是什么样子

00:14:29.082 --> 00:14:29.382
对不对

00:14:29.382 --> 00:14:30.522
那么然后这个时候

00:14:30.522 --> 00:14:33.582
这个模型回复一个概率

00:14:33.582 --> 00:14:38.062
年到一这样的一个分值过来

00:14:38.062 --> 00:14:38.862
一个概率过来

00:14:38.862 --> 00:14:40.922
如果说这个值是一的话

00:14:40.922 --> 00:14:41.562
那么说明什么

00:14:41.562 --> 00:14:43.122
说明这个紧迫度是很高的

00:14:43.122 --> 00:14:43.402
对不对

00:14:43.402 --> 00:14:44.502
如果是0.95的话

00:14:44.502 --> 00:14:45.902
这个紧迫度也是很高的

00:14:45.902 --> 00:14:46.902
好

00:14:46.902 --> 00:14:47.702
然后我们再来看一下

00:14:47.702 --> 00:14:49.242
那其他的这种

00:14:49.242 --> 00:14:51.462
这个案例啊

00:14:51.462 --> 00:14:52.342
如果说我们是

00:14:52.342 --> 00:14:54.142
写代码掉结果

00:14:54.142 --> 00:14:55.902
那么我们自己在代码里面

00:14:55.902 --> 00:14:57.102
就要这样来写啊

00:14:57.102 --> 00:14:57.362
好

00:14:57.362 --> 00:14:58.042
那么同样的

00:14:58.042 --> 00:14:58.722
它的这个

00:14:58.722 --> 00:15:00.502
上下文还是这个啊

00:15:00.502 --> 00:15:01.662
还是这个来举例啊

00:15:01.662 --> 00:15:02.902
我们看一下它的模型

00:15:02.902 --> 00:15:04.002
是Jolatist

00:15:04.002 --> 00:15:05.122
好

00:15:05.122 --> 00:15:06.422
那么这个下面是问题啊

00:15:06.422 --> 00:15:07.942
它其实是什么呢

00:15:07.942 --> 00:15:08.502
呃

00:15:08.502 --> 00:15:10.522
它是它什么

00:15:10.522 --> 00:15:12.662
它其实是一个一个上下文

00:15:12.662 --> 00:15:14.202
它其实是问了三个问题啊

00:15:14.202 --> 00:15:14.782
问了三个问题

00:15:14.782 --> 00:15:17.262
其实用三种类型来问好

00:15:17.262 --> 00:15:18.402
这个是choose

00:15:18.402 --> 00:15:19.842
choose ok

00:15:19.842 --> 00:15:21.042
这个呢就是它的问题

00:15:21.042 --> 00:15:22.102
哪一个团队呢

00:15:22.102 --> 00:15:24.202
来处理这样的一个事情

00:15:24.202 --> 00:15:24.542
对吧

00:15:24.542 --> 00:15:25.662
提供了三个选项

00:15:25.662 --> 00:15:27.362
这个是结算这个团队

00:15:27.362 --> 00:15:28.262
这个是技术这个团队

00:15:28.262 --> 00:15:29.202
这个销售这个团队

00:15:29.202 --> 00:15:30.882
这提供了三个选项

00:15:31.597 --> 00:15:34.597
因為我們說過,truth嘛,對不對?

00:15:34.597 --> 00:15:37.597
你是要大模型給你做選擇,所以你提供這個選項給他。

00:15:37.597 --> 00:15:40.597
像ABCD,做選擇題,是這樣子。

00:15:40.597 --> 00:15:45.597
好,我們看第二個,就是分數,score,使用這個類型來進行回答。

00:15:45.597 --> 00:15:47.797
回答好那么他是什么呢

00:15:47.797 --> 00:15:51.477
呃这个现在这个客户的这个什么啊

00:15:51.477 --> 00:15:54.777
失望度呢怎么样对吗啊啊

00:15:54.777 --> 00:15:55.697
什么怎么样啊OK

00:15:55.697 --> 00:15:57.697
他同样的提供了三个什么呢

00:15:57.697 --> 00:15:59.377
三种可能啊

00:15:59.377 --> 00:16:00.537
第一个呢就是冷静

00:16:00.537 --> 00:16:01.917
第二个呢是失望

00:16:01.917 --> 00:16:03.937
而第三个是非常生气

00:16:03.937 --> 00:16:05.277
就是你要根据什么

00:16:05.277 --> 00:16:09.977
根据这个上下文来去对于这三个描述进行打分

00:16:09.977 --> 00:16:11.137
打分

00:16:11.137 --> 00:16:13.637
OK好我们再看第三个啊

00:16:13.637 --> 00:16:15.217
第三个就是什么呢

00:16:15.597 --> 00:16:19.197
那Noah这种类型其实就是

00:16:19.197 --> 00:16:20.997
概率对吧是概率这个

00:16:20.997 --> 00:16:24.197
那么也就是说你的问题一定是跟概率相关的是吧

00:16:24.197 --> 00:16:26.197
这个信息它到底

00:16:26.197 --> 00:16:29.597
也表示了它多么紧迫对吧

00:16:29.597 --> 00:16:31.797
ok 那么这个时候你回答一个概率就可以了

00:16:31.797 --> 00:16:33.397
好 我们再来看一下它的回答

00:16:33.397 --> 00:16:36.397
因为你这里是三个类型的问题对吧

00:16:36.397 --> 00:16:36.997
三个类型的问题

00:16:36.997 --> 00:16:38.597
所以它的回答也是三个类型的

00:16:38.597 --> 00:16:40.197
我们看choose

00:16:40.197 --> 00:16:41.397
choose就是

00:16:41.397 --> 00:16:43.597
它首先要做出一个选择对吧

00:16:43.597 --> 00:16:45.937
ABCD要选一个选一个选一个答案

00:16:45.937 --> 00:16:46.737
对不对啊

00:16:46.737 --> 00:16:48.337
但是结果是技术部门是吧

00:16:48.337 --> 00:16:50.097
技术部门来处理这个问题啊

00:16:50.097 --> 00:16:51.757
之前都是0.78啊

00:16:51.757 --> 00:16:54.157
然后当然他也会给三个选项呢

00:16:54.157 --> 00:16:55.457
每一个打一个分数啊

00:16:56.657 --> 00:16:59.497
我们看第二个第二个问题

00:17:00.397 --> 00:17:01.657
第二个问题是打分对吧

00:17:02.237 --> 00:17:03.237
打分啊打分的话

00:17:03.237 --> 00:17:05.997
他会对于三个情绪啊

00:17:05.997 --> 00:17:08.257
但见到打分那很明显啊

00:17:08.257 --> 00:17:09.457
这个呢呃

00:17:09.457 --> 00:17:12.037
第二个情绪他的这个分值是会高的

00:17:12.037 --> 00:17:14.557
也就是他当前的用户所表达这个情绪

00:17:14.557 --> 00:17:15.517
应该是这个是吧

00:17:16.597 --> 00:17:17.117
啊

00:17:17.157 --> 00:17:17.797
是这个

00:17:18.357 --> 00:17:19.237
这个情绪啊

00:17:20.357 --> 00:17:21.557
好我们看最后这个啊

00:17:21.997 --> 00:17:23.477
最后这个是要表

00:17:23.477 --> 00:17:25.197
要是输出一个概率是不是

00:17:25.197 --> 00:17:26.277
然后直接给了一个概率是不是

00:17:26.277 --> 00:17:27.237
这个最简单的啊

00:17:27.237 --> 00:17:29.517
一点点说明这个事情的紧迫度啊

00:17:29.517 --> 00:17:30.597
是非常非常大的

00:17:30.597 --> 00:17:31.157
对不对

00:17:31.317 --> 00:17:32.317
这个其实就是

00:17:32.597 --> 00:17:33.597
Jayv这个模型啊

00:17:33.597 --> 00:17:34.917
使用的这个

00:17:35.197 --> 00:17:36.477
这样的一个方式啊

00:17:36.477 --> 00:17:37.597
其实就是掉接口

00:17:37.597 --> 00:17:38.317
然后呢

00:17:38.317 --> 00:17:38.597
啊

00:17:38.597 --> 00:17:39.317
接口里面呢

00:17:39.317 --> 00:17:41.077
需要描述你的这个问题

00:17:41.077 --> 00:17:43.077
其实需要提供一个上下文啊

00:17:43.077 --> 00:17:44.677
把你的这个情况给交代啊

00:17:44.677 --> 00:17:46.837
这个做用gp

00:17:46.837 --> 00:17:47.837
用chat gpt

00:17:47.837 --> 00:17:48.837
gpt或者glowd

00:17:48.837 --> 00:17:49.317
都是一样的

00:17:49.317 --> 00:17:50.637
要提供一个上下文对不对

00:17:50.637 --> 00:17:51.637
然后就是问题

00:17:51.637 --> 00:17:54.637
如果说是truth或者说score

00:17:54.637 --> 00:17:56.517
那么还需要提供这个选项

00:17:56.877 --> 00:17:57.637
啊OK

00:17:57.637 --> 00:17:58.757
那么结果呢

00:17:58.757 --> 00:18:00.277
就对方就会提供一个

00:18:00.517 --> 00:18:02.437
啊json的这样的一个结果化的

00:18:02.437 --> 00:18:04.277
一个字符传给到我们啊

00:18:04.277 --> 00:18:04.917
他这个时候

00:18:04.917 --> 00:18:05.637
大家就会问了

00:18:05.637 --> 00:18:07.277
这这东西到底有什么用对吧

00:18:07.277 --> 00:18:08.637
能用在哪个地方

00:18:08.917 --> 00:18:10.917
啊好像没有这个chat gpt

00:18:10.917 --> 00:18:11.877
这种这么方便

00:18:11.877 --> 00:18:13.537
什么都可以问

00:18:13.537 --> 00:18:15.097
然后他多给你一个回复

00:18:15.097 --> 00:18:15.337
是不是

00:18:15.337 --> 00:18:18.377
但其实这个场景是非常多的

00:18:18.377 --> 00:18:19.697
我们来看一下他的场景

00:18:19.697 --> 00:18:21.697
其实很多时候

00:18:21.697 --> 00:18:23.977
其实并不需要用GPT这种模型

00:18:23.977 --> 00:18:25.877
因为他成本太高了

00:18:25.877 --> 00:18:27.077
第一个就是成本高

00:18:27.077 --> 00:18:27.617
第二个就是什么

00:18:27.617 --> 00:18:30.577
就是他的延时太高了

00:18:30.577 --> 00:18:32.517
就是处理一个问题要好几秒

00:18:32.517 --> 00:18:34.357
他这个几百毫秒就能解决

00:18:34.357 --> 00:18:34.617
是不是

00:18:34.617 --> 00:18:36.177
所以我们这个时候来看一下

00:18:36.177 --> 00:18:37.717
他的场景

00:18:37.717 --> 00:18:38.657
第一个场景其实就是

00:18:38.657 --> 00:18:40.337
我们用在agent里面

00:18:40.337 --> 00:18:44.577
比如说浏览器与这个电脑的使用

00:18:44.577 --> 00:18:46.337
比如说什么

00:18:46.337 --> 00:18:50.057
识别这个页面状态

00:18:50.057 --> 00:18:51.277
判断下一个动作

00:18:51.277 --> 00:18:53.317
因为它的这个动作

00:18:53.317 --> 00:18:55.097
其实是有限的嘛

00:18:55.097 --> 00:18:55.317
对不对

00:18:55.317 --> 00:18:57.337
点击输入下拉对不对

00:18:57.857 --> 00:18:59.877
就哪怕我玩游戏也是一样的

00:18:59.877 --> 00:19:01.737
玩游戏它动作就那么点

00:19:01.737 --> 00:19:02.737
选项只有那么多

00:19:02.737 --> 00:19:03.037
对不对

00:19:03.037 --> 00:19:04.637
你可以把它选项全部列出来

00:19:04.637 --> 00:19:04.917
是不是

00:19:04.917 --> 00:19:07.577
列出来给它就可以了

00:19:07.577 --> 00:19:09.977
也就是说这种操作是有限的操作

00:19:09.977 --> 00:19:12.977
其实非常适合用J5这种模型来处理的

00:19:12.977 --> 00:19:14.597
还有智能工具路由

00:19:14.597 --> 00:19:14.937
对吧

00:19:14.937 --> 00:19:16.277
坚准选择工具

00:19:16.277 --> 00:19:18.817
搜索数据库邮件询问用户

00:19:18.817 --> 00:19:20.897
比如说安全降与分控

00:19:20.897 --> 00:19:24.737
就是高危操作前的快速的安全判断

00:19:24.737 --> 00:19:26.797
高频游戏

00:19:26.797 --> 00:19:27.597
说实话

00:19:27.597 --> 00:19:32.757
昨天我还用J5来去玩俄罗斯方块

00:19:32.757 --> 00:19:34.277
因为俄罗斯方块的话

00:19:34.277 --> 00:19:34.877
其实说实话

00:19:34.877 --> 00:19:35.957
它只有那几种选项

00:19:35.957 --> 00:19:36.237
对不对

00:19:36.237 --> 00:19:37.897
你把选项全部列出来就可以了

00:19:37.897 --> 00:19:39.877
用J5进行判断

00:19:39.877 --> 00:19:42.277
最高他支持255种选项

00:19:42.277 --> 00:19:42.557
是不是

00:19:42.557 --> 00:19:45.017
那其实生活中绝大部分

00:19:45.017 --> 00:19:46.657
其实实验绝大部分场景的

00:19:46.657 --> 00:19:47.517
就有几少数场景

00:19:47.517 --> 00:19:49.137
它是一种无限可能的

00:19:49.137 --> 00:19:49.537
对不对

00:19:49.537 --> 00:19:51.837
绝大部分场景都是有限可能的

00:19:51.837 --> 00:19:52.057
是不是

00:19:52.057 --> 00:19:54.617
我们这个只要把动作

00:19:54.617 --> 00:19:55.437
全部罗列出来

00:19:55.437 --> 00:19:57.137
就可以这样交给他去判断

00:19:57.137 --> 00:19:59.057
他又快成本又低

00:19:59.057 --> 00:19:59.737
是不是

00:19:59.737 --> 00:20:00.957
好给我们看一下

00:20:00.957 --> 00:20:02.577
比如说客户公单与客户

00:20:02.577 --> 00:20:03.777
消息智能处理平台

00:20:03.777 --> 00:20:05.797
比如说公单的分类

00:20:05.797 --> 00:20:06.077
是吧

00:20:06.077 --> 00:20:06.757
是物流问题

00:20:06.757 --> 00:20:07.357
账单问题

00:20:07.357 --> 00:20:08.377
产品故障还是投诉

00:20:08.377 --> 00:20:08.777
对吧

00:20:08.777 --> 00:20:10.537
比如说紧急度打分

00:20:10.537 --> 00:20:13.097
这个情绪的强烈度

00:20:13.097 --> 00:20:13.717
对不对

00:20:13.717 --> 00:20:17.257
还有这个比如说像这个Node核心判断

00:20:17.257 --> 00:20:18.137
是不是退款

00:20:18.137 --> 00:20:19.617
是不是辱骂

00:20:19.617 --> 00:20:21.377
是不是需要人工进入

00:20:21.377 --> 00:20:21.717
对不对

00:20:21.717 --> 00:20:23.497
做的非常非常适合用

00:20:23.497 --> 00:20:24.717
我们的Jail这个模型来处理

00:20:24.717 --> 00:20:25.797
真的非常非常方便

00:20:25.797 --> 00:20:28.617
所以以后做这个智能体

00:20:28.617 --> 00:20:29.557
它一定是什么

00:20:29.557 --> 00:20:30.637
一定是Jail

00:20:30.637 --> 00:20:33.677
一定是Jail和这个GPT或者和Lode

00:20:33.677 --> 00:20:35.517
进行配合使用

00:20:35.517 --> 00:20:37.257
就现在硅谷已经基本上

00:20:37.257 --> 00:20:38.817
是这两个组合在一起使用了

00:20:38.817 --> 00:20:39.457
啊

00:20:39.457 --> 00:20:39.897
就跟我

00:20:39.897 --> 00:20:41.177
根据我所找的信息

00:20:41.177 --> 00:20:43.697
就是他们现在已经在调整自己的决策了

00:20:43.697 --> 00:20:45.157
都是使用J5加什么

00:20:45.157 --> 00:20:47.217
加GPT来做这个智能体

00:20:47.217 --> 00:20:49.457
因为GPT其实实在是太贵了

00:20:49.457 --> 00:20:50.217
知道吗

00:20:50.217 --> 00:20:50.497
啊

00:20:50.497 --> 00:20:51.237
好用就好

00:20:51.237 --> 00:20:52.017
它实在是贵

00:20:52.017 --> 00:20:53.037
而且效率比较低

00:20:53.037 --> 00:20:56.177
所以不是所有的场景都适合用GPT键理

00:20:56.177 --> 00:20:57.037
啊

00:20:57.037 --> 00:20:57.557
其实少

00:20:57.557 --> 00:20:58.457
就是大部分场景

00:20:58.457 --> 00:21:00.497
其实都是比较适合用J5来做处理的

00:21:00.497 --> 00:21:03.177
还比如说这个内容与文档的拼尿删讯

00:21:03.177 --> 00:21:04.137
有些分类

00:21:04.137 --> 00:21:04.677
是不是

00:21:04.677 --> 00:21:05.337
啊

00:21:05.337 --> 00:21:05.577
只要

00:21:05.577 --> 00:21:07.377
就是只要给一个标记就可以了

00:21:07.377 --> 00:21:07.657
对吧

00:21:07.657 --> 00:21:08.937
还有评论

00:21:08.937 --> 00:21:09.817
消息删选

00:21:09.817 --> 00:21:10.777
对不对

00:21:10.777 --> 00:21:12.717
说实话

00:21:12.717 --> 00:21:14.997
你之前给几个标签给它

00:21:14.997 --> 00:21:15.297
是不是

00:21:15.297 --> 00:21:16.377
因为这个

00:21:16.377 --> 00:21:18.917
这往判断是哪一种类型的

00:21:18.917 --> 00:21:20.077
直接就说实话

00:21:20.077 --> 00:21:22.037
就很快

00:21:22.037 --> 00:21:23.757
就给我们打这个标签了

00:21:23.757 --> 00:21:24.857
还能闻到删选

00:21:24.857 --> 00:21:25.797
会议记样

00:21:25.797 --> 00:21:26.137
是不是

00:21:26.137 --> 00:21:28.257
还有实时业务分控

00:21:28.257 --> 00:21:28.757
自动化

00:21:28.757 --> 00:21:30.797
交易电带分控

00:21:30.797 --> 00:21:32.617
服务器与AOT设备

00:21:32.617 --> 00:21:33.577
告紧自动化

00:21:33.577 --> 00:21:35.237
都适合用

00:21:35.237 --> 00:21:37.297
用我们的J5来先处理

00:21:37.297 --> 00:21:39.177
比如说模型的路由与大模型

00:21:39.177 --> 00:21:39.837
这要评估

00:21:39.837 --> 00:21:41.757
模型路由对不对

00:21:41.757 --> 00:21:45.277
因为你全部使用GPT或者Close

00:21:45.277 --> 00:21:47.177
来解决问题实在是太贵了

00:21:47.177 --> 00:21:48.757
公司消耗不起对吧

00:21:48.757 --> 00:21:49.717
那么这个时候呢

00:21:49.717 --> 00:21:53.197
我就完全可以由J5来做一个模型的调度

00:21:53.197 --> 00:21:54.537
来做一个路由

00:21:54.537 --> 00:21:56.057
就是说你这个问题

00:21:56.057 --> 00:21:58.117
到底适合有哪一个模型来进行处理

00:21:58.117 --> 00:21:58.477
对不对

00:21:58.477 --> 00:22:01.337
常用的模型可能也就十来个

00:22:01.337 --> 00:22:03.437
你把这十来个模型全部累出来

00:22:03.437 --> 00:22:06.217
然后你交个J5判断一下就可以了

00:22:06.217 --> 00:22:07.797
到底选哪一个模型来处理这个问题

00:22:07.797 --> 00:22:08.457
对不对

00:22:08.457 --> 00:22:11.337
然后选出来之后

00:22:11.337 --> 00:22:13.057
然后我们再交个对应的模型来处理

00:22:13.057 --> 00:22:13.357
对不对

00:22:13.357 --> 00:22:15.317
比如大模型输出降业预示

00:22:15.317 --> 00:22:18.397
判断反复结果是否拼离核心要求

00:22:18.397 --> 00:22:20.697
是否存在幻觉分件

00:22:20.697 --> 00:22:21.577
做质量预示

00:22:21.577 --> 00:22:23.637
比如数据及标注与评测

00:22:23.637 --> 00:22:26.097
拼量进行按原判断与分离打分

00:22:26.097 --> 00:22:30.577
高效替代大模型的榨纸调用

00:22:30.577 --> 00:22:31.757
这只调用

00:22:31.757 --> 00:22:33.397
这个其实就是说

00:22:33.397 --> 00:22:35.997
它比这个原先用GPT去做决策呢

00:22:35.997 --> 00:22:36.957
就要快很多

00:22:36.957 --> 00:22:37.717
方便很多

00:22:37.717 --> 00:22:40.797
就主打一个高效和年价

00:22:40.797 --> 00:22:41.517
对吧

00:22:41.517 --> 00:22:43.357
这是我们这种模型的特点

00:22:43.357 --> 00:22:44.497
记住啊

00:22:44.497 --> 00:22:45.897
它不是要去替代GPT

00:22:45.897 --> 00:22:46.877
也不是要替代GPT

00:22:46.877 --> 00:22:48.197
也不是替代这Cloud

00:22:48.197 --> 00:22:50.817
还是给它们实现一种互补

00:22:50.817 --> 00:22:52.137
来完成一个

00:22:52.137 --> 00:22:55.157
一个又好用

00:22:55.157 --> 00:22:56.397
又省钱的这么一个应用