计算对 ChatGPT 的 API 请求（包括函数）的总令牌

Question

Stack Overflow 社区您好，

我一直致力于将 ChatGPT 的 API 集成到我的项目中，但在计算 API 请求的令牌总数时遇到了一些问题。具体来说，我在 API 调用中传递消息和函数。

我已经设法弄清楚如何计算消息的令牌计数，但我不确定如何计算函数使用的令牌。

有人可以指导我如何正确计算对 ChatGPT API 的请求的总令牌数（包括消息和函数）吗？

任何帮助或见解将不胜感激！

提前谢谢您。

我一直致力于通过以不同方式格式化调用中的数据来暴力破解解决方案。我一直在使用 tokenizer 和 Tiktokenizer 来测试我的格式。

Answer 1

我将引导您计算 gpt-3.5 和 gpt-4 的令牌。您可以将类似的方法应用于其他模型，您只需要找到正确的设置即可。

我们将分别计算消息和函数使用的代币，然后将它们最后相加得到总数。

留言

首先使用 tiktoken 获取标记生成器。我们将使用它来标记消息和函数中的所有自定义文本。还要为 API 将添加到请求的额外令牌添加常量。

enc = tiktoken.encoding_for_model(model)

创建一个变量来保存消息的总令牌并将其设置为 0。

msg_token_count = 0

循环消息，并为每条消息添加 3 到

msg_token_count

。然后循环遍历消息中的每个元素并对值进行编码，将编码对象的长度添加到

msg_token_count

。如果字典设置了“name”键，则向

msg_token_count

添加一个附加标记。

for message in messages:
    msg_token_count += 3  # Add tokens for each message
    for key, value in message.items():
        msg_token_count += len(enc.encode(value))  # Add tokens in set message
        if key == "name":
            msgTokenCount += 1 # Add token if name is set

最后我们需要将 3 添加到

msg_token_count

，作为结束标记。

msgTokenCount += 3 # Add tokens to account for ending

功能

现在我们将计算函数将占用的令牌数量。

首先创建一个变量来保存函数使用的总标记并将其设置为 0。

func_token_count = 0

接下来我们将循环遍历这些函数并向

func_token_count

添加标记。循环遍历函数并将每个函数的

func_token_count

加 7。然后添加编码名称和描述的长度。

对于每个函数，如果它有属性，则将 3 添加到

func_token_count

。然后，对于属性中的每个键，再添加 3 和编码属性的长度，如果它有“枚举”键，请确保减去 3，并为枚举部分中的每个项目添加 3。

最后，将 12 添加到

func_token_count

以计算所有函数末尾的令牌。

for function in functions:
    func_token_count += 7  # Add tokens for start of each function
    f_name = function["name"]
    f_desc = function["description"]
    if f_desc.endswith("."):
        f_desc = f_desc[:-1]
    line = f_name + ":" + f_desc
    func_token_count += len(enc.encode(line))  # Add tokens for set name and description
    if len(function["parameters"]["properties"]) > 0:
        func_token_count += 3  # Add tokens for start of each property
        for key in list(function["parameters"]["properties"].keys()):
            func_token_count += 3  # Add tokens for each set property
            p_name = key
            p_type = function["parameters"]["properties"][key]["type"]
            p_desc = function["parameters"]["properties"][key]["description"]
            if "enum" in function["parameters"]["properties"][key].keys():
                func_token_count += 3  # Add tokens if property has enum list
                for item in function["parameters"]["properties"][key]["enum"]:
                    func_token_count += 3
                    func_token_count += len(enc.encode(item))
            if p_desc.endswith("."):
                p_desc = p_desc[:-1]
            line = f"{p_name}:{p_type}:{p_desc}"
            func_token_count += len(enc.encode(line))
func_token_count += 12

这是完整的代码。请注意，我没有使用硬编码附加令牌计数，而是使用常量来保存该值。

def get_token_count(model, messages, functions):
    # Initialize message settings to 0
    msg_init = 0
    msg_name = 0
    msg_end = 0
    
    # Initialize function settings to 0
    func_init = 0
    prop_init = 0
    prop_key = 0
    enum_init = 0
    enum_item = 0
    func_end = 0
    
    if model in [
        "gpt-3.5-turbo-0613",
        "gpt-4-0613"
    ]:
        # Set message settings for above models
        msg_init = 3
        msg_name = 1
        msg_end = 3
        
        # Set function settings for the above models
        func_init = 7
        prop_init = 3
        prop_key = 3
        enum_init = -3
        enum_item = 3
        func_end = 12
    
    enc = tiktoken.encoding_for_model(model)
    
    msg_token_count = 0
    for message in messages:
        msg_token_count += msg_init  # Add tokens for each message
        for key, value in message.items():
            msg_token_count += len(enc.encode(value))  # Add tokens in set message
            if key == "name":
                msg_token_count += msg_name  # Add tokens if name is set
    msg_token_count += msg_end  # Add tokens to account for ending
    
    func_token_count = 0
    if len(functions) > 0:
        for function in functions:
            func_token_count += func_init  # Add tokens for start of each function
            f_name = function["name"]
            f_desc = function["description"]
            if f_desc.endswith("."):
                f_desc = f_desc[:-1]
            line = f_name + ":" + f_desc
            func_token_count += len(enc.encode(line))  # Add tokens for set name and description
            if len(function["parameters"]["properties"]) > 0:
                func_token_count += prop_init  # Add tokens for start of each property
                for key in list(function["parameters"]["properties"].keys()):
                    func_token_count += prop_key  # Add tokens for each set property
                    p_name = key
                    p_type = function["parameters"]["properties"][key]["type"]
                    p_desc = function["parameters"]["properties"][key]["description"]
                    if "enum" in function["parameters"]["properties"][key].keys():
                        func_token_count += enum_init  # Add tokens if property has enum list
                        for item in function["parameters"]["properties"][key]["enum"]:
                            func_token_count += enum_item
                            func_token_count += len(enc.encode(item))
                    if p_desc.endswith("."):
                        p_desc = p_desc[:-1]
                    line = f"{p_name}:{p_type}:{p_desc}"
                    func_token_count += len(enc.encode(line))
        func_token_count += func_end
    
    return msg_token_count + func_token_count

如果有不清楚的地方，或者您有建议让我的帖子变得更好，请告诉我。

Answer 2

计算 GPT 4o-mini 的成本。 提示和数据将进入 API 调用，响应将是其输出。产生的（大约）总成本将达到 -

## !pip install tiktoken
import tiktoken

# Initialize the tokenizer for the GPT model
tokenizer = tiktoken.encoding_for_model("gpt-4o-mini")  

# request and response
request = str(prompt) + str(data)
response = str(out)

# Tokenize 
request_tokens = tokenizer.encode(request)
response_tokens = tokenizer.encode(response)

# Counting the total tokens for request and response separately
input_tokens = len(request_tokens)
output_tokens = len(response_tokens)

# Actual costs per 1 million tokens
cost_per_1M_input_tokens = 0.15  # $0.150 per 1M input tokens
cost_per_1M_output_tokens = 0.60  # $0.600 per 1M output tokens

# Calculate the costs
input_cost = (input_tokens / 10**6) * cost_per_1M_input_tokens
output_cost = (output_tokens / 10**6) * cost_per_1M_output_tokens
total_cost = input_cost + output_cost

print(f"Input tokens: {input_tokens}")
print(f"Output tokens: {output_tokens}")
print(f"Total tokens: {input_tokens + output_tokens}")
print(f"Cost: ${total_cost:.5f}")