训练营-第P2周：CIFAR10彩色图片识别

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊

我的环境：

• 语言：Python3.12.2
• 编译器：jupyter notebook
• 框架：Pytorch with torch:2.2.2 + torchvision:0.17.2

一、前期准备

1.设置GPU/CPU

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

device(type='cpu')

print(torchvision.__version__)
print(torch.__version__)

0.17.2
2.2.2

2.导入数据

使用dataset下载CIFAR10数据集，并划分训练集与测试集

使用dataloader加载数据，并设置好基本的batch size

train_ds = torchvision.datasets.CIFAR10('data', 
                                      train=True, 
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)

test_ds  = torchvision.datasets.CIFAR10('data', 
                                      train=False, 
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)

Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to data\cifar-10-python.tar.gz


100.0%


Extracting data\cifar-10-python.tar.gz to data
Files already downloaded and verified

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

# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
# 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。
imgs, labels = next(iter(train_dl))
imgs.shape

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

3.数据可视化

利用squeeze()函数的功能，去除维度为1的shape

import numpy as np
#原每张图的shape(3, 32, 32)
#指定图片大小，图像大小为20宽、5高的绘图(单位为英寸inch)
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')
    

二、构建简单的CNN网络

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

torch.nn.Conv2d() is to construct convolution layers

CLASS 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)

Applies a 2D convolution over an input signal composed of several input planes.

输入的尺度是(N, C_in,H,W)，输出尺度（N,C_out,H_out,W_out）的计算方式：

where ⋆ is the valid 2D cross-correlation operator, N is a batch size, C denotes a number of channels, H is a height of input planes in pixels, and W is width in pixels.

关键参数：

• in_channels(int):输入图像中的通道数
• out_channels(int):卷积产生的通道数
• kernel_size (int or tuple): 卷积核的大小
• stride(int or tuple, optional): 卷积的步长。默认值：1
• padding (int, tuple or str, optional): 添加到输入的所有四个边的填充，默认值：0
• dilation(int or tuple, optional):扩张操作，控制kernel点（卷积核点）的间距，默认值：1
• groups(int,optional): 将输入通道分组成多个子组，每个子组使用一组卷积核来处理。默认值为 1，表示不进行分组卷积。
• padding_mode(str,optional): ‘zeros’, ‘reflect’, ‘replicate’ or ‘circular’. Default: ‘zeros’
• bias(bool,optional): 如果为True，则在输出添加一个可学习的bias，默认值True

padding='valid' is the same as no padding. padding='same' pads the input so the output has the shape as the input. However, this mode doesn’t support any stride values other than 1.

dilation参数图解：

torch.nn.Linear() is to construct Linear Layers

CLASS torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)

对输入数据做线性变换：y=Ax+b

关键参数：

• in_features(int): 每个输入样本的大小
• out_features(int): 每个输出样本的大小
• bias: 如果为False，这层不会学习额外的偏置，默认值是True

torch.nn.MaxPool2d

对由多个输入平面组成的输入信号进行二维最大集合。

torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

关键参数：

• kernel_size (int or Tuple[int, int]) – 最大的窗口大小
• stride (int or Tuple[int, int]) – 窗口的步幅，默认值为kernel_size
• padding (int or Tuple[int, int]) – 在两侧添加隐式负无穷大填充
• dilation (int or Tuple[int, int]) – 控制窗口中元素步幅的参数
• return_indices (bool) – if True, will return the max indices along with the outputs. Useful for torch.nn.MaxUnpool2d later
• ceil_mode (bool) – when True, will use ceil instead of floor to compute the output shape

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

数据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)

【卷积层的计算】与【池化层的计算】这两篇文章有手动推导这个过程

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)   # 第一层卷积,卷积核大小为3*3
        self.pool1 = nn.MaxPool2d(kernel_size=2)       # 设置池化层，池化核大小为2*2
        self.conv2 = nn.Conv2d(64, 64, kernel_size=3)  # 第二层卷积,卷积核大小为3*3   
        self.pool2 = nn.MaxPool2d(kernel_size=2) 
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3) # 第二层卷积,卷积核大小为3*3   
        self.pool3 = 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.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

加载和打印模型

from torchinfo import summary

model = Model().to(device)

summary(model)

=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
Model                                    --
├─Conv2d: 1-1                            1,792
├─MaxPool2d: 1-2                         --
├─Conv2d: 1-3                            36,928
├─MaxPool2d: 1-4                         --
├─Conv2d: 1-5                            73,856
├─MaxPool2d: 1-6                         --
├─Linear: 1-7                            131,328
├─Linear: 1-8                            2,570
=================================================================
Total params: 246,474
Trainable params: 246,474
Non-trainable params: 0
=================================================================

三、训练模型

1.设置超参数

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-2 # 学习率
opt  = torch.optim.SGD(model.parameters(),lr=learn_rate)

2.编写训练函数

1. optimizer.zero_grad()

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

2. 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()之前。

3. optimizer.step()

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

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

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小，一共60000张图片
    num_batches = len(dataloader)   # 批次数目，1875（60000/32）

    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)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
        
        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.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.编写测试函数

测试函数和训练函数大致相同，但是由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小，一共10000张图片
    num_batches = len(dataloader)          # 批次数目，313（10000/32=312.5，向上取整）
    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

4.正式训练

1. model.train()

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

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

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

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')

Epoch: 1, Train_acc:11.7%, Train_loss:2.292, Test_acc:18.4%，Test_loss:2.254
Epoch: 2, Train_acc:24.3%, Train_loss:2.045, Test_acc:30.6%，Test_loss:1.897
Epoch: 3, Train_acc:33.8%, Train_loss:1.812, Test_acc:38.1%，Test_loss:1.717
Epoch: 4, Train_acc:40.3%, Train_loss:1.640, Test_acc:43.6%，Test_loss:1.565
Epoch: 5, Train_acc:44.1%, Train_loss:1.543, Test_acc:46.2%，Test_loss:1.478
Epoch: 6, Train_acc:47.6%, Train_loss:1.451, Test_acc:48.4%，Test_loss:1.463
Epoch: 7, Train_acc:50.7%, Train_loss:1.370, Test_acc:52.1%，Test_loss:1.333
Epoch: 8, Train_acc:53.7%, Train_loss:1.296, Test_acc:55.2%，Test_loss:1.272
Epoch: 9, Train_acc:56.4%, Train_loss:1.231, Test_acc:55.1%，Test_loss:1.277
Epoch:10, Train_acc:58.7%, Train_loss:1.171, Test_acc:59.3%，Test_loss:1.151
Done

四、结果可视化

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(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()

五、学习总结：

• 学习CNN的结构以及不同功能的layers
• 学习如何计算卷积层、池化层，对stride, padding, kernel等概念有了更进一步的理解
• 学习如何构建CNN网络，并且如何训练模型和测试
  
  ps: 没有GPU真有点难受，训练模型跑得很…慢…