模型家族全解：Opus 4.7 / Sonnet 4.6 / Haiku 4.5 选型决策树
第二章：模型选择指南：Opus、Sonnet、Haiku 的能力边界与成本权衡
2.1 为什么模型选择是架构决策
许多开发者在刚接触 Claude API 时，有一个直觉反应：用最好的模型。这个直觉在实验阶段合理，但在生产系统中会导致严重的成本失控。一个中型 SaaS 产品，如果所有请求都路由到 claude-opus-4-6，每月的 token 消耗账单可能是合理架构下的 10-20 倍。
模型选择本质上是一个多维优化问题，涉及：
- 任务复杂度：这个任务真正需要多强的推理能力？
- 延迟要求：用户愿意等多久？
- 吞吐量：每天要处理多少请求？
- 准确性容忍度：5% 的错误率是否可接受？
- 成本预算：每 1000 次请求的可接受成本上限是多少？
本章提供一套系统性的决策框架，帮助你在具体场景下做出理性的模型选择。
2.2 能力边界的量化理解
推理深度：最显著的差距所在
三档模型之间差距最显著的维度是多步推理。下面用一个具体例子说明：
任务：给定一段 500 行的 Python 代码，找出其中的线程安全问题并解释为什么会在生产环境中偶发性触发（而非每次运行都触发）。
| 模型 | 典型表现 |
|---|---|
| Haiku | 能找到明显的竞态条件，但对偶发性触发的机制解释不准确，可能遗漏复杂的锁层次问题 |
| Sonnet | 能找到大多数问题，对偶发性触发有合理的解释，偶尔遗漏细微的 ABA 问题 |
| Opus | 能系统性地识别所有问题，给出精确的触发条件分析（包括 CPU 缓存行、内存屏障等底层机制），提供优先级排序 |
这种差距的量化来源于学术基准测试：
MMLU（知识广度）：
Opus: ~88%
Sonnet: ~83%
Haiku: ~75%
HumanEval（代码生成）：
Opus: ~75%
Sonnet: ~70%
Haiku: ~60%
MATH（数学推理）：
Opus: ~60%
Sonnet: ~50%
Haiku: ~35%
注意：MATH 基准上的差距最大，这意味着在涉及严格数学推理的任务上，Haiku 与 Opus 之间的能力鸿沟是最深的。
指令遵循：差距小于推理
在严格遵循复杂指令方面，三档模型的差距相对较小。如果你的 system prompt 有 30 条格式规则，Haiku 通常也能遵循其中 25-28 条。这意味着对于格式化输出、结构化提取等任务，Haiku 往往是性价比最高的选择。
长上下文处理：注意"中间遗忘"现象
所有三档模型都支持 200K tokens 的上下文窗口，但长上下文处理能力存在显著差异。研究表明，大型语言模型在处理超长上下文时存在"lost in the middle"现象：放在文档中间的信息比开头和结尾更难被模型准确检索。
Long Context Recall 测试（信息放置位置 vs 准确率）：
准确率
100% ┤
90% ┤ ████████████████ ██████████████████
80% ┤ ████████████
70% ┤
└─────────────────────────────────────────────→ 位置
文档开头 文档结尾
Opus 在这个测试中的中间位置准确率约为 85%，而 Haiku 约为 65%。如果你的任务依赖于从超长文档中精确检索中段信息，这个差距很重要。
2.3 成本分析：真实场景下的数字
成本计算必须基于真实的 token 消耗模式，而不是官方的每百万 token 定价表。让我们用几个典型场景来说明。
场景一：客服聊天机器人
假设：
- 平均每轮对话：用户输入 150 tokens + 系统提示 500 tokens + 历史 800 tokens = 1450 输入 tokens
- 平均输出：300 tokens
- 每日请求量：10,000 次
# 每日成本计算
haiku_daily = (10000 * 1450 / 1_000_000 * 0.25) + (10000 * 300 / 1_000_000 * 1.25)
# = $3.625 + $3.75 = $7.375/天
sonnet_daily = (10000 * 1450 / 1_000_000 * 3.0) + (10000 * 300 / 1_000_000 * 15.0)
# = $43.5 + $45.0 = $88.5/天
opus_daily = (10000 * 1450 / 1_000_000 * 15.0) + (10000 * 300 / 1_000_000 * 75.0)
# = $217.5 + $225.0 = $442.5/天
年化成本对比：
- Haiku：约 $2,700/年
- Sonnet：约 $32,300/年
- Opus：约 $161,500/年
对于这个场景，如果 Haiku 的错误率在可接受范围内，选择 Haiku 可以节省约 95% 的模型成本。
场景二：代码审查工具
假设：
- 平均每次审查：系统提示 1000 tokens + 代码 3000 tokens + 输出 1500 tokens
- 每日请求量：500 次
haiku_daily = (500 * 4000 / 1_000_000 * 0.25) + (500 * 1500 / 1_000_000 * 1.25)
# = $0.5 + $0.9375 = $1.4375/天
sonnet_daily = (500 * 4000 / 1_000_000 * 3.0) + (500 * 1500 / 1_000_000 * 15.0)
# = $6.0 + $11.25 = $17.25/天
opus_daily = (500 * 4000 / 1_000_000 * 15.0) + (500 * 1500 / 1_000_000 * 75.0)
# = $30.0 + $56.25 = $86.25/天
对于代码审查，质量重要性更高。如果 Sonnet 能达到 95% 的 Opus 质量，而成本仅为 Opus 的 20%，Sonnet 通常是更合理的选择。
场景三：内容批量生成
假设：
- 每次生成：系统提示 500 tokens + 用户指令 200 tokens + 输出 2000 tokens
- 每日请求量：2,000 次（批处理，非实时）
这个场景的特点是：对延迟不敏感，但对成本敏感，对质量有一定要求。
推荐方案：使用 Sonnet + Batch API（批处理 API 有 50% 折扣）
sonnet_batch_daily = (2000 * 700 / 1_000_000 * 1.5) + (2000 * 2000 / 1_000_000 * 7.5)
# 使用批处理折扣后：输入 $1.5/M，输出 $7.5/M
# = $2.1 + $30.0 = $32.1/天
2.4 决策框架：五步选模型法
Step 1：确定任务类型
首先将任务归入以下类别之一：
任务类型分类树：
是否需要长链推理（>3步逻辑）？
├─ 是 → 是否涉及数学/代码复杂性？
│ ├─ 是 → Opus（或 Sonnet+Extended Thinking）
│ └─ 否 → Sonnet
└─ 否 → 是否以输出格式为主（提取/分类）？
├─ 是 → Haiku
└─ 否 → 是否需要高质量写作/分析？
├─ 是 → Sonnet
└─ 否 → Haiku
Step 2：评估延迟要求
| 延迟要求 | 推荐档次 |
|---|---|
| < 1s（实时交互） | Haiku |
| 1-5s（普通聊天） | Haiku 或 Sonnet |
| 5-30s（可接受的思考时间） | Sonnet 或 Opus |
| > 30s（批处理，异步） | 任意档次，优先考虑成本 |
Step 3：估算错误代价
| 错误代价 | 示例 | 推荐策略 |
|---|---|---|
| 低（可人工修正） | 草稿生成、初步分类 | Haiku |
| 中（影响用户体验） | 客服回复、代码补全 | Sonnet |
| 高（直接影响业务决策） | 合同分析、医疗咨询 | Opus + 人工审核 |
| 极高（法律/安全） | 法规合规检查 | Opus + 专业人工审核 |
Step 4：运行 A/B 对比测试
不要依赖直觉，要用数据说话。推荐的测试流程：
import anthropic
import json
client = anthropic.Anthropic()
def evaluate_models(test_cases: list[dict], models: list[str]) -> dict:
"""
对多个模型运行相同测试集，比较输出质量
Args:
test_cases: [{"prompt": str, "expected": str, "criteria": list[str]}]
models: 要测试的模型 ID 列表
Returns:
每个模型的质量分数和成本统计
"""
results = {model: {"scores": [], "input_tokens": 0, "output_tokens": 0}
for model in models}
for case in test_cases:
for model in models:
response = client.messages.create(
model=model,
max_tokens=1024,
messages=[{"role": "user", "content": case["prompt"]}]
)
output = response.content[0].text
results[model]["input_tokens"] += response.usage.input_tokens
results[model]["output_tokens"] += response.usage.output_tokens
# 用 Opus 作为评判模型（或人工评分）
score = judge_output(output, case["expected"], case["criteria"])
results[model]["scores"].append(score)
return results
def judge_output(output: str, expected: str, criteria: list[str]) -> float:
"""使用 Opus 评判输出质量"""
judge_prompt = f"""
评判以下输出是否满足要求（返回 0-100 的分数）：
评判标准：{json.dumps(criteria, ensure_ascii=False)}
期望结果：{expected}
实际输出：{output}
只返回一个整数分数，不要解释。
"""
judge_client = anthropic.Anthropic()
response = judge_client.messages.create(
model="claude-opus-4-6",
max_tokens=10,
messages=[{"role": "user", "content": judge_prompt}]
)
try:
return int(response.content[0].text.strip())
except ValueError:
return 0
Step 5：持续监控并调整
生产系统中，模型性能会随任务分布变化而变化。建议的监控指标：
关键指标：
- 用户满意度（CSAT 评分）
- 错误/投诉率
- 任务完成率
- 平均响应时间
- 每请求成本
告警阈值示例：
- 错误率 > 5%：考虑升级到更高档次模型
- 平均成本增长 > 20%：检查是否有异常长的输入
- 响应时间 p95 > 5s：考虑降级到更快模型或优化 prompt
2.5 混合模型架构
生产系统通常不是单一模型，而是根据任务类型路由到不同模型的混合架构。
路由器模式
用户请求
↓
[分类器：Haiku]
↓
┌───────────────────────────────────┐
│ 简单查询 → Haiku │
│ 中等复杂度 → Sonnet │
│ 高复杂度推理 → Opus │
│ 需要搜索 → Haiku + 工具调用 │
└───────────────────────────────────┘
实现示例：
import anthropic
client = anthropic.Anthropic()
def route_request(user_message: str) -> str:
"""
使用 Haiku 作为路由器，决定使用哪个模型处理请求
返回模型 ID
"""
routing_prompt = f"""
分析以下用户请求的复杂度，返回以下之一：
- "simple"：简单的事实查询、格式转换、简单提取
- "medium"：需要推理但不超过 3-4 步、代码生成、摘要
- "complex"：多步推理、专业分析、代码架构设计、数学证明
用户请求：{user_message}
只返回 "simple"、"medium" 或 "complex"，不要其他内容。
"""
response = client.messages.create(
model="claude-haiku-4-5-20251001", # 用最便宜的模型做路由
max_tokens=10,
messages=[{"role": "user", "content": routing_prompt}]
)
complexity = response.content[0].text.strip().lower()
model_map = {
"simple": "claude-haiku-4-5-20251001",
"medium": "claude-sonnet-4-6",
"complex": "claude-opus-4-6"
}
return model_map.get(complexity, "claude-sonnet-4-6")
def smart_complete(user_message: str, system_prompt: str = "") -> str:
"""带路由的智能补全"""
model = route_request(user_message)
messages = [{"role": "user", "content": user_message}]
kwargs = {
"model": model,
"max_tokens": 2048,
"messages": messages
}
if system_prompt:
kwargs["system"] = system_prompt
response = client.messages.create(**kwargs)
print(f"[路由到: {model}]")
return response.content[0].text
级联验证模式
对于高精度要求的场景，可以用低成本模型先生成，再用高精度模型验证：
def cascade_generate(prompt: str) -> dict:
"""
级联生成：
1. Haiku 生成初稿
2. Opus 验证并决定是否需要重新生成
"""
# 第一步：Haiku 生成
draft_response = client.messages.create(
model="claude-haiku-4-5-20251001",
max_tokens=1024,
messages=[{"role": "user", "content": prompt}]
)
draft = draft_response.content[0].text
# 第二步：Opus 验证
validation_prompt = f"""
评估以下响应的质量。如果质量足够好（准确、完整、无明显错误），
回复 "PASS"。如果需要改进，回复 "FAIL: <原因>"。
原始问题：{prompt}
响应：{draft}
"""
validation_response = client.messages.create(
model="claude-opus-4-6",
max_tokens=100,
messages=[{"role": "user", "content": validation_prompt}]
)
verdict = validation_response.content[0].text.strip()
if verdict.startswith("PASS"):
return {"model_used": "haiku", "content": draft, "validated": True}
else:
# 让 Opus 重新生成
final_response = client.messages.create(
model="claude-opus-4-6",
max_tokens=1024,
messages=[{"role": "user", "content": prompt}]
)
return {
"model_used": "opus",
"content": final_response.content[0].text,
"validated": True,
"fallback_reason": verdict
}
2.6 Extended Thinking 模式：何时开启
claude-opus-4-6 和 claude-sonnet-4-6 支持扩展思考（Extended Thinking）模式。开启后，模型在生成最终响应之前会产生一段"思考过程"token 序列（对用户可见但不计入输出 token 的限制）。
开启扩展思考的时机
| 场景 | 是否值得开启 |
|---|---|
| 数学证明 | 强烈推荐 |
| 复杂代码调试 | 推荐 |
| 多因素决策分析 | 推荐 |
| 简单问答 | 不推荐（增加延迟和成本） |
| 格式转换 | 不推荐 |
| 创意写作 | 视情况，通常不需要 |
# 开启扩展思考示例
response = client.messages.create(
model="claude-opus-4-6",
max_tokens=16000,
thinking={
"type": "enabled",
"budget_tokens": 10000 # 给思考过程分配最多 10K tokens
},
messages=[{
"role": "user",
"content": "证明：对任意正整数 n，n^5 - n 能被 30 整除。"
}]
)
# 输出包含 thinking block 和 text block
for block in response.content:
if block.type == "thinking":
print(f"[思考过程 - {len(block.thinking)} 字符]")
elif block.type == "text":
print(f"[最终答案]\n{block.text}")
扩展思考的成本
思考过程 tokens 按照与正常 token 相同的价格计费（输出价格）。因此，如果你设置 budget_tokens=10000，在最坏情况下，每次请求的成本会增加最多 10000 / 1,000,000 * $75 = $0.75（对于 Opus）。要谨慎设置 budget_tokens，从较小值（如 2000-5000）开始测试。
2.7 常见决策误区
误区一：总是用最新模型
模型版本号更大不等于对你的任务更好。claude-haiku-4-5-20251001 对于简单提取任务可能比 claude-opus-4-6 性价比高出 60 倍，而质量差距可以忽略不计。
误区二：忽略延迟的复合效应
在一个多步 Agent 工作流中，如果每一步都使用 Opus（假设平均 8s/请求），10 步工作流的总延迟是 80s。用 Sonnet（假设 3s/请求）完成同样 10 步，总延迟 30s。对于需要多轮工具调用的 agentic 任务，延迟差距被显著放大。
误区三：用基准测试代替业务测试
MMLU、HumanEval 等学术基准不能直接映射到你的具体业务任务。构建一个包含真实业务样本的评估集，是模型选择中最有价值的投入之一。
误区四：不考虑 prompt 优化的空间
在升级模型之前，先检查你的 prompt 是否已经充分优化。通常，一个精心设计的 prompt 让 Sonnet 达到的质量，比一个糟糕的 prompt 驱动的 Opus 效果更好，而且成本更低。
小结
模型选择是架构设计的一部分，不是事后配置。核心原则：
- Haiku 用于高吞吐、低延迟、对准确性容忍度较高的任务
- Sonnet 是大多数生产场景的合理默认选择
- Opus 保留给真正需要深度推理的场景，以及错误代价较高的关键路径
- 混合架构（路由+级联）是平衡成本与质量的最优解
- 测量先于决策：构建任务特定的评估集，用数据驱动模型选择
下一章，我们将离开抽象讨论，进入实操：如何申请 API Key、理解限流机制、安装 SDK 并发出第一个请求。