几种网络LeNet、VGG Net、ResNet原理及PyTorch实现

LeNet比较经典，就从LeNet开始，其PyTorch实现比较简单，通过LeNet为基础引出下面的VGG-Net和ResNet。

LeNet

LeNet比较经典的一张图如下图

在这里插入图片描述

LeNet-5共有7层，不包含输入，每层都包含可训练参数；每个层有多个Feature Map，每个FeatureMap通过一种卷积滤波器提取输入的一种特征，然后每个FeatureMap有多个神经元。

1.INPUT层-输入层

输入图像的尺寸统一归一化为: 32 x 32。

2.C1层卷积层

输入图片：32 x 32
卷积核大小：5 x 5
卷积核种类：6
输出featuremap大小：28 x 28 （32-5+1）=28
神经元数量：28 x 28 x 6
可训练参数：（5 x 5+1) x 6（每个滤波器5 x 5=25个unit参数和一个bias参数，一共6个滤波器）
连接数：（5 x 5+1） x 6 x 28 x 28=122304

3.S2层池化层（下采样层）

输入：28 x 28
采样区域：2 x 2
采样方式：4个输入相加，乘以一个可训练参数，再加上一个可训练偏置。结果通过sigmoid
采样种类：6
输出featureMap大小：14 x14（28/2）
神经元数量：14 x 14 x 6
可训练参数：2 x 6（和的权+偏置）
连接数：（2 x 2+1） x 6 x 14 x 14
S2中每个特征图的大小是C1中特征图大小的1/4。

4.C3层卷积层

5.S4层池化层（下采样层）

6.C5层卷积层

7.F6层全连接层

输入：c5 120维向量
计算方式：计算输入向量和权重向量之间的点积，再加上一个偏置，结果通过sigmoid函数输出。
可训练参数:84 x (120+1)=10164

8.output层全连接层

Output层也是全连接层，共有10个节点，分别代表数字0到9，且如果节点i的值为0，则网络识别的结果是数字i。采用的是径向基函数（RBF）的网络连接方式。假设x是上一层的输入，y是RBF的输出，则RBF输出的计算方式是：
上式w_ij 的值由i的比特图编码确定，i从0到9，j取值从0到7 x 12-1。RBF输出的值越接近于0，则越接近于i，即越接近于i的ASCII编码图，表示当前网络输入的识别结果是字符i。该层有84x10=840个参数和连接。

下面基于PyTorch实现LeNet

 1 #coding=utf-8
 2 import torch
 3 import torch.nn as nn
 4 import torch.nn.functional as F
 5 from torch.autograd import Variable
 6 
 7 class Net(nn.Module):
 8     #定义Net的初始化函数，这个函数定义了该神经网络的基本结构
 9     def __init__(self):
10         super(Net, self).__init__() 
11         #复制并使用Net的父类的初始化方法，即先运行nn.Module的初始化函数
12         self.conv1 = nn.Conv2d(1, 6, 5) 
13         # 定义conv1函数的是图像卷积函数：输入为图像（1个频道，即灰度图）,输出为 6张特征图, 卷积核为5x5正方形
14         self.conv2 = nn.Conv2d(6, 16, 5)
15         # 定义conv2函数的是图像卷积函数：输入为6张特征图,输出为16张特征图, 卷积核为5x5正方形
16         self.fc1   = nn.Linear(16*5*5, 120) 
17         # 定义fc1（fullconnect）全连接函数1为线性函数：y = Wx + b，并将16*5*5个节点连接到120个节点上。
18         self.fc2   = nn.Linear(120, 84)
19         #定义fc2（fullconnect）全连接函数2为线性函数：y = Wx + b，并将120个节点连接到84个节点上。
20         self.fc3   = nn.Linear(84, 10)
21         #定义fc3（fullconnect）全连接函数3为线性函数：y = Wx + b，并将84个节点连接到10个节点上。
22 
23     #定义该神经网络的向前传播函数，该函数必须定义，一旦定义成功，向后传播函数也会自动生成（autograd）
24     def forward(self, x):
25         x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) 
26         #输入x经过卷积conv1之后，经过激活函数ReLU，使用2x2的窗口进行最大池化Max pooling，然后更新到x。
27         x = F.max_pool2d(F.relu(self.conv2(x)), 2) 
28         #输入x经过卷积conv2之后，经过激活函数ReLU，使用2x2的窗口进行最大池化Max pooling，然后更新到x。
29         x = x.view(-1, self.num_flat_features(x)) 
30         #view函数将张量x变形成一维的向量形式，总特征数并不改变，为接下来的全连接作准备。
31         x = F.relu(self.fc1(x)) 
32         #输入x经过全连接1，再经过ReLU激活函数，然后更新x
33         x = F.relu(self.fc2(x)) 
34         #输入x经过全连接2，再经过ReLU激活函数，然后更新x
35         x = self.fc3(x) 
36         #输入x经过全连接3，然后更新x
37         return x
38 
39     #使用num_flat_features函数计算张量x的总特征量（把每个数字都看出是一个特征，即特征总量），比如x是4*2*2的张量，那么它的特征总量就是16。
40     def num_flat_features(self, x):
41         size = x.size()[1:] 
42         # 这里为什么要使用[1:],是因为pytorch只接受批输入，也就是说一次性输入好几张图片，那么输入数据张量的维度自然上升到了4维。【1:】让我们把注意力放在后3维上面
43         num_features = 1
44         for s in size:
45             num_features *= s
46         return num_features
47 
48 
49 net = Net()
50 net
51 
52 # 以下代码是为了看一下我们需要训练的参数的数量
53 print net
54 params = list(net.parameters())
55 
56 k=0
57 for i in params:
58     l =1
59     print "该层的结构："+str(list(i.size()))
60     for j in i.size():
61         l *= j
62     print "参数和："+str(l)
63     k = k+l
64 
65 print "总参数和："+ str(k)

VGG

VGG结构图

VGG-16

Faster R-CNN用到了VGG-16

彩色图片输入到网络，白色框是卷积层，红色是池化，蓝色是全连接层，棕色框是预测层。预测层将全连接层输出的信息转化为相应的类别概率，而起到分类作用。
VGG16 是13个卷积层+3个全连接层叠加而成。

 1 class Vgg16(torch.nn.Module):
 2     def __init__(self):
 3         super(Vgg16, self).__init__()
 4         self.conv1_1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
 5         self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
 6  
 7         self.conv2_1 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
 8         self.conv2_2 = nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1)
 9  
10         self.conv3_1 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
11         self.conv3_2 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
12         self.conv3_3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
13  
14         self.conv4_1 = nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1)
15         self.conv4_2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
16         self.conv4_3 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
17  
18         self.conv5_1 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
19         self.conv5_2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
20         self.conv5_3 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
21  
22     def forward(self, X):
23         h = F.relu(self.conv1_1(X))
24         h = F.relu(self.conv1_2(h))
25         relu1_2 = h
26         h = F.max_pool2d(h, kernel_size=2, stride=2)
27  
28         h = F.relu(self.conv2_1(h))
29         h = F.relu(self.conv2_2(h))
30         relu2_2 = h
31         h = F.max_pool2d(h, kernel_size=2, stride=2)
32  
33         h = F.relu(self.conv3_1(h))
34         h = F.relu(self.conv3_2(h))
35         h = F.relu(self.conv3_3(h))
36         relu3_3 = h
37         h = F.max_pool2d(h, kernel_size=2, stride=2)
38  
39         h = F.relu(self.conv4_1(h))
40         h = F.relu(self.conv4_2(h))
41         h = F.relu(self.conv4_3(h))
42         relu4_3 = h
43  
44         return [relu1_2, relu2_2, relu3_3, relu4_3]

Jianwei Yang 大神 Faster R-CNN中的vgg16 code

 1 import torch
 2 import torch.nn as nn
 3 import torch.nn.functional as F
 4 from torch.autograd import Variable
 5 import math
 6 import torchvision.models as models
 7 from model.faster_rcnn.faster_rcnn import _fasterRCNN
 8 import pdb
 9 
10 class vgg16(_fasterRCNN):
11   def __init__(self, classes, pretrained=False, class_agnostic=False):
12     self.model_path = 'data/pretrained_model/vgg16_caffe.pth'
13     self.dout_base_model = 512
14     self.pretrained = pretrained
15     self.class_agnostic = class_agnostic
16 
17     _fasterRCNN.__init__(self, classes, class_agnostic)
18 
19   def _init_modules(self):
20     vgg = models.vgg16()
21     if self.pretrained:
22         print("Loading pretrained weights from %s" %(self.model_path))
23         state_dict = torch.load(self.model_path)
24         vgg.load_state_dict({k:v for k,v in state_dict.items() if k in vgg.state_dict()})
25 
26     vgg.classifier = nn.Sequential(*list(vgg.classifier._modules.values())[:-1])
27 
28     # not using the last maxpool layer
29     self.RCNN_base = nn.Sequential(*list(vgg.features._modules.values())[:-1])
30 
31     # Fix the layers before conv3:
32     for layer in range(10):
33       for p in self.RCNN_base[layer].parameters(): p.requires_grad = False
34 
35     # self.RCNN_base = _RCNN_base(vgg.features, self.classes, self.dout_base_model)
36 
37     self.RCNN_top = vgg.classifier
38 
39     # not using the last maxpool layer
40     self.RCNN_cls_score = nn.Linear(4096, self.n_classes)
41 
42     if self.class_agnostic:
43       self.RCNN_bbox_pred = nn.Linear(4096, 4)
44     else:
45       self.RCNN_bbox_pred = nn.Linear(4096, 4 * self.n_classes)      
46 
47   def _head_to_tail(self, pool5):
48     
49     pool5_flat = pool5.view(pool5.size(0), -1)
50     fc7 = self.RCNN_top(pool5_flat)
51 
52     return fc7