自动化测试在医疗AI中的实践：Baichuan-M2-32B的pytest框架集成

医疗AI模型在实际应用中，诊断的准确性、响应的及时性以及面对异常情况的处理能力，直接关系到其能否真正为医疗健康领域带来价值。想象一下，一个用于辅助诊断的模型，如果回答模棱两可，或者响应速度慢如蜗牛，甚至遇到稍微复杂一点的病例就直接“罢工”，这样的工具谁敢用？

今天，我们就来聊聊如何为像Baichuan-M2-32B这样的顶尖医疗大模型，构建一套扎实的自动化测试体系。这套体系不是简单的“跑通就行”，而是要像一位严格的“主治医师”一样，从诊断准确性、响应延迟到异常处理，全方位地评估模型的质量，并把它无缝集成到持续集成（CI）流程中，确保每一次模型更新或部署，质量都有保障。

1. 为什么医疗AI模型需要专门的自动化测试？

你可能觉得，大模型调用一下，看看输出结果不就行了？但对于医疗场景，这远远不够。医疗AI的测试，核心是建立信任。

首先，准确性就是生命线。一个关于药物剂量的回答，小数点错一位都可能带来严重后果。我们不能只靠人工抽查几个案例，必须系统性地验证模型在大量、多样化的医学问题上的表现。

其次，响应速度影响体验和效率。在临床辅助决策或在线健康咨询场景中，医生或用户等待时间过长，工具的实用性就大打折扣。我们需要量化模型的响应延迟，并设定明确的性能基线。

再者，鲁棒性决定可用性边界。模型会不会被奇怪的输入“带偏”？遇到它知识范围外的问题，是坦诚告知还是胡言乱语？这些异常情况的处理能力，需要通过测试来探查和加固。

最后，回归测试保障持续迭代。模型会更新，底层的推理框架（如vLLM、SGLang）会升级，部署环境会变化。没有自动化测试，我们无法快速、自信地确认这些变更没有引入“暗病”。

而pytest，作为Python生态中最强大、最灵活的测试框架之一，正是构建这套体系的上佳之选。它插件丰富、断言清晰、夹具（fixture）机制灵活，能很好地组织我们对模型API发起的各种“考验”。

2. 搭建测试骨架：模型服务与pytest基础配置

测试的前提，是要有一个正在运行、可供调用的模型服务。Baichuan-M2-32B通常通过vLLM或SGLang部署为OpenAI兼容的API服务。我们的测试将针对这个API端点进行。

首先，我们来规划测试项目的结构，并准备好核心的测试工具。

medical_ai_model_tests/
├── conftest.py           # pytest共享配置和夹具
├── requirements.txt      # 项目依赖
├── tests/                # 测试用例目录
│   ├── __init__.py
│   ├── test_accuracy.py # 诊断准确性测试
│   ├── test_latency.py  # 响应延迟测试
│   └── test_robustness.py # 异常处理测试
└── utils/               # 工具函数
    ├── __init__.py
    ├── client.py        # 模型API客户端封装
    └── evaluators.py    # 评分逻辑

接下来是requirements.txt，列出我们需要的包：

pytest>=7.0.0
requests>=2.28.0
openai>=1.0.0  # 用于兼容OpenAI API的调用
pytest-benchmark>=4.0.0  # 性能基准测试插件
pytest-html>=3.0.0       # 生成HTML测试报告
python-dotenv>=0.19.0    # 管理环境变量

测试的入口，是conftest.py。这里我们会定义一些全局的、可重用的组件，比如模型API客户端。

# conftest.py
import pytest
import os
from openai import OpenAI
from dotenv import load_dotenv

# 加载环境变量，用于配置API地址和密钥
load_dotenv()

@pytest.fixture(scope="session")
def model_client():
    """
    创建一个全局的OpenAI兼容客户端夹具。
    作用域为session，意味着所有测试用例共享同一个客户端实例。
    """
    base_url = os.getenv("MODEL_API_BASE_URL", "http://localhost:8000/v1")
    api_key = os.getenv("MODEL_API_KEY", "not-needed")  # 本地部署可能不需要key

    client = OpenAI(
        base_url=base_url,
        api_key=api_key,
        timeout=30.0  # 默认超时时间
    )
    return client

@pytest.fixture(scope="session")
def model_name():
    """返回被测试的模型名称。"""
    return os.getenv("MODEL_NAME", "Baichuan-M2-32B")

通过环境变量来配置连接信息，使得我们的测试套件可以灵活地在不同环境（开发、测试、生产）中运行。现在，测试的骨架已经搭好，我们可以开始编写具体的“考题”了。

3. 第一道关卡：诊断准确性测试

这是医疗AI测试的重中之重。我们的目标不是穷举所有医学知识，而是设计一套有代表性的测试集，覆盖常见症状、鉴别诊断、用药咨询等核心场景。

我们准备一个简单的测试集文件（比如JSON格式），并在测试中读取它。

# tests/test_accuracy.py
import pytest
import json
from pathlib import Path

# 加载测试用例
TEST_CASES_PATH = Path(__file__).parent / "data" / "medical_qa_cases.json"
with open(TEST_CASES_PATH, 'r', encoding='utf-8') as f:
    ACCURACY_TEST_CASES = json.load(f)

class TestDiagnosticAccuracy:
    """诊断准确性测试套件"""

    @pytest.mark.parametrize("test_case", ACCURACY_TEST_CASES)
    def test_medical_qa_accuracy(self, model_client, model_name, test_case):
        """
        参数化测试：遍历测试用例集中的每一个问题，验证模型回答的关键信息。
        """
        question = test_case["question"]
        expected_keywords = test_case.get("expected_keywords", [])
        must_not_contain = test_case.get("must_not_contain", [])

        # 调用模型
        response = model_client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": question}],
            max_tokens=500,
            temperature=0.1  # 低温度，使输出更确定，便于测试
        )

        answer = response.choices[0].message.content

        # 断言1: 回答不应包含危险或绝对化的错误信息
        for forbidden in must_not_contain:
            assert forbidden not in answer, f"回答中不应包含 '{forbidden}'"

        # 断言2: 回答应包含预期的关键医学术语或概念（非精确匹配，是包含关系）
        # 这是一个相对宽松的检查，更严格的检查可能需要NLP模型或规则引擎。
        if expected_keywords:
            found_keywords = [kw for kw in expected_keywords if kw in answer]
            assert len(found_keywords) > 0, (
                f"回答中未找到任何预期关键词。问题：{question}\n"
                f"预期关键词：{expected_keywords}\n"
                f"实际回答：{answer[:200]}..."
            )
            # 可以记录匹配到的关键词比例，用于生成详细报告
            print(f"问题：{question[:50]}... -> 匹配关键词：{found_keywords}")

    def test_differential_diagnosis_scenario(self, model_client, model_name):
        """测试鉴别诊断场景：模型应能列出多种可能性，而非武断结论。"""
        scenario = "一位45岁男性，主诉持续上腹痛伴反酸、烧心2个月。可能的诊断有哪些？"
        response = model_client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": scenario}],
            max_tokens=600,
        )
        answer = response.choices[0].message.content.lower()

        # 检查回答是否表现出鉴别诊断的思维
        # 例如，包含“可能”、“需要考虑”、“鉴别”等词语，并列出多于一种疾病。
        assert any(word in answer for word in ["可能", "考虑", "鉴别", "或", "以及"])
        # 简单检查是否提到了至少两种常见的相关疾病
        common_conditions = ["胃炎", "胃溃疡", "反流性食管炎", "胆囊炎"]
        mentioned = [cond for cond in common_conditions if cond in answer]
        assert len(mentioned) >= 2, f"鉴别诊断应提及多种可能，实际提到：{mentioned}"

这里的测试用例集medical_qa_cases.json需要你根据实际需求精心设计，可以包含简单的事实问答、症状分析、用药安全提醒等。断言条件可以根据测试的严格程度调整，从关键词匹配到使用更复杂的医学自然语言推理（NLI）模型进行打分。

4. 第二道关卡：响应延迟与性能测试

用户和医生无法忍受长时间的等待。我们需要确保模型服务在预期的负载下，响应时间保持在可接受的范围内。pytest-benchmark插件非常适合做这件事。

# tests/test_latency.py
import pytest
import statistics

class TestResponseLatency:
    """响应延迟测试套件"""

    @pytest.mark.benchmark(group="simple_qa_latency", warmup=True)
    def test_single_turn_latency(self, model_client, model_name, benchmark):
        """基准测试：测量单轮简单问答的响应时间。"""
        question = "感冒了应该多喝水吗？"

        def query_model():
            # benchmark会多次运行此函数，计算耗时
            resp = model_client.chat.completions.create(
                model=model_name,
                messages=[{"role": "user", "content": question}],
                max_tokens=100,
                temperature=0.0
            )
            return resp

        response = benchmark(query_model)
        # benchmark对象会自动记录并输出统计信息（平均、中位数、标准差等）
        # 我们可以添加自定义断言，例如要求P95延迟小于3秒
        # 注意：benchmark.stats 存储了详细数据
        assert benchmark.stats['mean'] < 3.0, f"平均响应时间{benchmark.stats['mean']:.2f}秒超过3秒阈值"

    def test_concurrent_latency(self, model_client, model_name):
        """
        测试轻度并发下的延迟表现（模拟多个用户同时咨询）。
        使用简单的多线程来模拟。
        """
        import concurrent.futures
        import time

        question = "请解释一下高血压的定义。"
        num_requests = 5
        latencies = []

        def single_request(_):
            start = time.perf_counter()
            model_client.chat.completions.create(
                model=model_name,
                messages=[{"role": "user", "content": question}],
                max_tokens=150,
                temperature=0.0
            )
            end = time.perf_counter()
            return end - start

        with concurrent.futures.ThreadPoolExecutor(max_workers=num_requests) as executor:
            futures = [executor.submit(single_request, i) for i in range(num_requests)]
            for future in concurrent.futures.as_completed(futures):
                latencies.append(future.result())

        avg_latency = statistics.mean(latencies)
        p95_latency = sorted(latencies)[int(0.95 * len(latencies))]

        print(f"轻度并发({num_requests}请求) - 平均延迟: {avg_latency:.2f}s, P95延迟: {p95_latency:.2f}s")
        # 断言：在轻度并发下，P95延迟不应显著高于单请求延迟（例如不超过2倍）
        # 这里需要根据基线单请求延迟来设定，可以先记录基线，或使用一个经验值。
        assert p95_latency < 5.0, f"并发P95延迟{p95_latency:.2f}秒过高"

性能测试的关键是建立基线。首次运行测试时，记录下各项延迟指标的平均值和分布。后续的测试运行，就可以与之对比，监控是否有性能退化。pytest-benchmark生成的报告非常详细，能帮你一眼看出变化。

5. 第三道关卡：异常处理与鲁棒性测试

一个好的医疗AI，不仅要答得对，还要“扛得住”。我们要测试它在面对各种“刁难”时的表现。

# tests/test_robustness.py
import pytest

class TestRobustnessAndEdgeCases:
    """异常处理与边界情况测试套件"""

    def test_handling_unknown_query(self, model_client, model_name):
        """测试模型如何处理其知识范围之外的问题。"""
        # 可以是一个荒谬的或非常专业冷门的问题
        query = "请根据紫微斗数推算我明天是否适合进行心脏搭桥手术？"
        response = model_client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": query}],
            max_tokens=200,
        )
        answer = response.choices[0].message.content

        # 理想的回答应该表明其局限性，而不是胡编乱造。
        # 检查是否包含表明不确定、无法回答或建议咨询专业人士的表述。
        safe_indications = ["无法", "不建议", "咨询医生", "专业医疗", "不提供", "仅供参考"]
        assert any(indication in answer for indication in safe_indications), (
            f"对于知识外问题，回答应体现谨慎。实际回答：{answer[:150]}..."
        )

    def test_resilience_to_noise(self, model_client, model_name):
        """测试模型对输入中无关噪音的鲁棒性。"""
        # 在正常问题中插入无关字符、重复词等
        noisy_question = "我头疼！！！！！！！！！并且有点发烧。。。大概38度左右吧，，，请问怎么办？？？？？？？？"
        response = model_client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": noisy_question}],
            max_tokens=300,
        )
        answer = response.choices[0].message.content
        # 核心断言：尽管输入有噪音，模型仍应提取出“头痛”、“发烧”、“38度”等关键信息并给出相关建议。
        # 我们可以检查回答中是否包含针对这些症状的合理关键词。
        assert any(symptom in answer for symptom in ["头痛", "发烧", "体温"]), (
            "模型未能从噪音输入中识别核心症状。"
        )

    @pytest.mark.parametrize("empty_input", ["", "   ", "\n\n"])
    def test_handling_empty_input(self, model_client, model_name, empty_input):
        """测试模型如何处理空输入或空白输入。"""
        # 预期行为：模型应返回一个提示用户输入有效问题的回复，而不是崩溃或输出无意义内容。
        response = model_client.chat.completions.create(
            model=model_name,
            messages=[{"role": "user", "content": empty_input}],
            max_tokens=100,
        )
        answer = response.choices[0].message.content
        # 不应是空字符串或极短的乱码
        assert len(answer.strip()) > 10, "对空输入的回答过短或无意义。"
        # 回答语气应该是中性的提示，而非一个具体的医疗建议。
        assert "?" in answer or "请" in answer or "输入" in answer, (
            "对空输入的回答应包含提示性语言。"
        )

鲁棒性测试能暴露出模型服务在真实世界可能遇到的边缘情况，帮助我们提前加固，避免线上事故。

6. 集成到CI/CD：让测试自动运行

写好的测试，只有自动运行起来才有价值。我们可以用GitHub Actions、GitLab CI等工具，在每次代码推送或模型更新时触发测试。

下面是一个GitHub Actions工作流的示例：

# .github/workflows/model-test.yml
name: Medical Model Quality Gate

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
  schedule:
    - cron: '0 2 * * *'  # 每天凌晨2点运行一次，用于监控每日性能

jobs:
  test:
    runs-on: ubuntu-latest
    # 如果需要GPU测试，可以指定 runs-on: [self-hosted, gpu]
    env:
      MODEL_API_BASE_URL: ${{ secrets.MODEL_API_BASE_URL }}
      MODEL_API_KEY: ${{ secrets.MODEL_API_KEY }}
      MODEL_NAME: Baichuan-M2-32B

    steps:
    - uses: actions/checkout@v3

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.10'

    - name: Install dependencies
      run: |
        pip install -r requirements.txt

    - name: Run accuracy and robustness tests
      run: |
        pytest tests/test_accuracy.py tests/test_robustness.py -v --html=report.html --self-contained-html
      # 如果测试失败，工作流会停止

    - name: Run latency benchmarks
      run: |
        pytest tests/test_latency.py -v --benchmark-json=benchmark.json
      # 性能测试可能允许有较小波动，不一定导致CI失败，但会生成报告

    - name: Upload test report
      if: always()  # 即使测试失败也上传报告
      uses: actions/upload-artifact@v3
      with:
        name: test-reports
        path: |
          report.html
          benchmark.json

这样，每次提交都会触发完整的测试流水线。测试报告和性能基准数据会被保存下来，方便对比历史记录，清晰看到模型服务的质量变化趋势。

7. 总结与展望

为Baichuan-M2-32B这类医疗大模型构建基于pytest的自动化测试体系，就像给一位高明的医生配备了一套完整的体检设备。它不能替代医生的专业判断（即模型本身的能力），但能持续、客观地监控这位“医生”的身体状况和业务水平，确保其始终处于可信任、可用的状态。

这套体系的价值，会随着时间推移越来越明显。当你要评估模型新版本的效果时，当底层推理引擎升级时，当部署环境调整时，一键运行的测试套件能给你最快的反馈和最强的信心。它把模型质量的保障，从一种依赖个人经验的“艺术”，变成了可重复、可度量的“工程”。

当然，本文展示的只是一个起点。真实的医疗AI测试可能会更复杂，比如需要构建覆盖更广、标注更精细的测试数据集，集成专业的医学知识图谱进行更深入的答案验证，或者模拟更复杂的多轮对话场景。但无论如何，从搭建一个结构清晰、覆盖核心维度的pytest测试套件开始，无疑是迈向高质量、高可靠医疗AI应用最踏实的一步。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。