• ? 本文为?365天深度学习训练营 内部限免文章（版权归 K同学啊 所有）
• ? 作者：K同学啊

1 引言

本文主要实现了构建 CNN 网络实现 cifar-10 的彩色图片分类问题。

1.1 训练营要求

• 学习如何编写一个完整的深度学习程序
• 手动推导卷积层于池化层的计算过程

1.2 训练记录

1. 使用原文章代码进行训练
2. 添加 dropout 层
3. 数据增强

各个训练记录的结果与改进效果将在文章的结果分析部分详细讲解。

结果：最终 val_accuracy 达到 79.37%，并解决原文代码中存在的过拟合问题。

附：由于许多内容在其他文章中都有所涉及，因此在此片笔记中不会过多讲解，但是会附上链接

2 前期工作

2.1 设置 GPU

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

2.2 导入数据

使用 dataset 下载 CIFAR10 数据集，并划分好训练集和测试集
使用 dataloader 加载数据，并设置好基本的 batch_size

from torchvision import transforms


transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])


train_ds = torchvision.datasets.CIFAR10(
    'data',
    train = True,
    transform = transform_train,
    download = True
)

test_ds = torchvision.datasets.CIFAR10(
    'data',
    train = False,
    transform = transform_train,
    download = True
)

batch_size = 32

train_dl = torch.utils.data.DataLoader(
    train_ds,
    batch_size = batch_size,
    shuffle = True
)

test_dl = torch.utils.data.DataLoader(
    test_ds,
    batch_size = batch_size
)

2.2.1 transforms.Compose

在本段代码中使用了 transforms.Compose 函数进行数据增强，包括随机裁剪、随机水平翻转和颜色抖动，然后将图像转换为张量并使用平均值和标准差值进行归一化处理。下面详细讲解一下这一函数。

transforms.Compose 是 PyTorch 中一个用于构建图像预处理流水线的函数，它可以将多个图像预处理操作组合成一个序列，以便对输入数据进行处理。

比如，我们可以将以下三个预处理操作组合成一个序列：

transforms.RandomCrop(32)
transforms.RandomHorizontalFlip()
transforms.ToTensor()

这样，我们就可以使用transforms.Compose将这三个操作组合成一个序列，以便于在训练或测试时一次性对数据进行处理。下面是一个示例：

transform_train = transforms.Compose([
    transforms.RandomCrop(32),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
])

在上面的例子中，transform_train就是一个预处理序列，其中包含了三个步骤：

1. 先进行RandomCrop裁剪操作，
2. 再进行RandomHorizontalFlip翻转操作，
3. 最后将数据转换为张量ToTensor。

这个预处理序列可以被用于对训练数据进行批量处理。

通过组合不同的预处理操作，我们可以构建出非常灵活和强大的预处理流水线，以适应不同的数据集和模型需求。在PyTorch中，transforms模块提供了许多常用的图像预处理函数，如 RandomCrop、Resize、RandomHorizontalFlip、ColorJitter 等，这些函数可以用于构建各种图像预处理操作。

2.3 数据可视化

# 4.可视化图片
'''
将数据集前 20 个图片数据可视化显示
进行图像大小：20 *10 的绘图
'''
import numpy as np

plt.figure(figsize = (20,5))

for i, imgs in enumerate(imgs[:20]):

    npimg = imgs.numpy().transpose((1,2,0))
    plt.subplot(2,10,i+1)
    plt.imshow(npimg, cmap = plt.cm.binary)
    plt.axis("off")

可视化结果如下：

由于在前面处理数据时使用了 transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4)，因此结果可能和原图存在以下差异。

3 构建 CNN 网络

对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类。

3.1 torch.nn.Conv2d()详解

函数原型： torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode=‘zeros’, device=None, dtype=None)

关键参数说明：

• in_channels ( int ) – 输入图像中的通道数
• out_channels ( int ) – 卷积产生的通道数
• kernel_size ( int or tuple ) – 卷积核的大小
• stride ( int or tuple , optional ) – 卷积的步幅。默认值：1
• padding ( int , tuple或str , optional ) – 添加到输入的所有四个边的填充。默认值：0
• dilation (int or tuple, optional) - 扩张操作：控制kernel点（卷积核点）的间距，默认值:1。
• padding_mode (字符串,可选) – ‘zeros’, ‘reflect’, ‘replicate’或’circular’. 默认：‘zeros’

关于dilation参数图解：

3.2 torch.nn.Linear()详解

函数原型：torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)

关键参数说明：

• in_features：每个输入样本的大小
• out_features：每个输出样本的大小

3.3 torch.nn.MaxPool2d()详解

函数原型： torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

关键参数说明：

• kernel_size：最大的窗口大小
• stride：窗口的步幅，默认值为kernel_size
• padding：填充值，默认为0
• dilation：控制窗口中元素步幅的参数

3.4 关于卷积层、池化层的计算：

下面的网络数据shape变化过程为： 3, 32, 32（输入数据） -> 64, 30, 30（经过卷积层1）-> 64, 15, 15（经过池化层1） -> 64, 13, 13（经过卷积层2）-> 64, 6, 6（经过池化层2） -> 128, 4, 4（经过卷积层3） -> 128, 2, 2（经过池化层3） -> 512 -> 256 -> num_classes(10)

网络结构图：

# 构建 CNN 网络

import torch.nn.functional as F

num_classes = 10

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        # 特征提取网络
        self.conv1 = nn.Conv2d(3,64,kernel_size=3)
        self.pool1 = nn.MaxPool2d(kernel_size=2)
        self.dropout = nn.Dropout(p=0.3)

        self.conv2 = nn.Conv2d(64,64,kernel_size=3)
        self.pool2 = nn.MaxPool2d(kernel_size=2)
        self.dropout = nn.Dropout(p=0.3)

        self.conv3 = nn.Conv2d(64,128,kernel_size=3)
        self.pool3 = nn.MaxPool2d(kernel_size=2)
        # self.dropout = nn.Dropout(p=0.3)

        # self.conv4 = nn.Conv2d(128,256,kernel_size=3)
        # self.pool4 = nn.MaxPool2d(kernel_size=2)


        # 分类网络
        self.fc1 = nn.Linear(512, 256)
        self.fc2 = nn.Linear(256, num_classes)


    def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x)))
        x = self.dropout(x)
        x = self.pool2(F.relu(self.conv2(x)))
        x = self.dropout(x)
        x = self.pool3(F.relu(self.conv3(x)))
        # x = self.dropout(x)
        # x = self.pool4(F.relu(self.conv4(x)))

        x = torch.flatten(x, start_dim=1)

        x = F.relu(self.fc1(x))
        x = self.fc2(x)

        return x

# 加载并打印网络

from torchinfo import summary
model = Model().to(device)
summary(model)

4 训练模型

4.1 设置超参数

loss_fn = nn.CrossEntropyLoss()
learn_rate = 1e-2
opt = torch.optim.SGD(model.parameters(), lr=learn_rate)

4.2 编写训练函数

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)

    train_loss, train_acc = 0 , 0

    for x , y in dataloader:
        x, y = x.to(device), y.to(device)

        pred = model(x)
        loss = loss_fn(pred, y)

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

        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc /= size
    train_loss /= num_batches

    return train_acc, train_loss

4.3 编写测试函数

def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)

    test_loss, test_acc = 0 , 0

    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc /= size
    test_loss /= num_batches

    return test_acc, test_loss

4.4 正式训练

epochs = 100
train_loss = []
train_acc = []
test_loss = []
test_acc = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    template = ('Epoch:{:2d},Train_acc:{:.1f}%,Train_loss:{:.3f},Test_acc:{:.1f}%,Test_loss:{:.3f}')
    print(template.format(epoch+1,epoch_train_acc*100,epoch_train_loss,epoch_test_acc*100,epoch_test_loss))

print("Done")

4.4.1 model.train()

model.train()的作用是启用 Batch Normalization 和 Dropout。

如果模型中有BN层(Batch Normalization）和 Dropout，需要在训练时添加model.train()。model.train()是保证BN层能够用到每一批数据的均值和方差。对于Dropout，model.train()是随机取一部分网络连接来训练更新参数。

4.4.2 model.eval()

model.eval()的作用是不启用 Batch Normalization 和 Dropout。

如果模型中有BN层(Batch Normalization）和 Dropout，在测试时添加model.eval()。model.eval()是保证BN层能够用全部训练数据的均值和方差，即测试过程中要保证BN层的均值和方差不变。对于Dropout，model.eval()是利用到了所有网络连接，即不进行随机舍弃神经元。

训练完train样本后，生成的模型model要用来测试样本。在model(test)之前，需要加上model.eval()，否则的话，有输入数据，即使不训练，它也会改变权值。这是model中含有BN层和Dropout所带来的的性质。

5 结果可视化

import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
plt.rcParams['figure.dpi'] = 100

epochs_range = range(epochs)

plt.figure(figsize = (12,3))
plt.subplot(1,2,1)
plt.plot(epochs_range,train_acc,label='Training Accuracy')
plt.plot(epochs_range,test_acc,label='Test Accuracy')
plt.legend()
plt.title("Training and Validation Accuracy")

plt.subplot(1,2,2)
plt.plot(epochs_range,train_loss,label="Training Loss")
plt.plot(epochs_range,test_loss,label='Testing Loss')
plt.legend()
plt.title('Training and Validation Loss')
plt.show()

最终的训练结果如上图，这个曲线看起来还挺好看的……

6 结果分析

上图为训练营原文代码所训练的结果，可以看出模型在15个 epoch左右就开始收敛，且出现了过拟合的现象。

在此原代码基础上，添加了 Dropout 层，看起来结果还不错，如下图：

此外，还尝试了修改网络结构（添加一层卷积层和池化层），但是效果并不明显，遂去除。同时产生了如下的报错信息：

RuntimeError: Calculated padded input size per channel: (2 x 2). Kernel size: (3 x 3). Kernel size can’t be greater than actual input size

• 查询得知结果如下：这个错误通常表示输入的图像尺寸太小，无法应用给定的卷积核大小进行卷积操作。
• 一种解决方法是通过调整输入图像的尺寸来适应卷积核的大小。另一种方法是使用较小的卷积核大小，或者在卷积层中添加padding来增加输入尺寸。
• 例如，如果您的输入图像大小为(3,3)，而您使用了一个3x3的卷积核，那么卷积后的输出大小将为(1,1)。在这种情况下，您需要通过调整图像大小或使用更小的卷积核来解决此错误。

最后，尝试使用数据增强技术，训练结果如下图：

很好的解决了过拟合问题，也提高了正确率。