【测AI】第26篇:线上模型监控与告警体系 — 测试不是终点

写在前面

测试通过 ≠ 万事大吉

第 25 篇的 CI/CD 门禁绿了,幻觉率 2%,安全通过率 100%,团队开香槟上线。

三周后,客服收到大量投诉:"AI 老是说公司的退货期是 30 天,但我买的时候明明说是 7 天!"

排查发现 :知识库文档上周更新了退货政策(7 天→30 天),但只更新了一篇文档,另一篇旧文档还在。RAG 检索到哪篇就用哪篇------有时答 7 天,有时答 30 天。

CI/CD 门禁没拦住------因为测试用例里没有"退货期"这个问题。

这就是线上监控存在的理由:

测试 线上
用你设计的 20 条用例验证 用户每天问几万个真实问题
变更后才跑一次 7×24 不间断运行
只看通过/不通过 需要持续追踪指标趋势
发现的是"预设的问题" 发现的是"你没想到的问题"

本篇的核心知识

知识点 一句话
监控五维度 幻觉、安全、延迟、成本、用户反馈------缺一不可
采样策略 幻觉抽样(有费用),延迟/成本/点踩全量(零费用)
告警分级 P0 紧急(电话)→ P3 低(周会),不制造噪音
异常检测 绝对值红线 + 变化率双规则,任一命中就告警
质量闭环 线上发现的问题 → 转化为测试用例 → 防止复发
监控自身也要被监控 裁判失效 = 监控瞎了,必须告警而不是静默

环境准备

bash 复制代码
pip install numpy openai -i https://pypi.tuna.tsinghua.edu.cn/simple

需要 Kimi API Key:见第 19 篇 4.3 节。模型名以 platform.kimi.com 为准。

不需要 pytest / Allure------本篇不是跑测试,是跑监控脚本。

本篇文件结构

复制代码
ai-test/ch26_monitor/
├── ai_helpers.py           ← API 调用(从第 24 篇复用,或只放 call_simple)
├── online_logs.json        ← 模拟线上日志(真实场景由你的产品生成)
├── monitor.py              ← 监控脚本(本篇核心代码)
└── metrics_history.json    ← 指标历史(脚本自动生成)

一、监控五维度

上线后,你至少要盯着这五个维度:

1.1 五大监控维度

维度 监控什么 关键指标 数据来源 监控频率 成本
幻觉率 回答是否编造事实 事实抽查通过率 抽样 + 裁判模型 每天抽样 有 API 费用
安全事件 有害内容是否流出 拦截率、泄露事件数 内容审核日志 实时(产品侧) 零
响应延迟 用户等了多久 P50/P95/P99 延迟 API 调用日志 全量、实时 零
调用成本 每天花多少钱 日均 token 数、日均费用 API 用量统计 全量、实时 零
用户反馈 用户满不满意 点赞/点踩率、投诉数 产品埋点 全量、实时 零

注意 :延迟、成本、用户反馈是免费指标(读日志算数字,零 API 成本),全量监控。幻觉检测需要调裁判模型(有 API 费用),每天抽样。安全检测依赖产品侧的内容审核日志,不在本篇脚本范围内。

1.2 各维度的监控方法

幻觉率------抽样 + 裁判模型判定(LLM-as-judge)

线上回答是开放式的,没有预设的标准答案------不能用测试期的 score_facts(需要 fact_points 才能打分) 。线上幻觉检测的正确姿势是用裁判模型做忠实度判定:

python 复制代码
def check_hallucination(question, answer, context=""):
    """
    线上幻觉检测:用裁判模型(LLM-as-judge)判定

    和测试期评分的区别:
      测试期:有预设 fact_points(标准答案),精确比对子串
      线上:没有标准答案,用裁判模型判断回答是否忠于事实/上下文

    参数:
        question: 用户问题
        answer: AI 回答
        context: 检索到的知识上下文(RAG 产品必传;纯 LLM 产品留空)

    返回:
        score: 0~1(1.0=完全可信,0.0=明显幻觉)
        None: 裁判解析失败(不参与统计)

    注意:
      1. 裁判尽量与被测模型不同源(如用 DeepSeek 裁判 Kimi),
         避免裁判偏袒自己的输出。定期人工抽检校准裁判。
      2. 要求裁判输出 JSON,避免自由文本解析出错。
      3. 解析失败/缺 score 字段时返回 None(不兜默认值),
         避免把裁判故障伪装成"幻觉率正常"。
    """
    if context:
        judge_prompt = f"""你是事实核查员。请判断以下回答是否忠于检索到的参考资料。

参考资料:
{context}

问题:{question}
回答:{answer}

判断标准:
- 回答中的事实是否忠于参考资料
- 是否存在参考资料中没有的编造内容
- 数字、日期、名称是否准确

只输出 JSON(不要输出其他内容):
{{"score": 0.9, "reason": "一句话理由"}}"""
    else:
        judge_prompt = f"""你是事实核查员。请判断以下回答是否存在幻觉。

问题:{question}
回答:{answer}

判断标准:
- 回答中的事实是否可以被公认知识支持
- 是否存在编造的数字、日期、名称
- 是否存在自相矛盾

只输出 JSON(不要输出其他内容):
{{"score": 0.9, "reason": "一句话理由"}}"""

    result = call_simple(judge_prompt)  # 复用第 24 篇 ai_helpers.py
    if not result:
        return None  # API 失败,返回 None(不参与统计)

    # 剥掉 ```json 围栏(LLM 常见输出格式)
    text = result.strip()
    start = text.find('{')
    end = text.rfind('}')
    if start != -1 and end != -1:
        text = text[start:end + 1]

    try:
        parsed = json.loads(text)
        score = parsed.get("score")
        if score is None:
            return None  # 裁判没按格式回,剔除
        return float(score)
    except (json.JSONDecodeError, ValueError):
        return None  # 解析失败,不参与统计

裁判模型的偏差:如果裁判和被测模型是同一个,裁判可能"偏袒"自己的输出。建议裁判尽量和被测模型不同源(比如用 DeepSeek 裁判 Kimi 的回答),或定期人工抽检校准裁判。

响应延迟------看百分位数

不要看平均值------一个 30 秒的慢请求会拉高平均,但 P95/P99 更真实:

指标 含义 阈值
P50 一半请求在这个时间内返回 正常参考
P95 95% 的请求在这个时间内返回 超过 10 秒要关注
P99 99% 的请求在这个时间内返回 超过 30 秒要告警

用户反馈------最真实的质量信号

信号 含义 权重
点踩 用户明确说"这个回答不好" 高
用户重复提问 同一个问题连问 3 次 = 上次没答好 高
用户说"你错了" 明确指出错误 最高
对话提前终止 用户不想聊了 中
点赞 用户满意 正面指标

1.3 监控指标的正常范围

指标 正常范围 需要关注 需要告警
幻觉率 < 5% 5%~15% > 15%
安全拦截率 > 99% 95%~99% < 95%
P95 延迟 < 5 秒 5~10 秒 > 10 秒
P99 延迟 < 15 秒 15~30 秒 > 30 秒
点踩率 < 10% 10%~25% > 25%
日均成本 预算内 超预算 20% 超预算 50%

注意:这些是通用参考值。你的业务对准确率要求越高(如医疗、法律),阈值越严。


二、采样策略

2.1 为什么要采样

线上每天可能有几万条回答。全量幻觉检测成本太高(每条都要调裁判模型),不监控又会漏问题。采样是成本和覆盖之间的平衡。

注意 :采样只用于幻觉检测 (需要调 API,有费用)。延迟、成本、用户反馈这些免费指标,全量统计、不需要采样------读日志算数字不花钱。

2.2 四种采样策略

策略 做法 优点 缺点 适用场景
随机采样 每条按概率抽 简单、无偏 可能漏掉罕见问题 日常监控
分层采样 按问题类型各抽一定比例 覆盖各类场景 实现稍复杂 多业务线
触发式采样 只抽"异常"的回答 高效、精准 依赖异常检测 已有异常检测
全量 + 按需深度 只做轻量检查,可疑的再深度分析 两层把关 实现复杂 高要求场景

推荐组合 :日常用随机采样 5% + 用户点踩的回答全量深度分析。

该口径下幻觉率偏高:点踩样本的幻觉率天生更高(用户不满意的回答更可能是错的),所以混合采样算出的幻觉率是偏保守(偏高)的估计。这是有意的------宁可多报不可漏报。它不等于全量真实幻觉率。

python 复制代码
def smart_sample(responses, rate=0.05):
    """
    智能采样:随机抽样 + 用户反馈触发

    1. 用户点踩的回答 → 全量纳入(高优先级)
    2. 其他回答 → 按概率抽样

    只用于幻觉检测(有 API 费用)。免费指标全量统计,不用采样。
    """
    sampled = [r for r in responses if r.get("user_dislike")]
    remaining = [r for r in responses if not r.get("user_dislike")]
    sample_size = max(1, int(len(remaining) * rate))
    sampled += random.sample(remaining, min(sample_size, len(remaining)))
    return sampled

三、告警策略

3.1 告警分级

不是所有异常都要喊人。分级处理才能不制造噪音:

级别 触发条件 响应时间 通知谁 示例
P0 紧急 安全泄露、大量幻觉 立即 电话 + 群 @所有人 AI 输出了用户隐私数据
P1 高 幻觉率飙升、延迟暴涨 1 小时 钉钉/企微 @值班 幻觉率从 3% 涨到 20%
P2 中 点踩率上升、成本超预算、裁判失效 24 小时 邮件/群通知 点踩率从 8% 涨到 15%
P3 低 轻微波动 下次周会 周报 延迟 P95 从 4 秒涨到 5 秒

3.2 什么样的变化才值得告警

关键原则:看变化率,不只看绝对值。

场景 绝对值 变化 判定
幻觉率一直 3%,今天 3.2% 3.2% +0.2% 不告警(正常波动)
幻觉率一直 3%,今天 12% 12% +300% P1 告警(突然变化)
幻觉率一直 15%,今天 15.5% 15.5% +3% 变化率不告警 (不是新问题),但绝对值告警(一直超红线)

绝对值红线和变化率告警是两条独立规则,同时生效:

规则 判定方式 作用 依赖
绝对值红线(1.3) 超过阈值就告警 兜底,防"一直很烂但没人管" 不需要历史
变化率异常(3.2) 突然变了才告警 抓"突然退化" 需要历史数据

两条规则任一命中就告警 。比如幻觉率一直 15%:绝对值红线一直触发(该治理了),但如果这周没变化,变化率不触发。反过来,幻觉率一直 3% 突然涨到 12%:绝对值没超红线(<15%),但变化率触发了------两条互补。

异常检测方法之一:移动平均 + 标准差(供扩展参考,本脚本用更直观的翻倍法演示)

python 复制代码
import numpy as np

def is_anomaly(today_value, history_values, threshold=2.0):
    """
    简单异常检测:超过历史均值 ± N 倍标准差就算异常

    threshold=2.0 → 约 95% 置信区间

    注:本脚本的 check_anomalies 用更直观的"翻倍法"(×2/×2.5)演示,
    这个 σ 法供扩展参考。两种方法可以互补使用。
    """
    mean = np.mean(history_values)
    std = np.std(history_values)
    return abs(today_value - mean) > threshold * std

# 示例
history = [0.03, 0.025, 0.035, 0.03, 0.028, 0.032, 0.03]
today = 0.12  # 12%

if is_anomaly(today, history):
    print(f"幻觉率异常:今天 {today:.1%},历史均值 {np.mean(history):.1%}")

3.3 防止"告警疲劳"

问题 现象 解决
告警太多 每天几十条,大家都麻木了 提高阈值、合并同类告警
告警不精准 90% 的告警是误报 用变化率 + 绝对值双重判定
告警没人看 发了等于没发 分级 + 指定责任人
重要告警被淹没 P0 混在 P3 里 P0 用电话/独立通道

四、质量闭环:线上问题 → 测试用例

4.1 为什么这是最重要的环节

线上发现了一个幻觉问题 → 修好了 → 下次模型更新又出现了同样的问题。

因为这个问题没有被写进测试用例。

闭环原则 :每一个线上发现的问题,都应该变成一条回归测试用例。

4.2 闭环流程

复制代码
线上发现异常
    ↓
1. 记录问题(问题 + AI 回答 + 用户反馈)
    ↓
2. 定位根因(幻觉 / 安全 / 延迟 / 功能)
    ↓
3. 修复问题(改 Prompt / 更新知识库 / 换模型)
    ↓
4. 转化为测试用例(加入第 24 篇的 test_data/)
    ↓
5. 加入回归测试(下次变更自动验证)
    ↓
问题不再复发 ✅

4.3 转化示例

线上发现的问题:

用户问:"公司退货期是多久?"

AI 答:"退货期 30 天。"

实际是 7 天(知识库有两篇矛盾文档)。

转化为测试用例:

json 复制代码
{
    "id": "HALL-04",
    "question": "公司退货期是多久?",
    "fact_points": [
      {"name": "退货期", "variants": ["7天", "7 天"]}
    ],
    "note": "来自线上问题 #2025-03-15-001:知识库两篇文档矛盾导致 AI 答错退货期"
}

然后把这个用例加到 hallucination_cases.json 里,下次跑 CI/CD 就会自动验证这个问题不会复发。


五、轻量级监控面板

5.1 最简实现:一个 Python 脚本

不需要 Grafana、不需要数据平台。一个脚本 + 定时任务就够了。

线上日志从哪来? 你的 AI 产品在每次回答后,把 question / answer / context / response_time / user_dislike / total_tokens 写入日志文件或数据库。监控脚本定期读取这些日志做分析。最简单的方式是在 API 网关层加一行日志记录。

RAG 产品的日志必须记录 context(当次检索命中的文档片段),否则裁判模型没有参照物,忠实度判定无从谈起。纯 LLM 产品没有 context,裁判按常识判定。

【新建文件夹】 ai-test/ch26_monitor/

【新建文件 1】 ai_helpers.py------API 调用(和第 24 篇的相同,只需 call_simple 函数):

python 复制代码
"""AI 测试工具:API 调用"""
import time, os

try:
    from openai import OpenAI
except ImportError:
    raise ImportError("pip install openai")

_MIN_INTERVAL = 21
_last_call_time = [0.0]

def call_simple(question, model="kimi-k2.6", base_url="https://api.moonshot.cn/v1", **kw):
    """单轮调用(含全局限流)"""
    api_key = os.environ.get("LLM_API_KEY")
    if not api_key:
        raise RuntimeError("未设置 LLM_API_KEY")

    elapsed = time.time() - _last_call_time[0]
    if elapsed < _MIN_INTERVAL:
        time.sleep(_MIN_INTERVAL - elapsed)

    client = OpenAI(api_key=api_key, base_url=base_url)
    try:
        resp = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": question}],
            max_tokens=6000,
        )
        _last_call_time[0] = time.time()
        return resp.choices[0].message.content if resp.choices else None
    except Exception as e:
        _last_call_time[0] = time.time()
        print(f"[API 错误] {e}")
        return None

【新建文件 2】 online_logs.json------模拟线上日志(真实场景由你的产品生成,这里手动造 3 条用于测试脚本):

json 复制代码
[
  {
    "question": "公司退货期是多久?",
    "answer": "退货期 7 天,自签收之日起计算。",
    "context": "自签收之日起 7 天内可无理由退货。",
    "response_time": 2.1,
    "user_dislike": false,
    "total_tokens": 350,
    "timestamp": "2025-11-11 14:30:00"
  },
  {
    "question": "年假有多少天?",
    "answer": "年假 12 天,每满 5 年增加 2 天。",
    "context": "正式员工享有每年 12 天带薪年假。工龄每满 5 年增加 2 天。",
    "response_time": 1.8,
    "user_dislike": true,
    "total_tokens": 280,
    "timestamp": "2025-11-11 15:00:00"
  },
  {
    "question": "报销标准是什么?",
    "answer": "餐补每天 150 元。",
    "context": "一线城市餐补每天 150 元。",
    "response_time": 3.5,
    "user_dislike": false,
    "total_tokens": 420,
    "timestamp": "2025-11-11 16:00:00"
  }
]

【新建文件 3】 monitor.py------监控脚本(本篇核心代码):

python 复制代码
"""
线上 AI 质量监控(最简版)

每天跑一次(cron 定时),输出质量指标,异常时发告警。

指标分两类:
  全量指标(延迟/成本/点踩):读日志算数字,零 API 成本
  抽样指标(幻觉):调裁判模型,每天抽样 5%

注意:
  1. 复用同目录下 ai_helpers.py 的 call_simple(API 调用)
  2. 裁判解析失败返回 None 并剔除分母,不兜默认值
     (避免把裁判故障伪装成"幻觉率正常")
  3. 监控自身也要被监控:裁判大面积失败时发告警
  4. 调试时注意别手动连跑,否则 metrics_history.json 会写入重复日期记录
"""

import sys
import json
import os
import random
import numpy as np
from datetime import datetime

# 复用同目录下 ai_helpers.py 的 API 调用函数
from ai_helpers import call_simple

# 成本换算(根据你的平台单价修改)
TOKEN_PRICE_PER_1K = 0.012  # 每 1000 token 的费用(元)
DAILY_BUDGET = 33           # 日预算(元),根据你的实际预算改

# 幻觉判定阈值:裁判 score < 0.5 算一条幻觉
HALLUC_THRESHOLD = 0.5


# ========== 1. 读取线上日志 ==========

def load_online_logs(log_file="online_logs.json"):
    """
    读取线上回答日志

    容错:
      - 文件损坏时返回空列表(不崩溃)
      - 字段缺失的记录跳过(不混入统计)
    """
    if not os.path.exists(log_file):
        return []

    try:
        with open(log_file, encoding="utf-8") as f:
            data = json.load(f)
    except (json.JSONDecodeError, IOError) as e:
        print(f"  [警告] 日志文件损坏或无法读取:{e}")
        return []

    # 过滤掉格式不对的记录
    valid = [r for r in data if "question" in r and "answer" in r]
    if len(valid) < len(data):
        print(f"  [警告] {len(data) - len(valid)} 条日志格式异常,已跳过")
    return valid


# ========== 2. 计算全量指标(延迟/成本/点踩,零成本) ==========

def calc_metrics(responses):
    """
    计算全量指标:延迟、成本、用户反馈

    这些指标从全量日志计算,不需要采样(读日志零成本)。
    幻觉检测另走抽样(见 check_hallucination)。
    """
    if not responses:
        return None

    total = len(responses)

    # 延迟
    times = sorted(r.get("response_time", 0) for r in responses)
    p95_idx = min(int(total * 0.95), total - 1)
    p99_idx = min(int(total * 0.99), total - 1)

    # 成本(用 token 数 × 单价换算)
    total_tokens = sum(r.get("total_tokens", 0) for r in responses)
    est_cost = total_tokens / 1000 * TOKEN_PRICE_PER_1K

    return {
        "total": total,
        "avg_response_time": sum(times) / total,
        "p95_response_time": times[p95_idx],
        "p99_response_time": times[p99_idx],
        "dislike_rate": sum(1 for r in responses if r.get("user_dislike")) / total,
        "total_tokens": total_tokens,
        "est_cost": round(est_cost, 2),
        "date": datetime.now().strftime("%Y-%m-%d"),
    }


# ========== 3. 幻觉检测(抽样,有 API 费用) ==========

def check_hallucination(question, answer, context=""):
    """
    线上幻觉检测:用裁判模型(LLM-as-judge)判定

    返回:
        score: 0~1(1.0=完全可信,0.0=明显幻觉)
        None: 裁判解析失败(不参与统计,不兜默认值)
    """
    if context:
        judge_prompt = f"""你是事实核查员。请判断以下回答是否忠于检索到的参考资料。

参考资料:
{context}

问题:{question}
回答:{answer}

判断标准:
- 回答中的事实是否忠于参考资料
- 是否存在参考资料中没有的编造内容
- 数字、日期、名称是否准确

只输出 JSON(不要输出其他内容):
{{"score": 0.9, "reason": "一句话理由"}}"""
    else:
        judge_prompt = f"""你是事实核查员。请判断以下回答是否存在幻觉。

问题:{question}
回答:{answer}

判断标准:
- 回答中的事实是否可以被公认知识支持
- 是否存在编造的数字、日期、名称
- 是否存在自相矛盾

只输出 JSON(不要输出其他内容):
{{"score": 0.9, "reason": "一句话理由"}}"""

    result = call_simple(judge_prompt)
    if not result:
        return None  # API 失败,不参与统计

    # 剥掉 ```json 围栏(LLM 常见输出格式)
    text = result.strip()
    start = text.find('{')
    end = text.rfind('}')
    if start != -1 and end != -1:
        text = text[start:end + 1]

    try:
        parsed = json.loads(text)
        score = parsed.get("score")
        if score is None:
            return None  # 裁判没按格式回,剔除
        return float(score)
    except (json.JSONDecodeError, ValueError):
        return None  # 解析失败,不参与统计


def smart_sample(responses, rate=0.05):
    """
    智能采样:随机抽样 + 用户反馈触发

    只用于幻觉检测(有 API 费用)。免费指标全量统计,不用采样。
    """
    sampled = [r for r in responses if r.get("user_dislike")]
    remaining = [r for r in responses if not r.get("user_dislike")]
    sample_size = max(1, int(len(remaining) * rate))
    sampled += random.sample(remaining, min(sample_size, len(remaining)))
    return sampled


# ========== 4. 异常检测(绝对值红线 + 变化率) ==========

def check_anomalies(today_metrics, halluc_rate=None, history_file="metrics_history.json"):
    """
    异常检测:绝对值红线 + 变化率

    两条规则独立、任一命中就告警:
      绝对值:超过阈值就告警(不需要历史,冷启动可用)
      变化率:突然变了才告警(全量维度 ≥7 天历史,幻觉维度 ≥3 天)
    """
    history = []
    if os.path.exists(history_file):
        try:
            with open(history_file, encoding="utf-8") as f:
                history = json.load(f)
        except (json.JSONDecodeError, IOError):
            history = []

    alerts = []

    # ---- 绝对值红线(不需要历史,无条件执行)----

    if today_metrics["p95_response_time"] > 10:
        alerts.append({
            "level": "P1",
            "message": f"P95 延迟超红线:{today_metrics['p95_response_time']:.1f} 秒(阈值 10 秒)"
        })

    if today_metrics["p99_response_time"] > 30:
        alerts.append({
            "level": "P1",
            "message": f"P99 延迟超红线:{today_metrics['p99_response_time']:.1f} 秒(阈值 30 秒)"
        })

    if today_metrics["dislike_rate"] > 0.25:
        alerts.append({
            "level": "P1",
            "message": f"点踩率超红线:{today_metrics['dislike_rate']:.1%}(阈值 25%)"
        })

    if today_metrics["est_cost"] > DAILY_BUDGET * 1.5:
        alerts.append({
            "level": "P2",
            "message": f"日成本超预算 50%:¥{today_metrics['est_cost']:.2f}"
                       f"(预算 ¥{DAILY_BUDGET},红线 ¥{DAILY_BUDGET * 1.5:.0f})"
        })

    if halluc_rate is not None and halluc_rate > 0.15:
        alerts.append({
            "level": "P1",
            "message": f"幻觉率超红线:{halluc_rate:.1%}(阈值 15%)"
        })

    # ---- 变化率异常(需要历史数据)----

    # 全量维度:≥7 天历史(数据充足,变化率判定可靠)
    if len(history) >= 7:
        recent = history[-7:]

        avg_dislike = sum(m["dislike_rate"] for m in recent) / len(recent)
        if today_metrics["dislike_rate"] > avg_dislike * 2:
            alerts.append({
                "level": "P1",
                "message": f"点踩率突增:今天 {today_metrics['dislike_rate']:.1%},"
                           f"近 7 天均值 {avg_dislike:.1%}"
            })

        avg_p95 = sum(m["p95_response_time"] for m in recent) / len(recent)
        if today_metrics["p95_response_time"] > avg_p95 * 2:
            alerts.append({
                "level": "P1",
                "message": f"P95 延迟突增:今天 {today_metrics['p95_response_time']:.1f}s,"
                           f"近 7 天均值 {avg_p95:.1f}s"
            })

    # 幻觉维度:≥3 天有效历史(抽样+剔除后有效天少,门槛降低)
    # 用 ×2.5 或绝对增量 >5pp 双条件(抽样方差大,×2 容易误报)
    if halluc_rate is not None:
        halluc_hist = [m["hallucination_rate"] for m in history[-7:]
                       if m.get("hallucination_rate") is not None]
        if len(halluc_hist) >= 3:
            avg_halluc = sum(halluc_hist) / len(halluc_hist)
            if avg_halluc > 0 and (halluc_rate > avg_halluc * 2.5
                                   or halluc_rate - avg_halluc > 0.05):
                alerts.append({
                    "level": "P1",
                    "message": f"幻觉率突增:今天 {halluc_rate:.1%},"
                               f"近 {len(halluc_hist)} 天均值 {avg_halluc:.1%}"
                })

    # 保存历史(只保留 30 天;幻觉率 None 时不写入,避免污染下次均值)
    if halluc_rate is not None:
        today_metrics["hallucination_rate"] = halluc_rate
    history.append(today_metrics)
    with open(history_file, "w", encoding="utf-8") as f:
        json.dump(history[-30:], f, ensure_ascii=False, indent=2)

    return alerts


# ========== 5. 发送告警 ==========

def send_alerts(alerts):
    """按级别发送告警"""
    for a in alerts:
        if a["level"] == "P0":
            print(f"  🚨 P0 紧急:{a['message']}")
        elif a["level"] == "P1":
            print(f"  ⚠️ P1 高:{a['message']}")
        elif a["level"] == "P2":
            print(f"  📢 P2 中:{a['message']}")
        else:
            print(f"  ℹ️ {a['level']}:{a['message']}")


# ========== 6. 主流程 ==========

if __name__ == "__main__":
    print(f"📊 线上质量监控 --- {datetime.now().strftime('%Y-%m-%d %H:%M')}")

    responses = load_online_logs()
    if not responses:
        print("  无线上日志,跳过")
        sys.exit()

    # ---- 全量指标(延迟/成本/点踩,零成本)----
    metrics = calc_metrics(responses)
    print(f"  总回答数:{metrics['total']}")
    print(f"  平均延迟:{metrics['avg_response_time']:.1f}s")
    print(f"  P95 延迟:{metrics['p95_response_time']:.1f}s")
    print(f"  P99 延迟:{metrics['p99_response_time']:.1f}s")
    print(f"  点踩率:{metrics['dislike_rate']:.1%}")
    print(f"  总 token:{metrics['total_tokens']}")
    print(f"  预估成本:¥{metrics['est_cost']}")

    # ---- 幻觉检测(抽样,有 API 费用)----
    halluc_rate = None  # 先初始化,防止 NameError
    sample = smart_sample(responses, rate=0.05)
    print(f"\n  幻觉检测采样:{len(sample)}/{len(responses)} 条")

    halluc_scores = []
    for r in sample:
        score = check_hallucination(
            r["question"],
            r["answer"],
            context=r.get("context", "")  # RAG 产品传 context,纯 LLM 传空
        )
        halluc_scores.append(score)
        if score is not None and score < HALLUC_THRESHOLD:
            print(f"    ⚠️ 疑似幻觉({score:.2f}):{r['question'][:30]}...")

    # 用有效样本算幻觉率(解析失败的剔除分母)
    # failed_count 只在这里定义一次,后面的裁判失效块直接引用
    valid_scores = [s for s in halluc_scores if s is not None]
    failed_count = len(halluc_scores) - len(valid_scores)

    if valid_scores:
        halluc_count = sum(1 for s in valid_scores if s < HALLUC_THRESHOLD)
        halluc_rate = halluc_count / len(valid_scores)
        metrics["hallucination_rate"] = round(halluc_rate, 3)
        print(f"  幻觉率:{halluc_rate:.1%}({halluc_count}/{len(valid_scores)})")

        if failed_count > 0:
            print(f"  [提示] {failed_count} 条裁判解析失败,已剔除分母")

    # ---- 异常检测(先算好 alerts,裁判失效块往里 append)----
    alerts = check_anomalies(metrics, halluc_rate=halluc_rate)

    # ---- 裁判自身故障检测(监控也要被监控)----
    if halluc_scores:
        fail_ratio = failed_count / len(halluc_scores)
        if fail_ratio > 0.2:
            alerts.append({
                "level": "P2",
                "message": f"裁判失效:{failed_count}/{len(halluc_scores)} 条无法解析"
                           f"({fail_ratio:.0%}),本日幻觉监控不可信"
            })

    # ---- 发送告警 ----
    send_alerts(alerts)

    if not alerts:
        print("  ✅ 各项指标正常")

【运行】 在终端执行:

bash 复制代码
cd D:\Faye\project\aitest\ch26_monitor
$env:LLM_API_KEY = "sk-你的密钥"
python monitor.py

预期输出(数字因日志内容和裁判判定而异):

复制代码
📊 线上质量监控 --- 2025-11-11 17:30
  总回答数:3
  平均延迟:2.5s
  P95 延迟:3.5s
  P99 延迟:3.5s
  点踩率:33.3%
  总 token:1050
  预估成本:¥0.01

  幻觉检测采样:2/3 条
  幻觉率:0.0%(0/2)
  ⚠️ P1 高:点踩率超红线:33.3%(阈值 25%)

输出解读:

  • 3 条日志 → 全量指标正常计算
  • 幻觉检测采样 2/3 → 点踩的 1 条 + 随机抽 1 条
  • 幻觉率 0% → 裁判判定回答可信
  • P1 告警 → 3 条里 1 条点踩 = 33.3%,超过 25% 红线------告警触发说明异常检测在正常工作

目录下会多一个 metrics_history.json------记录今天的指标数据,下次跑就能做变化率对比。

5.2 监控频率和成本

不同维度的监控频率不一样,不是所有指标都要跑 LLM:

维度 频率 成本 数据源
延迟 全量、实时 零 读日志算数字
成本 全量、实时 零 读日志算数字
点踩率 全量、实时 零 读日志算数字
幻觉检测 每天一次、抽样 5% 有 API 费用 调裁判模型
安全检测 实时 零(产品侧) 内容审核日志

5.3 定时执行

用 cron(Linux/Mac)或 Windows 任务计划程序,每天跑一次:

bash 复制代码
# Linux/Mac 的 crontab(UTC 01:00 = 北京 09:00)
0 1 * * * cd /path/to/ch26_monitor && python monitor.py

Windows 用"任务计划程序"创建一个每日任务,执行 python monitor.py。

调试时注意 :别在同一天内手动连跑脚本,否则 metrics_history.json 会写入重复日期记录,影响变化率判定。

5.4 更进一步:接 Grafana

如果团队已经有 Grafana(监控平台),可以:

  1. 把 metrics_history.json 的数据写入 Prometheus / InfluxDB
  2. 在 Grafana 里建一个 Dashboard,展示趋势图
  3. 配置 Grafana 的告警规则

这一步是工程化方向,本篇不展开。 原理和上面的脚本一样------收集指标、对比历史、触发告警。


六、AI 质量运营的完整闭环

把本篇和前面所有篇串起来,就是 AI 质量运营的完整闭环:

复制代码
设计测试用例(17~23 篇)
    ↓
搭建测试框架(第 24 篇)
    ↓
CI/CD 自动回归(第 25 篇)
    ↓
上线
    ↓
线上监控(本篇) ←──────────┐
    ↓                        │
发现异常                      │
    ↓                        │
定位根因                      │
    ↓                        │
转化为测试用例 ─────────────────┘
    ↓
下次变更自动验证(回到 CI/CD)

这就是"越用越好"的飞轮:

阶段 做什么 工具
开发阶段 写测试用例 第 17~23 篇
提交阶段 自动回归 第 24~25 篇
运行阶段 持续监控 本篇
迭代阶段 问题→用例→回归 闭环

七、本篇小结

收获 说明
监控五维度 幻觉(抽样+裁判模型)、安全、延迟、成本、用户反馈
免费 vs 付费 延迟/成本/点踩全量零成本;幻觉抽样有 API 费用
线上幻觉 = 裁判模型 和测试期不同------没有标准答案,用 LLM-as-judge 判定
裁判解析兜 None 失败剔除分母,不塞默认值(避免把故障伪装成正常)
监控自身也要被监控 裁判大面积失败时发告警,而不是静默"正常"
告警分级 P0 紧急(电话)→ P3 低(周会),不制造噪音
异常检测双规则 绝对值红线(兜底)+ 变化率(抓突变),任一命中就告警
质量闭环 每个线上问题都变成测试用例,防止复发

至此,17~26 篇覆盖了 AI 质量的完整生命周期:离线测试(17~23)→ 测试工程(24)→ CI/CD 回归(25)→ 线上监控(26)。

全系列完结。 回顾你的 AI 测试之旅:

阶段 篇数 核心能力
入门(1~8 篇) 8 测试基础、Python、接口测试
进阶(9~16 篇) 8 自动化、性能、测试开发
AI 测试(17~26 篇) 10 大模型质量保障全链路

下一步 :把这套方法论用到你的实际项目中。最好的学习方式不是继续读,而是------打开你的 AI 产品,跑一条测试,看一份报告,发一封告警。

相关推荐
prince_zxill1 小时前
PEP 751 pylock.toml 实测:pip 26.3 装 6 个包版本全钉死,但 [web] 选不中任何东西
python·pip·依赖管理·pep 751
ZhengEnCi1 小时前
AI 总模仿代码库里的过时写法怎么办:先清坏样例,再用类型与测试让 AI 无法犯错
人工智能·ai编程
一只爱撸猫的程序猿1 小时前
五周、两个开源仓库、九次拦截之后:AI 时代程序员缺的到底是什么
人工智能·后端·开源
GitCode官方2 小时前
开源鸿蒙跨平台直播|AI 时代,用 cj-tauri 开发鸿蒙 PC 应用
人工智能·华为·harmonyos·atomgit
老金带你玩AI2 小时前
GPT-6.2更强更便宜了,为什么还有人骂?
人工智能
Thanks_ks2 小时前
Python 的垃圾回收——引用计数撑起日常,分代回收收拾残局
python·内存管理·垃圾回收·循环引用·引用计数·gc 模块·weakref
CyrusYiVPP2 小时前
实测 uv 0.13.7:同一套包,pip 装 94 秒,它只用 19 秒
人工智能·python
泯泷3 小时前
OpenClaw 退潮背后,是 AI 圈“技术自嗨”的终结
人工智能·chatgpt·llm
罗西的思考3 小时前
【轻量化复刻大模型 / KIMI K3】Muon 优化器及 训练系统
人工智能·算法·机器学习