体育门户网站源码重庆最新数据消息
知识点回顾：
- 随机种子
- 内参的初始化
- 神经网络调参指南
- 参数的分类
- 调参的顺序
- 各部分参数的调整心得
作业：对于day'41的简单cnn，看看是否可以借助调参指南进一步提高精度。
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np# 设置中文字体支持
plt.rcParams["font.family"] = ["SimHei"]
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题# 检查GPU是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")# 1. 数据预处理
# 训练集：使用多种数据增强方法提高模型泛化能力
train_transform = transforms.Compose([# 随机裁剪图像，从原图中随机截取32x32大小的区域transforms.RandomCrop(32, padding=4),# 随机水平翻转图像（概率0.5）transforms.RandomHorizontalFlip(),# 随机颜色抖动：亮度、对比度、饱和度和色调随机变化transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),# 随机旋转图像（最大角度15度）transforms.RandomRotation(15),# 将PIL图像或numpy数组转换为张量transforms.ToTensor(),# 标准化处理：每个通道的均值和标准差，使数据分布更合理transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])# 测试集：仅进行必要的标准化，保持数据原始特性，标准化不损失数据信息，可还原
test_transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])# 2. 加载CIFAR-10数据集
train_dataset = datasets.CIFAR10(root='./data',train=True,download=True,transform=train_transform # 使用增强后的预处理
)test_dataset = datasets.CIFAR10(root='./data',train=False,transform=test_transform # 测试集不使用增强
)# 3. 创建数据加载器
batch_size = 128 #优化调参点 由64 ————》128
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)# 4. 定义CNN模型的定义（替代原MLP）
class CNN(nn.Module):def __init__(self):super(CNN, self).__init__() # 继承父类初始化# ---------------------- 第一个卷积块 ----------------------# 卷积层1：输入3通道（RGB），输出32个特征图，卷积核3x3，边缘填充1像素self.conv1 = nn.Conv2d(in_channels=3, # 输入通道数（图像的RGB通道）out_channels=32, # 输出通道数（生成32个新特征图）kernel_size=3, # 卷积核尺寸（3x3像素）padding=1 # 边缘填充1像素，保持输出尺寸与输入相同)# 批量归一化层：对32个输出通道进行归一化，加速训练self.bn1 = nn.BatchNorm2d(num_features=32)# ReLU激活函数：引入非线性，公式：max(0, x)self.relu1 = nn.ReLU()# 最大池化层：窗口2x2，步长2，特征图尺寸减半（32x32→16x16）self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2) # stride默认等于kernel_size# ---------------------- 第二个卷积块 ----------------------# 卷积层2：输入32通道（来自conv1的输出），输出64通道self.conv2 = nn.Conv2d(in_channels=32, # 输入通道数（前一层的输出通道数）out_channels=64, # 输出通道数（特征图数量翻倍）kernel_size=3, # 卷积核尺寸不变padding=1 # 保持尺寸：16x16→16x16（卷积后）→8x8（池化后）)self.bn2 = nn.BatchNorm2d(num_features=64)self.relu2 = nn.ReLU()self.pool2 = nn.MaxPool2d(kernel_size=2) # 尺寸减半：16x16→8x8# ---------------------- 第三个卷积块 ----------------------# 卷积层3：输入64通道，输出128通道self.conv3 = nn.Conv2d(in_channels=64, # 输入通道数（前一层的输出通道数）out_channels=128, # 输出通道数（特征图数量再次翻倍）kernel_size=3,padding=1 # 保持尺寸：8x8→8x8（卷积后）→4x4（池化后）)self.bn3 = nn.BatchNorm2d(num_features=128)self.relu3 = nn.ReLU() # 复用激活函数对象（节省内存）self.pool3 = nn.MaxPool2d(kernel_size=2) # 尺寸减半：8x8→4x4# ---------------------- 全连接层（分类器） ----------------------# 计算展平后的特征维度：128通道 × 4x4尺寸 = 128×16=2048维self.fc1 = nn.Linear(in_features=128 * 4 * 4, # 输入维度（卷积层输出的特征数）out_features=512 # 输出维度（隐藏层神经元数）)# Dropout层：训练时随机丢弃50%神经元，防止过拟合self.dropout = nn.Dropout(p=0.5)# 输出层：将512维特征映射到10个类别（CIFAR-10的类别数）self.fc2 = nn.Linear(in_features=512, out_features=10)def forward(self, x):# 输入尺寸：[batch_size, 3, 32, 32]（batch_size=批量大小，3=通道数，32x32=图像尺寸）# ---------- 卷积块1处理 ----------x = self.conv1(x) # 卷积后尺寸：[batch_size, 32, 32, 32]（padding=1保持尺寸）x = self.bn1(x) # 批量归一化，不改变尺寸x = self.relu1(x) # 激活函数，不改变尺寸x = self.pool1(x) # 池化后尺寸：[batch_size, 32, 16, 16]（32→16是因为池化窗口2x2）# ---------- 卷积块2处理 ----------x = self.conv2(x) # 卷积后尺寸：[batch_size, 64, 16, 16]（padding=1保持尺寸）x = self.bn2(x)x = self.relu2(x)x = self.pool2(x) # 池化后尺寸：[batch_size, 64, 8, 8]# ---------- 卷积块3处理 ----------x = self.conv3(x) # 卷积后尺寸：[batch_size, 128, 8, 8]（padding=1保持尺寸）x = self.bn3(x)x = self.relu3(x)x = self.pool3(x) # 池化后尺寸：[batch_size, 128, 4, 4]# ---------- 展平与全连接层 ----------# 将多维特征图展平为一维向量：[batch_size, 128*4*4] = [batch_size, 2048]x = x.view(-1, 128 * 4 * 4) # -1自动计算批量维度，保持批量大小不变x = self.fc1(x) # 全连接层：2048→512，尺寸变为[batch_size, 512]x = self.relu3(x) # 激活函数（复用relu3，与卷积块3共用）x = self.dropout(x) # Dropout随机丢弃神经元，不改变尺寸x = self.fc2(x) # 全连接层：512→10，尺寸变为[batch_size, 10]（未激活，直接输出logits）return x # 输出未经过Softmax的logits，适用于交叉熵损失函数# 初始化模型
model = CNN()
model = model.to(device) # 将模型移至GPU（如果可用）criterion = nn.CrossEntropyLoss() # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam优化器# 引入学习率调度器，在训练过程中动态调整学习率--训练初期使用较大的 LR 快速降低损失，训练后期使用较小的 LR 更精细地逼近全局最优解。
# 在每个 epoch 结束后，需要手动调用调度器来更新学习率，可以在训练过程中调用 scheduler.step()
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, # 指定要控制的优化器（这里是Adam）mode='min', # 监测的指标是"最小化"（如损失函数）patience=3, # 如果连续3个epoch指标没有改善，才降低LRfactor=0.6 # 降低LR的比例（新LR = 旧LR × 0.6）
)# 5. 训练模型（记录每个 iteration 的损失）
def train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs):model.train() # 设置为训练模式# 记录每个 iteration 的损失all_iter_losses = [] # 存储所有 batch 的损失iter_indices = [] # 存储 iteration 序号# 记录每个 epoch 的准确率和损失train_acc_history = []test_acc_history = []train_loss_history = []test_loss_history = []for epoch in range(epochs):running_loss = 0.0correct = 0total = 0for batch_idx, (data, target) in enumerate(train_loader):data, target = data.to(device), target.to(device) # 移至GPUoptimizer.zero_grad() # 梯度清零output = model(data) # 前向传播loss = criterion(output, target) # 计算损失loss.backward() # 反向传播optimizer.step() # 更新参数# 记录当前 iteration 的损失iter_loss = loss.item()all_iter_losses.append(iter_loss)iter_indices.append(epoch * len(train_loader) + batch_idx + 1)# 统计准确率和损失running_loss += iter_loss_, predicted = output.max(1)total += target.size(0)correct += predicted.eq(target).sum().item()# 每100个批次打印一次训练信息if (batch_idx + 1) % 100 == 0:print(f'Epoch: {epoch+1}/{epochs} | Batch: {batch_idx+1}/{len(train_loader)} 'f'| 单Batch损失: {iter_loss:.4f} | 累计平均损失: {running_loss/(batch_idx+1):.4f}')# 计算当前epoch的平均训练损失和准确率epoch_train_loss = running_loss / len(train_loader)epoch_train_acc = 100. * correct / totaltrain_acc_history.append(epoch_train_acc)train_loss_history.append(epoch_train_loss)# 测试阶段model.eval() # 设置为评估模式test_loss = 0correct_test = 0total_test = 0with torch.no_grad():for data, target in test_loader:data, target = data.to(device), target.to(device)output = model(data)test_loss += criterion(output, target).item()_, predicted = output.max(1)total_test += target.size(0)correct_test += predicted.eq(target).sum().item()epoch_test_loss = test_loss / len(test_loader)epoch_test_acc = 100. * correct_test / total_testtest_acc_history.append(epoch_test_acc)test_loss_history.append(epoch_test_loss)# 更新学习率调度器scheduler.step(epoch_test_loss)print(f'Epoch {epoch+1}/{epochs} 完成 | 训练准确率: {epoch_train_acc:.2f}% | 测试准确率: {epoch_test_acc:.2f}%')# 绘制所有 iteration 的损失曲线plot_iter_losses(all_iter_losses, iter_indices)# 绘制每个 epoch 的准确率和损失曲线plot_epoch_metrics(train_acc_history, test_acc_history, train_loss_history, test_loss_history)return epoch_test_acc # 返回最终测试准确率# 6. 绘制每个 iteration 的损失曲线
def plot_iter_losses(losses, indices):plt.figure(figsize=(10, 4))plt.plot(indices, losses, 'b-', alpha=0.7, label='Iteration Loss')plt.xlabel('Iteration（Batch序号）')plt.ylabel('损失值')plt.title('每个 Iteration 的训练损失')plt.legend()plt.grid(True)plt.tight_layout()plt.show()# 7. 绘制每个 epoch 的准确率和损失曲线
def plot_epoch_metrics(train_acc, test_acc, train_loss, test_loss):epochs = range(1, len(train_acc) + 1)plt.figure(figsize=(12, 4))# 绘制准确率曲线plt.subplot(1, 2, 1)plt.plot(epochs, train_acc, 'b-', label='训练准确率')plt.plot(epochs, test_acc, 'r-', label='测试准确率')plt.xlabel('Epoch')plt.ylabel('准确率 (%)')plt.title('训练和测试准确率')plt.legend()plt.grid(True)# 绘制损失曲线plt.subplot(1, 2, 2)plt.plot(epochs, train_loss, 'b-', label='训练损失')plt.plot(epochs, test_loss, 'r-', label='测试损失')plt.xlabel('Epoch')plt.ylabel('损失值')plt.title('训练和测试损失')plt.legend()plt.grid(True)plt.tight_layout()plt.show()# 8. 执行训练和测试
epochs = 30 # 增加训练轮次以获得更好效果 优化调参 20 ————》30
print("开始使用CNN训练模型...")
final_accuracy = train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs)
print(f"训练完成！最终测试准确率: {final_accuracy:.2f}%")# # 保存模型
# torch.save(model.state_dict(), 'cifar10_cnn_model.pth')
# print("模型已保存为: cifar10_cnn_model.pth")# 9.对CNN模型进行优化调参 对batchsize、epoch调整，学习率采用adam+ReduceLROnPlateau（学习率0.001）factor改为0.6
一、随机种子
1.torch中使用随机数的场景
（1）权重、偏置的随机初始化
（2）数据加载（shuffling打乱）与批次加载（随机批次加载）的随机化
（3）数据增强的随机化（随机旋转、缩放、平移、裁剪等）
（4）随机正则化dropout
（5）优化器中的随机性
2.随机种子作用
（1）python的随机种子，需要确保random模块、以及一些无序数据结构的一致性
（2）numpy的随机种子，控制数组的随机性
（3）torch的随机种子，控制张量的随机性，在cpu和gpu上均适用
（4）cuDNN（CUDA Deep Neural Network library ，CUDA 深度神经网络库）的随机性，针对cuda的优化算法的随机性
二、参数初始化
避免梯度消失或爆炸：如果神经网络的权重初始化过大或过小，会导致梯度在反向传播过程中迅速消失或爆炸。例如，当权重初始化为非常小的值时，激活函数的导数可能接近于零，使得梯度在传播过程中逐渐减小，导致网络难以更新权重；而当权重初始化为非常大的值时，激活函数的导数可能变得非常大，使得梯度在传播过程中迅速增大，导致权重更新过于剧烈，网络无法收敛。
打破对称性：在多层神经网络中，如果所有权重都初始化为相同的值，那么在训练过程中，每一层的神经元会以相同的方式更新权重，导致网络无法学习到复杂的特征。通过随机初始化权重，可以打破这种对称性，使每个神经元能够学习到不同的特征，从而提高网络的表达能力。
加速收敛：合适的参数初始化可以使网络在训练初期更快地收敛到一个较好的状态，减少训练所需的迭代次数，提高训练效率。
三、神经网络调参
1.神经网络超参数类别
网络参数：包括网络层之间的交互方式（如相加、相乘或串接）、卷积核的数量和尺寸、网络层数（深度）和激活函数等。
优化参数：一般指学习率、批样本数量、不同优化器的参数及部分损失函数的可调参数。
正则化参数：如权重衰减系数、丢弃比率（dropout）。
2.调参顺序
模型能训练（基础配置）→ 提升性能（核心参数）→ 最后，抑制过拟合（正则化）
之前的模型，主要都是停留在第一步，先跑起来。如果想要更进一步提高精度，就需要进一步调参。以下是进一步调参的流程：
（1）参数初始化----有预训练的参数直接起飞
预训练参数是最好的参数初始化方法，在训练前先找找类似的论文有无预训练参数，其次是Xavir，尤其是小数据集的场景，多找论文找到预训练模型是最好的做法。关于预训练参数，我们介绍过了，优先动深层的参数，因为浅层是通用的；其次是学习率要采取分阶段的策略。
如果从0开始训练的话，PyTorch 默认用 Kaiming 初始化（适配 ReLU）或 Xavier 初始化（适配 Sigmoid/Tanh）。
（2）batchsize---测试下能允许的最高值
当Batch Size 太小的时候，模型每次更新学到的东西太少了，很可能白学了因为缺少全局思维。所以尽可能高一点，16的倍数即可，越大越好。
（3）epoch---这个不必多说，默认都是训练到收敛位置，可以采取早停策略
学习率就是参数更新的步长，LR 过大→不好收敛；LR 过小→训练停滞（陷入局部最优）
一般最开始用adam快速收敛，然后sgd收尾，一般精度会高一点；只能选一个就adam配合调度器使用。比如 CosineAnnealingLR余弦退火调度器、StepLR固定步长衰减调度器，比较经典的搭配就是Adam + ReduceLROnPlateau，SGD + CosineAnnealing，或者Adam → SGD + StepLR。
（4）学习率与调度器----收益最高，因为鞍点太多了，模型越复杂鞍点越多
（5）模型结构----消融实验或者对照试验
如卷积核尺寸等，一般就是7*7、5*5、3*3这种奇数对构成，其实我觉得无所谓，最开始不要用太过分的下采样即可。
神经元的参数，直接用 Kaiming 初始化（适配 ReLU，PyTorch 默认）或 Xavier 初始化（适配 Sigmoid/Tanh）。
（6）损失函数---选择比较少，试出来一个即可，高手可以自己构建
大部分我们目前接触的任务都是单个损失函数构成的，正常选即可
分类任务
1) 交叉熵损失函数Cross-Entropy Loss--多分类场景
2) 二元交叉熵损失函数Binary Cross-Entropy Loss--二分类场景
3) Focal Loss----类别不平衡场景
注意点：
- CrossEntropyLoss内置 Softmax，输入应为原始 logits（非概率）。
- BCEWithLogitsLoss内置 Sigmoid，输入应为原始 logits。
- 若评价指标为准确率，用交叉熵损失；若为 F1 分数，考虑 Focal Loss 或自定义损失。
回归任务
1) 均方误差MSE
2) 绝对误差MAE
也要根据场景和数据特点来选，不同损失受到异常值的影响程度不同
（7）激活函数---选择同样较少
视情况选择，一般默认relu或者其变体，如leaky relu，再或者用tanh。只有二分类任务最后的输出层用sigmoid，多分类任务用softmax，其他全部用relu即可。此外，还有特殊场景下的，比如GELU（适配 Transformer）
（8）正则化参数---主要是droupout，等到过拟合了用，上述所有步骤都为了让模型过拟合
droupout一般控制在0.2-0.5之间，这里说一下小技巧，先追求过拟合后追求泛化性。也就是说先把模型做到过拟合，然后在慢慢增加正则化程度。
正则化中，如果train的loss可以很低，但是val的loss还是很高，则说明泛化能力不强，优先让模型过拟合，在考虑加大正则化提高泛化能力，可以分模块来droupout，可以确定具体是那部分参数导致过拟合，这里还有个小trick是引入残差链接后再利用droupout
注：调参顺序并不固定，而且也不是按照重要度来选择，是按照方便程度来选择，比如选择少的选完后，会减小后续实验的成本。
@浙大疏锦行