精华内容
下载资源
问答
  • 4.2 用智能工具处理信息 ;田甜;我们身边的智能工具;人工智能;1.手写输入汉字;你输入汉字计算机总共识别出多少个字识别率为多少 怎样书写汉字可以提高识别率;...影响OCR识别准确率的因素 ;任务三让电
  • 什么是卷积操作?三维的卷积是个怎样计算过程?以及由此引发卷积后导致的...退化问题——深度加深准确率无法提高,且训练和验证错误率比浅层更大 实验内容:对比浅层模型和深层模型 预测结果:深度模型的损失值会降

    这篇文章适合反复学习你必须要知道CNN模型:ResNet

    摘要

    • 简化
      -将层次重新定义为剩余函数
      -更容易优化模型
      -深度越深精确度越高,且复杂度也降低
      -错误率低而赢得2015年ImageNet第一名
    • 深度是获奖的基本条件

    1.介绍

    • 模型深度丰富了深度网络的等级
    • 深模型问题:梯度消失/爆炸——导致难以收敛
    • 解决方案有两个:归一初始化和中间初始化
    • 退化问题——深度加深准确率无法提高,且训练和验证错误率比浅层更大

    在这里插入图片描述
    实验内容:对比浅层模型和深层模型
    预测结果:深度模型的损失值会降低
    实际结果:现存的方案无法让深度模型的损失值保持或降低
    所以以上的两种解决方案均不可行

    • 引出本文的解决方案:深度残差学习模型
    • 假设优化F(x)要比优化F(x)+x难度更大

    在这里插入图片描述

    • F(x)+x

    -可通过捷径连接跳过一个或多个层次
    -恒定映射
    -不增加参数和计算复杂度
    -实现简单

    • 在ImageNet数据集
      -深度模型更容易优化
      -精确度随深度增加而增加

    • 在CIF-10中也出现相似现象

    • ResNet

    • 52层
      -复杂度低于VGG
      -误差降到3.57%
      -在多个领域获第一名

    2.相关工作

    • 残差描述
      -VLAD
      -构建子问题和级联预处理两种方法比无残差方法更好优化

    • 捷径连接
      -很多文献都有研究,但切入点不同
      -无参数也无需调参
      -从不关闭,始终包含

    3.深度残差学习

    3.1 残差学习

    • 多层叠加模块=H(x)
    • 假设多层线性层约等于复杂函数约,也约等于残差函数
    • H(x)=F(x)+x
    • 改变非线性层来近似恒定映射
    • 如果F(x)趋于0,则H(x)=x
    • 重构模型有助于解决优化问题

    3.2 利用捷径作恒等映射

    • y=F(x,{Wi}) + x
    • 为了补齐维度:y=F(x,{Wi}}) + Ws·x
    • 对卷积层也可行

    3.3 网络神经

    测试普通层和残差网络

    • 普通层:
      -有大量连续相同的卷积层、输入输出维度相同
      -如果图片尺寸减半,滤波器数量要翻倍
      -相对于VGG,滤波器数量减少,计算复杂度降低(VGG的18%)
    • 残差网络
      -增加了捷径连接
      -实现连接F(x)和x维度相同、虚线维度不同
      -两种补齐维度方法:空缺元素补零、1x1卷积

    3.4 实现

    • 数据处理:
      -按短边抽样
      -224x224剪裁
      -减去均值
      -色彩增强
    • 代码实现
      -初始化:batch_size=256(SGD)
      -Ir = 0.1 错误时降低10倍
      -trainning=60万次
      -race = 0,0001
      -nomentum = 0.9
      -no dropout
    • 测试
      -10-crop
      -全连接卷积
      -对多个尺寸图像缩放为短边结果取均值

    4.实验

    4.1 ImageNet分类数据集

    • 普通网络
      -18 vs 34
      -依然是较深的34层网络的交叉验证错误率要高于较浅的18层网络
      -BN避免了梯度消失的问题,且没有影响正常梯度值
      -猜测:深度网络骄傲的错误率是因为较低的收敛速率
    • 残差网络
      -基于普通网络增加捷径连接
      -补零方法补齐维度
      -无新增参数
      -结果:深度模型的错误率、训练误差都要低于普通网络

    -残差网络收敛速度更快

    • 投影快捷连接
      -成本不划算
    • 深度瓶颈架构
      -1x1,3x3,1x1
    • 50层残差网络
      -换成瓶颈块
    • 101层和152层残差网络
      -增加了瓶颈块的数目
      -复杂度更低
      -准确率提高
    • 比较
      -单个模型就优于之前综合模型

    5.代码实现:

    import torch
    import torch.nn as nn
    from .utils import load_state_dict_from_url
    
    
    __all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
               'resnet152', 'resnext50_32x4d', 'resnext101_32x8d',
               'wide_resnet50_2', 'wide_resnet101_2']
    
    
    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',
        'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
        'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
        'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth',
        'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth',
    }
    
    
    def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
    
        return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
                         padding=dilation, groups=groups, bias=False, dilation=dilation)
    
    
    def conv1x1(in_planes, out_planes, stride=1):
     
        return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
    
    
    class BasicBlock(nn.Module):
        expansion = 1
    
        def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
                     base_width=64, dilation=1, norm_layer=None):
            super(BasicBlock, self).__init__()
            if norm_layer is None:
                norm_layer = nn.BatchNorm2d
            if groups != 1 or base_width != 64:
                raise ValueError('BasicBlock only supports groups=1 and base_width=64')
            if dilation > 1:
                raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
           
            self.conv1 = conv3x3(inplanes, planes, stride)
            self.bn1 = norm_layer(planes)
            self.relu = nn.ReLU(inplace=True)
            self.conv2 = conv3x3(planes, planes)
            self.bn2 = norm_layer(planes)
            self.downsample = downsample
            self.stride = stride
    
        def forward(self, x):
            identity = 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:
                identity = self.downsample(x)
    
            out += identity
            out = self.relu(out)
    
            return out
    
    
    class Bottleneck(nn.Module):
    
        expansion = 4
    
        def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
                     base_width=64, dilation=1, norm_layer=None):
            super(Bottleneck, self).__init__()
            if norm_layer is None:
                norm_layer = nn.BatchNorm2d
            width = int(planes * (base_width / 64.)) * groups
            # Both self.conv2 and self.downsample layers downsample the input when stride != 1
            self.conv1 = conv1x1(inplanes, width)
            self.bn1 = norm_layer(width)
            self.conv2 = conv3x3(width, width, stride, groups, dilation)
            self.bn2 = norm_layer(width)
            self.conv3 = conv1x1(width, planes * self.expansion)
            self.bn3 = norm_layer(planes * self.expansion)
            self.relu = nn.ReLU(inplace=True)
            self.downsample = downsample
            self.stride = stride
    
        def forward(self, x):
            identity = 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:
                identity = self.downsample(x)
    
            out += identity
            out = self.relu(out)
    
            return out
    
    
    class ResNet(nn.Module):
    
        def __init__(self, block, layers, num_classes=1000, zero_init_residual=False,
                     groups=1, width_per_group=64, replace_stride_with_dilation=None,
                     norm_layer=None):
            super(ResNet, self).__init__()
            if norm_layer is None:
                norm_layer = nn.BatchNorm2d
            self._norm_layer = norm_layer
    
            self.inplanes = 64
            self.dilation = 1
            if replace_stride_with_dilation is None:
                replace_stride_with_dilation = [False, False, False]
            if len(replace_stride_with_dilation) != 3:
                raise ValueError("replace_stride_with_dilation should be None "
                                 "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
            self.groups = groups
            self.base_width = width_per_group
            self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,
                                   bias=False)
            self.bn1 = norm_layer(self.inplanes)
            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,
                                           dilate=replace_stride_with_dilation[0])
            self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
                                           dilate=replace_stride_with_dilation[1])
            self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
                                           dilate=replace_stride_with_dilation[2])
            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
            self.fc = nn.Linear(512 * block.expansion, num_classes)
    
            for m in self.modules():
                if isinstance(m, nn.Conv2d):
                    nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
                    nn.init.constant_(m.weight, 1)
                    nn.init.constant_(m.bias, 0)
    
            if zero_init_residual:
                for m in self.modules():
                    if isinstance(m, Bottleneck):
                        nn.init.constant_(m.bn3.weight, 0)
                    elif isinstance(m, BasicBlock):
                        nn.init.constant_(m.bn2.weight, 0)
    
        def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
            norm_layer = self._norm_layer
            downsample = None
            previous_dilation = self.dilation
            if dilate:
                self.dilation *= stride
                stride = 1
            if stride != 1 or self.inplanes != planes * block.expansion:
                downsample = nn.Sequential(
                    conv1x1(self.inplanes, planes * block.expansion, stride),
                    norm_layer(planes * block.expansion),
                )
    
            layers = []
            layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
                                self.base_width, previous_dilation, norm_layer))
            self.inplanes = planes * block.expansion
            for _ in range(1, blocks):
                layers.append(block(self.inplanes, planes, groups=self.groups,
                                    base_width=self.base_width, dilation=self.dilation,
                                    norm_layer=norm_layer))
    
            return nn.Sequential(*layers)
    
        def _forward_impl(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 = torch.flatten(x, 1)
            x = self.fc(x)
    
            return x
    
        def forward(self, x):
            return self._forward_impl(x)
    
    
    def _resnet(arch, block, layers, pretrained, progress, **kwargs):
        model = ResNet(block, layers, **kwargs)
        if pretrained:
            state_dict = load_state_dict_from_url(model_urls[arch],
                                                  progress=progress)
            model.load_state_dict(state_dict)
        return model
    
    
    def resnet18(pretrained=False, progress=True, **kwargs):
        r"""ResNet-18 model from
        `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress,
                       **kwargs)
    
    
    def resnet34(pretrained=False, progress=True, **kwargs):
        r"""ResNet-34 model from
        `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        return _resnet('resnet34', BasicBlock, [3, 4, 6, 3], pretrained, progress,
                       **kwargs)
    
    
    def resnet50(pretrained=False, progress=True, **kwargs):
        r"""ResNet-50 model from
        `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        return _resnet('resnet50', Bottleneck, [3, 4, 6, 3], pretrained, progress,
                       **kwargs)
    
    
    def resnet101(pretrained=False, progress=True, **kwargs):
        r"""ResNet-101 model from
        `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        return _resnet('resnet101', Bottleneck, [3, 4, 23, 3], pretrained, progress,
                       **kwargs)
    
    
    def resnet152(pretrained=False, progress=True, **kwargs):
        r"""ResNet-152 model from
        `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        return _resnet('resnet152', Bottleneck, [3, 8, 36, 3], pretrained, progress,
                       **kwargs)
    
    
    def resnext50_32x4d(pretrained=False, progress=True, **kwargs):
        r"""ResNeXt-50 32x4d model from
        `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        kwargs['groups'] = 32
        kwargs['width_per_group'] = 4
        return _resnet('resnext50_32x4d', Bottleneck, [3, 4, 6, 3],
                       pretrained, progress, **kwargs)
    
    
    def resnext101_32x8d(pretrained=False, progress=True, **kwargs):
        r"""ResNeXt-101 32x8d model from
        `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        kwargs['groups'] = 32
        kwargs['width_per_group'] = 8
        return _resnet('resnext101_32x8d', Bottleneck, [3, 4, 23, 3],
                       pretrained, progress, **kwargs)
    
    
    def wide_resnet50_2(pretrained=False, progress=True, **kwargs):
        r"""Wide ResNet-50-2 model from
        `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_
        The model is the same as ResNet except for the bottleneck number of channels
        which is twice larger in every block. The number of channels in outer 1x1
        convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
        channels, and in Wide ResNet-50-2 has 2048-1024-2048.
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        kwargs['width_per_group'] = 64 * 2
        return _resnet('wide_resnet50_2', Bottleneck, [3, 4, 6, 3],
                       pretrained, progress, **kwargs)
    
    
    def wide_resnet101_2(pretrained=False, progress=True, **kwargs):
        r"""Wide ResNet-101-2 model from
        `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_
        The model is the same as ResNet except for the bottleneck number of channels
        which is twice larger in every block. The number of channels in outer 1x1
        convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
        channels, and in Wide ResNet-50-2 has 2048-1024-2048.
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        kwargs['width_per_group'] = 64 * 2
        return _resnet('wide_resnet101_2', Bottleneck, [3, 4, 23, 3],
                       pretrained, progress, **kwargs)
    
    展开全文
  • 该方案实现了单通道128 kHz的采样和12位的数据精度,解 决了系统中信号的时序配合问题,很准确地得到了系统的接收矩阵,提高了系统的定位精度,并将数据刷新率提高 到125 Hz。  六自由度电磁跟踪系统根据电磁...
  •  六年级数学复习计划1 学习对象分析:本班学生上册应掌握的知识基本掌握较好,尤其是分数计算方面准确率较高,但在实际应用类,如应用题,还有个别学生对题目难以理解,解题困难。大部分学生学习较主动,能自觉...
  •  二、双基情况 大部分学生本册应掌握的知识基本掌握较好,尤其是分数计算方面准确率较高,但在实际应用类,如应用题,还有个别学生对题目难以理解,解题困难。 三、学习能力 大部分学生学习较主动,能自觉进行...
  • 有30个特征,为提高分类的准确率,或者出于汇报的要求(哪些特征,或者有可解释性意义的特征组合对结果影响较大)需要对特征进行分析和组合,不是PCA之类的降维,比如对两个连续变量进行计算组合,对几个分类变量...
  • 6.23 sizeof返回的大小是以字节计算的,怎样才能判断数组中有多少个元素呢? 第7章 内存分配 基本的内存分配问题 7.1 为什么这段代码不行?char*answer;printf("Typesomething:\n");gets(answer);printf(...
  • 1.7 怎样声明和定义全局变量和函数最好? 4 1.8 如何在C中实现不透明(抽象)数据类型? 5 1.9 如何生成“半全局变量”,就是那种只能被部分源文件中的部分函数访问的变量? 5 存储类型 6 1.10 同一个静态...
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    3.12 我不想学习那些复杂的规则,怎样才能避免这些未定义的求值顺序问题呢? 38 其他的表达式问题 39 *3.13 ++i和i++有什么区别? 39 3.14 如果我不使用表达式的值,那我应该用i++还是++i来做自增呢? 39 ...
  • 《Photoshop CS3数码照片专业处理技法》没有介绍大套的理论,作者逐步向您准确演示当今一流数码摄影师所使用的方法,《Photoshop CS3数码照片专业处理技法》所做的是直接告诉您使用哪些设置。什么时候使用这些设置,...
  • 运用学生成绩管理维护系统可以减轻学院教学人员的工作量,缩小开支,提高工作效率与准确率,能够节省时间,学生也能够尽快的知道自己的考试成绩,投入新的课程的学习或复习这次没有考过的课程。而学生成绩管理系统...
  • 但在发送窗口和接收窗口的共同作用下可以在数据传输时提高对信道的利用。那么到底应当怎样看待发送窗口的作用? 问题3-8:在关于数据链路层工作原理的叙述中,经常会见到两个不同的名词——“丢失”和“丢弃”。...
  • 问题4-36:“交换(switching)”的准确含义是什么? 问题4-37:为什么生存时间TTL原来用秒作为单位而现在TTL却表示数据报在网络中所能通过的路由器数的最大值? 第5章 运输层 问题5-1:TCP协议是面向连接的,但TCP...
  • 内存作为磁盘读写的高速缓存可以有效提高系统运行效率。Smartdrv.exe这 个文件在Windows各个版本的安装光盘中或是硬盘上的Windows/command/里都 有,只有几十KB,把这个文件复制到软盘下,启动系统后直接运行这个...
  • 以微软公司生产的鼠标器为例,就其功能而言,只需要有三个按键就可以满足使用需要,但是,怎样才能让鼠标器的手感最好,而且经过长时间使用也不易产生疲劳感却是生产厂商需要认真考虑的问题。因此微软公司首先根据...
  • 数学试题虽然千变万化,其知识结构却基本相同,题型也相对固定,往往存在一定的解题套路,熟练掌握后既能提高正确,又能提高解题速度。 <br> 数学考研题的重要特征之一就是综合性强、知识覆盖面广,一些稍有...
  •  硬件特征:速度、容量及工作可靠性有明显提高,价格降低,销售有爆炸性增长 。  软件特征:程序员数量猛增,开发人员素质低。  ③ 软件工程阶段。  硬件特征:向超高速、大容量、微型化及网络化方向发展。  ...
  • CruiseYoung提供的带有详细书签的电子书籍目录 ... Oracle Database 11g数据库管理艺术(涵盖DBA必知必会的所有数据库管理知识) 基本信息 原书名: Expert Oracle Database 11g Administration 原出版社: Apress ...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    供不应求:软件开发生产跟不上计算机应用迅速深入的趋势 软件危机 原因 客观:软件本身特点 逻辑部件 规模庞大 主观:不正确的开发方法 忽视需求分析 错误认为:软件开发=程序编写 轻视软件维护 软件危机 产生...
  •  ◇ 详细设计说明书:着重描述每一模块是怎样实现的,包括实现算法、逻辑流程等。  ◇ 用户操作手册:本手册详细描述软件的功能、性能和用户界面,使用户对如何使用该软件得到具体的了解,为操作人员提供该软件...
  • 其次列为综合课程,因为它把各门职能课程结合在一起,不仅阐明了各种职能在企业争取达到经营目标的过程中如何相互作用,而且指出了企业与其所处的环境怎样互相影响。 表2.1.2 企业管理学的学科分类 ────...
  • 13.1.1 提高可用性 562 13.1.2 减少管理负担 564 13.1.3 改善语句性能 569 13.2 表分区机制 571 13.2.1 区间分区 571 13.2.2 散列分区 574 13.2.3 列表分区 579 13.2.4 组合分区 581 13.2.5 行移动 583 ...

空空如也

空空如也

1 2
收藏数 23
精华内容 9
关键字:

怎样提高计算准确率