2.15 模型选择

一句话总结：90% 的场景不需要训练模型——先用 API 验证，再决定是否微调。

📊 学习进度

• 状态：⬜ 未开始
• 上次实时更新：2026-07-03
• 预计时长：3-4 小时
• 已完成：0/3 个模块
• 在整体流程中的位置：AI 应用开发·第 3 阶段

📍 本章定位

• 服务方案：方案 1（核心 80%）/ 方案 2（重要 60%）
• 学习方式：⭐ 必学
• 在流程中的作用：选择最合适的模型方案，平衡成本、效果和速度
• 核心知识点：API 调用、微调（Fine-tuning）、模型评估
• 预计时长：3-4 小时
• 完成后能做什么：能为具体场景选择最优模型方案

---

人机分工

环节	谁做	重要度	说明
路线选择	🧑 人	⭐⭐⭐⭐⭐	API/微调/训练的决策
模型评估	🤖 AI 执行 / 🧑 审核	⭐⭐⭐⭐	AI 跑基准，人判断是否满足业务
Prompt 设计	🧑 人 + 🤖 AI	⭐⭐⭐⭐⭐	需要业务理解
微调执行	🤖 AI	⭐⭐⭐	工具自动化

---

三条路线选择

路线	适用场景	成本	技术门槛
A: 调用 API	大多数文本类应用、快速原型	低	低
B: 微调	有特定领域数据、需要特定风格	中	中
C: 从头训练	几乎只有大公司在做	极高	极高

---

路线 A：调用 API（推荐起步）

人机分工：🧑 人设计 Prompt / 🤖 AI 生成响应

主要 API 提供商全景对比（2025-2026）

提供商	模型	上下文窗口	多模态	特点	价格（输入/输出 per 1M tokens）
Anthropic	Claude Opus 4.8	200K	文本+图像	最强推理、复杂任务，SWE-bench 88.6%	$5.00 / $25.00
Anthropic	Claude Sonnet 4.6	200K	文本+图像	长上下文、安全、编码能力强	$3.00 / $15.00
Anthropic	Claude Haiku 4.5	200K	文本+图像	快速、低成本	$1.00 / $5.00
OpenAI	GPT-5.4	128K	文本+图像+音频	多模态、推理强	$2.50 / $15.00
OpenAI	GPT-5.3-Codex	128K	文本+图像	专为编码优化	$1.75 / $14.00
OpenAI	GPT-5.4-mini	128K	文本+图像	快速、低成本	$0.75 / $4.50
Google	Gemini 3.1 Pro	1M+	文本+图像+视频+音频	超长上下文、SWE-bench 80.6%	$2.00 / $12.00
Google	Gemini 3.5 Flash	1M	文本+图像+视频	快速、性价比之王	$1.50 / $9.00
DeepSeek	V4 Pro	128K	文本	开源、极低成本、SWE-bench 80.6%	$0.435 / $0.87
DeepSeek	V4 Flash	128K	文本	极致低价，缓存命中 $0.0028	$0.14 / $0.28

数据来源：各提供商官网，2026 年 7 月价格。DeepSeek V4 Flash 定价比 Claude Opus 低 99.5%+，彻底改变了 Token 经济格局。

开源模型对比（自部署场景）

模型	参数量	上下文	显存需求	适用场景	许可证
Llama 3.1 70B	70B	128K	40GB (FP16)	通用对话、推理	Llama License
Qwen 2.5 72B	72B	128K	40GB (FP16)	中文场景、编程	Apache 2.0
DeepSeek V3	671B (MoE)	128K	160GB (FP16)	推理、编程	DeepSeek License
Mistral Large	123B	128K	70GB (FP16)	多语言、推理	Mistral License
Llama 3.1 8B	8B	128K	6GB (INT4)	轻量级、边缘部署	Llama License

数据来源：HuggingFace Open LLM Leaderboard，2025。据 LMSYS Chatbot Arena 排名，Llama 3.1 70B 在人类偏好评估中接近 GPT-4o 水平。

模型选择决策流程图

模型路由策略（Model Routing）

模型路由是 OPC 创业者控制成本的核心策略——简单问题用小模型，复杂问题用大模型。

"""
模型路由器 - 根据问题复杂度自动选择最优模型
成本节省：30-50%（据 LangChain 2025 基准测试）
"""
import anthropic
from enum import Enum
from dataclasses import dataclass

class ModelTier(Enum):
    FAST = "claude-haiku-4-20250514"      # 成本最低
    BALANCED = "claude-sonnet-4-20250514"  # 性价比最优
    POWERFUL = "claude-opus-4-20250514"    # 最强推理

@dataclass
class RoutingRule:
    max_tokens: int
    keywords: list[str]
    tier: ModelTier

# 路由规则配置
ROUTING_RULES = [
    # 简单问题 → 小模型
    RoutingRule(max_tokens=100, keywords=["你好", "谢谢", "天气"], tier=ModelTier.FAST),
    # 中等复杂度 → 中等模型
    RoutingRule(max_tokens=500, keywords=["分析", "总结", "翻译"], tier=ModelTier.BALANCED),
    # 复杂问题 → 大模型
    RoutingRule(max_tokens=2000, keywords=["推理", "对比", "策略", "代码"], tier=ModelTier.POWERFUL),
]

def route_model(question: str) -> ModelTier:
    """根据问题特征选择最优模型"""
    question_lower = question.lower()
    
    # 按复杂度从高到低匹配
    for rule in reversed(ROUTING_RULES):
        if any(kw in question_lower for kw in rule.keywords):
            return rule.tier
        if len(question) > rule.max_tokens:
            return rule.tier
    
    # 默认使用中等模型
    return ModelTier.BALANCED

def chat_with_routing(question: str) -> str:
    """带模型路由的对话"""
    client = anthropic.Anthropic()
    model = route_model(question)
    
    print(f"选择模型: {model.value}")
    
    response = client.messages.create(
        model=model.value,
        max_tokens=1024,
        messages=[{"role": "user", "content": question}],
    )
    return response.content[0].text

# 测试
if __name__ == "__main__":
    questions = [
        "你好",                          # → Haiku (快速)
        "帮我总结这篇文章的要点",          # → Sonnet (平衡)
        "请对比分析 RAG 和 Fine-tuning 的优缺点，并给出选型建议",  # → Opus (强力)
    ]
    for q in questions:
        model = route_model(q)
        print(f"问题: {q[:20]}... → 模型: {model.value}")

成本对比（月调用 10 万次，混合场景）：

策略	月成本	质量影响
全部用 Opus	¥15,000	最高质量
全部用 Sonnet	¥3,000	高质量
模型路由（60% Haiku + 30% Sonnet + 10% Opus）	¥1,200	接近全部 Sonnet
节省幅度	60%	质量损失 <5%

数据来源：LangChain 2025 模型路由基准测试，混合路由在保持 95% 质量的同时降低 60% 成本。

Batch API：非实时场景的成本利器

对于不需要实时响应的场景（如批量数据分析、内容生成），使用 Batch API 可以节省 50% 成本。

"""
Batch API 使用示例 - 批量处理节省 50% 成本
适用场景：数据分析、内容批量生成、报告生成
"""
import anthropic
import json

client = anthropic.Anthropic()

# 1. 准备批量请求
requests = []
questions = [
    "总结这篇文档的核心观点",
    "提取文档中的关键数据",
    "生成文档的 SEO 标题",
    # ... 更多任务
]

for i, q in enumerate(questions):
    requests.append({
        "custom_id": f"task-{i}",
        "params": {
            "model": "claude-sonnet-4-20250514",
            "max_tokens": 1024,
            "messages": [{"role": "user", "content": q}],
        }
    })

# 2. 提交批量任务
batch = client.messages.batches.create(requests=requests)
print(f"批量任务 ID: {batch.id}")
print(f"状态: {batch.processing_status}")

# 3. 查询结果（任务完成后）
# results = client.messages.batches.results(batch.id)
# for result in results:
#     print(f"{result.custom_id}: {result.result.content[0].text}")

Batch API vs 实时 API 成本对比：

方式	单价（Sonnet, per 1M tokens）	适用场景	延迟
实时 API	$3 / $15	在线对话、实时查询	1-3 秒
Batch API	$1.5 / $7.5	数据分析、内容生成	24 小时内
节省幅度	50%	-	-

数据来源：Anthropic 官方定价，2025。Batch API 价格为实时 API 的 50%。

关键技能：Prompt Engineering

技巧	说明	效果	适用场景
System Prompt	定义 AI 角色和行为	控制输出风格	所有场景
Few-shot	提供 2-5 个示例	提高准确率 15-30%	分类、格式化
Chain-of-Thought	引导推理过程	提高复杂任务效果 20-40%	推理、分析
Structured Output	指定输出格式（JSON/Pydantic）	方便程序解析	API 集成
Role-playing	指定专家角色	提高专业性	领域问题
Step-by-step	要求分步骤回答	减少遗漏	复杂任务

Prompt 优化前后对比：

# ❌ 差的 Prompt（准确率 60%）
prompt = "分析这段文本的情感"

# ✅ 好的 Prompt（准确率 92%）
prompt = """
你是一个专业的文本情感分析专家。

请分析以下文本的情感倾向，返回 JSON 格式：
{
  "sentiment": "positive/negative/neutral",
  "confidence": 0.0-1.0,
  "reason": "简短说明判断依据",
  "keywords": ["关键词1", "关键词2"]
}

文本：{text}
"""

数据来源：Anthropic 2025 Prompt Engineering 指南，结构化 Prompt 比自由格式准确率高 30-50%。

---

路线 B：微调（Fine-tuning）

人机分工：🧑 人准备数据+定义目标 / 🤖 AI 执行训练

微调 vs API 调用决策矩阵

维度	API 调用	微调	选择建议
数据量	不需要训练数据	需要 100-10000 条高质量数据	数据少→API，数据多→微调
领域适配	通用能力	特定领域优化	通用→API，垂直→微调
延迟要求	受网络影响	本地部署可优化	低延迟→微调
成本结构	按 Token 付费	前期投入+固定运维	小规模→API，大规模→微调
迭代速度	即时生效	需要重新训练	快速迭代→API
数据隐私	数据发送到云端	数据不出本地	敏感数据→微调

微调方法对比（2025-2026）

方法	显存需求	训练速度	效果	适用场景
全参数微调	极高（8×A100）	慢	最好	大公司、追求极致
LoRA	中（1×A100 40GB）	快	接近全参数	OPC 推荐
QLoRA	低（1×RTX 4090 24GB）	中	接近 LoRA	预算有限推荐
Prefix Tuning	极低	极快	一般	快速验证
Adapter Tuning	低	快	中等	多任务切换

数据来源：HuggingFace PEFT 文档，2025。据论文数据，QLoRA 在 4-bit 量化下仅损失 1-2% 的全参数微调效果。

微调完整代码示例（QLoRA + LLaMA-Factory）

"""
微调实战：用 QLoRA 微调 Qwen 2.5 7B 做客服问答
硬件需求：RTX 4090 24GB 或同等显存
"""
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from transformers import BitsAndBytesConfig, TrainingArguments, Trainer
import torch

# ========== 1. 加载基座模型（4-bit 量化）==========
model_name = "Qwen/Qwen2.5-7B-Instruct"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,                    # 4-bit 量化加载
    bnb_4bit_quant_type="nf4",           # NF4 量化类型
    bnb_4bit_compute_dtype=torch.bfloat16, # 计算精度
    bnb_4bit_use_double_quant=True,       # 双重量化，进一步节省显存
)

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)

# ========== 2. 配置 LoRA ==========
lora_config = LoraConfig(
    r=16,                      # LoRA 秩（越大效果越好，显存消耗越大）
    lora_alpha=32,             # 缩放系数
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],  # 目标层
    lora_dropout=0.05,         # Dropout 防过拟合
    bias="none",
    task_type="CAUSAL_LM",
)

model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, lora_config)

# 打印可训练参数量
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
total_params = sum(p.numel() for p in model.parameters())
print(f"可训练参数: {trainable_params:,} / {total_params:,} ({trainable_params/total_params:.2%})")

# ========== 3. 准备训练数据 ==========
# 数据格式：指令微调格式
training_data = [
    {
        "instruction": "你是一个专业的客服助手",
        "input": "我的订单什么时候发货？",
        "output": "您好！订单通常在付款后 24 小时内发货。如果您已超过 24 小时，请提供订单号，我帮您查询具体状态。"
    },
    {
        "instruction": "你是一个专业的客服助手",
        "input": "可以退货吗？",
        "output": "当然可以！我们支持 7 天无理由退退货。请在"我的订单"中申请退货，填写退货原因，我们会在 1-2 个工作日内审核。"
    },
    # ... 更多训练数据
]

def format_instruction(sample):
    """格式化为指令微调格式"""
    return f"### System: {sample['instruction']}\n### User: {sample['input']}\n### Assistant: {sample['output']}"

# ========== 4. 训练配置 ==========
training_args = TrainingArguments(
    output_dir="./output/qwen-customer-service",
    num_train_epochs=3,                    # 训练轮数
    per_device_train_batch_size=4,         # 批次大小
    gradient_accumulation_steps=4,         # 梯度累积
    learning_rate=2e-4,                    # 学习率
    warmup_steps=100,                      # 预热步数
    logging_steps=10,                      # 日志频率
    save_strategy="epoch",                 # 每轮保存
    evaluation_strategy="epoch",           # 每轮评估
    fp16=True,                             # 混合精度训练
    optim="paged_adamw_8bit",              # 8-bit 优化器，节省显存
)

# ========== 5. 开始训练 ==========
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
    tokenizer=tokenizer,
)

trainer.train()

# ========== 6. 保存 LoRA 权重 ==========
model.save_pretrained("./output/qwen-customer-service-lora")
print("微调完成！LoRA 权重已保存。")

微调前后效果对比（客服问答场景）：

指标	微调前（通用模型）	微调后（领域模型）	提升
回答准确率	72%	94%	+22pp
专业术语使用率	45%	89%	+44pp
平均响应长度	150 字	80 字	-47%（更精简）
用户满意度	3.6/5	4.5/5	+25%
单次调用成本	¥0.03（API）	¥0.005（自部署）	-83%

数据来源：LLaMA-Factory 社区案例，2025。微调效果因数据质量和任务类型而异。

推荐工具

• LLaMA-Factory — 一站式微调框架，支持 100+ 模型，Web UI 操作
• Axolotl — 灵活的微调工具，支持多种训练策略
• Unsloth — 2x 训练速度提升，显存优化
• TRL — HuggingFace 官方微调库，支持 RLHF

关键认知：微调不是万能的，数据质量 > 微调技巧。据 HuggingFace 2025 研究，高质量数据对微调效果的贡献占 70%，超参数调优仅占 30%。

---

评估环节

人机分工：🤖 AI 执行评估 / 🧑 人判断是否满足业务

评估维度与指标

评估维度	指标	计算方法	说明
离线评估	准确率、F1、BLEU、ROUGE	自动化计算	快速筛选
人工评估	A/B 测试、盲评	人工打分	最终判断标准
延迟	P50/P95/P99 响应时间	自动采集	用户体验
成本	单次调用成本	Token 数 × 单价	成本控制
业务对齐	是否满足业务目标	业务指标	最重要

模型评估代码示例

"""
模型评估工具 - 自动化评估多个模型的性能
"""
import time
import json
import anthropic
from dataclasses import dataclass, field
from typing import List, Dict

@dataclass
class EvalResult:
    model: str
    accuracy: float
    avg_latency_ms: float
    avg_cost_usd: float
    test_cases: int
    details: List[Dict] = field(default_factory=list)

class ModelEvaluator:
    """模型评估器"""
    
    def __init__(self):
        self.client = anthropic.Anthropic()
        self.test_cases = []
    
    def add_test_case(self, question: str, expected_answer: str, category: str = "general"):
        """添加测试用例"""
        self.test_cases.append({
            "question": question,
            "expected": expected_answer,
            "category": category,
        })
    
    def evaluate_model(self, model: str, max_tokens: int = 512) -> EvalResult:
        """评估单个模型"""
        results = []
        total_latency = 0
        total_cost = 0
        
        for case in self.test_cases:
            # 计时
            start = time.time()
            response = self.client.messages.create(
                model=model,
                max_tokens=max_tokens,
                messages=[{"role": "user", "content": case["question"]}],
            )
            latency = (time.time() - start) * 1000  # ms
            
            # 计算成本（简化计算）
            input_tokens = response.usage.input_tokens
            output_tokens = response.usage.output_tokens
            cost = self._calculate_cost(model, input_tokens, output_tokens)
            
            # 判断准确性（简化：关键词匹配）
            answer = response.content[0].text
            is_correct = self._check_answer(answer, case["expected"])
            
            results.append({
                "question": case["question"][:50],
                "correct": is_correct,
                "latency_ms": latency,
                "cost_usd": cost,
            })
            
            total_latency += latency
            total_cost += cost
        
        correct_count = sum(1 for r in results if r["correct"])
        
        return EvalResult(
            model=model,
            accuracy=correct_count / len(results),
            avg_latency_ms=total_latency / len(results),
            avg_cost_usd=total_cost / len(results),
            test_cases=len(results),
            details=results,
        )
    
    def _calculate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
        """计算调用成本"""
        pricing = {
            "claude-haiku-4-20250514": (0.25, 1.25),
            "claude-sonnet-4-20250514": (3.0, 15.0),
            "claude-opus-4-20250514": (15.0, 75.0),
        }
        input_price, output_price = pricing.get(model, (3.0, 15.0))
        return (input_tokens * input_price + output_tokens * output_price) / 1_000_000
    
    def _check_answer(self, actual: str, expected: str) -> bool:
        """简化答案检查（实际项目中用更复杂的评估方法）"""
        return expected.lower() in actual.lower()
    
    def compare_models(self, models: List[str]) -> List[EvalResult]:
        """对比多个模型"""
        results = []
        for model in models:
            print(f"评估模型: {model}")
            result = self.evaluate_model(model)
            results.append(result)
            print(f"  准确率: {result.accuracy:.1%}")
            print(f"  平均延迟: {result.avg_latency_ms:.0f}ms")
            print(f"  平均成本: ${result.avg_cost_usd:.4f}")
        return results

# 使用示例
if __name__ == "__main__":
    evaluator = ModelEvaluator()
    
    # 添加测试用例
    evaluator.add_test_case(
        "Python 列表去重有哪些方法？",
        "set、dict.fromkeys、列表推导式",
        category="编程"
    )
    evaluator.add_test_case(
        "什么是 RAG？",
        "检索增强生成",
        category="AI"
    )
    evaluator.add_test_case(
        "HTTP 状态码 429 是什么意思？",
        "请求过多",
        category="技术"
    )
    
    # 对比模型
    results = evaluator.compare_models([
        "claude-haiku-4-20250514",
        "claude-sonnet-4-20250514",
    ])
    
    # 输出对比报告
    print("\n=== 模型对比报告 ===")
    for r in results:
        print(f"\n模型: {r.model}")
        print(f"  准确率: {r.accuracy:.1%}")
        print(f"  平均延迟: {r.avg_latency_ms:.0f}ms")
        print(f"  平均成本: ${r.avg_cost_usd:.4f}")

评估流程图

---

常见问题

问题	原因	解决方案
API 成本太高	Token 消耗过多	优化 Prompt、缓存、模型路由
微调效果差	数据质量低	先清洗数据，确保标注一致性
输出不稳定	温度参数太高	降低 temperature 至 0-0.3
微调过拟合	训练数据太少或训练轮数太多	增加数据量、减少 epoch、增加 dropout
API 延迟高	网络或模型负载	流式响应、异步调用、就近部署
模型选择困难	缺乏评估标准	用本章评估代码自动化对比
微调显存不足	模型太大	使用 QLoRA 4-bit 量化
Prompt 效果不稳定	缺乏结构化设计	使用 Few-shot + 结构化输出
微调数据格式错误	数据格式不匹配	参考 LLaMA-Factory 文档的格式要求
API 限流	调用频率超限	实现指数退避重试 + 多 Provider 兜底
模型幻觉严重	缺少约束	添加"如果不确定请说不知道"指令 + RAG 补充事实

---

实操案例：电商客服模型选型

场景

一个电商 SaaS 平台需要为 500+ 商家提供 AI 客服能力，日均处理 10 万+ 对话。

选型过程

Step 1：需求分析

维度	要求	优先级
准确率	≥ 90%	P0
延迟	< 2 秒	P0
成本	< ¥0.05/次	P1
多语言	中文+英文	P2
数据隐私	部分商家要求本地化	P2

Step 2：候选方案评估

方案	准确率	延迟	月成本（10万次/天）	数据隐私
Claude Sonnet API	94%	1.2s	¥9,000	云端
GPT-4o API	92%	1.5s	¥7,500	云端
Qwen 2.5 7B 微调	91%	0.8s	¥3,000（GPU）	本地
混合方案（微调+API 兜底）	93%	1.0s	¥5,000	混合

Step 3：决策

选择混合方案：

• 80% 常见问题用微调的 Qwen 2.5 7B 处理（成本低、速度快）
• 20% 复杂问题用 Claude Sonnet API 处理（质量高）
• 设置准确率阈值，低于 85% 自动切换到 API

前后对比：

指标	之前（纯人工）	之后（混合方案）	改善
日处理量	5,000 条	100,000 条	20x
平均响应时间	5 分钟	1 秒	99.7%↓
月度成本	¥150,000（30 人）	¥5,000	97%↓
客户满意度	72%	88%	+16pp

---

趋势预判（未来 1-3 年）

时间窗口	预判	概率	OPC 行动建议
1 年内	小模型（7B-14B）能力接近 GPT-4	高(85%)	关注开源模型微调
1-2 年	模型 API 价格再降 50%	高(80%)	优先用 API 验证
2-3 年	端侧 AI 部署成为标配	中(60%)	学习模型量化技术
2-3 年	多模态成为基础能力	高(75%)	关注多模态应用场景

数据来源：据 McKinsey 2025 AI 报告，同等能力模型的 API 成本每年下降 50-70%。据 Meta 2025 发布路线图，Llama 4 系列将在 2026 年初发布，预期性能大幅提升。

---

下一步

完成模型选择后，进入 阶段 4：应用集成

---

参考与延伸

[1] Anthropic. "Claude API Documentation"（2025）— Claude API 使用指南，包含模型对比和定价

[2] HuggingFace. "PEFT: Parameter-Efficient Fine-Tuning"（2025）— 高效微调方法，LoRA/QLoRA 技术细节

[3] LLaMA-Factory（2025）— 一站式微调框架，支持 100+ 模型

[4] OpenAI. "GPT-4o System Card"（2025）— GPT-4o 技术报告，包含性能基准

[5] LMSYS. "Chatbot Arena Leaderboard"（2025）— 众包模型评估排行榜，基于人类偏好

[6] LangChain. "Model Routing"（2025）— 模型路由策略，降低 60% 成本

[7] McKinsey. "The State of AI in 2025"（2025）— AI 成本趋势，API 价格每年下降 50-70%

[8] Google. "Gemini Technical Report"（2025）— Gemini 2.0 技术规格和性能数据

[9] Unsloth. "Documentation"（2025）— 2x 训练速度优化，显存节省方案

[10] Anthropic. "Batch API Documentation"（2025）— 批量 API，成本降低 50%

[11] Together AI. "Research on Open Models"（2025）— 开源模型推理服务，支持 100+ 开源模型