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
ResNet
使用了一种连接方式叫做“shortcut connection”，差不多就是抄近道的意思。