超参数调优：网格搜索、随机搜索、贝叶斯优化

一句话概述

超参数调优（Hyperparameter Tuning）是机器学习中「从 90 分到 95 分」的关键环节。网格搜索（Grid Search）暴力遍历所有参数组合，适合参数空间小的情况；随机搜索（Random Search）在参数空间中随机采样，效率更高且能发现网格搜索遗漏的好点；贝叶斯优化（Bayesian Optimization）通过构建代理模型智能地选择下一个评估点，在大参数空间中效率最高。超参数调优的核心是：在有限的计算预算下，找到使验证集性能最大化的参数组合。

💡 核心要点：① 超参数是在训练前设定的参数（如学习率、树深度），与模型参数（如权重）不同 ② 网格搜索适合小参数空间（≤3 个参数），随机搜索适合中等参数空间，贝叶斯优化适合大参数空间 ③ 贝叶斯优化通过高斯过程代理模型，智能平衡「探索」和「利用」④ 超参数调优必须使用交叉验证，不能直接在测试集上调参

教学与演示

一、网格搜索（Grid Search）

是什么：网格搜索是最简单直接的超参数调优方法——为每个超参数指定一组候选值，然后遍历所有可能的参数组合，通过交叉验证评估每组参数的性能，最终选择性能最优的组合。例如，learning_rate ∈ {0.01, 0.1, 1.0}，max_depth ∈ {3, 5, 7}，共 3×3=9 种组合。

大白话 网格搜索就是「地毯式搜索」——把所有可能的参数组合都试一遍，看哪个最好。优点是绝对不会漏掉，缺点是参数多了组合数爆炸，试不过来。

为什么：网格搜索的优点是简单、可并行、结果确定（不会遗漏网格内的最优组合）。缺点是「维度灾难」——参数数量和候选值数量呈指数增长。如果 5 个参数各 10 个候选值，就有 10^5=100,000 种组合，即使每次训练只需 1 分钟，也需要约 70 天。因此网格搜索只适用于参数少（≤3 个）、每个参数候选值也少的情况。

怎么做：

import numpy as np

# ========== 网格搜索演示 ==========
np.random.seed(42)

def grid_search_demo():
    """演示网格搜索的穷举过程"""
    print("=== 网格搜索（Grid Search）===")
    
    # 定义超参数候选值
    param_grid = {
        'learning_rate': [0.01, 0.05, 0.1, 0.5],
        'max_depth': [3, 5, 7],
        'n_estimators': [50, 100, 200],
    }
    
    # 计算总组合数
    n_combinations = 1
    for values in param_grid.values():
        n_combinations *= len(values)
    print(f"参数网格:")
    for name, values in param_grid.items():
        print(f"  {name}: {values} ({len(values)} 个候选值)")
    print(f"总组合数: {n_combinations}")
    print()
    
    # 模拟网格搜索过程
    # 真实性能曲面（模拟）：最优参数在 (0.1, 5, 100)
    def true_performance(lr, depth, n_est):
        """模拟真实性能：最优参数组合得分最高"""
        base = 0.80
        # 距离最优参数越近，性能越好
        lr_dist = (lr - 0.1) ** 2 / 0.01
        depth_dist = (depth - 5) ** 2 / 10
        n_dist = (n_est - 100) ** 2 / 5000
        noise = np.random.randn() * 0.01  # 模拟交叉验证的随机性
        return base - lr_dist - depth_dist - n_dist + noise
    
    # 遍历所有组合
    best_score = -np.inf
    best_params = None
    all_results = []
    
    print("网格搜索过程（显示前 5 个和后 5 个组合）:")
    count = 0
    for lr in param_grid['learning_rate']:
        for depth in param_grid['max_depth']:
            for n_est in param_grid['n_estimators']:
                score = true_performance(lr, depth, n_est)
                all_results.append((lr, depth, n_est, score))
                if score > best_score:
                    best_score = score
                    best_params = (lr, depth, n_est)
                count += 1
                if count <= 5 or count > n_combinations - 5:
                    print(f"  {count:2d}. lr={lr:.2f}, depth={depth}, n_est={n_est:3d} → score={score:.4f}")
                elif count == 6:
                    print(f"  ... (省略中间 {n_combinations - 10} 个组合)")
    
    print(f"\n最优参数: lr={best_params[0]:.2f}, depth={best_params[1]}, n_est={best_params[2]}")
    print(f"最优得分: {best_score:.4f}")
    print(f"\n网格搜索特点:")
    print(f"  优点: 穷举所有组合，不会漏掉网格内的最优解")
    print(f"  缺点: 组合数爆炸 (若10个参数各10个候选值 = 100亿组合)")
    print(f"  适用: 参数数量 ≤ 3，每个参数候选值 ≤ 5")

grid_search_demo()

大白话 网格搜索的问题在于「指数爆炸」——每多一个参数，组合数就翻几倍。3 个参数各 5 个值 = 125 种组合还能接受，但 5 个参数各 10 个值 = 100,000 种组合，根本试不完。这时候就需要更聪明的方法。

二、随机搜索（Random Search）

是什么：随机搜索不是暴力遍历所有组合，而是在参数空间中随机采样指定数量的参数组合进行评估。Bergstra & Bengio（2012）的经典论文证明：在相同的计算预算下，随机搜索通常比网格搜索找到更好的参数组合——因为只有少数参数真正重要，随机搜索在每个参数上探索了更多不同的值。

大白话 网格搜索就像「在棋盘上每隔一格放一个棋子」，随机搜索就像「在棋盘上随机撒一把棋子」。如果只有少数几个格子重要（少数参数重要），随机撒反而更容易碰到好格子。

为什么：随机搜索的理论优势在于：对于只有少数参数重要的场景，网格搜索在重要参数上只探索了有限的几个值，而随机搜索通过随机采样，每个参数都探索了更多不同的值。例如，3 个参数各 10 个候选值，网格搜索在 1000 次评估中每个参数最多探索 10 个值；随机搜索在 60 次评估中，每个参数可能探索 60 个不同的值（远多于 10 个）。

怎么做：

import numpy as np

# ========== 随机搜索演示 ==========
np.random.seed(42)

def random_search_demo():
    """演示随机搜索及其与网格搜索的对比"""
    print("=== 随机搜索（Random Search）===")
    
    # 真实性能：只有 learning_rate 重要，其他参数几乎无关
    def true_performance(lr, depth, n_est):
        """只有 lr 真正重要，depth 和 n_est 影响很小"""
        base = 0.80
        lr_effect = -((lr - 0.1) ** 2) / 0.01  # lr 最重要
        depth_effect = -((depth - 5) ** 2) / 100  # 影响很小
        n_effect = -((n_est - 100) ** 2) / 50000  # 几乎无影响
        noise = np.random.randn() * 0.005
        return base + lr_effect + depth_effect + n_effect + noise
    
    # 网格搜索：仅 4 个 lr 值
    grid_lr = [0.01, 0.05, 0.1, 0.5]
    grid_scores = [true_performance(lr, 5, 100) for lr in grid_lr]
    grid_best = max(grid_scores)
    
    # 随机搜索：在 lr 范围内随机采样 20 个值
    n_random = 20
    random_lr = np.random.uniform(0.001, 0.6, n_random)
    random_scores = [true_performance(lr, 5, 100) for lr in random_lr]
    random_best = max(random_scores)
    
    print(f"真实最优 lr = 0.1")
    print(f"网格搜索（4 个 lr 值）: 最优得分 = {grid_best:.4f}")
    print(f"  评估的 lr: {grid_lr}")
    print(f"随机搜索（{n_random} 个 lr 值）: 最优得分 = {random_best:.4f}")
    print(f"  评估的 lr 范围: [{random_lr.min():.3f}, {random_lr.max():.3f}]")
    
    print(f"\n随机搜索优势: {random_best - grid_best:.4f} (得分提升)")
    print(f"原因: 随机搜索在 lr 上尝试了 {n_random} 个不同的值")
    print(f"      网格搜索在 lr 上只尝试了 {len(grid_lr)} 个值")
    print(f"      如果 lr 很重要，更多探索 → 更可能找到最优值")
    
    print(f"\n随机搜索特点:")
    print(f"  优点: 在重要参数上探索更多值，效率更高")
    print(f"  缺点: 可能漏掉参数空间中的某些区域")
    print(f"  适用: 参数数量 3-10，计算预算有限")
    print(f"  经典结论: 60 次随机搜索 ≈ 1000 次网格搜索的效果")

random_search_demo()

大白话 随机搜索的「魔法」在于：大多数参数其实不重要，只有少数几个参数对性能有显著影响。随机搜索让每个参数都尝试了更多不同的值，所以在重要参数上更容易碰巧找到好值。60 次随机搜索的效果往往堪比 1000 次网格搜索。

三、贝叶斯优化

是什么：贝叶斯优化（Bayesian Optimization）是最高效的超参数调优方法。它不盲目搜索，而是构建一个「代理模型」（通常是高斯过程）来近似超参数与性能之间的关系，然后根据代理模型智能地选择下一个最值得评估的参数组合。核心思想是使用采集函数（Acquisition Function）平衡「探索」（探索不确定性高的区域）和「利用」（在已知好的区域附近精调）。

大白话 贝叶斯优化就像一个有经验的「寻宝者」——不是盲目挖坑，而是根据已挖过的坑的收获，推测哪里最可能有宝藏，然后去那个地方挖。它既会去「看起来最有希望」的地方（利用），也会去「还没探索过」的地方（探索），避免错过宝藏。

为什么：贝叶斯优化的核心组件是：① 高斯过程代理模型——对目标函数 f(x) 提供概率预测（均值 μ(x) 和不确定度 σ(x)），② 采集函数——根据代理模型的预测，决定下一个评估点。最常用的采集函数是 Expected Improvement (EI)：EI(x) = E[max(f(x) − f_best, 0)]，它衡量在 x 点评估后预期的改进量。EI 高意味着要么预测值高（利用），要么不确定度高（探索）。

怎么做：

import numpy as np

# ========== 贝叶斯优化演示 ==========
np.random.seed(42)

def bayesian_optimization_demo():
    """演示贝叶斯优化的核心原理"""
    print("=== 贝叶斯优化（Bayesian Optimization）===")
    
    # 真实性能函数（未知，贝叶斯优化试图学习它）
    def true_performance(lr, depth):
        """真实性能曲面：两个参数都有影响"""
        # 最优参数在 lr=0.1, depth=5
        lr_effect = -((lr - 0.1) ** 2) / 0.005
        depth_effect = -((depth - 5) ** 2) / 5
        interaction = 0.02 * (lr - 0.1) * (depth - 5)  # 交互项
        noise = np.random.randn() * 0.01
        return 0.85 + lr_effect + depth_effect + interaction + noise
    
    # 简化版高斯过程：用加权平均模拟
    def gp_predict(x_new, X_known, y_known, length_scale=0.05):
        """
        简化的高斯过程预测
        返回: (预测均值, 预测标准差)
        """
        if len(X_known) == 0:
            return 0.5, 0.5  # 无信息先验
        
        # 计算新点与已知点的相似度（RBF 核）
        distances = np.abs(x_new - X_known)
        weights = np.exp(-0.5 * (distances / length_scale) ** 2)
        
        # 预测均值 = 加权平均
        mean = np.sum(weights * y_known) / (np.sum(weights) + 1e-10)
        # 预测标准差 = 1 - 最大权重（近似的）
        std = 1.0 / (np.sum(weights) + 1e-10)
        std = np.clip(std, 0.01, 0.5)
        
        return mean, std
    
    # 采集函数：Expected Improvement
    def expected_improvement(mean, std, y_best):
        """计算 Expected Improvement"""
        if std < 1e-10:
            return 0.0
        z = (mean - y_best) / std
        # 标准正态的 PDF 和 CDF 近似
        from math import erf, exp, sqrt, pi
        phi = exp(-0.5 * z**2) / sqrt(2 * pi)  # PDF
        Phi = 0.5 * (1 + erf(z / sqrt(2)))    # CDF
        return std * (z * Phi + phi)
    
    # 模拟贝叶斯优化迭代
    n_iterations = 10
    X_known = []  # 已知评估点
    y_known = []  # 已知评估值
    
    # 初始随机采样 2 个点
    X_known = [0.05, 0.3]
    y_known = [true_performance(x, 5) for x in X_known]
    
    print(f"初始点: {X_known}")
    print(f"初始值: {[f'{y:.4f}' for y in y_known]}")
    print()
    
    best_y = max(y_known)
    
    for iteration in range(1, n_iterations + 1):
        # 在密集网格上计算 EI
        x_candidates = np.linspace(0.01, 0.5, 100)
        ei_values = []
        
        for x in x_candidates:
            mean, std = gp_predict(x, np.array(X_known), np.array(y_known))
            ei = expected_improvement(mean, std, best_y)
            ei_values.append(ei)
        
        # 选择 EI 最大的点
        best_idx = np.argmax(ei_values)
        x_next = x_candidates[best_idx]
        y_next = true_performance(x_next, 5)
        
        X_known.append(x_next)
        y_known.append(y_next)
        
        if y_next > best_y:
            best_y = y_next
        
        if iteration <= 3 or iteration >= n_iterations - 1:
            print(f"迭代{iteration:2d}: 评估 lr={x_next:.3f} → score={y_next:.4f}, "
                  f"当前最优={best_y:.4f}")
    
    print(f"\n贝叶斯优化最终结果:")
    best_idx = np.argmax(y_known)
    print(f"  最优 lr = {X_known[best_idx]:.3f}, score = {y_known[best_idx]:.4f}")
    print(f"  真实最优 lr = 0.100")
    print(f"  总评估次数: {len(X_known)}")
    print(f"\n贝叶斯优化特点:")
    print(f"  优点: 效率最高，评估次数最少")
    print(f"  缺点: 实现复杂，串行评估（难以并行化）")
    print(f"  适用: 参数空间大，每次评估成本高（如深度学习训练）")

bayesian_optimization_demo()

大白话 贝叶斯优化就像一个「有记忆的寻宝者」——它记得之前在哪挖过、挖到了什么，然后根据这些信息推测下一个最有希望的地点。它不会在同一个地方重复挖（利用已知信息），也不会去完全没去过的地方乱挖（探索未知），而是找到一个最佳的平衡点。

什么用：在 AI 工业中，超参数调优策略的选择取决于计算预算和参数空间大小：① 小参数空间（≤3 个参数）→ 网格搜索，② 中等参数空间（3-10 个参数）→ 随机搜索，③ 大参数空间（>10 个参数）或评估成本高 → 贝叶斯优化。Hyperopt、Optuna 和 Ray Tune 等库提供了这些方法的工业级实现。深度学习中，贝叶斯优化常用于学习率、批量大小、网络层数等超参数的调优。

哪些坑：超参数调优必须在验证集上进行，绝对不能使用测试集（否则会导致对测试集过拟合的乐观估计）。调优时应该使用交叉验证而非单次验证集划分，以减少随机性。搜索空间的选择至关重要——如果最优参数不在搜索空间内，任何方法都找不到。贝叶斯优化对代理模型和采集函数的选择敏感，且难以并行化（但 Batch Bayesian Optimization 可以缓解）。

概念关系图谱

重点答疑

Q1: 超参数调优应该在什么数据上进行？

在验证集上，绝对不能在测试集上。正确流程：训练集 → 交叉验证调参 → 选择最优参数 → 在完整训练集上重新训练 → 测试集上最终评估。测试集只能使用一次（最终评估），如果反复用测试集调参，会导致对测试集的过拟合，失去泛化性能评估的意义。

Q2: 随机搜索为什么比网格搜索更有效？

Bergstra & Bengio(2012) 的经典分析：大多数超参数对性能的影响很小，只有少数几个参数真正重要。网格搜索在重要参数上只探索了有限个值（如 5 个），而随机搜索在相同预算下，每个参数都能探索更多不同的值。如果 1 个重要参数有 10 个候选值，网格搜索可能只探索了 3 个，随机搜索可能探索了 60 个——找到好值的概率更高。

Q3: 贝叶斯优化的计算开销主要在哪里？

主要在：① 高斯过程推断——每步需要 O(n³) 的时间复杂度（n 是已评估点的数量），当 n 较大时成为瓶颈，② 采集函数优化——需要在参数空间中搜索 EI 最大的点，对于高维空间需要全局优化算法，③ 串行评估——每次只能评估一个点。实践中的解决方案：使用稀疏高斯过程（降低复杂度）、Batch Bayesian Optimization（并行评估多个点）、多保真度优化（先用低保真度评估筛选）。

章节单词汇总