用Pytorch创建CNN字符识别模型

开始构建一个字符识别模型–定长字符分类模型。利用卷积神经网络(Convolutional Neural Network ,CNN)从头搭建一个字符识别模型，并讲解卷积神经网络的常见层。
学习目标：1. 学习CNN基础和原理 2. 使用Pytorch框架构建CNN模型并完成训练

1 CNN介绍

卷积神经网络CNN 是深度学习最重要的一个分支。在传统的图像处理中的卷积就是过滤器。CNN在很多领域都表现优异，精度和速度比传统计算学习算法高很多。特别是在计算机视觉领域，CNN是解决图像分类、图像检索、物体检测和语义分割的主流模型。
CNN是一种层次模型，输入的是原始的像素数据。CNN通过卷积(convolution)、池化(pooling)、非线性激活函数（non-linear activation function）和全连接层(fully connected layer)构成。
卷积神经网络在本质上是一种输入到输出的映射，它能够学习大量的输入与输出之间的映射关系，而不需要任何输入与输出之间的精确的数学表达式，只要用已知的模式对卷积神经网络加以训练，网络就具有输入与输出之间的映射能力。卷积网络是有监督学习，所以它的样本集都形如：（输入向量，理想输出向量）之类的向量对构成。
在训练之前，所有权值都用一些不同的小随机数进行初始化，小的随机数可以保证网络不会因权值太大而进入饱和状态，从而导致训练失败。不同则保证网络可以正常学习。
如果要是用相同的数去初始化矩阵，网络会没有学习的能力。

1.1 LeNet网络结构（1998）

卷积神经网络三个基本概念：局部感受野（Local Receptive Fields）、共享权值(Shared Weights）、池化（Pooling)。

1. 局部感受野：局部感受野。对于一般的深度神经网络，往往会把图像的每一个像素点连接到全连接的每一个神经元中，而卷积神经网络则是把每一个隐藏节点只连接到图像的某个局部区域，从而减少参数训练的数量。例如，一张1024×720的图像，使用9×9的感受野，则只需要81个权值参数。对于一般的视觉也是如此，当观看一张图像时，更多的时候关注的是局部。
2. 共享权值。在卷积神经网络的卷积层中，神经元对应的权值是相同的，由于权值相同，因此可以减少训练的参数量。共享的权值和偏置也被称作卷积核或滤汲器。
3. 池化。由于待处理的图像往往都比较大，而在实际过程中，没有必要对原图进行分析，能够有效获得图像的特征才是最主要的，因此可以采用类似于图像压缩的思想，对图像进行卷积之后，通过一个下采样过程，来调整图像的大小。
   LeNet网络结构，是非常经典的字符识别模型。两个卷积层，两个池化层，两个全连接层组成。卷积核都是5×5，stride=1，池化层使用最大池化。

C1，C3，C5为卷积层，S2，S4为降采样层，F6为全连接层，还有一个输出层。
下采样的作用： 利用图像的局部相关性原理，对图像进行子抽样，可以减少数据处理量，同时又保留有用的信息。
方式就是池化层：池化层一般有两种方式：
（1） Max_Pooling： 选择Pooling窗口中最大值最为采样值。
（2） Mean_Pooling： 将Pooling窗口中的所有值相加取平均，然后以平均值最为采样值。

上图说明了卷积过程子+采样过程。卷积过程中，用一个可训练的过滤器fx去卷积一个输入图像，然后添加一个偏置bx ，得到卷积层Cx 。子采样过程就是：每个邻域4个像素变为一个像素，然后加上标量Wx 加权，最后再增加偏置bx+1 ，接着通过一个sigmoid激活函数，产生一个大概缩小了4倍的特征映射图Sx+1。

主要参考来源：https://blog.csdn.net/weixin_42398658/article/details/84392845?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase

1.2 AlexNet(2012)

看文章待补充

1.3 VGG-16(2014)

看文章待补充

1.4 Inception-v1(2014) InceptionResNetV2 InceptionV3

看文章待补充

1.5 ResNet-50(2015) ResNeXt50

看文章待补充

2 Pytorch构建CNN模型

在Pytorch中构建CNN模型非常简单，只需要定义好模型的参数和正向传播即可，Pytorch会根据正向传播自动计算反向传播。 构建一个非常简单的CNN，然后进行训练。这个CNN模型包括两个卷积层，最后并联6个全连接层进行分类。

2.1 定义模型

import torch
torch.manual_seed(0)
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.benchmark = True

import torchvision.models as models
import torchvision.transforms as transforms
import torchvision.datasets as datasets
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable
from torch.utils.data.dataset import Dataset

# 定义模型
class SVHN_Model1(nn.Module):
    def __init__(self):
        super(SVHN_Model1, self).__init__()
        # CNN提取特征模块
        self.cnn = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=(3, 3), stride=(2, 2)),
            nn.ReLU(),  
            nn.MaxPool2d(2),
            nn.Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2)),
            nn.ReLU(), 
            nn.MaxPool2d(2),
        )
        # 
        self.fc1 = nn.Linear(32*3*7, 11)
        self.fc2 = nn.Linear(32*3*7, 11)
        self.fc3 = nn.Linear(32*3*7, 11)
        self.fc4 = nn.Linear(32*3*7, 11)
        self.fc5 = nn.Linear(32*3*7, 11)
        self.fc6 = nn.Linear(32*3*7, 11)
    
    def forward(self, img):        
        feat = self.cnn(img)
        feat = feat.view(feat.shape[0], -1)
        c1 = self.fc1(feat)
        c2 = self.fc2(feat)
        c3 = self.fc3(feat)
        c4 = self.fc4(feat)
        c5 = self.fc5(feat)
        c6 = self.fc6(feat)
        return c1, c2, c3, c4, c5, c6
    
model = SVHN_Model1()

在为了追求精度，也可以使用在ImageNet数据集上的预训练模型：

class SVHN_Model2(nn.Module):
    def __init__(self):
        super(SVHN_Model1, self).__init__()
                
        model_conv = models.resnet18(pretrained=True)
        model_conv.avgpool = nn.AdaptiveAvgPool2d(1)
        model_conv = nn.Sequential(*list(model_conv.children())[:-1])
        self.cnn = model_conv
        
        self.fc1 = nn.Linear(512, 11)
        self.fc2 = nn.Linear(512, 11)
        self.fc3 = nn.Linear(512, 11)
        self.fc4 = nn.Linear(512, 11)
        self.fc5 = nn.Linear(512, 11)
    
    def forward(self, img):        
        feat = self.cnn(img)
        # print(feat.shape)
        feat = feat.view(feat.shape[0], -1)
        c1 = self.fc1(feat)
        c2 = self.fc2(feat)
        c3 = self.fc3(feat)
        c4 = self.fc4(feat)
        c5 = self.fc5(feat)
        return c1, c2, c3, c4, c5

2.2 训练代码

# 损失函数
criterion = nn.CrossEntropyLoss()
# 优化器
optimizer = torch.optim.Adam(model.parameters(), 0.005)

loss_plot, c0_plot = [], []
# 迭代10个Epoch
for epoch in range(10):
    for data in train_loader:
        c0, c1, c2, c3, c4, c5 = model(data[0])
        loss = criterion(c0, data[1][:, 0]) + \
                criterion(c1, data[1][:, 1]) + \
                criterion(c2, data[1][:, 2]) + \
                criterion(c3, data[1][:, 3]) + \
                criterion(c4, data[1][:, 4]) + \
                criterion(c5, data[1][:, 5])
        loss /= 6
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        loss_plot.append(loss.item())
        c0_plot.append((c0.argmax(1) == data[1][:, 0]).sum().item()*1.0 / c0.shape[0])
        
    print(epoch)