计算与预测 API 成本

为什么成本预测很重要

OpenAI 的定价结构

成本估算辅助函数

import tiktoken

# Prices per million tokens as of early 2025
PRICING = {
    'gpt-4o': {'input': 2.50, 'output': 10.00},
    'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
    'gpt-4-turbo': {'input': 10.00, 'output': 30.00},
    'text-embedding-3-small': {'input': 0.02, 'output': 0.0},
}

def estimate_cost(messages, model='gpt-4o-mini', expected_output_tokens=500):
    enc = tiktoken.encoding_for_model(model)
    input_tokens = sum(
        len(enc.encode(m.get('content', ''))) + 4
        for m in messages
    ) + 3

    if model not in PRICING:
        raise ValueError(f'Unknown model: {model}')

    rates = PRICING[model]
    input_cost = (input_tokens / 1_000_000) * rates['input']
    output_cost = (expected_output_tokens / 1_000_000) * rates['output']
    total = input_cost + output_cost

    print(f'Model: {model}')
    print(f'Input tokens: {input_tokens} (${input_cost:.6f})')
    print(f'Est. output tokens: {expected_output_tokens} (${output_cost:.6f})')
    print(f'Estimated total: ${total:.6f}')
    return total

从 API 响应跟踪实际成本

import openai

client = openai.OpenAI()

PRICING = {
    'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
}

def chat_with_cost_tracking(model, messages):
    response = client.chat.completions.create(
        model=model, messages=messages
    )
    usage = response.usage
    rates = PRICING.get(model, {'input': 0, 'output': 0})
    actual_cost = (
        (usage.prompt_tokens / 1_000_000) * rates['input'] +
        (usage.completion_tokens / 1_000_000) * rates['output']
    )
    print(f'Input: {usage.prompt_tokens} tokens')
    print(f'Output: {usage.completion_tokens} tokens')
    print(f'Total: {usage.total_tokens} tokens')
    print(f'Actual cost: ${actual_cost:.6f}')
    return response, actual_cost

预测每月成本

def project_monthly_cost(
    avg_cost_per_request,
    requests_per_day,
    days=30
):
    daily_cost = avg_cost_per_request * requests_per_day
    monthly_cost = daily_cost * days

    print(f'Avg cost/request: ${avg_cost_per_request:.6f}')
    print(f'Requests/day: {requests_per_day:,}')
    print(f'Daily cost: ${daily_cost:.2f}')
    print(f'Monthly cost: ${monthly_cost:.2f}')

    # Growth scenarios
    for multiplier in [2, 5, 10]:
        scaled = monthly_cost * multiplier
        print(f'  At {multiplier}x traffic: ${scaled:.2f}/month')

# Example: customer support bot
project_monthly_cost(
    avg_cost_per_request=0.002,  # 2 cents per support query
    requests_per_day=5000
)

模型选择对成本的影响

提示词长度与成本

通过批处理提高成本效率

import openai
import json

client = openai.OpenAI()

# Create batch request file
requests = [
    {'custom_id': f'doc-{i}',
     'method': 'POST',
     'url': '/v1/chat/completions',
     'body': {
         'model': 'gpt-4o-mini',
         'messages': [{'role': 'user', 'content': f'Summarize document {i}'}],
         'max_tokens': 200
     }}
    for i in range(100)
]

# Write to JSONL
with open('/tmp/batch_input.jsonl', 'w') as f:
    for req in requests:
        f.write(json.dumps(req) + '\n')

# Upload and submit (50% off list price)
print('Would submit batch for 100 documents at 50% discount')
# batch_file = client.files.create(file=open('/tmp/batch_input.jsonl','rb'), purpose='batch')
# batch = client.batches.create(input_file_id=batch_file.id, endpoint='/v1/chat/completions', completion_window='24h')

设置支出限额

通过缓存避免重复的 API 调用

import hashlib
import json

# Simple in-memory cache (use Redis in production)
_cache = {}

def cached_completion(client, model, messages, **kwargs):
    cache_key = hashlib.sha256(
        json.dumps({'model': model, 'messages': messages}).encode()
    ).hexdigest()

    if cache_key in _cache:
        print('Cache HIT - no API call made')
        return _cache[cache_key]

    response = client.chat.completions.create(
        model=model, messages=messages, **kwargs
    )
    _cache[cache_key] = response
    print('Cache MISS - API call made')
    return response

构建成本仪表板

快速检查

课程回顾