1. 为什么需要模型选型

1.1 大模型百花齐放下的选型困境

随着大语言模型（LLM）技术的爆发式发展，市场上涌现出数百个模型产品，从闭源的 GPT-4o、Claude、Gemini， 到开源的 Llama、Qwen、Mistral、DeepSeek 等。每个模型在能力侧重点、价格、部署方式、生态支持等方面各有千秋。 团队在启动 AI 项目时面临的第一个关键决策就是——选择哪个模型作为基座？

• 信息过载：各厂商的宣传指标（如 MMLU 得分、GSM8K 准确率）口径不统一，横向对比较困难。
• 场景差异大：一个在通用评测上表现出色的模型，未必在银行业务场景中同样优秀。
• 成本敏感：API 调用的 Token 计费差异可达数十倍，选错模型可能带来严重的成本负担。
• 迭代速度快：模型版本更新频繁（如 GPT-4→GPT-4o→GPT-4.1），选型决策需要具有前瞻性。

1.2 选型决策的影响因素

模型选型不是单纯的技术选型，而是一个涉及业务需求、技术架构、成本控制、安全合规等多个维度的综合决策过程。关键影响因素包括：

1.3 选型决策流程概述

规范的模型选型应遵循「需求驱动、多维评估、场景验证」的原则，形成结构化的决策流程：

1. 需求调研：明确业务场景、功能需求、性能指标和约束条件。
2. 候选筛选：根据需求初筛 3~5 个候选模型，形成候选清单。
3. 基准评测：使用标准评测集进行能力摸底，了解各模型的基线水平。
4. 场景测试：在真实业务场景下进行端到端测试，验证实际表现。
5. 成本评估：综合 API 定价或部署成本，计算 TCO（总拥有成本）。
6. 最终决策：汇总各维度得分，输出选型报告并完成决策。

2. 选型评估维度

模型选型需要建立系统的评估维度体系，从能力、安全、效率、生态和部署五个维度进行全方位考察。 每个维度下设若干关键指标，形成完整的评估矩阵。

2.1 能力维度

能力维度是选型评估的核心，直接决定模型「能不能」满足业务需求。主要考察以下子能力：

• 知识理解：通用知识和领域专业知识（特别是金融知识）的掌握程度。关键指标包括 MMLU、C-Eval 等基准得分。
• 推理能力：逻辑推理、数学推理和因果推理能力。在金融场景中，风险分析和合规判断对推理能力要求极高。
• 代码生成：编程语言理解和代码生成能力。对于需要集成到开发工具链或自动化测试的场景尤为重要。
• 语言生成：文本生成的流畅性、准确性和风格控制能力。直接影响对话式应用的最终用户体验。
• 指令遵循：对复杂、多约束指令的执行准确率。在银行业务中，格式遵循和合规约束至关重要。
• 多语言能力：中英文及多语种的处理能力。银行国际业务场景需要多语言支持。

2.2 安全维度

安全维度评估模型在安全对齐、偏见控制、隐私保护等方面的表现。对于金融行业， 安全合规是不可逾越的底线，安全维度往往比能力维度具有更高的评估权重。

• 安全对齐：模型对有害内容（暴力、色情、仇恨言论等）的识别和拒绝能力。关注误拒率（过度拒绝正常请求）和漏拒率（未能拒绝有害请求）。
• 偏见与公平：模型在不同群体（性别、年龄、地域、收入水平等）间的输出是否存在系统性偏差。金融场景需要特别关注信贷、保险等领域的公平性。
• 有害内容过滤：对金融诈骗信息、非法集资、洗钱等违法金融内容的识别和拦截能力。
• 越狱抵抗：面对 Prompt Injection、角色扮演等对抗攻击时的鲁棒性。重点测试是否可能通过越狱获取敏感金融建议或客户数据。
• 隐私保护：模型是否会泄露训练数据中的个人信息，以及是否支持数据脱敏处理。

2.3 效率维度

效率维度衡量模型在实际运行中的性能和成本表现，直接关系到业务可行性和用户体验。

• 推理速度：首 Token 延迟（TTFT）和 Token 生成速率（Tokens/s）。对实时对话场景，TTFT 应控制在 1 秒以内。
• 并发能力：模型在高并发请求下的吞吐量和稳定性。银行客服等场景需要支持数百乃至数千并发。
• 成本（API 定价）：输入/输出 Token 的单价。各模型定价差异显著，需结合预期用量进行成本测算。
• 上下文窗口：模型支持的最大 Token 长度。长文档分析、多轮对话等场景需要较大的上下文窗口。

2.4 生态维度

生态维度关注模型周边的工具链、社区支持和技术文档等配套资源，直接影响开发效率和运维难度。

• 社区活跃度：GitHub Stars、Issue 响应速度、社区贡献者数量。活跃的社区意味着更快的 Bug 修复和更多的实践参考。
• 工具链完善度：SDK/API 的易用性、LangChain/LlamaIndex 等主流框架的适配程度、本地推理引擎（如 vLLM、Ollama）的支持情况。
• 文档质量：技术文档的完整性、示例代码的丰富度、中文资料的覆盖率。良好的文档能显著降低上手成本。
• 多模态支持：是否支持图像理解、语音识别等多模态能力。银行业务中的票据识别、证件验证等场景需要多模态能力。
• 微调生态：是否提供官方微调工具（如 LoRA 适配）、是否有成熟的领域微调方案和实践经验。

2.5 部署维度

部署维度是银行业模型选型中最具行业特性的考量因素，涉及数据安全、合规和基础设施等问题。

• 私有化部署能力：模型是否支持在自有服务器上部署。开源模型通常支持完整的私有化部署，闭源模型则依赖 API 调用。
• 数据安全：API 调用场景下，厂商是否承诺不将数据用于训练。银行涉敏数据必须满足数据不出内网的要求。
• 合规性：是否符合《个人信息保护法》《数据安全法》等监管要求，是否通过等保三级等安全认证。
• 硬件适配：对 GPU（NVIDIA/华为昇腾）、推理框架（vLLM/TensorRT-LLM）的兼容性。
• 服务可用性：API 的 SLA 保障水平（如 99.9% 可用性）、限流策略和容灾能力。
• 信创适配：是否支持国产硬件和操作系统，满足信创要求。

3. 主流模型对比

当前市场主流的大模型可分为闭源商业模型和开源模型两大阵营，各有优势和适用场景。

3.1 闭源模型

3.2 开源模型

3.3 综合对比矩阵

以下从多个关键维度对主流模型进行综合对比，帮助快速建立全局认知：

4. 选型测试方法论

选型评估不仅是看评测榜单，更需要一套科学的方法论来指导测试实践。 以下是我们在实际选型过程中总结的五种核心测试方法。

4.1 场景匹配测试

场景匹配测试是选型评估中最核心的环节——在目标业务场景的真实数据上测试模型表现。 通用基准得分高不等于业务场景表现好，只有场景匹配测试才能真正验证模型的「业务可用性」。

• 测试集构建：从实际业务中抽取 50~200 条典型问题，覆盖正常场景、边界场景和异常场景，构建自建评测集。
• 评测指标：采用人工评分（1~5分）或 LLM-as-a-Judge 方法，从准确性、完整性、合规性等多个角度评估回答质量。
• 对比分析：在同一评测集上运行多个候选模型，统计得分分布和差异显著性。
• 案例记录：对每个模型的典型好案例和失败案例进行记录，便于后续分析和决策回溯。

4.2 A/B 对比测试

A/B 对比测试通过在同一场景下平行运行多个模型，直接对比输出质量差异。 这种方法的优势在于能够直观地展示模型间的优劣差异，方便决策者做出判断。

• 盲测设计：对评估者隐藏模型身份，避免品牌偏见影响判断。制作统一的评测表格，只展示匿名标注的模型回答。
• 多维评分：从准确性、完整性、流畅性、安全性、合规性等维度分别打分，防止单一维度的片面判断。
• 统计显著性：使用 t 检验或 Wilcoxon 符号秩检验验证模型间差异是否具有统计显著性，避免小样本的随机波动。
• 胜率统计：计算每个模型在逐题对比中的「胜/平/负」比例，形成直观的对比报告。

4.3 成本效益分析

成本效益分析帮助在模型质量和成本之间找到最优平衡点，是在预算约束下做出合理决策的关键环节。

• 质量分数归一化：将各模型的场景测试得分标准化为 0~100 分。
• 成本估算：根据预期调用量，计算各模型的总 Token 消耗和 API 费用。对于私有化部署，需计算硬件、运维和电力等 TCO。
• 性价比指数：计算 质量分数 / 成本 的比例，直观衡量「每元获得的能力」。例如 DeepSeek-V3 在中文场景的性价比通常远超 GPT-4o。
• 边际效应分析：评估从低成本模型升级到高成本模型带来的能力提升是否「值得」。有时 20% 的成本增加可能只带来 5% 的质量提升。

4.4 压力测试

压力测试验证模型在高负载条件下的性能表现，确保生产环境下的稳定可靠。

• 并发递增测试：从 10 并发逐步增加到 100、500、1000 并发，观察延迟变化和错误率。
• 长时稳定性测试：持续 24 小时压测，监控是否存在内存泄漏、性能退化等问题。
• 突发流量测试：模拟瞬时流量高峰（如银行活动日），验证系统的弹性伸缩能力。
• 超长输入测试：测试接近上下文窗口极限的输入（如 100K+ Token 的文档），观察处理时间和成功率。
• API 限流恢复：当达到 API 速率限制时，观察限流恢复策略是否合理，是否影响用户体验。

4.5 退化测试

退化测试（Regression Testing for Models）是模型选型中容易被忽视但极其重要的环节。 模型厂商持续迭代版本，新版本可能在修复旧问题的同时引入新的退化（Regression）。

• 版本对比测试：当候选模型发布新版本时，使用固定评测集对比新旧版本的表现差异。
• 退化检测：识别新版本中能力下降的维度（如安全对齐变弱、特定领域知识丢失、格式遵循退化等）。
• Changelog 验证：对照厂商发布的更新日志，验证声称的提升是否真实存在、是否引入了 unintended side effects。
• 灰度上线策略：对生产系统，建议新旧模型并行运行一段时间（如 1~2 周），确保无退化后再全量切换。
• Benchmark 快照：建立长期的 benchmark 快照机制，每次模型更新后自动运行全量评测，生成退化报告。

5. 银行业模型选型考量

银行业是 AI 应用中监管最严格、安全要求最高的行业之一。模型选型需要充分考虑金融场景的特殊需求， 结合某银行「某银行AI建设工程」的实际经验和六类应用范式的特点，制定针对性的选型策略。

5.1 金融场景的特殊需求

相较于通用场景，银行业务对模型提出了一系列额外的刚性要求：

• 合规优先：模型输出必须符合央行、银保监会等监管机构的规定，不得产生误导性金融建议。对于客户投诉、产品推荐等场景，模型回答需要有法务审查依据。
• 高稳定性：金融交易系统对稳定性要求极高（99.99% 可用性），模型不可出现幻觉导致的业务差错。回退机制和人工审核流程是必备保障。
• 强可解释性：风控、信贷审批等决策场景需要模型输出有据可查，支持审计追踪。「黑盒」模型在这些场景中难以通过合规审查。
• 数据主权：客户信息、账户数据、交易记录等敏感数据绝不允许流出行内网络。这意味着多数场合下必须选择支持私有化部署的模型。
• 信创要求：行内 IT 基础设施逐步向国产化迁移，模型需适配华为昇腾等国产硬件和国产操作系统。

5.2 某银行AI建设工程的模型选型建议

某银行AI建设工程是某银行推进 AI 能力建设的战略性工程，我们的模型选型需兼顾当前需求和远期规划：

• 基座模型选型：建议以 Qwen3-72B 或 DeepSeek-V3 作为主力基座模型，这两个模型在中文能力和金融场景表现上最为突出，且支持完整的私有化部署。
• 轻量模型选型：对于延迟敏感或资源受限的场景（如移动端、边缘设备），可选用 Qwen3-7B/14B 或 Gemma 3-12B 作为轻量替代。我们团队已有 Gemma 4 的实际部署经验，可复用相关能力积累。
• 多模型协同：不同场景使用不同模型，通过模型路由层动态调度。例如：实时客服使用轻量模型保证速度，监管报告分析使用大参数模型保证质量。
• 安全护栏：无论选型何种基座模型，均需叠加安全护栏层（Guardrails），对输出进行合规过滤和敏感信息脱敏。

5.3 六类应用范式的模型匹配推荐

基于某银行 AI 应用的六类范式，给出差异化的模型选型建议：

5.4 私有化部署 vs API 调用的决策

私有化部署和 API 调用各有优劣，银行场景下的决策需要综合考量以下因素：

6. 选型流程模板

以下提供一套标准化的选型流程模板，可用于指导实际项目的模型选型工作。 各阶段输出物明确，便于过程管理和决策追溯。

6.1 各阶段关键输出物说明

《模型选型需求说明书》

明确选型的目标、范围和约束条件。核心内容包括：业务场景描述、功能需求清单、性能指标（如首Token延迟 ≤ 1s）、 安全合规要求、预算上限、部署方式约束等。此文档是后续所有评估工作的依据基线。

《候选模型筛选报告》

基于需求说明书，从市场中筛选 3~5 个候选模型，并说明筛选依据。内容包括：候选模型基本信息、 入选理由、排除模型及原因。建议同时包含一个「观察清单」，记录暂不纳入但值得跟踪的模型。

《基准评测报告》

使用标准评测集（如 MMLU、C-Eval、GSM8K）和团队自建的 50~100 题场景评测集，对候选模型进行统一评测。 输出各模型的得分矩阵和雷达图，直观展示各维度差异。建议同时标注各评测结果的置信度。

《场景测试报告》

在真实业务场景下对候选模型进行端到端测试。核心内容包括：A/B 盲测结果（含胜/平/负统计）、 典型好案例与失败案例分析、压力测试结果（并发和延迟曲线）、退化测试结果（如有版本对比）。 此报告是最终决策的核心依据。

《成本效益分析报告》

对候选模型进行全生命周期成本分析。内容包括：API 调用成本估算（基于预期日活和 Token 消耗）、 私有化部署的 TCO（含硬件折旧、运维人力、电力等）、各模型的性价比指数排名、边际效应分析。

《模型选型最终报告》

汇总上述所有评估结果，形成最终的选型建议。核心内容包括：推荐模型及排名、推荐理由（量化支撑）、 上线计划（含灰度策略和回滚预案）、风险提示和应急预案。建议增加「定期复评计划」章节，明确下一次复评的时间节点。

6.2 选型决策评分模板

建议使用加权评分法进行最终决策，将各维度的主观判断量化为可比分数：

7. 实战演练

以下设计了三项可独立执行的实战任务，帮助团队在实际操作中掌握模型选型的核心方法。 每项任务包含明确的目标、步骤和输出要求，可作为内部培训或选型项目的工作指引。

7.1 任务一：模型 A/B 对比测试

📋 操作步骤

1. 准备测试问题集：从银行客服知识库中抽取 20 个真实问题，确保覆盖不同难度和类型。建议按以下分布设计：
   • 账户查询类（5题）：余额查询、交易明细、开户行信息等
   • 业务办理类（5题）：转账限额、密码重置、挂失补办等
   • 投诉处理类（5题）：服务投诉、费用争议、排队时长等
   • 理财咨询类（5题）：产品推荐、风险评估、收益计算等
2. 搭建测试环境：调用两个模型的 API 接口，统一 Prompt 模板（包含 System Prompt 和 User Prompt），确保对比公平。使用相同 temperature 参数（建议 0.3 以确保回答稳定性）。
3. 执行测试：依次将 20 个问题同时发送给两个模型，记录每个问题的完整输出及以下指标：
   • 首 Token 延迟（TTFT，毫秒）
   • 总耗时（毫秒）
   • Token 消耗量（输入 + 输出）
   • API 调用费用（$）
4. 质量评分：邀请 2~3 位评测人员，对每个模型的回答进行 1~5 分的盲评（隐藏模型身份），评分维度包括准确性、完整性、合规性和友好度。
5. 汇总分析：将结果填入对比表格，统计胜/平/负比例，计算平均分和置信区间。

7.2 任务二：成本效益分析

📋 操作步骤

1. 计算日均 Token 消耗：
   • 日均输入 Token = 10万次 × 500 tokens = 50M tokens/天
   • 日均输出 Token = 10万次 × 300 tokens = 30M tokens/天
   • 月均输入 Token = 50M × 30天 = 1,500M tokens ≈ 1.5B tokens
   • 月均输出 Token = 30M × 30天 = 900M tokens ≈ 0.9B tokens
2. API 方案月成本估算：根据各模型当前输入/输出单价计算月费。
3. 私有化部署 TCO 估算：对于 Qwen3-72B 私有化方案，需计算硬件折旧（GPU 服务器约 ¥5万/月）、运维人力（约 ¥2万/月）、电力和机房（约 ¥0.5万/月），合计约 ¥7.5万/月。
4. 质量评估：使用任务一的 20 题评测集，获取各模型的场景匹配得分（归一化到 0~100 分）。
5. 计算性价比指数：性价比 = 质量分数 / 月成本（千元），数值越高表示「每一千元换来的能力」越多。

7.3 任务三：模型退化测试

📋 操作步骤

1. 建立基准快照：选取 30~50 个能稳定反映模型能力的评测题目，保存旧版本模型的回答作为「基准快照」。 题目应覆盖以下维度（每维度 5~10 题）：
   • 金融知识：利率计算、外汇牌价、理财产品解释等
   • 格式遵循：要求 JSON 输出、表格输出、特定模板填空等
   • 安全对齐：包含金融欺诈话术、诱导性投资建议等需拒绝的 prompt
   • 推理能力：多步计算（如复利计算、分期还款方案对比）
   • 合规输出：涉及监管规定的回答是否准确完整
2. 新版本评测：使用完全相同的 Prompt 在新版本模型上运行，记录回答和关键指标。
3. 逐题对比：对每个题目，比较新旧版本的回答质量，标注差异类型：
   • 正向变化（+）：新版本明显更好
   • 无变化（=）：两版本表现相当
   • 退化（-）：新版本明显更差
   • 风格变化（~）：能力相当但输出风格有变
4. 退化分类：对于标注为「退化」的题目，进一步分析退化类型和严重程度。
5. 生成退化报告：汇总退化案例，评估对生产系统的影响程度。

8. 银行场景模型选型决策模板

以下提供一套针对银行业务场景的标准化模型选型决策模板，可直接用于实际选型项目。 模板采用加权评分法，已预置银行场景的推荐权重分配，各维度可根据实际业务优先级调整。

8.1 银行业模型选型评分卡

8.2 银行场景权重调整参考

不同银行场景的优先级差异较大，建议根据业务场景类型动态调整权重分配。以下给出三类典型场景的推荐权重配置：

8.3 模型选型决策检查清单

在完成评分卡后，建议使用以下检查清单进行最终确认，确保不遗漏关键考量因素：

💻 模型选型评估代码示例

1. 模型 A/B 对比测试框架

同时调用两个候选模型的 API，对比输出质量和响应时间，适用于 Prompt Engineering 阶段的快速验证。

"""
模型 A/B 对比测试框架
功能：同时调用两个模型 API，对比输出质量（BLEU/ROUGE）和响应时间（P50/P95/P99）
"""
import time
import statistics
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
from typing import Optional

import requests


@dataclass
class ModelConfig:
    """模型 API 配置"""
    name: str              # 模型标识，如 "GPT-4o"、"DeepSeek-V3"
    endpoint: str          # API 地址
    api_key: str           # 认证密钥
    model_id: str          # 模型 ID，如 "gpt-4o"
    max_tokens: int = 2048
    temperature: float = 0.0


@dataclass
class ABTestResult:
    """单条 A/B 测试结果"""
    prompt: str
    response_a: str
    response_b: str
    time_a_ms: float
    time_b_ms: float
    winner: Optional[str] = None  # "A" / "B" / "tie"


def call_model_api(config: ModelConfig, prompt: str) -> tuple[str, float]:
    """
    调用模型 API，返回 (响应文本, 耗时毫秒)
    此处以 OpenAI 兼容接口为例，实际可替换为各厂商 SDK
    """
    headers = {
        "Authorization": f"Bearer {config.api_key}",
        "Content-Type": "application/json"
    }
    payload = {
        "model": config.model_id,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": config.max_tokens,
        "temperature": config.temperature
    }

    start = time.perf_counter()
    resp = requests.post(config.endpoint, json=payload, headers=headers, timeout=60)
    elapsed_ms = (time.perf_counter() - start) * 1000
    resp.raise_for_status()
    data = resp.json()
    return data["choices"][0]["message"]["content"], elapsed_ms


def run_ab_test(
    model_a: ModelConfig,
    model_b: ModelConfig,
    test_cases: list[str]  # 测试 Prompt 列表
) -> list[ABTestResult]:
    """
    执行一轮 A/B 测试：对每条 prompt 并行调用两个模型，汇总结果
    """
    results: list[ABTestResult] = []

    def test_one(prompt: str) -> ABTestResult:
        with ThreadPoolExecutor(max_workers=2) as pool:
            future_a = pool.submit(call_model_api, model_a, prompt)
            future_b = pool.submit(call_model_api, model_b, prompt)
            resp_a, time_a = future_a.result()
            resp_b, time_b = future_b.result()

        # 简易质量对比：长度差异过大视为异常
        len_diff = abs(len(resp_a) - len(resp_b)) / max(len(resp_a), len(resp_b), 1)
        winner = "tie"
        if time_a < time_b and len_diff < 0.3:
            winner = "A"
        elif time_b < time_a and len_diff < 0.3:
            winner = "B"

        return ABTestResult(
            prompt=prompt,
            response_a=resp_a, response_b=resp_b,
            time_a_ms=time_a, time_b_ms=time_b,
            winner=winner
        )

    with ThreadPoolExecutor(max_workers=5) as pool:
        results = list(pool.map(test_one, test_cases))

    return results


def print_summary(results: list[ABTestResult], name_a: str, name_b: str):
    """打印 A/B 测试汇总报告"""
    times_a = [r.time_a_ms for r in results]
    times_b = [r.time_b_ms for r in results]
    wins_a = sum(1 for r in results if r.winner == "A")
    wins_b = sum(1 for r in results if r.winner == "B")
    ties  = sum(1 for r in results if r.winner == "tie")

    print(f"\n{'='*50}")
    print(f"  A/B 测试报告: {name_a} (A) vs {name_b} (B)")
    print(f"{'='*50}")
    print(f"用例数: {len(results)}")
    print(f"\n⏱️  响应时间统计:")
    print(f"  {name_a:<16} P50={statistics.median(times_a):.0f}ms  P95={sorted(times_a)[int(len(times_a)*0.95)]:.0f}ms")
    print(f"  {name_b:<16} P50={statistics.median(times_b):.0f}ms  P95={sorted(times_b)[int(len(times_b)*0.95)]:.0f}ms")
    print(f"\n🏆 胜负统计:")
    print(f"  {name_a} 胜: {wins_a}   {name_b} 胜: {wins_b}   平局: {ties}")
    print(f"  → {'推荐 ' + name_a if wins_a > wins_b else '推荐 ' + name_b if wins_b > wins_a else '无显著差异'}")


# ===== 使用示例 =====
if __name__ == "__main__":
    # 配置两个候选模型
    model_a = ModelConfig(
        name="GPT-4o",
        endpoint="https://api.openai.com/v1/chat/completions",
        api_key="sk-your-key-a",
        model_id="gpt-4o"
    )
    model_b = ModelConfig(
        name="DeepSeek-V3",
        endpoint="https://api.deepseek.com/v1/chat/completions",
        api_key="sk-your-key-b",
        model_id="deepseek-chat"
    )

    # 准备测试用例（覆盖典型业务场景）
    test_cases = [
        "请用中文解释什么是大语言模型的幻觉现象，并给出3个金融场景的例子。",
        "将以下英文合同条款翻译为中文，并说明潜在的法律风险：...",
        "根据以下客户对话记录，提取关键信息并生成 JSON 格式的摘要：...",
    ]

    results = run_ab_test(model_a, model_b, test_cases)
    print_summary(results, model_a.name, model_b.name)

2. 加权评分选型工具

输入各候选模型在多个维度上的得分和权重，计算加权总分并给出推荐排名，辅助最终决策。

"""
加权评分选型工具
功能：根据预设维度和权重，对候选模型进行加权评分，输出排名和推荐
"""
import json
from dataclasses import dataclass, field
from typing import Optional


@dataclass
class Dimension:
    """评估维度定义"""
    name: str           # 维度名称，如 "准确性"
    weight: float       # 权重（所有维度权重之和应为 1.0）
    key: str            # 维度键名，如 "accuracy"
    min_score: int = 1  # 最低分
    max_score: int = 5  # 最高分（5 分制）


@dataclass
class ModelCandidate:
    """候选模型"""
    name: str                            # 模型名称
    scores: dict[str, float]             # 各维度得分，如 {"accuracy": 4.5, "latency": 4.0}
    notes: dict[str, str] = field(default_factory=dict)  # 各维度备注
    cost_per_1k_tokens: Optional[float] = None  # 每 1K token 成本（可选）


def weighted_score(
    candidate: ModelCandidate,
    dimensions: list[Dimension]
) -> tuple[float, dict]:
    """
    计算加权总分，返回 (总分, 分维度加权得分明细)
    """
    total = 0.0
    detail = {}
    for dim in dimensions:
        raw = candidate.scores.get(dim.key, 0)
        weighted = raw * dim.weight
        total += weighted
        detail[dim.name] = {
            "raw_score": raw,
            "weight": dim.weight,
            "weighted": round(weighted, 2)
        }
    return round(total, 2), detail


def rank_models(
    candidates: list[ModelCandidate],
    dimensions: list[Dimension],
    cost_weight: float = 0.0,     # 成本维度的额外权重（如已包含在 dimensions 中则设为 0）
    budget_per_month: float = 0.0 # 月度预算（用于超预算警告）
) -> list[dict]:
    """
    对候选模型进行加权评分排名
    返回排序后的结果列表，包含总分、明细和推荐标记
    """
    # 校验权重
    total_weight = sum(d.weight for d in dimensions) + cost_weight
    if not 0.99 <= total_weight <= 1.01:
        print(f"⚠️ 警告：维度权重之和为 {total_weight}，建议调整为 1.0")

    results = []
    for c in candidates:
        score, detail = weighted_score(c, dimensions)

        # 成本评估
        cost_warning = ""
        if c.cost_per_1k_tokens and budget_per_month > 0:
            # 假设月调用量 100 万 token，简单估算
            estimated_monthly = c.cost_per_1k_tokens * 1000
            if estimated_monthly > budget_per_month:
                cost_warning = f"⚠️ 预估月费 ${estimated_monthly:.0f} 超出预算 ${budget_per_month:.0f}"

        results.append({
            "name": c.name,
            "total_score": score,
            "detail": detail,
            "cost_per_1k": c.cost_per_1k_tokens,
            "cost_warning": cost_warning,
            "notes": c.notes
        })

    # 按总分降序排列
    results.sort(key=lambda x: x["total_score"], reverse=True)

    # 标记推荐
    for i, r in enumerate(results):
        if i == 0:
            r["recommendation"] = "🥇 强烈推荐"
        elif r["total_score"] >= results[0]["total_score"] * 0.9:
            r["recommendation"] = "🥈 备选推荐"
        else:
            r["recommendation"] = ""

    return results


def print_ranking(results: list[dict], dimensions: list[Dimension]):
    """以表格形式打印排名结果"""
    print(f"\n{'='*70}")
    print(f"  📊 模型选型评分排名")
    print(f"{'='*70}")

    # 表头
    header = f"{'排名':<4} {'模型':<20} {'总分':>6}"
    for d in dimensions:
        header += f"  {d.name[:4]:>5}"
    print(header)
    print("-" * 70)

    for i, r in enumerate(results, 1):
        line = f"{i:<4} {r['name']:<20} {r['total_score']:>6.2f}"
        for d in dimensions:
            raw = r["detail"].get(d.name, {}).get("raw_score", "-")
            line += f"  {str(raw):>5}"
        rec = r.get("recommendation", "")
        if rec:
            line += f"  {rec}"
        if r.get("cost_warning"):
            line += f"\n    {r['cost_warning']}"
        print(line)

    print(f"\n✅ 推荐模型：{results[0]['name']}")


# ===== 使用示例：银行智能客服模型选型 =====
if __name__ == "__main__":
    # 1. 定义评估维度（权重基于银行业务优先级）
    dimensions = [
        Dimension(name="准确性",    weight=0.30, key="accuracy"),
        Dimension(name="安全性",    weight=0.25, key="security"),
        Dimension(name="响应速度",  weight=0.15, key="latency"),
        Dimension(name="中文能力",  weight=0.15, key="chinese"),
        Dimension(name="合规性",    weight=0.10, key="compliance"),
        Dimension(name="成本",      weight=0.05, key="cost"),
    ]

    # 2. 定义候选模型及其得分（1-5 分，基于自建评测集结果）
    candidates = [
        ModelCandidate(
            name="GPT-4o",
            scores={"accuracy": 4.8, "security": 4.2, "latency": 3.5,
                    "chinese": 4.5, "compliance": 4.0, "cost": 2.0},
            cost_per_1k_tokens=0.015,
            notes={"accuracy": "金融场景准确率 92%"}
        ),
        ModelCandidate(
            name="DeepSeek-V3",
            scores={"accuracy": 4.5, "security": 4.5, "latency": 4.0,
                    "chinese": 4.8, "compliance": 4.5, "cost": 4.5},
            cost_per_1k_tokens=0.002,
            notes={"accuracy": "中文金融理解优秀"}
        ),
        ModelCandidate(
            name="Claude 3.5 Sonnet",
            scores={"accuracy": 4.6, "security": 4.8, "latency": 3.8,
                    "chinese": 4.0, "compliance": 4.5, "cost": 2.5},
            cost_per_1k_tokens=0.012,
            notes={"security": "安全对齐业界领先"}
        ),
        ModelCandidate(
            name="Qwen2.5-72B（私有化）",
            scores={"accuracy": 4.2, "security": 5.0, "latency": 3.0,
                    "chinese": 4.7, "compliance": 5.0, "cost": 3.0},
            cost_per_1k_tokens=0.0,  # 私有化部署，无 token 成本
            notes={"security": "数据不出域，满足监管要求"}
        ),
    ]

    # 3. 执行评分排名
    results = rank_models(candidates, dimensions, budget_per_month=5000)
    print_ranking(results, dimensions)

    # 4. 导出详细报告
    report = {
        "dimensions": [{"name": d.name, "weight": d.weight} for d in dimensions],
        "ranking": results
    }
    print(f"\n📎 详细报告已生成，可通过以下方式导出：")
    print(f"   json.dumps(report, ensure_ascii=False, indent=2)")