Googlenet论文笔记及代码实现
Googlenet
2014年ImageNet比赛冠军模型，论文发表于cvpr2015
论文原文地址：https://arxiv.org/abs/1409.4842
参考翻译地址：https://blog.csdn.net/c_chuxin/article/details/82856502
卷积神经网络发展史的重要时间点
主要探讨了如何在没有大量增加参数的情况下增加网络深度
LeNet
LeNet是卷积神经网络的开山之作1998年与LeCun提出
缺点：网络层浅，无激活层
AlexNet
AlexNet:2012年在ImageNet竞赛取得了冠军，相较于AlexNet，网络更深，同时第一次引入拉人ReLu激活层，在全链接层引入了Dropout层防止过拟合。
VGGNet
VGGNet：ImageNet 2014年亚军，相比于AlexNet，AlexNet只有8层，而VGG有16～19层，AlexNet使用了11x11的卷积器，VGG使用了3x3卷积核和2x2的最大池化层。
GoogLeNet
GoogLeNet：2014年ImageNet比赛冠军，比VGG更深的网络，而参数却比AlexNet少了12倍。Inception模块。
Inception v1：
增加了网络宽度每个卷积后都做一个relu操作
Inception v2：
5x5卷积和所需计算量很大，在3x3和5x5前以及max pooling后加上了1x1卷积核，以降低特征图都厚度。
Inception v3：
不改变感受野同时采用1xn和nx1卷积核替代nxn卷积核
Inception v4:
加入了残差链接改进v3结构
1 x 1 Conv
- 在相同尺寸的感受野中叠加更多的卷积，能提取到更丰富的特种。
- 使用1x1卷积进行降维，降低了计算复杂度。
多尺寸卷积聚合：
-
在直观感觉上在多个尺度上进行同时卷积，能提取到不同尺度到特征。（一张图片中，人和汽车大小是不同到，用不同尺寸到卷积核提取特征效果比单一尺寸卷积核效果好。
-
利用稀疏矩阵分解成密集矩阵计算到原理来加快收敛速度。Inception就是在特征维度上进行分解
-
Hebbin 赫布原理，Inception结构吧相关性强到特征汇聚到一起。
pytorch 代码实现
import sys
sys.path.append('..')
import numpy as np
import torch
from torch import nn
from torch.autograd import Variable
from torchvision.datasets import CIFAR10
# 定义一个卷积加一个 relu 激活函数和一个 batchnorm 作为一个基本的层结构
def conv_relu(in_channel, out_channel, kernel, stride=1, padding=0):
layer = nn.Sequential(
nn.Conv2d(in_channel, out_channel, kernel, stride, padding),
nn.BatchNorm2d(out_channel, eps=1e-3),
nn.ReLU(True)
)
return layer
class inception(nn.Module):
def __init__(self, in_channel, out1_1, out2_1, out2_3, out3_1, out3_5, out4_1):
super(inception, self).__init__()
# 第一条线路
self.branch1x1 = conv_relu(in_channel, out1_1, 1)
# 第二条线路
self.branch3x3 = nn.Sequential(
conv_relu(in_channel, out2_1, 1),
conv_relu(out2_1, out2_3, 3, padding=1)
)
# 第三条线路
self.branch5x5 = nn.Sequential(
conv_relu(in_channel, out3_1, 1),
conv_relu(out3_1, out3_5, 5, padding=2)
)
# 第四条线路
self.branch_pool = nn.Sequential(
nn.MaxPool2d(3, stride=1, padding=1),
conv_relu(in_channel, out4_1, 1)
)
#定义inception前向传播
def forward(self, x):
f1 = self.branch1x1(x)
f2 = self.branch3x3(x)
f3 = self.branch5x5(x)
f4 = self.branch_pool(x)
output = torch.cat((f1, f2, f3, f4), dim=1)
return output
#测试网络
test_net = inception(3, 64, 48, 64, 64, 96, 32)
test_x = Variable(torch.zeros(1, 3, 96, 96))
print('input shape: {} x {} x {}'.format(test_x.shape[1], test_x.shape[2], test_x.shape[3]))
test_y = test_net(test_x)
print('output shape: {} x {} x {}'.format(test_y.shape[1], test_y.shape[2], test_y.shape[3]))
class googlenet(nn.Module):
def __init__(self, in_channel, num_classes, verbose=False):
super(googlenet, self).__init__()
self.verbose = verbose
self.block1 = nn.Sequential(
conv_relu(in_channel, out_channel=64, kernel=7, stride=2, padding=3),
nn.MaxPool2d(3, 2)
)
self.block2 = nn.Sequential(
conv_relu(64, 64, kernel=1),
conv_relu(64, 192, kernel=3, padding=1),
nn.MaxPool2d(3, 2)
)
self.block3 = nn.Sequential(
inception(192, 64, 96, 128, 16, 32, 32),
inception(256, 128, 128, 192, 32, 96, 64),
nn.MaxPool2d(3, 2)
)
self.block4 = nn.Sequential(
inception(480, 192, 96, 208, 16, 48, 64),
inception(512, 160, 112, 224, 24, 64, 64),
inception(512, 128, 128, 256, 24, 64, 64),
inception(512, 112, 144, 288, 32, 64, 64),
inception(528, 256, 160, 320, 32, 128, 128),
nn.MaxPool2d(3, 2)
)
self.block5 = nn.Sequential(
inception(832, 256, 160, 320, 32, 128, 128),
inception(832, 384, 182, 384, 48, 128, 128),
nn.AvgPool2d(2)
)
self.classifier = nn.Linear(1024, num_classes)
def forward(self, x):
x = self.block1(x)
if self.verbose:
print('block 1 output: {}'.format(x.shape))
x = self.block2(x)
if self.verbose:
print('block 2 output: {}'.format(x.shape))
x = self.block3(x)
if self.verbose:
print('block 3 output: {}'.format(x.shape))
x = self.block4(x)
if self.verbose:
print('block 4 output: {}'.format(x.shape))
x = self.block5(x)
if self.verbose:
print('block 5 output: {}'.format(x.shape))
x = x.view(x.shape[0], -1)
x = self.classifier(x)
return x