精华内容
下载资源
问答
  • 残差网络代码
    千次阅读
    2022-02-20 17:42:46

    Resnet50是Resnet残差网络系列的代表网络,由Kaiming于2016年发表于CVPR

    论文地址:CVPR 2016 Open Access Repository

    参考代码:https://github.com/bubbliiiing/classification-pytorch/tree/main/nets

    import torch
    import torch.nn as nn
    #--------------------------------#
    # 从torch官方可以下载resnet50的权重
    #--------------------------------#
    model_urls = {
        'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
    }
    
    #-----------------------------------------------#
    # 此处为定义3*3的卷积,即为指此次卷积的卷积核的大小为3*3
    #-----------------------------------------------#
    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)
    
    #-----------------------------------------------#
    # 此处为定义1*1的卷积,即为指此次卷积的卷积核的大小为1*1
    #-----------------------------------------------#
    def conv1x1(in_planes, out_planes, stride=1):
        return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
    
    #----------------------------------#
    # 此为resnet50中标准残差结构的定义
    # conv3x3以及conv1x1均在该结构中被定义
    #----------------------------------#
    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
            #---------------------------------------------------#
            # 根据input的planes确定width,width的值为
            # 卷积输出通道以及BatchNorm2d的数值
            # 因为在接下来resnet结构构建的过程中给到的planes的数值不相同
            #---------------------------------------------------#
            width           = int(planes * (base_width / 64.)) * groups
            #-----------------------------------------------#
            # 当步长的值不为1时,self.conv2 and self.downsample
            # 的作用均为对输入进行下采样操作
            # 下面为定义了一系列操作,包括卷积,数据归一化以及relu等
            #-----------------------------------------------#
            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
        #--------------------------------------#
        # 定义resnet50中的标准残差结构的前向传播函数
        #--------------------------------------#
        def forward(self, x):
            identity = x
            #-------------------------------------------------------------------------#
            # conv1*1->bn1->relu 先进行一次1*1的卷积之后进行数据归一化操作最后过relu增加非线性因素
            # conv3*3->bn2->relu 先进行一次3*3的卷积之后进行数据归一化操作最后过relu增加非线性因素
            # conv1*1->bn3 先进行一次1*1的卷积之后进行数据归一化操作
            #-------------------------------------------------------------------------#
            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(identity)
            #---------------------------------------------#
            # 首先是将两部分进行add操作,最后过relu来增加非线性因素
            # concat(堆叠)可以看作是通道数的增加
            # add(相加)可以看作是特征图相加,通道数不变
            # add可以看作特殊的concat,并且其计算量相对较小
            #---------------------------------------------#
            out += identity
            out = self.relu(out)
    
            return out
    
    #--------------------------------#
    # 此为resnet50网络的定义
    # input的大小为224*224
    # 初始化函数中的block即为上面定义的
    # 标准残差结构--Bottleneck
    #--------------------------------#
    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
            #---------------------------------------------------------#
            # 使用膨胀率来替代stride,若replace_stride_with_dilation为none
            # 则这个列表中的三个值均为False
            #---------------------------------------------------------#
            if replace_stride_with_dilation is None:
                replace_stride_with_dilation = [False, False, False]
            #----------------------------------------------#
            # 若replace_stride_with_dilation这个列表的长度不为3
            # 则会有ValueError
            #----------------------------------------------#
            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.block       = block
            self.groups      = groups
            self.base_width  = width_per_group
            #-----------------------------------#
            # conv1*1->bn1->relu
            # 224,224,3 -> 112,112,64
            #-----------------------------------#
            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)
            #------------------------------------#
            # 最大池化只会改变特征图像的高度以及
            # 宽度,其通道数并不会发生改变
            # 112,112,64 -> 56,56,64
            #------------------------------------#
            self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
    
            # 56,56,64   -> 56,56,256
            self.layer1  = self._make_layer(block, 64, layers[0])
    
            # 56,56,256  -> 28,28,512
            self.layer2  = self._make_layer(block, 128, layers[1], stride=2,dilate=replace_stride_with_dilation[0])
    
            # 28,28,512  -> 14,14,1024
            self.layer3  = self._make_layer(block, 256, layers[2], stride=2,dilate=replace_stride_with_dilation[1])
    
            # 14,14,1024 -> 7,7,2048
            self.layer4  = self._make_layer(block, 512, layers[3], stride=2,dilate=replace_stride_with_dilation[2])
            #--------------------------------------------#
            # 自适应的二维平均池化操作,特征图像的高和宽的值均变为1
            # 并且特征图像的通道数将不会发生改变
            # 7,7,2048 -> 1,1,2048
            #--------------------------------------------#
            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
            #----------------------------------------#
            # 将目前的特征通道数变成所要求的特征通道数(1000)
            # 2048 -> num_classes
            #----------------------------------------#
            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)
    
        #--------------------------------------#
        # _make_layer这个函数的定义其可以在类的
        # 初始化函数中被调用
        # block即为上面定义的标准残差结构--Bottleneck
        #--------------------------------------#
        def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
            norm_layer        = self._norm_layer
            downsample        = None
            previous_dilation = self.dilation
            #-----------------------------------#
            # 在函数的定义中dilate的值为False
            # 所以说下面的语句将直接跳过
            #-----------------------------------#
            if dilate:
                self.dilation *= stride
                stride        = 1
            #-----------------------------------------------------------#
            # 如果stride!=1或者self.inplanes != planes * block.expansion
            # 则downsample将有一次1*1的conv以及一次BatchNorm2d
            #-----------------------------------------------------------#
            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,其为一个列表
            # 卷积块的定义,每一个卷积块可以理解为一个Bottleneck的使用
            #-----------------------------------------------#
            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):
                # identity_block
                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)
        #------------------------------#
        # resnet50的前向传播函数
        #------------------------------#
        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的第1个维度拼接(按照列来拼接,横向拼接)
            # 拼接之后,张量的shape为(batch_size,2048)
            #--------------------------------------#
            x = torch.flatten(x, 1)
            #--------------------------------------#
            # 过全连接层来调整特征通道数
            # (batch_size,2048)->(batch_size,1000)
            #--------------------------------------#
            x = self.fc(x)
            return x
    
    F=torch.randn(16,3,224,224)
    print("As begin,shape:",format(F.shape))
    resnet=ResNet(Bottleneck,[3,4,6,3])
    F=resnet(F)
    print(F.shape)
    

    更多相关内容
  • 残差网络代码

    2018-09-22 15:47:30
    适合学习的ResNet残差网络,适合配合论文一起使用,非常适合初学者阅读的经典代码
  • resnet 残差模块实现
    • 调已有的接口
    import torch
    from torch import nn
    import torchvision.models as models
    
    class nmv_res50_centernet(nn.Module):
        def __init__(self, cls_num):
            super(nmv_res50_centernet, self).__init__()
            self.resnet50 = models.resnet50(pretrained=True)#使用resnet50作为backbone
            #其他使用到的层设置
    		......
    
    	def forward(self, x):
    	        #===========backbone============
    	        out = self.resnet50.conv1(x)
    	        out = self.resnet50.bn1(out)
    	        out = self.resnet50.relu(out)
    	        out = self.resnet50.maxpool(out)
    	        res2 = self.resnet50.layer1(out)
    	        res3 = self.resnet50.layer2(res2)
    	        res4 = self.resnet50.layer3(res3)
    	        #res4_d = res4.detach()#将该层梯度截断不反传
    	        #将特征图tensor按n通道均分为2份,若指定大小分割可用split
    	        fea_id, fea_attr_det = torch.chunk(res4, 2, dim=0)
    
    			# 其他分类、检测头 分支
    			......
    
    • 自己实现
    import torch
    from torch import nn
    from torch.nn import functional as F
    
    '''
    自己实现 残差基本结构
    input_channels : 输入的通道数
    num_channels : 输出的通道数
    use_1x1conv : 残差连接path是否使用1*1conv
    strides : 步长,默认为1。 控制输出特征图hw是否缩小
    '''
    class Residual(nn.Module):
        def __init__(self, input_channels, num_channels, use_1x1conv=False, strides=1):
            super().__init__()
            self.conv1 = nn.Conv2d(input_channels, num_channels, kernel_size=3, padding=1, stride=strides)
            self.conv2 = nn.Conv2d(num_channels, num_channels, kernel_size=3, padding=1)
            if use_1x1conv: # 跨连path是否使用1*1conv
                self.conv3 = nn.Conv2d(input_channels, num_channels, kernel_size=1, stride=strides)
            else:
                self.conv3 = None
            self.bn1 = nn.BatchNorm2d(num_channels)
            self.bn2 = nn.BatchNorm2d(num_channels)
            self.relu = nn.ReLU(inplace=True) # inplace方式节省内存,训练更快
    
        def forward(self, x):
            y = F.relu(self.bn1(self.conv1(x)))
            y = self.bn2(self.conv2(y))
            if self.conv3:
                x = self.conv3(x)
            y += x # 残差concate
            return F.relu(y)
    
    '''
    (叠加的)残差块 实现函数
    num_residuals : 残差模块 中 有几个残差子块 叠加
    '''
    def resnet_block(input_channels, num_channels, num_residuals, first_block=False):
        blk = []
        for i in range(num_residuals):
            if i == 0 and not first_block:
                blk.append(Residual(input_channels, num_channels, use_1x1conv=True, strides=2)) # 非首个个残差块的 第一个残差子块h,w减半
            else:
                blk.append(Residual(num_channels, num_channels)) # 其他残差子块不改变特征图维度
        return blk
    
    if __name__ == '__main__':
        # ResNet
        b1 = nn.Sequential(
            nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=2),
            nn.BatchNorm2d(64), nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
    
        b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True)) # *是对list解引用,取出元素
        b3 = nn.Sequential(*resnet_block(64, 128, 2))
        b4 = nn.Sequential(*resnet_block(128, 256, 2))
        b5 = nn.Sequential(*resnet_block(256, 512, 2))
    
        # nn.AdaptiveAvgPool2d()自适应池化,输入参数(out_h,out_w),则 n*c*h*w ---> n * c * out_h * out_w
        # nn.Flaten() 默认从第一维c 到 最后一维w压缩到一起,也可自己指定。n*c*h*w ---> n * chw; 若nn.Flaten(1,2) 则n*c*h*w ---> n * ch * w
        net = nn.Sequential(b1, b2, b3, b4, b5, nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(), nn.Linear(512, 10))
    
        x = torch.rand(size=(1, 1, 224, 224))
        for layer in net:
            x = layer(x)
            print(layer.__class__.__name__, 'output shape:\t', x.shape)
    
    

    结果如下:
    在这里插入图片描述

    展开全文
  • ResNet 残差网络详解级代码详细注释

    千次阅读 2020-11-05 15:30:31
    ResNet是一种残差网络,咱们可以把它理解为一个子网络,这个子网络经过堆叠可以构成一个很深的网络。咱们可以先简单看一下ResNet的结构,之后会对它的结构进行详细介绍。 为什么要引入ResNet? 我们知道,网络越深...

    ResNet是一种残差网络,咱们可以把它理解为一个子网络,这个子网络经过堆叠可以构成一个很深的网络。咱们可以先简单看一下ResNet的结构,之后会对它的结构进行详细介绍。
    在这里插入图片描述
    为什么要引入ResNet?

    我们知道,网络越深,咱们能获取的信息越多,而且特征也越丰富。但是根据实验表明,随着网络的加深,优化效果反而越差,测试数据和训练数据的准确率反而降低了。这是由于网络的加深会造成梯度爆炸和梯度消失的问题。

    目前针对这种现象已经有了解决的方法:对输入数据和中间层的数据进行归一化操作,这种方法可以保证网络在反向传播中采用随机梯度下降(SGD),从而让网络达到收敛。但是,这个方法仅对几十层的网络有用,当网络再往深处走的时候,这种方法就无用武之地了。

    为了让更深的网络也能训练出好的效果,何凯明大神提出了一个新的网络结构——ResNet

    ResNet详细解说
    再放一遍ResNet结构图。要知道咱们要介绍的核心就是这个图啦!(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)部分的权重值就行啦!不用像一般的卷积层一样大动干戈!

    上代码:

    import  os
    import  tensorflow as tf
    import  numpy as np
    from    tensorflow import keras
    
    """ResNet是一种残差网络,咱们可以把它理解为一个子网络,这个子网络经过堆叠可以构成一个很深的网络。
    咱们可以先简单看一下ResNet的结构,之后会对它的结构进行详细介绍.H(x) = F(x) + x。x:输入。H(x):期望输出。F(x):输入和输出的差别叫残差 即H(x) - x"""
    
    # In[1]:
    
    
    tf.random.set_seed(22)
    np.random.seed(22)
    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
    assert tf.__version__.startswith('2.')
    
    
    
    
    (x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()
    x_train, x_test = x_train.astype(np.float32)/255., x_test.astype(np.float32)/255.
    #print(x_train.shape, y_train.shape) (60000, 28, 28) (60000,)
    
    """
    np.expand_dims扩充矩阵的维度,axis的值代表着扩充维度的位置。例如:axis=0那么[60000, 28, 28] => [1,60000, 28, 28]
    axis=1那么[60000, 28, 28] => [60000, 1, 28, 28]其他类推
    """
    x_train, x_test = np.expand_dims(x_train, axis=3), np.expand_dims(x_test, axis=3)#[60000, 28, 28] => [60000, 28, 28, 1]
    
    """(60000,)-->(60000, 10)"""
    y_train_ohe = tf.one_hot(y_train, depth=10).numpy()
    y_test_ohe = tf.one_hot(y_test, depth=10).numpy()
    # In[2]:
    
    
    print(x_train.shape, y_train.shape)
    print(x_test.shape, y_test.shape)
    
    
    """
    输入:[batch, height, width, channels]
    第一个维度batch,一般设置为1,代表每一个样本都要作为输入进行传递。
    第二个维度和第三个维度代表单个样本的行数和列数,
    第四个维度代表输入图像的通道数,通常值为1,代表不跳过每一个颜色通道。
    注意:不要和输入图像的参数搞混了,比如输入[1,5,5,3]这个3代表的是图像是三通道的彩色图像
    
    Conv2D():卷积层函数。假如输入w为[batch, height, width, channels],padding='same'就是P=1,stride(S)在这是1.kernel为卷积核的大小。
    不带dilation_rate参数的计算公式height_out = ((height-kernel+2P)/S) + 1 ,width_out = ((weight-kernel+2P)/S) + 1
    带dilation_rate(D)的计算公式为:先计算channels的新值:kernel = kernel+(kernel−1)∗(D−1),将新的channels带入height_out = ((height-kernel+2P)/S) + 1 
    
    因此输出矩阵为:[batch,height_out,width_out,Conv2D函数filters参数的值]
    """
    def conv3x3(channels, stride=1, kernel=(3, 3)):#
        return keras.layers.Conv2D(channels, kernel, strides=stride, padding='same',
                                   use_bias=False,
                                kernel_initializer=tf.random_normal_initializer())
    
    class ResnetBlock(keras.Model):
    
        def __init__(self, channels, strides=1, residual_path=False):
            super(ResnetBlock, self).__init__()
    
            self.channels = channels#通道数
            self.strides = strides#步长
            self.residual_path = residual_path
    
            self.conv1 = conv3x3(channels, strides)#卷积核为3 * 3的卷积函数
            self.bn1 = keras.layers.BatchNormalization()#对所有样本归一化
            self.conv2 = conv3x3(channels)
            self.bn2 = keras.layers.BatchNormalization()
    
            if residual_path:
                self.down_conv = conv3x3(channels, strides, kernel=(1, 1))
                self.down_bn = tf.keras.layers.BatchNormalization()
    
        def call(self, inputs, training=None):
            residual = inputs#input=(batch, height, weight, channels)
            x = self.bn1(inputs, training=training)#对input的数据进行归一化操作 输出x = (batch, height, weight, channels)
            x = tf.nn.relu(x)#input数据 所有小于0的数据设置为0,输出输入形状为:(batch, height, weight, channels)
            x = self.conv1(x)#卷积输出为(batch, height_out, weight_out, channels) 详细看conv3x3的注释 里面有height_out和weight_out的计算公式
            x = self.bn2(x, training=training)#再一次对input的数据进行归一化操作 输出x = (batch, height_out, weight_out, channels)
            x = tf.nn.relu(x)#再一次对input数据 所有小于0的数据设置为0,输出输入形状为:(batch, height_out, weight_out, channels)
            x = self.conv2(x)#卷积 (batch, height_out, weight_out, channels)
    
    
            """residual计算残差"""
            if self.residual_path:
                residual = self.down_bn(inputs, training=training)#对所有样本归一化
                residual = tf.nn.relu(residual)#input数据 所有小于0的数据设置为0 输出/输入(batch, height, weight, channels)
                residual = self.down_conv(residual)#卷积 输入(batch, height, weight, channels) 输出(batch, height_out, weight_out, channels)
    
            x = x + residual#x=(batch, height_out, weight_out, channels) 期望输出 H(x) = residual(残差) + x
            print("x:",x.shape, 'residual_path:', self.residual_path)
            return x
    
    
    class ResNet(keras.Model):
    
        def __init__(self, block_list, num_classes, initial_filters=16, **kwargs):
            super(ResNet, self).__init__(**kwargs)
    
            self.num_blocks = len(block_list)
            self.block_list = block_list
    
            self.in_channels = initial_filters
            self.out_channels = initial_filters
            self.conv_initial = conv3x3(self.out_channels)
    
            self.blocks = keras.models.Sequential(name='dynamic-blocks')#创建Sequential()对象,逐层堆叠网络
            print(block_list)
            # build all the blocks
            for block_id in range(len(block_list)):#block_list=[2, 2, 2]
                for layer_id in range(block_list[block_id]):
                    print('block_id:',block_id, 'layer_id:', layer_id)
                    if block_id != 0 and layer_id == 0:
                        block = ResnetBlock(self.out_channels, strides=2, residual_path=True)
                    else:
                        if self.in_channels != self.out_channels:
                            residual_path = True
                        else:
                            residual_path = False
                        block = ResnetBlock(self.out_channels, residual_path=residual_path)
    
                    self.in_channels = self.out_channels
    
                    self.blocks.add(block)
    
                self.out_channels *= 2
    
            self.final_bn = keras.layers.BatchNormalization()#对所有样本归一化
            self.avg_pool = keras.layers.GlobalAveragePooling2D()#全局平均池化
            self.fc = keras.layers.Dense(num_classes)#全连接层
    
        def call(self, inputs, training=None):
            out = self.conv_initial(inputs)#输入(batch_size=32, 28, 28, 1) 输出(batch_size=32, 28, 28, channels=16)
            out = self.blocks(out, training=training)#输入(batch_size=32, 28, 28, channels=16) 输出(batch_size=32, 7, 7, channels=64)
            out = self.final_bn(out, training=training)#对所有样本归一化,输出(batch_size=32, 7, 7, channels=64)
            out = tf.nn.relu(out)#input数据 所有小于0的数据设置为0 输出(batch_size=32, 7, 7, channels=64)
            out = self.avg_pool(out)#全局平均池化 输入(batch_size=32, 7, 7, channels=64) 输出:(batch_size=32, channels=64)
            out = self.fc(out)#全连接层 输出:(batch_size=32, num_classes=10)
            return out
    
    # In[3]:
    
    def main():
        num_classes = 10
        batch_size = 32
        epochs = 1
    
        # build model and optimizer
        model = ResNet([2, 2, 2], num_classes)#输出 (batch_size, num_classes)
        model.compile(optimizer=keras.optimizers.Adam(0.001),
                      loss=keras.losses.CategoricalCrossentropy(from_logits=True),
                      metrics=['accuracy'])
        model.build(input_shape=(None, 28, 28, 1))
        print("Number of variables in the model :", model.name)
        model.summary()
    
        # train
        model.fit(x_train, y_train_ohe, batch_size=batch_size, epochs=epochs,
                  validation_data=(x_test, y_test_ohe), verbose=1)
    
        # evaluate on test set
        scores = model.evaluate(x_test, y_test_ohe, batch_size, verbose=1)
        print("Final test loss and accuracy :", scores)
    
    
    
    
    if __name__ == '__main__':
        main()
    
    展开全文
  • 1.1 神经网络嵌套函数和非嵌套函数(前提知识): 首先,假设有一类特定的神经网络架构F\mathcal{F}F,它包括学习速率和其他超参数设置。对于所有f∈Ff \in \mathcal{F}f∈F,存在一些参数集(例如权重和偏置),这些...

    1.ResNet

    1.1 神经网络嵌套函数和非嵌套函数(前提知识):

    首先,假设有一类特定的神经网络架构 F \mathcal{F} F,它包括学习速率和其他超参数设置。对于所有 f ∈ F f \in \mathcal{F} fF,存在一些参数集(例如权重和偏置),这些参数可以通过在合适的数据集上进行训练而获得。现在假设 f ∗ f^* f是我们真正想要找到的函数,如果是 f ∗ ∈ F f^* \in \mathcal{F} fF,那我们可以轻而易举的训练得到它,但通常不能找到我们真正想要的函数 f ∗ f^* f,相反,我们将尝试找到一个函数 f F ∗ f^*_\mathcal{F} fF,这是我们在 F \mathcal{F} F中的最佳选择。例如,给定一个具有 X \mathbf{X} X特性和 y \mathbf{y} y标签的数据集,我们可以尝试通过解决以下优化问题来找到它:
    f F ∗ : = a r g m i n f L ( X , y , f )  subject to  f ∈ F . f^*_\mathcal{F} := \mathop{\mathrm{argmin}}_f L(\mathbf{X}, \mathbf{y}, f) \text{ subject to } f \in \mathcal{F}. fF:=argminfL(X,y,f) subject to fF.
    那么,怎样得到更近似真正 f ∗ f^* f的函数呢?
    唯一合理的可能性是,我们需要设计一个更强大的架构 F ′ \mathcal{F}' F。换句话说,我们预计 f F ′ ∗ f^*_{\mathcal{F}'} fF f F ∗ f^*_{\mathcal{F}} fF“更近似”。然而,如果 F ⊈ F ′ \mathcal{F} \not\subseteq \mathcal{F}' FF,则无法保证新的体系“更近似”。事实上, f F ′ ∗ f^*_{\mathcal{F}'} fF可能更糟:如下面左图所示,对于非嵌套函数(non-nested function)类,较复杂的函数类并不总是向“真”函数 f ∗ f^* f靠拢(复杂度由 F 1 \mathcal{F}_1 F1 F 6 \mathcal{F}_6 F6递增)。在左边图中,虽然 F 3 \mathcal{F}_3 F3 F 1 \mathcal{F}_1 F1更接近 f ∗ f^* f,但 F 6 \mathcal{F}_6 F6却离的更远了。相反对于下面右边图的嵌套函数(nested function)类 F 1 ⊆ … ⊆ F 6 \mathcal{F}_1 \subseteq \ldots \subseteq \mathcal{F}_6 F1F6,我们可以避免上述问题。

    非嵌套函数和嵌套函数
    因此,只有当较复杂的函数类包含较小的函数类时,我们才能确保提高它们的性能。 对于深度神经网络,如果我们能将新添加的层训练成恒等映射(identity function) 𝑓(𝐱)=𝐱 ,新模型和原模型将同样有效。 同时,由于新模型可能得出更优的解来拟合训练数据集,因此添加层似乎更容易降低训练误差。
    针对这一问题,何恺明等人提出了残差网络(ResNet),它在2015年的ImageNet图像识别挑战赛夺魁,并深刻影响了后来的深度神经网络的设计。 残差网络的核心思想是:每个附加层都应该更容易地包含原始函数作为其元素之一。 于是,残差块(residual blocks)便诞生了,这个设计对如何建立深层神经网络产生了深远的影响。 凭借它,ResNet赢得了2015年ImageNet大规模视觉识别挑战赛。

    1.2 残差块

    聚焦于神经网络局部:如下图所示,假设我们的原始输入为 𝑥 ,而希望学出的理想映射为 𝑓(𝐱) (作为下图上方激活函数的输入)。左图虚线框中的部分需要直接拟合出该映射 𝑓(𝐱) ,而右图虚线框中的部分则需要拟合出残差映射 𝑓(𝐱)−𝐱 ,残差映射在现实中往往更容易优化。 以上面提到的恒等映射(f(x)=x)作为我们希望学出的理想映射 𝑓(𝐱) ,我们只需将下面右图虚线框内上方的加权运算的权重和偏置参数设成0,那么 𝑓(𝐱) 即为恒等映射(输出等于输入)。 实际中,当理想映射 𝑓(𝐱) 极接近于恒等映射时,残差映射也易于捕捉恒等映射的细微波动。 下面右图是ResNet的基础架构–残差块(residual block)。在残差块中,输入可通过跨层数据线路更快地向前传播。
    残差块

    1.3 残差块的设计

    ResNet沿用了VGG完整的 3×3 卷积层设计。 残差块里首先有2个有相同输出通道数的 3×3 卷积层。 每个卷积层后接一个批量规范化层和ReLU激活函数。 然后我们通过跨层数据通路,跳过这2个卷积运算,将输入直接加在最后的ReLU激活函数前。 这样的设计要求经过2个卷积层和只直接经过旁路层(跨层数据线路)的输出形状一样,从而使它们可以相加,即实现了输出y=f(x)+x (因此输出y=f(x)+x包含了输入x,也即是y包含了x,函数y比x更复杂,符合了上面提到的嵌套函数的概念,当f(x)=0,即权重和偏差为0时y=x)。 如果想改变通道数,就需要引入一个额外的 1×1 卷积层来将输入变换成需要的形状后再做相加运算
    1.4 残差块的实现如下:

    import d2l.torch
    import torch
    from torch.nn import functional as F
    from torch import nn
    
    #一个残差网络层,包含两个卷积层和一个旁路支路
    class Residul(nn.Module):
        def __init__(self,input_channels,output_channels,use_1x1conv2d=False,stride=1):
            super(Residul, self).__init__()
            #一个残差块包含两个卷积层,第一个卷积层通常改变输入输出通道数,并且改变输出的尺寸的形状大小,第二个卷积层输入输出通道数通常不会改变,每一个卷积层会跟着一个批量规范层
            self.conv2d_1 = nn.Conv2d(in_channels=input_channels,out_channels=output_channels,kernel_size=3,padding=1,stride=stride)
            self.conv2d_2 = nn.Conv2d(in_channels=output_channels,out_channels=output_channels,kernel_size=3,padding=1,stride=1)
            self.bn1 = nn.BatchNorm2d(num_features=output_channels)
            self.bn2 = nn.BatchNorm2d(num_features=output_channels)
            #当输入输出通道数(同时输出的形状大小也会改变)改变后需要加一个1x1卷积层,来改变输入X的形状大小和通道数
            if use_1x1conv2d:
                self.conv2d_3 = nn.Conv2d(in_channels=input_channels,out_channels=output_channels,kernel_size=1,stride=stride)
            else:
                self.conv2d_3 = None
        def forward(self,X):
            Y = F.relu(self.bn1(self.conv2d_1(X)))
            Y = self.bn2(self.conv2d_2(Y))
            if self.conv2d_3:
                X = self.conv2d_3(X)
            Y +=X
            #将输入经过两层卷积层得到的输出Y再与输入X相加后,再经过ReLU()激活函数,必须保证X和Y的通道数和尺寸形状大小相同
            return F.relu(Y)
    #查看输入和输出形状一致,不改变输入的通道数和尺寸大小
    residul = Residual(3,3)
    X = torch.rand(4, 3, 6, 6)
    Y = residul (X)
    print(Y.shape)
    #查看增加输出通道数的同时,并减半输入的高和宽
    residul =Residul(3,6,use_1x1conv2d=True,stride=2)
    X = torch.randn(size=(4,3,6,6))
    Y = residul(X)
    print(Y.shape)
    '''
    输出结果:
    torch.Size([4, 3, 6, 6])
    torch.Size([4, 6, 3, 3])
    '''
    

    此代码生成两种类型的网络如下所示: 一种是当use_1x1conv2d=False时,应用ReLU非线性函数之前,将输入直接经过跨层数据线路添加到输出。 另一种是当use_1x1conv2d=True时,通过添加 1×1 卷积调整输入通道和分辨率与经过两层卷积层的输出形状大小一样,从而才能进行输入和输出相加。
    残差块

    1.4 ResNet模型

    1. ResNet的前两层跟之前介绍的GoogLeNet中的一样: 在输出通道数为64、步幅为2的 7×7 卷积层后,接步幅为2的 3×3 的最大汇聚层。 不同之处在于ResNet每个卷积层后增加了批量规范化层。
    #ResNet第一个模块跟GoogleNet第一个模块相同
    b1 = nn.Sequential(nn.Conv2d(in_channels=1,out_channels=64,kernel_size=7,padding=3,stride=2),
                       nn.BatchNorm2d(64),
                       nn.ReLU(),
                       nn.MaxPool2d(kernel_size=3,padding=1,stride=2))
    
    1. GoogLeNet在后面接了4个由Inception块组成的模块。 ResNet则使用4个由残差块组成的模块,每个模块使用若干个同样输出通道数的残差块。 第一个模块的输出通道数同输入通道数一致。 由于之前已经使用了步幅为2的最大汇聚层,所以无须减小高和宽。 之后的每个模块在第一个残差块里将上一个模块的输出通道数翻倍,并将高和宽减半,下面代码来实现这个模块。注意,我们对第一个残差网络模块做了特别处理。
    #定义一个ResNet块,通常包含两个残差块Residul块(也即是包含两个残差网络层),一个ResNet块通常通道数加倍,尺寸形状高和宽减半,对应到由第一个残差块输出通道是输入通道两倍,尺寸大小减半,第二个残差块输入输出通道数相同,输入输出尺寸形状大小不变,但除开第二个ResNet块,因为第一个ResNet块将输入尺寸形状大小降低了4倍
    def resnet_block(input_channels,output_channels,num_residuls,first_block=False):
        block = []
        for i in range(num_residuls):
            if i==0 and not first_block:
                block.append(Residul(input_channels=input_channels,output_channels=output_channels,use_1x1conv2d=True,stride=2))
            else:
                block.append(Residul(input_channels=output_channels,output_channels=output_channels))
        return block
    
    1. 接着在ResNet加入所有残差块,每个模块使用2个残差块。
    b2 = nn.Sequential(*resnet_block(64,64,2,True))#第二个ResNet块,输入输出通道数不变,输入输出尺寸形状大小不变
    b3 = nn.Sequential(*resnet_block(64,128,2,False))#第三个ResNet块,输出通道数是输入通道数2倍,则输出尺寸形状是输入尺寸形状高和宽的1/2
    b4 = nn.Sequential(*resnet_block(128,256,2,False))#第二个ResNet块,输出通道数是输入通道数2倍,则输出尺寸形状是输入尺寸形状高和宽的1/2
    b5 = nn.Sequential(*resnet_block(256,512,2,False))#第二个ResNet块,输出通道数是输入通道数2倍,则输出尺寸形状是输入尺寸形状高和宽的1/2
    
    1. 最后,与GoogLeNet一样,在ResNet中加入全局平均汇聚层,以及全连接层输出。
    resnet = nn.Sequential(b1,b2,b3,b4,b5,
                           nn.AdaptiveAvgPool2d((1,1)),
                           nn.Flatten(),
                           nn.Linear(in_features=512,out_features=10))
    
    1. 每个模块有4个卷积层(不包括恒等映射的 1×1 卷积层)。 加上第一个 7×7 卷积层和最后一个全连接层,共有18层。 因此,这种模型通常被称为ResNet-18。 通过配置不同的通道数和模块里的残差块数可以得到不同的ResNet模型,例如更深的含152层的ResNet-152。 虽然ResNet的主体架构跟GoogLeNet类似,但ResNet架构更简单,修改也更方便。这些因素都导致了ResNet迅速被广泛使用,下图描述了完整的ResNet-18。
      ResNet架构
    2. 在训练ResNet之前看一下ResNet中不同模块的输出形状是如何变化的。 基本在所有架构中都是将分辨率降低,通道数量增加,直到全局平均汇聚层聚集所有特征。
    #查看每一层输出的通道数和形状尺寸大小
    X = torch.randn(size=(1,1,224,224))
    for layer in resnet:
        X = layer(X)
        print(layer.__class__.__name__," output shape :\t",X.shape)
    
    '''
    输出结果如下:
    Sequential output shape:	 torch.Size([1, 64, 56, 56])
    Sequential output shape:	 torch.Size([1, 64, 56, 56])
    Sequential output shape:	 torch.Size([1, 128, 28, 28])
    Sequential output shape:	 torch.Size([1, 256, 14, 14])
    Sequential output shape:	 torch.Size([1, 512, 7, 7])
    AdaptiveAvgPool2d output shape:	 torch.Size([1, 512, 1, 1])
    Flatten output shape:	 torch.Size([1, 512])
    Linear output shape:	 torch.Size([1, 10])
    '''
    
    1. ResNet模型训练和测试(学习率lr = 0.05,训练轮数为10轮,batch_size为64
    lr,num_epochs,batch_size = 0.05,10,64
    train_iter,test_iter = d2l.torch.load_data_fashion_mnist(batch_size,resize=224)
    d2l.torch.train_ch6(resnet,train_iter,test_iter,num_epochs,lr,device=d2l.torch.try_gpu())
    

    模型训练和测试结果如下图所示:
    ResNet模型训练和测试结果

    1.5 小结:

    1. 残差映射可以更容易地学习同一函数,例如将权重层中的参数近似为零。
      利用残差块(residual blocks)可以训练出一个有效的深层神经网络:输入可以通过跨层数据通路更快地向前传播。
    2. 残差网络(ResNet)对随后的深层神经网络设计产生了深远影响。
    3. 通常卷积层如果通道数加倍,输出尺寸形状高和宽都需要减半
    4. ResNet模型中Residul残差块正是因为添加将输入加入到输出的跨层数据通路时,当神经网络达到很深时,网络底层(靠近输入层)的权重参数才不会出现梯度消失的情况,权重参数更新也不会更新的很缓慢,达不到收敛的状态。通常靠近输入层的网络层的权重梯度很小,会出现梯度消失的情况,当靠近输出层的网络层的权重梯度通常会比较大,会出现梯度爆炸的情况,Residul残差块解决了靠近输入层的网络底层权重更新缓慢,梯度消失,收敛很慢很慢的情况
    5. 加入Residul后靠近输入层的权重参数梯度不会随着层数加深而变小,仍然也会变得很大,从而靠近输入层的参数更容易更新,如下图所示:
      加入Residul后底层权重参数梯度计算

    2.ResNet模型全部代码:

    import d2l.torch
    import torch
    from torch.nn import functional as F
    from torch import nn
    
    #一个残差网络层,包含两个卷积层和一个旁路支路
    class Residul(nn.Module):
        def __init__(self,input_channels,output_channels,use_1x1conv2d=False,stride=1):
            super(Residul, self).__init__()
            #一个残差块包含两个卷积层,第一个卷积层通常改变输入输出通道数,并且改变输出的尺寸的形状大小,第二个卷积层输入输出通道数通常不会改变,每一个卷积层会跟着一个批量规范层
            self.conv2d_1 = nn.Conv2d(in_channels=input_channels,out_channels=output_channels,kernel_size=3,padding=1,stride=stride)
            self.conv2d_2 = nn.Conv2d(in_channels=output_channels,out_channels=output_channels,kernel_size=3,padding=1,stride=1)
            self.bn1 = nn.BatchNorm2d(num_features=output_channels)
            self.bn2 = nn.BatchNorm2d(num_features=output_channels)
            #当输入输出通道数(同时输出的形状大小也会改变)改变后需要加一个1x1卷积层,来改变输入X的形状大小和通道数
            if use_1x1conv2d:
                self.conv2d_3 = nn.Conv2d(in_channels=input_channels,out_channels=output_channels,kernel_size=1,stride=stride)
            else:
                self.conv2d_3 = None
        def forward(self,X):
            Y = F.relu(self.bn1(self.conv2d_1(X)))
            Y = self.bn2(self.conv2d_2(Y))
            if self.conv2d_3:
                X = self.conv2d_3(X)
            Y +=X
            #将输入经过两层卷积层得到的输出Y再与输入X相加后,再经过ReLU()激活函数,必须保证X和Y的通道数和尺寸形状大小相同
            return F.relu(Y)
    
    residul =Residul(3,6,use_1x1conv2d=True,stride=2)
    X = torch.randn(size=(4,3,6,6))
    Y = residul(X)
    print(Y.shape)
    #ResNet第一个模块跟GoogleNet第一个模块相同
    b1 = nn.Sequential(nn.Conv2d(in_channels=1,out_channels=64,kernel_size=7,padding=3,stride=2),
                       nn.BatchNorm2d(64),
                       nn.ReLU(),
                       nn.MaxPool2d(kernel_size=3,padding=1,stride=2))
    #定义一个ResNet块,通常包含两个残差块Residul块(也即是包含两个残差网络层),一个ResNet块通常通道数加倍,尺寸形状高和宽减半,对应到由第一个残差块输出通道是输入通道两倍,尺寸大小减半,第二个残差块输入输出通道数相同,输入输出尺寸形状大小不变,但除开第二个ResNet块,因为第一个ResNet块将输入尺寸形状大小降低了4倍
    def resnet_block(input_channels,output_channels,num_residuls,first_block=False):
        block = []
        for i in range(num_residuls):
            if i==0 and not first_block:
                block.append(Residul(input_channels=input_channels,output_channels=output_channels,use_1x1conv2d=True,stride=2))
            else:
                block.append(Residul(input_channels=output_channels,output_channels=output_channels))
        return block
    b2 = nn.Sequential(*resnet_block(64,64,2,True))#第二个ResNet块,输入输出通道数不变,输入输出尺寸形状大小不变
    b3 = nn.Sequential(*resnet_block(64,128,2,False))#第三个ResNet块,输出通道数是输入通道数2倍,则输出尺寸形状是输入尺寸形状高和宽的1/2
    b4 = nn.Sequential(*resnet_block(128,256,2,False))#第二个ResNet块,输出通道数是输入通道数2倍,则输出尺寸形状是输入尺寸形状高和宽的1/2
    b5 = nn.Sequential(*resnet_block(256,512,2,False))#第二个ResNet块,输出通道数是输入通道数2倍,则输出尺寸形状是输入尺寸形状高和宽的1/2
    resnet = nn.Sequential(b1,b2,b3,b4,b5,
                           nn.AdaptiveAvgPool2d((1,1)),
                           nn.Flatten(),
                           nn.Linear(in_features=512,out_features=10))
    X = torch.randn(size=(1,1,224,224))
    for layer in resnet:
        X = layer(X)
        print(layer.__class__.__name__," output shape :\t",X.shape)
    
    lr,num_epochs,batch_size = 0.05,10,64
    train_iter,test_iter = d2l.torch.load_data_fashion_mnist(batch_size,resize=224)
    d2l.torch.train_ch6(resnet,train_iter,test_iter,num_epochs,lr,device=d2l.torch.try_gpu())
    
    展开全文
  • 残差图的matlab代码
  • 如何理解残差网络(resnet)结构和代码实现(Pytorch)笔记分享
  • 用于伪 3d 残差网络的 Tensorflow 实现。 作者 yfxc 电子邮件 张量流 1.10+(不支持2.0) 介绍 Pseudo-3d-residual-network 主要用于动作识别,论文网址: : 这是张量流版本。 准备自己的数据集。 假设您将要...
  • PyTorch框架中torchvision模块下有:torchvision.datasets、torchvision.models、torchvision.transforms这3个子包。 关于详情请参考官网:... 具体代码可以参考github:https://github.com/pytorc...
  • 深度残差收缩网络的完整PyTorch代码

    千次阅读 多人点赞 2021-04-02 22:31:52
    深度残差收缩网络是建立在三个部分的基础之上的,包括残差网络、注意力机制和软阈值化。 其功能特色包括: 1)由于软阈值化是信号降噪算法的常用步骤,所以深度残差收缩网络比较适合强噪、高冗余数据。同时,软阈值...
  • 残差网络–ResNeXt (附python代码) 一、ResNet、ResNeXt介绍 ####1.1 ResNet 的结构 ResNet 采用模块化的思维来替代整体的卷积层,通过一个个模块的堆叠来替代不断增加的卷积层。按照残差模块堆叠数量的不同,产生...
  • 残差神经网络代码详解

    万次阅读 多人点赞 2018-08-26 15:10:44
    一、残差神经网络——ResNet的综述 深度学习网络的深度对最后的分类和识别的效果有着很大的影响,所以正常想法就是能把网络设计的越深越好, 但是事实上却不是这样,常规的网络的堆叠(plain network)在网络很深...
  • 深度残差卷积神经网络作为交互式Web服务器上的性别分类器。 该网络是通过优化实现的 项目规格书 奥斯纳布吕克大学 2016/17冬季学期 课程:使用Tensorflow的人工神经网络简介 贡献者:Clemens Hutter,Michele ...
  • 2.内容:基于深度残差网络的人脸眼睛定位算法matlab仿真+代码仿真操作视频 3.用处:用于人脸眼睛定位算法编程学习 4.指向人群:本硕博等教研学习使用 5.运行注意事项: 使用matlab2021a或者更高版本测试,运行...
  • 深度残差网络demo

    2018-07-24 15:24:12
    vs项目,代码难度并不是很高,使用TensorFlow原生的代码,不过是本人毕设的一套代码,读取文件夹的文件的图片为批次,然后使用批次调用深度残差网络进行训练,并进行保存。压缩包里包含了测试代码,因为本人的是文字...
  • 代码 1.1DRSN_keras.py python版本为3.6 安装tensorflow1.15.0 直接利用tensorflow中的keras import部分的代码改成: from __future__ import print_function import numpy as np from tensorflow import keras from...
  • 残差网络ResNet模块

    2018-04-21 10:45:09
    ResNet网络结构模块,可直接使用,返回值一个是loss用于损失值优化,第二个softmax输出的是预测值用于测试
  • 本文主要介绍如何使用python搭建:一个基于深度残差网络(ResNet)的水果**图像分类识别系统**。 项目只是用水果分类作为抛砖引玉,其中包含了使用ResNet进行图像分类的相关代码。主要功能如下: - 数据预处理,...
  • matlab残差函数定义代码RDN-Tensorflow (2018/09/04) 介绍 我为 . 我使用 DIV2K 数据集作为训练数据集。 环境 Ubuntu 16.04 Python 3.5 依赖 麻木 Opencv2 matplotlib 文件 main.py : 执行 train.py 并传递默认值。 ...
  • 如何使用PyTorch简易搭建残差网络

    千次阅读 2021-09-26 18:16:27
    然而,许多人可能都不知道的是,近年来计算机视觉的突破性进步都是由一种特定类型的网络架构推动的,也就是所谓的残差网络(residual network,ResNet)。事实上,我们所看到的诸多先进的人工智能成果,没有残差块...
  • cnn下的网络修改对数据分析的应用
  • 参考:...PyTorch框架中torchvision模块下有:torchvision.datasets、torchvision.models、torchvision.transforms这3个子包。 ... 具体代码可以参考github: https://github
  • PyTorch实现简单的残差网络

    千次阅读 2022-03-09 18:30:18
    残差网络(Residual Network)的特点是容易优化,并且能够通过增加相当的深度来提高准确率。其内部的残差块使用了跳跃连接,缓解了在深度神经网络中增加深度带来的梯度消失问题。 本文实现如图1所示的两层残差模块用于...
  • 残差网络(Pytorch实现)

    千次阅读 2021-09-10 18:31:30
    本文讲如何使用Pytorch实现残差网络残差网络的结构如图: 输入x,输出output=F(x)+x:F(x)为输入经过卷积运算后的结果,x为输入本身。实际上就是将输出结果再次加上了本身。 1. 如何理解"+"号运算? 这里的加法...
  • 残差网络ResNet代码解读

    千次阅读 2019-11-25 09:30:09
    残差网络效果 卷积神经网络CNN的发展历史如图所示: 从起初AlexNet的的8层网络,到ResNet的152层网络,层数逐步增加。当网络层数增加到一定程度之后,错误率反而上升,其原因是层数太多梯度下降变得越发困难。而...
  • 博客见:https://blog.csdn.net/qq_37534947/article/details/109727232,主要是空洞卷积以及残差网络代码实现,包含数据集,框架是pytorch
  • 深度残差网络

    2022-02-13 11:32:37
    在较深层数的神经网络中,梯度信息由网络的末层逐层传向网络的首层时, 传递的过程中会出现梯度接近于 0 或梯度值非常大的现象 怎么解决深层神经网络的梯度弥散和梯度爆炸现象呢?既然浅层神经网络不容易出现梯度...
  • 残差网络实现

    千次阅读 2020-07-02 22:34:19
    残差网络可以解决多层神经网络问题,这里使用mnist数据集实现一下残差网络。 网络模型如下: 该代码可以在普通VGG网络中随意添加残差层(RENN(x1, x2, layer_name)),方便建立自己的网络模型。 代码: # ...
  • PyTorch深度学习:卷积神经网络( 简单的残差卷积神经网络
  • 残差网络 ResNet(PyTorch)

    2022-07-03 19:07:07
    残差网路

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,048
精华内容 7,619
关键字:

残差网络代码

友情链接: saqy.rar