GPT3.5 改用 GPT4 价格翻了30倍 如何破局? GPT 对话成本推演

2024-01-01 01:36

本文主要是介绍GPT3.5 改用 GPT4 价格翻了30倍 如何破局? GPT 对话成本推演,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

场景介绍

假设你搭建了一个平台,提供 ChatGPT 3.5 的聊天服务。目前已经有一批用户的使用数据,想要测算一下如果更换 GPT 4.0 服务需要多少成本?

方案阐述

如果是全切,最简单粗暴的方案就是根据提供 ChatGPT 3.5 消费的金额乘以一个倍数,这个倍数是 GPT 4 的单格/ChatGPT 3.5 的单价,不过由于输入价和输出价有差异,所以会有一定误差,但不影响全量切换的大致判断。

如果要求更精确一些,就需要根据每一次问答的输入 Token 数和输出 Token 数,分别求和,计算有多少 k Tokens,然后算一个占比,看看各自的消费占比,分别乘以输入和输出的价格倍数。
image.png
以上是直接接官方的情况,但是更多时候,可能是通过第三方服务,第三方的价格不是根据官方定价,会有出入,需要结合第三方价格具体分析。

由于 GPT 4.0 相对高昂的价格,一般需要做限制,比如:限制访问频率、限制整体用量等。
举个例子,限制每分钟不超过 3 次,每 3 小时不超过 50 次;每天 10 次,每月 100次、200 次等。
这时候就需要精确一些的计算,通过指定的算法,测算切换 GPT 4.0 的成本是多少。

本次用于示例计算的单价为:

ModelInputOutput
gpt-4$0.03 / 1K tokens$0.06 / 1K tokens
gpt-3.5-turbo-1106$0.0010 / 1K tokens$0.0020 / 1K tokens

本次拿两个限制做案例开展:

  • 案例1:限制每天 10 次
  • 案例2:限制每分钟不超过 3 次,每 3 小时不超过 50 次

创建测试数据

本次测试借助数据库 MySQL 来实现这些复杂的算法。
首先在本地创建数据库testdb

create database if not exists testdb;

创建表chat_logs,并给四个字段都加上索引,提高查询效率:

create table if not exists testdb.chat_logs(user_id					bigint	comment '用户ID',request_time		bigint	comment '请求时间',prompt_tokens	bigint	comment '提示词的 Tokens,input Tokens',output_tokens	bigint	comment '回答的 Tokens,output Tokens',index userid_idx(user_id),index reqtime_idx(request_time),index prompt_idx(prompt_tokens),index output_idx(output_tokens)
) comment 'GPT对话记录';

插入数据,本次demo 数据量 100 条。

由于数据较长,不便展示,另外上传到资源,可前往免费下载:GPT 对话成本推演-数据demo

插入数据方法

  • 方法1:复制代码,接着上面步骤粘贴代码,回车即可执行
  • 方法2:直接执行文件,假设文件路径为:D:\insert_into_table.sql,则执行命令如下:
SOURCE D:\insert_into_table.sql;

案例1:限制每天 10 次(总量限制)

该逻辑实现比较简单,按天聚合,然后排序计算不超过 10 有多少 Tokens,大于 10 次又有多少 Tokens,然后再分别乘以单价,计算得出限制后的成本。

使用 SQL 实现

查看每天限制 10 次 GPT 4.0,超过部分按 GPT 3.5 计算,需要先将请求的数据按天进行排序,然后计算不超过 10 的部分和大于 10 的分别的 Tokens 分别是多少。

格式化时间,将request_time转为request_date

-- 格式化时间
select user_id,from_unixtime(request_time,'%Y-%m-%d') request_date,request_time,prompt_tokens,output_tokens
from testdb.chat_logs

按天编号

with chat_logs_format as(-- 格式化时间select user_id,from_unixtime(request_time,'%Y-%m-%d') request_date,request_time,prompt_tokens,output_tokensfrom testdb.chat_logs
)
-- 对话排序
select *,row_number()over(partition by user_id,request_date order by request_time) req_sort
from chat_logs_format

分类求 Tokens 数,编号req_sort不超过 10 次的分为GPT4,其他分为GPT3.5

with chat_logs_format as(-- 格式化时间select user_id,from_unixtime(request_time,'%Y-%m-%d') request_date,request_time,prompt_tokens,output_tokensfrom testdb.chat_logs
)
,chat_sort as(-- 对话排序select user_id,request_date,prompt_tokens,output_tokens,row_number()over(partition by user_id,request_date order by request_time) req_sortfrom chat_logs_format
)
-- 分类求 Tokens 数
select if(req_sort<=10,'GPT4','GPT3.5') mark_model,sum(prompt_tokens)/1000 k_prompt_tokens,sum(output_tokens)/1000 k_output_tokens
from chat_sort
group by mark_model

image.png

根据 Tokens 计算成本。

with chat_logs_format as(-- 格式化时间select user_id,from_unixtime(request_time,'%Y-%m-%d') request_date,request_time,prompt_tokens,output_tokensfrom testdb.chat_logs
)
,chat_sort as(-- 对话排序select user_id,request_date,prompt_tokens,output_tokens,row_number()over(partition by user_id,request_date order by request_time) req_sortfrom chat_logs_format
)
,k_tokens as(-- 分类求 Tokens 数select if(req_sort<=10,'GPT4','GPT3.5') mark_model,sum(prompt_tokens)/1000 k_input_tokens,sum(output_tokens)/1000 k_output_tokensfrom chat_sortgroup by mark_model
)
-- gpt-4:input 0.03,output 0.06
-- gpt-3:input 0.0010,output 0.0020
select sum(0.0010*k_input_tokens+0.0020*k_output_tokens) "调整前成本",sum(if(mark_model='GPT4',0.03,0.0010)*k_input_tokens+if(mark_model='GPT4',0.06,0.0020)*k_output_tokens) "调整后成本"
from k_tokens

image.png
调整前后成本相差还是挺大的,调整后成本是调整前的 12.5 倍。实际情况可以拿更多的数据,比如说一周、一个月,进行测算。

使用 Python 实现

使用 Python 实现比 SQL 实现多加了一步:读取数据,并转化为数组。之后的逻辑也是大同小异:时间格式化->记录排序、编号->分类求 Token->计算成本。

读取数据表,使用sql读取数据库数据,并使用 Pandas 转为 DataFrame。

import pandas as pd
from sqlalchemy import create_engine
def get_datas(sql):# 连接数据库# engine = create_engine("mysql+pymysql://用户名:密码@主机地址:端口号/数据库名")connect_info = 'mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'\.format("root", "123123", "127.1.1.0", "3306","testdb")engine = create_engine(connect_info)# 执行SQL语句prox = engine.execute(sql)df = pd.DataFrame(list(prox),columns=prox.keys())return df
sql = 'select * from testdb.chat_logs'
df = get_datas(sql)

image.png

将时间戳格式化

#将 request_time 转为日期格式
df['request_date'] = pd.to_datetime(df.request_time,unit='s').dt.date

排序编号

df['req_sort'] = df.groupby(['user_id','request_date'])['request_time'].rank(ascending=True,method='first')

分类,编号req_sort不超过 10 次的分为GPT4,其他分为GPT3.5

df['mark_model'] = df.req_sort.apply(lambda x:'GPT4' if x<=10 else 'GPT3.5')

求和,并转化为 k Token 单位

df_1 = df.groupby(['mark_model'])['prompt_tokens','output_tokens'].sum().reset_index()
df_1['k_input_tokens'] = df_1.prompt_tokens/1000
df_1['k_output_tokens'] = df_1.output_tokens/1000
df_1[['mark_model','k_input_tokens','k_output_tokens']]

image.png
计算成本

-- gpt-4input 0.03,output 0.06
-- gpt-3input 0.0010,output 0.0020
input_price_4 = 0.03
input_price_3 = 0.0010
output_price_4 = 0.06
output_price_3 = 0.0020
df_1['调整前成本'] = df_1[['mark_model','k_input_tokens','k_output_tokens']].apply(lambda x:x[1]*input_price_3+x[2]*output_price_3,axis=1)
df_1['调整后成本'] = df_1[['mark_model','k_input_tokens','k_output_tokens']].apply(lambda x:x[1]*input_price_4+x[2]*output_price_4 if x[0]=='GPT4' else x[1]*input_price_3+x[2]*output_price_3,axis=1)
df_1[['调整前成本','调整后成本']].sum()

image.png

案例2:限制每分钟不超过 3 次,每 3 小时不超过 50 次(频率限制)

该逻辑实现比较复杂一些,本质上还是先切分,然后排序再进行统计 Tokens,再计算成本。
不同点在于,前面是按天切分,有天然的便捷方式,直接格式化即可,每天看做一个桶,分桶计算,而 1 分钟和 3 小时需要自行构建相关的计算桶,不能一步到位。

过程算法其实也有多种:
比如说按自然分钟计算,每分钟为一个单位;按自然小时计算,02、35、68、911、1214、1517、1820、2123。
比如说拿一个初始的值做差值计算,然后在这个基础上分割,这个会受到初始值的影响,不过如果把初始值设置为某一天的零时零点零分,可以兼容上面一个算法,本次拿第二种来展开。

PS:实现第一种的方法:1分钟分桶:from_unixtime(request_time,’%Y-%m-%d %H:%i’);3小时分桶(日期+小时):from_unixtime(request_time,’%Y-%m-%d’)、floor(hour(from_unixtime(request_time)/3)

使用 SQL 实现

取最小时间,使用窗口函数来取值。如果是想设置固定的某个值,可以直接新增一个列。

-- 取最小的请求时间,
select user_id,request_time,prompt_tokens,output_tokens,min(request_time)over(partition by user_id) min_time
from chat_logs

求时间差值,使用request_time减去最小值。

-- 取时间差值
select user_id,request_time,prompt_tokens,output_tokens,request_time-min(request_time)over(partition by user_id) minute_diff
from chat_logs

分桶,1 分钟则除以 60 秒,3 小时则除以 60603 秒,然后使用ceil()函数向上取值。

-- 分桶
select user_id,request_time,prompt_tokens,output_tokens,ceil((request_time-min(request_time)over(partition by user_id))/60) minute_bucket,ceil((request_time-min(request_time)over(partition by user_id))/60/60/3) hour_bucket
from chat_logs

排序,根据用户和分桶字段进行分组,然后对request_time升序排序

with 
-- 分桶
cut_bucket as(select user_id,request_time,prompt_tokens,output_tokens,ceil((request_time-min(request_time)over(partition by user_id))/60) minute_bucket,ceil((request_time-min(request_time)over(partition by user_id))/60/60/3) hour_bucketfrom chat_logs
)
-- 排序
select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,row_number()over(partition by user_id,minute_bucket order by request_time) minute_bucket_sort,row_number()over(partition by user_id,hour_bucket order by request_time) hour_bucket_sort
from cut_bucket

分类求和,将minute_bucket_sort<=3 and hour_bucket_sort<=50分为GPT4,其他的分为GPT3.5,然后聚合求 Tokens。

with
-- 分桶
cut_bucket as(select user_id,request_time,prompt_tokens,output_tokens,ceil((request_time-min(request_time)over(partition by user_id))/60) minute_bucket,ceil((request_time-min(request_time)over(partition by user_id))/60/60/3) hour_bucketfrom chat_logs
)
-- 排序
,bucket_sort as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,row_number()over(partition by user_id,minute_bucket order by request_time) minute_bucket_sort,row_number()over(partition by user_id,hour_bucket order by request_time) hour_bucket_sortfrom cut_bucket
)
-- 分类
,mark_models as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,minute_bucket_sort,hour_bucket_sort,(case when minute_bucket_sort<=3 and hour_bucket_sort<=50 then 'GPT4' else 'GPT3.5' end) mark_modelfrom bucket_sort
)
-- 计算分钟<=3且3小时<=50
select mark_model,sum(prompt_tokens)/1000 k_input_tokens,sum(output_tokens)/1000 k_output_tokens
from mark_models
group by mark_model

image.png
然后再计算成本,完事!
直接计算minute_bucket_sort<=3hour_bucket_sort<=50就可以了?
不不不!这里有坑,先不聚合,查看明细数据看看,如下图第一个红框,它不符合 1 分钟 3 次上限的逻辑,所以被剔除了,标记为 GPT3.5。而第二个框,它不符合 3 小时 50 次上限的逻辑,所以也被剔除了。
不知道你是否意识到了问题,通过肉眼看,第二个框的 3 条记录应该是要被统计到 3 小时 50 次上限的逻辑的,因为前面因为 1 分钟的限制多剔除了 3 条记录。
所以在 3 小时的桶里面排序的时候,需要建立 1 分钟的桶的基础之上,先保证每一条记录都符合 1 分钟的逻辑,再针对这些记录拿 3 小时的逻辑加以限制。
image.png
修改 3 小时的分桶排序逻辑,要建立在 1 分钟的基础上才开始排序。
新增一个步骤,对 1 分钟的桶不超过 3 次的部分和大于 3 次的部分进行分类。然后对 3 小时的分桶排序则建在 1 分钟不超过 3 次的类别上。
代码实现上,将 1 分钟不超过 3 次和大于 3 次的分类(mark_target_record)加入 3 小时的分桶排序的分组(partition by)中,然后限制只取mark_target_record=1部分作为GPT4,参考修改逻辑如下:

with 
-- 分桶
cut_bucket as(select user_id,request_time,prompt_tokens,output_tokens,ceil((request_time-min(request_time)over(partition by user_id))/60) minute_bucket,ceil((request_time-min(request_time)over(partition by user_id))/60/60/3) hour_bucketfrom chat_logs
)
-- 排序
,bucket_sort as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,row_number()over(partition by user_id,minute_bucket order by request_time) minute_bucket_sort,row_number()over(partition by user_id,hour_bucket order by request_time) hour_bucket_sortfrom cut_bucket
)
-- 对分钟的排序数据进行分类
,mark_chatlog as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,minute_bucket_sort,hour_bucket_sort,(case when minute_bucket_sort<=3 then 1 else 0 end) mark_target_recordfrom bucket_sort
)
-- 分钟 <= 3 且 3小时 <= 50 标记为 GPT4
,mark_models as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,minute_bucket_sort,hour_bucket_sort,mark_target_record,(case when mark_target_record=1 and row_number() over(partition by user_id,hour_bucket,mark_target_record order by request_time)<=50 then 'GPT4' else 'GPT3.5' end) mark_modelfrom mark_chatlog
)
select *
from mark_models
order by user_id,request_time

修改为叠加的逻辑之后,效果如下:
image.png

计算 Token 数,根据分好的模型聚合求和即可。

with 
-- 分桶
cut_bucket as(select user_id,request_time,prompt_tokens,output_tokens,ceil((request_time-min(request_time)over(partition by user_id))/60) minute_bucket,ceil((request_time-min(request_time)over(partition by user_id))/60/60/3) hour_bucketfrom chat_logs
)
-- 排序
,bucket_sort as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,row_number()over(partition by user_id,minute_bucket order by request_time) minute_bucket_sort,row_number()over(partition by user_id,hour_bucket order by request_time) hour_bucket_sortfrom cut_bucket
)
-- 对分钟的排序数据进行分类
,mark_chatlog as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,minute_bucket_sort,hour_bucket_sort,(case when minute_bucket_sort<=3 then 1 else 0 end) mark_target_recordfrom bucket_sort
)
-- 分钟 <= 3 且 3小时 <= 50 标记为 GPT4
,mark_models as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,minute_bucket_sort,hour_bucket_sort,mark_target_record,(case when mark_target_record=1 and row_number() over(partition by user_id,hour_bucket,mark_target_record order by request_time)<=50 then 'GPT4' else 'GPT3.5' end) mark_modelfrom mark_chatlog
)
-- 聚合求 Tokens
select mark_model,sum(prompt_tokens)/1000 k_input_tokens,sum(output_tokens)/1000 k_output_tokens
from mark_models
group by mark_model

统计结果如下:
image.png
计算调整前后成本:

with 
-- 分桶
cut_bucket as(select user_id,request_time,prompt_tokens,output_tokens,ceil((request_time-min(request_time)over(partition by user_id))/60) minute_bucket,ceil((request_time-min(request_time)over(partition by user_id))/60/60/3) hour_bucketfrom chat_logs
)
-- 排序
,bucket_sort as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,row_number()over(partition by user_id,minute_bucket order by request_time) minute_bucket_sort,row_number()over(partition by user_id,hour_bucket order by request_time) hour_bucket_sortfrom cut_bucket
)
-- 对分钟的排序数据进行分类
,mark_chatlog as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,minute_bucket_sort,hour_bucket_sort,(case when minute_bucket_sort<=3 then 1 else 0 end) mark_target_recordfrom bucket_sort
)
-- 分钟 <= 3 且 3小时 <= 50 标记为 GPT4
,mark_models as(select user_id,request_time,prompt_tokens,output_tokens,minute_bucket,hour_bucket,minute_bucket_sort,hour_bucket_sort,mark_target_record,(case when mark_target_record=1 and row_number() over(partition by user_id,hour_bucket,mark_target_record order by request_time)<=50 then 'GPT4' else 'GPT3.5' end) mark_modelfrom mark_chatlog
)
-- 聚合求 Tokens
,k_tokens as(select mark_model,sum(prompt_tokens)/1000 k_input_tokens,sum(output_tokens)/1000 k_output_tokensfrom mark_modelsgroup by mark_model
)
-- gpt-4:input 0.03,output 0.06
-- gpt-3:input 0.0010,output 0.0020
select sum(0.0010*k_input_tokens+0.0020*k_output_tokens) "调整前成本",sum(if(mark_model='GPT4',0.03,0.0010)*k_input_tokens+if(mark_model='GPT4',0.06,0.0020)*k_output_tokens) "调整后成本"
from k_tokens

统计结果如下:
image.png
调整前后成本相差 27 倍。

使用 Python 实现

同样,使用 Python 实现比 SQL 实现多加了一步:读取数据,并转化为数组。之后的逻辑也是大同小异:求最小时间->求时间差值->分桶->1分钟排序和分类->3 小时排序和最终分类->分类求 Token->计算成本。

读取数据表,使用sql读取数据库数据,并使用 Pandas 转为 DataFrame。

import pandas as pd
from sqlalchemy import create_engine
def get_datas(sql):# 连接数据库# engine = create_engine("mysql+pymysql://用户名:密码@主机地址:端口号/数据库名")connect_info = 'mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'\.format("root", "123123", "127.1.1.0", "3306","testdb")engine = create_engine(connect_info)# 执行SQL语句prox = engine.execute(sql)df = pd.DataFrame(list(prox),columns=prox.keys())return df
sql = 'select * from testdb.chat_logs'
df = get_datas(sql)

取最小请求时间,并合并到原来的数据框。

#取每个key的最小请求时间
df_mintime = df.groupby(['user_id'])['request_time'].min().reset_index()
#合并到原DataFrame
df = df.merge(df_mintime,on='user_id',how='left',suffixes=['','_min'])

将请求时间和最小请求时间求差值。

#将请求时间和最小请求时间求差值;  
df['diff_time'] = df.request_time-df.request_time_min

分桶,保持单位一致,即 1 分钟转为 60 秒,3 小时转为 60603 秒。
使用math.ceil()向上取整。

#根据差值进行分桶,两层:1 分钟 和 3 小时,都向上取整数; 
import math
df['minute_bucket'] = df.diff_time.apply(lambda x:math.ceil(x/60))
df['hour_bucket'] = df.diff_time.apply(lambda x:math.ceil(x/60/60/3))

对 1 分钟的桶排序和分类:不超过 3 次的为一类用 1 标识,其他的为另外一类,用 0 表示。

#对 1 分钟的桶和 user_id 分组,按请求时间排序; 
df['minute_bucket_sort'] = df.groupby(['user_id','minute_bucket'])['request_time'].rank(ascending=True,method='first')
#对 1 分钟不超过 3 次和大于 3 次的部分进行分组
df['mark_target_record'] = df.minute_bucket_sort.apply(lambda x:1 if x<=3 else 0)

3 小时的桶排序,根据用户、分桶和 1 分钟的分类进行分组,按请求时间排序。

#3小时的桶排序
df['hour_bucket_sort'] = df.groupby(['user_id','hour_bucket','mark_target_record'])['request_time'].rank(ascending=True,method='first')

最终分类:minute_bucket_sort<=3,且hour_bucket_sort<=50为 GPT4,其他为 GPT3.5。

#最终分类
df['mark_model']  = df[['minute_bucket_sort','hour_bucket_sort']].apply(lambda x:'GPT4' if x[0]<=3 and x[1]<=50 else 'GPT3.5',axis=1)

分类聚合求 Tokens

#按请求日期和模型聚合,统计Tokens 和价格
df_1 = df.groupby(['mark_model'])['prompt_tokens','output_tokens'].sum().reset_index()
df_1['k_input_tokens'] = df_1.prompt_tokens/1000
df_1['k_output_tokens'] = df_1.output_tokens/1000
df_1[['mark_model','k_input_tokens','k_output_tokens']]

结果如下,再除以 1000 就是上面 SQL 的结果。
image.png

求最终调整前后成本

#求调整前后成本
#gpt-4:input 0.03,output 0.06
#gpt-3:input 0.0010,output 0.0020
input_price_4 = 0.03
input_price_3 = 0.0010
output_price_4 = 0.06
output_price_3 = 0.0020
df_1['调整前成本'] = df_1[['mark_model','k_input_tokens','k_output_tokens']].apply(lambda x:x[1]*input_price_3+x[2]*output_price_3,axis=1)
df_1['调整后成本'] = df_1[['mark_model','k_input_tokens','k_output_tokens']].apply(lambda x:x[1]*input_price_4+x[2]*output_price_4 if x[0]=='GPT4' else x[1]*input_price_3+x[2]*output_price_3,axis=1)
df_1[['调整前成本','调整后成本']].sum()

image.png

Python 完整代码:

import pandas as pd
from sqlalchemy import create_engine#连接数据库读取数据,并转为 DataFrame
def get_datas(sql):# 连接数据库# engine = create_engine("mysql+pymysql://用户名:密码@主机地址:端口号/数据库名")connect_info = 'mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'\.format("root", "123123", "127.1.1.0", "3306","testdb")engine = create_engine(connect_info)# 执行SQL语句prox = engine.execute(sql)data = list()for result in prox:cur = dict()#     print(result)for k, v in result._mapping.items(): # 不用 _mapping 也可以,后续会被弃用而已cur[k] = vdata.append(cur)df = pd.DataFrame(data)return df
sql = 'select * from testdb.chat_logs'
df = get_datas(sql)#取每个key的最小请求时间
df_mintime = df.groupby(['user_id'])['request_time'].min().reset_index()
#合并到原DataFrame
df = df.merge(df_mintime,on='user_id',how='left',suffixes=['','_min'])#将请求时间和最小请求时间求差值;  
df['diff_time'] = df.request_time-df.request_time_min#根据差值进行分桶,两层:1 分钟 和 3 小时,都向上取整数; 
import math
df['minute_bucket'] = df.diff_time.apply(lambda x:math.ceil(x/60))
df['hour_bucket'] = df.diff_time.apply(lambda x:math.ceil(x/60/60/3))#对 1 分钟的桶和 user_id 分组,按请求时间排序; 
df['minute_bucket_sort'] = df.groupby(['user_id','minute_bucket'])['request_time'].rank(ascending=True,method='first')
#对 1 分钟不超过 3 次和大于 3 次的部分进行分组
df['mark_target_record'] = df.minute_bucket_sort.apply(lambda x:1 if x<=3 else 0)
#3小时的桶排序
df['hour_bucket_sort'] = df.groupby(['user_id','hour_bucket','mark_target_record'])['request_time'].rank(ascending=True,method='first')
#最终分类
df['mark_model']  = df[['minute_bucket_sort','hour_bucket_sort']].apply(lambda x:'GPT4' if x[0]<=3 and x[1]<=50 else 'GPT3.5',axis=1)#按请求日期和模型聚合,统计Tokens 和价格
df_1 = df.groupby(['mark_model'])['prompt_tokens','output_tokens'].sum().reset_index()
df_1['k_input_tokens'] = df_1.prompt_tokens/1000
df_1['k_output_tokens'] = df_1.output_tokens/1000
df_1[['mark_model','k_input_tokens','k_output_tokens']]#求调整前后成本
#gpt-4:input 0.03,output 0.06
#gpt-3:input 0.0010,output 0.0020
input_price_4 = 0.03
input_price_3 = 0.0010
output_price_4 = 0.06
output_price_3 = 0.0020
df_1['调整前成本'] = df_1[['mark_model','k_input_tokens','k_output_tokens']].apply(lambda x:x[1]*input_price_3+x[2]*output_price_3,axis=1)
df_1['调整后成本'] = df_1[['mark_model','k_input_tokens','k_output_tokens']].apply(lambda x:x[1]*input_price_4+x[2]*output_price_4 if x[0]=='GPT4' else x[1]*input_price_3+x[2]*output_price_3,axis=1)
df_1[['调整前成本','调整后成本']].sum()

小结

从上面的两个案例来看,成本都是以十倍上涨,不过加了限制,最高也不会超过官方标价的倍数(30 倍)。
但无论如何,成本较之前都是很高的。
如果想要保证用户体验好、可以多用GPT4、成本又不高,那是很难的。
当然,解决办法还是有的:

  • 用户层面:可以搞会员制,要求不高的,用用GPT3.5,要求高的多掏钱买个会员。
  • 供应商层面:降低成本,这个要拼渠道了。

没有完美的,只有合适的,看需求搞事情~

这篇关于GPT3.5 改用 GPT4 价格翻了30倍 如何破局? GPT 对话成本推演的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/557812

相关文章

30常用 Maven 命令

Maven 是一个强大的项目管理和构建工具,它广泛用于 Java 项目的依赖管理、构建流程和插件集成。Maven 的命令行工具提供了大量的命令来帮助开发人员管理项目的生命周期、依赖和插件。以下是 常用 Maven 命令的使用场景及其详细解释。 1. mvn clean 使用场景:清理项目的生成目录,通常用于删除项目中自动生成的文件(如 target/ 目录)。共性规律:清理操作

4B参数秒杀GPT-3.5:MiniCPM 3.0惊艳登场!

​ 面壁智能 在 AI 的世界里,总有那么几个时刻让人惊叹不已。面壁智能推出的 MiniCPM 3.0,这个仅有4B参数的"小钢炮",正在以惊人的实力挑战着 GPT-3.5 这个曾经的AI巨人。 MiniCPM 3.0 MiniCPM 3.0 MiniCPM 3.0 目前的主要功能有: 长上下文功能:原生支持 32k 上下文长度,性能完美。我们引入了

2024网安周今日开幕,亚信安全亮相30城

2024年国家网络安全宣传周今天在广州拉开帷幕。今年网安周继续以“网络安全为人民,网络安全靠人民”为主题。2024年国家网络安全宣传周涵盖了1场开幕式、1场高峰论坛、5个重要活动、15场分论坛/座谈会/闭门会、6个主题日活动和网络安全“六进”活动。亚信安全出席2024年国家网络安全宣传周开幕式和主论坛,并将通过线下宣讲、创意科普、成果展示等多种形式,让广大民众看得懂、记得住安全知识,同时还

GPT系列之:GPT-1,GPT-2,GPT-3详细解读

一、GPT1 论文:Improving Language Understanding by Generative Pre-Training 链接:https://cdn.openai.com/research-covers/languageunsupervised/language_understanding_paper.pdf 启发点:生成loss和微调loss同时作用,让下游任务来适应预训

速通GPT-3:Language Models are Few-Shot Learners全文解读

文章目录 论文实验总览1. 任务设置与测试策略2. 任务类别3. 关键实验结果4. 数据污染与实验局限性5. 总结与贡献 Abstract1. 概括2. 具体分析3. 摘要全文翻译4. 为什么不需要梯度更新或微调⭐ Introduction1. 概括2. 具体分析3. 进一步分析 Approach1. 概括2. 具体分析3. 进一步分析 Results1. 概括2. 具体分析2.1 语言模型

c++习题30-求10000以内N的阶乘

目录 一,题目  二,思路 三,代码    一,题目  描述 求10000以内n的阶乘。 输入描述 只有一行输入,整数n(0≤n≤10000)。 输出描述 一行,即n!的值。 用例输入 1  4 用例输出 1  24   二,思路 n    n!           0    1 1    1*1=1 2    1*2=2 3    2*3=6 4

嵌入式面试经典30问:二

1. 嵌入式系统中,如何选择合适的微控制器或微处理器? 在嵌入式系统中选择合适的微控制器(MCU)或微处理器(MPU)时,需要考虑多个因素以确保所选组件能够满足项目的具体需求。以下是一些关键步骤和考虑因素: 1.1 确定项目需求 性能要求:根据项目的复杂度、处理速度和数据吞吐量等要求,确定所需的处理器性能。功耗:评估系统的功耗需求,选择低功耗的MCU或MPU以延长电池寿命或减少能源消耗。成本

MiniCPM-V: A GPT-4V Level MLLM on Your Phone

MiniCPM-V: A GPT-4V Level MLLM on Your Phone 研究背景和动机 现有的MLLM通常需要大量的参数和计算资源,限制了其在实际应用中的范围。大部分MLLM需要部署在高性能云服务器上,这种高成本和高能耗的特点,阻碍了其在移动设备、离线和隐私保护场景中的应用。 文章主要贡献: 提出了MiniCPM-V系列模型,能在移动端设备上部署的MLLM。 性能优越:

【全网最全】2024年数学建模国赛A题30页完整建模文档+17页成品论文+保奖matla代码+可视化图表等(后续会更新)

您的点赞收藏是我继续更新的最大动力! 一定要点击如下的卡片,那是获取资料的入口! 【全网最全】2024年数学建模国赛A题30页完整建模文档+17页成品论文+保奖matla代码+可视化图表等(后续会更新)「首先来看看目前已有的资料,还会不断更新哦~一次购买,后续不会再被收费哦,保证是全网最全资源,随着后续内容更新,价格会上涨,越早购买,价格越低,让大家再也不需要到处买断片资料啦~💰💸👋」�

JobScheduler 调用导致的运行时长30分钟的功耗问题

一、SDK 的使用情况与功耗影响 案例是否导致功耗变大onStartJob return true 且子线程没有调用jobFinished()告知系统功耗变大,最长带来30分钟的partial wakelock 长持锁onStartJob return true 且子线程调用jobFinished()告知系统功耗有影响,主要线程执行时长,标准是30秒内onStartJob return fals