阿里天池CV竞赛 Task3 字符识别模型

学习目标

1.学习CNN基础和原理
2.使用pytorch框架构建CNN模型，并完成训练。

CNN介绍

卷积神经网络（CNN）是一类特殊的人工神经网络，是深度学习中重要的一个分支，CNN在多数领域表现优异，精度和速度比传统的计算学习算法高很多。CNN进行权值共享，在计算机视觉领域，CNN是解决图像分类，图像检索，物体检测和语义分割的主流模型。
CNN每一层由众多的卷积核组成，每个卷积核对输入的像素进行卷积操作，然后再进行池化，最后进行全连接层形成一个闭环操作。随着网络层的增加卷积核会逐渐扩大感受野，并缩减图像尺寸。

CNN是一种层次结构模型，输入的原始图片像素数据。CNN通过卷积（convolution），池化（pooling）,非线性激活函数（sigmoid，tanh,relu以及relu变形），和全连接层（fully connected layer）构成。
如下图所示为LeNet网络结构，是非常经典的字符识别模型，2个卷积层，2个池化层，2个全连接层，卷积核都是5*5,stride=1,池化层使用的是最大池化。

通过多次卷积和池化，CNN的最后一层将输入的图像像素映射为具体的输出。如在分类任务重会转换为不同类别的概率输出。然后计算真实标签与CNN模型的预测结果的差异，并通过反向传播更新每一层的参数，并在更新完成后再次前向传播，如此反复知道训练完成。
与传统的机器学习模型相比，CNN具有一种端到端（End to End）的思路。在CNN训练的过程中是直接从图片像素到最终输出，并不涉及到具体的特征提取和构建模型过程，也不需要人工的参与。传统的机器学习模型易于解释，在过程应用中，能够达到一定的效果，而且传统的机器学习是需要先进性特征工程，在进行模型选择，最后进行模型调优，模型预测，模型的部署。而CNN模型可解释性弱，如果是要查看模型运作，可以去Tensorborad里面去查看网络结构。

CNN发展

随着网络结构的发展，研究人员最初发现网络模型结果越深，网络参数越多模型的精度更优，比较典型的是AlexNet,VGG,InceptionV3和ResNet发展脉络。

LeNet_5(1998)

AlexNet

VGG-16(2014)

InceptionV1(2014)

ResNet50

pytorch构建CNN

在之前任务中，我们构建如何使用pytorch来读取数据集，下面我们用简单的CNN知识，完成字符识别功能。
在pytorch中构建CNN模型非常简单，只需要定义好模型参数，和正向传播即可，pytorch会根据正向传播自动计算反向传播。
这里我们构建简单的CNN，然后进行训练。构建2个卷积层，最后使用6个全连接层进行分类。

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_Model(nn.Module):
		def __init__(self):
				super(SVHN_Model,self).__init__()
				#CNN提取特征模块
				self.cnn=nn.Sequential(
					 nn.Conv2d(3,16,
					 kernel_size=(3,3),
					 stride=(2,2),
					 nn.Relu(),
					 nn.Dropout(0.3),
					 nn.MaxPool(2),
					  nn.Conv2d(16,32,
					 kernel_size=(3,3),
					 stride=(2,2),
					 nn.Relu(),
					 nn.Dropout(0.3),
					 nn.MaxPool(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 froward(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_Model()
 #损失函数
 criterion=nn.CrossEntropyLoss()
 #定义优化器
 optimizer=torch.optim.Adam(model.parameters(),0.005)

loss_plot,c0_plot = [],[]

#迭代10次
for epoch in range(10):
	for data in train_loader:
		 c0,c1,c2,c3,c4,c5 = model(data[0])
		 target=data[1].long()
		 #将所得损失函数相加
		 loss=criterion(c0,target[:,0] + \
		 		 criterion(c1,target[:,1] + \
		 		 criterion(c2,target[:,2] + \
		 		 criterion(c3,target[:,3] + \
		 		 criterion(c4,target[:,4] + \
		 		 criterion(c5,target[:,5] + \
		 loss/=6
		 optimizer.zero_grad()
		 loss.backward()
		 optimizer.step()

		loss_plot.append(loss.item())
		c0_plot.append((c0.argmax(1)==target[:,0].sum().item()*1.0/c0.shape[0]						 
	print(epoch)	

当然为了追求精度，在这里我们可以使用ImageNet数据集上的预训练模型，具体代码如下：

class SVHN_Model1(nn.Module):
	def __init__(self):
		super(SVHN_Model1,self).__init__()

		model_conv = models.resnet18(pretrained=True)
		model_conv.avgpool = nn.AdaptiveAvgPool2d(1) #这里可以换成maxpool
		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)
		self.fc6=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)
		c6 = self.fc6(feat)
		return c1,c2,c3,c4,c5,c6