学习曲线与验证曲线

一句话概述

学习曲线（Learning Curve）和验证曲线（Validation Curve）是诊断模型性能的两大可视化工具。学习曲线展示模型性能随训练样本数量增加的变化趋势——训练误差和验证误差的收敛情况可以诊断过拟合、欠拟合和数据需求。验证曲线展示模型性能随某个超参数变化的变化趋势——帮助找到最优超参数值，同时观察过拟合和欠拟合的边界。它们是模型调优的「心电图」，让数据科学家看到模型在「哪里」出了问题。

💡 核心要点：① 学习曲线诊断「数据够不够」和「模型是否过拟合/欠拟合」② 验证曲线诊断「超参数选得对不对」③ 高方差（过拟合）的表现：训练误差低、验证误差高，两条曲线间距大 ④ 高偏差（欠拟合）的表现：训练误差和验证误差都高，且两条曲线接近

教学与演示

一、学习曲线

是什么：学习曲线（Learning Curve）以训练样本数量为 x 轴，以模型性能（误差或准确率）为 y 轴，分别绘制训练集和验证集上的性能曲线。随着训练样本增加，训练误差通常逐渐上升（更难拟合所有数据），验证误差逐渐下降（更多数据 → 更好的泛化）。两条曲线的收敛状态揭示了模型的状态。

大白话 学习曲线就像「学生的学习成长曲线」——随着做了越来越多的练习题（训练样本），他的做题能力（训练误差）和考试能力（验证误差）都有什么变化？如果练习题做得很好但考试很差，说明他在「死记硬背」（过拟合）；如果两样都很差，说明他「还没学会」（欠拟合）。

为什么：学习曲线的诊断逻辑基于偏差-方差权衡：① 高偏差（欠拟合）——训练误差和验证误差都很高，且两条曲线接近（增加数据帮助不大），② 高方差（过拟合）——训练误差低、验证误差高，两条曲线之间存在大的 gap（增加数据可能有帮助），③ 理想情况——训练误差和验证误差都较低，且收敛到相近的水平。

怎么做：

import numpy as np

# ========== 学习曲线生成与诊断 ==========
np.random.seed(42)

def learning_curve_demo():
    """生成学习曲线并诊断模型状态"""
    n_samples = 300
    n_features = 20
    
    # 生成数据：只有 5 个特征相关
    X = np.random.randn(n_samples, n_features)
    true_coef = np.zeros(n_features)
    true_coef[:5] = np.array([1.5, 1.0, 0.8, 0.5, 0.3])
    y = X @ true_coef + np.random.randn(n_samples) * 0.5
    
    # 划分训练/验证集
    split = int(n_samples * 0.7)
    X_train, X_val = X[:split], X[split:]
    y_train, y_val = y[:split], y[split:]
    
    # 模拟不同训练集大小下的学习曲线
    train_sizes = [10, 20, 40, 80, 150, split]
    
    print("=== 学习曲线（Learning Curve）===")
    print(f"总特征: {n_features}, 相关特征: 5")
    print(f"训练集: {split}, 验证集: {n_samples - split}")
    print()
    
    # 场景1：简单模型（线性回归，可能欠拟合）
    print("--- 场景1：简单线性回归 ---")
    train_errors = []
    val_errors = []
    
    for size in train_sizes:
        # 使用前 size 个训练样本
        X_sub = X_train[:size]
        y_sub = y_train[:size]
        
        # 线性回归（最小二乘解）
        w = np.linalg.lstsq(np.column_stack([np.ones(size), X_sub]), y_sub, rcond=None)[0]
        
        # 训练误差
        train_pred = np.column_stack([np.ones(size), X_sub]) @ w
        train_err = np.mean((y_sub - train_pred) ** 2)
        train_errors.append(train_err)
        
        # 验证误差
        val_pred = np.column_stack([np.ones(len(y_val)), X_val]) @ w
        val_err = np.mean((y_val - val_pred) ** 2)
        val_errors.append(val_err)
    
    print(f"{'训练样本':<10} {'训练 MSE':<12} {'验证 MSE':<12} {'诊断'}")
    for i, size in enumerate(train_sizes):
        gap = val_errors[i] - train_errors[i]
        if val_errors[i] < 0.5 and gap < 0.3:
            diag = "良好"
        elif val_errors[i] > 1.0 and gap < 0.3:
            diag = "欠拟合"
        elif gap > 0.5:
            diag = "过拟合"
        else:
            diag = "适中"
        print(f"{size:<10} {train_errors[i]:<12.4f} {val_errors[i]:<12.4f} {diag}")
    
    # 场景2：复杂模型（高阶多项式，可能过拟合）
    print("\n--- 场景2：高阶多项式（degree=10）---")
    train_errors_poly = []
    val_errors_poly = []
    
    for size in train_sizes:
        X_sub = X_train[:size, :3]  # 只用前3个特征（避免维度爆炸）
        y_sub = y_train[:size]
        X_val_sub = X_val[:, :3]
        
        # 生成多项式特征（degree=2）
        X_poly = np.column_stack([
            np.ones(size),
            X_sub[:, 0], X_sub[:, 1], X_sub[:, 2],
            X_sub[:, 0]**2, X_sub[:, 1]**2, X_sub[:, 2]**2,
            X_sub[:, 0]*X_sub[:, 1], X_sub[:, 0]*X_sub[:, 2], X_sub[:, 1]*X_sub[:, 2]
        ])
        X_val_poly = np.column_stack([
            np.ones(len(y_val)),
            X_val_sub[:, 0], X_val_sub[:, 1], X_val_sub[:, 2],
            X_val_sub[:, 0]**2, X_val_sub[:, 1]**2, X_val_sub[:, 2]**2,
            X_val_sub[:, 0]*X_val_sub[:, 1], X_val_sub[:, 0]*X_val_sub[:, 2], X_val_sub[:, 1]*X_val_sub[:, 2]
        ])
        
        w = np.linalg.lstsq(X_poly, y_sub, rcond=None)[0]
        train_err = np.mean((y_sub - X_poly @ w) ** 2)
        val_err = np.mean((y_val - X_val_poly @ w) ** 2)
        train_errors_poly.append(train_err)
        val_errors_poly.append(val_err)
    
    print(f"{'训练样本':<10} {'训练 MSE':<12} {'验证 MSE':<12} {'诊断'}")
    for i, size in enumerate(train_sizes):
        gap = val_errors_poly[i] - train_errors_poly[i]
        if gap > 0.5:
            diag = "过拟合"
        elif val_errors_poly[i] > 1.0:
            diag = "欠拟合"
        else:
            diag = "良好"
        print(f"{size:<10} {train_errors_poly[i]:<12.4f} {val_errors_poly[i]:<12.4f} {diag}")

learning_curve_demo()

大白话 看学习曲线就像看「心电图」——训练误差和验证误差之间的 gap 就是「异常信号」。gap 大 → 过拟合（模型在训练时「记住」了数据，但考试时不会用），gap 小但两条线都在高位 → 欠拟合（模型太简单，学不会）。

什么用：学习曲线是判断「是否需要更多数据」的最直接工具。如果验证误差在训练样本数增加时仍在下降，说明收集更多数据可能有帮助。如果验证误差已经趋于平稳（收敛），增加数据帮助不大。在工业项目中，学习曲线帮助决策：是继续标注数据，还是改进模型架构。

哪些坑：学习曲线对随机性敏感——不同随机种子可能得到不同的曲线。建议使用交叉验证来生成学习曲线（每个训练集大小取多次评估的平均值）。学习曲线在数据量很少时不稳定（方差大），需要谨慎解读。

二、验证曲线

是什么：验证曲线（Validation Curve）以某个超参数为 x 轴，以模型性能为 y 轴，分别绘制训练集和验证集上的性能。与学习曲线不同，训练样本数固定，变化的只是超参数值。验证曲线帮助找到最优超参数值，同时观察超参数对过拟合/欠拟合的影响。

大白话 验证曲线就像「调节旋钮看效果」——当你拧动某个参数旋钮（如模型复杂度），训练效果和验证效果各有什么变化？找到那个「验证效果最好」的位置，就是最优参数。

为什么：验证曲线的诊断价值在于：超参数向一个方向变化时，训练误差和验证误差的 gap 会变化。例如，增大决策树深度 → 训练误差下降、验证误差先降后升 → 最优深度在验证误差最低点。这种「U 形」验证误差曲线是超参数调优的经典模式，直观展示了欠拟合→最优→过拟合的过渡。

怎么做：

import numpy as np

# ========== 验证曲线生成与诊断 ==========
np.random.seed(42)

def validation_curve_demo():
    """生成验证曲线并诊断最优超参数"""
    n_samples = 200
    n_features = 10
    
    # 生成数据
    X = np.random.randn(n_samples, n_features)
    y = (X[:, 0] * 3 + X[:, 1] * 2 + X[:, 2] * 1 + 
         np.random.randn(n_samples) * 0.5 > 0).astype(int)
    
    # 划分训练/验证集
    split = int(n_samples * 0.7)
    X_train, X_val = X[:split], X[split:]
    y_train, y_val = y[:split], y[split:]
    
    print("=== 验证曲线（Validation Curve）===")
    print(f"超参数: 决策树最大深度（max_depth）")
    print(f"训练集: {split}, 验证集: {n_samples - split}")
    print()
    
    # 模拟不同 max_depth 下的性能
    def simple_tree_accuracy(X_train, y_train, X_val, y_val, max_depth):
        """
        模拟决策树在不同深度下的性能
        浅树 → 欠拟合，深树 → 过拟合
        """
        n_features = X_train.shape[1]
        # 用特征0的多个分位数来模拟树的分裂
        thresholds = np.linspace(X_train[:, 0].min(), X_train[:, 0].max(), 2**max_depth + 1)
        
        # 训练准确率：深度越大，拟合越好（但可能过拟合）
        train_base = 0.65 + 0.15 * (1 - np.exp(-max_depth / 2))
        # 验证准确率：先升后降（U 形）
        val_base = 0.65 + 0.12 * (1 - np.exp(-max_depth / 2)) - 0.02 * max_depth
        
        # 添加噪声
        train_acc = train_base + np.random.randn() * 0.02
        val_acc = val_base + np.random.randn() * 0.02
        
        return np.clip(train_acc, 0, 1), np.clip(val_acc, 0, 1)
    
    depths = [1, 2, 3, 4, 5, 6, 7, 8, 10, 15, 20]
    train_scores = []
    val_scores = []
    
    print(f"{'max_depth':<12} {'训练准确率':<12} {'验证准确率':<12} {'诊断'}")
    best_val = 0
    best_depth = 0
    
    for depth in depths:
        train_acc, val_acc = simple_tree_accuracy(X_train, y_train, X_val, y_val, depth)
        train_scores.append(train_acc)
        val_scores.append(val_acc)
        
        if val_acc > best_val:
            best_val = val_acc
            best_depth = depth
        
        gap = train_acc - val_acc
        if gap > 0.10:
            diag = "过拟合"
        elif train_acc < 0.70:
            diag = "欠拟合"
        else:
            diag = "最优区域"
        
        marker = " ← 最优" if depth == best_depth else ""
        print(f"{depth:<12} {train_acc:<12.3f} {val_acc:<12.3f} {diag}{marker}")
    
    print(f"\n最优 max_depth = {best_depth} (验证准确率 = {best_val:.3f})")
    print(f"\n验证曲线的典型模式:")
    print(f"  欠拟合区域: 训练和验证准确率都低，gap 小")
    print(f"  最优区域: 验证准确率达到峰值")
    print(f"  过拟合区域: 训练准确率继续升，验证准确率下降，gap 增大")

validation_curve_demo()

大白话 验证曲线就是「参数调优的导航图」——告诉你往哪个方向调整参数能提升效果，以及什么时候该停手（过了最优值反而会变差）。它把「试错」变成了「参考地图」。

什么用：验证曲线是超参数调优的「先导步骤」——在正式调优前，先画验证曲线了解每个参数的大致有效范围，可以缩小搜索空间，提高调优效率。在工业中，验证曲线帮助快速判断模型对各个超参数的敏感度——如果验证曲线很平，说明该参数不重要，可以固定为默认值。

哪些坑：单次验证曲线可能受随机性影响较大——建议使用交叉验证的均值（带误差棒）来绘制。验证曲线的 x 轴分辨率取决于评估点的数量——太稀疏可能错过最优值，太密集计算成本高。验证曲线只展示单个超参数的影响，忽略了参数之间的交互效应。

三、学习曲线与验证曲线的联合诊断

是什么：学习曲线和验证曲线联合使用，可以全面诊断模型的性能问题。学习曲线回答「数据够不够」和「模型是否过拟合」，验证曲线回答「超参数选得对不对」。两者结合，可以系统性地定位问题和指导改进方向。

大白话 学习曲线是「纵览全局」（看数据量的影响），验证曲线是「聚焦细节」（看某个参数的影响）。就像医生看病——学习曲线是「体检报告」（整体健康状况），验证曲线是「专项检查」（某个指标的具体问题）。

为什么：不同诊断结果对应不同的改进策略：① 学习曲线显示高偏差 + 验证曲线显示模型太简单 → 增加模型复杂度，② 学习曲线显示高方差 + 验证曲线显示模型太复杂 → 降低复杂度或增加正则化，③ 学习曲线显示验证误差仍在下降 → 收集更多数据，④ 验证曲线很平 → 该参数不重要，无需精细调优。

怎么做：

import numpy as np

# ========== 联合诊断决策树 ==========
def joint_diagnosis_demo():
    """演示学习曲线和验证曲线的联合诊断"""
    print("=== 学习曲线 + 验证曲线联合诊断 ===")
    print()
    
    print("诊断决策树：")
    print()
    
    diagnoses = [
        ("学习曲线: 训练误差高, 验证误差高, gap小", "验证曲线: 参数往复杂方向, 验证误差下降",
         "欠拟合", "增加模型复杂度（更多特征、更深层、更复杂算法）"),
        ("学习曲线: 训练误差低, 验证误差高, gap大", "验证曲线: 参数往复杂方向, 验证误差上升",
         "过拟合", "降低复杂度/增加正则化/收集更多数据"),
        ("学习曲线: 训练误差和验证误差都收敛到低值", "验证曲线: 有明显的最优点",
         "良好", "维持当前配置，可在最优参数附近微调"),
        ("学习曲线: 验证误差仍在下降", "验证曲线: 无明显最优点",
         "数据不足", "收集更多训练数据"),
        ("学习曲线: 训练误差和验证误差都高, 收敛但gap大", "验证曲线: 参数变化对性能影响小",
         "数据质量/特征问题", "改进特征工程/清洗数据/检查标签质量"),
    ]
    
    for i, (lc, vc, diagnosis, action) in enumerate(diagnoses):
        print(f"情况{i+1}:")
        print(f"  {lc}")
        print(f"  {vc}")
        print(f"  → 诊断: {diagnosis}")
        print(f"  → 建议: {action}")
        print()

joint_diagnosis_demo()

# ===== 实用建议 =====
print("=== 实用建议 ===")
print("1. 永远先画学习曲线——它是诊断模型问题的「第一站」")
print("2. 验证曲线帮助确定每个超参数的合理搜索范围")
print("3. 在调优前，用验证曲线排除不重要的超参数")
print("4. 学习曲线和验证曲线都应使用交叉验证来减少随机性")
print("5. 使用带误差棒（±1 std）的曲线，而非单次评估结果")

大白话 学习曲线和验证曲线是模型调优的「左右眼」——闭上一只眼，你只能看到问题的一半。两只眼同时睁开，才能看到问题的全貌，做出正确的诊断。

概念关系图谱

重点答疑

Q1: 学习曲线中训练误差和验证误差的 gap 很大说明什么？

这说明模型过拟合（高方差）——模型在训练数据上表现很好（训练误差低），但在未见过的验证数据上表现差（验证误差高）。模型的复杂度过高，拟合了训练数据中的噪声而非真实模式。解决方案：① 降低模型复杂度，② 增加正则化，③ 收集更多训练数据，④ 使用数据增强。

Q2: 学习曲线显示验证误差已收敛，但误差仍然很高，怎么办？

这说明模型欠拟合（高偏差）——模型太简单，无法捕捉数据的真实模式。增加训练数据不会有帮助（因为曲线已收敛，更多数据不会改变误差水平）。解决方案：① 增加模型复杂度（更深的网络、更多特征），② 使用更复杂的算法，③ 添加更多有信息量的特征，④ 减少正则化强度。

Q3: 验证曲线和学习曲线应该先画哪个？

建议先画学习曲线，因为它回答的是基础问题——「模型是否过拟合/欠拟合？数据是否充足？」。如果学习曲线显示欠拟合，验证曲线中追求更简单的模型就没有意义。如果学习曲线显示过拟合，验证曲线可以帮你找到合适的正则化强度。先「诊断」再「开药方」。

章节单词汇总