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

场景介绍

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

方案阐述

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

如果要求更精确一些，就需要根据每一次问答的输入 Token 数和输出 Token 数，分别求和，计算有多少 k Tokens，然后算一个占比，看看各自的消费占比，分别乘以输入和输出的价格倍数。

以上是直接接官方的情况，但是更多时候，可能是通过第三方服务，第三方的价格不是根据官方定价，会有出入，需要结合第三方价格具体分析。

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

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

Model	Input	Output
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_tokens
  from 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_tokens
  from 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_sort
  from 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

根据 Tokens 计算成本。

with chat_logs_format as(
  -- 格式化时间
  select user_id,from_unixtime(request_time,'%Y-%m-%d') request_date,request_time,prompt_tokens,output_tokens
  from 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_sort
  from 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_tokens
  from chat_sort
  group 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

调整前后成本相差还是挺大的，调整后成本是调整前的 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)

将时间戳格式化

#将 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']]

计算成本

-- 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()

案例2：限制每分钟不超过 3 次，每 3 小时不超过 50 次（频率限制）

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

过程算法其实也有多种：
比如说按自然分钟计算，每分钟为一个单位；按自然小时计算，0_2、35、6_8、911、12_14、1517、18_20、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_bucket
  from 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_bucket
  from 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_sort
  from 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_model
  from 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

然后再计算成本，完事！
直接计算minute_bucket_sort<=3且hour_bucket_sort<=50就可以了？
不不不！这里有坑，先不聚合，查看明细数据看看，如下图第一个红框，它不符合 1 分钟 3 次上限的逻辑，所以被剔除了，标记为 GPT3.5。而第二个框，它不符合 3 小时 50 次上限的逻辑，所以也被剔除了。
不知道你是否意识到了问题，通过肉眼看，第二个框的 3 条记录应该是要被统计到 3 小时 50 次上限的逻辑的，因为前面因为 1 分钟的限制多剔除了 3 条记录。
所以在 3 小时的桶里面排序的时候，需要建立 1 分钟的桶的基础之上，先保证每一条记录都符合 1 分钟的逻辑，再针对这些记录拿 3 小时的逻辑加以限制。

修改 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_bucket
  from 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_sort
  from 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_record
  from 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_model
  from mark_chatlog
)
select *
from mark_models
order by user_id,request_time

修改为叠加的逻辑之后，效果如下：

计算 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_bucket
  from 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_sort
  from 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_record
  from 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_model
  from 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

统计结果如下：

计算调整前后成本：

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_bucket
  from 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_sort
  from 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_record
  from 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_model
  from mark_chatlog
)
-- 聚合求 Tokens
,k_tokens as(
  select mark_model,sum(prompt_tokens)/1000 k_input_tokens,sum(output_tokens)/1000 k_output_tokens
  from mark_models
  group 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

统计结果如下：

调整前后成本相差 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 的结果。

求最终调整前后成本

#求调整前后成本
#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()

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] = v
        data.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，要求高的多掏钱买个会员。
• 供应商层面：降低成本，这个要拼渠道了。

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