图像分类丨ILSVRC历届冠军网络「从AlexNet到SENet」

前言

• 深度卷积网络极大地推进深度学习各领域的发展&＃xff0c;ILSVRC作为最具影响力的竞赛功不可没&＃xff0c;促使了许多经典工作。我梳理了ILSVRC分类任务的各届冠军和亚军网络&＃xff0c;简单介绍了它们的核心思想、网络架构及其实现。

  代码主要来自&＃xff1a;https://github.com/weiaicunzai/pytorch-cifar100

• ImageNet和ILSVRC

• • ImageNet是一个超过15 million的图像数据集&＃xff0c;大约有22,000类。

  • ILSVRC全称ImageNet Large-Scale Visual Recognition Challenge&＃xff0c;从2010年开始举办到2017年最后一届&＃xff0c;使用ImageNet数据集的一个子集&＃xff0c;总共有1000类。

• 历届结果

• 评价标准

  top1是指概率向量中最大的作为预测结果&＃xff0c;若分类正确&＃xff0c;则为正确&＃xff1b;top5则只要概率向量中最大的前五名里有分类正确的&＃xff0c;则为正确。

LeNet

Gradient-Based Learning Applied to Document Recognition

网络架构

import torch.nn as nn
import torch.nn.functional as func
class LeNet(nn.Module):def __init__(self):super(LeNet, self).__init__()self.conv1 &＃61; nn.Conv2d(1, 6, kernel_size&＃61;5)self.conv2 &＃61; nn.Conv2d(6, 16, kernel_size&＃61;5)self.fc1 &＃61; nn.Linear(16*16, 120)self.fc2 &＃61; nn.Linear(120, 84)self.fc3 &＃61; nn.Linear(84, 10)def forward(self, x):x &＃61; func.relu(self.conv1(x))x &＃61; func.max_pool2d(x, 2)x &＃61; func.relu(self.conv2(x))x &＃61; func.max_pool2d(x, 2)x &＃61; x.view(x.size(0), -1)x &＃61; func.relu(self.fc1(x))x &＃61; func.relu(self.fc2(x))x &＃61; self.fc3(x)return x


AlexNet

ImageNet Classification with Deep Convolutional Neural Networks

核心思想

• AlexNet相比前人有以下改进&＃xff1a;

•               1.采用ReLU激活函数

                2.局部响应归一化LRN

  

                3.Overlapping Pooling

                4.引入Drop out

                5.数据增强

                6.多GPU并行

网络架构

• 代码实现

class AlexNet(nn.Module):def __init__(self, num_classes&＃61;NUM_CLASSES):super(AlexNet, self).__init__()self.features &＃61; nn.Sequential(nn.Conv2d(1, 96, kernel_size&＃61;11,padding&＃61;1),nn.ReLU(inplace&＃61;True),nn.MaxPool2d(kernel_size&＃61;2),nn.Conv2d(96, 256, kernel_size&＃61;3, padding&＃61;1),nn.ReLU(inplace&＃61;True),nn.MaxPool2d(kernel_size&＃61;2),nn.Conv2d(256, 384, kernel_size&＃61;3, padding&＃61;1),nn.ReLU(inplace&＃61;True),nn.Conv2d(384, 384, kernel_size&＃61;3, padding&＃61;1),nn.ReLU(inplace&＃61;True),nn.Conv2d(384, 256, kernel_size&＃61;3, padding&＃61;1),nn.ReLU(inplace&＃61;True),nn.MaxPool2d(kernel_size&＃61;2),)self.classifier &＃61; nn.Sequential(nn.Dropout(),nn.Linear(256 * 2 * 2, 4096),nn.ReLU(inplace&＃61;True),nn.Dropout(),nn.Linear(4096, 4096),nn.ReLU(inplace&＃61;True),nn.Linear(4096, 10),)def forward(self, x):x &＃61; self.features(x)x &＃61; x.view(x.size(0), 256 * 2 * 2)x &＃61; self.classifier(x)return x


实验结果

ZFNet

Visualizing and Understanding Convolutional Networks

核心思想

• 利用反卷积可视化CNN学到的特征。

•     1.Unpooling&＃xff1a;池化操作不可逆&＃xff0c;但通过记录池化最大值的位置可实现逆操作。

      2.Rectification&＃xff1a;ReLU

      3.Filtering&＃xff1a;使用原卷积核的转置版本。

网络架构

实验结果

• 特征可视化&＃xff1a;Layer2响应角落和边缘、颜色连接&＃xff1b;Layer3有更复杂的不变性&＃xff0c;捕获相似纹理&＃xff1b;Layer4展示了明显的变化&＃xff0c;跟类别更相关&＃xff1b;Layer5看到整个物体。

• 训练过程特征演化&＃xff1a;低层特征较快收敛&＃xff0c;高层到后面才开始变化。

• 特征不变性&＃xff1a;小变换在模型第一层变化明显&＃xff0c;但在顶层影响较小。网络输出对翻转和缩放是稳定的&＃xff0c;但除了旋转对称性的物体&＃xff0c;输出对旋转并不是不变的。

• 遮挡敏感性&＃xff1a;当对象被遮挡&＃xff0c;准确性会明显下降。

• ImageNet结果

VGG

Very Deep Convolutional Networks for Large-Scale Image Recognition

核心思想

• 重复使用3x3卷积和2x2池化增加网络深度。

网络架构

• VGG19表示有19层conv或fc&＃xff0c;参数量较大。

• 代码实现

cfg &＃61; {&＃39;A&＃39; : [64, &＃39;M&＃39;, 128, &＃39;M&＃39;, 256, 256, &＃39;M&＃39;, 512, 512, &＃39;M&＃39;, 512, 512, &＃39;M&＃39;],&＃39;B&＃39; : [64, 64, &＃39;M&＃39;, 128, 128, &＃39;M&＃39;, 256, 256, &＃39;M&＃39;, 512, 512, &＃39;M&＃39;, 512, 512, &＃39;M&＃39;],&＃39;D&＃39; : [64, 64, &＃39;M&＃39;, 128, 128, &＃39;M&＃39;, 256, 256, 256, &＃39;M&＃39;, 512, 512, 512, &＃39;M&＃39;, 512, 512, 512, &＃39;M&＃39;],&＃39;E&＃39; : [64, 64, &＃39;M&＃39;, 128, 128, &＃39;M&＃39;, 256, 256, 256, 256, &＃39;M&＃39;, 512, 512, 512, 512, &＃39;M&＃39;, 512, 512, 512, 512, &＃39;M&＃39;]
}def vgg19_bn():return VGG(make_layers(cfg[&＃39;E&＃39;], batch_norm&＃61;True))class VGG(nn.Module):def __init__(self, features, num_class&＃61;100):super().__init__()self.features &＃61; featuresself.classifier &＃61; nn.Sequential(nn.Linear(512, 4096),nn.ReLU(inplace&＃61;True),nn.Dropout(),nn.Linear(4096, 4096),nn.ReLU(inplace&＃61;True),nn.Dropout(),nn.Linear(4096, num_class))def forward(self, x):output &＃61; self.features(x)output &＃61; output.view(output.size()[0], -1)output &＃61; self.classifier(output)return outputdef make_layers(cfg, batch_norm&＃61;False):layers &＃61; []input_channel &＃61; 3for l in cfg:if l &＃61;&＃61; &＃39;M&＃39;:layers &＃43;&＃61; [nn.MaxPool2d(kernel_size&＃61;2, stride&＃61;2)]continuelayers &＃43;&＃61; [nn.Conv2d(input_channel, l, kernel_size&＃61;3, padding&＃61;1)]if batch_norm:layers &＃43;&＃61; [nn.BatchNorm2d(l)]layers &＃43;&＃61; [nn.ReLU(inplace&＃61;True)]input_channel &＃61; lreturn nn.Sequential(*layers)


实验结果

GoogLeNet(v1)

Going Deeper with Convolutions

核心思想

• 提出Inception模块&＃xff0c;可在保持计算成本的同时增加网络的深度和宽度。

• 代码实现

class Inception(nn.Module):def __init__(self, input_channels, n1x1, n3x3_reduce, n3x3, n5x5_reduce, n5x5, pool_proj):super().__init__()#1x1conv branchself.b1 &＃61; nn.Sequential(nn.Conv2d(input_channels, n1x1, kernel_size&＃61;1),nn.BatchNorm2d(n1x1),nn.ReLU(inplace&＃61;True))#1x1conv -> 3x3conv branchself.b2 &＃61; nn.Sequential(nn.Conv2d(input_channels, n3x3_reduce, kernel_size&＃61;1),nn.BatchNorm2d(n3x3_reduce),nn.ReLU(inplace&＃61;True),nn.Conv2d(n3x3_reduce, n3x3, kernel_size&＃61;3, padding&＃61;1),nn.BatchNorm2d(n3x3),nn.ReLU(inplace&＃61;True))#1x1conv -> 5x5conv branch#we use 2 3x3 conv filters stacked instead#of 1 5x5 filters to obtain the same receptive#field with fewer parametersself.b3 &＃61; nn.Sequential(nn.Conv2d(input_channels, n5x5_reduce, kernel_size&＃61;1),nn.BatchNorm2d(n5x5_reduce),nn.ReLU(inplace&＃61;True),nn.Conv2d(n5x5_reduce, n5x5, kernel_size&＃61;3, padding&＃61;1),nn.BatchNorm2d(n5x5, n5x5),nn.ReLU(inplace&＃61;True),nn.Conv2d(n5x5, n5x5, kernel_size&＃61;3, padding&＃61;1),nn.BatchNorm2d(n5x5),nn.ReLU(inplace&＃61;True))#3x3pooling -> 1x1conv#same convself.b4 &＃61; nn.Sequential(nn.MaxPool2d(3, stride&＃61;1, padding&＃61;1),nn.Conv2d(input_channels, pool_proj, kernel_size&＃61;1),nn.BatchNorm2d(pool_proj),nn.ReLU(inplace&＃61;True))def forward(self, x):return torch.cat([self.b1(x), self.b2(x), self.b3(x), self.b4(x)], dim&＃61;1)


网络架构

• 代码实现

def googlenet():return GoogleNet()class GoogleNet(nn.Module):def __init__(self, num_class&＃61;100):super().__init__()self.prelayer &＃61; nn.Sequential(nn.Conv2d(3, 192, kernel_size&＃61;3, padding&＃61;1),nn.BatchNorm2d(192),nn.ReLU(inplace&＃61;True))#although we only use 1 conv layer as prelayer,#we still use name a3, b3.......self.a3 &＃61; Inception(192, 64, 96, 128, 16, 32, 32)self.b3 &＃61; Inception(256, 128, 128, 192, 32, 96, 64)#"""In general, an Inception network is a network consisting of#modules of the above type stacked upon each other, with occasional#max-pooling layers with stride 2 to halve the resolution of the#grid"""self.maxpool &＃61; nn.MaxPool2d(3, stride&＃61;2, padding&＃61;1)self.a4 &＃61; Inception(480, 192, 96, 208, 16, 48, 64)self.b4 &＃61; Inception(512, 160, 112, 224, 24, 64, 64)self.c4 &＃61; Inception(512, 128, 128, 256, 24, 64, 64)self.d4 &＃61; Inception(512, 112, 144, 288, 32, 64, 64)self.e4 &＃61; Inception(528, 256, 160, 320, 32, 128, 128)self.a5 &＃61; Inception(832, 256, 160, 320, 32, 128, 128)self.b5 &＃61; Inception(832, 384, 192, 384, 48, 128, 128)#input feature size: 8*8*1024self.avgpool &＃61; nn.AdaptiveAvgPool2d((1, 1))self.dropout &＃61; nn.Dropout2d(p&＃61;0.4)self.linear &＃61; nn.Linear(1024, num_class)def forward(self, x):output &＃61; self.prelayer(x)output &＃61; self.a3(output)output &＃61; self.b3(output)output &＃61; self.maxpool(output)output &＃61; self.a4(output)output &＃61; self.b4(output)output &＃61; self.c4(output)output &＃61; self.d4(output)output &＃61; self.e4(output)output &＃61; self.maxpool(output)output &＃61; self.a5(output)output &＃61; self.b5(output)#"""It was found that a move from fully connected layers to#average pooling improved the top-1 accuracy by about 0.6%,#however the use of dropout remained essential even after#removing the fully connected layers."""output &＃61; self.avgpool(output)output &＃61; self.dropout(output)output &＃61; output.view(output.size()[0], -1)output &＃61; self.linear(output)return output


实验结果

ResNet

Deep Residual Learning for Image Recognition

核心思想

• 为了解决深层网络难以训练的问题&＃xff0c;提出了残差模块和深度残差网络

•        1.假设网络输入是x&＃xff0c;经学习的输出是F(x)&＃xff0c;最终拟合目标是H(x)。

         2.深层网络相比浅层网络有一些层是多余的&＃xff0c;若让多余层学习恒等变换H(x)&＃61;x&＃xff0c;那么网络性能不该比浅层网络要差。

         3.传统网络训练目标H(x)&＃61;F(x)&＃xff0c;残差网络训练目标H(x)&＃61;F(x)&＃43;x。

         4.为了学习恒等变换&＃xff0c;传统网络要求网络学习F(x)&＃61;H(x)&＃61;x&＃xff0c;残差网络只需学习   F(x)&＃61;H(x)−x&＃61;x−x&＃61;0。残差学习之所以有效是因为让网络学习F(x)&＃61;0比学习F(x)&＃61;x要容易。

• bottleneck

• 代码实现

class BottleNeck(nn.Module):"""Residual block for resnet over 50 layers"""expansion &＃61; 4def __init__(self, in_channels, out_channels, stride&＃61;1):super().__init__()self.residual_function &＃61; nn.Sequential(nn.Conv2d(in_channels, out_channels, kernel_size&＃61;1, bias&＃61;False),nn.BatchNorm2d(out_channels),nn.ReLU(inplace&＃61;True),nn.Conv2d(out_channels, out_channels, stride&＃61;stride, kernel_size&＃61;3, padding&＃61;1, bias&＃61;False),nn.BatchNorm2d(out_channels),nn.ReLU(inplace&＃61;True),nn.Conv2d(out_channels, out_channels * BottleNeck.expansion, kernel_size&＃61;1, bias&＃61;False),nn.BatchNorm2d(out_channels * BottleNeck.expansion),)self.shortcut &＃61; nn.Sequential()if stride !&＃61; 1 or in_channels !&＃61; out_channels * BottleNeck.expansion:self.shortcut &＃61; nn.Sequential(nn.Conv2d(in_channels, out_channels * BottleNeck.expansion, stride&＃61;stride, kernel_size&＃61;1, bias&＃61;False),nn.BatchNorm2d(out_channels * BottleNeck.expansion))def forward(self, x):return nn.ReLU(inplace&＃61;True)(self.residual_function(x) &＃43; self.shortcut(x))


网络架构

• 代码实现

def resnet152():""" return a ResNet 152 object"""return ResNet(BottleNeck, [3, 8, 36, 3])class ResNet(nn.Module):def __init__(self, block, num_block, num_classes&＃61;100):super().__init__()self.in_channels &＃61; 64self.conv1 &＃61; nn.Sequential(nn.Conv2d(3, 64, kernel_size&＃61;3, padding&＃61;1, bias&＃61;False),nn.BatchNorm2d(64),nn.ReLU(inplace&＃61;True))#we use a different inputsize than the original paper#so conv2_x&＃39;s stride is 1self.conv2_x &＃61; self._make_layer(block, 64, num_block[0], 1)self.conv3_x &＃61; self._make_layer(block, 128, num_block[1], 2)self.conv4_x &＃61; self._make_layer(block, 256, num_block[2], 2)self.conv5_x &＃61; self._make_layer(block, 512, num_block[3], 2)self.avg_pool &＃61; nn.AdaptiveAvgPool2d((1, 1))self.fc &＃61; nn.Linear(512 * block.expansion, num_classes)def _make_layer(self, block, out_channels, num_blocks, stride):"""make resnet layers(by layer i didnt mean this &＃39;layer&＃39; was thesame as a neuron netowork layer, ex. conv layer), one layer maycontain more than one residual blockArgs:block: block type, basic block or bottle neck blockout_channels: output depth channel number of this layernum_blocks: how many blocks per layerstride: the stride of the first block of this layerReturn:return a resnet layer"""# we have num_block blocks per layer, the first block# could be 1 or 2, other blocks would always be 1strides &＃61; [stride] &＃43; [1] * (num_blocks - 1)layers &＃61; []for stride in strides:layers.append(block(self.in_channels, out_channels, stride))self.in_channels &＃61; out_channels * block.expansionreturn nn.Sequential(*layers)def forward(self, x):output &＃61; self.conv1(x)output &＃61; self.conv2_x(output)output &＃61; self.conv3_x(output)output &＃61; self.conv4_x(output)output &＃61; self.conv5_x(output)output &＃61; self.avg_pool(output)output &＃61; output.view(output.size(0), -1)output &＃61; self.fc(output)return output


实验结果

ResNeXt

Aggregated Residual Transformations for Deep Neural Networks

核心思想

• 通过重复构建block来聚合一组相同拓扑结构的特征&＃xff0c;并提出一个新维度”cardinality“。

• ResNeXt结合了VGG、ResNet重复堆叠模块和Inception的split-transform-merge的思想。

以下三者等价&＃xff0c;文章采用第三种实现&＃xff0c;其使用了组卷积。

• 代码实现

CARDINALITY &＃61; 32
DEPTH &＃61; 4
BASEWIDTH &＃61; 64class ResNextBottleNeckC(nn.Module):def __init__(self, in_channels, out_channels, stride):super().__init__()C &＃61; CARDINALITY #How many groups a feature map was splitted into#"""We note that the input/output width of the template is fixed as#256-d (Fig. 3), We note that the input/output width of the template#is fixed as 256-d (Fig. 3), and all widths are dou- bled each time#when the feature map is subsampled (see Table 1)."""D &＃61; int(DEPTH * out_channels / BASEWIDTH) #number of channels per groupself.split_transforms &＃61; nn.Sequential(nn.Conv2d(in_channels, C * D, kernel_size&＃61;1, groups&＃61;C, bias&＃61;False),nn.BatchNorm2d(C * D),nn.ReLU(inplace&＃61;True),nn.Conv2d(C * D, C * D, kernel_size&＃61;3, stride&＃61;stride, groups&＃61;C, padding&＃61;1, bias&＃61;False),nn.BatchNorm2d(C * D),nn.ReLU(inplace&＃61;True),nn.Conv2d(C * D, out_channels * 4, kernel_size&＃61;1, bias&＃61;False),nn.BatchNorm2d(out_channels * 4),)self.shortcut &＃61; nn.Sequential()if stride !&＃61; 1 or in_channels !&＃61; out_channels * 4:self.shortcut &＃61; nn.Sequential(nn.Conv2d(in_channels, out_channels * 4, stride&＃61;stride, kernel_size&＃61;1, bias&＃61;False),nn.BatchNorm2d(out_channels * 4))def forward(self, x):return F.relu(self.split_transforms(x) &＃43; self.shortcut(x))


网络架构

• 代码实现

  以下部分跟ResNet基本一致&＃xff0c;重点关注ResNextBottleNeckC的实现。

def resnext50():""" return a resnext50(c32x4d) network"""return ResNext(ResNextBottleNeckC, [3, 4, 6, 3])class ResNext(nn.Module):def __init__(self, block, num_blocks, class_names&＃61;100):super().__init__()self.in_channels &＃61; 64self.conv1 &＃61; nn.Sequential(nn.Conv2d(3, 64, 3, stride&＃61;1, padding&＃61;1, bias&＃61;False),nn.BatchNorm2d(64),nn.ReLU(inplace&＃61;True))self.conv2 &＃61; self._make_layer(block, num_blocks[0], 64, 1)self.conv3 &＃61; self._make_layer(block, num_blocks[1], 128, 2)self.conv4 &＃61; self._make_layer(block, num_blocks[2], 256, 2)self.conv5 &＃61; self._make_layer(block, num_blocks[3], 512, 2)self.avg &＃61; nn.AdaptiveAvgPool2d((1, 1))self.fc &＃61; nn.Linear(512 * 4, 100)def forward(self, x):x &＃61; self.conv1(x)x &＃61; self.conv2(x)x &＃61; self.conv3(x)x &＃61; self.conv4(x)x &＃61; self.conv5(x)x &＃61; self.avg(x)x &＃61; x.view(x.size(0), -1)x &＃61; self.fc(x)return xdef _make_layer(self, block, num_block, out_channels, stride):"""Building resnext blockArgs:block: block type(default resnext bottleneck c)num_block: number of blocks per layerout_channels: output channels per blockstride: block strideReturns:a resnext layer"""strides &＃61; [stride] &＃43; [1] * (num_block - 1)layers &＃61; []for stride in strides:layers.append(block(self.in_channels, out_channels, stride))self.in_channels &＃61; out_channels * 4return nn.Sequential(*layers)


实验结果

SENet

Squeeze-and-Excitation Networks

核心思想

• 卷积操作融合了空间和特征通道信息。大量工作研究了空间部分&＃xff0c;而本文重点关注特征通道的关系&＃xff0c;并提出了Squeeze-and-Excitation(SE)block&＃xff0c;对通道间的依赖关系进行建模&＃xff0c;自适应校准通道方面的特征响应。

• SE block

  表示transformation&＃xff08;一系列卷积操作&＃xff09;&＃xff1b;表示squeeze&＃xff0c;产生通道描述&＃xff1b;表示excitation&＃xff0c;通过参数WW来建模通道的重要性。表示reweight&＃xff0c;将excitation输出的权重逐乘以先前特征&＃xff0c;完成特征重标定。

• SE-ResNet Module

  

• 代码实现

class BottleneckResidualSEBlock(nn.Module):expansion &＃61; 4def __init__(self, in_channels, out_channels, stride, r&＃61;16):super().__init__()self.residual &＃61; nn.Sequential(nn.Conv2d(in_channels, out_channels, 1),nn.BatchNorm2d(out_channels),nn.ReLU(inplace&＃61;True),nn.Conv2d(out_channels, out_channels, 3, stride&＃61;stride, padding&＃61;1),nn.BatchNorm2d(out_channels),nn.ReLU(inplace&＃61;True),nn.Conv2d(out_channels, out_channels * self.expansion, 1),nn.BatchNorm2d(out_channels * self.expansion),nn.ReLU(inplace&＃61;True))self.squeeze &＃61; nn.AdaptiveAvgPool2d(1)self.excitation &＃61; nn.Sequential(nn.Linear(out_channels * self.expansion, out_channels * self.expansion // r),nn.ReLU(inplace&＃61;True),nn.Linear(out_channels * self.expansion // r, out_channels * self.expansion),nn.Sigmoid())self.shortcut &＃61; nn.Sequential()if stride !&＃61; 1 or in_channels !&＃61; out_channels * self.expansion:self.shortcut &＃61; nn.Sequential(nn.Conv2d(in_channels, out_channels * self.expansion, 1, stride&＃61;stride),nn.BatchNorm2d(out_channels * self.expansion))def forward(self, x):shortcut &＃61; self.shortcut(x)residual &＃61; self.residual(x)squeeze &＃61; self.squeeze(residual)squeeze &＃61; squeeze.view(squeeze.size(0), -1)excitation &＃61; self.excitation(squeeze)excitation &＃61; excitation.view(residual.size(0), residual.size(1), 1, 1)x &＃61; residual * excitation.expand_as(residual) &＃43; shortcutreturn F.relu(x)


网络架构

• 代码实现

def seresnet50():return SEResNet(BottleneckResidualSEBlock, [3, 4, 6, 3])class SEResNet(nn.Module):def __init__(self, block, block_num, class_num&＃61;100):super().__init__()self.in_channels &＃61; 64self.pre &＃61; nn.Sequential(nn.Conv2d(3, 64, 3, padding&＃61;1),nn.BatchNorm2d(64),nn.ReLU(inplace&＃61;True))self.stage1 &＃61; self._make_stage(block, block_num[0], 64, 1)self.stage2 &＃61; self._make_stage(block, block_num[1], 128, 2)self.stage3 &＃61; self._make_stage(block, block_num[2], 256, 2)self.stage4 &＃61; self._make_stage(block, block_num[3], 516, 2)self.linear &＃61; nn.Linear(self.in_channels, class_num)def forward(self, x):x &＃61; self.pre(x)x &＃61; self.stage1(x)x &＃61; self.stage2(x)x &＃61; self.stage3(x)x &＃61; self.stage4(x)x &＃61; F.adaptive_avg_pool2d(x, 1)x &＃61; x.view(x.size(0), -1)x &＃61; self.linear(x)return xdef _make_stage(self, block, num, out_channels, stride):layers &＃61; []layers.append(block(self.in_channels, out_channels, stride))self.in_channels &＃61; out_channels * block.expansionwhile num - 1:layers.append(block(self.in_channels, out_channels, 1))num -&＃61; 1return nn.Sequential(*layers)


实验结果

总结

 一、小结

1.LeNet[1998]&＃xff1a;CNN的鼻祖。

2.AlexNet[2012]&＃xff1a;第一个深度CNN。

3.ZFNet[2012]&＃xff1a;通过DeconvNet可视化CNN学习到的特征。

4.VGG[2014]&＃xff1a;重复堆叠3x3卷积增加网络深度。

5.GoogLeNet[2014]&＃xff1a;提出Inception模块&＃xff0c;在控制参数和计算量的前提下&＃xff0c;增加网络的深度与宽度。

6.ResNet[2015]&＃xff1a;提出残差网络&＃xff0c;解决了深层网络的优化问题。

7.ResNeXt[2016]&＃xff1a;ResNet和Inception的结合体&＃xff0c;Inception中每个分支结构相同&＃xff0c;无需人为设计。

8.SENet[2017]&＃xff1a;提出SE block&＃xff0c;关注特征的通道关系。

二、经典模型中结构、参数对比

参考

• paper

[1]LeCun Y, Bottou L, Bengio Y, et al. Gradient-based learning applied to document recognition[J]. Proceedings of the IEEE, 1998, 86(11): 2278-2324.

[2]Krizhevsky A, Sutskever I, Hinton G E. Imagenet classification with deep convolutional neural networks[C]//Advances in neural information processing systems. 2012: 1097-1105.

[3]Zeiler M D, Fergus R. Visualizing and understanding convolutional networks[C]//European conference on computer vision. springer, Cham, 2014: 818-833.

[4]Simonyan K, Zisserman A. Very deep convolutional networks for large-scale image recognition[J]. arXiv preprint arXiv:1409.1556, 2014.

[5]Szegedy C, Liu W, Jia Y, et al. Going deeper with convolutions[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2015: 1-9.

[6]He K, Zhang X, Ren S, et al. Deep residual learning for image recognition[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2016: 770-778.

[7]Xie S, Girshick R, Dollár P, et al. Aggregated residual transformations for deep neural networks[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2017: 1492-1500.

[8]Hu J, Shen L, Sun G. Squeeze-and-excitation networks[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2018: 7132-7141.

• blog

ImageNet历年冠军和相关CNN模型

残差网络ResNet笔记

(二)计算机视觉四大基本任务(分类、定位、检测、分割)

论文笔记&＃xff1a;CNN经典结构2&＃xff08;WideResNet&＃xff0c;FractalNet&＃xff0c;DenseNet&＃xff0c;ResNeXt&＃xff0c;DPN&＃xff0c;SENet&＃xff09;

论文笔记&＃xff1a;CNN经典结构1&＃xff08;AlexNet&＃xff0c;ZFNet&＃xff0c;OverFeat&＃xff0c;VGG&＃xff0c;GoogleNet&＃xff0c;ResNet&＃xff09;

深度学习在计算机视觉领域&＃xff08;包括图像&＃xff0c;视频&＃xff0c;3-D点云&＃xff0c;深度图&＃xff09;的应用一览

&＃xff08;本文出自平台合作作者Vincent&＃xff0c;cs硕士在读。&＃xff09;

     不断更新资源

     获取更多精彩

长按二维码扫码关注