精华内容
下载资源
问答
  • 密集连接层的功能接口。 This layer implements the operation: `outputs = activation(inputs * kernel + bias)` where `activation` is the activation function passed as the `activation` argument (if ...

    from tensorflow\python\layers\core.py

    @tf_export('layers.dense')
    def dense(
        inputs, units,
        activation=None,
        use_bias=True,
        kernel_initializer=None,
        bias_initializer=init_ops.zeros_initializer(),
        kernel_regularizer=None,
        bias_regularizer=None,
        activity_regularizer=None,
        kernel_constraint=None,
        bias_constraint=None,
        trainable=True,
        name=None,
        reuse=None):
      """Functional interface for the densely-connected layer.
      密集连接层的功能接口。
    
      This layer implements the operation:
      `outputs = activation(inputs * kernel + bias)`
      where `activation` is the activation function passed as the `activation`
      argument (if not `None`), `kernel` is a weights matrix created by the layer,
      and `bias` is a bias vector created by the layer
      (only if `use_bias` is `True`).
    
    该层实现以下操作:
    输出=激活(输入*内核+偏差)其中“激活”是作为“激活”参数(如果不是“无”)传递的激活函数,“内核”是由以下项创建的权重矩阵 层,“ bias”是由该层创建的偏差矢量(仅当“ use_bias”为“ True”时)。
    
      Arguments:
        inputs: Tensor input. 张量输入。
        units: Integer or Long, dimensionality of the output space.
        	   输出空间的维度:Integer或Long。
        activation: Activation function (callable). Set it to None to maintain a
          linear activation.
          			激活功能(可调用)。 将其设置为None以保持线性激活。
        use_bias: Boolean, whether the layer uses a bias.
        		  布尔值,层是否使用偏差。
        kernel_initializer: Initializer function for the weight matrix.
          If `None` (default), weights are initialized using the default
          initializer used by `tf.get_variable`.
          					权重矩阵的初始化函数。 如果为“ None”(默认),则权重将使用“ tf.get_variable”使用的默认初始化程序进行初始化。
        bias_initializer: Initializer function for the bias.
        				  偏置的初始化函数。
        kernel_regularizer: Regularizer function for the weight matrix.
        					权重矩阵的正则函数。
        bias_regularizer: Regularizer function for the bias.
        				  正则化功能的偏置。
        activity_regularizer: Regularizer function for the output.
        					  输出的正则函数。
        kernel_constraint: An optional projection function to be applied to the
            kernel after being updated by an `Optimizer` (e.g. used to implement
            norm constraints or value constraints for layer weights). The function
            must take as input the unprojected variable and must return the
            projected variable (which must have the same shape). Constraints are
            not safe to use when doing asynchronous distributed training.
            			   (内核约束)一种可选的投影函数,在由“ Optimizer”更新后将应用于内核(例如,用于实现规范约束或层权重的值约束)。 
            			   该函数必须将未投影的变量作为输入,并且必须返回投影变量(形状必须相同)。 
            			   在进行异步分布式训练时,使用约束并不安全。
        bias_constraint: An optional projection function to be applied to the
            bias after being updated by an `Optimizer`.
            			 一个可选的投影函数,在由“ Optimizer”更新后将应用于偏置。
        trainable: Boolean, if `True` also add variables to the graph collection
          `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
          		   布尔值,如果True还将变量添加到图形集合GraphKeys.TRAINABLE_VARIABLES中(请参见tf.Variable)。
        name: String, the name of the layer.
        	  字符串,层的名称。
        reuse: Boolean, whether to reuse the weights of a previous layer
          by the same name.
          	   布尔值,是否重复使用相同名称的上一层的权重。
    
      Returns:
        Output tensor the same shape as `inputs` except the last dimension is of
        size `units`.
        输出张量与“输入”具有相同的形状,除了最后一个维度的尺寸为“units”。
    
      Raises:
        ValueError: if eager execution is enabled.
        ValueError:如果启用了急切执行。
      """
      layer = Dense(units,
                    activation=activation,
                    use_bias=use_bias,
                    kernel_initializer=kernel_initializer,
                    bias_initializer=bias_initializer,
                    kernel_regularizer=kernel_regularizer,
                    bias_regularizer=bias_regularizer,
                    activity_regularizer=activity_regularizer,
                    kernel_constraint=kernel_constraint,
                    bias_constraint=bias_constraint,
                    trainable=trainable,
                    name=name,
                    _scope=name,
                    _reuse=reuse)
      return layer.apply(inputs)
    
    
    展开全文
  • 此外,密集连接层的表示不再包含物体在输入图像中的位置信息。密集连接层舍弃了空间的概念,而物体位置信息仍然由卷积特征图所描述。如果物体位置对于问题很重要,那么密集连接层的特征在很大程度上是无用的。 ...

      一般来说,应该避免这么做。原因在于卷积基学到的表示可能更加通用,因此更适合重复使用。卷积神经网络的特征图表示通用概念在图像中是否存在,无论面对什么样的计算机视觉问题,这种特征图都可能很有用。但是,分类器学到的表示必然是针对于模型训练的类别,其中仅包含某个类别出现在整张图像中的概率信息。此外,密集连接层的表示不再包含物体在输入图像中的位置信息。密集连接层舍弃了空间的概念,而物体位置信息仍然由卷积特征图所描述。如果物体位置对于问题很重要,那么密集连接层的特征在很大程度上是无用的。

      注意,某个卷积层提取的表示的通用性(以及可复用性)取决于该层在模型中的深度。模型中更靠近底部的层提取的是局部的、高度通用的特征图(比如视觉边缘、颜色和纹理),而更靠近顶部的层提取的是更加抽象的概念(比如"猫耳朵"或"狗眼睛")。因此,如果你的新数据集与原始模型训练的数据集有很大差异,那么最好只使用模型的前几层来做特征提取,而不是使用整个卷积基。

    注:这里更靠近底部的层是指在定义模型时先添加到模型中的层,而更靠近顶部的层则是后添加到模型中的层,下同。

    展开全文
  • 在判别网络结构中,采用6个卷积模块和一个全连接层对真伪图像进行甄别,采用对抗博弈的思想,提升重建图像的质量。实验结果表明,本文算法在视觉效果评估、峰值信噪比值、结构相似性值以及耗时等多方面指标上都有了很大...
  • 连接层的前向计算下图中连线最密集的2个地方就是全连接层,这很明显的可以看出全连接层的参数的确很多。在前向计算过程,也就是一个线性的加权求和的过程,全连接层的每一个输出都可以看成前一层的每一个结点乘以...

    全连接层的推导

    全连接层的每一个结点都与上一层的所有结点相连,用来把前边提取到的特征综合起来。由于其全相连的特性,一般全连接层的参数也是最多的。

    全连接层的前向计算

    下图中连线最密集的2个地方就是全连接层,这很明显的可以看出全连接层的参数的确很多。在前向计算过程,也就是一个线性的加权求和的过程,全连接层的每一个输出都可以看成前一层的每一个结点乘以一个权重系数W,最后加上一个偏置值b得到,即 。如下图中第一个全连接层,输入有50*4*4个神经元结点,输出有500个结点,则一共需要50*4*4*500=400000个权值参数W和500个偏置参数b。


    下面用一个简单的网络具体介绍一下推导过程


    其中,x1、x2、x3为全连接层的输入,a1、a2、a3为输出,根据我前边在笔记1中的推导,有

    可以写成如下矩阵形式:


    全连接层的反向传播

    以我们的第一个全连接层为例,该层有50*4*4=800个输入结点和500个输出结点。

    由于需要对W和b进行更新,还要向前传递梯度,所以我们需要计算如下三个偏导数。

    1、对上一层的输出(即当前层的输入)求导

    若我们已知转递到该层的梯度,则我们可以通过链式法则求得loss对x的偏导数。
    首先需要求得该层的输出ai对输入xj的偏导数

    再通过链式法则求得loss对x的偏导数:

    上边求导的结果也印证了我前边那句话:在反向传播过程中,若第x层的a节点通过权值W对x+1层的b节点有贡献,则在反向传播过程中,梯度通过权值W从b节点传播回a节点。

    若我们的一次训练16张图片,即batch_size=16,则我们可以把计算转化为如下矩阵形式。

    2、对权重系数W求导

    我们前向计算的公式如下图,


    由图可知,所以:

    当batch_size=16时,写成矩阵形式:

    3、对偏置系数b求导

    由上面前向推导公式可知

    即loss对偏置系数的偏导数等于对上一层输出的偏导数。

    当batch_size=16时,将不同batch对应的相同b的偏导相加即可,写成矩阵形式即为乘以一个全1的矩阵:




    -----------------------------------------------------------------------------------------------------------------------------------

    接下来再主要谈谈全连接层的意义

    连接层实际就是卷积核大小为上层特征大小的卷积运算,卷积后的结果为一个节点,就对应全连接层的一个点。
    假设最后一个卷积层的输出为7×7×512,连接此卷积层的全连接层为1×1×4096。
    连接层实际就是卷积核大小为上层特征大小的卷积运算,卷积后的结果为一个节点,就对应全连接层的一个点。如果将这个全连接层转化为卷积层:
    1.共有4096组滤波器
    2.每组滤波器含有512个卷积核
    3.每个卷积核的大小为7×7
    4.则输出为1×1×4096
    ------------------------------------------
    若后面再连接一个1×1×4096全连接层。则其对应的转换后的卷积层的参数为:
    1.共有4096组滤波器
    2.每组滤波器含有4096个卷积核
    3.每个卷积核的大小为1×1
    4.输出为1X1X4096
    相当于就是将特征组合起来进行4096个分类分数的计算,得分最高的就是划到的正确的类别。

    而全连接层的坏处就在于其会破坏图像的空间结构,
    因此人们便开始用卷积层来“代替”全连接层,
    通常采用1×1的卷积核,这种不包含全连接的CNN成为全卷积神经网络(FCN),
    FCN最初是用于图像分割任务,
    之后开始在计算机视觉领域的各种问题上得到应用,
    事实上,Faster R-CNN中用来生成候选窗口的CNN就是一个FCN。
    FCN的特点就在于输入和输出都是二维的图像,并且输入和输出具有相对应的空间结构,
    在这种情况下,我们可以将FCN的输出看作是一张热度图,用热度来指示待检测的目标的位置和覆盖的区域。
    在目标所处的区域内显示较高的热度,
    而在背景区域显示较低的热度,
    这也可以看成是对图像上的每一个像素点都进行了分类,
    这个点是否位于待检测的目标上。
    展开全文
  • 经过滤波后的图像进入两卷积层进行特征提取,在卷积层之后使用了5组密集连接模块来解决网络加深带来的梯度消失问题,密集连接模块之间通过过度来控制整个网络的宽度。实验结果表明,相比传统的图像隐写分析算法...
  • 采用密集连接的网络结构,充分利用每网络提取的特征,减少网络推理时间;采用具有更大感受野的扩张块结构;使用扩张块结构和反卷积网络结构将浅层特征图和深层特征图进行信息融合,从而增强遥感图像中多尺度目标的检测...
  • 密集连接融合后组成的密集块结构使图像区域的上下文信息得到有效利用。激励模块将有价值的全局信息选择性放大并将无用特征加以抑制。图像重建部分中的多个1×1卷积层结构减小了前一的尺寸,在加速计算的同时减少了...
  • 什么是DenseNet? ... 我们知道,当靠近输入的和靠近输出的之间的连接越短,卷积神经网络就可以做得更深,精度更高且可以更加有效的训练。而DenseNet在此基础上将每一与之前所有连接。传统的L

    什么是DenseNet?

    DenseNet是由清华大学的Zhuang Liu、康奈尔大学的Gao Huang和Kilian Q.Weinberger,以及Facebook研究员Laurens van der Maaten在CVPR 2017所作,并且还获得了2017CVPR最佳论文!下面我们就来看看DenseNet是何方神圣吧。

    我们知道,当靠近输入的层和靠近输出的层之间的连接越短,卷积神经网络就可以做得更深,精度更高且可以更加有效的训练。而DenseNet在此基础上将每一层与之前所有层相连接。传统的L层卷积神经网络有L个连接——位于每一层和其后一层之间—,而我们的神经网络有L*(L+1)/2个直接链接。对于每一层,其输入的特征是之前所有的层,而它自己的特征图作为之后所有层的输入。

    下图展示了具体的密集连接方式:

    DenseNet有以下几个引人注目的优点:缓解梯度消失问题,加强特征传播,鼓励特征复用,极大的减少了参数量。DenseNets需要更少的计算来实现高性能

    ResNet

    训练深层的神经网络,会遇到梯度消失和梯度爆炸(vanishing/exploding gradients)的问题,影响了网络的收敛,但是这很大程度已经被标准初始化(normalized initialization)和BN(Batch Normalization)所处理

    当深层网络能够开始收敛,会引起网络退化(degradation problem)问题,即随着网络深度增加,准确率会饱和,甚至下降。这种退化不是由过拟合引起的,因为在适当的深度模型中增加更多的层反而会导致更高的训练误差
    ResNet就通过引入深度残差连接来解决网络退化的问题,建立前面层与后面层之间的短链接(shortcuts),从而解决深度CNN模型难训练的问题

    具体表达式如下:
    在这里插入图片描述
    在ResNet中前面层与后面层建立的短链接(shortcuts)方式是add相加操作,因此要求输入与输出的shape完全一样!这主要是由ResNet结构中的Identity Block来完成的,更大程度地去加深网络的深度,实现了深度残差网络。但是add操作可能会阻碍网络中的信息流。

    DenseNets和Resnet之间的主要区别,DenseNets通过特征重用来挖掘网络的潜力,产生易于训练且参数效率高的精简模型。将不同层学习到的特征映射进行堆叠操作,可以增加后续层的输入变化,并提高效率。

    DenseNet

    DenseNet的整体网络架构如下图所示:

    一个有三个Dense Block的DenseNet网络。每个Dense Block中含有多个conv blocks,conv blocks中特征图的高度和宽度不发生变化,进行的是通道数的变化。 两个相邻Dense Block之间的层称为Transition Layer过渡层,通过卷积和池化改变特征图的大小

    Dense connectivity 紧密连接

    为了进一步改善层与层之间的信息流,提出了一种不同的连接模式:引入从任何层到所有后续层的直接连接。正如上图所展示的那样,例如第l层接收前面所有层的特征映射,即x0,x1,…,xl-1作为输入:
    在这里插入图片描述
    H函数实现每层的非线性变换,主要由BN,Relu和3x3Conv组成,式中[x0,x1,…,xl-1]指的是第0,…,l-1层中生成的特征图进行串联。

    Bottleneck layers

    每一个Dense Block中的conv block经过H非线性输出k个特征图,但是它通常是输入特征图更多。因此在3x3卷积之前引入1x1卷积作为瓶颈层,以减少特征映射的数量,从而提高计算效率。

    Growth rate

    如果每个函数H生成k个特征映射,则第l层具有k0+k×(l-1)个输入特征映射,其中k0是输入的通道数。DenseNet与现有网络体系结构的一个重要区别是,DenseNet可以有非常窄的层,例如k=12。我们把超参数k称为网络的growth rate。相对较小的growth rate足以获得最新的结果。
    实现代码为:

    class Bottleneck(nn.Module):
        def __init__(self, nChannels, growthRate):
            super(Bottleneck, self).__init__()
            interChannels = 4*growthRate
            # 瓶颈结构1x1卷积减少输入的通道数
            self.bn1 = nn.BatchNorm2d(nChannels)
            self.conv1 = nn.Conv2d(nChannels, interChannels, kernel_size=1,bias=False)
            # H函数实现非线性输出BN+Relu+BN
            self.bn2 = nn.BatchNorm2d(interChannels)
            self.conv2 = nn.Conv2d(interChannels, growthRate, kernel_size=3,padding=1, bias=False)
    
        def forward(self, x):
            out = self.conv1(F.relu(self.bn1(x)))
            out = self.conv2(F.relu(self.bn2(out)))
            out = torch.cat((x, out), 1)
            return out
    

    Pooling layers 池化层

    当特征映射的大小发生变化时,上面式子中使用的连接操作是不可行的。然而,卷积网络的一个重要组成部分是向下采样层来改变特征映射的大小。因此在Dense Block之间添加Transition Layer来进行特征图大小的压缩,而Transition Layer主要由一个1x1卷积块以及步长为2的AveragePooling2D来进行特征图大小压缩。

    Compression 压缩

    为了进一步提高模型的紧凑性,在Transition Layer中减少特征映射的数量。如果一个Desne Block中包含m个特征映射,在Transition Layer中生成的特征图数量为θm,其中0<θ≤1被称为压缩因子。当θ=1时,Transition Layer的特征图数量保持不变,论文中将θ设置为0.5。
    Transition Layer实现代码如下:

    # reduction即为压缩因子
    nOutChannels = int(math.floor(nChannels*reduction))
    class Transition(nn.Module):
        def __init__(self, nChannels, nOutChannels):
            super(Transition, self).__init__()
            self.bn1 = nn.BatchNorm2d(nChannels)
            self.conv1 = nn.Conv2d(nChannels, nOutChannels, kernel_size=1,bias=False)
    
        def forward(self, x):
            out = self.conv1(F.relu(self.bn1(x)))
            out = F.avg_pool2d(out, 2)
            return out
    

    下图包含了具有四个Dense Block的DenseNet网络架构,根据每一个Dense Block中1x1conv 和3x3conv(即conv block)重复次数的不同,可以分为DenseNet-121,DenseNet-1169,DenseNet-201和DenseNet-264。所有网络的growth rate为32。
    输入图片在DenseNet网络的shape的具体变化如下:

    我们以上述DenseNet-121为例,来进行DenseNet网络的详解。我们将输入图片进行数据增强后,resize成224x224的shape作为DenseNet的输入input(224x224,3),经过一个kernel size为7且stride=2的卷积块(Conv+BN+Relu),此时conv1的shape为(112,112,64),再经过一次MaxPooling,poo1的shape变为(56,56,64);进入第一个Dense Block(1),此时的输入为poo1(56,56,64),Dense Block中首先是瓶颈层,即将pool1利用1x1卷积进行降维,降至4xgrowth rate,然后再进行3x3卷积特征提取,将输出通道固定为growth rate,将1x1conv和3
    x3conv称为Dense Block中的一个conv block。然后在进行Dense Block中特有的残差边短接,即将该输出(56,56,growth rate)与输入pool1进行通道数的堆叠,shape变为(56,56,64+growth rate);然后又将该特征层作为输入,继续重复瓶颈结构和残差边短接操作,在DenseNet-121的Dense Block(1)中,上述的conv block和残差边短接一共进行了6次,故输出dense1的shape变为(56,56,64+6growth rate)=(56,56,256),论文中是将growth rate设置为32。需要注意的是,上述Dense Block(1)中并没有发生特征图高度和宽度的改变,仅仅是进行了通道数的堆叠concatenate操作,即层与层之间的密集连接。接着是进入第一个Transition Layer(1),在Transition Layer(1)中首先利用1x1卷积进行通道数的压缩,压缩为一半的通道数,提高模型的紧凑性,shape此时变为(56,56,(64+6growth rate)/2)=(56,56,128)。然后再利用一个步长stride=2的平均池化AveragePooling2D来压缩特征层的高度和宽度,此时trans1的shape变为(28,28,(64+6growth rate)/2)=(56,56,128)。然后再将此特征层作为输入,进入第二个Dense Block(2),Dense Block(2)中进行的操作和Dense Block(1)一样,只是conv block和残差边短接重复的次数不一样而已,Dense Block(2)中一共进行了12次,此时dense2的shape为(28,28,(64+6growth rate)/2+12growth rate)=(28,28,512)。接着进入第二个Transition Layer(2),操作和Transition Layer(1)一样,先利用1x1卷积进行通道数压缩,再利用平均池化压缩特征层的高度和宽度,即trans2的shape为(14,14,((64+6growth rate)/2+12growth rate)/2)=(14,14,256)。再进入第三个Dense Block(3),conv block和残差边短接一共进行了24次,输出dense3的shape为(14,14,((64+6growth rate)/2+12growth rate)/2+24growth rate)=(14,14,1024),进入Transition Layer(3),输出trans3的shape为(7,7,512)。再进入第四个Dense Block(4),conv block和残差边短接一共进行了16次,输出dense4的shape为(7,7,1024)。然后进行一个全局平均池化,最后接一个全连接层将输出通道数固定为n_classes类别数量。

    DenseNet121的pytorch代码具体如下:

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    from torch.autograd import Variable
    import torchvision.transforms as transforms
    import torchvision.models as models
    from torchsummary import summary
    
    import sys
    import math
    
    
    # 瓶颈结构,1x1卷积将输入通道数降低为4*growthRate,3x3卷积将通道数固定growthRate
    class Bottleneck(nn.Module):
        def __init__(self, nChannels, growthRate):
            super(Bottleneck, self).__init__()
            interChannels = 4 * growthRate
            self.bn1 = nn.BatchNorm2d(nChannels)
            self.conv1 = nn.Conv2d(nChannels, interChannels, kernel_size=1, bias=False)
            self.bn2 = nn.BatchNorm2d(interChannels)
            self.conv2 = nn.Conv2d(interChannels, growthRate, kernel_size=3, padding=1, bias=False)
    
        def forward(self, x):
            out = self.conv1(F.relu(self.bn1(x)))
            out = self.conv2(F.relu(self.bn2(out)))
            out = torch.cat((x, out), 1)
            return out
    
    class SingleLayer(nn.Module):
        def __init__(self, nChannels, growthRate):
            super(SingleLayer, self).__init__()
            self.bn1 = nn.BatchNorm2d(nChannels)
            self.conv1 = nn.Conv2d(nChannels, growthRate, kernel_size=3, padding=1, bias=False)
    
        def forward(self, x):
            out = self.conv1(F.relu(self.bn1(x)))
            out = torch.cat((x, out), 1)
            return out
    
    # Transition Layer将1x1卷积进行通道数压缩一半,然后再进行平均池化
    class Transition(nn.Module):
        def __init__(self, nChannels, nOutChannels):
            super(Transition, self).__init__()
            self.bn1 = nn.BatchNorm2d(nChannels)
            self.conv1 = nn.Conv2d(nChannels, nOutChannels, kernel_size=1, bias=False)
    
        def forward(self, x):
            out = self.conv1(F.relu(self.bn1(x)))
            out = F.avg_pool2d(out, 2)
            return out
    
    
    class DenseNet(nn.Module):
        def __init__(self, growthRate, nDenseBlocks, reduction, bottleneck, nClasses):
            super(DenseNet, self).__init__()
    
            # growthRate=32
            nChannels = 2 * growthRate
            self.conv1 = nn.Conv2d(3, nChannels, kernel_size=7, stride=2, padding=3, bias=False)
            self.bn1 = nn.BatchNorm2d(nChannels)
            self.relu = nn.ReLU(inplace=True)
            self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0, ceil_mode=True)
    
            self.dense1 = self._make_dense(nChannels, growthRate, nDenseBlocks[0],bottleneck)
            nChannels += nDenseBlocks[0] * growthRate
            nOutChannels = int(math.floor(nChannels * reduction))
            self.trans1 = Transition(nChannels, nOutChannels)
    
            nChannels = nOutChannels
            self.dense2 = self._make_dense(nChannels, growthRate, nDenseBlocks[1],bottleneck)
            nChannels += nDenseBlocks[1] * growthRate
            nOutChannels = int(math.floor(nChannels * reduction))
            self.trans2 = Transition(nChannels, nOutChannels)
    
            nChannels = nOutChannels
            self.dense3 = self._make_dense(nChannels, growthRate, nDenseBlocks[2],bottleneck)
            nChannels += nDenseBlocks[2] * growthRate
            nOutChannels = int(math.floor(nChannels * reduction))
            self.trans3 = Transition(nChannels, nOutChannels)
    
            nChannels = nOutChannels
            self.dense4 = self._make_dense(nChannels, growthRate, nDenseBlocks[3],bottleneck)
            nChannels += nDenseBlocks[3] * growthRate
    
    
            self.bn2 = nn.BatchNorm2d(nChannels)
            self.fc = nn.Linear(nChannels, nClasses)
    
            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_()
                elif isinstance(m, nn.Linear):
                    m.bias.data.zero_()
    
        def _make_dense(self, nChannels, growthRate, nDenseBlocks, bottleneck):
            layers = []
            for i in range(int(nDenseBlocks)):
                if bottleneck:
                    layers.append(Bottleneck(nChannels, growthRate))
                else:
                    layers.append(SingleLayer(nChannels, growthRate))
                nChannels += growthRate
            return nn.Sequential(*layers)
    
        def forward(self, x):
            print(x.shape)
            out = self.conv1(x)
            print(out.shape)
            out = self.bn1(out)
            out = self.relu(out)
            out = self.maxpool(out)
            print(out.shape)
    
            out = self.trans1(self.dense1(out))
            print(out.shape)
            out = self.trans2(self.dense2(out))
            print(out.shape)
            out = self.trans3(self.dense3(out))
            print(out.shape)
            out = self.dense4(out)
            print(out.shape)
            out = torch.squeeze(F.avg_pool2d(F.relu(self.bn2(out)), 7))
            print(out.shape)
            out = F.log_softmax(self.fc(out))
            return out
    
    if __name__ == '__main__':
        DenseNet121= DenseNet(growthRate=32, nDenseBlocks=[6, 12, 24, 16], reduction=0.5, bottleneck=True,nClasses=1000)
        model = DenseNet121.train().cuda()
        summary(model,(3,224,224))
    

    在这里插入图片描述
    DenseNet的缺点:DneseNet在训练时十分消耗内存,这是由于算法实现不优带来的。当前的深度学习框架对 DenseNet 的密集连接没有很好的支持,所以只能借助于反复的拼接(Concatenation)操作,将之前层的输出与当前层的输出拼接在一起,然后传给下一层。对于大多数框架(如Torch和TensorFlow),每次拼接操作都会开辟新的内存来保存拼接后的特征。这样就导致一个 L 层的网络,要消耗相当于 L(L+1)/2 层网络的内存(第 l 层的输出在内存里被存了 (L-l+1) 份)

    展开全文
  • Caffe 全连接层

    2018-09-17 17:05:15
    下图中连线最密集的2个地方就是全连接层,这很明显的可以看出全连接层的参数的确很多。在前向计算过程,也就是一个线性的加权求和的过程,全连接层的每一个输出都可以看成前一层的每一个结点乘以一个权重系数W,最后...
  • 密集连接卷积网络 摘要 最近的研究表明,如果卷积网络在接近输入和接近输出之间包含更短的连接,那么它在本质上可以更深入、更准确、更有效地进行训练。在本文中,我们接受了这一观察,并介绍了稠密卷积网络...
  • 连接层的实现

    2019-10-16 15:33:53
    下图中连线最密集的2个地方就是全连接层,这很明显的可以看出全连接层的参数的确很多。在前向计算过程,也就是一个线性的加权求和的过程,全连接层的每一个输出都可以看成前一层的每一个结点乘以一个权重系数W,最后...
  • 第三章 基于密集连接卷积网络改进的目标分类算法 最近的研究表明,如果卷积网络包含接近输入的和接近输出的之间的较短连接,则卷积网络可以更深入,更精确和更有效地进行训练。在本章中,论文首先研究密集卷积...
  • 连接层的理解

    2019-04-28 10:02:34
    下图中连线最密集的2个地方就是全连接层,这很明显的可以看出全连接层的参数的确很多。在前向计算过程,也就是一个线性的加权求和的过程,全连接层的每一个输出都可以看成前一层的每一个结点乘以一个权重系数W,最后...
  • 针对这些问题,提出多维加权密集连接卷积神经网络模型实现对多光谱卫星云图的云检测。跨连接能够实现网络中所有之间的信息流,从而减少训练过程中的梯度消失导致收敛困难的问题。特征图之间连接的权值不同使得...
  • 最近的工作表明,卷积网络如果在靠近输入的和靠近输出的之间包含较短的连接,就可以更深入,更准确,更有效地进行训练。我们认同这个观察结果,并引入密集卷积网络(DenseNet),该网络以前馈的方式将每一...
  • 向量数据:密集连接网络(Dense) 图像数据:二维卷积神经网络 声音数据(比如波形):一维卷积神经网络(首选)或循环神经网络 文本数据:一维卷积神经网络(首选)或循环神经网络 时间序列数据:循环神经...
  • 对于全连接层的理解

    万次阅读 2018-08-24 11:45:07
    下图中连线最密集的2个地方就是全连接层,这很明显的可以看出全连接层的参数的确很多。在前向计算过程,也就是一个线性的加权求和的过程,全连接层的每一个输出都可以看成前一层的每一个结点乘以一个权重系数W,最后...
  • ResNet模型的核心是通过建立前面与后面之间的“短路连接”(shortcuts,skip connection),这有助于训练过程中梯度的反向传播,从而能训练出更深的CNN网络。今天我们要介绍的是 DenseNet(Densely connected con
  • 连接层的前向计算下图中连线最密集的2个地方就是全连接层,这很明显的可以看出全连接层的参数的确很多。在前向计算过程,也就是一个线性的加权求和的过程,全连接层的每一个输出都可以看成前一层的每一个结点乘以...
  • 本文借鉴了DenseNet的思想,提出了一种密集连接的带有注意力机制的循环网络结构(DRCN)。网络中每一的输入均由当前的特征表示、attention表示、上一的隐藏输出表示三部分拼接构成,并引入了自编码结构来解决...
  • 对于卷积神经网络中全连接层的理解

    万次阅读 多人点赞 2018-06-11 15:20:09
    连接层的前向计算下图中连线最密集的2个地方就是全连接层,这很明显的可以看出全连接层的参数的确很多。在前向计算过程,也就是一个线性的加权求和的过程,全连接层的每一个输出都可以看成前一层的每一个结点乘以...
  • Based Action Recognition来源作者单位会议论文地址代码江南大学ICCV 2019暂无创新点引入了空间残差来捕获和融合时空特征在先前的工作中,时...
  • 前言在计算机视觉领域,卷积神经网络(CNN)已经成为最主流的方法,比如最近的GoogLenet...ResNet模型的核心是通过建立前面与后面之间的“短路连接”(shortcuts,skip connection),这有助于训练过程中梯度的反向...
  • 近几年来,随着卷积神经网络(CNNs...但随着网络数的加深,网络在训练过程中的前传信号和梯度信号在经过很多之后可能会逐渐消失。先前有一些非常好的工作来解决这一问题。如在 Highway 和 ResNet 结构中均提出了...
  • 连接层(Fully Connected Layer)

    千次阅读 2019-04-25 21:33:17
    一.概述 全连接层的每一个结点都与上一层的所有结点相连,用来把...下图中连线最密集的2个地方就是全连接层,这很明显的可以看出全连接层的参数的确很多。在前向计算过程,也就是一个线性的加权求和的过程,全连接...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 294
精华内容 117
关键字:

密集连接层