实战：MNIST 上调参全流程演示

📚 《从零到一造大脑：AI架构入门之旅》专栏
专栏定位：面向中学生、大学生和 AI 初学者的科普专栏，用大白话和生活化比喻带你从零理解人工智能
本系列共 43 篇，分为八大模块：

• 📖 模块一【AI 基础概念】(3 篇)：AI/ML/DL 关系、学习方式、深度之谜
• 🧠 模块二【神经网络入门】(4 篇)：神经元、权重、激活函数、MLP
• 🏗️ 模块三【深度学习核心】(6 篇)：损失函数、梯度下降、反向传播、过拟合、Batch/Epoch/LR
• 🎯 模块四【注意力机制】(5 篇)：从 Attention 到 Transformer
• 🔬 模块五【NCT 与 CATS-NET 案例】(8 篇)：真实架构演进全记录
• 🔄 模块六【架构融合方法】(6 篇)：如何设计混合架构
• ⚙️ 模块七【调参炼丹术】(7 篇)：学习率、正则化、超参数搜索
• 🚀 模块八【综合应用展望】(4 篇)：未来趋势与职业规划
  本文是模块七第 6 篇，带你完成一个完整的调参实战项目。

👨‍💻 作者简介：NeuroConscious Research Team，一群热爱 AI 科普的研究者，专注于神经科学启发的 AI架构设计与可解释性研究。理念：“再复杂的概念，也能用大白话讲清楚”。

💻 项目地址：https://github.com/wyg5208/nct.git
🌐 官网地址：https://neuroconscious.link
📝 作者 CSDN：https://blog.csdn.net/yweng18
📦 NCT PyPI：https://pypi.org/project/neuroconscious-transformer/
⭐ 欢迎 Star⭐、Fork🍴、贡献代码🤝

---

📌 本文核心比喻：烹饪大赛——从准备食材到完美上菜
⏱️ 阅读时间：约 30 分钟
🎯 学习目标：掌握完整的调参流程，学会系统化优化模型性能

---

📝 文章摘要

本文是一个完整的调参实战记录。我们从一个简单的基线模型开始，逐步调整学习率、Batch Size、正则化、学习率调度等超参数，最终将 MNIST 手写数字识别的准确率从 85% 提升到 98% 以上。每一轮调整都有完整的代码和结果分析，你可以跟着一步步复现。

---

🎯 你需要先了解

阅读本文前，建议你：

• ✅ 了解学习率的概念（参考第 10 篇）
• ✅ 知道正则化的作用（参考第 39、40 篇）
• ✅ 了解学习率调度策略（参考第 41 篇）
• ✅ 能够运行 PyTorch 代码

如果还没读前文，[点这里返回](41-学习率调度 让学习先快后慢_version_B.md)

---

📖 正文

一、调参全流程概览

1.1 像烹饪大赛一样调参

食材准备 → 数据加载和预处理

基础菜谱 → 建立基线模型

调味试验 → 学习率搜索

火候把控 → Batch Size 选择

点缀装饰 → 正则化调整

最后收汁 → 学习率调度

上菜摆盘 → 最终评估

1.2 调参流程图

MNIST 调参全流程

步骤	操作	目标准确率
Step 1	数据准备	-
Step 2	建立基线模型	~85%
Step 3	学习率搜索（找到最优 LR）	-
Step 4	Batch Size 调整	-
Step 5	模型容量调整（加层/加宽）	-
Step 6	正则化（Dropout + L2）	-
Step 7	学习率调度器	-
Step 8	数据增强	-
Step 9	最终评估	~98%

1.3 调参记录表模板

我们用这个表格记录每一步的结果：

轮次	修改内容	训练准确率	测试准确率	提升
基线	2层MLP	85%	85%	-
1	增加模型容量	92%	92%	+7%
2	调整学习率	94%	94%	+2%
…	…	…	…	…

---

二、Step 1：数据准备

2.1 加载 MNIST 数据集

"""
MNIST 调参实战 - Step 1: 数据准备
"""
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
import numpy as np
import time
from datetime import datetime

# 设置随机种子，保证可复现
torch.manual_seed(42)
np.random.seed(42)

# 设备选择
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"使用设备: {device}")

# 数据预处理
# MNIST 数据范围是 0-255，归一化到 -1 到 1
transform = transforms.Compose([
    transforms.ToTensor(),  # 转为 Tensor，范围 0-1
    transforms.Normalize((0.1307,), (0.3081,))  # 标准化
])

# 加载数据集
train_dataset = datasets.MNIST(
    root='./data', 
    train=True, 
    download=True, 
    transform=transform
)

test_dataset = datasets.MNIST(
    root='./data', 
    train=False, 
    download=True, 
    transform=transform
)

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

print(f"训练集大小: {len(train_dataset)}")
print(f"测试集大小: {len(test_dataset)}")
print(f"每批数据形状: {next(iter(train_loader))[0].shape}")

输出：

使用设备: cuda
训练集大小: 60000
测试集大小: 10000
每批数据形状: torch.Size([64, 1, 28, 28])

2.2 可视化数据样本

def visualize_samples(dataset, num_samples=10):
    """可视化数据样本"""
    fig, axes = plt.subplots(2, 5, figsize=(12, 5))
    
    for i, ax in enumerate(axes.flat):
        img, label = dataset[i]
        # 反归一化显示
        img = img.squeeze() * 0.3081 + 0.1307
        ax.imshow(img, cmap='gray')
        ax.set_title(f"Label: {label}")
        ax.axis('off')
    
    plt.tight_layout()
    plt.savefig('images/img_42_mnist_samples.png', dpi=150, bbox_inches='tight')
    plt.show()

visualize_samples(train_dataset)

---

三、Step 2：建立基线模型

3.1 基线模型定义

"""
MNIST 调参实战 - Step 2: 基线模型
"""

class BaselineModel(nn.Module):
    """
    基线模型：简单的 2 层 MLP
    784 → 128 → 10
    """
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(784, 128)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = self.flatten(x)
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 创建模型
model = BaselineModel().to(device)
print(model)

# 统计参数数量
total_params = sum(p.numel() for p in model.parameters())
print(f"模型参数数量: {total_params:,}")

输出：

BaselineModel(
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (fc1): Linear(in_features=784, out_features=128, bias=True)
  (relu): ReLU()
  (fc2): Linear(in_features=128, out_features=10, bias=True)
)
模型参数数量: 101,770

3.2 训练和评估函数

def train_epoch(model, train_loader, optimizer, criterion, device):
    """训练一个 epoch"""
    model.train()
    total_loss = 0
    correct = 0
    total = 0
    
    for data, target in train_loader:
        data, target = data.to(device), target.to(device)
        
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item() * data.size(0)
        _, predicted = output.max(1)
        total += target.size(0)
        correct += predicted.eq(target).sum().item()
    
    return total_loss / total, correct / total

def evaluate(model, test_loader, criterion, device):
    """评估模型"""
    model.eval()
    total_loss = 0
    correct = 0
    total = 0
    
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            loss = criterion(output, target)
            
            total_loss += loss.item() * data.size(0)
            _, predicted = output.max(1)
            total += target.size(0)
            correct += predicted.eq(target).sum().item()
    
    return total_loss / total, correct / total

def train_model(model, train_loader, test_loader, optimizer, criterion, 
                scheduler=None, epochs=10, device='cpu'):
    """完整训练流程"""
    history = {
        'train_loss': [], 'train_acc': [],
        'test_loss': [], 'test_acc': [],
        'lr': []
    }
    
    start_time = time.time()
    
    for epoch in range(epochs):
        # 训练
        train_loss, train_acc = train_epoch(
            model, train_loader, optimizer, criterion, device
        )
        
        # 评估
        test_loss, test_acc = evaluate(
            model, test_loader, criterion, device
        )
        
        # 记录学习率
        current_lr = optimizer.param_groups[0]['lr']
        
        # 更新学习率（如果有调度器）
        if scheduler is not None:
            if isinstance(scheduler, optim.lr_scheduler.ReduceLROnPlateau):
                scheduler.step(test_loss)
            else:
                scheduler.step()
        
        # 记录历史
        history['train_loss'].append(train_loss)
        history['train_acc'].append(train_acc)
        history['test_loss'].append(test_loss)
        history['test_acc'].append(test_acc)
        history['lr'].append(current_lr)
        
        # 打印进度
        print(f"Epoch {epoch+1:2d}/{epochs}: "
              f"Train Loss={train_loss:.4f}, Train Acc={train_acc:.4f}, "
              f"Test Loss={test_loss:.4f}, Test Acc={test_acc:.4f}, "
              f"LR={current_lr:.6f}")
    
    total_time = time.time() - start_time
    print(f"\n训练完成! 总用时: {total_time:.1f}秒")
    
    return history

3.3 训练基线模型

# 训练配置
LEARNING_RATE = 0.001
BATCH_SIZE = 64
EPOCHS = 10

# 重新创建数据加载器（使用当前 Batch Size）
train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

# 创建模型、优化器、损失函数
model = BaselineModel().to(device)
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
criterion = nn.CrossEntropyLoss()

# 训练
print("=" * 60)
print("基线模型训练")
print("=" * 60)
history_baseline = train_model(
    model, train_loader, test_loader, optimizer, criterion,
    epochs=EPOCHS, device=device
)

# 记录结果
results_log = []
results_log.append({
    'name': '基线模型',
    'config': f'LR={LEARNING_RATE}, BS={BATCH_SIZE}, Epochs={EPOCHS}',
    'train_acc': history_baseline['train_acc'][-1],
    'test_acc': history_baseline['test_acc'][-1],
})

输出：

============================================================
基线模型训练
============================================================
Epoch  1/10: Train Loss=0.3521, Train Acc=0.9012, Test Loss=0.3124, Test Acc=0.9102, LR=0.001000
Epoch  2/10: Train Loss=0.2105, Train Acc=0.9389, Test Loss=0.2845, Test Acc=0.9187, LR=0.001000
Epoch  3/10: Train Loss=0.1723, Train Acc=0.9501, Test Loss=0.2543, Test Acc=0.9265, LR=0.001000
...
Epoch 10/10: Train Loss=0.0912, Train Acc=0.9723, Test Loss=0.1845, Test Acc=0.9487, LR=0.001000

训练完成! 总用时: 45.2秒

---

四、Step 3：学习率搜索

4.1 学习率网格搜索

"""
MNIST 调参实战 - Step 3: 学习率搜索
"""

def learning_rate_search(train_loader, test_loader, lr_list, epochs=5, device='cpu'):
    """学习率搜索"""
    results = {}
    
    for lr in lr_list:
        print(f"\n{'='*50}")
        print(f"测试学习率: {lr}")
        print('='*50)
        
        model = BaselineModel().to(device)
        optimizer = optim.Adam(model.parameters(), lr=lr)
        criterion = nn.CrossEntropyLoss()
        
        history = train_model(
            model, train_loader, test_loader, optimizer, criterion,
            epochs=epochs, device=device
        )
        
        results[lr] = history['test_acc'][-1]
    
    return results

# 学习率候选列表
lr_candidates = [0.0001, 0.001, 0.01, 0.1]

# 运行搜索
print("开始学习率搜索...")
lr_results = learning_rate_search(
    train_loader, test_loader, lr_candidates, 
    epochs=5, device=device
)

# 打印结果
print("\n" + "=" * 60)
print("学习率搜索结果")
print("=" * 60)
for lr, acc in sorted(lr_results.items()):
    print(f"LR = {lr:8.5f} → 测试准确率 = {acc:.4f} ({acc*100:.2f}%)")

# 找到最佳学习率
best_lr = max(lr_results, key=lr_results.get)
print(f"\n最佳学习率: {best_lr}")

输出：

============================================================
学习率搜索结果
============================================================
LR = 0.00010 → 测试准确率 = 0.9312 (93.12%)
LR = 0.00100 → 测试准确率 = 0.9487 (94.87%)
LR = 0.01000 → 测试准确率 = 0.9652 (96.52%)  ← 最佳
LR = 0.10000 → 测试准确率 = 0.7234 (72.34%)  ← 发散

最佳学习率: 0.01

4.2 学习率搜索可视化

def plot_lr_search(lr_results):
    """可视化学习率搜索结果"""
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
    
    lrs = list(lr_results.keys())
    accs = list(lr_results.values())
    
    # 准确率柱状图
    colors = ['green' if a == max(accs) else 'steelblue' for a in accs]
    ax1.bar(range(len(lrs)), [a*100 for a in accs], color=colors)
    ax1.set_xticks(range(len(lrs)))
    ax1.set_xticklabels([f'{lr:.5f}' for lr in lrs], rotation=45)
    ax1.set_xlabel('Learning Rate')
    ax1.set_ylabel('Test Accuracy (%)')
    ax1.set_title('Learning Rate vs Accuracy')
    ax1.grid(True, alpha=0.3, axis='y')
    
    # 对数尺度折线图
    ax2.semilogx(lrs, [a*100 for a in accs], 'bo-', linewidth=2, markersize=10)
    ax2.set_xlabel('Learning Rate (log scale)')
    ax2.set_ylabel('Test Accuracy (%)')
    ax2.set_title('Learning Rate Search (Log Scale)')
    ax2.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.savefig('images/img_42_lr_search.png', dpi=150, bbox_inches='tight')
    plt.show()

plot_lr_search(lr_results)

4.3 使用最佳学习率重新训练

# 使用最佳学习率重新训练
BEST_LR = 0.01
EPOCHS = 15

model = BaselineModel().to(device)
optimizer = optim.Adam(model.parameters(), lr=BEST_LR)
criterion = nn.CrossEntropyLoss()

print("=" * 60)
print(f"使用最佳学习率 {BEST_LR} 训练")
print("=" * 60)
history_best_lr = train_model(
    model, train_loader, test_loader, optimizer, criterion,
    epochs=EPOCHS, device=device
)

results_log.append({
    'name': '调整学习率',
    'config': f'LR={BEST_LR}, Epochs={EPOCHS}',
    'train_acc': history_best_lr['train_acc'][-1],
    'test_acc': history_best_lr['test_acc'][-1],
})

---

五、Step 4：增加模型容量

5.1 定义更大的模型

"""
MNIST 调参实战 - Step 4: 增加模型容量
"""

class LargerModel(nn.Module):
    """
    更大的模型：3 层 MLP
    784 → 256 → 128 → 10
    """
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.layers = nn.Sequential(
            nn.Linear(784, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )
    
    def forward(self, x):
        x = self.flatten(x)
        return self.layers(x)

model = LargerModel().to(device)
total_params = sum(p.numel() for p in model.parameters())
print(f"更大的模型参数数量: {total_params:,}")
# 输出: 更大的模型参数数量: 235,146

5.2 训练更大的模型

model = LargerModel().to(device)
optimizer = optim.Adam(model.parameters(), lr=BEST_LR)
criterion = nn.CrossEntropyLoss()

print("=" * 60)
print("训练更大的模型")
print("=" * 60)
history_larger = train_model(
    model, train_loader, test_loader, optimizer, criterion,
    epochs=EPOCHS, device=device
)

results_log.append({
    'name': '增加模型容量',
    'config': '784→256→128→10',
    'train_acc': history_larger['train_acc'][-1],
    'test_acc': history_larger['test_acc'][-1],
})

输出：

============================================================
训练更大的模型
============================================================
Epoch  1/15: Train Loss=0.2423, Train Acc=0.9287, Test Loss=0.2156, Test Acc=0.9356, LR=0.010000
...
Epoch 15/15: Train Loss=0.0512, Train Acc=0.9834, Test Loss=0.0723, Test Acc=0.9785, LR=0.010000

训练完成! 总用时: 52.3秒

---

六、Step 5：添加正则化

6.1 添加 Dropout 和 L2 正则化

"""
MNIST 调参实战 - Step 5: 添加正则化
"""

class RegularizedModel(nn.Module):
    """
    带正则化的模型
    - Dropout 层防止过拟合
    - L2 正则化通过 weight_decay 实现
    """
    def __init__(self, dropout_rate=0.3):
        super().__init__()
        self.flatten = nn.Flatten()
        self.layers = nn.Sequential(
            nn.Linear(784, 256),
            nn.ReLU(),
            nn.Dropout(dropout_rate),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(dropout_rate),
            nn.Linear(128, 10)
        )
    
    def forward(self, x):
        x = self.flatten(x)
        return self.layers(x)

# 创建模型
model = RegularizedModel(dropout_rate=0.3).to(device)

# weight_decay 就是 L2 正则化
optimizer = optim.Adam(model.parameters(), lr=BEST_LR, weight_decay=1e-4)
criterion = nn.CrossEntropyLoss()

print("=" * 60)
print("训练带正则化的模型")
print("=" * 60)
history_regularized = train_model(
    model, train_loader, test_loader, optimizer, criterion,
    epochs=EPOCHS, device=device
)

results_log.append({
    'name': '添加正则化',
    'config': 'Dropout=0.3, L2=1e-4',
    'train_acc': history_regularized['train_acc'][-1],
    'test_acc': history_regularized['test_acc'][-1],
})

Dropout：训练时随机"关掉"一些神经元

• 防止神经元之间过度依赖

• 增强模型的泛化能力

L2 正则化（Weight Decay）：惩罚大权重

• 防止权重过大

• 让模型更简单、更泛化

---

七、Step 6：添加学习率调度器

7.1 使用 Cosine Annealing 调度器

"""
MNIST 调参实战 - Step 6: 学习率调度
"""
from torch.optim.lr_scheduler import CosineAnnealingLR

model = RegularizedModel(dropout_rate=0.3).to(device)
optimizer = optim.Adam(model.parameters(), lr=BEST_LR, weight_decay=1e-4)
criterion = nn.CrossEntropyLoss()

# 添加学习率调度器
scheduler = CosineAnnealingLR(optimizer, T_max=EPOCHS, eta_min=1e-5)

print("=" * 60)
print("训练带学习率调度的模型")
print("=" * 60)
history_scheduler = train_model(
    model, train_loader, test_loader, optimizer, criterion,
    scheduler=scheduler, epochs=EPOCHS, device=device
)

results_log.append({
    'name': '学习率调度',
    'config': 'CosineAnnealing',
    'train_acc': history_scheduler['train_acc'][-1],
    'test_acc': history_scheduler['test_acc'][-1],
})

7.2 可视化学习率调度效果

def plot_history_with_lr(history, title):
    """可视化训练历史和学习率"""
    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
    
    # Loss 曲线
    axes[0].plot(history['train_loss'], 'b-', label='Train', linewidth=2)
    axes[0].plot(history['test_loss'], 'r-', label='Test', linewidth=2)
    axes[0].set_xlabel('Epoch')
    axes[0].set_ylabel('Loss')
    axes[0].set_title('Loss Curve')
    axes[0].legend()
    axes[0].grid(True, alpha=0.3)
    
    # 准确率曲线
    axes[1].plot(history['train_acc'], 'b-', label='Train', linewidth=2)
    axes[1].plot(history['test_acc'], 'r-', label='Test', linewidth=2)
    axes[1].set_xlabel('Epoch')
    axes[1].set_ylabel('Accuracy')
    axes[1].set_title('Accuracy Curve')
    axes[1].legend()
    axes[1].grid(True, alpha=0.3)
    
    # 学习率曲线
    axes[2].plot(history['lr'], 'g-', linewidth=2)
    axes[2].set_xlabel('Epoch')
    axes[2].set_ylabel('Learning Rate')
    axes[2].set_title('Learning Rate Schedule')
    axes[2].grid(True, alpha=0.3)
    
    plt.suptitle(title, fontsize=14)
    plt.tight_layout()
    plt.savefig('images/img_42_training_history.png', dpi=150, bbox_inches='tight')
    plt.show()

plot_history_with_lr(history_scheduler, '完整调参流程训练曲线')

---

八、Step 7：数据增强

8.1 添加数据增强

"""
MNIST 调参实战 - Step 7: 数据增强
"""

# 训练集使用数据增强
train_transform = transforms.Compose([
    transforms.RandomRotation(10),  # 随机旋转 ±10 度
    transforms.RandomAffine(0, translate=(0.1, 0.1)),  # 随机平移
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 测试集不使用数据增强
test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 重新加载数据
train_dataset_aug = datasets.MNIST(
    root='./data', train=True, download=True, transform=train_transform
)
test_dataset = datasets.MNIST(
    root='./data', train=False, download=True, transform=test_transform
)

train_loader_aug = DataLoader(train_dataset_aug, batch_size=64, shuffle=True)

# 训练
model = RegularizedModel(dropout_rate=0.3).to(device)
optimizer = optim.Adam(model.parameters(), lr=BEST_LR, weight_decay=1e-4)
scheduler = CosineAnnealingLR(optimizer, T_max=EPOCHS, eta_min=1e-5)

print("=" * 60)
print("训练带数据增强的模型")
print("=" * 60)
history_aug = train_model(
    model, train_loader_aug, test_loader, optimizer, criterion,
    scheduler=scheduler, epochs=EPOCHS, device=device
)

results_log.append({
    'name': '数据增强',
    'config': 'RandomRotation(10) + RandomAffine',
    'train_acc': history_aug['train_acc'][-1],
    'test_acc': history_aug['test_acc'][-1],
})

8.2 可视化数据增强效果

def show_augmentation_effects(dataset, num_samples=5):
    """展示数据增强效果"""
    fig, axes = plt.subplots(3, num_samples, figsize=(15, 9))
    
    for i in range(num_samples):
        # 原图
        img, label = dataset[i]
        axes[0, i].imshow(img.squeeze(), cmap='gray')
        axes[0, i].set_title(f'Original: {label}')
        axes[0, i].axis('off')
        
        # 增强后的图（多次采样）
        for j in range(1, 3):
            aug_img, _ = dataset[i]
            axes[j, i].imshow(aug_img.squeeze(), cmap='gray')
            axes[j, i].set_title(f'Augmented {j}')
            axes[j, i].axis('off')
    
    plt.tight_layout()
    plt.savefig('images/img_42_data_augmentation.png', dpi=150, bbox_inches='tight')
    plt.show()

show_augmentation_effects(train_dataset_aug)

---

九、最终结果汇总

9.1 调参记录汇总表

import pandas as pd

def print_results_table(results_log):
    """打印调参结果汇总表"""
    df = pd.DataFrame(results_log)
    df['improvement'] = df['test_acc'].diff().fillna(0)
    
    print("\n" + "=" * 80)
    print("调参结果汇总表")
    print("=" * 80)
    print(df.to_string(index=False))
    
    # 计算总提升
    baseline_acc = df['test_acc'].iloc[0]
    final_acc = df['test_acc'].iloc[-1]
    total_improvement = final_acc - baseline_acc
    
    print(f"\n总提升: {total_improvement*100:.2f}% (从 {baseline_acc*100:.2f}% 到 {final_acc*100:.2f}%)")
    
    return df

results_df = print_results_table(results_log)

输出示例：

================================================================================
调参结果汇总表
================================================================================
        name                          config  train_acc  test_acc  improvement
    基线模型    LR=0.001, BS=64, Epochs=10   0.9723    0.9487     0.0000
  调整学习率          LR=0.01, Epochs=15   0.9812    0.9652     0.0165
  增加模型容量            784→256→128→10   0.9834    0.9785     0.0133
  添加正则化       Dropout=0.3, L2=1e-4   0.9756    0.9801     0.0016
  学习率调度            CosineAnnealing   0.9778    0.9823     0.0022
    数据增强 RandomRotation(10) + RandomAffine   0.9712    0.9852     0.0029

总提升: 3.65% (从 94.87% 到 98.52%)

9.2 最终结果可视化

def plot_final_comparison(results_log):
    """可视化调参过程对比"""
    names = [r['name'] for r in results_log]
    train_accs = [r['train_acc'] * 100 for r in results_log]
    test_accs = [r['test_acc'] * 100 for r in results_log]
    
    x = np.arange(len(names))
    width = 0.35
    
    fig, ax = plt.subplots(figsize=(14, 6))
    
    bars1 = ax.bar(x - width/2, train_accs, width, label='Train Acc', color='steelblue')
    bars2 = ax.bar(x + width/2, test_accs, width, label='Test Acc', color='coral')
    
    ax.set_ylabel('Accuracy (%)')
    ax.set_title('MNIST 调参过程对比')
    ax.set_xticks(x)
    ax.set_xticklabels(names, rotation=30, ha='right')
    ax.legend()
    ax.grid(True, alpha=0.3, axis='y')
    
    # 添加数值标签
    for bar in bars2:
        height = bar.get_height()
        ax.annotate(f'{height:.1f}%',
                    xy=(bar.get_x() + bar.get_width() / 2, height),
                    xytext=(0, 3),
                    textcoords="offset points",
                    ha='center', va='bottom', fontsize=9)
    
    plt.tight_layout()
    plt.savefig('images/img_42_final_comparison.png', dpi=150, bbox_inches='tight')
    plt.show()

plot_final_comparison(results_log)

---

十、完整代码总结

10.1 一键运行完整流程

"""
MNIST 调参实战 - 完整流程
将所有步骤整合成一个可复现的脚本
"""

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torch.optim.lr_scheduler import CosineAnnealingLR
import matplotlib.pyplot as plt
import numpy as np

# ==================== 配置 ====================
CONFIG = {
    'device': 'cuda' if torch.cuda.is_available() else 'cpu',
    'batch_size': 64,
    'learning_rate': 0.01,
    'epochs': 20,
    'dropout': 0.3,
    'weight_decay': 1e-4,
}

print(f"配置: {CONFIG}")

# ==================== 数据 ====================
train_transform = transforms.Compose([
    transforms.RandomRotation(10),
    transforms.RandomAffine(0, translate=(0.1, 0.1)),
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

train_dataset = datasets.MNIST('./data', train=True, download=True, transform=train_transform)
test_dataset = datasets.MNIST('./data', train=False, download=True, transform=test_transform)

train_loader = DataLoader(train_dataset, batch_size=CONFIG['batch_size'], shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

# ==================== 模型 ====================
class FinalModel(nn.Module):
    def __init__(self, dropout=0.3):
        super().__init__()
        self.flatten = nn.Flatten()
        self.layers = nn.Sequential(
            nn.Linear(784, 256),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(128, 10)
        )
    
    def forward(self, x):
        x = self.flatten(x)
        return self.layers(x)

# ==================== 训练 ====================
model = FinalModel(dropout=CONFIG['dropout']).to(CONFIG['device'])
optimizer = optim.Adam(model.parameters(), lr=CONFIG['learning_rate'], 
                       weight_decay=CONFIG['weight_decay'])
scheduler = CosineAnnealingLR(optimizer, T_max=CONFIG['epochs'], eta_min=1e-5)
criterion = nn.CrossEntropyLoss()

# 训练循环（使用之前定义的 train_model 函数）
history = train_model(
    model, train_loader, test_loader, optimizer, criterion,
    scheduler=scheduler, epochs=CONFIG['epochs'], device=CONFIG['device']
)

# ==================== 结果 ====================
print(f"\n最终测试准确率: {history['test_acc'][-1]*100:.2f}%")

10.2 调参经验总结

1. 学习率最重要

• 先找到合适的学习率范围

• 使用学习率搜索快速定位

2. 模型容量是基础

• 太小：欠拟合

• 太大：过拟合

• 配合正则化使用

3. 正则化防过拟合

• Dropout：简单有效

• L2：通用选择

• 数据增强：最有效的正则化

4. 学习率调度锦上添花

• Cosine：平滑稳定

• 配合 Warmup：大模型必备

5. 记录和对比

• 每次只改一个参数

• 记录所有实验结果

• 用表格和图表对比

---

⚠️ 常见误区

❌ 误区 1：“一次调所有参数”

真相：

调参应该一次只改一个参数，记录效果，再调下一个。一次改多个参数无法判断哪个改动有效。

---

❌ 误区 2：“训练集准确率越高越好”

真相：

训练集准确率太高可能是过拟合。应该关注测试集准确率，以及训练集和测试集的差距。

---

❌ 误区 3：“照搬别人的超参数”

真相：

不同数据集、不同模型、不同任务的最优超参数可能完全不同。需要针对自己的任务重新调参。

---

💡 一句话总结

记忆口诀：

调参路上要记牢，
一步一步慢慢跑。
学习率先找最佳，
模型容量慢慢加。
正则化要防过拟合，
学习率调度锦上花。
数据增强最有效，
记录对比不抓瞎。

---

🔬 动手实验

实验：复现完整调参流程

按照本文的步骤，从头开始：

1. 建立基线模型
2. 进行学习率搜索
3. 逐步优化
4. 记录每一步的结果

挑战目标：能否通过调参，将测试准确率提升到 99%？

---

📚 延伸阅读

• MNIST 数据集介绍
• PyTorch 训练教程
• 深度学习调参指南

---

✍️ 课后作业

选择题（每题 10 分）

1. 调参时应该？

A. 一次修改多个参数
B. 一次只改一个参数 ✅
C. 随机尝试参数
D. 用默认参数不调

2. 学习率太大会导致？

A. 训练太慢
B. 训练发散 ✅
C. 过拟合
D. 欠拟合

3. 数据增强的主要作用是？

A. 加快训练速度
B. 减少数据量
C. 提升泛化能力 ✅
D. 增加模型参数

---

思考题（20 分）

在本次调参实验中，哪个步骤带来的提升最大？为什么这个改动最有效？结合你的理解，分析不同超参数对模型性能的影响机制。

---

📝 下一篇预告

---