彩色图片识别-第二周

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

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

要求:

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

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

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

文章目录

  • 前言
  • 一、CIFAR10是什么?
  • 二、使用步骤
    • 1.默认启动GPU,没有的话则使用CPU
    • 2.读入数据
    • 3.数据可视化
  • 二、构建CNN网络
    • 2.1 简单CNN网络
    • 2.2 模型改进
  • 三.训练模型
    • 1.超参数
    • 2.训练函数
    • 3.测试函数
    • 4. 正式训练
  • 四. 结果可视化
  • 总结


前言

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

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


一、CIFAR10是什么?

这里搬运一下官网的介绍。CIFAR10 数据集
是由 Hinton 的学生 Alex Krizhevsky 和 Ilya Sutskever 整理的一个用于识别普适物体的小型数据集。CIFAR-10数据集包含60000幅32x32的彩色图像,分为10个类,每类6000幅图像。训练图像50000张,测试图像10000张。
彩色图片识别-第二周_第1张图片
可以看到,数据集包含飞机,汽车,鸟,猫,鹿,狗,蛙,马,羊,卡车一共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)

彩色图片识别-第二周_第2张图片


#取一个批次查看数据格式
#数据的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')

彩色图片识别-第二周_第3张图片

二、构建CNN网络

2.1 简单CNN网络

卷积层公式:
彩色图片识别-第二周_第4张图片
池化层公式:在这里插入图片描述
手动推导第一个卷积层和池化层,其它同理。
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)

彩色图片识别-第二周_第5张图片

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

彩色图片识别-第二周_第6张图片

三.训练模型

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网络结果:
彩色图片识别-第二周_第7张图片
改进CNN网络结果:
彩色图片识别-第二周_第8张图片

四. 结果可视化

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网络:
彩色图片识别-第二周_第9张图片
改进CNN网络:
彩色图片识别-第二周_第10张图片

总结

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

你可能感兴趣的:(python,深度学习,计算机视觉)