Optuna贝叶斯优化：高效超参数调优实战指南

1. 为什么我们需要贝叶斯优化？

在机器学习模型训练过程中，超参数调优一直是个令人头疼的问题。传统网格搜索(Grid Search)和随机搜索(Random Search)方法虽然简单直接，但效率低下，特别是在参数空间较大时。我曾经在一个包含12个超参数的深度学习项目中尝试网格搜索，结果跑了整整三天三夜才完成一轮调参，这种体验简直让人崩溃。

贝叶斯优化(Bayesian Optimization)提供了一种更聪明的解决方案。它通过构建目标函数的概率模型（通常使用高斯过程），利用已有的评估结果指导下一次参数选择。简单来说，就是"学着调参"——每次试验后都会根据结果调整对目标函数的理解，并选择最有希望的区域进行下一次尝试。

实际经验：在图像分类任务中，使用贝叶斯优化通常能在50-100次试验内找到接近最优的参数组合，而随机搜索可能需要300-500次才能达到相似效果。

2. Optuna框架核心解析

2.1 Optuna的架构设计

Optuna是一个专为超参数优化设计的Python框架，其核心架构包含三个关键组件：

1. Study：整个优化过程的容器，记录所有试验(trials)和结果
2. Trial：单次参数评估的上下文，负责参数生成和目标值记录
3. Sampler：决定如何选择下一组参数的算法引擎

这种设计使得Optuna非常灵活，可以轻松扩展到各种优化场景。我特别喜欢它的"先定义后运行"模式——先创建目标函数，再启动优化过程，这种设计让代码结构特别清晰。

2.2 目标函数定义技巧

定义良好的目标函数是成功调参的关键。以下是一个典型模式：

python复制import optuna

def objective(trial):
    # 参数空间定义
    lr = trial.suggest_float('lr', 1e-5, 1e-2, log=True)
    batch_size = trial.suggest_categorical('batch_size', [16, 32, 64])
    n_layers = trial.suggest_int('n_layers', 1, 5)
    
    # 模型构建与训练
    model = build_model(lr=lr, batch_size=batch_size, n_layers=n_layers)
    val_loss = train_model(model)
    
    return val_loss

避坑指南：目标函数中不要包含随机种子设置！这会影响优化过程的可靠性。应该在Study层面设置随机种子。

3. 高级调参策略实战

3.1 参数空间设计原则

设计参数空间时需要考虑几个关键因素：

1. 参数相关性：有些参数之间存在依赖关系。例如，当选择特定优化器时，才需要设置该优化器特有的参数。Optuna提供了conditional参数空间支持：

python复制optimizer = trial.suggest_categorical('optimizer', ['adam', 'sgd'])
if optimizer == 'sgd':
    momentum = trial.suggest_float('momentum', 0.0, 0.9)

2. 参数尺度感知：学习率等参数通常需要在log空间采样：

python复制lr = trial.suggest_float('lr', 1e-5, 1e-2, log=True)

3. 参数类型选择：根据参数性质选择合适的采样方法：

• 连续值：suggest_float
• 离散值：suggest_int
• 类别值：suggest_categorical

3.2 并行优化策略

大规模调参通常需要并行执行。Optuna支持多种并行方式：

1. 分布式优化：使用RDB存储后端实现多进程/多机协同

python复制study = optuna.create_study(
    storage='mysql://user:pass@host/db',
    study_name='distributed_example'
)

2. 批处理优化：通过TPESampler的n_startup_trials参数控制初始随机搜索轮数

3. 超时处理：设置单个trial的超时时间，避免卡死

python复制study.optimize(objective, timeout=60*60)  # 1小时超时

实战心得：并行优化时，建议设置n_startup_trials=10*N（N为并行worker数），确保初始探索充分。

4. 可视化与结果分析

4.1 关键可视化工具

Optuna提供了丰富的可视化功能：

1. 参数重要性分析：

python复制optuna.visualization.plot_param_importances(study)

这个图能直观显示哪些参数对模型性能影响最大，对后续参数空间调整很有帮助。

2. 优化历史图：

python复制optuna.visualization.plot_optimization_history(study)

展示优化过程中目标值的变化趋势，可以判断优化是否收敛。

3. 参数关系图：

python复制optuna.visualization.plot_parallel_coordinate(study)

揭示参数组合与目标值之间的关系模式。

4.2 结果持久化与复用

优化结果可以保存为CSV或直接存入数据库：

python复制df = study.trials_dataframe()
df.to_csv('optimization_results.csv')

更专业的做法是使用SQLite或MySQL作为存储后端：

python复制study = optuna.create_study(
    storage='sqlite:///example.db',
    study_name='my_study',
    load_if_exists=True
)

5. 生产环境最佳实践

5.1 早停策略实现

在资源有限的情况下，实现早停(Early Stopping)很有必要：

python复制class EarlyStopping:
    def __init__(self, patience=5):
        self.patience = patience
        self.best_value = None
        self.no_improvement = 0

    def __call__(self, study, trial):
        current_value = trial.value
        if self.best_value is None or current_value < self.best_value:
            self.best_value = current_value
            self.no_improvement = 0
        else:
            self.no_improvement += 1
            if self.no_improvement >= self.patience:
                study.stop()

使用方式：

python复制study.optimize(objective, callbacks=[EarlyStopping(patience=10)])

5.2 多目标优化

有些场景需要平衡多个目标（如精度和推理速度）：

python复制def multi_objective(trial):
    accuracy = train_model(trial)
    latency = measure_latency(trial)
    return accuracy, latency

study = optuna.create_study(directions=['maximize', 'minimize'])
study.optimize(multi_objective, n_trials=100)

5.3 与主流框架集成

1. PyTorch Lightning集成：

python复制from pytorch_lightning.callbacks import Callback

class OptunaPruningCallback(Callback):
    def __init__(self, trial):
        self.trial = trial

    def on_validation_end(self, trainer, pl_module):
        current_score = trainer.callback_metrics['val_loss']
        self.trial.report(current_score, step=trainer.current_epoch)
        if self.trial.should_prune():
            raise optuna.TrialPruned()

2. TensorFlow/Keras集成：

python复制from tensorflow.keras.callbacks import Callback

class ReportMetrics(Callback):
    def __init__(self, trial):
        super().__init__()
        self.trial = trial

    def on_epoch_end(self, epoch, logs=None):
        self.trial.report(logs['val_loss'], step=epoch)
        if self.trial.should_prune():
            raise optuna.TrialPruned()

6. 常见问题排查

6.1 优化过程不收敛

可能原因及解决方案：

6.2 内存泄漏问题

长时间运行的优化可能遇到内存问题：

1. 定期清理无用变量
2. 使用gc.collect()手动触发垃圾回收
3. 考虑使用multiprocessing而非多线程

6.3 结果复现性

确保结果可复现的关键点：

1. 在Study层面设置随机种子：

python复制study = optuna.create_study(sampler=optuna.samplers.TPESampler(seed=42))

2. 在目标函数中避免使用全局随机状态

3. 记录完整的参数配置和代码版本

7. 性能优化技巧

7.1 加速评估过程

1. 缓存机制：对计算密集型部分实现缓存

python复制from functools import lru_cache

@lru_cache(maxsize=None)
def expensive_computation(params):
    # 耗时计算
    return result

2. 提前终止：使用Optuna的剪枝功能

python复制def objective(trial):
    for epoch in range(100):
        train_epoch()
        score = validate()
        trial.report(score, epoch)
        if trial.should_prune():
            raise optuna.TrialPruned()
    return score

7.2 参数空间缩减策略

1. 先进行大范围粗调，锁定有希望的区域
2. 然后在小范围内精细调整
3. 对重要参数给予更大搜索空间

python复制def objective(trial):
    # 第一阶段：粗调
    if trial.number < 20:
        lr = trial.suggest_float('lr', 1e-6, 1e-1, log=True)
    else:  # 第二阶段：精调
        lr = trial.suggest_float('lr', 1e-4, 1e-3, log=True)

8. 实际案例：图像分类任务调优

8.1 项目背景

假设我们有一个ResNet50图像分类任务，需要优化的参数包括：

• 学习率及调度器参数
• 数据增强策略
• 批大小
• 权重衰减系数
• Dropout率

8.2 完整优化代码

python复制import torch
import optuna
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

def define_model(trial):
    dropout = trial.suggest_float('dropout', 0.0, 0.5)
    n_layers = trial.suggest_int('n_layers', 1, 3)
    
    layers = []
    in_features = 2048  # ResNet50最后一层特征维度
    for i in range(n_layers):
        out_features = trial.suggest_int(f'n_units_{i}', 64, 1024)
        layers.append(torch.nn.Linear(in_features, out_features))
        layers.append(torch.nn.ReLU())
        layers.append(torch.nn.Dropout(dropout))
        in_features = out_features
    layers.append(torch.nn.Linear(in_features, 10))  # 假设10类分类
    
    return torch.nn.Sequential(*layers)

def get_data_loaders(trial):
    batch_size = trial.suggest_categorical('batch_size', [32, 64, 128])
    
    transform = transforms.Compose([
        transforms.RandomHorizontalFlip(
            p=trial.suggest_float('flip_p', 0.0, 1.0)),
        transforms.RandomRotation(
            degrees=trial.suggest_int('rotation', 0, 30)),
        transforms.ToTensor(),
    ])
    
    train_set = datasets.CIFAR10(root='./data', train=True, 
                                download=True, transform=transform)
    val_set = datasets.CIFAR10(root='./data', train=False,
                              download=True, transform=transform)
    
    train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True)
    val_loader = DataLoader(val_set, batch_size=batch_size, shuffle=False)
    
    return train_loader, val_loader

def objective(trial):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    # 定义模型
    backbone = torch.hub.load('pytorch/vision', 'resnet50', pretrained=True)
    head = define_model(trial).to(device)
    model = torch.nn.Sequential(backbone, head)
    
    # 优化器配置
    lr = trial.suggest_float('lr', 1e-5, 1e-2, log=True)
    weight_decay = trial.suggest_float('weight_decay', 1e-6, 1e-2, log=True)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr, 
                                weight_decay=weight_decay)
    
    # 数据加载
    train_loader, val_loader = get_data_loaders(trial)
    
    # 训练循环
    for epoch in range(10):  # 简化示例，实际应该更多
        model.train()
        for inputs, labels in train_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = torch.nn.functional.cross_entropy(outputs, labels)
            loss.backward()
            optimizer.step()
        
        # 验证
        model.eval()
        correct = 0
        total = 0
        with torch.no_grad():
            for inputs, labels in val_loader:
                inputs, labels = inputs.to(device), labels.to(device)
                outputs = model(inputs)
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()
        
        accuracy = correct / total
        trial.report(accuracy, epoch)
        
        if trial.should_prune():
            raise optuna.TrialPruned()
    
    return accuracy

study = optuna.create_study(direction='maximize', 
                          sampler=optuna.samplers.TPESampler(seed=42))
study.optimize(objective, n_trials=100)

print('最佳准确率:', study.best_value)
print('最佳参数:', study.best_params)

8.3 结果分析

经过100次试验后，我们可能得到类似如下的最佳参数组合：

python复制{
    'dropout': 0.2,
    'n_layers': 2,
    'n_units_0': 512,
    'n_units_1': 256,
    'batch_size': 64,
    'flip_p': 0.5,
    'rotation': 15,
    'lr': 0.0003,
    'weight_decay': 0.0001
}

这个配置在验证集上达到了85.6%的准确率，相比默认参数的78.2%有显著提升。参数重要性分析显示学习率和批大小对结果影响最大，而数据增强参数影响相对较小。

9. 扩展应用场景

9.1 神经网络架构搜索

Optuna不仅可以调参，还能用于神经网络架构搜索(NAS)：

python复制def define_architecture(trial):
    arch = []
    n_layers = trial.suggest_int('n_layers', 1, 5)
    
    for i in range(n_layers):
        layer_type = trial.suggest_categorical(
            f'layer_{i}_type', ['conv', 'pool', 'identity'])
        
        if layer_type == 'conv':
            out_channels = trial.suggest_int(f'layer_{i}_channels', 16, 128)
            kernel_size = trial.suggest_int(f'layer_{i}_kernel', 3, 7, step=2)
            arch.append(('conv', out_channels, kernel_size))
        elif layer_type == 'pool':
            pool_type = trial.suggest_categorical(
                f'layer_{i}_pool', ['max', 'avg'])
            arch.append(('pool', pool_type))
    
    return arch

9.2 特征工程优化

自动化特征选择和变换：

python复制def feature_engineering(trial, X):
    # 特征选择
    if trial.suggest_categorical('do_feature_selection', [True, False]):
        k = trial.suggest_int('n_features', 10, X.shape[1])
        selector = SelectKBest(k=k)
        X = selector.fit_transform(X, y)
    
    # 特征缩放
    scaler_type = trial.suggest_categorical(
        'scaler', ['standard', 'minmax', 'robust', 'none'])
    if scaler_type != 'none':
        scaler = {
            'standard': StandardScaler(),
            'minmax': MinMaxScaler(),
            'robust': RobustScaler()
        }[scaler_type]
        X = scaler.fit_transform(X)
    
    return X

9.3 集成学习优化

优化集成模型的基学习器和组合方式：

python复制def define_ensemble(trial):
    models = []
    n_models = trial.suggest_int('n_models', 2, 5)
    
    for i in range(n_models):
        model_type = trial.suggest_categorical(
            f'model_{i}_type', ['dtree', 'svm', 'mlp'])
        
        if model_type == 'dtree':
            max_depth = trial.suggest_int(f'model_{i}_max_depth', 3, 10)
            models.append(DecisionTreeClassifier(max_depth=max_depth))
        elif model_type == 'svm':
            C = trial.suggest_float(f'model_{i}_C', 0.1, 10, log=True)
            models.append(SVC(C=C))
        else:
            hidden_size = trial.suggest_int(f'model_{i}_hidden', 10, 100)
            models.append(MLPClassifier(hidden_layer_sizes=(hidden_size,)))
    
    voting = trial.suggest_categorical('voting', ['hard', 'soft'])
    return VotingClassifier(estimators=[
        (f'model_{i}', model) for i, model in enumerate(models)
    ], voting=voting)

10. 性能监控与调优

10.1 资源使用监控

大型调参任务需要监控资源使用情况：

python复制import psutil
import time

def monitor_resources(interval=60):
    while True:
        cpu = psutil.cpu_percent()
        mem = psutil.virtual_memory().percent
        print(f'CPU使用率: {cpu}%, 内存使用率: {mem}%')
        time.sleep(interval)

# 在单独的线程中启动监控
import threading
monitor_thread = threading.Thread(target=monitor_resources)
monitor_thread.daemon = True
monitor_thread.start()

10.2 优化过程记录

详细记录每个trial的元数据：

python复制def objective(trial):
    start_time = time.time()
    
    # ...原有优化代码...
    
    end_time = time.time()
    trial.set_user_attr('duration', end_time - start_time)
    trial.set_user_attr('device', str(device))
    return accuracy

之后可以分析这些元数据：

python复制durations = [t.user_attrs['duration'] for t in study.trials]
print(f'平均trial时间: {sum(durations)/len(durations):.2f}s')

10.3 自动化报告生成

使用Optuna的日志功能生成优化报告：

python复制from optuna.logging import get_logger, INFO

# 设置日志级别
get_logger('optuna').setLevel(INFO)

# 优化完成后生成报告
def generate_report(study):
    report = f"""
    Optimization Report
    ==================
    Best value: {study.best_value:.4f}
    Best params: {study.best_params}
    Number of trials: {len(study.trials)}
    Duration: {sum(t.user_attrs.get('duration',0) for t in study.trials):.2f}s
    """
    print(report)

11. 与其他工具的对比

11.1 Optuna vs Hyperopt

11.2 Optuna vs Ray Tune

11.3 选择建议

• 中小型项目：Optuna是绝佳选择
• 大规模分布式：考虑Ray Tune
• 简单任务：Hyperopt可能足够
• 研究新算法：Optuna的灵活架构更适合

12. 前沿发展方向

12.1 多保真度优化

利用低精度评估快速筛选候选参数：

python复制def objective(trial):
    epochs = 5 if trial.number < 20 else 20  # 初期快速评估
    # ...训练代码...

12.2 元学习辅助

利用历史优化结果指导新任务：

python复制study = optuna.create_study(
    sampler=optuna.samplers.TPESampler(
        consider_prior=True,
        prior_weight=1.0,
        consider_magic_clip=True
    )
)

12.3 自动化机器学习管道

将Optuna与AutoML工具结合：

python复制from sklearn.pipeline import Pipeline

def create_pipeline(trial):
    steps = []
    
    # 特征选择
    if trial.suggest_categorical('do_feature_selection', [True, False]):
        selector = SelectKBest(k=trial.suggest_int('n_features', 5, 50))
        steps.append(('feature_selection', selector))
    
    # 分类器选择
    classifier_type = trial.suggest_categorical(
        'classifier', ['logistic', 'svc', 'rf'])
    
    if classifier_type == 'logistic':
        C = trial.suggest_float('logistic_C', 0.1, 10, log=True)
        classifier = LogisticRegression(C=C)
    elif classifier_type == 'svc':
        C = trial.suggest_float('svc_C', 0.1, 10, log=True)
        classifier = SVC(C=C)
    else:
        n_estimators = trial.suggest_int('rf_n_estimators', 10, 200)
        classifier = RandomForestClassifier(n_estimators=n_estimators)
    
    steps.append(('classifier', classifier))
    return Pipeline(steps)

13. 生产部署建议

13.1 模型服务化

将优化后的模型部署为服务：

python复制import flask
import joblib

app = flask.Flask(__name__)
model = joblib.load('optimized_model.pkl')

@app.route('/predict', methods=['POST'])
def predict():
    data = flask.request.json
    features = preprocess(data)
    prediction = model.predict([features])
    return {'prediction': int(prediction[0])}

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

13.2 持续优化框架

建立自动化优化流水线：

python复制from airflow import DAG
from airflow.operators.python_operator import PythonOperator
from datetime import datetime

def run_optimization():
    study = optuna.create_study()
    study.optimize(objective, n_trials=50)
    # 保存最佳模型...

dag = DAG(
    'weekly_optimization',
    schedule_interval='@weekly',
    start_date=datetime(2023, 1, 1)
)

task = PythonOperator(
    task_id='optimize_model',
    python_callable=run_optimization,
    dag=dag
)

13.3 监控与再训练

设置性能监控和自动再训练机制：

python复制def monitor_model_performance():
    current_acc = evaluate_model()
    if current_acc < threshold:
        run_optimization()
        
    # 定期任务
    schedule.every().day.at("02:00").do(monitor_model_performance)
    while True:
        schedule.run_pending()
        time.sleep(60)

14. 实用技巧汇编

14.1 参数空间设计技巧

1. 动态参数空间：根据其他参数值动态调整范围

python复制if trial.suggest_categorical('use_batchnorm', [True, False]):
    bn_momentum = trial.suggest_float('bn_momentum', 0.1, 0.9)

2. 分层采样：对不同类型参数采用不同采样策略

python复制# 连续参数用log均匀采样
lr = trial.suggest_float('lr', 1e-5, 1e-2, log=True)

# 离散参数用均匀采样
units = trial.suggest_int('units', 32, 512)

14.2 优化过程加速技巧

1. 缓存数据加载：避免重复数据预处理

python复制@functools.lru_cache(maxsize=None)
def load_data(config):
    # 数据加载和预处理
    return processed_data

2. 并行数据加载：使用多进程加速

python复制DataLoader(..., num_workers=4, persistent_workers=True)

3. 混合精度训练：减少显存占用

python复制scaler = torch.cuda.amp.GradScaler()
with torch.cuda.amp.autocast():
    outputs = model(inputs)
    loss = criterion(outputs, labels)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

14.3 结果分析技巧

1. 参数相关性分析：

python复制optuna.visualization.plot_contour(study, params=['lr', 'batch_size'])

2. 历史轨迹分析：

python复制optuna.visualization.plot_slice(study, params=['dropout'])

3. 多维参数分析：

python复制optuna.visualization.plot_parallel_coordinate(
    study, params=['lr', 'batch_size', 'dropout'])

15. 资源管理与成本控制

15.1 云计算成本优化

在云平台上运行大规模优化时：

1. 使用抢占式实例(Spot Instances)
2. 设置预算限制和自动终止
3. 监控资源使用情况

python复制# AWS示例：使用Spot实例
from sagemaker.tuner import HyperparameterTuner, ContinuousParameter

tuner = HyperparameterTuner(
    estimator=estimator,
    objective_metric_name='validation:accuracy',
    hyperparameter_ranges={
        'lr': ContinuousParameter(1e-5, 1e-2),
        'batch-size': IntegerParameter(32, 256)
    },
    max_jobs=100,
    max_parallel_jobs=10,
    strategy='Bayesian',
    early_stopping_type='Auto'
)

tuner.fit({'train': train_input, 'test': test_input}, 
          spot_instance=True,
          max_wait=3600)  # 最长等待1小时

15.2 本地资源管理

1. 内存管理：

python复制import resource
resource.setrlimit(resource.RLIMIT_AS, (10_000_000_000, 10_000_000_000))  # 限制10GB

2. GPU利用率监控：

python复制nvidia-smi -l 1  # 每秒刷新GPU状态

3. 进程管理：

python复制import signal
signal.signal(signal.SIGTERM, handle_termination)  # 优雅处理终止信号

16. 安全与隐私考量

16.1 数据安全

1. 优化过程中使用数据子集

python复制# 使用20%数据进行快速评估
subset_indices = np.random.choice(len(full_dataset), 
                                int(0.2*len(full_dataset)),
                                replace=False)
subset = torch.utils.data.Subset(full_dataset, subset_indices)

2. 敏感数据脱敏处理

python复制from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

16.2 模型安全

1. 防止过拟合

python复制optuna.logging.set_verbosity(optuna.logging.WARNING)  # 减少日志信息泄露

2. 模型鲁棒性测试

python复制# 对抗样本测试
from torchattacks import PGD
attack = PGD(model, eps=0.3, alpha=0.1, steps=10)
adv_data = attack(data, labels)

17. 社区资源与学习路径

17.1 官方资源

1. Optuna官方文档
2. GitHub仓库
3. 官方示例集

17.2 推荐学习路径

1. 初学者：

   • 从基础教程开始
   • 尝试修改示例代码
   • 在小数据集上实践

2. 中级用户：

   • 学习高级采样器
   • 实现自定义目标函数
   • 尝试分布式优化

3. 高级用户：

   • 研究源代码
   • 实现自定义可视化
   • 参与社区贡献

17.3 常见问题解答

1. Q: 优化过程太慢怎么办？
   A: 尝试以下方法：

   • 减少目标函数复杂度
   • 使用更简单的模型进行评估
   • 增加并行度
   • 设置合理的剪枝策略

2. Q: 结果不可复现怎么办？
   A: 确保：

   • 设置了随机种子
   • 没有使用全局随机状态
   • 记录了完整的实验配置

3. Q: 如何选择采样器？
   A: 根据问题特点：

   • TPESampler：默认选择，适合大多数场景
   • RandomSampler：基准测试
   • CmaEsSampler：连续参数优化
   • NSGAIISampler：多目标优化

18. 个人经验分享

在实际项目中应用Optuna几年后，我总结了几个关键心得：

1. 参数空间设计比算法选择更重要：精心设计的参数空间能让任何采样器表现良好。我通常会先进行小规模随机搜索来测试参数范围的合理性。

2. 早停策略是必备的：特别是在资源有限的情况下。我实现的渐进式早停策略——初期宽松后期严格，节省了约40%的计算资源。

3. 可视化不是可选项：每次优化后花10分钟分析可视化结果，能发现很多参数交互模式和优化方向。我最常用的是平行坐标图和参数重要性图。

4. 记录一切：包括失败的试验。建立完整的实验数据库后，可以用这些历史数据指导新项目的优化，形成正向循环。

5. 从简单开始：先优化最重要的2-3个参数，稳定后再扩展。一次性优化太多参数反而会降低效率。

最后一个小技巧：对于特别耗时的评估，可以在目标函数开始时检查trial.number，如果是前几轮，使用简化评估（如减少数据量或训练轮数），快速排除明显不好的参数区域。