跳至主要內容

LLM模型评估与选型：如何为你的场景选对模型

老张2026/7/14大约 26 分钟模型评估选型基准测试MMLUHumanEvalSpring AIJava

LLM模型评估与选型：如何为你的场景选对模型

一、那次代价惨重的"选错模型"

2024年秋天，深圳某电商公司，AI工程师刘洋主导了公司的智能客服系统选型。

他做了充分的"功课"：在HuggingFace的Open LLM Leaderboard上找到了一个MMLU排名第一的开源模型，综合得分高达88.3。他在公司内部演示了几个效果惊人的对话——逻辑推理清晰，英文表达准确，代码生成质量高。

领导拍板：就用这个。

三个月后，系统上线了。客户开始使用，问题来了：

  • 客户用带地方口音的中文问产品问题，模型理解率只有60%
  • 客户问"这个口红和裙子配吗"，模型给了一篇关于色彩理论的学术性分析
  • 客户发了一张产品图片问"这个包是真的吗"，模型说"我没有视觉能力"
  • 客户问"明天的闪购什么时候开始"，模型给了错误的时间（知识截止日期问题）

每月客服工单里，AI处理满意度只有31%，远低于人工客服的87%。

问题出在哪里？

MMLU测的是通识知识和推理能力，是英文为主的学术测试，和他们的业务场景——中文、口语化、时效性强、需要理解图片、高度领域特定——几乎完全不同。

他选了一个"考试第一名"的学生，却不知道这场"考试"考的是和他实际工作完全不同的内容。

这篇文章就是为刘洋这样的工程师写的：如何系统地为你的业务场景选对模型。

二、公开基准的局限：为什么排行榜不能直接指导选型

2.1 主流基准测试的设计意图

先了解各大基准在测什么：

MMLU（Massive Multitask Language Understanding）

  • 覆盖57个学术学科（数学、历史、法律、医学、计算机等）
  • 形式：四选一的选择题
  • 语言：英文为主
  • 测的是：通识知识广度和学术推理

HumanEval

  • 164道编程题，写函数完成给定任务
  • 语言：Python为主
  • 测的是：基础算法和编程能力

GSM8K（Grade School Math）

  • 8500道小学数学应用题
  • 测的是：数学推理（基础到中等难度）

HellaSwag

  • 常识推理和叙事补全
  • 测的是：常识理解和语言生成

Big-Bench Hard

  • 23个具有挑战性的推理任务
  • 测的是：高难度逻辑推理

2.2 基准测试的系统性局限

局限一：污染问题（Data Contamination）

很多开源模型的训练数据里可能包含了这些基准测试题目及答案，导致"考试作弊"。研究者无法完全验证训练数据的内容，所以榜单数据存疑。

// 类比：如果你在招聘Java工程师，测试题提前泄露了
// 候选人背下了所有答案，面试成绩很高
// 但实际工作中遇到新问题依然束手无策

// 这就是基准污染的本质问题

局限二：测试形式和实际使用的差距

基准测试通常是选择题、判断题，有标准答案。但实际生产中，你需要模型：

  • 生成长篇结构化输出
  • 理解模糊的自然语言输入
  • 在特定领域保持一致的人设
  • 处理多轮对话中的上下文

局限三：英文中心

大多数主流基准是英文的。对于中文业务，英文基准分数与中文实际效果的相关性有限。

局限四：静态快照

基准测试是固定的题目集。随着模型训练时间增加，越来越多的模型达到近似满分，榜单的区分度越来越低。

三、理解通用基准的正确姿势

既然基准不能直接指导选型，是不是完全没用？不是。

基准的正确使用方式：用来排除明显不合适的模型，而不是选出"最好的"模型。

3.1 各基准的解读

看MMLU：如果一个模型MMLU低于70，说明基础知识能力不足，一般不考虑。高于80表示基础能力扎实。

看HumanEval/MBPP：如果你的场景涉及代码（代码生成、代码审查），这个指标重要。但注意这些测试Python为主，Java代码能力需要单独验证。

看GSM8K：如果场景涉及数学计算或多步推理，关注这个。但超过80分的模型差距主要体现在更难的数学题（MATH数据集）上。

看中文基准（C-Eval、CMMLU）：这是中文业务选型时必须看的。

// 实际选型时的基准阅读策略（伪代码）
public boolean isModelWorthConsidering(ModelBenchmarks b) {
    // 硬性门槛：通用能力不过线，直接排除
    if (b.getMmlu() < 70) return false;
    
    // 如果是中文业务
    if (businessIsChineseLanguage) {
        if (b.getCeval() < 65 || b.getCmmlu() < 65) return false;
    }
    
    // 如果涉及代码生成
    if (businessInvolvesCode) {
        if (b.getHumanEval() < 50) return false;
    }
    
    // 通过门槛，进入下一轮自定义评估
    return true;
}

3.2 值得关注的中文基准

基准内容特点
C-Eval中文学科知识选择题中文学术能力
CMMLU中文多任务语言理解覆盖更广的中文场景
CLUEWSC中文代词消解中文语言理解
LCCC中文多轮对话中文对话质量
SuperCLUE综合中文能力国内常用参考

四、自定义评估集：为你的业务场景构建黄金标准

这是整篇文章最重要的一节。

核心原则：你的业务场景才是最权威的评估基准。

4.1 构建评估集的步骤

第一步：收集真实用户输入

从你的系统日志、历史数据、用户反馈中提取真实的用户输入，而不是自己编造测试用例。

@Service
public class EvalDatasetBuilder {
    
    public List<EvalCase> buildFromLogs(String startDate, String endDate, int count) {
        // 从历史对话日志采样
        List<ConversationLog> logs = logRepository.findByDateRange(startDate, endDate);
        
        return logs.stream()
            // 过滤：只保留有完整对话的记录
            .filter(log -> log.hasUserMessage() && log.hasAgentResponse())
            // 分层采样：按输入类型分层，确保覆盖各种场景
            .collect(groupingBy(ConversationLog::getIntentCategory))
            .values().stream()
            .flatMap(categoryLogs -> 
                categoryLogs.stream()
                    .sorted(Comparator.comparingDouble(this::computeDiversity).reversed())
                    .limit(count / INTENT_CATEGORY_COUNT))
            .map(log -> EvalCase.builder()
                .input(log.getUserMessage())
                .referenceOutput(log.getAgentResponse()) // 历史的好回复作为参考
                .metadata(Map.of(
                    "intent", log.getIntentCategory(),
                    "satisfaction_score", log.getSatisfactionScore()
                ))
                .build())
            .collect(toList());
    }
}

第二步：标注标准答案（Golden Labels）

// 评估用例的数据结构
@Data
@Builder
public class EvalCase {
    private String id;
    private String input;
    private String referenceOutput;     // 参考答案（人工标注的理想输出）
    
    // 评估维度的标准分数（0-5分）
    private int accuracyScore;          // 事实准确性
    private int relevanceScore;         // 与问题的相关性
    private int tonScore;               // 语气/风格
    private int completenessScore;      // 回答完整性
    private int formatScore;            // 格式规范性
    
    // 分类标签（用于分析不同类型问题的表现）
    private String intentCategory;      // 意图类别
    private DifficultyLevel difficulty; // 难度级别
    
    // 关键词（用于验证回答是否包含必要信息）
    private List<String> requiredKeywords;
    private List<String> forbiddenPhrases; // 不应该出现的说法
}

第三步：分层覆盖

好的评估集需要覆盖不同类型的输入：

// 评估集分层策略（以客服系统为例）
Map<String, Integer> evalSetDistribution = Map.of(
    "产品咨询",         20,  // 20%是产品相关问题
    "订单问题",         20,  // 20%是订单相关
    "退款投诉",         15,  // 15%是投诉处理
    "技术支持",         15,  // 15%是技术问题
    "活动信息",         10,  // 10%是活动相关
    "账号问题",         10,  // 10%是账号相关
    "模糊意图",          5,  // 5%是意图不明确的问题
    "边界情况",          5   // 5%是刁钻/测试性输入
);

// 总共约200个用例，这是最低够用的量
// 如果预算允许，500-1000个用例更可靠

4.2 评估集的大小建议

场景复杂度最小评估集大小置信度
简单、单一意图50一般
中等复杂度200可接受
复杂、多意图500-1000良好
高精度要求1000+ + 人工验证高

五、评估维度：不只是准确率

5.1 五维评估框架

@Data
public class ModelEvaluationResult {
    private String modelName;
    
    // 维度1：准确性（Accuracy）
    // 回答中的事实是否正确
    private double accuracyScore;
    
    // 维度2：速度（Latency）
    private LatencyStats latencyStats; // P50, P90, P99
    
    // 维度3：成本（Cost）
    private CostStats costStats;       // 每1000次调用的费用
    
    // 维度4：API稳定性（Reliability）
    private double availabilityRate;   // 可用率（过去30天）
    private double errorRate;          // 错误率
    private RateLimitInfo rateLimits;  // 限速信息
    
    // 维度5：上下文长度（Context Window）
    private int maxContextLength;      // 最大输入长度
    private double longContextAccuracy;// 长文档处理的准确率
}

5.2 速度基准测试

@Service
public class LatencyBenchmarkService {
    
    public LatencyStats benchmarkLatency(LLMClient client, 
                                          List<String> prompts,
                                          int iterations) {
        List<Long> latencies = new ArrayList<>();
        AtomicInteger firstTokenCount = new AtomicInteger();
        List<Long> ttftLatencies = new ArrayList<>(); // Time To First Token
        
        for (String prompt : prompts) {
            for (int i = 0; i < iterations; i++) {
                long startTime = System.currentTimeMillis();
                
                // 流式API：记录首个token的到达时间
                AtomicBoolean firstToken = new AtomicBoolean(false);
                
                client.streamChat(prompt, token -> {
                    if (!firstToken.getAndSet(true)) {
                        ttftLatencies.add(System.currentTimeMillis() - startTime);
                    }
                });
                
                long totalLatency = System.currentTimeMillis() - startTime;
                latencies.add(totalLatency);
            }
        }
        
        // 计算统计数据
        Collections.sort(latencies);
        int size = latencies.size();
        
        return LatencyStats.builder()
            .p50(latencies.get(size / 2))
            .p90(latencies.get((int) (size * 0.9)))
            .p99(latencies.get((int) (size * 0.99)))
            .avgTTFT(ttftLatencies.stream().mapToLong(l -> l).average().orElse(0))
            .throughputTokensPerSecond(computeThroughput(latencies, prompts))
            .build();
    }
}

5.3 成本计算框架

@Service
public class ModelCostCalculator {
    
    /**
     * 计算不同模型在你的实际业务量下的真实成本
     */
    public CostComparison compareCosts(ModelConfig model, BusinessMetrics metrics) {
        // 从业务指标中推算token使用量
        double avgInputTokens = metrics.getAvgPromptLength() * 1.3; // 大约系数
        double avgOutputTokens = metrics.getAvgResponseLength() * 1.3;
        
        // 月成本计算
        long monthlyRequests = metrics.getDailyRequests() * 30;
        
        double monthlyInputCost = (avgInputTokens * monthlyRequests / 1_000_000) 
                                   * model.getInputPricePerMillion();
        double monthlyOutputCost = (avgOutputTokens * monthlyRequests / 1_000_000)
                                    * model.getOutputPricePerMillion();
        
        // 如果支持Prompt Caching，计算缓存节省
        double cacheSavings = 0;
        if (model.supportsCaching() && metrics.getSystemPromptTokens() > 1000) {
            double cacheableTokenRatio = (double) metrics.getSystemPromptTokens() 
                                          / avgInputTokens;
            cacheSavings = monthlyInputCost * cacheableTokenRatio 
                           * (1 - model.getCacheHitPrice() / model.getInputPricePerMillion());
        }
        
        return CostComparison.builder()
            .modelName(model.getName())
            .monthlyInputCost(monthlyInputCost)
            .monthlyOutputCost(monthlyOutputCost)
            .cacheSavings(cacheSavings)
            .totalMonthlyCost(monthlyInputCost + monthlyOutputCost - cacheSavings)
            .costPerRequest((monthlyInputCost + monthlyOutputCost - cacheSavings) 
                           / monthlyRequests)
            .build();
    }
    
    /**
     * 2025年主流模型成本概览（仅供参考，以实际官网为准）
     */
    public List<ModelConfig> getModelPriceList() {
        return List.of(
            ModelConfig.builder()
                .name("gpt-4o")
                .inputPricePerMillion(2.50)
                .outputPricePerMillion(10.00)
                .supportsCaching(true)
                .build(),
            ModelConfig.builder()
                .name("gpt-4o-mini")
                .inputPricePerMillion(0.15)
                .outputPricePerMillion(0.60)
                .supportsCaching(true)
                .build(),
            ModelConfig.builder()
                .name("claude-3-5-sonnet")
                .inputPricePerMillion(3.00)
                .outputPricePerMillion(15.00)
                .supportsCaching(true)
                .cacheHitPrice(0.30)
                .build(),
            ModelConfig.builder()
                .name("claude-3-5-haiku")
                .inputPricePerMillion(0.80)
                .outputPricePerMillion(4.00)
                .supportsCaching(true)
                .build(),
            ModelConfig.builder()
                .name("deepseek-v3")
                .inputPricePerMillion(0.27)
                .outputPricePerMillion(1.10)
                .build(),
            ModelConfig.builder()
                .name("qwen-plus")
                .inputPricePerMillion(0.56)
                .outputPricePerMillion(2.24)
                .build()
        );
    }
}

六、A/B测试框架：在生产环境对比两个模型

6.1 为什么要做生产A/B测试

离线评估（用你自己构建的评估集）和在线实际效果之间总是有差距。生产环境的用户行为更加多样和不可预测。

A/B测试是最终的裁判。

6.2 Spring AI实现的A/B测试框架

@Service
@Slf4j
public class ModelABTestService {
    
    private final Map<String, LLMClient> modelClients;
    private final ABTestConfig config;
    private final MetricsCollector metricsCollector;
    
    /**
     * A/B测试路由：按比例分配流量到不同模型
     */
    public ChatResponse routeWithABTest(String userId, ChatRequest request) {
        String selectedModel = selectModel(userId);
        
        long startTime = System.currentTimeMillis();
        ChatResponse response;
        
        try {
            response = modelClients.get(selectedModel).chat(request);
            
            // 记录成功指标
            metricsCollector.recordSuccess(
                selectedModel,
                System.currentTimeMillis() - startTime,
                countTokens(response.getContent())
            );
            
        } catch (Exception e) {
            log.error("模型{}调用失败: {}", selectedModel, e.getMessage());
            metricsCollector.recordError(selectedModel, e.getClass().getSimpleName());
            
            // 故障转移：失败时切换到备用模型
            String fallbackModel = config.getFallbackModel(selectedModel);
            response = modelClients.get(fallbackModel).chat(request);
        }
        
        // 在响应中标记使用的模型（用于后续反馈关联）
        response.setModelUsed(selectedModel);
        response.setTraceId(UUID.randomUUID().toString());
        
        return response;
    }
    
    /**
     * 基于用户ID的一致性分组（同一用户始终用同一个模型）
     */
    private String selectModel(String userId) {
        // 用userId的哈希值做一致性分组
        int hash = Math.abs(userId.hashCode() % 100);
        
        int cumulative = 0;
        for (Map.Entry<String, Integer> entry : config.getTrafficSplit().entrySet()) {
            cumulative += entry.getValue();
            if (hash < cumulative) {
                return entry.getKey();
            }
        }
        
        return config.getDefaultModel();
    }
    
    /**
     * A/B测试结果统计报告
     */
    public ABTestReport generateReport(String startDate, String endDate) {
        Map<String, ModelMetrics> metricsMap = metricsCollector
            .getMetricsByModel(startDate, endDate);
        
        // 计算各模型的统计数据
        Map<String, ModelStats> statsMap = new HashMap<>();
        metricsMap.forEach((modelName, metrics) -> {
            statsMap.put(modelName, ModelStats.builder()
                .requestCount(metrics.getRequestCount())
                .avgLatencyMs(metrics.getAvgLatency())
                .p99LatencyMs(metrics.getP99Latency())
                .errorRate(metrics.getErrorRate())
                .avgTokensPerRequest(metrics.getAvgTokensPerRequest())
                .estimatedCost(metrics.getEstimatedCost())
                // 如果有用户反馈分数
                .avgUserSatisfaction(metrics.getAvgSatisfactionScore())
                .build());
        });
        
        // 统计显著性检验（判断差异是否显著）
        Map<String, StatTestResult> significance = new HashMap<>();
        String baselineModel = config.getBaselineModel();
        statsMap.entrySet().stream()
            .filter(e -> !e.getKey().equals(baselineModel))
            .forEach(e -> {
                significance.put(e.getKey(), 
                    performChiSquareTest(
                        statsMap.get(baselineModel),
                        e.getValue()
                    )
                );
            });
        
        return ABTestReport.builder()
            .startDate(startDate)
            .endDate(endDate)
            .modelStats(statsMap)
            .statisticalSignificance(significance)
            .winner(determineWinner(statsMap, significance))
            .recommendation(generateRecommendation(statsMap, significance))
            .build();
    }
}

6.3 A/B测试的统计显著性

很多工程师犯的错误：只看平均值，不考虑统计显著性。

/**
 * 使用卡方检验或t检验判断差异是否显著
 * 只有p值<0.05时，差异才是"统计显著"的
 */
private StatTestResult performChiSquareTest(ModelStats baseline, ModelStats variant) {
    // 这里用二项分布的z检验比较满意度比例
    double p1 = baseline.getAvgUserSatisfaction();
    double p2 = variant.getAvgUserSatisfaction();
    int n1 = baseline.getRequestCount();
    int n2 = variant.getRequestCount();
    
    double pPooled = (p1 * n1 + p2 * n2) / (n1 + n2);
    double se = Math.sqrt(pPooled * (1 - pPooled) * (1.0/n1 + 1.0/n2));
    double zScore = (p2 - p1) / se;
    
    double pValue = 2 * (1 - normalCDF(Math.abs(zScore)));
    
    return StatTestResult.builder()
        .zScore(zScore)
        .pValue(pValue)
        .isSignificant(pValue < 0.05)
        .absoluteDifference(p2 - p1)
        .relativeDifference((p2 - p1) / p1 * 100)
        .interpretation(pValue < 0.05 
            ? String.format("差异显著（p=%.4f），变体模型相对基准%s%.1f%%", 
                           pValue, p2 > p1 ? "提升了" : "下降了", 
                           Math.abs(p2 - p1) / p1 * 100)
            : "差异不显著，无法得出结论")
        .build();
}

实践建议：每个模型至少需要1000次请求才有足够的统计显著性。

七、中文能力专项评估

7.1 中文能力测试矩阵

对于中文业务，需要专门评估以下维度：

@Service
public class ChineseCapabilityEvaluator {
    
    /**
     * 全面的中文能力测试套件
     */
    public ChineseCapabilityReport evaluate(LLMClient client) {
        return ChineseCapabilityReport.builder()
            // 1. 基础语言理解
            .comprehensionScore(testComprehension(client))
            // 2. 多方言/口语理解
            .dialectScore(testDialectUnderstanding(client))
            // 3. 中文特有的语言现象
            .classicalChineseScore(testClassicalChinese(client))
            // 4. 领域特定术语
            .domainTermScore(testDomainTerms(client))
            // 5. 文化背景理解
            .culturalScore(testCulturalUnderstanding(client))
            // 6. 长中文文档处理
            .longDocScore(testLongDocumentProcessing(client))
            .build();
    }
    
    private double testDialectUnderstanding(LLMClient client) {
        List<TestCase> dialectCases = List.of(
            // 网络用语
            new TestCase("这个YYDS，真的绷不住了", "理解并正常回应"),
            // 方言词汇（普通话客服可能遇到）
            new TestCase("我想买那个嘎嘎好看的裙子", "理解"嘎嘎"是程度副词"),
            // 缩写和表情包文化
            new TestCase("今天xswl了，886", "理解网络缩写含义")
        );
        
        return evaluateCases(client, dialectCases);
    }
    
    private double testDomainTerms(LLMClient client) {
        // 根据你的业务领域自定义
        List<TestCase> domainCases = getBusinessSpecificTermCases();
        return evaluateCases(client, domainCases);
    }
}

7.2 中文能力对比（2025年参考）

模型C-EvalCMMLU中文口语中文长文档中文代码注释
GPT-4o87.285.6好优秀优秀
Claude 3.5 Sonnet86.885.2好优秀优秀
DeepSeek V390.188.9优秀优秀优秀
Qwen2.5-72B91.290.3优秀优秀优秀
文心一言4.082.381.4优秀好好

结论：对于中文场景，国内模型（Qwen、DeepSeek）在中文基准上普遍优于国外模型，但具体业务场景仍需自测。

八、Java代码能力专项评估

对Java工程师最关心的代码生成能力，HumanEval（Python为主）的分数参考价值有限。需要专门的Java代码评估。

8.1 Java代码评估维度

@Service
public class JavaCodeCapabilityEvaluator {
    
    /**
     * Java代码生成能力评估框架
     */
    public JavaCodeReport evaluateJavaCapability(LLMClient client) {
        return JavaCodeReport.builder()
            .basicSyntaxScore(testBasicJavaSyntax(client))
            .springBootScore(testSpringBootKnowledge(client))
            .concurrencyScore(testConcurrencyKnowledge(client))
            .designPatternScore(testDesignPatterns(client))
            .unitTestScore(testUnitTestGeneration(client))
            .codeReviewScore(testCodeReviewAbility(client))
            .refactoringScore(testRefactoringAbility(client))
            .apiVersionAwarenessScore(testAPIVersionAwareness(client))
            .build();
    }
    
    /**
     * 测试Spring Boot相关知识
     */
    private double testSpringBootKnowledge(LLMClient client) {
        List<CodeTestCase> cases = List.of(
            // 测试1：Spring AI集成
            CodeTestCase.builder()
                .prompt("用Spring AI写一个调用OpenAI API的简单聊天接口")
                .checks(List.of(
                    code -> code.contains("@RestController"),
                    code -> code.contains("ChatClient") || code.contains("ChatModel"),
                    code -> !code.contains("openai.beta") // 排除旧版API
                ))
                .build(),
            
            // 测试2：事务管理
            CodeTestCase.builder()
                .prompt("写一个带有事务管理的Service方法，在转账失败时回滚")
                .checks(List.of(
                    code -> code.contains("@Transactional"),
                    code -> code.contains("rollbackFor") || code.contains("RuntimeException")
                ))
                .build(),
            
            // 测试3：最新API版本意识
            CodeTestCase.builder()
                .prompt("用Spring Boot 3.x写一个接口，使用虚拟线程处理请求")
                .checks(List.of(
                    code -> code.contains("VirtualThreadTaskExecutor") 
                            || code.contains("virtual-threads"),
                    // 不应该使用Spring Boot 2.x的老写法
                    code -> !code.contains("ThreadPoolTaskExecutor")
                ))
                .build()
        );
        
        return (double) cases.stream()
            .filter(c -> evaluateCodeCase(client, c))
            .count() / cases.size();
    }
    
    /**
     * 测试模型对Java版本的意识
     * 特别重要：2025年很多模型仍然用Java 8的写法
     */
    private double testAPIVersionAwareness(LLMClient client) {
        List<CodeTestCase> versionCases = List.of(
            CodeTestCase.builder()
                .prompt("Java中如何读取一个文件的内容？")
                .checks(List.of(
                    // 应该用现代API
                    code -> code.contains("Files.readString") 
                            || code.contains("Files.readAllLines"),
                    // 不应该用老式的BufferedReader模式（除非有特殊原因）
                    code -> !code.contains("new BufferedReader(new FileReader")
                ))
                .build(),
            
            CodeTestCase.builder()
                .prompt("Java中如何实现一个不可变的数据类？")
                .checks(List.of(
                    // Java 16+应该用record
                    code -> code.contains("record") || code.contains("@Value"),
                    // 不应该手动写setter-less class
                    code -> !code.startsWith("class")
                ))
                .build()
        );
        
        return (double) versionCases.stream()
            .filter(c -> evaluateCodeCase(client, c))
            .count() / versionCases.size();
    }
}

8.2 自动化代码正确性验证

@Service
public class CodeCorrectnessValidator {
    
    /**
     * 对生成的Java代码进行编译和基础运行验证
     */
    public ValidationResult validateJavaCode(String generatedCode, String testCode) {
        // 1. 编译验证
        try {
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            
            // 把代码写到临时文件
            Path sourceFile = writeToTempFile(generatedCode, "GeneratedClass.java");
            
            StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
            Iterable<? extends JavaFileObject> units = 
                fileManager.getJavaFileObjects(sourceFile.toFile());
            
            // 编译
            DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
            boolean compileSuccess = compiler.getTask(null, fileManager, diagnostics, 
                                                       null, null, units).call();
            
            if (!compileSuccess) {
                List<String> errors = diagnostics.getDiagnostics().stream()
                    .filter(d -> d.getKind() == Diagnostic.Kind.ERROR)
                    .map(d -> d.getMessage(null))
                    .collect(toList());
                
                return ValidationResult.compileFailed(errors);
            }
            
        } catch (Exception e) {
            return ValidationResult.error(e.getMessage());
        }
        
        // 2. 单元测试验证（如果提供了测试代码）
        if (testCode != null && !testCode.isEmpty()) {
            return runUnitTests(generatedCode, testCode);
        }
        
        return ValidationResult.compileSuccess();
    }
}

九、评估自动化：用另一个LLM做自动评估

手工评估100个用例已经很累了，更别说几千个。解决方案是：LLM-as-a-Judge（用大模型评价大模型）。

9.1 LLM-as-a-Judge的原理

研究发现，GPT-4等强模型在评估其他模型的输出质量时，与人工评估的一致性高达80-90%。

@Service
public class LLMJudgeService {
    
    // 用一个"裁判模型"来评估其他模型的输出
    private final ChatClient judgeClient; // 通常用GPT-4或Claude作为裁判
    
    /**
     * 评估单个回答的质量
     */
    public JudgeResult evaluateResponse(String question,
                                         String modelResponse,
                                         String referenceAnswer) {
        String judgePrompt = """
            你是一个严格、公正的AI输出质量评估专家。
            请评估以下AI回答的质量，与参考答案进行对比。
            
            问题：
            %s
            
            参考答案（专家撰写，作为评估基准）：
            %s
            
            待评估的AI回答：
            %s
            
            请从以下5个维度评分（1-5分），并给出简短的理由：
            
            1. 事实准确性（1-5）：回答中的事实是否正确，与参考答案是否一致
            2. 相关性（1-5）：回答是否回应了问题的核心
            3. 完整性（1-5）：是否覆盖了参考答案中的关键点
            4. 简洁性（1-5）：回答是否言简意赅，没有无关信息
            5. 格式质量（1-5）：结构、可读性是否良好
            
            以JSON格式返回：
            {
                "accuracy": {"score": X, "reason": "简短理由"},
                "relevance": {"score": X, "reason": "简短理由"},
                "completeness": {"score": X, "reason": "简短理由"},
                "conciseness": {"score": X, "reason": "简短理由"},
                "format": {"score": X, "reason": "简短理由"},
                "overall_score": X.X,
                "summary": "整体评价（一句话）"
            }
            """.formatted(question, referenceAnswer, modelResponse);
        
        String judgeResponse = judgeClient.prompt()
            .user(judgePrompt)
            .options(ChatOptions.builder().temperature(0.1).build())
            .call()
            .content();
        
        return parseJudgeResult(judgeResponse);
    }
    
    /**
     * 批量评估，生成完整的模型对比报告
     */
    public ModelComparisonReport evaluateModels(List<String> modelNames,
                                                  List<EvalCase> evalCases) {
        Map<String, List<JudgeResult>> resultsByModel = new HashMap<>();
        
        for (EvalCase evalCase : evalCases) {
            for (String modelName : modelNames) {
                // 每个模型对每个用例生成回答
                String modelResponse = getModelResponse(modelName, evalCase.getInput());
                
                // 用裁判模型评估
                JudgeResult result = evaluateResponse(
                    evalCase.getInput(),
                    modelResponse,
                    evalCase.getReferenceOutput()
                );
                
                resultsByModel.computeIfAbsent(modelName, k -> new ArrayList<>())
                              .add(result);
                
                // 控制裁判模型的API调用速率
                rateLimiter.acquire();
            }
        }
        
        // 汇总统计
        return ModelComparisonReport.builder()
            .modelScores(computeAverageScores(resultsByModel))
            .dimensionBreakdown(computeDimensionScores(resultsByModel))
            .categoryBreakdown(computeCategoryScores(resultsByModel, evalCases))
            .winner(determineWinner(resultsByModel))
            .build();
    }
}

9.2 避免LLM-as-a-Judge的偏见

裁判模型有已知的偏见：

  • 位置偏见：倾向于认为第一个或最后一个回答更好
  • 长度偏见：倾向于认为更长的回答更好
  • 自我偏见：GPT-4倾向于给GPT系列的输出更高分

消除偏见的策略：

// 策略1：换序评估（防止位置偏见）
// 对同一对比，改变答案顺序重复评估，取平均

// 策略2：盲评（防止模型名称偏见）
// 不在Prompt里透露模型名称

// 策略3：多个裁判（减少单一裁判的偏见）
public JudgeResult robustEvaluate(String question, String response, String reference) {
    List<JudgeResult> judgeResults = List.of(
        evaluateWithJudge("gpt-4o", question, response, reference),
        evaluateWithJudge("claude-3-5-sonnet", question, response, reference)
    );
    
    // 取平均分
    return JudgeResult.average(judgeResults);
}

十、选型决策模板：从业务需求到模型选择

10.1 完整的决策流程图

第一步：明确业务需求
    ├── 主要语言？（中文/英文/多语言）
    ├── 主要任务类型？（对话/代码/分析/生成）
    ├── 延迟要求？（实时对话 <2s / 批处理不限）
    ├── 吞吐量？（QPS要求）
    ├── 成本预算？（月度API费用上限）
    ├── 数据隐私？（能否发送到第三方API）
    └── 集成要求？（云服务/本地部署）

第二步：建立候选清单（用基准排除明显不合适的）
    ├── 英文为主 → GPT-4o, Claude 3.5 Sonnet
    ├── 中文为主 → Qwen2.5, DeepSeek V3, 文心一言
    ├── 代码为主 → Claude 3.5 Sonnet, GPT-4o, DeepSeek Coder
    ├── 成本敏感 → GPT-4o-mini, Claude Haiku, Qwen-plus
    └── 本地部署 → Qwen2.5-7B, LLaMA3.1-8B, Qwen2.5-Coder-7B

第三步：用自定义评估集评估候选模型（3-5个）
    → 计算各维度分数（准确性、速度、成本）

第四步：小流量A/B测试（5%-10%）
    → 收集真实用户反馈数据

第五步：全量切换
    → 持续监控，建立告警

10.2 Java工程师实战选型矩阵（2025年参考）

场景首推方案备选方案关键原因
中文客服对话Qwen2.5-72BDeepSeek V3中文理解最强
Java代码辅助Claude 3.5 SonnetGPT-4o代码质量高，上下文长
文档分析/总结Claude 3.5 SonnetQwen2.5-72B长上下文处理好
高吞吐低成本GPT-4o-miniQwen-plus成本最优
本地私有化Qwen2.5-14BLLaMA3.1-70B中文好，可本地部署
多模态（含图片）GPT-4oClaude 3.5 Sonnet视觉理解
数学/科学推理o1/o3DeepSeek R1推理模型专项优化

10.3 决策工具：完整的选型评估代码

@Service
public class ModelSelectionAdvisor {
    
    /**
     * 根据业务需求自动推荐模型
     */
    public ModelRecommendation recommend(BusinessRequirements req) {
        // 获取候选模型
        List<ModelConfig> candidates = getCandidateModels(req);
        
        // 多维度加权评分
        Map<String, Double> scores = new HashMap<>();
        
        candidates.forEach(model -> {
            double score = 0;
            
            // 中文能力权重
            if (req.isPrimaryLanguageChinese()) {
                score += model.getChineseScore() * 0.35;
            } else {
                score += model.getEnglishScore() * 0.35;
            }
            
            // 代码能力权重
            if (req.isCodeHeavyTask()) {
                score += model.getCodeScore() * 0.30;
            } else {
                score += model.getCodeScore() * 0.10;
            }
            
            // 成本权重（用倒数，成本越低分越高）
            double normalizedCost = normalizeCost(model.getEstimatedMonthlyCost(req));
            score += (1 - normalizedCost) * req.getCostSensitivity();
            
            // 延迟权重
            double normalizedLatency = normalizeLatency(model.getAvgLatencyMs());
            score += (1 - normalizedLatency) * (req.isRealtime() ? 0.20 : 0.05);
            
            // 可用性权重
            score += model.getAvailabilityRate() * 0.05;
            
            scores.put(model.getName(), score);
        });
        
        // 按分数排序
        List<Map.Entry<String, Double>> ranked = scores.entrySet().stream()
            .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
            .collect(toList());
        
        return ModelRecommendation.builder()
            .topRecommendation(ranked.get(0).getKey())
            .topScore(ranked.get(0).getValue())
            .alternatives(ranked.subList(1, Math.min(3, ranked.size())))
            .reasoning(generateReasoning(req, ranked.get(0).getKey()))
            .nextSteps(generateNextSteps(req))
            .build();
    }
    
    private String generateReasoning(BusinessRequirements req, String topModel) {
        List<String> reasons = new ArrayList<>();
        
        if (req.isPrimaryLanguageChinese()) {
            reasons.add("中文业务场景，优先选择中文能力强的模型");
        }
        if (req.isCodeHeavyTask()) {
            reasons.add("代码生成是主要任务，代码质量权重较高");
        }
        if (req.getCostSensitivity() > 0.7) {
            reasons.add("成本敏感场景，在效果可接受的前提下优先考虑低成本方案");
        }
        if (req.isRealtime()) {
            reasons.add("实时对话场景，低延迟是重要指标");
        }
        
        return String.join("；", reasons);
    }
}

十一、FAQ

Q1：选型后发现效果不好，怎么快速切换？

A：这是Spring AI等框架的核心价值。用ChatModel抽象层，切换模型只需修改配置，不需要改代码：

# 只需修改application.yml
spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-4o-mini  # 从gpt-4o切换到gpt-4o-mini

Q2：同一个场景，用不同模型的Prompt一样吗？

A：通常需要调整。不同模型对Prompt的"偏好"不同：

  • Claude更擅长处理结构化指令，喜欢XML标签格式
  • GPT对Markdown格式响应更好
  • 国内模型对中文直接指令响应更稳定，不需要英文提示

切换模型时，Prompt也需要重新优化。

Q3：模型的版本更新后，评估集还有用吗？

A：有，但需要重新跑一遍。模型更新后，某些能力可能提升，某些可能退化（Capability Regression）。建议把评估集作为回归测试，每次模型版本更新后都跑一遍，确认效果没有下降。

Q4：小公司没有资源做系统的评估，怎么快速选型？

A：快速选型的最低门槛方案：

  1. 从候选模型中选2-3个
  2. 用你们最典型的20个真实用户问题手工测试
  3. 让团队里2-3个人主观打分（1-5分）
  4. 选平均分最高的，快速上线
  5. 上线后收集真实用户反馈，2周后再做一次更严格的评估

完美是好的敌人。快速上线获取真实数据，比在离线评估上花太多时间更有价值。

Q5：多模型组合使用（路由策略）有价值吗？

A：非常有价值。典型策略：

  • 简单查询 → 小模型（低成本，低延迟）
  • 复杂推理 → 大模型（高准确率）
  • 代码任务 → 专用代码模型
  • 中文专题 → 中文专用模型
@Service
public class IntelligentModelRouter {
    
    public String route(ChatRequest request) {
        String complexity = classifyComplexity(request.getUserMessage());
        
        return switch (complexity) {
            case "simple" -> "gpt-4o-mini";      // 低成本处理简单问题
            case "code" -> "claude-3-5-sonnet";  // 代码专用
            case "chinese_deep" -> "qwen2.5-72b"; // 深度中文理解
            default -> "gpt-4o";                  // 通用高质量
        };
    }
}

研究表明，合理的多模型路由策略可以在保持90%+效果的同时，将API成本降低40-60%。

十二、总结：选型是一个持续的过程

回到刘洋的故事。他的错误不是选错了模型本身，而是：

  1. 把英文学术基准当作中文业务的指导
  2. 没有构建自己的业务评估集
  3. 没有在小范围A/B测试后再全量上线

大模型选型的正确姿态是：

离线评估（自定义评估集）→ 小流量在线测试（A/B）→ 全量部署 → 持续监控 → 下一轮评估

这是一个循环，而不是一次性决策。

阶段关键行动产出物
基准筛选用公开基准排除明显不合适的候选模型清单（3-5个）
自定义评估构建业务评估集 + 自动评估各模型的量化得分
A/B测试5%流量 × 1-2周真实用户满意度数据
全量部署灰度发布 + 监控告警生产模型确定
持续迭代每季度重新评估选型文档更新

最重要的一条：没有"最好的模型"，只有"最适合你场景的模型"。

十三、模型退化（Model Regression）监控：让选型工作持续生效

选型不是一次性工作。模型提供商会不断更新模型版本，有时候更新会引入意想不到的退化——某些能力提升了，另一些能力可能下降。

13.1 构建持续评估Pipeline

@Service
public class ModelRegressionMonitorService {
    
    // 黄金评估集：精心构建的、固定不变的测试用例集
    private final List<EvalCase> goldenEvalSet;
    
    /**
     * 当模型版本更新时，自动运行回归测试
     * 在CI/CD Pipeline中触发
     */
    public RegressionTestResult runRegressionTest(String newModelVersion,
                                                    String baselineVersion) {
        Map<String, ModelTestResult> results = new HashMap<>();
        
        for (String version : List.of(newModelVersion, baselineVersion)) {
            double totalScore = 0;
            Map<String, Double> scoresByCategory = new HashMap<>();
            
            for (EvalCase evalCase : goldenEvalSet) {
                String response = callModel(version, evalCase.getInput());
                double score = autoScore(evalCase, response);
                totalScore += score;
                
                // 按类别统计
                scoresByCategory.merge(
                    evalCase.getIntentCategory(), score, Double::sum
                );
            }
            
            results.put(version, ModelTestResult.builder()
                .modelVersion(version)
                .overallScore(totalScore / goldenEvalSet.size())
                .scoresByCategory(normalizeByCategory(scoresByCategory, goldenEvalSet))
                .build());
        }
        
        // 计算退化
        ModelTestResult baseline = results.get(baselineVersion);
        ModelTestResult newModel = results.get(newModelVersion);
        
        double overallDiff = newModel.getOverallScore() - baseline.getOverallScore();
        
        // 识别退化的具体类别
        Map<String, Double> categoryDiffs = new HashMap<>();
        newModel.getScoresByCategory().forEach((category, score) -> {
            double diff = score - baseline.getScoresByCategory().getOrDefault(category, 0.0);
            categoryDiffs.put(category, diff);
        });
        
        List<String> regressionCategories = categoryDiffs.entrySet().stream()
            .filter(e -> e.getValue() < -0.05) // 下降超过5%算退化
            .map(Map.Entry::getKey)
            .collect(toList());
        
        RegressionTestResult regrResult = RegressionTestResult.builder()
            .newVersion(newModelVersion)
            .baselineVersion(baselineVersion)
            .overallImprovement(overallDiff)
            .regressionCategories(regressionCategories)
            .passRegression(regressionCategories.isEmpty() && overallDiff >= -0.02)
            .recommendation(regressionCategories.isEmpty() 
                ? "可以升级到新版本" 
                : "以下类别出现退化，升级前需要额外处理：" + regressionCategories)
            .build();
        
        // 如果退化严重，发告警
        if (!regrResult.isPassRegression()) {
            alertService.sendAlert(
                AlertLevel.WARNING,
                String.format("模型版本%s相比%s在%s方面出现退化，建议暂缓升级",
                             newModelVersion, baselineVersion, regressionCategories)
            );
        }
        
        return regrResult;
    }
}

13.2 生产环境的模型版本灰度策略

@Service
public class ModelVersionGradualRolloutService {
    
    private final Map<String, Integer> versionTrafficPercent = new HashMap<>();
    
    /**
     * 灰度发布：新版本从1%流量开始，逐步提升
     */
    public void startGradualRollout(String newVersion, String currentVersion) {
        // 初始1%流量
        versionTrafficPercent.put(newVersion, 1);
        versionTrafficPercent.put(currentVersion, 99);
        
        // 启动自动扩流任务
        scheduleTrafficIncrease(newVersion, currentVersion);
    }
    
    @Async
    private void scheduleTrafficIncrease(String newVersion, String currentVersion) {
        int[] schedule = {1, 5, 10, 25, 50, 100}; // 流量扩充计划
        long[] intervals = {3_600_000, 7_200_000, 14_400_000, 86_400_000, 
                            86_400_000, 86_400_000}; // 每步等待时间（毫秒）
        
        for (int i = 0; i < schedule.length; i++) {
            try {
                Thread.sleep(intervals[i]);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
            
            // 检查新版本在当前流量下的效果
            ModelHealthMetrics metrics = metricsService.getRecentMetrics(newVersion, 60);
            
            if (metrics.getErrorRate() > 0.05 || 
                metrics.getAvgUserSatisfaction() < baselineMetrics.getAvgUserSatisfaction() - 0.1) {
                
                // 效果不好：回滚到旧版本
                log.warn("新版本{}在{}%流量下表现不佳，自动回滚", newVersion, schedule[i]);
                versionTrafficPercent.put(newVersion, 0);
                versionTrafficPercent.put(currentVersion, 100);
                alertService.sendAlert(AlertLevel.WARNING, "模型版本" + newVersion + "已自动回滚");
                return;
            }
            
            // 效果正常：继续扩流
            versionTrafficPercent.put(newVersion, schedule[i]);
            versionTrafficPercent.put(currentVersion, 100 - schedule[i]);
            log.info("新版本{}流量提升至{}%", newVersion, schedule[i]);
        }
        
        log.info("新版本{}已完成灰度，全量切换完成", newVersion);
    }
}

十四、选型备忘清单：一张表帮你做决定

把本文所有关键决策点浓缩成一张快速参考表：

14.1 初始筛选清单

在开始任何深入评估之前，用以下问题快速排除不合适的选项：

问题如果答案是...动作
是否有严格的数据隐私要求（医疗/金融）？是优先考虑本地部署或私有化模型
主要语言是中文吗？是C-Eval < 70的模型直接排除
需要处理代码吗？是HumanEval < 50的模型排除
上下文需要超过64K tokens吗？是只看支持长上下文的模型
需要多模态（图片/语音）吗？是只看多模态模型
月均API调用超过100万次吗？是优先考虑成本，看小模型或开源模型
需要实时响应（<1秒）吗？是重点测试TTFT和TPS

14.2 最终决策矩阵

给每个候选模型在关键维度打分（1-5），加权求和：

// 决策矩阵示例
Map<String, Map<String, Double>> scoringMatrix = new LinkedHashMap<>();

// 维度和权重（根据你的业务调整权重）
Map<String, Double> weights = Map.of(
    "中文能力",    0.30,
    "任务准确率",  0.25,
    "响应速度",    0.15,
    "成本",        0.15,
    "稳定性",      0.10,
    "上下文长度",  0.05
);

// 候选模型评分（你的自定义评估集 + 主观测试）
scoringMatrix.put("Qwen2.5-72B", Map.of(
    "中文能力", 4.8, "任务准确率", 4.5, "响应速度", 3.8,
    "成本", 4.2, "稳定性", 4.0, "上下文长度", 4.5
));
scoringMatrix.put("GPT-4o", Map.of(
    "中文能力", 4.2, "任务准确率", 4.8, "响应速度", 4.0,
    "成本", 2.5, "稳定性", 4.8, "上下文长度", 4.8
));
scoringMatrix.put("DeepSeek-V3", Map.of(
    "中文能力", 4.7, "任务准确率", 4.6, "响应速度", 4.2,
    "成本", 4.8, "稳定性", 3.8, "上下文长度", 4.5
));

// 计算加权总分
scoringMatrix.forEach((model, scores) -> {
    double weightedScore = scores.entrySet().stream()
        .mapToDouble(e -> e.getValue() * weights.get(e.getKey()))
        .sum();
    System.out.printf("%-20s 加权总分: %.2f%n", model, weightedScore);
});

最终加权分最高的不一定是你选的，因为还有一些无法量化的因素（团队熟悉度、供应商关系、合规要求）。但这个矩阵给你提供了一个结构化的决策依据，而不是凭感觉拍板。

编辑此页
最近更新:
贡献者: xiaozhangge