resnet_resnet50 - CSDN
精华内容
参与话题
  • ResNet详细解读

    万次阅读 多人点赞 2017-12-13 21:20:11
    这篇文章是Deep Residual Learning for Image Recognition 的翻译,精简部分内容的同时补充了相关的概念,如有错误,敬请指正。

    这篇文章是Deep Residual Learning for Image Recognition 的翻译,精简部分内容的同时补充了相关的概念,如有错误,敬请指正。

    Abstract

    深度神经网络通常都比较难训练。我们提出残差学习的框架来减轻深层网络训练的难度。我们重新构建了网络以便学习包含推理的残差函数,而不是学习未经过推理的函数。实验结果显示,残差网络更容易优化,并且加深网络层数有助于提高正确率。在ImageNet上使用152层的残差网络(VGG net的8倍深度,但残差网络复杂度更低)。对这些网络使用集成方法实现了3.75%的错误率。获得了ILSVRC 2015竞赛的第一名。同时,我们也在CIFAR-10上分别使用100和1000层的网络进行了实验。
    网络能表达的深层特征是许多视觉识别任务的关键。借助网络的深层表达能力,残差网络在COCO目标检测数据集上实现了28%的相对提升。

    1. Introduction

    深度卷积网络在图像分类任务上取得了一系列突破。深度网络通过多层端到端的方式,集成了低中高三个层次的特征和分类器,并且这些特征的数量还可以通过堆叠层数来增加。在ImageNet数据集上获胜的网络揭示了网络深度的重要性。
    随着网络层数的增加,训练的问题随之凸显。比较显著的问题有梯度消失/爆炸,这会在一开始就影响收敛。收敛的问题可以通过正则化来得到部分的解决。
    在深层网络能够收敛的前提下,随着网络深度的增加,正确率开始饱和甚至下降,称之为网络的退化(degradation)问题。 示例可见Figure 1. 显然,56层的网络相对于20层的网络,不管是训练误差还是测试误差都显著增大。

    很明显,这些退化并不是过拟合造成的。在给定的网络上增加层数会增大训练误差。 网络的退化说明不是所有的系统都很容易优化。考虑一个浅层的网络架构和在它基础上构建的深层网络,在极端条件下,如果增加的所有层都是前一层的直接复制(即y=x),这种情况下深层网络的训练误差应该和浅层网络相等。因此,网络退化的根本原因还是优化问题。 为了解决优化的难题,提出了残差网络。在残差网络中,不是让网络直接拟合原先的映射,而是拟合残差映射。 假设原始的映射为H(x),残差网络拟合的映射为:F(x)=H(x)
    其中,identity mapping为恒等映射。 残差网络可以理解为在前向网络中增加了一些快捷连接(shortcut connections)。这些连接会跳过某些层,将原始数据直接传到之后的层。新增的快捷连接不会增加模型的参数和复杂度。整个模型还是可以使用端到端的方法来训练(比如SGD),在实现上并不难。

    2. Related Work

    Shortcut Connections

    高速网络(highway networks)1和快捷连接有相似之处,但是高速网络中含有参数。高速网络中的gate在训练过程中可能关闭,相反,残差网络中的连接不会关闭,残差函数可以被学习。

    3. Deep Residual Learning

    在堆叠的几层网络上使用残差连接。整个网络的架构如图:

    其中,左边是VGG-19的模型,中间是原始网络,右边是残差网络。残差网络的参数比VGG-19要少。

    Implementation

    在ImageNet上的测试设置如下:
    图片使用欠采样放缩到[256480],以提供尺寸上的数据增强。对原图作水平翻转,并且使用[224224]的随机采样,同时每一个像素作去均值处理。在每一个卷积层之后,激活函数之前使用BN。使用SGD,mini-batch大小为256。学习率的初始值为0.1,当训练误差不再缩小时降低学习率为原先的1/10继续训练。训练过程进行了600000次迭代。

    4. Experiments

    Table1中给出了不同层数的ResNet架构。



    ImageNet Classification

    Plain Networks

    分别使用18层的plain nets和34层的plain nets,结果显示34层的网络有更高的验证误差。下图比较了整个过程的训练和测试误差:

    注:细实线代表训练误差,粗实线代表验证误差。左侧为plain nets,右侧为ResNet。 这种优化上的困难不是由于梯度消失造成的,因为在网络中已经使用了BN,保证了前向传播的信号有非零的方差。猜想深层的神经网络的收敛几率随着网络层数的加深,以指数的形式下降,导致训练误差很难降低。

    Residual Networks

    测试18层和34层的ResNet。注意到34层的训练和测试误差都要比18层的小。这说明网络退化的问题得到了部分解决,通过加深网络深度,可以提高正确率。注意到18层的plain net和18层的ResNet可以达到相近的正确率,但是ResNet收敛更快。这说明网络不够深的时候,SGD还是能够找到很好的解。

    Identity vs. Projection Shortcuts

    比较了三种选择:
    (A)zero-padding shortcuts用来增加维度(Residual block的维度小于输出维度时,使用0来进行填充),所有的shortcut无参数。
    (B)projection shortcuts用来增加维度(维度不一致时使用),其他的shortcut都是恒等映射(identity)类型。
    (C)所有的shortcut都是使用projection shortcuts。
    Table3中给出了实验结果:

    结果表明,这三种选择都有助于提高正确率。其中,B比A效果好,原因可能是A中zero-padded的维度没有使用残差学习。C比B效果好,原因可能是projection shortcuts中引入的参数。但是ABC中的结果表明,projection shortcuts对于解决网络的退化问题是没有作用的,对于正确率的提升作用也十分有限。所以,从减少模型参数,降低复杂度的角度考虑,使用Identity shortcuts就已经足够了。

    Deeper Bottleneck Architectures.

    在探究更深层网络性能的时候,处于训练时间的考虑,我们使用bottleneck design的方式来设计building block。对于每一个残差函数F,使用一个三层的stack代替以前的两层。这三层分别使用1×1, 3×3, 和 1×1的卷积。其中,1×1卷积用来降维然后升维,即利用1×1卷积解决维度不同的问题。3×3对应一个瓶颈(更少的输入、输出维度)。Fig.5 展示了这种设计。

    50、101和152层的ResNet相对于32层网络有更高的准确率。Table3和4中给出了测试结果。
    注:使用集成方法的152层网络能达到3.75%的错误率。

    4.2. CIFAR10 and Analysis

    在CIFAR10数据集上的测试表明,ResNet的layer对于输入信号具有更小的响应。

    对于更深的网络,比如超过1000层的情况,虽然能够进行训练,但是测试的正确率并不理想。原因可能是过拟合,因为超过1000层的网络对于这个小数据集来说,容量还是过大。

    总结

    ResNet和Highway Network的思路比较类似,都是将部分原始输入的信息不经过矩阵乘法和非线性变换,直接传输到下一层。这就如同在深层网络中建立了许多条信息高速公路。ResNet通过改变学习目标,即不再学习完整的输出F(x),而是学习残差H(x)x,解决了传统卷积层或全连接层在进行信息传递时存在的丢失、损耗等问题。通过直接将信息从输入绕道传输到输出,一定程度上保护了信息的完整性。同时,由于学习的目标是残差,简化了学习的难度。根据Schmidhuber教授的观点,ResNet类似于一个没有gates的LSTM网络,即旁路输入x一直向之后的层传递,而不需要学习。有论文表示,ResNet的效果类似于对不同层数网络进行集成方法。

    Inplimentation

    这里简单分析一下ResNet152在PyTorch上的实现。
    源代码:https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py

    首先需要导入相关的库。注意这个文件中实现了五种不同层数的ResNet模型’resnet18’, ‘resnet34’, ‘resnet50’, ‘resnet101’, ‘resnet152’

    import torch.nn as nn
    import math
    import torch.utils.model_zoo as model_zoo
    
    
    __all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
               'resnet152']
    
    
    model_urls = {
        'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
        'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
        'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
        'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
        'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
    }

    接下来定义一个3*3的卷积模板,步长为1,并且使用大小为1的zeropadding。

    def conv3x3(in_planes, out_planes, stride=1):
        "3x3 convolution with padding"
        return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
                         padding=1, bias=False)

    之后定义基础模块BasicBlock
    1. 可以看出BasicBlock架构中,主要使用了两个33的卷积,然后进行BN,之后的out += residual这一句在输出上叠加了输入x(注意到一开始定义了residual = x
    2. if self.downsample is not None:部分的代码,实际上是在进行欠采样,在网络的某些层可能会用到。

    class BasicBlock(nn.Module):
        expansion = 1
    
        def __init__(self, inplanes, planes, stride=1, downsample=None):
            super(BasicBlock, self).__init__()
            self.conv1 = conv3x3(inplanes, planes, stride)
            self.bn1 = nn.BatchNorm2d(planes)
            self.relu = nn.ReLU(inplace=True)
            self.conv2 = conv3x3(planes, planes)
            self.bn2 = nn.BatchNorm2d(planes)
            self.downsample = downsample
            self.stride = stride
    
        def forward(self, x):
            residual = x
    
            out = self.conv1(x)
            out = self.bn1(out)
            out = self.relu(out)
    
            out = self.conv2(out)
            out = self.bn2(out)
    
            if self.downsample is not None:
                residual = self.downsample(x)
    
            out += residual
            out = self.relu(out)
    
            return out

    接下来定义Bottleneck模块。
    这三层分别使用113311的卷积模板,使用Bottleneck结构可以减少网络参数数量。

    class Bottleneck(nn.Module):
        expansion = 4
    
        def __init__(self, inplanes, planes, stride=1, downsample=None):
            super(Bottleneck, self).__init__()
            self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
            self.bn1 = nn.BatchNorm2d(planes)
            self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
                                   padding=1, bias=False)
            self.bn2 = nn.BatchNorm2d(planes)
            self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
            self.bn3 = nn.BatchNorm2d(planes * 4)
            self.relu = nn.ReLU(inplace=True)
            self.downsample = downsample
            self.stride = stride
    
        def forward(self, x):
            residual = x
    
            out = self.conv1(x)
            out = self.bn1(out)
            out = self.relu(out)
    
            out = self.conv2(out)
            out = self.bn2(out)
            out = self.relu(out)
    
            out = self.conv3(out)
            out = self.bn3(out)
    
            if self.downsample is not None:
                residual = self.downsample(x)
    
            out += residual
            out = self.relu(out)
    
            return out

    接下来定义整个残差网络
    1. 第一层卷积使用77大小的模板,步长为2,padding为3。之后进行BN,ReLU和maxpool。这些构成了第一部分卷积模块。
    2. 之后的layer1到layer4分别是四个不同的模块,具体细节可以参考Table1
    3. _make_layer方法作用是生成多个卷积层,形成一个大的模块。

    class ResNet(nn.Module):
    
        def __init__(self, block, layers, num_classes=1000):
            self.inplanes = 64
            super(ResNet, self).__init__()
            self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
                                   bias=False)
            self.bn1 = nn.BatchNorm2d(64)
            self.relu = nn.ReLU(inplace=True)
            self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
            self.layer1 = self._make_layer(block, 64, layers[0])
            self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
            self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
            self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
            self.avgpool = nn.AvgPool2d(7, stride=1)
            self.fc = nn.Linear(512 * block.expansion, num_classes)
    
            for m in self.modules():
                if isinstance(m, nn.Conv2d):
                    n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                    m.weight.data.normal_(0, math.sqrt(2. / n))
                elif isinstance(m, nn.BatchNorm2d):
                    m.weight.data.fill_(1)
                    m.bias.data.zero_()
    
        def _make_layer(self, block, planes, blocks, stride=1):
            downsample = None
            if stride != 1 or self.inplanes != planes * block.expansion:
                downsample = nn.Sequential(
                    nn.Conv2d(self.inplanes, planes * block.expansion,
                              kernel_size=1, stride=stride, bias=False),
                    nn.BatchNorm2d(planes * block.expansion),
                )
    
            layers = []
            layers.append(block(self.inplanes, planes, stride, downsample))
            self.inplanes = planes * block.expansion
            for i in range(1, blocks):
                layers.append(block(self.inplanes, planes))
    
            return nn.Sequential(*layers)
    
        def forward(self, x):
            x = self.conv1(x)
            x = self.bn1(x)
            x = self.relu(x)
            x = self.maxpool(x)
    
            x = self.layer1(x)
            x = self.layer2(x)
            x = self.layer3(x)
            x = self.layer4(x)
    
            x = self.avgpool(x)
            x = x.view(x.size(0), -1)
            x = self.fc(x)
    
            return x

    1. R. K. Srivastava, K. Greff, and J. Schmidhuber. Highway networks.
      arXiv:1505.00387, 2015.
    展开全文
  • 深度学习笔记(七)--ResNet(残差网络)

    万次阅读 多人点赞 2019-11-17 23:15:44
    内容来自吴恩达老师视频,网易云课堂有哦 ResNets 非常非常深的神经网络是很难训练的,因为存在梯度消失和梯度爆炸问题。ResNets是由残差块(Residual block)构建的,首先解释一下什么是残差块。...

    内容来自吴恩达老师视频,网易云课堂有哦

    ResNets

    非常非常深的神经网络是很难训练的,因为存在梯度消失和梯度爆炸问题。ResNets是由残差块(Residual block构建的,首先解释一下什么是残差块。

    这是一个两层神经网络,在 层进行激活,得到 ,再次进行激活,两层之后得到 。计算过程是从 开始,首先进行线性激活,根据这个公式: ,通过 算出 ,即 乘以权重矩阵,再加上偏差因子。然后通过ReLU非线性激活函数得到 计算得出。接着再次进行线性激活,依据等式 ,最后根据这个等式再次进行ReLu非线性激活,即 ,这里的 是指ReLU非线性函数,得到的结果就是 。换句话说,信息流从 需要经过以上所有步骤,即这组网络层的主路径。 

    在残差网络中有一点变化,我们将 直接向后,拷贝到神经网络的深层,在ReLU非线性激活函数前加上 ,这是一条捷径。] 的信息直接到达神经网络的深层,不再沿着主路径传递,这就意味着最后这个等式 )去掉了,取而代之的是另一个ReLU非线性函数,仍然对 进行 函数处理,但这次要加上即:也就是加上的这个 产生了一个残差块。 

    在上面这个图中,我们也可以画一条捷径,直达第二层。实际上这条捷径是在进行ReLU非线性激活函数之前加上的,而这里的每一个节点都执行了线性函数和ReLU激活函数。所以 插入的时机是在线性激活之后,ReLU激活之前。除了捷径,你还会听到另一个术语“跳跃连接”,就是指 跳过一层或者好几层,从而将信息传递到神经网络的更深层

    ResNet的发明者是何恺明Kaiming He)、张翔宇Xiangyu Zhang)、任少卿Shaoqing Ren)和孙剑Jiangxi Sun),他们发现使用残差块能够训练更深的神经网络。所以构建一个ResNet网络就是通过将很多这样的残差块堆积在一起,形成一个很深神经网络,我们来看看这个网络。

    这并不是一个残差网络,而是一个普通网络(Plain network,这个术语来自ResNet论文。

     把它变成ResNet的方法是加上所有跳跃连接,每两层增加一个捷径,构成一个残差块。如图所示,5个残差块连接在一起构成一个残差网络。

     

           如果我们使用标准优化算法训练一个普通网络,比如说梯度下降法,或者其它热门的优化算法。如果没有残差,没有这些捷径或者跳跃连接,凭经验你会发现随着网络深度的加深,训练错误会先减少,然后增多。而理论上,随着网络深度的加深,应该训练得越来越好才对。也就是说,理论上网络深度越深越好。但实际上,如果没有残差网络,对于一个普通网络来说,深度越深意味着用优化算法越难训练。实际上,随着网络深度的加深,训练错误会越来越多

            但有了ResNets就不一样了,即使网络再深,训练的表现却不错,比如说训练误差减少,就算是训练深达100层的网络也不例外。有人甚至在1000多层的神经网络中做过实验,尽管目前我还没有看到太多实际应用。但是对 的激活,或者这些中间的激活能够到达网络的更深层。这种方式确实有助于解决梯度消失和梯度爆炸问题,让我们在训练更深网络的同时,又能保证良好的性能。也许从另外一个角度来看,随着网络越来深,网络连接会变得臃肿,但是ResNet确实在训练深度网络方面非常有效。 

    展开全文
  • ResNet详解——通俗易懂版

    万次阅读 多人点赞 2019-05-05 17:12:37
    ResNet学习什么是ResNet为什么要引入ResNetResNet详细解说 本篇博客主要是自己对论文的一些解读以及参考一些博客后的理解,如若有不对之处,请给为道友指出。多谢! 2015年刚提出ResNet的Paper 2016对ResNet进行...

    本篇博客主要是自己对论文的一些解读以及参考一些博客后的理解,如若有不对之处,请各位道友指出。多谢!

    2015年刚提出ResNet的Paper
    2016对ResNet进行改进之后的Paper

    什么是ResNet

    ResNet是一种残差网络,咱们可以把它理解为一个子网络,这个子网络经过堆叠可以构成一个很深的网络。咱们可以先简单看一下ResNet的结构,之后会对它的结构进行详细介绍。
    ResNet块

    那么可能会有小伙伴疑问,干嘛非要构建这么一个网络来堆叠出一个深层网络呢?干嘛不直接用卷积层对网络进行一个堆叠呢?

    为什么要引入ResNet?

    我们知道,网络越深,咱们能获取的信息越多,而且特征也越丰富。但是根据实验表明,随着网络的加深,优化效果反而越差,测试数据和训练数据的准确率反而降低了。这是由于网络的加深会造成梯度爆炸和梯度消失的问题。
    网络加深时测试错误率和训练错误率显示
    目前针对这种现象已经有了解决的方法:对输入数据和中间层的数据进行归一化操作,这种方法可以保证网络在反向传播中采用随机梯度下降(SGD),从而让网络达到收敛。但是,这个方法仅对几十层的网络有用,当网络再往深处走的时候,这种方法就无用武之地了。

    为了让更深的网络也能训练出好的效果,何凯明大神提出了一个新的网络结构——ResNet。这个网络结构的想法主要源于VLAD(残差的想法来源)和Highway Network(跳跃连接的想法来源)。

    ResNet详细解说

    再放一遍ResNet结构图。要知道咱们要介绍的核心就是这个图啦!(ResNet block有两种,一种两层结构,一种三层结构)
    两种ResNet block
    咱们要求解的映射为:H(x)
    现在咱们将这个问题转换为求解网络的残差映射函数,也就是F(x),其中F(x) = H(x)-x。

    残差:观测值与估计值之间的差。
    这里H(x)就是观测值,x就是估计值(也就是上一层ResNet输出的特征映射)。
    我们一般称x为identity Function,它是一个跳跃连接;称F(x)为ResNet Function。

    那么咱们要求解的问题变成了H(x) = F(x)+x。

    有小伙伴可能会疑惑,咱们干嘛非要经过F(x)之后在求解H(x)啊!整这么麻烦干嘛!
    咱们开始看图说话:如果是采用一般的卷积神经网络的化,原先咱们要求解的是H(x) = F(x)这个值对不?那么,我们现在假设,在我的网络达到某一个深度的时候,咱们的网络已经达到最优状态了,也就是说,此时的错误率是最低的时候,再往下加深网络的化就会出现退化问题(错误率上升的问题)。咱们现在要更新下一层网络的权值就会变得很麻烦,权值得是一个让下一层网络同样也是最优状态才行。对吧?
    但是采用残差网络就能很好的解决这个问题。还是假设当前网络的深度能够使得错误率最低,如果继续增加咱们的ResNet,为了保证下一层的网络状态仍然是最优状态,咱们只需要把令F(x)=0就好啦!因为x是当前输出的最优解,为了让它成为下一层的最优解也就是希望咱们的输出H(x)=x的话,是不是只要让F(x)=0就行了?
    当然上面提到的只是理想情况,咱们在真实测试的时候x肯定是很难达到最优的,但是总会有那么一个时刻它能够无限接近最优解。采用ResNet的话,也只用小小的更新F(x)部分的权重值就行啦!不用像一般的卷积层一样大动干戈!

    现在大家已经理解了为啥只要用F(x)+x来表示H(x)了吧!
    它的公式也相当简单(这里给出两层结构的):a[l+2]=Relu(W[l+2](Relu(W[l+1]a[l]+b[l+1])+b[l+2]+a[l])
    (不理解这个公式的小伙伴可以跳到我之前关于BP的博客瞅瞅:BP——反向传播算法详解及代码

    注意:如果残差映射(F(x))的结果的维度与跳跃连接(x)的维度不同,那咱们是没有办法对它们两个进行相加操作的,必须对x进行升维操作,让他俩的维度相同时才能计算。
    升维的方法有两种:

    • 全0填充;
    • 采用1*1卷积。

    最后的实验结果表明,ResNet在上百层都有很好的表现,但是当达到上千层了之后仍然会出现退化现象。不过在2016年的Paper中对ResNet的网络结构进行了调整,使得当网络达到上千层的时候仍然具有很好的表现。有兴趣的小伙伴可以自己瞅瞅论文。

    做完汇报之后,老师向我提出了一个问题,不知道有没有童鞋知道答案:
    1.既然采用了残差结构,为什么当层数达到103的数量级时,会出现退化问题?

    【果然我还没有真正参透ResNet】

    我相中的两篇相关博客推荐给大家:
    [1]残差网络ResNet笔记
    [2]ResNet介绍-上善若水

    展开全文
  • 残差resnet网络原理详解

    万次阅读 多人点赞 2016-10-09 22:58:45
    resnet在2015名声大噪,而且影响了2016年DL在学术界和工业界的发展方向。它对每层的输入做一个reference, 学习形成残差函数, 而不是学习一些没有reference的函数。这种残差函数更容易优化,能使网络层数大大加深。


    resnet在2015名声大噪,而且影响了2016年DL在学术界和工业界的发展方向。下面是这个resnet的网络结构,大家先睹为快。

     

    它对每层的输入做一个reference, 学习形成残差函数, 而不是学习一些没有reference的函数。这种残差函数更容易优化,能使网络层数大大加深。
    我们知道,在计算机视觉里,特征的“等级”随增网络深度的加深而变高,研究表明,网络的深度是实现好的效果的重要因素。然而梯度弥散/爆炸成为训练深层次的网络的障碍,导致无法收敛。
    有一些方法可以弥补,如归一初始化,各层输入归一化,使得可以收敛的网络的深度提升为原来的十倍。然而,虽然收敛了,但网络却开始退化了,即增加网络层数却导致更大的误差, 如下图。 这种deep plain net收敛率十分低下。


    的确,通过在一个浅层网络基础上叠加y=x的层(称identity mappings,恒等映射),可以让网络随深度增加而不退化。这反映了多层非线性网络无法逼近恒等映射网络。

    但是,不退化不是我们的目的,我们希望有更好性能的网络。  resnet学习的是残差函数F(x) = H(x) - x, 这里如果F(x) = 0, 那么就是上面提到的恒等映射。事实上,resnet是“shortcut connections”的在connections是在恒等映射下的特殊情况,它没有引入额外的参数和计算复杂度。 假如优化目标函数是逼近一个恒等映射, 而不是0映射, 那么学习找到对恒等映射的扰动会比重新学习一个映射函数要容易。从下图可以看出,残差函数一般会有较小的响应波动,表明恒等映射是一个合理的预处理。


    残差块的结构如下图,


    它有二层,如下表达式,其中σ代表非线性函数ReLU


    然后通过一个shortcut,和第2个ReLU,获得输出y


    当需要对输入和输出维数进行变化时(如改变通道数目),可以在shortcut时对x做一个线性变换Ws,如下式,然而实验证明x已经足够了,不需要再搞个维度变换,除非需求是某个特定维度的输出,如文章开头的resnet网络结构图中的虚线,是将通道数翻倍。


    实验证明,这个残差块往往需要两层以上,单单一层的残差块(y=W1x+x)并不能起到提升作用。


    残差网络的确解决了退化的问题,在训练集和校验集上,都证明了的更深的网络错误率越小,如下图


    实际中,考虑计算的成本,对残差块做了计算优化,即将两个3x3的卷积层替换为1x1 + 3x3 + 1x1, 如下图。新结构中的中间3x3的卷积层首先在一个降维1x1卷积层下减少了计算,然后在另一个1x1的卷积层下做了还原,既保持了精度又减少了计算量。


    下面是resnet的成绩单, 在imagenet2015夺得冠军




    展开全文
  • 【深度学习】ResNet解读及代码实现

    万次阅读 多人点赞 2018-10-30 16:54:49
    ResNet是何凯明大神在2015年提出的一种网络结构,获得了ILSVRC-2015分类任务的第一名,同时在ImageNet detection,ImageNet localization,COCO detection和COCO segmentation等任务中均获得了第一名,在当时可谓是...
  • 转自:https://blog.csdn.net/u014380165/article/details/75142664论文:Densely Connected Convolutional Networks 论文链接:https://arxiv.org/pdf/1608.06993.pdf 代码的github链接:...
  • ResNet && DenseNet(原理篇)

    万次阅读 2016-12-10 15:18:48
    这篇博客讲现在很流行的两种网络模型,ResNet和DenseNet,其实可以把DenseNet看做是ResNet的特例 文章地址: [1]Deep Residual Learning for Image Recognition,CVPR2015 [2]Densely Connected Convolutional ...
  • 但残差网络(ResNet)却能够做到非常深,2015年,微软亚洲研究院的何凯明等人使用152层的残差网络ResNet参加了当年的ILSVRC,在图像分类、目标检测等任务中的表现大幅超越前一年的比赛的性能水准。 ResNet与其他的...
  • ResNet和DenseNet的一点比较

    千次阅读 2019-04-08 21:59:28
    ResNet和DenseNet有一点显著的不同,那就是Residual Block比Dense Block要小得多
  • 深度学习网络篇——ResNet

    万次阅读 多人点赞 2019-10-25 16:55:11
    ResNet 作者:Kaiming He ,Xiangyu Zhang ,Shaoqing Ren ,Jian Sun 研究机构:Microsoft Research About Kaiming He: 2003年广东省理科高考状元,清华基础科学班,香港中文大学攻读研究生,微软亚研院...
  • ResNet介绍

    万次阅读 多人点赞 2018-07-10 19:37:33
    ResNet介绍1 简要概括 ResNet(Residual Neural Network)由微软研究院的Kaiming He等四名华人提出,通过使用ResNet Unit成功训练出了152层的神经网络,并在ILSVRC2015比赛中取得冠军,在top5上的错误率为3.57%,...
  • ResNet解析

    万次阅读 多人点赞 2018-04-26 22:50:38
    ResNet在2015年被提出,在ImageNet比赛classification任务上获得第一名,因为它“简单与实用”并存,之后很多方法都建立在ResNet50或者ResNet101的基础上完成的,检测,分割,识别等领域都纷纷使用ResNet,Alpha ...
  • resnet18和resnet50的大致区别

    万次阅读 2018-12-28 17:31:36
    二者除了网络深度的不同,还有就是kernel的选择不一样 resnet50: 右侧的卷积核的排序是1*1 ,3*3,1*1 res18的kernrel 右侧的kernel 1*1,1*1
  • Resnet_50网络结构详解

    万次阅读 多人点赞 2017-04-05 21:51:04
  • resnet50结构图

    万次阅读 多人点赞 2018-08-14 21:09:58
    ![这里写代码片](https://img-blog.csdn.net/20180814210843952?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxMDQ2MTM1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
  • resnet50 网络结构图

    万次阅读 2019-08-27 22:58:59
    resnet50
  • ResNet50网络结构

    万次阅读 多人点赞 2018-09-13 12:25:35
    keras.utils.plot_model(keras.applications.ResNet50(include_top=True,input_shape=(224,224,3),weights=None), to_file='image_model.png', show_shapes=True) ResNet50的标准输入为224x224,avg_p...
  • resnet34\resnet101网络结构图

    万次阅读 2019-06-20 22:16:50
    注释:7x7conv,3->64,/2表示7x7大小的卷积核,3、64表示输入输出通道,/2表示输出为原来的1/2。 x2表示类似的结构还有两个。
  • ResNet 18 的结构解读

    万次阅读 多人点赞 2019-06-27 16:00:40
    现在很多网络结构都是一个命名+数字,比如(ResNet18),数字代表的是网络的深度,也就是说ResNet18 网络就是18层的吗?其实这里的18指定的是带有权重的 18层,包括卷积层和全连接层,不包括池化层和BN层。下面先贴...
  • Resnet_50网络结构图

    万次阅读 2017-04-05 21:42:09
1 2 3 4 5 ... 20
收藏数 38,247
精华内容 15,298
关键字:

resnet