机器学习模型验证可视化技术与工程实践-代码聚汇网

机器学习模型验证可视化技术与工程实践

EYES 乱·2026-07-23·阅读 67 GEO检测（免费）

机器学习模型验证可视化技术交叉验证

|难度：普通|阅读约 51 分钟

1. 模型验证技术解析：为什么我们需要可视化指南

在机器学习项目的全生命周期中，模型验证环节往往决定了最终落地的成败。我见过太多团队花费数月训练复杂模型，却因为验证环节的疏漏导致生产环境表现远低于预期。传统验证报告里那些枯燥的数值指标（准确率、F1值等）就像体检报告上的数字——专业人士能读懂，但普通团队成员和业务方往往难以直观理解模型的实际表现边界。

这就是为什么我们需要带代码示例的可视化指南。通过Matplotlib、Seaborn或Plotly等工具，我们可以将模型在验证集上的表现转化为决策边界图、特征重要性热力图、预测误差分布直方图等直观形式。去年我们为电商平台开发推荐系统时，用t-SNE将高维用户特征投影到2D平面，配合散点图颜色映射点击概率，让非技术背景的产品经理一眼就理解了模型在年轻用户群体中的推荐偏差问题。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 核心验证方法的技术实现

2.1 交叉验证的代码实践

K折交叉验证是避免数据划分偏差的黄金标准。但直接使用scikit-learn的cross_val_score会丢失很多细节信息。这里分享我的改进方案：

python复制from sklearn.model_selection import KFold
import numpy as np
import matplotlib.pyplot as plt

# 自定义可视化交叉验证
def visualize_cv(X, y, model, n_splits=5):
    kf = KFold(n_splits=n_splits)
    fig, axes = plt.subplots(n_splits, 2, figsize=(12, n_splits*3))
    
    for i, (train_idx, test_idx) in enumerate(kf.split(X)):
        # 训练和预测
        model.fit(X[train_idx], y[train_idx])
        preds = model.predict(X[test_idx])
        
        # 绘制训练/测试数据分布
        axes[i,0].scatter(X[train_idx,0], X[train_idx,1], c='blue', alpha=0.5, label='Train')
        axes[i,0].scatter(X[test_idx,0], X[test_idx,1], c='red', alpha=0.5, label='Test')
        axes[i,0].set_title(f'Fold {i+1} Data Split')
        
        # 绘制预测效果
        axes[i,1].scatter(X[test_idx,0], X[test_idx,1], c=preds, cmap='coolwarm')
        axes[i,1].set_title(f'Fold {i+1} Predictions')
    
    plt.tight_layout()
    return fig

这个可视化方案特别适合向团队展示：

每个fold的数据分布是否均衡（避免某次划分恰好抽到特殊样本）
模型在不同数据子集上的表现一致性
决策边界是否稳定

2.2 混淆矩阵的进阶可视化

普通的混淆矩阵热力图只能展示分类结果的数量分布。加入以下改进可以提取更多信息：

python复制from sklearn.metrics import confusion_matrix
import seaborn as sns

def enhanced_confusion_matrix(y_true, y_pred, class_names):
    cm = confusion_matrix(y_true, y_pred)
    
    # 计算比例矩阵（按真实标签）
    cm_norm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
    
    fig, ax = plt.subplots(1, 2, figsize=(12, 5))
    
    # 原始数量矩阵
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
                xticklabels=class_names, yticklabels=class_names, 
                ax=ax[0])
    ax[0].set_title('Count Matrix')
    ax[0].set_ylabel('True Label')
    
    # 标准化比例矩阵
    sns.heatmap(cm_norm, annot=True, fmt='.2f', cmap='Oranges',
                xticklabels=class_names, yticklabels=class_names,
                ax=ax[1])
    ax[1].set_title('Normalized Matrix (by True Label)')
    
    plt.suptitle('Enhanced Confusion Matrix Analysis')
    return fig

这种双面板设计可以同时看到：

左侧：各类别的绝对错误数量（帮助发现样本量不平衡问题）
右侧：各类别的相对错误比例（消除样本量影响，反映模型真实能力）

3. 特殊场景的验证技巧

3.1 时间序列数据的验证陷阱

处理时间序列数据时，随机划分的交叉验证会导致数据泄露。我曾在一个销售预测项目中踩过这个坑——模型在验证集表现很好，但实际预测未来时完全失效。正确的做法是使用时序交叉验证：

python复制from sklearn.model_selection import TimeSeriesSplit

def time_series_cv_plot(model, X, y, n_splits=5):
    tscv = TimeSeriesSplit(n_splits=n_splits)
    fig, axes = plt.subplots(n_splits, 1, figsize=(10, n_splits*3))
    
    for i, (train_idx, test_idx) in enumerate(tscv.split(X)):
        # 获取时间戳（假设第一列是时间）
        train_time = X[train_idx, 0]
        test_time = X[test_idx, 0]
        
        # 训练和预测
        model.fit(X[train_idx], y[train_idx])
        preds = model.predict(X[test_idx])
        
        # 绘制时序划分
        axes[i].axvspan(train_time.min(), train_time.max(), 
                       alpha=0.2, color='blue')
        axes[i].axvspan(test_time.min(), test_time.max(),
                       alpha=0.2, color='red')
        axes[i].plot(test_time, y[test_idx], label='True')
        axes[i].plot(test_time, preds, label='Predicted')
        axes[i].set_title(f'Fold {i+1} - Test from {test_time.min()} to {test_time.max()}')
        axes[i].legend()
    
    plt.tight_layout()
    return fig

关键点：

确保测试集的时间永远在训练集之后
可视化展示每个fold的时间范围
观察模型在不同时间段的预测稳定性

3.2 小样本数据的验证策略

当数据量少于1000条时，传统的70-30划分会带来很大方差。这时bootstrap方法更可靠：

python复制def bootstrap_validation(model, X, y, n_iterations=1000):
    stats = []
    for _ in range(n_iterations):
        # 有放回抽样
        idx = np.random.choice(len(X), size=len(X), replace=True)
        X_sample, y_sample = X[idx], y[idx]
        
        # 保留未抽中的样本作为测试集
        oob_idx = np.setdiff1d(np.arange(len(X)), np.unique(idx))
        if len(oob_idx) > 0:
            model.fit(X_sample, y_sample)
            score = model.score(X[oob_idx], y[oob_idx])
            stats.append(score)
    
    # 可视化结果分布
    plt.figure(figsize=(10, 5))
    plt.hist(stats, bins=30, edgecolor='k', alpha=0.7)
    plt.axvline(np.mean(stats), color='r', linestyle='--')
    plt.title(f'Bootstrap Validation (Mean Accuracy: {np.mean(stats):.3f})')
    plt.xlabel('Accuracy')
    plt.ylabel('Frequency')
    return plt

这种方法特别适合：

医学影像分析等小样本场景
数据收集成本高的工业检测项目
需要估计指标置信区间的场景

4. 高级可视化技术

4.1 决策边界的三维呈现

对于二维特征数据，我们可以直接绘制决策边界。但当特征维度升高时，需要更聪明的可视化方案：

python复制from sklearn.decomposition import PCA
from mpl_toolkits.mplot3d import Axes3D

def plot_3d_decision_boundary(model, X, y, n_components=3):
    # 降维处理
    pca = PCA(n_components=n_components)
    X_pca = pca.fit_transform(X)
    
    # 生成网格数据
    x_min, x_max = X_pca[:, 0].min() - 1, X_pca[:, 0].max() + 1
    y_min, y_max = X_pca[:, 1].min() - 1, X_pca[:, 1].max() + 1
    z_min, z_max = X_pca[:, 2].min() - 1, X_pca[:, 2].max() + 1
    
    xx, yy, zz = np.meshgrid(np.linspace(x_min, x_max, 30),
                             np.linspace(y_min, y_max, 30),
                             np.linspace(z_min, z_max, 30))
    
    # 预测网格点
    grid_points = np.c_[xx.ravel(), yy.ravel(), zz.ravel()]
    Z = model.predict(pca.inverse_transform(grid_points))
    Z = Z.reshape(xx.shape)
    
    # 3D绘图
    fig = plt.figure(figsize=(12, 8))
    ax = fig.add_subplot(111, projection='3d')
    
    # 绘制决策边界（透明度调整）
    ax.scatter(xx.ravel(), yy.ravel(), zz.ravel(), c=Z.ravel(), 
               alpha=0.02, cmap='coolwarm')
    
    # 绘制真实数据点
    ax.scatter(X_pca[:,0], X_pca[:,1], X_pca[:,2], c=y, 
               cmap='coolwarm', edgecolor='k', s=50)
    
    ax.set_title('3D Decision Boundary via PCA')
    return fig

这种可视化可以：

保留原始数据的拓扑结构
展示高维决策边界的复杂形状
识别潜在的非线性可分区域

4.2 动态交互式验证面板

静态图像有时难以全面展示模型特性。使用Plotly可以创建交互式验证面板：

python复制import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots

def interactive_validation_dashboard(X, y, preds):
    # 创建子图
    fig = make_subplots(rows=2, cols=2,
                        specs=[[{'type': 'scatter3d'}, {'type': 'xy'}],
                               [{'type': 'xy'}, {'type': 'domain'}]])
    
    # 3D特征空间
    fig.add_trace(
        go.Scatter3d(x=X[:,0], y=X[:,1], z=X[:,2],
                     mode='markers',
                     marker=dict(color=y, colorscale='Viridis'),
                     name='True Labels'),
        row=1, col=1
    )
    
    # 预测误差分布
    errors = y - preds
    fig.add_trace(
        go.Histogram(x=errors, nbinsx=30,
                     marker_color='#FFA07A',
                     name='Prediction Errors'),
        row=2, col=1
    )
    
    # 特征重要性（假设模型有feature_importances_属性）
    if hasattr(model, 'feature_importances_'):
        feat_imp = model.feature_importances_
        fig.add_trace(
            go.Bar(x=[f'Feature {i}' for i in range(len(feat_imp))],
                   y=feat_imp,
                   name='Feature Importance'),
            row=1, col=2
        )
    
    # 模型指标饼图
    metrics = {
        'MAE': np.mean(np.abs(errors)),
        'R2': model.score(X, y)
    }
    fig.add_trace(
        go.Pie(labels=list(metrics.keys()),
               values=list(metrics.values()),
               name='Metrics'),
        row=2, col=2
    )
    
    fig.update_layout(height=800, title_text='Interactive Model Validation Dashboard')
    return fig

这种动态面板的价值在于：

支持旋转/缩放/悬停查看细节
多角度同时观察模型表现
适合在演示会议中使用

5. 验证结果的专业报告

5.1 自动化报告生成

将验证结果整理成专业报告是项目交付的关键环节。我通常使用以下模板：

python复制from jinja2 import Template
import pdfkit

def generate_validation_report(model, X_test, y_test, output_path='report.pdf'):
    # 计算各项指标
    from sklearn.metrics import (accuracy_score, precision_score, 
                                recall_score, f1_score, roc_auc_score)
    
    y_pred = model.predict(X_test)
    metrics = {
        'Accuracy': accuracy_score(y_test, y_pred),
        'Precision': precision_score(y_test, y_pred),
        'Recall': recall_score(y_test, y_pred),
        'F1 Score': f1_score(y_test, y_pred),
        'ROC AUC': roc_auc_score(y_test, y_pred) if len(np.unique(y_test)) == 2 else None
    }
    
    # 生成可视化图表
    conf_matrix = plot_confusion_matrix(model, X_test, y_test)
    conf_matrix_path = 'conf_matrix.png'
    conf_matrix.savefig(conf_matrix_path)
    
    # HTML模板
    html_template = """
    <!DOCTYPE html>
    <html>
    <head>
        <title>Model Validation Report</title>
        <style>
            body { font-family: Arial, sans-serif; margin: 40px; }
            h1 { color: #2c3e50; border-bottom: 2px solid #3498db; }
            .metrics { background: #f8f9fa; padding: 20px; border-radius: 5px; }
            table { width: 100%; border-collapse: collapse; }
            th, td { padding: 8px; text-align: left; border-bottom: 1px solid #ddd; }
            img { max-width: 100%; height: auto; }
        </style>
    </head>
    <body>
        <h1>Model Validation Report</h1>
        <p>Generated on {{ date }}</p>
        
        <h2>Performance Metrics</h2>
        <div class="metrics">
            <table>
                {% for name, value in metrics.items() %}
                <tr>
                    <th>{{ name }}</th>
                    <td>{{ '%.3f'|format(value) if value is not none else 'N/A' }}</td>
                </tr>
                {% endfor %}
            </table>
        </div>
        
        <h2>Confusion Matrix</h2>
        <img src="{{ conf_matrix_path }}" alt="Confusion Matrix">
        
        <h2>Model Characteristics</h2>
        <pre>{{ model_params }}</pre>
    </body>
    </html>
    """
    
    # 渲染并导出PDF
    template = Template(html_template)
    html = template.render(
        date=datetime.now().strftime('%Y-%m-%d'),
        metrics=metrics,
        conf_matrix_path=conf_matrix_path,
        model_params=str(model.get_params())
    )
    
    pdfkit.from_string(html, output_path)
    return output_path

5.2 关键注意事项

数据泄露防护：
- 所有特征工程步骤必须封装在交叉验证循环内部
- 时序数据要严格保证时间先后顺序
- 在可视化中明确标注数据划分边界
可视化设计原则：
- 一个图表只传达一个核心信息
- 使用颜色时考虑色盲用户（避免红绿对比）
- 动态图表要提供关键状态的截图备份
报告呈现技巧：
- 技术指标与业务KPI要对应展示
- 对非技术受众要提供简化版可视化
- 保留原始代码和数据以备审计

6. 验证工具链的搭建

6.1 自动化验证流水线

成熟的ML项目应该建立自动化验证流程。这是我的推荐架构：

python复制from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder

# 构建包含验证的完整pipeline
def build_validation_pipeline(model):
    # 数值特征处理
    numeric_transformer = Pipeline(steps=[
        ('imputer', SimpleImputer(strategy='median')),
        ('scaler', StandardScaler())
    ])
    
    # 类别特征处理
    categorical_transformer = Pipeline(steps=[
        ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
        ('onehot', OneHotEncoder(handle_unknown='ignore'))
    ])
    
    # 组合特征处理器
    preprocessor = ColumnTransformer(
        transformers=[
            ('num', numeric_transformer, selector(dtype_include=np.number)),
            ('cat', categorical_transformer, selector(dtype_include=object))
        ])
    
    # 完整pipeline（包含验证）
    full_pipeline = Pipeline([
        ('preprocessor', preprocessor),
        ('model', model),
        ('validator', CrossValidator())  # 自定义验证器
    ])
    
    return full_pipeline

6.2 自定义验证器的实现

扩展scikit-learn的BaseEstimator可以创建强大的自定义验证器：

python复制from sklearn.base import BaseEstimator, TransformerMixin
import matplotlib.pyplot as plt
import io
import base64

class VisualValidator(BaseEstimator, TransformerMixin):
    def __init__(self, metrics=['accuracy', 'precision'], n_splits=5):
        self.metrics = metrics
        self.n_splits = n_splits
        self.figures_ = []
        
    def fit(self, X, y=None):
        return self
    
    def transform(self, X, y=None):
        # 在实际项目中这里会执行完整的验证流程
        # 以下是简化的演示版本
        fig, ax = plt.subplots(figsize=(8, 4))
        ax.plot([0, 1], [0, 1], 'r--')
        ax.set_title('Validation Metrics Trend')
        self.figures_.append(fig)
        
        # 将图像转换为HTML可嵌入格式
        buf = io.BytesIO()
        fig.savefig(buf, format='png')
        buf.seek(0)
        img_str = base64.b64encode(buf.read()).decode('utf-8')
        
        return f'<img src="data:image/png;base64,{img_str}">'
    
    def generate_report(self):
        report = "<h2>Model Validation Report</h2>"
        for fig in self.figures_:
            buf = io.BytesIO()
            fig.savefig(buf, format='png')
            buf.seek(0)
            img_str = base64.b64encode(buf.read()).decode('utf-8')
            report += f'<img src="data:image/png;base64,{img_str}"><br>'
        return report

这种设计允许：

将验证过程无缝集成到ML流水线中
自动保存所有验证可视化结果
生成统一的验证报告

7. 实际项目经验分享

在金融风控项目中，我们遇到了类别极度不平衡的问题（正常交易99.7%，欺诈交易0.3%）。传统的准确率指标完全失效，这时我们开发了针对性的验证方案：

python复制def fraud_validation_plots(y_true, y_pred, y_score):
    from sklearn.metrics import (precision_recall_curve, average_precision_score,
                                roc_curve, auc)
    
    # 计算各项曲线
    precision, recall, _ = precision_recall_curve(y_true, y_score)
    fpr, tpr, _ = roc_curve(y_true, y_score)
    
    # 创建子图
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
    
    # PR曲线
    ax1.plot(recall, precision, color='darkorange',
             label=f'AP={average_precision_score(y_true, y_score):.2f}')
    ax1.set_xlabel('Recall')
    ax1.set_ylabel('Precision')
    ax1.set_title('Precision-Recall Curve')
    ax1.legend()
    
    # ROC曲线
    ax2.plot(fpr, tpr, color='navy',
             label=f'AUC={auc(fpr, tpr):.2f}')
    ax2.plot([0, 1], [0, 1], 'r--')
    ax2.set_xlabel('False Positive Rate')
    ax2.set_ylabel('True Positive Rate')
    ax2.set_title('ROC Curve')
    ax2.legend()
    
    # 添加混淆矩阵注释
    cm = confusion_matrix(y_true, y_pred)
    tn, fp, fn, tp = cm.ravel()
    ax2.annotate(f'TN: {tn}\nFP: {fp}\nFN: {fn}\nTP: {tp}',
                 xy=(0.6, 0.3), xycoords='axes fraction',
                 bbox=dict(boxstyle='round', alpha=0.2))
    
    plt.tight_layout()
    return fig

关键收获：

在极度不平衡场景下，ROC曲线可能过于乐观，PR曲线更可靠
要同时关注绝对数量（如FP不能超过业务承受范围）
阈值选择需要与业务成本函数挂钩

8. 验证环境的工程化实践

8.1 验证结果版本控制

模型验证结果需要与代码、数据保持同步。我的推荐做法：

python复制import hashlib
import json
from datetime import datetime

def save_validation_results(model, X_test, y_test, metrics, plots):
    # 生成唯一版本ID
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    data_hash = hashlib.md5(X_test.tobytes()).hexdigest()[:8]
    version_id = f"{timestamp}_{data_hash}"
    
    # 保存结构化结果
    result = {
        'version': version_id,
        'model_type': str(type(model).__name__),
        'model_params': model.get_params(),
        'metrics': metrics,
        'timestamp': timestamp
    }
    
    # 创建版本目录
    os.makedirs(f'validation_results/{version_id}', exist_ok=True)
    
    # 保存JSON报告
    with open(f'validation_results/{version_id}/report.json', 'w') as f:
        json.dump(result, f, indent=2)
    
    # 保存可视化图表
    for name, fig in plots.items():
        fig.savefig(f'validation_results/{version_id}/{name}.png')
    
    # 保存测试数据样本
    np.savez(f'validation_results/{version_id}/test_data.npz',
             X_test=X_test, y_test=y_test)
    
    return version_id

8.2 验证监控看板

在生产环境中，我推荐使用Grafana+Prometheus搭建实时监控看板：

python复制from prometheus_client import start_http_server, Gauge
import time

class ModelMonitor:
    def __init__(self, model_name):
        self.metrics = {
            'accuracy': Gauge(f'{model_name}_accuracy', 'Model accuracy'),
            'latency': Gauge(f'{model_name}_latency_ms', 'Prediction latency'),
            'data_drift': Gauge(f'{model_name}_data_drift', 'Feature distribution shift')
        }
        
    def update_metrics(self, X, y, preds, latency):
        accuracy = accuracy_score(y, preds)
        drift_score = calculate_drift(X)  # 自定义特征漂移计算
        
        self.metrics['accuracy'].set(accuracy)
        self.metrics['latency'].set(latency*1000)  # 转毫秒
        self.metrics['data_drift'].set(drift_score)
        
def start_monitoring(port=8000):
    start_http_server(port)
    print(f"Monitoring server started on port {port}")
    while True:
        time.sleep(60)  # 每分钟更新一次指标

这种架构提供了：

实时性能指标可视化
历史趋势分析
异常自动告警

9. 验证环节的团队协作

9.1 可视化标注系统

在团队review模型问题时，建立统一的标注系统很关键：

python复制def create_annotated_validation(plot_func, X, y, notes):
    fig = plot_func(X, y)
    
    # 添加团队标注
    ax = fig.gca()
    for note in notes:
        ax.annotate(note['text'], 
                   xy=note['point'], 
                   xytext=note['text_pos'],
                   arrowprops=dict(facecolor='black', shrink=0.05),
                   bbox=dict(boxstyle='round', alpha=0.2))
    
    # 添加水印
    fig.text(0.95, 0.05, f'Team Review {datetime.now().date()}',
             fontsize=12, color='gray', alpha=0.5,
             ha='right', va='bottom', rotation='vertical')
    
    return fig

9.2 验证知识库构建

使用Jupyter Notebook构建可交互的知识库：

python复制from IPython.display import display, Markdown
import pandas as pd

class ValidationKB:
    def __init__(self):
        self.cases = []
        
    def add_case(self, description, plot_func, data, tags):
        fig = plot_func(*data)
        buf = io.BytesIO()
        fig.savefig(buf, format='png')
        buf.seek(0)
        img_str = base64.b64encode(buf.read()).decode('utf-8')
        
        self.cases.append({
            'description': description,
            'image': img_str,
            'tags': tags,
            'date': datetime.now()
        })
    
    def show_by_tag(self, tag):
        display(Markdown(f"## Cases tagged '{tag}'"))
        for case in [c for c in self.cases if tag in c['tags']]:
            display(Markdown(case['description']))
            display(Markdown(f"![img](data:image/png;base64,{case['image']})"))
            display(Markdown(f"*{case['date']}*  \nTags: {', '.join(case['tags'])}"))
            display(Markdown("---"))

这种知识库可以帮助团队：

积累常见问题的识别模式
新成员快速学习验证方法
建立统一的验证标准

10. 前沿验证技术探索

10.1 对抗样本验证

对于安全敏感场景，需要验证模型对抗攻击的鲁棒性：

python复制import torch
import torchattacks

def adversarial_validation(model, X, y, epsilon=0.1):
    # 转换模型为PyTorch格式（假设已有转换工具）
    torch_model = convert_to_torch(model)
    attack = torchattacks.PGD(torch_model, eps=epsilon)
    
    # 生成对抗样本
    adv_X = attack(torch.Tensor(X), torch.Tensor(y))
    
    # 计算原始和对抗准确率
    orig_acc = accuracy_score(y, model.predict(X))
    adv_acc = accuracy_score(y, model.predict(adv_X.numpy()))
    
    # 可视化对比
    fig, ax = plt.subplots(1, 2, figsize=(12, 5))
    ax[0].imshow(X[0].reshape(28,28), cmap='gray')
    ax[0].set_title(f'Original (Acc: {orig_acc:.2f})')
    ax[1].imshow(adv_X[0].numpy().reshape(28,28), cmap='gray')
    ax[1].set_title(f'Adversarial (Acc: {adv_acc:.2f})')
    
    return fig, {'original_accuracy': orig_acc, 'adversarial_accuracy': adv_acc}

10.2 概念漂移检测

对于长期运行的模型，需要监控数据分布变化：

python复制from alibi_detect import KSDrift

def setup_drift_detector(X_train, p_val=0.05):
    # 初始化检测器
    detector = KSDrift(
        X_train,
        p_val=p_val,
        preprocess_fn=lambda x: x.reshape(x.shape[0], -1)
    )
    
    # 返回检测函数
    def detect_drift(X_new):
        preds = detector.predict(X_new)
        return {
            'drift_detected': preds['data']['is_drift'],
            'p_val': preds['data']['p_val'],
            'distance': preds['data']['distance']
        }
    
    return detect_drift

def plot_drift_history(drift_history):
    fig, ax = plt.subplots(figsize=(10, 5))
    
    # 提取历史记录
    dates = [d['date'] for d in drift_history]
    distances = [d['distance'] for d in drift_history]
    p_vals = [d['p_val'] for d in drift_history]
    
    # 绘制距离曲线
    ax.plot(dates, distances, 'b-', label='KS Distance')
    ax.set_ylabel('Distance', color='b')
    ax.tick_params(axis='y', labelcolor='b')
    
    # 添加p-value阈值线
    ax2 = ax.twinx()
    ax2.plot(dates, p_vals, 'r--', label='p-value')
    ax2.axhline(drift_history[0]['p_val_thresh'], color='k', linestyle=':')
    ax2.set_ylabel('p-value', color='r')
    ax2.tick_params(axis='y', labelcolor='r')
    
    # 标记漂移点
    drift_dates = [d['date'] for d in drift_history if d['drift_detected']]
    for date in drift_dates:
        ax.axvline(date, color='g', alpha=0.3)
    
    ax.set_title('Concept Drift Monitoring')
    fig.tight_layout()
    return fig