幾種網絡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

#coding=utf-8
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable

class Net(nn.Module):
    #定義Net的初始化函數，這個函數定義了該神經網絡的基本結構
    def __init__(self):
        super(Net, self).__init__() 
        #復制並使用Net的父類的初始化方法，即先運行nn.Module的初始化函數
        self.conv1 = nn.Conv2d(1, 6, 5) 
        # 定義conv1函數的是圖像卷積函數：輸入為圖像（1個頻道，即灰度圖）,輸出為 6張特征圖, 卷積核為5x5正方形
        self.conv2 = nn.Conv2d(6, 16, 5)
        # 定義conv2函數的是圖像卷積函數：輸入為6張特征圖,輸出為16張特征圖, 卷積核為5x5正方形
        self.fc1   = nn.Linear(16*5*5, 120) 
        # 定義fc1（fullconnect）全連接函數1為線性函數：y = Wx + b，並將16*5*5個節點連接到120個節點上。
        self.fc2   = nn.Linear(120, 84)
        #定義fc2（fullconnect）全連接函數2為線性函數：y = Wx + b，並將120個節點連接到84個節點上。
        self.fc3   = nn.Linear(84, 10)
        #定義fc3（fullconnect）全連接函數3為線性函數：y = Wx + b，並將84個節點連接到10個節點上。

    #定義該神經網絡的向前傳播函數，該函數必須定義，一旦定義成功，向后傳播函數也會自動生成（autograd）
    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) 
        #輸入x經過卷積conv1之后，經過激活函數ReLU，使用2x2的窗口進行最大池化Max pooling，然后更新到x。
        x = F.max_pool2d(F.relu(self.conv2(x)), 2) 
        #輸入x經過卷積conv2之后，經過激活函數ReLU，使用2x2的窗口進行最大池化Max pooling，然后更新到x。
        x = x.view(-1, self.num_flat_features(x)) 
        #view函數將張量x變形成一維的向量形式，總特征數並不改變，為接下來的全連接作准備。
        x = F.relu(self.fc1(x)) 
        #輸入x經過全連接1，再經過ReLU激活函數，然后更新x
        x = F.relu(self.fc2(x)) 
        #輸入x經過全連接2，再經過ReLU激活函數，然后更新x
        x = self.fc3(x) 
        #輸入x經過全連接3，然后更新x
        return x

    #使用num_flat_features函數計算張量x的總特征量（把每個數字都看出是一個特征，即特征總量），比如x是4*2*2的張量，那么它的特征總量就是16。
    def num_flat_features(self, x):
        size = x.size()[1:] 
        # 這里為什么要使用[1:],是因為pytorch只接受批輸入，也就是說一次性輸入好幾張圖片，那么輸入數據張量的維度自然上升到了4維。【1:】讓我們把注意力放在后3維上面
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


net = Net()
net

# 以下代碼是為了看一下我們需要訓練的參數的數量
print net
params = list(net.parameters())

k=0
for i in params:
    l =1
    print "該層的結構："+str(list(i.size()))
    for j in i.size():
        l *= j
    print "參數和："+str(l)
    k = k+l

print "總參數和："+ str(k)

VGG

VGG結構圖

VGG-16

Faster R-CNN用到了VGG-16

彩色圖片輸入到網絡，白色框是卷積層，紅色是池化，藍色是全連接層，棕色框是預測層。預測層將全連接層輸出的信息轉化為相應的類別概率，而起到分類作用。
VGG16 是13個卷積層+3個全連接層疊加而成。

class Vgg16(torch.nn.Module):
    def __init__(self):
        super(Vgg16, self).__init__()
        self.conv1_1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)
        self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
 
        self.conv2_1 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
        self.conv2_2 = nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1)
 
        self.conv3_1 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
        self.conv3_2 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
        self.conv3_3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
 
        self.conv4_1 = nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1)
        self.conv4_2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
        self.conv4_3 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
 
        self.conv5_1 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
        self.conv5_2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
        self.conv5_3 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
 
    def forward(self, X):
        h = F.relu(self.conv1_1(X))
        h = F.relu(self.conv1_2(h))
        relu1_2 = h
        h = F.max_pool2d(h, kernel_size=2, stride=2)
 
        h = F.relu(self.conv2_1(h))
        h = F.relu(self.conv2_2(h))
        relu2_2 = h
        h = F.max_pool2d(h, kernel_size=2, stride=2)
 
        h = F.relu(self.conv3_1(h))
        h = F.relu(self.conv3_2(h))
        h = F.relu(self.conv3_3(h))
        relu3_3 = h
        h = F.max_pool2d(h, kernel_size=2, stride=2)
 
        h = F.relu(self.conv4_1(h))
        h = F.relu(self.conv4_2(h))
        h = F.relu(self.conv4_3(h))
        relu4_3 = h
 
        return [relu1_2, relu2_2, relu3_3, relu4_3]

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

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import math
import torchvision.models as models
from model.faster_rcnn.faster_rcnn import _fasterRCNN
import pdb

class vgg16(_fasterRCNN):
  def __init__(self, classes, pretrained=False, class_agnostic=False):
    self.model_path = 'data/pretrained_model/vgg16_caffe.pth'
    self.dout_base_model = 512
    self.pretrained = pretrained
    self.class_agnostic = class_agnostic

    _fasterRCNN.__init__(self, classes, class_agnostic)

  def _init_modules(self):
    vgg = models.vgg16()
    if self.pretrained:
        print("Loading pretrained weights from %s" %(self.model_path))
        state_dict = torch.load(self.model_path)
        vgg.load_state_dict({k:v for k,v in state_dict.items() if k in vgg.state_dict()})

    vgg.classifier = nn.Sequential(*list(vgg.classifier._modules.values())[:-1])

    # not using the last maxpool layer
    self.RCNN_base = nn.Sequential(*list(vgg.features._modules.values())[:-1])

    # Fix the layers before conv3:
    for layer in range(10):
      for p in self.RCNN_base[layer].parameters(): p.requires_grad = False

    # self.RCNN_base = _RCNN_base(vgg.features, self.classes, self.dout_base_model)

    self.RCNN_top = vgg.classifier

    # not using the last maxpool layer
    self.RCNN_cls_score = nn.Linear(4096, self.n_classes)

    if self.class_agnostic:
      self.RCNN_bbox_pred = nn.Linear(4096, 4)
    else:
      self.RCNN_bbox_pred = nn.Linear(4096, 4 * self.n_classes)      

  def _head_to_tail(self, pool5):
    
    pool5_flat = pool5.view(pool5.size(0), -1)
    fc7 = self.RCNN_top(pool5_flat)

    return fc7

ResNet

使用了一種連接方式叫做“shortcut connection”，差不多就是抄近道的意思。