文章目录

---

前言

•  🍨本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/rbOOmire8OocQ90QM78DRA) 中的学习记录博客
• 🍖 原作者：K同学啊

 说在前面

• 本周的学习目标：学习如何编写一个完整的深度学习程序；手动推导卷积层和池化层的计算过程
• 学习重点：学会构建CNN网络
• 我的环境：Python 3.8、Pycharm2020、torch1.12.1+cu113

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、前期准备

1.1 设置GPU

由于电脑配置原因，只能使用CPU

#1.1 设置GPU(没有就用cpu）
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision
import numpy as np
import torch.nn.functional as F
from torchinfo import summary

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

运行结果：

1.2 导入数据

使用dataset从pytorch的数据库下载CIFAR10数据集，并划分好训练集和测试集；然后使用dataloader加载数据集，并设置好batch_size

• 数据集介绍：

参考自：【神经网络与深度学习】CIFAR10数据集介绍，并使用卷积神经网络训练图像分类模型——[附完整训练代码]_cifar-10-CSDN博客https://blog.csdn.net/weixin_45954454/article/details/114519299

CIFAR10数据集共有60000个样本，每个样本都是一张32*32像素的RGB图像（彩色图像），每个RGB图像又必定分为3个通道（R通道、G通道、B通道）。这60000个样本被分成了50000个训练样本和10000个测试样本。
CIFAR10数据集是用来监督学习训练的，那么每个样本就一定都配备了一个标签值（用来区分这个样本是什么），不同类别的物体用不同的标签值，CIFAR10中有10类物体，标签值分别按照0~9来区分,他们分别是飞机（ airplane ）、汽车（ automobile ）、鸟（ bird ）、猫（ cat ）、鹿（ deer ）、狗（ dog ）、青蛙（ frog ）、马（ horse ）、船（ ship ）和卡车（ truck ）

• 下载数据和加载数据代码如下：

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

batch_size = 32
train_dl = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True) 
#shuffle在机器学习与深度学习中代表的意思是，将训练模型的数据集进行打乱的操作。
test_dl = torch.utils.data.DataLoader(test_ds, batch_size=batch_size)

下载结果：

• 一个批次的数据格式查看：

imgs, labels =next(iter(train_dl))
print(imgs.shape)    #取一个批次查看数据格式，shape为[batch_size,channel,height,weight]

输出显示：

torch.Size([32,3,32,32])

1.3 数据可视化

# 1.3 数据可视化
plt.figure(figsize=(20, 5))
for i, imgs in enumerate(imgs[:20]):
    # 维度缩减
    npimg = imgs.numpy().transpose((1, 2, 0))
    # 将整个figure分成2行10列，绘制第i+1个子图。
    plt.subplot(2, 10, i+1)
    plt.imshow(npimg, cmap=plt.cm.binary)
    plt.axis('off')
plt.show()

运行结果：

二、构建简单的CNN网络

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

2.1 预备知识

2.1.1 torch.nn.Linear() 详解

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

关键参数说明：

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

2.1.2 关于卷积层、池化层的计算

本处的计算参看自'K同学呀'的预备知识中的公式

本处所用的CNN网络结构如下图所示

下面的网络数据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)

计算过程如图：

注意：这里第二个池化层的shape推出来是6.5，这里是向下取整为6

2.2 CNN网络实现代码

num_class = 10   #图片的类别数

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        #特征提取网络
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3)   #第一层卷积，卷积核为3*3
        self.pool1 = nn.MaxPool2d(kernel_size=2)       #第一层池化层，池化核大小为2*2
        self.conv2 = nn.Conv2d(64, 64, kernel_size=3)
        self.pool2 = nn.MaxPool2d(kernel_size=2)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3)
        self.pool3 = nn.MaxPool2d(kernel_size=2)

        #分类网络
        self.fc1 = nn.Linear(512, 256)
        self.fc2 = nn.Linear(256, num_class)
    #前向传播
    def forward(self,x):
        x = self.pool1(F.relu(self.conv1(x)))
        x = self.pool2(F.relu(self.conv2(x)))
        x = self.pool3(F.relu(self.conv3(x)))

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

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

        return x

#加载并打印模型
model = Model().to(device)
summary(model)

加载并打印模型输出如下：

三、训练模型

3.1 设置超参数

这里主要是设置损失函数(本例使用的是交叉熵函数)、学习率、优化器(本例使用的是SGD)

loss_fn = nn.CrossEntropyLoss()   #交叉熵函数
learn_rate = 1e-2
opt = torch.optim.SGD(model.parameters(),lr=learn_rate)

3.2 编写训练函数

3.2.1 训练的几个关键函数

• optimizer.zero_grad()：函数会遍历模型的所有参数，通过内置方法截断反向传播的梯度流，再将每个参数的梯度值设为0，即上一次的梯度记录被清空。

• loss.backward()：PyTorch的反向传播(即tensor.backward())是通过autograd包来实现的，autograd包会根据tensor进行过的数学运算来自动计算其对应的梯度。具体来说，torch.tensor是autograd包的基础类，如果你设置tensor的requires_grads为True，就会开始跟踪这个tensor上面的所有运算，如果你做完运算后使用tensor.backward()，所有的梯度就会自动运算，tensor的梯度将会累加到它的.grad属性里面去。更具体地说，损失函数loss是由模型的所有权重w经过一系列运算得到的，若某个w的requires_grads为True，则w的所有上层参数（后面层的权重w）的.grad_fn属性中就保存了对应的运算，然后在使用loss.backward()后，会一层层的反向传播计算每个w的梯度值，并保存到该w的.grad属性中。

  如果没有进行tensor.backward()的话，梯度值将会是None，因此loss.backward()要写在optimizer.step()之前。

• optimizer.step()：step()函数的作用是执行一次优化步骤，通过梯度下降法来更新参数的值。因为梯度下降是基于梯度的，所以在执行optimizer.step()函数前应先执行loss.backward()函数来计算梯度。

注意：optimizer只负责通过梯度下降进行优化，而不负责产生梯度，梯度是tensor.backward()方法产生的

3.2.2 训练函数代码

#3.2编写训练函数
  #训练循环
def train(dataloader, model, loss_fn, optimier):
    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)
        #反向传播
        optimier.zero_grad()   #grad属性归零
        loss.backward()        #反向传播
        optimier.step()        #每一步自动更新
        #记录acc和loss
        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

3.3 编写测试函数

其实测试函数和训练函数基本相同，只不过测试函数因为不进行梯度下降对网络权重进行更新，所以不需要传入优化器

#3.2编写测试函数
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)

            # 计算loss
            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

3.4 正式训练

3.4.1 基本概念介绍

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

• 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所带来的的性质。

3.4.2 模型正式训练

训练代码如下：

#3.4 正式训练
epochs = 10
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')

训练进程如下：

四、结果可视化

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(loc='lower right')
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='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

结果显示：

可以看出随着Epoch的增加，模型的精度咋不断提升，损失loss也在不断下降，但这里的epoch显然不够，因为最后精度最高也只达到了58%。

---

总结

本周和手写字识别的代码基本一致，有区别的地方主要就是数据集不同，和CNN的模型不同，此处的CNN模型较为复杂一些，我理解下来其实CNN的搭建就像是搭积木一样，定义模型的类，在初始化模块内将卷积核池化层按照要求进行堆叠即可，然后对每一层的连接在前向传播过程进行定义，使用相应的激活函数等进行前向传播。

这些只是最基础的理解，明白各行代码的意思，但是还不明白为什么网络结构要这样设计，例如：

• 为什么channel的数目在一些层变，为什么需要变？
• 各层设置的目的，就像本例中为什么用一层卷积又接着一层池化层，三个这样的结构作用是什么？与三个卷积连着再三个池化层又有什么区别？

接下来将会继续学习相关的概念，相信后面看得越来越多，这些问题也会有答案的！