当前位置：首页 > news >正文

Optuna超参数优化实战：PyTorch深度学习调参的正确打开方式

news 2026/5/22 15:23:53

1. 项目概述：为什么我坚持用 Optuna 调参，而不是 GridSearch 或 Random Search

在 PyTorch 项目里调参这件事，我干了快七年——从最早手写 for 循环嵌套 lr、batch_size、dropout 三重循环，到后来用 sklearn 的 GridSearchCV 包裹 PyTorch 模型（结果报错八百次），再到试过 Ray Tune、Hyperopt，最后在 2020 年底彻底切到 Optuna，再没回头。不是因为它名字好听，而是它真正在解决一个被很多人忽略的底层问题：深度学习超参数空间不是均匀的，而是高度非线性的、有强依赖关系的、且评估代价极其昂贵的。你随便改个 learning_rate，可能让整个训练过程从收敛变成梯度爆炸；把 weight_decay 从 1e-4 拉到 1e-2，模型精度可能掉两个点，但训练时间反而缩短 30%；而 dropout 和 hidden_dim 往往是耦合的——高 dropout 配大 hidden_dim 才稳，小 hidden_dim 配高 dropout 就直接欠拟合。这些关系，GridSearch 看不见，Random Search 碰不到，只有基于贝叶斯优化原理、自带 pruner 机制、支持 conditional space 定义的 Optuna，能真正“理解”你在调什么。

我最近刚上线的一个工业缺陷检测模型（ResNet-18 改进版，输入 256×256，类别 7，数据量 12K），原始 baseline 在验证集上 F1 是 0.831。用传统手动调参花了 5 天，最终做到 0.859；换成 Optuna 做 20 次 trial，只用了 18 小时（单卡 V100），F1 直接冲到 0.873，而且找到了一组非常反直觉的组合：learning_rate=3.2e-4（不是常见的 1e-4 或 5e-4）、weight_decay=8.7e-5（比默认小一个数量级）、dropout=0.45（高于常规的 0.1–0.3）、batch_size=48（不是 32 或 64）。这组参数在其他模型上未必好使，但它在这个特定数据分布+网络结构下，就是最优解。Optuna 不是给你一个“通用答案”，而是帮你在这个具体任务里，找到那个最贴身的解。它不承诺“一定更快”，但承诺“每一轮 trial 都比上一轮更聪明”。这也是为什么我把它列为 PyTorch 工程化流程里的标准组件——不是锦上添花，而是基建必需。

关键词里提到的 “Towards AI - Medium”，其实是个信号：这类内容往往面向刚脱离教程阶段、正要接手真实项目的开发者。他们需要的不是理论推导，而是“今天下午就能跑起来、明天就能看到效果”的方案。所以这篇不会讲 TPE（Tree-structured Parzen Estimator）的概率密度估计怎么算，也不会展开讲如何自定义 Sampler；我会直接告诉你：在哪加几行代码、哪些参数必须设、哪些坑我踩过三次以上、以及为什么你的第一次 trial 总是失败。如果你正在为一个 Kaggle 比赛卡在 0.01 分，或者老板催着上线一个推荐模型但 baseline 性能拉胯，那接下来的内容，就是你接下来 4 小时该做的事。

2. 整体设计思路与方案选型逻辑

2.1 为什么不是 Ray Tune？也不是 Hyperopt？

先说结论：Ray Tune 和 Hyperopt 都很强，但在 PyTorch 单机多卡或单卡中等规模训练场景下，Optuna 的轻量性、调试友好性和集成成本，碾压级胜出。这不是主观偏好，而是实测数据支撑的工程判断。

我拿同一个 ResNet-18 + CIFAR-10 任务做过横向对比（固定 30 次 trial，V100 单卡，早停 patience=5）：

工具	安装复杂度	启动时间（秒）	Trial 间平均开销（秒）	报错定位难度	最终 best F1
Optuna	`pip install optuna`，无依赖冲突	< 0.5	1.2（纯 Python 开销）	日志直接打到 stdout，错误堆栈清晰指向 objective 函数内某行	0.932
Ray Tune	需`pip install ray[tune]`，常与 torch.cuda 冲突	8.7（启动 Ray cluster）	4.8（含序列化/反序列化开销）	错误分散在 driver / worker 日志，需`ray logs`查	0.929
Hyperopt	`pip install hyperopt`，但依赖旧版 networkx	2.1	3.5（TPE 采样计算较重）	堆栈深，常卡在 fmin 内部，难 debug objective	0.926

关键差异在“trial 生命周期管理”。Optuna 的 trial 是纯 Python 对象，你可以在objective(trial)里任意 print、断点、调用 pdb；而 Ray Tune 的每个 trial 是独立进程，变量不共享，print 输出要绕道 log 文件；Hyperopt 的 fmin 则把所有逻辑封装在黑盒里，你想看中间 loss 曲线都得自己 hack callback。在真实项目里，80% 的调参失败不是算法问题，而是 objective 函数写错了——比如 validation loader 忘了shuffle=False，或者model.eval()漏写了，导致 val loss 虚高。这时候，你能秒级定位，和你要翻三份日志、重启整个集群，完全是两个世界。

提示：别被“分布式”三个字迷惑。除非你有 10+ 张 GPU 同时跑上百 trial，否则 Ray Tune 的分布式优势根本发挥不出来，反而徒增复杂度。Optuna 的study.optimize(n_jobs=-1)在 4 卡机器上，实际并行效率比 Ray Tune 高 15%，因为没有跨进程通信开销。

2.2 为什么不用 Sklearn 的 GridSearchCV？

这是新手最容易踩的坑。GridSearchCV 设计初衷是为 sklearn estimator 服务的，它假设：

模型 fit() 是原子操作，不返回中间指标；
所有参数都是独立可枚举的；
训练和评估是瞬时完成的。

但 PyTorch 模型完全不满足这三点。你不能把nn.Module直接塞给 GridSearchCV，必须包装成sklearn.base.BaseEstimator，这意味着你要重写fit()、predict()、score()方法——而fit()里要包含完整的训练循环、早停逻辑、checkpoint 保存，这已经不是调参，是在重写训练框架。更致命的是，GridSearchCV 会把所有参数组合一次性生成，然后暴力穷举。一个 4 维参数空间（lr, bs, wd, dp），每维取 5 个值，就是 625 次 trial。而 Optuna 的 TPE 采样，在第 10 次 trial 后就开始聚焦高潜力区域，20 次 trial 往往就逼近最优解。我实测过：对同一任务，GridSearchCV 跑完 625 次要 32 小时，Optuna 20 次只用 4.5 小时，且结果更好。

注意：有人会说 “我可以限制 GridSearchCV 的 cv=2 来加速”。不行。cv=2 意味着每次 fit 都要训两轮，而 PyTorch 模型训一轮就要 20 分钟，两轮就是 40 分钟，625×40 分钟 = 437 小时。Optuna 的 pruner（如 MedianPruner）能在第 3 个 epoch 就判断这个 trial 已经没希望，直接 kill，省下后面 17 个 epoch 的时间。

2.3 Optuna 的核心设计哲学：Trial 不是实验，而是“智能探针”

理解这一点，才能用好 Optuna。官方文档说 “A trial is a process of evaluating an objective function”，但这太浅。实际上，每个 trial 是一个带记忆、可中断、能反馈的智能探针。它有三个关键能力：

动态参数建议：trial.suggest_float('lr', 1e-5, 1e-3, log=True)不是随机采样，而是根据历史所有 trial 的(lr, val_loss)对，用 TPE 拟合两个概率密度函数（好 trial 的 lr 分布 vs 坏 trial 的 lr 分布），然后采样“好分布”里概率高、但探索性也够的值。log=True 不是语法糖，是因为学习率在对数尺度上才是均匀分布的——1e-4 到 1e-3 的跨度，和 1e-3 到 1e-2 的跨度，在效果上是等价的，但线性采样会严重偏向大数值。
条件空间支持：比如你只想在model_type=='transformer'时才建议num_heads，否则跳过。Optuna 用trial.suggest_categorical+ if 判断天然支持，而 GridSearchCV 只能硬编码所有组合，包括无效的（如 CNN 用 num_heads）。
实时剪枝（Pruning）：这是 Optuna 区别于其他工具的王牌。MedianPruner(n_startup_trials=5, n_warmup_steps=3)意思是：前 5 次 trial 不剪枝（积累 baseline），之后每个 trial 训到第 3 个 epoch 时，把当前 val_loss 和历史所有 trial 在第 3 个 epoch 的 val_loss 中位数比较，如果更差，立刻终止。我在一个 NLP 任务里，30% 的 trial 在第 2 个 epoch 就被剪掉，节省了 40% 总时间。

所以，Optuna 的 study 不是一个“参数表格”，而是一个活的优化器。它在和你对话：你给它 objective，它还你最优解；你加 pruner，它帮你省钱；你定义 conditional space，它理解你的模型逻辑。这才是它成为 PyTorch 生态事实标准的原因。

3. 核心细节解析与实操要点

3.1 Objective 函数：必须封装完整训练闭环，不能只写 model.forward

这是 90% 新手写的第一个 bug。很多人以为 objective 就是 “把参数传进去，跑一个 epoch，返回 loss”，于是写出这样的代码：

def objective(trial): lr = trial.suggest_float('lr', 1e-5, 1e-3, log=True) model = MyModel() optimizer = torch.optim.Adam(model.parameters(), lr=lr) # ❌ 错误：只训一个 batch，loss 波动大，无法反映真实性能 for x, y in train_loader: pred = model(x) loss = F.cross_entropy(pred, y) loss.backward() optimizer.step() optimizer.zero_grad() return loss.item() # 直接返回，训练没结束！

这完全违背了调参本质。一个 trial 的目标不是“最小化单步 loss”，而是“在有限资源下，找到能获得最佳泛化性能的超参数”。所以 objective 必须模拟一次完整的、带验证的、可复现的训练过程。正确写法如下（精简版，完整版见 3.3）：

def objective(trial): # 1. 参数采样 lr = trial.suggest_float('lr', 1e-5, 1e-3, log=True) batch_size = trial.suggest_categorical('batch_size', [16, 32, 64]) weight_decay = trial.suggest_float('weight_decay', 1e-6, 1e-3, log=True) # 2. 数据加载（注意：必须固定 random seed！） train_dataset = MyDataset(train_paths, transform=train_transform) val_dataset = MyDataset(val_paths, transform=val_transform) # ✅ 关键：每个 trial 用独立 DataLoader，且 shuffle seed 固定 train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4, generator=torch.Generator().manual_seed(42)) val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=4) # 3. 模型 & 优化器 model = MyModel().to(device) optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=3) # 4. 训练循环（带早停） best_val_loss = float('inf') patience_counter = 0 for epoch in range(30): # max epochs model.train() train_loss = 0.0 for x, y in train_loader: x, y = x.to(device), y.to(device) optimizer.zero_grad() pred = model(x) loss = F.cross_entropy(pred, y) loss.backward() optimizer.step() train_loss += loss.item() # 5. 验证（必须！这是 objective 的返回依据） model.eval() val_loss = 0.0 with torch.no_grad(): for x, y in val_loader: x, y = x.to(device), y.to(device) pred = model(x) val_loss += F.cross_entropy(pred, y).item() val_loss /= len(val_loader) scheduler.step(val_loss) # 6. Pruning：告诉 Optuna 这个 trial 是否值得继续 trial.report(val_loss, epoch) if trial.should_prune(): raise optuna.exceptions.TrialPruned() # 7. 早停逻辑（防止过拟合，也节省时间） if val_loss < best_val_loss: best_val_loss = val_loss patience_counter = 0 else: patience_counter += 1 if patience_counter >= 7: break return best_val_loss # ✅ 返回最终 best val loss，不是 last epoch loss

注意：trial.report(val_loss, epoch)和trial.should_prune()是 pruner 生效的前提。report 告诉 Optuna “我在第 X 个 epoch 达到 Y loss”，should_prune 则触发剪枝判断。漏掉任何一个，pruner 就是摆设。

3.2 Pruner 选型：MedianPruner 是默认起点，但不是万能解

Optuna 提供多种 pruner，选错等于白搭。我按使用频率和适用场景排序：

Pruner	适用场景	优点	缺点	我的建议
`MedianPruner(n_startup_trials=5, n_warmup_steps=3)`	通用首选，尤其数据量中等（1K–100K）、epoch 数 20–50	实现简单，鲁棒性强，对噪声容忍度高	需要足够 warmup steps 积累 baseline，小数据集可能剪太狠	新项目一律从它开始
`HyperbandPruner(min_resource=1, max_resource=30, reduction_factor=3)`	训练耗时长（>1h/trial）、资源充足（多卡）、想快速淘汰差 trial	理论最优，能自动平衡 exploration/exploitation	配置复杂（resource 含义需明确定义），小 trial 数下不稳定	当 MedianPruner 跑 20 次后仍不满意，再切
`SuccessiveHalvingPruner`	类似 Hyperband，但更轻量	比 Hyperband 易配置	效果略逊于 Hyperband	不推荐，直接上 Hyperband
`NopPruner()`	调试阶段、或所有 trial 都必须跑满	无剪枝，100% 可控	无任何加速，纯暴力	仅用于验证 objective 正确性

关键参数解释：

n_startup_trials：前 N 个 trial 绝对不剪枝，用来建立 loss 分布 baseline。设太小（如 1），后续剪枝会因 baseline 不准而误杀；设太大（如 10），浪费资源。我的经验：总 trial 数 × 0.2，但不低于 3。
n_warmup_steps：每个 trial 至少训满 N 个 epoch 才开始剪枝。设太小（如 1），第一个 epoch loss 波动大，剪枝随机；设太大（如 10），差 trial 浪费太多时间。我的经验：总 epoch × 0.1，但不低于 2。

实操心得：我在一个医学图像分割任务（UNet，输入 512×512，GPU 显存吃紧）中，初始用 MedianPruner(n_startup=3, n_warmup=2)，结果 30% trial 在 epoch 2 被剪，但最终 best dice 是 0.812；后来改成 n_warmup=5，剪枝率降到 12%，best dice 反而升到 0.819。说明：warmup 不是越短越好，要匹配你的模型收敛速度。建议先跑 5 个 trial，画出所有 trial 的 val_loss 曲线，看 loss 何时开始稳定下降，那个 epoch 就是你的 n_warmup 下限。

3.3 Study 创建与优化：避免 study 被意外覆盖或重复读取

Study 是 Optuna 的核心对象，它存储所有 trial 记录。新手常犯两个错误：

每次运行都新建 study，导致历史记录丢失；
多进程同时写同一个 study，引发数据库锁或数据损坏。

正确做法是持久化到 SQLite 数据库，并显式指定 study 名称：

# ✅ 正确：study 持久化，名称唯一，支持断点续跑 storage = optuna.storages.RDBStorage( url="sqlite:///./optuna_study.db", # 数据库存储路径 engine_kwargs={"connect_args": {"timeout": 30}} # 防止多进程锁死 ) study = optuna.create_study( study_name="resnet18_cifar10_v2", # 必须唯一！v2 表示迭代版本 storage=storage, load_if_exists=True, # 如果 db 存在，直接加载，不报错 direction="minimize", # 优化方向：loss 越小越好；acc 越大越好则用 "maximize" sampler=optuna.samplers.TPESampler(seed=42), # 固定随机种子，保证可复现 pruner=optuna.pruners.MedianPruner( n_startup_trials=5, n_warmup_steps=3, interval_steps=1 # 每 1 个 epoch 检查一次是否剪枝 ) ) # 开始优化 study.optimize(objective, n_trials=50, timeout=None, n_jobs=1) # n_jobs=1 最安全

为什么n_jobs=1？因为多进程（n_jobs>1）在 Windows 上有 pickle 问题，在 Linux 上虽可用，但objective函数必须是模块顶层函数（不能是 class method），且所有依赖必须可序列化。而n_jobs=1加study.optimize(..., n_trials=50)是最稳的。如果你真需要并行，用joblib或concurrent.futures自己管理进程池，把study.enqueue_trial()和study.tell()分离，但那是进阶玩法，新手绕开。

提示：SQLite 文件optuna_study.db是你的黄金数据。别删它！每次新 experiment，改study_name即可。你可以用optuna.visualization模块画图分析：
fig = optuna.visualization.plot_optimization_history(study) fig.write_html("optimization_history.html") # 交互式 HTML
这张图能看出优化是否收敛、pruner 是否有效（看曲线是否越来越陡峭）、有没有异常 trial（突然飙升的点）。

4. 实操过程与核心环节实现

4.1 完整可运行代码：CIFAR-10 ResNet-18 调参实战

下面是一份经过我生产环境验证的、可直接复制粘贴运行的完整代码。它包含所有关键细节：数据加载、模型定义、训练循环、pruner 集成、study 持久化。你只需改三处路径，就能跑起来。

import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F from torch.utils.data import DataLoader, random_split from torchvision import datasets, transforms import optuna from optuna.trial import TrialState import os import numpy as np # ------------------- 1. 全局配置 ------------------- DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") BATCH_SIZE = 128 # DataLoader 默认 batch，trial 会覆盖 NUM_WORKERS = 4 SEED = 42 torch.manual_seed(SEED) np.random.seed(SEED) # ------------------- 2. 数据加载与预处理 ------------------- def get_dataloaders(): # 训练增强：随机水平翻转 + 随机裁剪 + 归一化 train_transform = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.RandomCrop(32, padding=4), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) # 验证无增强，仅归一化 val_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) # 加载 CIFAR-10 full_dataset = datasets.CIFAR10(root='./data', train=True, download=True) # 划分 train/val：45K / 5K train_dataset, val_dataset = random_split( full_dataset, [45000, 5000], generator=torch.Generator().manual_seed(SEED) ) # 应用 transform train_dataset.dataset.transform = train_transform val_dataset.dataset.transform = val_transform return train_dataset, val_dataset # ------------------- 3. 模型定义（简化 ResNet-18）------------------- class BasicBlock(nn.Module): def __init__(self, in_channels, out_channels, stride=1, downsample=None): super().__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride, 1, bias=False) self.bn1 = nn.BatchNorm2d(out_channels) self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, 1, bias=False) self.bn2 = nn.BatchNorm2d(out_channels) self.downsample = downsample def forward(self, x): identity = x out = F.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) if self.downsample is not None: identity = self.downsample(x) out += identity return F.relu(out) class ResNet18(nn.Module): def __init__(self, num_classes=10, dropout_rate=0.0): super().__init__() self.in_channels = 64 self.conv1 = nn.Conv2d(3, 64, 3, 1, 1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.layer1 = self._make_layer(64, 2, stride=1) self.layer2 = self._make_layer(128, 2, stride=2) self.layer3 = self._make_layer(256, 2, stride=2) self.layer4 = self._make_layer(512, 2, stride=2) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.dropout = nn.Dropout(dropout_rate) self.fc = nn.Linear(512, num_classes) def _make_layer(self, out_channels, blocks, stride): downsample = None if stride != 1 or self.in_channels != out_channels: downsample = nn.Sequential( nn.Conv2d(self.in_channels, out_channels, 1, stride, bias=False), nn.BatchNorm2d(out_channels) ) layers = [BasicBlock(self.in_channels, out_channels, stride, downsample)] self.in_channels = out_channels for _ in range(1, blocks): layers.append(BasicBlock(out_channels, out_channels)) return nn.Sequential(*layers) def forward(self, x): x = F.relu(self.bn1(self.conv1(x))) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) x = self.layer4(x) x = self.avgpool(x) x = torch.flatten(x, 1) x = self.dropout(x) return self.fc(x) # ------------------- 4. Objective 函数 ------------------- def objective(trial): # 1. 参数采样 lr = trial.suggest_float('lr', 1e-5, 1e-3, log=True) batch_size = trial.suggest_categorical('batch_size', [32, 64, 128]) weight_decay = trial.suggest_float('weight_decay', 1e-6, 1e-3, log=True) dropout_rate = trial.suggest_float('dropout_rate', 0.0, 0.5) # 2. 数据加载（固定 seed） train_dataset, val_dataset = get_dataloaders() train_loader = DataLoader( train_dataset, batch_size=batch_size, shuffle=True, num_workers=NUM_WORKERS, generator=torch.Generator().manual_seed(SEED) ) val_loader = DataLoader( val_dataset, batch_size=128, shuffle=False, num_workers=NUM_WORKERS ) # 3. 模型 & 优化器 model = ResNet18(num_classes=10, dropout_rate=dropout_rate).to(DEVICE) optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=3) # 4. 训练循环（带早停和 pruning） best_val_loss = float('inf') patience_counter = 0 for epoch in range(30): # 训练 model.train() train_loss = 0.0 for x, y in train_loader: x, y = x.to(DEVICE), y.to(DEVICE) optimizer.zero_grad() pred = model(x) loss = F.cross_entropy(pred, y) loss.backward() optimizer.step() train_loss += loss.item() train_loss /= len(train_loader) # 验证 model.eval() val_loss = 0.0 correct = 0 total = 0 with torch.no_grad(): for x, y in val_loader: x, y = x.to(DEVICE), y.to(DEVICE) pred = model(x) val_loss += F.cross_entropy(pred, y).item() _, predicted = pred.max(1) total += y.size(0) correct += predicted.eq(y).sum().item() val_loss /= len(val_loader) val_acc = 100. * correct / total # Pruning 检查 trial.report(val_loss, epoch) if trial.should_prune(): raise optuna.exceptions.TrialPruned() # 早停 if val_loss < best_val_loss: best_val_loss = val_loss patience_counter = 0 else: patience_counter += 1 if patience_counter >= 7: break return best_val_loss # ------------------- 5. Study 创建与优化 ------------------- if __name__ == "__main__": # 创建 study，持久化到 SQLite storage = optuna.storages.RDBStorage( url="sqlite:///./cifar10_resnet18_study.db", engine_kwargs={"connect_args": {"timeout": 30}} ) study = optuna.create_study( study_name="cifar10_resnet18_v1", storage=storage, load_if_exists=True, direction="minimize", sampler=optuna.samplers.TPESampler(seed=SEED), pruner=optuna.pruners.MedianPruner( n_startup_trials=5, n_warmup_steps=3, interval_steps=1 ) ) # 开始优化（50 trials） print("Starting Optuna optimization...") study.optimize(objective, n_trials=50, n_jobs=1) # 输出最佳结果 print("Number of finished trials: ", len(study.trials)) print("Best trial:") trial = study.best_trial print(" Value: ", trial.value) print(" Params: ") for key, value in trial.params.items(): print(" {}: {}".format(key, value)) # 保存最佳模型（可选） best_params = study.best_params best_model = ResNet18(num_classes=10, dropout_rate=best_params['dropout_rate']).to(DEVICE) # 这里可以加载权重或重新训练...

实操心得：这段代码我在我自己的 2080Ti 上跑了 3 轮，平均每 trial 耗时 182 秒（3 分钟），50 次共 2.5 小时。最终 best val_loss 是 0.287（对应 test acc 92.3%），比手动调参的 0.312（91.1%）高 1.2 个百分点。关键发现：最优dropout_rate=0.32，weight_decay=3.7e-5，这两个值都在常规范围之外，但确实有效。这再次证明，人工经验有盲区，而 Optuna 能突破它。

4.2 参数空间设计技巧：哪些参数值得调？哪些纯属浪费时间？

不是所有参数都值得放进suggest_*。调参的本质是“在有限 trial 数下，最大化信息增益”。我的经验法则：

必调参数（3–4 个，占 80% 效果提升）：

learning_rate：永远第一个调，log scale 采样；
weight_decay：和 lr 强耦合，必须一起调；
batch_size：影响梯度更新稳定性，但注意显存限制；
dropout_rate或label_smoothing：正则化强度，对过拟合敏感任务必调。

慎调参数（仅当 baseline 过拟合/欠拟合时加入）：

lr_scheduler.patience：如果发现 val loss 早早就 plateau，可调；
optimizer.momentum（SGD 专用）：Adam 一般不动；
model.hidden_dim：调它意味着要重训整个模型，cost 高，优先级低。

绝不调参数（纯属增加 noise）：

num_workers：这是 DataLoader 性能参数，和模型性能无关；
pin_memory：True/False 二值，影响数据加载速度，不影响 accuracy；
torch.backends.cudnn.benchmark：开启后首次运行慢，后续快，但不改变结果。

注意：batch_size的采样要结合硬件。不要写suggest_categorical([8,16,32,64,128,256])。先用nvidia-smi看你 GPU 显存占用，比如 V100 32G，ResNet-18 输入 32×32，最大 batch_size 是 512；那么采样[64,128,256]就够了。采样太多小值（如 8），会导致梯度更新 noisy，loss 曲线抖，pruner 误判。

4.3 结果分析与最佳参数落地：如何把 study 结果变成生产模型

Optuna 的输出只是开始，不是终点。study.best_params给你的是“在验证集上表现最好的超参数”，但你要把它变成线上可用的模型，还需三步：

第一步：用 best_params 重新训一个 full train因为 study 中的 trial 是用 train/val split 训的（比如 45K/5K），而生产模型要用全部 50K 训。所以：

best_params = study.best_params # 重新构建 train_loader 用全部 50K 数据 full_train_dataset = datasets.CIFAR10('./data', train=True, transform=train_transform) full_train_loader = DataLoader(full_train_dataset, batch_size=best_params['batch_size'], ...) # 用 best_params 初始化模型和优化器，训满 50 epoch

第二步：做 test set 评估，确认泛化性绝对不能只信 val loss！用完全未见过的 test set（CIFAR-10 的 10K）评估：

test_dataset = datasets.CIFAR10('./data', train=False, transform=val_transform) test_loader = DataLoader(test_dataset, batch_size=128, ...) # 计算 test acc / F1 / confusion matrix

第三步：保存 checkpoint 和 config

torch.save({ 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'best_params': best_params, 'test_acc': test_acc, 'timestamp': datetime.now().isoformat() }, 'best_resnet18_cifar10.pth')

这个.pth文件就是你的交付物。它包含模型权重、超参数、测试指标，可 audit、可复现、可部署。