如何测试“随机”结果？AI应用的自动化测试策略与Mock方案

2601_95249574

560人浏览 · 2026-02-23 16:30:10

2601_95249574 · 2026-02-23 16:30:10 发布

如何测试“随机”结果？AI应用的自动化测试策略与Mock方案

背景/痛点

在AI应用开发中，我们经常需要处理具有随机性的模块——例如生成式模型的输出、强化学习的策略选择、推荐系统的随机推荐等。这些模块的测试往往面临三大痛点：

不可重复性：每次运行结果不同，导致测试用例难以稳定复现
概率验证困难：如何验证一个概率为0.3的事件确实符合预期分布？
外部依赖干扰：涉及真实API调用或模型推理时，测试环境难以隔离

我曾参与开发一个智能客服对话系统，其回复模块基于Transformer模型生成文本。测试阶段发现：虽然人工测试通过率高，但自动化测试用例因随机性频繁失败，导致CI/CD流水线阻塞。更棘手的是，当模型升级后，原本通过的用例突然失效——这种"概率性回归"问题让团队疲于应对。

核心内容讲解

1. 随机性测试的核心挑战

挑战类型	具体表现	传统测试方案缺陷
结果不确定性	同一输入产生不同输出	无法使用固定断言
概率分布验证	需要统计结果是否符合预期分布	缺乏量化评估标准
随机种子控制	不同种子导致不同结果	未统一种子管理机制

2. 分层测试策略

针对AI应用的特性，我推荐采用三层测试架构：

第一层：确定性测试
- 通过固定随机种子确保结果可重复
- 验证核心逻辑的正确性
- 示例场景：模型前向传播计算

第二层：统计性测试
- 使用蒙特卡洛方法验证概率分布
- 设定统计显著性阈值
- 示例场景：推荐系统点击率分布

第三层：边界测试
- 极端输入下的行为验证
- 随机机制失效时的降级处理
- 示例场景：模型输入超出分布范围

3. Mock与Stub技术方案

对于涉及外部依赖的随机模块，可采用以下Mock策略：

确定性Mock：预设固定响应序列
概率Mock：按指定概率返回不同结果
时序Mock：模拟时间相关的随机过程

实战代码/案例

案例1：生成式文本模型的确定性测试

import unittest
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import torch
import numpy as np

class TestDeterministicGeneration(unittest.TestCase):
    def setUp(self):
        # 固定随机种子确保可重复性
        torch.manual_seed(42)
        np.random.seed(42)

        self.model = GPT2LMHeadModel.from_pretrained('gpt2')
        self.tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

    def test_generation_consistency(self):
        """验证相同输入和种子下生成结果一致"""
        input_text = "The future of AI is"
        inputs = self.tokenizer(input_text, return_tensors="pt")

        # 第一次生成
        outputs1 = self.model.generate(
            inputs.input_ids,
            max_length=20,
            do_sample=True,
            top_k=50,
            temperature=0.7
        )
        text1 = self.tokenizer.decode(outputs1[0])

        # 重置种子
        torch.manual_seed(42)
        np.random.seed(42)

        # 第二次生成
        outputs2 = self.model.generate(
            inputs.input_ids,
            max_length=20,
            do_sample=True,
            top_k=50,
            temperature=0.7
        )
        text2 = self.tokenizer.decode(outputs2[0])

        # 验证结果一致
        self.assertEqual(text1, text2, "相同种子下生成结果应一致")

案例2：推荐系统的统计性测试

from scipy import stats
import numpy as np

class TestRecommendationSystem(unittest.TestCase):
    def setUp(self):
        # 模拟推荐系统的历史数据
        self.historical_ctr = np.array([0.1, 0.15, 0.2, 0.05, 0.3])
        self.expected_distribution = [0.2, 0.2, 0.2, 0.2, 0.2]  # 均匀分布

    def test_ctr_distribution(self):
        """验证点击率是否符合预期分布"""
        # 模拟1000次推荐结果
        np.random.seed(42)
        simulated_results = []
        for _ in range(1000):
            # 按历史CTR概率选择物品
            item = np.random.choice(5, p=self.historical_ctr)
            simulated_results.append(item)

        # 卡方检验验证分布
        observed_counts = np.bincount(simulated_results, minlength=5)
        chi2, p_value = stats.chisquare(observed_counts, f_exp=np.array(self.expected_distribution)*1000)

        # 设置显著性水平α=0.05
        self.assertGreater(p_value, 0.05, 
                          f"p值={p_value:.4f} < 0.05，拒绝原假设，分布不符合预期")

案例3：基于TypeScript的随机API测试Mock

// mockRandomService.ts
export class RandomServiceMock {
    private deterministicResponses: any[] = [];
    private currentIndex = 0;

    // 设置确定性响应序列
    setResponses(responses: any[]) {
        this.deterministicResponses = responses;
        this.currentIndex = 0;
    }

    // 模拟随机选择方法
    async selectRandomOption(options: string[]): Promise<string> {
        if (this.deterministicResponses.length > 0) {
            const response = this.deterministicResponses[this.currentIndex];
            this.currentIndex = (this.currentIndex + 1) % this.deterministicResponses.length;
            return response;
        }

        // 默认随机行为
        return options[Math.floor(Math.random() * options.length)];
    }

    // 模拟概率性方法
    async triggerWithProbability(probability: number): Promise<boolean> {
        return Math.random() < probability;
    }
}

// 测试用例
import { RandomServiceMock } from './mockRandomService';

describe('RandomService Tests', () => {
    let mockService: RandomServiceMock;

    beforeEach(() => {
        mockService = new RandomServiceMock();
    });

    test('deterministic selection', async () => {
        const options = ['A', 'B', 'C'];
        mockService.setResponses(['A', 'B', 'A']);

        const result1 = await mockService.selectRandomOption(options);
        const result2 = await mockService.selectRandomOption(options);
        const result3 = await mockService.selectRandomOption(options);

        expect(result1).toBe('A');
        expect(result2).toBe('B');
        expect(result3).toBe('A');
    });

    test('probability verification', async () => {
        const trials = 1000;
        const successCount = 0;
        const expectedProbability = 0.3;

        for (let i = 0; i < trials; i++) {
            if (await mockService.triggerWithProbability(expectedProbability)) {
                successCount++;
            }
        }

        const observedProbability = successCount / trials;
        // 允许±5%的误差范围
        expect(observedProbability).toBeGreaterThan(expectedProbability - 0.05);
        expect(observedProbability).toBeLessThan(expectedProbability + 0.05);
    });
});