彩色图片识别-第二周

• 本文为365天深度学习训练营 中的学习记录博客
• 参考文章：365天深度学习训练营-第P2周：彩色识别
• 原作者：K同学啊|接辅导、项目定制
  ​第P2周：彩色图片识别

难度：小白入门⭐
语言：Python3、Pytorch

要求：

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

本次的重点在于学会构建CNN网络

我的环境：
语言环境：Python 3.6.13
编译器：Pycharm 2020.2
深度学习环境：Pytorch 1.10.0
显卡及显存: GTX 970 4G(本地) RTX 3060(服务器)

---

前言

图像识别的原理：
图像识别是人工智能比较热门的领域，机器的图像识别原理来源于人脑。
人脑的图像识别用科学的话来解释就是人脑看到一张图片时，大脑会迅速感应到是否见过此图片或者有相似的图片，而这个"看到"和"感应到"是一个快速识别过程，此时人脑会根据存储的记忆中已经分类好的图片进行识别，搜索大脑中是否存在相同或相近的存储记忆，从而识别出该图像。

图像识别的过程：
同样地，计算机图像识别过程其实也和人脑差不多。它包含信息的获取、预处理、特征抽取和选择、分类器设计和分类决策。
预处理是指图像处理中的去噪、平滑、变换等的操作，从而加强图像的重要特征。
特征抽取和选择在图像识别过程中是非常关键的技术之一，比如我们可以用CNN网络来提取特征。
分类器设计是指通过训练而得到一种识别规则，通过此识别规则可以得到一种特征分类，使图像识别技术能够得到高识别率。常见的分类器如softmax。
图像识别的应用：
图像识别的应用也比较广泛，比如遥感领域的航空遥感和微型遥感识别系统；军事刑侦领域中的军事目标侦查，公安部门现场照片、指纹、人脸等的识别；生物医学病例研究中通过射线成像了解人体内部的疾病；农业方面的种子识别技术、食品品质检测技术；生活中的应用比如车牌识别、人脸识别、图像文本识别、移动支付等。

---

一、CIFAR10是什么？

这里搬运一下官网的介绍。CIFAR10 数据集
是由 Hinton 的学生 Alex Krizhevsky 和 Ilya Sutskever 整理的一个用于识别普适物体的小型数据集。CIFAR-10数据集包含60000幅32x32的彩色图像，分为10个类，每类6000幅图像。训练图像50000张，测试图像10000张。

可以看到，数据集包含飞机，汽车，鸟，猫，鹿，狗，蛙，马，羊，卡车一共10类，这些类别之间是完全排斥的，也就是说每个类别中的子集不属于其他类别。相比MINIST：
CIFAR-10 是 3 通道的彩色 RGB 图像，而 MNIST 是灰度图像
CIFAR-10 图像尺寸是32x32,MINST图像尺寸为28x28
CIFAR-10是客观世界存在的物体，物体大小、特征不同，这给模型识别带来很大困难。使用传统机器学习模型效果不尽人意。

二、使用步骤

1.默认启动GPU，没有的话则使用CPU

代码如下（示例）：

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

2.读入数据

train=True表示训练集，train=False表示测试集
代码如下：

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)

---

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

3.数据可视化

import numpy as np

 # 指定图片大小，图像大小为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网络

2.1 简单CNN网络

卷积层公式:

池化层公式：
手动推导第一个卷积层和池化层，其它同理。
3,32,32（输入数据）Cin=3,w=32
经过卷积层1(3,64,kernel_size=3,padding=0,stride=1):
Cout=64,o=(32-3-2*0)/1+1=30
64,30,30（输入数据）Cin=64,w=30
经过池化层1(kernel_size=2,padding=0,stride=2，dilation=1):
Cout=64,o=(30+20-1(2-1)-1)/2+1=14+1=15
-> 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
将模型转移到GPU中（我们模型运行均在GPU中进行）
model = Model().to(device)
summary(model)

2.2 模型改进

模型引入Dropout层，并将padding设置为same（即输入和输出图像大小一样)。分类网络引入softmax作为分类器。

#%%
import torch.nn.functional as F

num_classes = 10  # 图片的类别数

class Model(nn.Module):
     def __init__(self):
        super().__init__()

        self.pool = nn.MaxPool2d(kernel_size=2)
        self.drop1=nn.Dropout(0.25)
        self.drop2=nn.Dropout(0.5)
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3,padding='same')
        self.conv2 = nn.Conv2d(32, 32, kernel_size=3,padding='same')# 第一层卷积,卷积核大小为3*3

        self.conv3 = nn.Conv2d(32, 64, kernel_size=3,padding='same')  # 第二层卷积,卷积核大小为3*3
        self.conv4 = nn.Conv2d(64, 64, kernel_size=3,padding='same')
        



        self.fc1 = nn.Linear(4096, 256)
        self.fc2 = nn.Linear(256, num_classes)
     # 前向传播
     def forward(self, x):
        x = self.pool(self.drop1(F.relu(self.conv2(F.relu(self.conv1(x))))))    #32*16*16
        x = self.pool(self.drop1(F.relu(self.conv4(F.relu(self.conv3(x))))))   #64*8*8
        

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

        x = self.drop2(F.relu(self.fc1(x)))
        x = self.fc2(x)
        x=F.softmax(x)  #
        return x

三.训练模型

1.超参数

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

2.训练函数

# 训练循环
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. 正式训练

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

简单CNN网络结果:

改进CNN网络结果:

四. 结果可视化

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网络:

改进CNN网络:

总结

1.学习了卷积层和池化层的推导公式。模型通过增加Dropout层，并将padding设置为same（即输入和输出图像大小一样)。分类网络引入softmax作为分类器。改进后模型最终准确率达到了76.2%。
2.改进后的模型在训练集表现较好，测试集从第5个epoch开始，accuracy降低了，但是随后的Epoch又让accuracy又上去，并且此后连续多次都没有达到最佳acc,可以认为accuracy不会再提高，这里可以采用 early stopping对训练数据集迭代收敛之前停止迭代来防止过拟合。
2.对于过拟合问题，一般可采用数据增强、正则化、早停、boosting等策略。
更多模型见参考资料。

参考资料
图像识别的原理、过程、应用前景，精华篇
who is the best in CIFAR-10
CIFAR10 ResNet: 90+% accuracy