深度学习调参基础

深度学习调参基础

1.需要调节的超参数有哪些？

• 和网络结构相关的参数：神经网络的网络层数、不同层的类别和搭建顺序、隐藏层神经元的参数设置、LOSS层的选择、正则化参数
• 和训练过程相关的参数：网络权重初始化方法、学习率使用策略、迭代次数、Batch的大小、输入数据相关

2.什么时候需要调参？

• 恰好拟合（一般不需要调参）
• 过拟合
• 欠拟合
• 收敛但震荡
• 不收敛

3.如何调参？

3.1过拟合情况调参

• 增加数据量。收集更多的训练数据，或者通过数据增强（Data Augmentation）的方法来增加数据量。
• 使用正则化技术。L1或L2正则化、Dropout、早停（Early Stopping）
• 减少模型复杂度。减少模型的参数数量，例如减少层数或者每层的神经元数量。
• 使用交叉验证。通过交叉验证来评估模型性能，选择最佳的超参数。
• 调整学习率。使用学习率衰减（Learning Rate Decay）来逐步减小学习率，从而让模型在训练后期更稳定。
• 调整批量大小。增加或减少批量大小（Batch Size），不同的数据集和模型可能需要不同的批量大小来达到最优效果。
• 使用逐层归一化(比如BatchNorm、LayerNorm)。通过在神经网络的每一层输入前加入一个归一化的操作，来使得每个特征的分布更加平稳，减少特征之间的相关性，从而提高模型的泛化能力。

3.2欠拟合情况调参

• 增加模型复杂度。增加神经网络的层数或每层的神经元数量。
• 训练更长时间。增加训练轮数（Epochs）
• 调整学习率。适当增加学习率，以加快模型的收敛速度。
• 减少正则化。减少或移除正则化项（例如L2正则化），以允许模型在训练数据上拟合得更好。降低或移除Dropout层，以减少训练过程中神经元的随机丢弃。
• 优化数据处理。确保数据预处理和归一化步骤没有问题，使数据分布适合模型训练。
• 使用更大的批量大小。

3.3收敛但震荡情况调参

• 降低学习率。学习率过高可能导致模型在收敛过程中震荡。适当降低学习率，模型的更新步骤会变小，从而有助于稳定收敛。
• 使用学习率调度器（如学习率衰减、余弦退火等）来动态调整学习率。
• 增加批量大小。
• 使用梯度裁剪。对梯度进行裁剪（Gradient Clipping），将梯度的最大范数限制在一个固定值以内，防止梯度爆炸和震荡。
• 增加正则化。增加L2正则化或者增加Dropout的比例，可以使模型的权重更新更为平滑，从而减少震荡。
• 确保数据没有问题，数据预处理和归一化步骤正确。
• 适当简化模型架构，减少过深或过宽的网络结构。

3.4不收敛情况调参

• 增加或降低学习率。学习率过高可能导致模型参数更新过大，无法收敛。学习率过低，模型可能收敛得太慢或者陷入局部极小值。
• 增加或降低模型复杂度。模型过于简单，无法拟合数据。模型过于复杂，难以训练。
• 改变激活函数。使用不同的激活函数，如ReLU、Leaky ReLU、ELU、Swish等。
• 调整优化器。尝试不同的优化器，如Adam、RMSprop、SGD with Momentum等。
• 增加批量大小。
• 增加训练次数。
• 使用合适的权重初始化方法，如He初始化或Xavier初始化，确保模型在训练初期不会因为不合理的权重导致无法收敛。

4.调参示例

补充知识：

len(dataloader)：返回batch的数量，即一个数据集总共有多少个 batch。

len(dataloader.dataset)：返回数据集中样本的数量，即 dataset 的长度。

"""
coding:utf-8
* @Author:FHTT-Tian
* @name:Adjust Parameter.py
* @Time:2024/7/10 星期三 16:39
* @Description: 调参示例代码，未调参之前
"""

# 手写数字识别数据集mnist
import torch
import torchvision.datasets as dataset
import torchvision.transforms as transforms
from matplotlib import pyplot as plt
from torch import nn, optim
from torch.utils.data import DataLoader

# 定义超参数
batch_size = 64
hidden_size = 64  # 神经元个数
learning_rate = 0.001
num_epochs = 10
input_size = 784  # 28*28
num_classes = 10

# 定义存放loss的列表
train_loss_list = []
test_loss_list = []

# 对图片进行预处理
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,), )])

# 下载数据集并预处理
trainset = dataset.MNIST(root="./MINST", train=True, download=True, transform=transform)
testset = dataset.MNIST(root="./MINST", train=False, download=True, transform=transform)

# dataloader设置,加载数据集
train_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False)


# 构建网络
class Net(nn.Module):
    def __init__(self, input_size, hideen_size, num_classes):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hideen_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hideen_size, num_classes)

    def forward(self, x):
        out = self.fc1(x.view(-1, input_size))
        out = self.relu(out)
        out = self.fc2(out)
        return out


# 网络实例化
model = Net(input_size, hidden_size, num_classes)

# 定义损失
criterion = nn.CrossEntropyLoss()

# 定义优化器
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

# 训练
total_step = len(train_loader)  # len(dataloader):返回batch的数量，即一个数据集总共有多少个batch
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        outputs = model(images)
        loss = criterion(outputs, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        train_loss_list.append(loss.item())  # train_loss_list 里面存的是每个batch对应的loss，loss.item() 返回的是当前批次的损失值。

        if (i + 1) % 100 == 0:
            print("Epoch [{}/{}], Step [{}/{}], Train Loss:{:.4f}".format(epoch + 1, num_epochs, i + 1, total_step,
                                                                          loss.item()))
    # 设置模型为评估模式
    model.eval()

    with torch.no_grad():
        test_loss = 0.0
        for images, labels in test_loader:
            outputs = model(images)
            loss = criterion(outputs, labels)

            test_loss += loss.item() * images.size(0)  # 当前批次的损失乘以该批次的样本数，然后累加到 test_loss。为了计算整个测试数据集的总损失

        # len(dataloader.dataset):返回数据集中样本的数量，即dataset的长度。将累加的总损失除以测试数据集的总样本数，以获得平均损失。
        test_loss /= len(test_loader.dataset)

        test_loss_list.extend([test_loss] * total_step)  # 将平均测试损失值 test_loss 复制成长度为 total_step 的列表

    # 设置模型为训练模式
    model.train()

    print("Epoch [{}/{}], Test Loss:{:.4f}".format(epoch + 1, num_epochs, test_loss))

# 绘制训练与测试的loss曲线
plt.plot(train_loss_list, label="Train Loss")
plt.plot(test_loss_list, label="Test Loss")
plt.title("Model Loss")
plt.xlabel("Iterations")
plt.ylabel("Loss")
plt.legend()
plt.show()

• 将SGD优化器改为Adam优化器查看模型效果：

optimizer = optim.Adam(model.parameters(), lr=learning_rate)

• 将batch_size修改为128，learning_rate修改为0.0001，查看模型的效果。

总结：如果出现过拟合、欠拟合、收敛但震荡或不收敛的情况，尝试使用相应的调参方法进行调整，以期得到较好的结果。建议在一个好的骨干网络下修改模型，这样大多数参数已经调得很好，不需要我们调整。因此，主要任务是添加模块，如果效果不佳，则更换模块✌。

参考

• 如何解决过拟合👀
• 炼丹笔记六 : 调参技巧
• 自动调参工具Optuna
• Pytorch 数据加载—Dataset和DataLoader详解
• 抑制过拟合——从梯度的角度看LayerNorm的作用

😃😃😃