ChatGPT选择模型入门指南：从原理到实战避坑

1次阅读

共计 3525 个字符，预计需要花费 9 分钟才能阅读完成。

ChatGPT 系列模型（如 GPT-3.5、GPT- 4 等）在不同业务场景下表现差异显著。选择合适的模型可以：

降低 30%-70% 的 API 调用成本
将响应速度提升 2 - 5 倍
针对特定任务获得更精准的结果

以客服场景为例：简单问答用 GPT-3.5 足够，但需要复杂逻辑推理时 GPT- 4 的错误率能降低 40%。

模型	输入成本 (每 1k tokens)	输出成本 (每 1k tokens)	平均响应延迟	最佳适用场景
gpt-3.5-turbo	$0.0015	$0.002	300-500ms	常规对话、基础文本处理
gpt-4	$0.03	$0.06	1.5-3s	复杂推理、专业领域咨询
gpt-4-turbo	$0.01	$0.03	800ms-1.2s	平衡成本与性能的折中选择

实际测试发现：当处理超过 2000tokens 的长文本时，GPT- 4 的上下文理解能力明显优于 3.5 版本。

from typing import Literal, Optional
import openai
from tenacity import retry, stop_after_attempt, wait_exponential

ModelType = Literal['gpt-3.5-turbo', 'gpt-4', 'gpt-4-turbo']

class ModelSelector:
    """
    根据内容和性能需求自动选择最优模型
    :param budget: 预算限制（美元 / 请求）:param max_latency: 最大允许延迟（毫秒）"""
    def __init__(self, budget: float = 0.02, max_latency: int = 1500):
        self.budget = budget
        self.max_latency = max_latency

    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
    async def select_model(
        self, 
        prompt: str, 
        require_high_accuracy: bool = False
    ) -> ModelType:
        """
        智能选择模型算法：1. 根据文本长度初步筛选
        2. 结合预算和延迟要求二次过滤
        3. 精度要求作为最终判断条件
        """
        estimated_tokens = len(prompt) // 4  # 简易 token 估算

        # 第一阶段筛选
        candidate_models = []
        if estimated_tokens < 3000:
            candidate_models.append('gpt-3.5-turbo')
        if estimated_tokens < 8000:
            candidate_models.append('gpt-4-turbo')
        if require_high_accuracy:
            candidate_models.append('gpt-4')

        # 第二阶段：成本过滤
        viable_models = [
            m for m in candidate_models 
            if self._estimate_cost(m, estimated_tokens) <= self.budget
        ]

        # 返回最优解（按性能排序）priority_order = ['gpt-4-turbo', 'gpt-4', 'gpt-3.5-turbo']
        for model in priority_order:
            if model in viable_models:
                return model

        # 兜底方案
        return 'gpt-3.5-turbo'

    def _estimate_cost(self, model: ModelType, tokens: int) -> float:
        """成本估算函数"""
        rates = {
            'gpt-3.5-turbo': 0.0015/1000,
            'gpt-4': 0.03/1000,
            'gpt-4-turbo': 0.01/1000
        }
        return rates[model] * tokens

关键实现要点：

使用 tenacity 库实现自动重试机制
通过 Literal 类型限定模型选项
采用分层筛选策略平衡性能和成本
包含简单的 token 估计算法

import asyncio
from datetime import datetime

async def stress_test(model: ModelType, requests: int = 100):
    """
    压力测试工具：:param requests: 并发请求数
    :return: 平均延迟和错误率
    """
    tasks = []
    start = datetime.now()

    async def _single_request():
        try:
            start_req = datetime.now()
            await openai.ChatCompletion.acreate(
                model=model,
                messages=[{'role': 'user', 'content': '1+1='}]
            )
            return (datetime.now() - start_req).total_seconds() * 1000
        except Exception as e:
            print(f"Request failed: {str(e)}")
            return None

    # 启动并发请求
    for _ in range(requests):
        tasks.append(asyncio.create_task(_single_request()))

    results = await asyncio.gather(*tasks)

    # 计算结果
    success = [r for r in results if r is not None]
    avg_latency = sum(success) / len(success)
    error_rate = (requests - len(success)) / requests

    print(f"{model} 测试结果：")
    print(f"• 平均延迟：{avg_latency:.2f}ms")
    print(f"• 错误率：{error_rate:.2%}")
    print(f"• 总耗时：{(datetime.now()-start).total_seconds():.2f}s")

对于 gpt-3.5-turbo：建议控制在 50 并发 / 秒以内
对于 gpt- 4 系列：不超过 10 并发 / 秒
使用 asyncio.Semaphore 实现限流：

semaphore = asyncio.Semaphore(10)  # 限制 10 并发

async def limited_request(prompt: str):
    async with semaphore:
        return await openai.ChatCompletion.acreate(
            model='gpt-4',
            messages=[{'role': 'user', 'content': prompt}]
        )

Token 计算陷阱
中文实际 token 消耗通常是字符数的 1.5- 2 倍

使用 tiktoken 库精确计算：

import tiktoken
enc = tiktoken.encoding_for_model("gpt-4")
real_tokens = len(enc.encode(prompt))

冷启动延迟
首次调用可能有 2 - 3 秒额外延迟
解决方案：
- 预热：系统启动时发送空请求
- 保持最小频率的心跳请求
速率限制应对
错误码 429 表示触发限流

推荐退避算法：

@retry(stop=stop_after_attempt(5),
    wait=wait_exponential(multiplier=1, min=4, max=60)
)
def safe_api_call():
    # API 调用代码

高级模型路由可以考虑：

实时性能监控
持续收集各模型的延迟、错误率数据
动态调整权重（类似负载均衡）

业务特征路由

def route_by_content(prompt: str) -> ModelType:
    if "法律条款" in prompt:
        return "gpt-4"
    elif len(prompt) < 500:
        return "gpt-3.5-turbo"
    else:
        return "gpt-4-turbo"