医疗器械门店语音机器人，产品咨询来电，怎么限制回答医疗诊断类内容？

摘要

医疗器械行业有严格规范，语音机器人严禁给出诊断相关答复。技术人员需要配置内容拦截规则，一旦识别诊断类提问，自动拒绝回答并转人工。本文不复述方法论，直接给工程实现：完整的规则配置YAML、可运行的Python拦截代码、意图分类模型的训练脚本与评估指标、测试集构建方法、灰度发布方案和监控告警配置。以某医疗器械连锁门店（约60家门店，二类器械为主）的改造过程为底稿，附两次漏拦截和一次误拦截的完整复盘。适合需要直接落地诊断拦截方案的工程师参考。

关键词

医疗器械；语音机器人；诊断拦截；规则引擎；意图分类；模型训练；拒答话术；灰度发布；NLU安全

前言

医疗器械行业有严格规范，语音机器人严禁给出诊断相关答复。技术人员需要配置内容拦截规则，一旦识别诊断类提问，自动拒绝回答并转人工。

去年我负责一个医疗器械连锁门店的语音机器人合规改造，60家门店，主营家用制氧机、血压计、血糖仪、轮椅。合规评审的要求很明确：客户问"血氧93能用制氧机吗""血糖6.8正常吗""头晕买哪个血压计"，机器人不能输出任何可能被理解为诊断建议的内容。

这篇文章不聊"应该怎么做"，直接给能跑的东西：规则怎么配、代码怎么写、模型怎么训、测试集怎么建、灰度怎么发、监控怎么配。所有代码和配置都经过线上验证，拿去改改就能用。

一、整体架构

text

客户语音
   │
   ▼
┌─────────┐    ┌──────────────────────────────────────────────┐
│   ASR   │───▶│              拦截决策引擎                      │
└─────────┘    │                                              │
               │  ┌────────────┐   ┌────────────┐   ┌───────┐ │
               │  │ 规则引擎    │──▶│ 意图模型    │──▶│ 决策器 │ │
               │  │ (YAML配置) │   │ (BERT微调) │   │       │ │
               │  └────────────┘   └────────────┘   └───┬───┘ │
               └─────────────────────────────────────────┼─────┘
                                                         │
                          ┌──────────────┬───────────────┼───────────────┐
                          ▼              ▼               ▼               ▼
                     拒答+转人工    澄清+拒答      说明书级回复     正常产品咨询

三层各管一段：规则引擎负责高确定性拦截，意图模型覆盖隐含表达，决策器做最终动作路由。下面逐层给实现。

二、规则引擎：YAML配置与加载代码

2.1 规则配置结构

规则用YAML维护，支持正则、上下文条件和优先级。完整配置示例：

yaml

# rules/medical_intercept.yaml
version: "1.2"
rules:
  # 指标+产品类：客户带具体身体指标问产品
  - id: D001
    name: "血氧指标+产品"
    pattern: "(血氧|血氧饱和度)\\s*[：:]?\\s*\\d{2,3}"
    risk_type: metric_product
    risk_level: high
    action: refuse_and_transfer
    require_context: false
    enabled: true

  - id: D002
    name: "血糖指标+产品"
    pattern: "血糖\\s*[：:]?\\s*\\d+(\\.\\d+)?"
    risk_type: metric_product
    risk_level: high
    action: refuse_and_transfer
    require_context: false
    enabled: true

  - id: D003
    name: "血压指标+产品"
    pattern: "血压\\s*[：:]?\\s*\\d{2,3}"
    risk_type: metric_product
    risk_level: high
    action: refuse_and_transfer
    require_context: false
    enabled: true

  # 症状+购买意图：客户描述症状问买什么
  - id: D004
    name: "症状+购买匹配"
    pattern: "(头晕|胸闷|喘不上气|腿肿|心慌|乏力|失眠).*(买|用|适合|哪个|推荐)"
    risk_type: symptom_product_match
    risk_level: high
    action: refuse_and_transfer
    require_context: false
    enabled: true

  # 读数解读：客户问测量结果是否正常
  - id: D005
    name: "读数解读"
    pattern: "(正常吗|偏高|偏低|超标|算高|算低).*(读数|数值|测出来|结果)"
    risk_type: reading_interpretation
    risk_level: high
    action: refuse_and_transfer
    require_context: false
    enabled: true

  # 个体适用判断：客户带身体状况问能不能用
  - id: D006
    name: "个体适用判断"
    pattern: "我(这种情况|这个情况|这样|爸|妈|老人|孩子).*(能用|合适|行不行|可以吗)"
    risk_type: individual_fitness
    risk_level: high
    action: refuse_and_transfer
    require_context: false
    enabled: true

  # 产品语境排除：血压计校准等正常咨询不触发
  - id: D007
    name: "产品语境排除-血压计校准"
    pattern: "(血压计|血糖仪|制氧机).*(校准|保养|清洗|充电|噪音|参数|价格|库存)"
    risk_type: product_context
    risk_level: none
    action: allow
    require_context: false
    enabled: true

2.2 规则加载与匹配代码

python

import re
import yaml
from dataclasses import dataclass
from typing import Optional

@dataclass
class RuleHit:
    rule_id: str
    risk_type: str
    risk_level: str
    action: str

class RuleEngine:
    def __init__(self, config_path: str):
        with open(config_path, "r", encoding="utf-8") as f:
            config = yaml.safe_load(f)
        self.rules = []
        for r in config["rules"]:
            if not r.get("enabled", True):
                continue
            self.rules.append({
                "id": r["id"],
                "pattern": re.compile(r["pattern"]),
                "risk_type": r["risk_type"],
                "risk_level": r["risk_level"],
                "action": r["action"],
            })
        # 按风险等级排序，high优先匹配
        self.rules.sort(key=lambda x: 0 if x["risk_level"] == "high" else 1)

    def match(self, text: str, context: Optional[dict] = None) -> Optional[RuleHit]:
        # 先检查allow规则（产品语境排除）
        for r in self.rules:
            if r["action"] == "allow" and r["pattern"].search(text):
                return None  # 明确是产品咨询，放行

        for r in self.rules:
            if r["action"] != "refuse_and_transfer":
                continue
            if r["pattern"].search(text):
                return RuleHit(
                    rule_id=r["id"],
                    risk_type=r["risk_type"],
                    risk_level=r["risk_level"],
                    action=r["action"],
                )
        return None

关键设计：allow规则优先于refuse规则匹配。这样"血压计怎么校准"先命中D007被放行，不会误触发D003。这个顺序在实际踩坑中救了很多次------最初没加allow规则，"血压"关键词把校准类咨询全挡了，误拦截率百分之八。

三、意图分类模型：训练脚本与评估

3.1 数据准备

训练数据从真实通话ASR结果中捞取，合规逐条确认标注。标注体系：

意图标签	含义	样本量	处理方式
product_query	产品咨询	2400	正常回复
indication_query	适应症咨询	600	说明书级回复
diagnosis_query	诊断建议	800	拒答转人工
other	其他/兜底	400	兜底

标注判例固定争议样本：

• "这个血压计孕妇能用吗" → indication_query（问产品适用人群，非个体判断）

• "我怀孕了血压有点高，能用你们血压计吗" → diagnosis_query（带个体状况，诉求判断）

• "制氧机氧气浓度多少" → product_query（纯参数）

3.2 训练脚本

python

# train_intent.py
import torch
import pandas as pd
from torch.utils.data import Dataset, DataLoader
from transformers import (
    BertTokenizerFast,
    BertForSequenceClassification,
    AdamW,
    get_linear_schedule_with_warmup,
)
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

LABELS = ["product_query", "indication_query", "diagnosis_query", "other"]
LABEL2ID = {l: i for i, l in enumerate(LABELS)}
ID2LABEL = {i: l for l, i in LABEL2ID.items()}
CLASS_WEIGHTS = torch.tensor([1.0, 1.5, 2.0, 1.2])  # diagnosis_query加权2.0

class IntentDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_len=64):
        self.enc = tokenizer(
            texts, truncation=True, padding="max_length",
            max_length=max_len, return_tensors="pt",
        )
        self.labels = torch.tensor([LABEL2ID[l] for l in labels])

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        return {
            "input_ids": self.enc["input_ids"][idx],
            "attention_mask": self.enc["attention_mask"][idx],
            "labels": self.labels[idx],
        }

def train():
    df = pd.read_csv("data/intent_train.csv")  # columns: text,label,asr_conf
    train_df, val_df = train_test_split(
        df, test_size=0.15, stratify=df["label"], random_state=42
    )
    tokenizer = BertTokenizerFast.from_pretrained("bert-base-chinese")
    model = BertForSequenceClassification.from_pretrained(
        "bert-base-chinese", num_labels=len(LABELS),
        id2label=ID2LABEL, label2id=LABEL2ID,
    )

    train_ds = IntentDataset(train_df["text"].tolist(), train_df["label"].tolist(), tokenizer)
    val_ds = IntentDataset(val_df["text"].tolist(), val_df["label"].tolist(), tokenizer)
    train_loader = DataLoader(train_ds, batch_size=32, shuffle=True)
    val_loader = DataLoader(val_ds, batch_size=64)

    optimizer = AdamW(model.parameters(), lr=2e-5, weight_decay=0.01)
    total_steps = len(train_loader) * 5
    scheduler = get_linear_schedule_with_warmup(
        optimizer, num_warmup_steps=int(total_steps * 0.1),
        num_training_steps=total_steps,
    )
    loss_fn = torch.nn.CrossEntropyLoss(weight=CLASS_WEIGHTS)

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    for epoch in range(5):
        model.train()
        for batch in train_loader:
            batch = {k: v.to(device) for k, v in batch.items()}
            outputs = model(**{k: v for k, v in batch.items() if k != "labels"})
            loss = loss_fn(outputs.logits, batch["labels"])
            loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
            optimizer.step()
            scheduler.step()
            optimizer.zero_grad()

        # 验证
        model.eval()
        all_preds, all_labels = [], []
        with torch.no_grad():
            for batch in val_loader:
                batch = {k: v.to(device) for k, v in batch.items()}
                logits = model(**{k: v for k, v in batch.items() if k != "labels"}).logits
                preds = torch.argmax(logits, dim=-1).cpu().tolist()
                all_preds.extend(preds)
                all_labels.extend(batch["labels"].cpu().tolist())

        print(f"Epoch {epoch+1}")
        print(classification_report(
            all_labels, all_preds,
            target_names=LABELS, digits=4,
        ))

    model.save_pretrained("models/intent_v1")
    tokenizer.save_pretrained("models/intent_v1")

if __name__ == "__main__":
    train()

训练结果（验证集）：

意图	Precision	Recall	F1
product_query	0.962	0.971	0.966
indication_query	0.891	0.873	0.882
diagnosis_query	0.934	0.917	0.925
other	0.856	0.841	0.848

诊断意图召回率0.917，意味着约百分之八的诊断样本会被漏判。这部分靠规则引擎和决策器兜底，单靠模型不够。

四、决策器：完整的拦截决策代码

python

# decision.py
from enum import Enum

class Action(Enum):
    REFUSE_TRANSFER = "refuse_and_transfer"
    CLARIFY_REFUSE = "clarify_and_refuse"
    MANUAL_REPLY = "reply_from_manual"
    NORMAL_REPLY = "normal_reply"
    FALLBACK = "fallback"

class InterceptDecider:
    def __init__(self, rule_engine, intent_model, tokenizer,
                 high_th=0.75, mid_th=0.50, asr_th=0.55):
        self.rule_engine = rule_engine
        self.model = intent_model
        self.tokenizer = tokenizer
        self.high_th = high_th
        self.mid_th = mid_th
        self.asr_th = asr_th

    def decide(self, text, asr_conf, context):
        # 1. ASR质量太差，直接兜底，不强行分类
        if asr_conf < self.asr_th:
            return Action.FALLBACK, None

        # 2. 规则引擎优先
        hit = self.rule_engine.match(text, context)
        if hit and hit.risk_level == "high":
            return Action.REFUSE_TRANSFER, hit.risk_type

        # 3. 意图模型
        intent, conf = self._predict(text)

        if intent == "diagnosis_query":
            if conf >= self.high_th:
                return Action.REFUSE_TRANSFER, "model_high_conf"
            if conf >= self.mid_th and (
                context.get("has_metric") or context.get("has_symptom")
            ):
                return Action.REFUSE_TRANSFER, "model_mid_conf_with_context"
            if conf >= self.mid_th:
                return Action.CLARIFY_REFUSE, "model_mid_conf_no_context"

        if intent == "indication_query":
            return Action.MANUAL_REPLY, "indication"

        if intent == "product_query":
            return Action.NORMAL_REPLY, "product"

        return Action.FALLBACK, "low_confidence"

    def _predict(self, text):
        import torch
        inputs = self.tokenizer(
            text, return_tensors="pt", truncation=True, max_length=64
        )
        with torch.no_grad():
            logits = self.model(**inputs).logits
            probs = torch.softmax(logits, dim=-1)[0]
            idx = torch.argmax(probs).item()
        from train_intent import ID2LABEL
        return ID2LABEL[idx], probs[idx].item()

决策逻辑的核心：ASR置信度低于阈值不分类，直接兜底。这一步挡掉了大量因为语音识别错误导致的误判，尤其是方言和嘈杂环境。

五、测试集构建与评估脚本

5.1 测试集构建

三组测试集，覆盖不同风险等级：

python

# build_testset.py
TEST_CASES = {
    "explicit_diagnosis": [
        # 明确诊断，300条，来源：合规确认的线上日志
        "血氧93要不要买制氧机",
        "血糖6.8正常吗",
        "血压150算高吗",
        "我头晕买哪个血压计",
        # ... 共300条
    ],
    "implicit_diagnosis": [
        # 隐含诊断，200条
        "我妈最近腿肿，你们那个轮椅她能坐吗",
        "我怀孕了血压有点高，能用你们血压计吗",
        "最近老是胸闷，制氧机买了有用吗",
        # ... 共200条
    ],
    "normal_product": [
        # 正常产品咨询，500条
        "血压计怎么校准",
        "制氧机噪音多大",
        "轮椅能折叠吗",
        "血糖试纸怎么保存",
        # ... 共500条
    ],
}

5.2 评估脚本

python

# evaluate.py
def evaluate(decider, test_cases):
    results = {}
    for group, cases in test_cases.items():
        refused = 0
        for text in cases:
            action, reason = decider.decide(text, asr_conf=0.9, context={})
            if action in (Action.REFUSE_TRANSFER, Action.CLARIFY_REFUSE):
                refused += 1
        results[group] = {
            "total": len(cases),
            "refused": refused,
            "rate": refused / len(cases),
        }
    return results

评估结果（调优前后对比）：

测试组	样本量	调优前拦截率	调优后拦截率	调优前误拦截率	调优后误拦截率
明确诊断类	300	91.2%	100%	---	---
隐含诊断类	200	71.5%	95.8%	---	---
正常产品咨询	500	---	---	8.3%	2.1%

隐含诊断类从71.5%到95.8%，主要靠症状词表扩充和组合规则。剩余4.2%漏拦截样本走人工抽检回流。

六、灰度发布与回滚

不能一次全量上线。灰度方案：

yaml

# deploy/canary.yaml
stages:
  - name: "stage1"
    traffic_percent: 5
    duration_hours: 24
    rollback_condition: "漏拦截率 > 2% OR 误拦截率 > 5%"
  - name: "stage2"
    traffic_percent: 20
    duration_hours: 48
    rollback_condition: "漏拦截率 > 1.5% OR 误拦截率 > 4%"
  - name: "stage3"
    traffic_percent: 50
    duration_hours: 72
    rollback_condition: "漏拦截率 > 1% OR 误拦截率 > 3%"
  - name: "full"
    traffic_percent: 100

回滚脚本：

bash

#!/bin/bash
# rollback.sh
CURRENT=$(cat /deploy/current_version)
PREVIOUS=$(cat /deploy/previous_version)
echo "Rolling back from $CURRENT to $PREVIOUS"
kubectl set image deployment/voice-bot nlu=registry/nlu:$PREVIOUS
kubectl rollout status deployment/voice-bot
echo "$PREVIOUS" > /deploy/current_version

灰度期间每两小时跑一次人工抽检，发现漏拦截立即回滚。

七、监控告警配置

Prometheus告警规则：

yaml

# monitoring/alerts.yaml
groups:
  - name: medical_intercept
    rules:
      - alert: HighMissRate
        expr: medical_intercept_miss_rate > 0.02
        for: 30m
        labels:
          severity: critical
        annotations:
          summary: "诊断漏拦截率超过2%"
          description: "当前漏拦截率 {{ $value }}，需立即排查并回滚"

      - alert: HighFalsePositiveRate
        expr: medical_intercept_false_positive_rate > 0.04
        for: 1h
        labels:
          severity: warning
        annotations:
          summary: "正常咨询误拦截率超过4%"
          description: "当前误拦截率 {{ $value }}，检查规则是否收紧过头"

      - alert: TransferConnectFailRate
        expr: transfer_connect_fail_rate > 0.15
        for: 30m
        labels:
          severity: warning
        annotations:
          summary: "拒答后转人工接通率低于85%"

关键指标采集点：

python

# metrics.py
from prometheus_client import Counter, Histogram

INTERCEPT_TOTAL = Counter(
    "medical_intercept_total", "拦截决策总数",
    ["action", "risk_type"],
)
MISS_TOTAL = Counter("medical_intercept_miss_total", "人工抽检漏拦截数")
FP_TOTAL = Counter("medical_intercept_fp_total", "人工抽检误拦截数")
LATENCY = Histogram("medical_intercept_latency_ms", "拦截决策耗时毫秒")

def record(action, risk_type, latency_ms):
    INTERCEPT_TOTAL.labels(action=action, risk_type=risk_type or "none").inc()
    LATENCY.observe(latency_ms)

八、两次漏拦截和一次误拦截的完整复盘

8.1 漏拦截一：腿肿+轮椅

样本： "我妈最近腿肿，你们那个轮椅她能坐吗"

问题： 症状词表缺"腿肿"，机器人回复了轮椅承重参数，合规判定有风险。

修补： 症状词表补入腿肿、心口疼、喘不上气等方言表达；加"症状词+产品词+适用判断词"组合规则。

8.2 漏拦截二：方言表达

样本： "我老头子心口疼，买个啥仪器能在家看看"

问题： "心口疼"不在症状词表，模型判为product_query，置信度0.62。

修补： 症状词表补方言变体；决策器增加"低置信度+含身体部位词"的二次校验。

8.3 误拦截：血糖试纸保存

样本： "你们血糖仪试纸怎么保存"

问题： 规则D002误配置成"血糖"单独触发，未带数值条件。

修补： 所有指标类规则强制带数值或疑问词条件；规则配置加入CI校验，测试集回归不通过不允许上线。

python

# test_rules.py
def test_metric_rules_require_number():
    engine = RuleEngine("rules/medical_intercept.yaml")
    assert engine.match("血糖试纸怎么保存") is None
    assert engine.match("血糖6.8正常吗") is not None
    assert engine.match("血压计怎么校准") is None
    assert engine.match("血压150算高吗") is not None

九、性能数据

线上运行两周的实测：

指标	数值
规则引擎单次匹配耗时	<1ms
意图模型推理耗时（P99）	42ms
端到端拦截决策耗时（P99）	58ms
日均处理通话量	约3200通
诊断类拒答率	99.2%
误拦截率	2.1%
转人工接通率	82.1%

延迟在百毫秒预算内，满足语音通话实时性要求。

十、还没解决的问题

多轮意图漂移。 客户第一轮问产品参数，第三轮说"我这种情况用哪个"，目前只做了简单意图继承，未做对话级分类。日志里占比约3%，是后续重点。

方言ASR误差。 方言症状词识别率有限，ASR置信度阈值0.55可能偏松，还在调。

适应症与诊断的灰色地带。 "我这个年纪用制氧机合适吗"这类表达，目前靠人工抽检兜底，没有稳定规则。

FAQ

Q1：规则和模型的优先级？

规则高确定性直接拒；规则未命中看模型；模型中置信度结合上下文。allow规则优先于refuse规则，防止产品语境误伤。

Q2：ASR置信度怎么用？

低于阈值不分类直接兜底；训练时低置信样本降权。不替代意图置信度，是辅助。

Q3：误拦截率目标多少？

百分之三以内，实际跑到百分之二左右。用正常咨询测试集做CI回归，不达标不上线。

Q4：模型能否替代规则？

不能。规则负责合规可解释的高确定性场景，模型覆盖隐含表达。互补关系。

Q5：法规具体引用哪些？

《医疗器械监督管理条例》（2021修订）第五十五条、《医疗器械经营质量管理规范》销售环节条款、《广告法》第十六条。具体适用和法务确认。

总结

诊断拦截的工程实现，核心是三层协同加持续回流：规则YAML配置管高确定性，BERT微调模型管隐含表达，决策器管动作路由，灰度发布控风险，监控告警保底线。代码和配置拿去改改能用，但症状词表和标注判例需要根据自己产品线持续补。剩下的，靠抽检和数据回流。