🧠AI LLM 基础
模型选型与对比
难度：⭐ | 高频指数：🔥🔥🔥 | 应用岗相关度：★★★
面试回答
常见问法
- “你们项目为什么选这个模型？换一个行不行？”
- “开源模型和闭源模型怎么选？”
- “什么时候用大模型，什么时候用小模型？”
- “多个模型怎么配合使用？“
回答
模型选型不是选”最好的模型”，而是选最适合当前场景的模型。核心考虑维度是：任务类型、成本预算、延迟要求、中文能力、上下文长度和数据安全。
# 模型选型决策框架
class ModelSelector:
"""
模型选型决策框架
不要背benchmark数字（会过时），要掌握选型思路和维度
"""
def __init__(self):
# 选型维度权重（根据业务调整）
self.dimensions = {
'task_fit': 0.25, # 任务匹配度
'cost': 0.20, # 成本
'latency': 0.15, # 延迟
'chinese_ability': 0.15, # 中文能力
'context_length': 0.10, # 上下文长度
'safety': 0.15, # 数据安全/合规
}
def evaluate_model(self, model_name, requirements):
"""
评估模型是否适合需求
requirements示例：
{
'task_type': 'rag_qa', # 任务类型
'budget_per_1k_tokens': 0.01, # 预算
'max_latency_ms': 3000, # 最大延迟
'language': 'zh', # 主要语言
'min_context_length': 32000, # 最小上下文
'data_sensitivity': 'high', # 数据敏感度
}
"""
scores = {}
# 任务匹配度
scores['task_fit'] = self.evaluate_task_fit(
model_name, requirements['task_type']
)
# 成本评估
scores['cost'] = self.evaluate_cost(
model_name, requirements['budget_per_1k_tokens']
)
# 延迟评估
scores['latency'] = self.evaluate_latency(
model_name, requirements['max_latency_ms']
)
# 中文能力
scores['chinese_ability'] = self.evaluate_chinese(
model_name, requirements['language']
)
# 上下文长度
scores['context_length'] = self.evaluate_context(
model_name, requirements['min_context_length']
)
# 数据安全
scores['safety'] = self.evaluate_safety(
model_name, requirements['data_sensitivity']
)
# 加权总分
total = sum(
scores[dim] * weight
for dim, weight in self.dimensions.items()
)
return {
'model': model_name,
'total_score': total,
'dimension_scores': scores,
'recommendation': self.get_recommendation(total)
}
def get_recommendation(self, score):
"""给出推荐建议"""
if score > 0.8:
return "强烈推荐"
elif score > 0.6:
return "可以使用"
elif score > 0.4:
return "勉强可用，建议寻找替代"
else:
return "不推荐"
# 主流模型特点对比（思路而非具体数字）
MODEL_CHARACTERISTICS = """
选型时关注的维度（不要背具体数字，会过时）：
┌─────────────┬──────────────────────────────────────────────┐
│ 维度 │ 关注点 │
├─────────────┼──────────────────────────────────────────────┤
│ 通用能力 │ 推理、代码、创意写作、指令遵循 │
│ 中文能力 │ 中文理解、中文生成、中文知识 │
│ 成本 │ 输入/输出token单价、是否有免费额度 │
│ 延迟 │ 首token延迟、生成速度（tokens/s） │
│ 上下文 │ 最大上下文长度、长文本处理能力 │
│ 多模态 │ 是否支持图片/音频/视频输入 │
│ 部署方式 │ API调用 vs 私有化部署 │
│ 合规 │ 数据是否出境、是否有审计日志 │
└─────────────┴──────────────────────────────────────────────┘
"""追问
开源 vs 闭源怎么选？
# 开源vs闭源决策矩阵
OPEN_VS_CLOSED_DECISION = {
"选闭源API的场景": [
"快速验证MVP，不想运维模型",
"任务通用性强，不需要定制",
"团队没有GPU资源和模型运维能力",
"对最新能力有要求（闭源通常更新更快）",
],
"选开源自部署的场景": [
"数据敏感，不能出公司网络",
"需要微调适配特定业务",
"调用量大，API成本不可控",
"需要完全控制推理过程（如logprobs）",
"合规要求数据不出境",
],
"混合策略（常见）": [
"开发测试用闭源API（快速迭代）",
"生产环境用开源部署（成本可控）",
"简单任务用小模型，复杂任务用大模型",
"核心链路用闭源保效果，辅助链路用开源省成本",
]
}
class OpenVsClosedDecision:
"""开源vs闭源决策"""
def recommend(self, requirements):
"""根据需求推荐"""
score_open = 0
score_closed = 0
# 数据敏感度
if requirements.get('data_sensitivity') == 'high':
score_open += 3 # 强烈倾向开源
# 调用量
if requirements.get('daily_requests', 0) > 10000:
score_open += 2 # 量大用开源省钱
# 团队能力
if not requirements.get('has_gpu_infra'):
score_closed += 2 # 没有GPU基础设施用API
# 定制需求
if requirements.get('needs_finetuning'):
score_open += 2 # 需要微调用开源
# 时间压力
if requirements.get('time_pressure') == 'high':
score_closed += 2 # 赶时间用API
if score_open > score_closed:
return "推荐开源自部署"
elif score_closed > score_open:
return "推荐闭源API"
else:
return "推荐混合策略"什么时候用大模型，什么时候用小模型？
# 大小模型选择策略
class ModelSizeStrategy:
"""
大模型 vs 小模型选择
核心原则：能用小模型解决的不用大模型
大模型贵但强，小模型便宜但能力有限
"""
# 适合大模型的任务
LARGE_MODEL_TASKS = [
"复杂推理（多步逻辑）",
"创意写作（高质量文案）",
"代码生成（复杂逻辑）",
"多轮对话（需要深度理解上下文）",
"开放域问答（知识面要求广）",
]
# 适合小模型的任务
SMALL_MODEL_TASKS = [
"文本分类（情感分析、意图识别）",
"信息提取（NER、关键词提取）",
"简单格式转换（JSON提取）",
"文本改写（简单润色）",
"相似度计算（embedding）",
]
def select_model_size(self, task_description, constraints):
"""选择模型大小"""
# 先尝试小模型
small_model_score = self.evaluate_small_model_fit(task_description)
if small_model_score > 0.7 and constraints.get('cost_sensitive'):
return {
'recommendation': 'small',
'reason': '任务简单，小模型足够，且成本敏感',
'suggested_models': ['Qwen-7B', 'GLM-6B', 'DeepSeek-7B']
}
if small_model_score < 0.4 or constraints.get('quality_first'):
return {
'recommendation': 'large',
'reason': '任务复杂，需要大模型能力',
'suggested_models': ['GPT-4o', 'Claude-3.5', 'DeepSeek-V3']
}
return {
'recommendation': 'test_both',
'reason': '不确定，建议两者都测试对比',
'test_plan': '用20个样本分别测试，对比效果和成本'
}多模型混用策略
class MultiModelRouter:
"""
多模型路由策略
1. 路由（Router）：根据任务类型选模型
2. 降级（Fallback）：主模型失败时切备用
3. 级联（Cascade）：小模型先做，不确定时升级到大模型
"""
def __init__(self, models_config):
self.models = models_config
self.router = TaskRouter()
self.cascade_threshold = 0.7
# 策略1：路由
def route_by_task(self, query, task_type):
"""根据任务类型路由到不同模型"""
routing_rules = {
'simple_qa': 'small_model', # 简单问答用小模型
'complex_reasoning': 'large_model', # 复杂推理用大模型
'code_generation': 'code_model', # 代码生成用代码模型
'translation': 'multilingual_model', # 翻译用多语言模型
}
model_key = routing_rules.get(task_type, 'default_model')
model = self.models[model_key]
return model.generate(query)
# 策略2：降级
def fallback_strategy(self, query):
"""主模型失败时降级"""
# 按优先级尝试
model_priority = ['primary', 'secondary', 'fallback']
for model_key in model_priority:
try:
model = self.models[model_key]
response = model.generate(query, timeout=5)
if response and response.get('status') == 'success':
return response
except Exception as e:
print(f"模型 {model_key} 失败: {e}")
continue
# 所有模型都失败
return {
'status': 'all_failed',
'message': '服务暂时不可用，请稍后重试'
}
# 策略3：级联
def cascade_strategy(self, query):
"""
级联策略：小模型先做，不确定时升级
优点：大部分请求用小模型（省钱），
只有难题才用大模型（保质量）
"""
# 第一步：小模型尝试
small_response = self.models['small'].generate(
query, return_confidence=True
)
# 如果小模型有信心，直接返回
if small_response['confidence'] > self.cascade_threshold:
return {
'answer': small_response['answer'],
'model_used': 'small',
'confidence': small_response['confidence']
}
# 小模型不确定，升级到大模型
large_response = self.models['large'].generate(query)
return {
'answer': large_response['answer'],
'model_used': 'large',
'reason': f'小模型置信度 {small_response["confidence"]:.2f} 低于阈值'
}
def get_cost_comparison(self, request_log):
"""对比不同策略的成本"""
# 纯大模型成本
all_large_cost = sum(
r['tokens'] * self.models['large'].price_per_token
for r in request_log
)
# 级联策略成本
cascade_cost = sum(
r['tokens'] * self.models['small'].price_per_token
if r.get('small_model_sufficient') else
r['tokens'] * (
self.models['small'].price_per_token +
self.models['large'].price_per_token
)
for r in request_log
)
return {
'all_large_cost': all_large_cost,
'cascade_cost': cascade_cost,
'savings': (all_large_cost - cascade_cost) / all_large_cost
}原理展开
选型实战思路
# 面试时怎么回答"为什么选这个模型"
INTERVIEW_ANSWER_TEMPLATE = """
面试回答模板：
1. 先说业务需求：
"我们的场景是企业内部知识问答，主要是中文，
日均请求量约5000次，数据不能出公司网络"
2. 再说选型维度：
"基于这个需求，我们主要考虑：
- 中文能力（核心）
- 数据安全（必须私有化部署）
- 成本（日均5000次要可控）
- 上下文长度（文档较长，需要32K+）"
3. 说对比过程：
"我们对比了几个方案：
- GPT-4o：效果最好，但数据出境不合规
- DeepSeek：中文好，可私有化，成本合理
- Qwen：中文好，阿里云生态，部署方便
最终选了 DeepSeek，因为..."
4. 说验证方法：
"我们用100个业务样本做了对比测试，
在准确率、延迟、成本三个维度打分"
5. 回答追问"换一个行不行"：
"可以换，但需要重新评估。如果换GPT-4o，
效果可能更好但合规有问题；如果换小模型，
成本降低但复杂问题准确率会下降"
"""
# 选型评估报告模板
class ModelEvaluationReport:
"""模型选型评估报告"""
def generate_report(self, candidates, test_results):
"""生成选型报告"""
report = {
'summary': {},
'detailed_comparison': {},
'recommendation': '',
'risks': []
}
for model in candidates:
results = test_results[model]
report['detailed_comparison'][model] = {
'accuracy': results['accuracy'],
'avg_latency_ms': results['latency'],
'cost_per_1k_requests': results['cost'],
'chinese_score': results['chinese'],
'deployment': results['deployment_type'],
'pros': results['pros'],
'cons': results['cons']
}
# 综合推荐
best_model = max(
candidates,
key=lambda m: test_results[m]['weighted_score']
)
report['recommendation'] = (
f"推荐使用 {best_model}，"
f"综合评分最高（{test_results[best_model]['weighted_score']:.2f}）"
)
return report常见选型误区
COMMON_MISTAKES = {
"只看排行榜": {
"问题": "Benchmark排名不等于业务效果",
"正确做法": "用自己的业务数据测试"
},
"只看价格": {
"问题": "便宜的模型可能需要更多调用才能达到效果",
"正确做法": "算总体拥有成本（TCO），包括调用次数、重试、人工修正"
},
"忽略延迟": {
"问题": "用户体验对延迟很敏感",
"正确做法": "测试真实场景下的端到端延迟，包括网络"
},
"不考虑演进": {
"问题": "模型会更新，API可能变化",
"正确做法": "架构上做好模型抽象层，方便切换"
},
"一个模型打天下": {
"问题": "不同任务适合不同模型",
"正确做法": "根据任务类型路由到合适的模型"
}
}易错点
- 面试时背具体的 benchmark 数字（很快过时，显得不专业）
- 只说”我们用了 GPT-4”但说不清为什么选它
- 不考虑成本和延迟，只追求效果最好
- 忽略数据安全和合规要求
- 没有做过实际对比测试就下结论
记忆技巧
记住模型选型的”六维度 + 三策略”：
六个选型维度：
- 任务匹配度（能力够不够）
- 成本（预算内不内）
- 延迟（用户等得起不起）
- 中文能力（业务需不需要）
- 上下文长度（够不够用）
- 数据安全（合不合规）
三种多模型策略：
- 路由（Router）：按任务类型分流
- 降级（Fallback）：主模型挂了用备用
- 级联（Cascade）：小模型先做，不行再升级
面试速答版
- 模型选型不是选”最好的”，是选”最适合场景的”，六维度：任务、成本、延迟、中文、上下文、安全
- 开源 vs 闭源：数据敏感/量大/需微调选开源，快速验证/团队小/追求最新能力选闭源
- 大模型 vs 小模型：能用小的解决就不用大的，分类/提取/格式转换用小模型，复杂推理用大模型
- 多模型策略三种：路由（按任务分流）、降级（主挂用备）、级联（小模型先做不行再升级）
- 面试回答结构：业务需求 → 选型维度 → 对比过程 → 验证方法 → 能回答”换一个行不行”
- 常见坑：背 benchmark 数字、不做实际测试、忽略成本延迟、一个模型打天下
- 一句话最佳实践：用业务数据实测对比，架构上做好模型抽象层方便切换
Related · LLM 基础