Pytorch深度学习框架60天进阶学习计划 - 第34天：自动化模型调优

Pytorch深度学习框架60天进阶学习计划 - 第34天：自动化模型调优

今天，我们将深入研究一个让许多数据科学家和机器学习工程师头疼的问题：如何高效地调整模型超参数。我喜欢把超参数调优比作烹饪，你有最好的食材（数据）和厨具（模型架构），但如果调料（超参数）不对，再好的厨师也做不出美味的菜肴！

我们将学习如何使用Optuna这个强大的工具进行自动化超参数优化，实践多目标优化策略，并对比贝叶斯优化与网格搜索的效率差异。这些技术将帮助你从手动调参的痛苦中解脱出来，让算法为你找到最佳的超参数组合！

学习目标

1. 掌握使用Optuna进行超参数优化的方法
2. 理解并实践多目标优化策略
3. 比较贝叶斯优化与网格搜索的效率差异
4. 学习如何集成Optuna与Pytorch训练流程

为什么自动化模型调优很重要？

在我们深入技术细节之前，先来谈谈为什么这个主题如此重要。想象一下，你刚刚花了几周时间构建了一个复杂的神经网络模型，但性能却不尽如人意。你可能会思考：

• 学习率是不是太高或太低了？
• 批量大小是否合适？
• 优化器应该选择Adam、SGD还是RMSprop？
• 网络层数和每层的单元数是否合理？

这些都是超参数，而它们的组合可能性是天文数字！手动尝试每种组合不仅耗时，而且效率低下。这就是自动化超参数优化工具如Optuna的价值所在 - 它能帮你在更短的时间内找到更好的超参数组合。

超参数优化方法对比

让我们先了解一下不同的超参数优化方法及其特点：

优化方法	工作原理	优势	劣势	适用场景
网格搜索	在预定义的超参数空间中枚举所有可能的组合	简单易实现，易于并行化	计算成本高，维度灾难	超参数较少，计算资源充足
随机搜索	从超参数空间中随机采样组合	比网格搜索更有效，容易并行化	随机性导致可能错过最优区域	中等复杂度的问题
贝叶斯优化	根据历史评估结果构建超参数与性能的概率模型	高效利用历史信息，样本利用率高	计算复杂度高，不易并行化	计算资源有限，评估成本高
Optuna	基于贝叶斯优化的框架，但有更多高级特性	高效，支持多目标优化，有早停机制	相对复杂，需要一定学习成本	复杂模型，大规模超参数搜索

Optuna 简介

Optuna是一个专为机器学习设计的自动超参数优化框架。它结合了贝叶斯优化和其他先进技术，有以下特点：

1. 定义灵活：可以定义复杂的超参数搜索空间
2. 高效搜索：使用树结构Parzen估计器（TPE）等先进算法
3. 可视化：提供丰富的可视化工具来分析优化过程
4. 多目标优化：支持同时优化多个目标
5. 分布式支持：可以在多台机器上并行运行
6. 早停机制：可以自动终止表现不佳的试验

下面我们将通过实际的代码示例，学习如何将Optuna与Pytorch结合使用。

Optuna 与 Pytorch 集成实践

首先，让我们安装必要的包：

# 安装必要的库
# pip install torch torchvision optuna matplotlib pandas

基本超参数优化示例

我们将以MNIST数据集上的简单CNN模型为例，演示如何使用Optuna进行超参数优化：

import os
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import optuna
from optuna.visualization import plot_optimization_history, plot_param_importances
import matplotlib.pyplot as plt# 设置设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")# 准备数据
def get_mnist_loaders(batch_size):# 准备数据变换transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,), (0.3081,))])# 加载训练集train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)# 加载测试集test_dataset = datasets.MNIST('./data', train=False, transform=transform)test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)return train_loader, test_loader# 定义CNN模型
class Net(nn.Module):def __init__(self, n_filters1, n_filters2, dropout_rate):super(Net, self).__init__()self.conv1 = nn.Conv2d(1, n_filters1, 3, 1)self.conv2 = nn.Conv2d(n_filters1, n_filters2, 3, 1)self.dropout1 = nn.Dropout2d(dropout_rate)self.dropout2 = nn.Dropout2d(dropout_rate)# 根据卷积层的输出计算全连接层的输入大小self.fc1_input_size = n_filters2 * 5 * 5self.fc1 = nn.Linear(self.fc1_input_size, 128)self.fc2 = nn.Linear(128, 10)def forward(self, x):x = self.conv1(x)x = F.relu(x)x = F.max_pool2d(x, 2)x = self.dropout1(x)x = self.conv2(x)x = F.relu(x)x = F.max_pool2d(x, 2)x = self.dropout2(x)x = torch.flatten(x, 1)x = self.fc1(x)x = F.relu(x)x = self.fc2(x)output = F.log_softmax(x, dim=1)return output# 训练模型的函数
def train_and_evaluate(model, train_loader, test_loader, optimizer, n_epochs):# 训练模型model.train()for epoch in range(n_epochs):for batch_idx, (data, target) in enumerate(train_loader):data, target = data.to(device), target.to(device)optimizer.zero_grad()output = model(data)loss = F.nll_loss(output, target)loss.backward()optimizer.step()# 评估模型model.eval()test_loss = 0correct = 0with torch.no_grad():for data, target in test_loader:data, target = data.to(device), target.to(device)output = model(data)test_loss += F.nll_loss(output, target, reduction='sum').item()pred = output.argmax(dim=1, keepdim=True)correct += pred.eq(target.view_as(pred)).sum().item()test_loss /= len(test_loader.dataset)accuracy = correct / len(test_loader.dataset)return accuracy# 定义Optuna目标函数
def objective(trial):# 定义超参数搜索空间n_filters1 = trial.suggest_int('n_filters1', 16, 64)n_filters2 = trial.suggest_int('n_filters2', 32, 128)dropout_rate = trial.suggest_float('dropout_rate', 0.1, 0.5)lr = trial.suggest_float('lr', 1e-4, 1e-1, log=True)batch_size = trial.suggest_categorical('batch_size', [32, 64, 128, 256])optimizer_name = trial.suggest_categorical('optimizer', ['Adam', 'SGD', 'RMSprop'])# 获取数据加载器train_loader, test_loader = get_mnist_loaders(batch_size)# 创建模型model = Net(n_filters1, n_filters2, dropout_rate).to(device)# 配置优化器if optimizer_name == 'Adam':optimizer = optim.Adam(model.parameters(), lr=lr)elif optimizer_name == 'SGD':optimizer = optim.SGD(model.parameters(), lr=lr)else:  # RMSpropoptimizer = optim.RMSprop(model.parameters(), lr=lr)# 训练和评估模型accuracy = train_and_evaluate(model, train_loader, test_loader, optimizer, n_epochs=5)return accuracy# 运行Optuna优化
def run_optuna_optimization(n_trials=50):study = optuna.create_study(direction='maximize', study_name='mnist_cnn_optimization')study.optimize(objective, n_trials=n_trials)# 打印优化结果print('Number of finished trials:', len(study.trials))print('Best trial:')trial = study.best_trialprint('  Value:', trial.value)print('  Params:')for key, value in trial.params.items():print(f'    {key}: {value}')# 可视化结果fig1 = plot_optimization_history(study)fig2 = plot_param_importances(study)# 保存图表fig1.write_image("optimization_history.png")fig2.write_image("param_importances.png")return study# 使用最佳参数训练最终模型
def train_with_best_params(study):best_params = study.best_paramsprint(f"Training final model with best parameters: {best_params}")# 获取数据加载器train_loader, test_loader = get_mnist_loaders(best_params['batch_size'])# 创建最终模型final_model = Net(best_params['n_filters1'], best_params['n_filters2'], best_params['dropout_rate']).to(device)# 配置优化器if best_params['optimizer'] == 'Adam':optimizer = optim.Adam(final_model.parameters(), lr=best_params['lr'])elif best_params['optimizer'] == 'SGD':optimizer = optim.SGD(final_model.parameters(), lr=best_params['lr'])else:  # RMSpropoptimizer = optim.RMSprop(final_model.parameters(), lr=best_params['lr'])# 训练和评估最终模型accuracy = train_and_evaluate(final_model, train_loader, test_loader, optimizer, n_epochs=10)print(f"Final model accuracy: {accuracy:.4f}")return final_model, accuracy# 主函数
if __name__ == "__main__":# 运行10次试验进行优化（实际应用中应使用更多次试验）study = run_optuna_optimization(n_trials=10)# 使用最佳参数训练最终模型final_model, final_accuracy = train_with_best_params(study)# 保存最终模型torch.save(final_model.state_dict(), "best_mnist_model.pth")

上面的代码展示了如何使用Optuna进行基本的超参数优化。让我为你解释代码的主要部分：

1. 定义模型：我们创建了一个简单的CNN模型，其中一些关键参数（如卷积层的过滤器数量和dropout率）作为超参数进行优化。

2. 目标函数：objective函数是优化的核心，它接收一个trial对象，通过该对象定义超参数搜索空间，然后训练模型并返回性能指标（准确率）。

3. 超参数搜索空间：我们优化的超参数包括：

   • 卷积层的过滤器数量
   • Dropout率
   • 学习率（对数尺度）
   • 批量大小
   • 优化器类型

4. 创建和运行Study：使用optuna.create_study创建一个优化研究，并通过study.optimize运行指定次数的试验。

5. 可视化和分析：代码包括简单的可视化功能，展示优化历史和参数重要性。

6. 使用最佳参数：获取最佳超参数组合后，我们用它训练最终模型并评估性能。

多目标优化

在实际应用中，我们往往需要同时考虑多个目标，如模型的准确率、推理速度、模型大小等。Optuna支持多目标优化，让我们来看一个例子：

import os
import time
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import optuna
from optuna.visualization import plot_pareto_front
import matplotlib.pyplot as plt
import numpy as np# 设置设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")# 准备数据
def get_mnist_loaders(batch_size):transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,), (0.3081,))])train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)test_dataset = datasets.MNIST('./data', train=False, transform=transform)test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)return train_loader, test_loader# 灵活的CNN模型定义
class FlexibleCNN(nn.Module):def __init__(self, n_layers, n_filters, dropout_rate):super(FlexibleCNN, self).__init__()self.n_layers = n_layers# 第一个卷积层self.conv_layers = nn.ModuleList([nn.Conv2d(1, n_filters, 3, 1, 1)])# 添加更多卷积层for i in range(1, n_layers):self.conv_layers.append(nn.Conv2d(n_filters, n_filters, 3, 1, 1))# 计算全连接层的输入大小fc_input_size = n_filters * (28 // (2 ** min(n_layers, 4))) ** 2# 全连接层self.fc1 = nn.Linear(fc_input_size, 128)self.fc2 = nn.Linear(128, 10)self.dropout = nn.Dropout(dropout_rate)def forward(self, x):# 应用卷积层和池化for i, conv in enumerate(self.conv_layers):x = F.relu(conv(x))# 每两层应用一次池化if (i + 1) % 2 == 0 and i < 2 * min(self.n_layers, 4):x = F.max_pool2d(x, 2)# 平铺并应用全连接层x = torch.flatten(x, 1)x = F.relu(self.fc1(x))x = self.dropout(x)x = self.fc2(x)return F.log_softmax(x, dim=1)def count_parameters(self):return sum(p.numel() for p in self.parameters() if p.requires_grad)# 训练和评估函数，现在返回准确率和推理时间
def train_and_evaluate(model, train_loader, test_loader, optimizer, n_epochs):# 训练模型model.train()for epoch in range(n_epochs):for batch_idx, (data, target) in enumerate(train_loader):data, target = data.to(device), target.to(device)optimizer.zero_grad()output = model(data)loss = F.nll_loss(output, target)loss.backward()optimizer.step()# 评估准确率model.eval()test_loss = 0correct = 0# 测量推理时间inference_times = []with torch.no_grad():for data, target in test_loader:data, target = data.to(device), target.to(device)# 测量推理时间start_time = time.time()output = model(data)end_time = time.time()inference_times.append(end_time - start_time)test_loss += F.nll_loss(output, target, reduction='sum').item()pred = output.argmax(dim=1, keepdim=True)correct += pred.eq(target.view_as(pred)).sum().item()# 计算准确率accuracy = correct / len(test_loader.dataset)# 计算平均推理时间（毫秒）avg_inference_time = np.mean(inference_times) * 1000# 计算模型大小（MB）model_size_mb = model.count_parameters() * 4 / (1024 * 1024)  # 假设每个参数占用4字节return accuracy, avg_inference_time, model_size_mb# 多目标优化函数
def objective(trial):# 定义超参数搜索空间n_layers = trial.suggest_int('n_layers', 1, 4)n_filters = trial.suggest_int('n_filters', 16, 128)dropout_rate = trial.suggest_float('dropout_rate', 0.1, 0.5)lr = trial.suggest_float('lr', 1e-4, 1e-2, log=True)batch_size = trial.suggest_categorical('batch_size', [32, 64, 128])optimizer_name = trial.suggest_categorical('optimizer', ['Adam', 'SGD'])# 获取数据train_loader, test_loader = get_mnist_loaders(batch_size)# 创建模型model = FlexibleCNN(n_layers, n_filters, dropout_rate).to(device)# 配置优化器if optimizer_name == 'Adam':optimizer = optim.Adam(model.parameters(), lr=lr)else:  # SGDoptimizer = optim.SGD(model.parameters(), lr=lr)# 训练和评估模型accuracy, inference_time, model_size = train_and_evaluate(model, train_loader, test_loader, optimizer, n_epochs=3)return accuracy, inference_time, model_size# 运行多目标优化
def run_multi_objective_optimization(n_trials=50):study = optuna.create_study(directions=['maximize', 'minimize', 'minimize'],  # 最大化准确率，最小化推理时间和模型大小study_name='mnist_multi_objective')study.optimize(objective, n_trials=n_trials)# 打印优化结果print('\nNumber of finished trials:', len(study.trials))print('\nPareto front:')# 获取帕累托最优解pareto_front = study.best_trials# 打印帕累托最优解for i, trial in enumerate(pareto_front):print(f"\nTrial {i}:")print(f"  Values: Accuracy={trial.values[0]:.4f}, "f"Inference Time={trial.values[1]:.2f}ms, "f"Model Size={trial.values[2]:.2f}MB")print("  Params:")for key, value in trial.params.items():print(f"    {key}: {value}")# 可视化帕累托前沿fig = plot_pareto_front(study, target_names=["Accuracy", "Inference Time (ms)", "Model Size (MB)"])fig.write_image("pareto_front.png")return study# 主函数
if __name__ == "__main__":# 运行10次试验进行多目标优化（实际应用中应使用更多次试验）study = run_multi_objective_optimization(n_trials=10)# 可视化一些帕累托最优解if len(study.best_trials) > 0:best_trial = study.best_trials[0]  # 获取一个帕累托最优解print(f"\nSelected a Pareto-optimal solution with:")print(f"  Accuracy: {best_trial.values[0]:.4f}")print(f"  Inference Time: {best_trial.values[1]:.2f}ms")print(f"  Model Size: {best_trial.values[2]:.2f}MB")

这个多目标优化的例子中，我们同时考虑了三个目标：

1. 准确率（最大化）：模型的分类准确率
2. 推理时间（最小化）：模型进行预测所需的时间
3. 模型大小（最小化）：模型参数占用的内存空间

多目标优化不会给出单一的"最佳"解，而是一组帕累托最优解（Pareto-optimal solutions）。这些解之间存在权衡关系，例如：

• 高准确率的模型通常推理时间较长、模型较大
• 推理速度快的模型可能准确率较低
• 模型大小小的模型可能在准确率和速度上都有所妥协

你可以根据自己的具体需求（如部署环境限制、准确率要求等）从帕累托前沿中选择最适合的解。

对比贝叶斯优化、网格搜索和随机搜索

下面我们将实现三种不同的优化策略，并对比它们的效率：

import os
import time
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import optuna
from optuna.samplers import TPESampler, GridSampler, RandomSampler
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from datetime import datetime
from sklearn.metrics import accuracy_score# 设置设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")# 简化的CNN模型
class SimpleCNN(nn.Module):def __init__(self, n_filters=32, dropout_rate=0.3):super(SimpleCNN, self).__init__()self.conv1 = nn.Conv2d(1, n_filters, 3, 1)self.dropout = nn.Dropout2d(dropout_rate)self.fc1 = nn.Linear(n_filters * 13 * 13, 128)self.fc2 = nn.Linear(128, 10)def forward(self, x):x = self.conv1(x)x = F.relu(x)x = F.max_pool2d(x, 2)x = self.dropout(x)x = torch.flatten(x, 1)x = self.fc1(x)x = F.relu(x)x = self.fc2(x)return F.log_softmax(x, dim=1)# 准备数据
def get_mnist_loaders(batch_size=64):transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,), (0.3081,))])train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)test_dataset = datasets.MNIST('./data', train=False, transform=transform)test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)return train_loader, test_loader# 训练和评估函数
def train_and_evaluate(model, train_loader, test_loader, optimizer, n_epochs=2):# 训练模型model.train()for epoch in range(n_epochs):for batch_idx, (data, target) in enumerate(train_loader):data, target = data.to(device), target.to(device)optimizer.zero_grad()output = model(data)loss = F.nll_loss(output, target)loss.backward()optimizer.step()# 评估模型model.eval()correct = 0with torch.no_grad():for data, target in test_loader:data, target = data.to(device), target.to(device)output = model(data)pred = output.argmax(dim=1, keepdim=True)correct += pred.eq(target.view_as(pred)).sum().item()accuracy = correct / len(test_loader.dataset)return accuracy# 运行不同优化方法并比较结果
def compare_optimization_methods(n_trials=20):results = []methods = ["TPE (Bayesian)", "Random", "Grid"]# 1. 运行贝叶斯优化 (TPE)print("Running Bayesian Optimization (TPE)...")start_time = time.time()tpe_study = optuna.create_study(direction="maximize",sampler=TPESampler(seed=42),study_name="tpe_optimization")tpe_study.optimize(lambda trial: objective(trial), n_trials=n_trials)tpe_time = time.time() - start_time# 2. 运行随机搜索print("Running Random Search...")start_time = time.time()random_study = optuna.create_study(direction="maximize",sampler=RandomSampler(seed=42),study_name="random_optimization")random_study.optimize(lambda trial: objective(trial), n_trials=n_trials)random_time = time.time() - start_time# 3. 运行网格搜索print("Running Grid Search...")# 对于网格搜索，我们需要定义搜索空间search_space = {"n_filters": [16, 32, 64],"dropout_rate": [0.1, 0.3, 0.5],"lr": [0.001, 0.01, 0.1],"batch_size": [32, 64, 128]}start_time = time.time()grid_study = optuna.create_study(direction="maximize",sampler=GridSampler(search_space),study_name="grid_optimization")# 由于网格搜索需要运行所有组合，可能超过n_trialsgrid_n_trials = min(n_trials, np.prod([len(v) for v in search_space.values()]))grid_study.optimize(lambda trial: objective(trial, "grid"), n_trials=grid_n_trials)grid_time = time.time() - start_time# 收集结果studies = [tpe_study, random_study, grid_study]times = [tpe_time, random_time, grid_time]# 分析结果for method, study, elapsed_time in zip(methods, studies, times):best_value = study.best_valuebest_params = study.best_params# 收集每次试验的值trial_values = [t.value for t in study.trials if t.value is not None]# 计算收敛曲线（累积最大值）convergence = [max(trial_values[:i+1]) for i in range(len(trial_values))]results.append({"Method": method,"Best Accuracy": best_value,"Time (s)": elapsed_time,"Best Parameters": best_params,"Convergence": convergence,"Trials": len(study.trials)})return results# 可视化结果
def visualize_optimization_comparison(results):# 创建性能比较图表plt.figure(figsize=(15, 10))# 1. 准确率对比plt.subplot(2, 2, 1)methods = [r["Method"] for r in results]accuracies = [r["Best Accuracy"] for r in results]plt.bar(methods, accuracies)plt.title("Best Accuracy by Method")plt.ylabel("Accuracy")plt.ylim(0.9, 1.0)  # 通常MNIST的准确率都很高# 2. 运行时间对比plt.subplot(2, 2, 2)times = [r["Time (s)"] for r in results]plt.bar(methods, times)plt.title("Execution Time by Method")plt.ylabel("Time (seconds)")# 3. 收敛曲线对比plt.subplot(2, 1, 2)for r in results:plt.plot(range(1, len(r["Convergence"])+1), r["Convergence"], label=f"{r['Method']} (Best: {r['Best Accuracy']:.4f})")plt.title("Convergence Curve")plt.xlabel("Number of Trials")plt.ylabel("Best Accuracy So Far")plt.grid(True)plt.legend()plt.tight_layout()plt.savefig("optimization_methods_comparison.png")# 创建参数表格param_df = pd.DataFrame([{"Method": r["Method"],"Best Accuracy": f"{r['Best Accuracy']:.4f}","Time (s)": f"{r['Time (s)']:.2f}",**{k: v for k, v in r["Best Parameters"].items()}} for r in results])print("\nBest parameters by method:")print(param_df.to_string(index=False))return param_df# 主函数
if __name__ == "__main__":# 比较不同优化方法（为了演示使用较少的试验次数）results = compare_optimization_methods(n_trials=10)# 可视化结果param_df = visualize_optimization_comparison(results)# 保存结果到CSVparam_df.to_csv("optimization_results.csv", index=False)# 超参数优化的目标函数
def objective(trial, optimizer_type=None):# 定义超参数搜索空间if optimizer_type == "grid":# 网格搜索使用固定的步长n_filters = trial.suggest_categorical('n_filters', [16, 32, 64])dropout_rate = trial.suggest_categorical('dropout_rate', [0.1, 0.3, 0.5])lr = trial.suggest_categorical('lr', [0.001, 0.01, 0.1])batch_size = trial.suggest_categorical('batch_size', [32, 64, 128])# 获取数据加载器train_loader, test_loader = get_mnist_loaders(batch_size)# 创建模型model = SimpleCNN(n_filters, dropout_rate).to(device)# 配置优化器optimizer = optim.Adam(model.parameters(), lr=lr)# 训练和评估模型accuracy = train_and_evaluate(model, train_loader, test_loader, optimizer)return accuracyelse:# 贝叶斯和随机搜索使用连续空间n_filters = trial.suggest_int('n_filters', 16, 64)dropout_rate = trial.suggest_float('dropout_rate', 0.1, 0.5)lr = trial.suggest_float('lr', 0.001, 0.1, log=True)batch_size = trial.suggest_categorical('batch_size', [32, 64, 128])

现在我们再来实现一个集成Optuna与Early Stopping的更高级例子，以优化神经网络超参数：

import os
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader, random_split
from torchvision import datasets, transforms
import optuna
from optuna.pruners import MedianPruner
import matplotlib.pyplot as plt# 设置设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")# 准备数据，这次我们拆分训练集为训练和验证
def get_mnist_loaders(batch_size, val_ratio=0.1):transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,), (0.3081,))])# 加载完整训练集full_train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)# 拆分为训练集和验证集val_size = int(len(full_train_dataset) * val_ratio)train_size = len(full_train_dataset) - val_sizetrain_dataset, val_dataset = random_split(full_train_dataset, [train_size, val_size], generator=torch.Generator().manual_seed(42))# 创建数据加载器train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)# 加载测试集test_dataset = datasets.MNIST('./data', train=False, transform=transform)test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)return train_loader, val_loader, test_loader# 定义灵活的CNN模型
class CustomCNN(nn.Module):def __init__(self, n_conv_layers, n_filters, kernel_size, dropout_rate, n_fc_layers, fc_units):super(CustomCNN, self).__init__()# 卷积层self.conv_layers = nn.ModuleList()in_channels = 1  # 输入通道数（MNIST是灰度图像）for i in range(n_conv_layers):self.conv_layers.append(nn.Conv2d(in_channels, n_filters, kernel_size, padding=1))in_channels = n_filters# 计算卷积层后的特征图大小# 假设我们每两个卷积层后使用一次池化feature_size = 28  # MNIST原始大小n_pools = n_conv_layers // 2feature_size = feature_size // (2 ** n_pools)# 计算展平后的特征数量flat_features = n_filters * feature_size * feature_size# 全连接层self.fc_layers = nn.ModuleList()in_features = flat_featuresfor i in range(n_fc_layers):self.fc_layers.append(nn.Linear(in_features, fc_units))in_features = fc_units# 输出层self.output_layer = nn.Linear(in_features, 10)# Dropoutself.dropout = nn.Dropout(dropout_rate)def forward(self, x):# 应用卷积层for i, conv in enumerate(self.conv_layers):x = F.relu(conv(x))# 每两层后应用一次池化if (i + 1) % 2 == 0:x = F.max_pool2d(x, 2)# 展平x = torch.flatten(x, 1)# 应用全连接层for fc in self.fc_layers:x = F.relu(fc(x))x = self.dropout(x)# 输出层x = self.output_layer(x)return F.log_softmax(x, dim=1)# 训练函数，支持早停
def train_model(model, train_loader, val_loader, optimizer, n_epochs, patience=5, trial=None):# 初始化早停计数器和最佳验证损失counter = 0best_val_loss = float('inf')# 训练历史train_losses = []val_losses = []val_accuracies = []for epoch in range(n_epochs):# 训练阶段model.train()train_loss = 0for batch_idx, (data, target) in enumerate(train_loader):data, target = data.to(device), target.to(device)optimizer.zero_grad()output = model(data)loss = F.nll_loss(output, target)loss.backward()optimizer.step()train_loss += loss.item()train_loss /= len(train_loader)train_losses.append(train_loss)# 验证阶段model.eval()val_loss = 0correct = 0with torch.no_grad():for data, target in val_loader:data, target = data.to(device), target.to(device)output = model(data)val_loss += F.nll_loss(output, target, reduction='sum').item()pred = output.argmax(dim=1, keepdim=True)correct += pred.eq(target.view_as(pred)).sum().item()val_loss /= len(val_loader.dataset)val_losses.append(val_loss)accuracy = correct / len(val_loader.dataset)val_accuracies.append(accuracy)# 打印进度print(f'Epoch {epoch+1}/{n_epochs}: 'f'Train Loss: {train_loss:.4f}, 'f'Val Loss: {val_loss:.4f}, 'f'Val Accuracy: {accuracy:.4f}')# Optuna剪枝if trial is not None:trial.report(accuracy, epoch)if trial.should_prune():raise optuna.exceptions.TrialPruned()# 早停检查if val_loss < best_val_loss:best_val_loss = val_losscounter = 0else:counter += 1if counter >= patience:print(f'Early stopping at epoch {epoch+1}')breakreturn {'train_losses': train_losses,'val_losses': val_losses,'val_accuracies': val_accuracies,'final_accuracy': val_accuracies[-1]}# 评估模型
def evaluate_model(model, test_loader):model.eval()test_loss = 0correct = 0with torch.no_grad():for data, target in test_loader:data, target = data.to(device), target.to(device)output = model(data)test_loss += F.nll_loss(output, target, reduction='sum').item()pred = output.argmax(dim=1, keepdim=True)correct += pred.eq(target.view_as(pred)).sum().item()test_loss /= len(test_loader.dataset)accuracy = correct / len(test_loader.dataset)print(f'Test Loss: {test_loss:.4f}, Test Accuracy: {accuracy:.4f}')return test_loss, accuracy# Optuna目标函数
def objective(trial):# 定义超参数搜索空间n_conv_layers = trial.suggest_int('n_conv_layers', 1, 3)n_filters = trial.suggest_int('n_filters', 16, 64)kernel_size = trial.suggest_int('kernel_size', 3, 5, step=2)dropout_rate = trial.suggest_float('dropout_rate', 0.1, 0.5)n_fc_layers = trial.suggest_int('n_fc_layers', 1, 2)fc_units = trial.suggest_int('fc_units', 64, 256)lr = trial.suggest_float('lr', 1e-4, 1e-2, log=True)batch_size = trial.suggest_categorical('batch_size', [32, 64, 128])optimizer_name = trial.suggest_categorical('optimizer', ['Adam', 'SGD', 'RMSprop'])# 获取数据加载器train_loader, val_loader, test_loader = get_mnist_loaders(batch_size)# 创建模型model = CustomCNN(n_conv_layers=n_conv_layers,n_filters=n_filters,kernel_size=kernel_size,dropout_rate=dropout_rate,n_fc_layers=n_fc_layers,fc_units=fc_units).to(device)# 配置优化器if optimizer_name == 'Adam':optimizer = optim.Adam(model.parameters(), lr=lr)elif optimizer_name == 'SGD':optimizer = optim.SGD(model.parameters(), lr=lr)else:  # RMSpropoptimizer = optim.RMSprop(model.parameters(), lr=lr)# 训练模型（使用早停）history = train_model(model, train_loader, val_loader, optimizer, n_epochs=20, patience=5, trial=trial)return history['final_accuracy']# 可视化训练历史
def plot_training_history(history, title):fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))# 绘制损失曲线ax1.plot(history['train_losses'], label='Train Loss')ax1.plot(history['val_losses'], label='Validation Loss')ax1.set_xlabel('Epoch')ax1.set_ylabel('Loss')ax1.legend()ax1.set_title('Loss Curves')ax1.grid(True)# 绘制准确率曲线ax2.plot(history['val_accuracies'], label='Validation Accuracy')ax2.set_xlabel('Epoch')ax2.set_ylabel('Accuracy')ax2.set_title('Validation Accuracy')ax2.grid(True)plt.suptitle(title)plt.tight_layout()plt.savefig(f"{title.replace(' ', '_').lower()}.png")plt.close()# 主函数
def main():# 创建Optuna study，使用MedianPruner进行早期剪枝study = optuna.create_study(direction="maximize",pruner=MedianPruner(n_startup_trials=5, n_warmup_steps=5),study_name="mnist_cnn_optimization")# 运行优化study.optimize(objective, n_trials=15)# 打印优化结果print('\nBest trial:')trial = study.best_trialprint(f'  Value: {trial.value}')print('  Params:')for key, value in trial.params.items():print(f'    {key}: {value}')# 使用最佳超参数训练最终模型print('\nTraining final model with best parameters...')batch_size = trial.params['batch_size']train_loader, val_loader, test_loader = get_mnist_loaders(batch_size)# 创建最终模型final_model = CustomCNN(n_conv_layers=trial.params['n_conv_layers'],n_filters=trial.params['n_filters'],kernel_size=trial.params['kernel_size'],dropout_rate=trial.params['dropout_rate'],n_fc_layers=trial.params['n_fc_layers'],fc_units=trial.params['fc_units']).to(device)# 配置优化器optimizer_name = trial.params['optimizer']lr = trial.params['lr']if optimizer_name == 'Adam':optimizer = optim.Adam(final_model.parameters(), lr=lr)elif optimizer_name == 'SGD':optimizer = optim.SGD(final_model.parameters(), lr=lr)else:  # RMSpropoptimizer = optim.RMSprop(final_model.parameters(), lr=lr)# 训练最终模型final_history = train_model(final_model, train_loader, val_loader, optimizer, n_epochs=30, patience=10)# 可视化训练历史plot_training_history(final_history, "Final Model Training")# 评估最终模型test_loss, test_accuracy = evaluate_model(final_model, test_loader)# 保存最终模型torch.save(final_model.state_dict(), "best_mnist_model_optuna.pth")print(f'\nFinal model saved with test accuracy: {test_accuracy:.4f}')if __name__ == "__main__":main()

最后，让我们创建一个可视化工具来展示Optuna优化过程及其结果：

import os
import pickle
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import optuna
from optuna.visualization import (plot_optimization_history, plot_param_importances,plot_contour, plot_slice, plot_parallel_coordinate
)# 自定义可视化样式
plt.style.use('seaborn-v0_8-whitegrid')
sns.set_palette("viridis")
plt.rcParams['figure.figsize'] = (12, 8)
plt.rcParams['font.size'] = 12# 保存和加载Optuna Study
def save_study(study, filename):"""保存Optuna study到文件"""with open(filename, 'wb') as f:pickle.dump(study, f)print(f"Study saved to {filename}")def load_study(filename):"""从文件加载Optuna study"""with open(filename, 'rb') as f:study = pickle.load(f)print(f"Study loaded from {filename} with {len(study.trials)} trials")return study# 创建基础可视化
def create_basic_visualizations(study, output_dir="optuna_visualizations"):"""创建基本的Optuna可视化并保存"""# 创建输出目录os.makedirs(output_dir, exist_ok=True)# 1. 优化历史fig = plot_optimization_history(study)fig.write_image(f"{output_dir}/optimization_history.png")# 2. 参数重要性fig = plot_param_importances(study)fig.write_image(f"{output_dir}/param_importances.png")# 3. 并行坐标图fig = plot_parallel_coordinate(study)fig.write_image(f"{output_dir}/parallel_coordinate.png")print(f"Basic visualizations saved to {output_dir}")# 创建详细的参数分析
def create_detailed_param_analysis(study, output_dir="optuna_visualizations"):"""为每个重要参数创建详细的分析图"""os.makedirs(output_dir, exist_ok=True)# 获取所有参数名称param_names = list(study.best_params.keys())# 对每个参数创建切片图for param in param_names:try:fig = plot_slice(study, params=[param])fig.write_image(f"{output_dir}/slice_{param}.png")except Exception as e:print(f"Could not create slice plot for {param}: {e}")# 创建重要参数对的等高线图# 获取最重要的参数（基于参数重要性）try:importances = optuna.importance.get_param_importances(study)top_params = list(importances.keys())[:3]  # 选择前3个重要参数# 对每对重要参数创建等高线图for i in range(len(top_params)):for j in range(i+1, len(top_params)):param1 = top_params[i]param2 = top_params[j]try:fig = plot_contour(study, params=[param1, param2])fig.write_image(f"{output_dir}/contour_{param1}_vs_{param2}.png")except Exception as e:print(f"Could not create contour plot for {param1} vs {param2}: {e}")except Exception as e:print(f"Could not compute parameter importances: {e}")print(f"Detailed parameter analysis saved to {output_dir}")# 创建自定义可视化
def create_custom_visualizations(study, output_dir="optuna_visualizations"):"""创建自定义的可视化图表"""os.makedirs(output_dir, exist_ok=True)# 提取试验数据trials_df = study.trials_dataframe()# 1. 超参数分布与性能关系plt.figure(figsize=(16, 10))# 获取所有参数params = list(study.best_params.keys())n_params = len(params)# 计算子图布局n_cols = 3n_rows = (n_params + n_cols - 1) // n_colsfor i, param in enumerate(params):plt.subplot(n_rows, n_cols, i+1)# 检查参数类型并相应绘图param_values = trials_df[f"params_{param}"]values = trials_df["value"]if param_values.dtype in [np.float64, np.int64]:# 数值参数：散点图plt.scatter(param_values, values, alpha=0.7)plt.xlabel(param)plt.ylabel("Accuracy")# 添加趋势线try:z = np.polyfit(param_values, values, 1)p = np.poly1d(z)plt.plot(sorted(param_values), p(sorted(param_values)), "r--", alpha=0.7)except:passelse:# 分类参数：箱型图sns.boxplot(x=param_values, y=values)plt.xlabel(param)plt.ylabel("Accuracy")plt.tight_layout()plt.savefig(f"{output_dir}/param_performance_relationship.png")# 2. 学习曲线（如果有epoch级别的数据）# 这部分需要在Optuna试验中记录每个epoch的数据# 略过此部分，因为我们的示例代码中没有记录epoch级别的数据# 3. 创建收敛分析图plt.figure(figsize=(10, 6))# 按时间顺序排序的试验值values = [t.value for t in study.trials]best_values = np.maximum.accumulate(values)plt.plot(range(1, len(values)+1), values, "o-", alpha=0.7, label="Trial Value")plt.plot(range(1, len(best_values)+1), best_values, "r-", linewidth=2, label="Best Value")plt.xlabel("Trial Number")plt.ylabel("Accuracy")plt.title("Convergence Analysis")plt.legend()plt.grid(True)plt.savefig(f"{output_dir}/convergence_analysis.png")print(f"Custom visualizations saved to {output_dir}")# 创建超参数相关性分析
def create_correlation_analysis(study, output_dir="optuna_visualizations"):"""分析超参数之间的相关性"""os.makedirs(output_dir, exist_ok=True)# 提取试验数据trials_df = study.trials_dataframe()# 提取参数列param_columns = [col for col in trials_df.columns if col.startswith("params_")]# 只选择数值类型的参数进行相关性分析numeric_params = []for col in param_columns:if trials_df[col].dtype in [np.float64, np.int64]:numeric_params.append(col)if len(numeric_params) >= 2:  # 至少需要两个数值参数才能计算相关性# 计算相关性矩阵correlation = trials_df[numeric_params].corr()# 绘制热图plt.figure(figsize=(10, 8))sns.heatmap(correlation, annot=True, cmap="coolwarm", center=0, fmt=".2f")plt.title("Parameter Correlation Analysis")plt.tight_layout()plt.savefig(f"{output_dir}/parameter_correlation.png")print(f"Correlation analysis saved to {output_dir}")else:print("Not enough numeric parameters for correlation analysis")# 创建超参数重要性雷达图
def create_importance_radar(study, output_dir="optuna_visualizations"):"""创建超参数重要性的雷达图"""os.makedirs(output_dir, exist_ok=True)try:# 获取参数重要性importances = optuna.importance.get_param_importances(study)# 选择最重要的几个参数n_params = min(6, len(importances))top_params = list(importances.keys())[:n_params]top_importances = [importances[param] for param in top_params]# 创建雷达图fig = plt.figure(figsize=(8, 8))ax = fig.add_subplot(111, polar=True)# 计算角度angles = np.linspace(0, 2*np.pi, len(top_params), endpoint=False).tolist()angles += angles[:1]  # 闭合图形# 添加数据values = top_importances + [top_importances[0]]# 绘制雷达图ax.plot(angles, values, 'o-', linewidth=2)ax.fill(angles, values, alpha=0.25)# 设置标签ax.set_thetagrids(np.degrees(angles[:-1]), top_params)ax.set_ylim(0, max(values) * 1.1)ax.set_title("Parameter Importance Radar")plt.tight_layout()plt.savefig(f"{output_dir}/importance_radar.png")print(f"Importance radar chart saved to {output_dir}")except Exception as e:print(f"Could not create importance radar chart: {e}")# 综合报告函数
def generate_optimization_report(study, output_dir="optuna_visualizations"):"""生成综合的优化报告"""print("Generating Optuna optimization visualization report...")# 创建所有可视化create_basic_visualizations(study, output_dir)create_detailed_param_analysis(study, output_dir)create_custom_visualizations(study, output_dir)create_correlation_analysis(study, output_dir)create_importance_radar(study, output_dir)# 创建HTML报告（简单版本）html_path = f"{output_dir}/optimization_report.html"with open(html_path, 'w') as f:f.write(f"""<!DOCTYPE html><html><head><title>Optuna Optimization Report</title><style>body {{ font-family: Arial, sans-serif; margin: 0; padding: 20px; }}h1, h2 {{ color: #333; }}.section {{ margin-bottom: 30px; }}img {{ max-width: 100%; border: 1px solid #ddd; margin: 10px 0; }}.summary {{ background-color: #f5f5f5; padding: 15px; border-radius: 5px; }}</style></head><body><h1>Optuna Hyperparameter Optimization Report</h1><div class="section summary"><h2>Optimization Summary</h2><p><strong>Best trial:</strong> {study.best_trial.number}</p><p><strong>Best value:</strong> {study.best_value:.4f}</p><p><strong>Number of trials:</strong> {len(study.trials)}</p><p><strong>Best parameters:</strong></p><ul>{"".join([f"<li><strong>{k}:</strong> {v}</li>" for k, v in study.best_params.items()])}</ul></div><div class="section"><h2>Optimization History</h2><img src="optimization_history.png" alt="Optimization History"></div><div class="section"><h2>Parameter Importance</h2><img src="param_importances.png" alt="Parameter Importance"><img src="importance_radar.png" alt="Importance Radar"></div><div class="section"><h2>Parameter Relationships</h2><img src="parallel_coordinate.png" alt="Parallel Coordinate"><img src="parameter_correlation.png" alt="Parameter Correlation"><img src="param_performance_relationship.png" alt="Parameter Performance Relationship"></div><div class="section"><h2>Convergence Analysis</h2><img src="convergence_analysis.png" alt="Convergence Analysis"></div></body></html>""")print(f"Report generated at {html_path}")return html_path# 主函数
if __name__ == "__main__":# 这里可以加载一个之前保存的study# study = load_study("optuna_study.pkl")# 或者创建一个示例study（假设已经运行了前面的代码）try:import joblibstudy = joblib.load("mnist_cnn_optimization.pkl")generate_optimization_report(study)except:print("No study file found. Please run optimization first or provide a study object.")

让我继续完成Optuna可视化工具的代码：

自动化模型调优：优化你的Pytorch模型超参数

欢迎来到Pytorch进阶学习计划的第34天！今天我们将深入探讨一个非常重要的主题：自动化模型调优。

在机器学习中，我们常说"垃圾进，垃圾出"，强调数据质量的重要性。但即使有了优质数据，如果超参数选择不当，模型性能同样会大打折扣。对于初学者来说，往往会困惑：为什么同样的模型架构，同样的数据，不同人训练出来的效果可能相差甚远？秘密就在于超参数调优的艺术！

为什么自动化超参数优化很重要？

想象一下这个场景：你花了几周设计一个深度学习模型，经过辛苦训练后，却发现性能不尽如人意。你可能会问自己：

• 学习率是不是选错了？
• 批量大小是不是太大或太小？
• 网络结构是不是需要调整？
• 应该用哪种优化器？

一个复杂的深度学习模型可能有几十个超参数，每个参数又有不同的取值范围。如果手动尝试每种组合，可能需要几个月甚至几年的时间！这就是为什么我们需要自动化超参数优化工具，如Optuna。

超参数优化方法对比

在正式开始实践之前，让我们先了解几种常见的超参数优化方法：

优化方法	工作原理	优势	劣势	适用场景
网格搜索	在预定义的超参数空间中枚举所有可能的组合	简单易实现，结果可复现	计算复杂度随维度指数增长，“维度灾难”	超参数少(<5)，每个超参数取值少
随机搜索	从超参数空间中随机采样组合	比网格搜索更高效，易于理解和并行化	缺乏前后试验的联系，可能会重复探索无效区域	中等数量超参数，计算资源有限
贝叶斯优化	基于先验知识和历史结果，构建超参数-性能映射关系的概率模型	利用历史信息高效搜索，样本利用率高	算法复杂，难以并行化	单次评估代价高，超参数多
Optuna	以TPE（树形Parzen估计器）为核心的贝叶斯优化，支持更多高级特性	高效，支持多目标，支持早停和剪枝，易用性高	相对复杂，有一定学习成本	各类场景，特别是复杂模型调优

Optuna简介

Optuna是由Preferred Networks开发的超参数优化框架，专为机器学习设计。与其他框架相比，它有以下优势：

1. 灵活的搜索空间定义：可以使用条件参数，动态改变搜索空间
2. 高效的采样算法：基于TPE（树形Parzen估计器）的贝叶斯优化
3. 早期停止：可以自动停止表现不佳的试验，节省计算资源
4. 可视化工具：内置多种可视化功能，帮助理解优化过程
5. 支持多目标优化：可以同时优化多个指标，如准确率和速度
6. 分布式优化：支持并行计算，加速优化过程

现在，让我们通过实际例子来学习如何使用Optuna优化Pytorch模型！

实战：使用Optuna优化MNIST分类器

我们将以MNIST数字识别任务为例，展示如何用Optuna优化CNN模型的超参数。

第一步：安装必要的库

首先确保已安装所需的库：

pip install torch torchvision optuna matplotlib pandas

第二步：基本的Optuna优化流程

我们的第一个例子展示了基本的Optuna使用流程。这里我们优化了一个简单CNN的超参数，包括卷积层的过滤器数量、Dropout率、学习率等。

代码结构非常清晰：

1. 定义模型结构
2. 定义训练和评估函数
3. 创建Optuna目标函数，在其中定义超参数搜索空间
4. 运行优化过程
5. 使用最佳超参数训练最终模型

这里的核心是objective函数，它定义了超参数搜索空间并返回性能指标。Optuna会调用这个函数多次，尝试不同的超参数组合，最终找到最优的组合。

第三步：多目标优化

实际应用中，我们通常需要在多个目标之间做权衡，比如模型准确率、推理速度、模型大小等。Optuna支持多目标优化，可以同时优化多个指标。

在多目标优化中，没有单一的"最佳"解，而是一组帕累托最优解（Pareto-optimal solutions）。这些解之间存在权衡关系，根据具体应用场景选择适合的解。

第四步：比较不同优化方法

我们还比较了三种不同的优化方法：贝叶斯优化（TPE）、随机搜索和网格搜索。从结果可以看出贝叶斯优化通常能在相同试验次数下找到更好的解，特别是当超参数数量增多时。

第五步：集成Early Stopping

在实际训练中，一个好的做法是使用早停（Early Stopping）机制，及时终止性能不佳的试验。Optuna支持早停和剪枝功能，可以显著提高优化效率。

第六步：可视化优化结果

Optuna提供了丰富的可视化工具，帮助理解优化过程和分析参数重要性。我们的例子中展示了如何创建综合的可视化报告，包括优化历史、参数重要性、参数相关性等。

优化策略进阶

基于我们的实战经验，这里分享一些超参数优化的进阶策略：

1. 分阶段优化

对于复杂模型，可以采用分阶段优化策略：

• 第一阶段：用较小的数据集、较少的训练轮次，粗略探索超参数空间
• 第二阶段：根据第一阶段结果，缩小搜索空间，用完整数据集进行精细优化

2. 跨模型知识迁移

如果你在相似任务上有过优化经验，可以利用这些知识来缩小初始搜索空间。

3. 考虑计算资源约束

在优化过程中，可以添加计算资源相关的目标，如内存使用、推理时间等，确保优化出的模型适合你的部署环境。

4. 正交化超参数

有些超参数之间存在相关性，可以尝试将它们正交化，减少搜索空间。例如，批量大小和学习率通常有关联，可以考虑同时调整它们。

贝叶斯优化与网格搜索效率对比

从我们的对比实验可以看出，在相同试验次数下：

• 贝叶斯优化（TPE）：通常能找到更好的解，特别是对于高维参数空间
• 随机搜索：简单有效，在低维空间中表现可能接近贝叶斯优化
• 网格搜索：当参数较少时有用，但容易受到"维度灾难"影响

经验法则：

• 超参数少于3个：网格搜索可能足够
• 超参数3-10个：随机搜索或贝叶斯优化
• 超参数10个以上：强烈建议使用贝叶斯优化

实用流程图：Optuna优化流程

下面是一个简化的Optuna优化流程图，帮助你理解整个过程：

+-------------------+     +------------------------+     +--------------------+
| 定义模型和评估函数   | --> | 创建Optuna目标函数       | --> | 定义超参数搜索空间    |
+-------------------+     +------------------------+     +--------------------+|                                                         |v                                                         v
+-------------------+     +------------------------+     +--------------------+
| 使用最佳参数        | <-- | 分析和可视化优化结果       | <-- | 运行优化过程         |
| 训练最终模型        |     |                         |     |                    |
+-------------------+     +------------------------+     +--------------------+

常见问题与解决方案

在使用Optuna进行超参数优化时，你可能会遇到以下问题：

1. 优化时间过长

   • 解决方案：使用剪枝机制，减少试验次数，简化模型结构进行初步探索

2. 搜索空间定义不合理

   • 解决方案：根据领域知识或前人经验，合理设置参数范围；使用对数尺度搜索学习率等参数

3. 过拟合风险

   • 解决方案：使用交叉验证，不要过度相信验证集性能

4. 复现性问题

   • 解决方案：设置随机种子，记录完整的超参数配置

总结

自动化超参数优化是深度学习工作流中的关键环节。通过Optuna等工具，我们可以大大提高模型性能，节省手动调参的时间和精力。特别是对于复杂模型，自动化调优几乎是必不可少的步骤。

在本课中，我们学习了：

• 超参数优化的重要性和基本方法
• 使用Optuna进行单目标和多目标优化
• 贝叶斯优化与网格搜索的效率对比
• 集成早停机制提高优化效率
• 可视化和分析优化结果的方法

参考资源

• Optuna官方文档
• Bayesian Optimization
• Random Search for Hyper-Parameter Optimization

---

清华大学全五版的《DeepSeek教程》完整的文档需要的朋友，关注我私信：deepseek 即可获得。

怎么样今天的内容还满意吗？再次感谢朋友们的观看，关注GZH：凡人的AI工具箱，回复666，送您价值199的AI大礼包。最后，祝您早日实现财务自由，还请给个赞，谢谢！