【深度学习】Dilated/Atrous conv 空洞卷积/多孔卷积

最新推荐文章于 2024-04-24 12:00:04 发布
最新推荐文章于 2024-04-24 12:00:04 发布
阅读量567 收藏 2
点赞数 1
分类专栏： 深度学习

DilatedDilated可以叫空洞卷积或者扩张卷积。

空洞卷积诞生于图像分割领域，图像输入到网络中经过CNNCNN横空出世。

在讲空洞卷积都会用到原论文中的一张图来说明
这里写图片描述

在空洞卷积中有个重要的参数叫raterate，这个参数代表了空洞的大小。
要理解空洞概念和如何操作可以从两个角度去看。
1）从原图角度，所谓空洞就是在原图上做采样。采样的频率是根据rate参数来设置的，当rate为1时候，就是原图不丢失任何信息采样，此时卷积操作就是标准的卷积操作，当rate>1，比如2的时候，就是在原图上每隔一（rate-1）个像素采样，如图b，可以把红色的点想象成在原图上的采样点，然后将采样后的图像与kernel做卷积，这样做其实变相增大了感受野。
2）从kernel角度去看空洞的话就是扩大kernel的尺寸，在kernel中，相邻点之间插入rate-1个零，然后将扩大的kernel和原图做卷积 ，这样还是增大了感受野。

在VGG网络中就证明了使用小卷积核叠加来取代大卷积核可以起到减少参数同时达到大卷积核同样大小感受野的功效。但是通过叠加小卷积核来扩大感受野只能线性增长，公式为(kernelSize−1)∗layers+1(kernelSize−1)∗layers+1,，也就是线性增长，而空洞卷积可以以指数级增长感受野。

标准卷积方式
标准卷积

空洞卷积方式
这里写图片描述
空洞卷积在全卷积网络（FCN）（FCN），当它和双线性插值一起使用时可以替代转置卷积。空洞卷积可以在kernel有效增大感受野的同时不增加模型参数或者计算量。在图像需要全局信息或者语音文本需要较长的sequence信息依赖的问题中，都能较好的应用空洞卷积。在图像分割，语音合成WaveNet，机器翻译ByteNet中都有空洞卷积的身影。

在之前的一篇博文中，我稍微总结了deconv/转置卷积概念和用法，现在把deconv和Dilated conv在一起比较一下。

deconvdeconv为1）。

对于标准的k*k的卷积核，stridestride，分三种情况分析：

1）s>1s>1操作扩大原图，然后再卷积，这样得到的结果图会变大。

DilatedDilated填充扩大后来卷积，以达到增大感受野的效果。

在TensorflowTensorflow。

tf.nn.atrous__conv2dtf.nn.atrous__conv2d

在tf.nn.conv2d函数中有一个参数叫dilations，同样可以是可以实现空洞卷积的效果在tf.nn.conv2d函数中有一个参数叫dilations，同样可以是可以实现空洞卷积的效果

2018/4/2更新：

在实际使用中发现atrous_conv2d和conv2d对于空洞后卷积输出的shape描述不清楚，自己搜资料发现输出的shape不光和padding有关，还与rate有关。输出shape计算思路如下，首先看padding，如果padding是SAME，那么不管rate是多少，都按照这里写图片描述这个来算。如果padding是VALID，那么也是按照这里写图片描述这个来算，只不过这儿的filter_size需要根据rate来重新算，也就是说空洞是加在卷积核上的，我们先对卷积核填充0，得到新的卷积核大小filter_height = heght+(height-1)*(rate-1),宽同理。将新的filter送到上面VALID模式下计算卷积输出就是最后的输出了。实际代码输出感受下

import tensorflow as tf
import numpy as np

input_img_np = np.random.random((1, 256, 256, 1)).astype(np.float32)
kernel =  np.random.random((6,6,1,1)).astype(np.float32)

with tf.Session() as sess:
    concrete_input_op = tf.constant(input_img_np)
    concrete_output_op = tf.nn.convolution(concrete_input_op, kernel, padding='SAME', dilation_rate=np.array([2, 2]))
    concrete_output = sess.run(concrete_output_op)

    print('convolution + CONCRETE + SAME')
    print('concrete_input_op: ', concrete_input_op.get_shape())
    print('concrete_output_op: ', concrete_output_op.get_shape())
    print('concrete_output:', concrete_output.shape)
    assert(concrete_input_op.get_shape() == concrete_output_op.get_shape())


    undef_input_op = tf.placeholder(tf.float32, shape=(None, 256, 256, 1))
    undef_output_op = tf.nn.convolution(undef_input_op, kernel, padding='SAME', dilation_rate=np.array([2, 2]))
    undef_output = sess.run(undef_output_op, feed_dict={undef_input_op: input_img_np})

    print('convolution + UNDEF + SAME')
    print('undef_input_op: ', undef_input_op.get_shape())
    print('undef_output_op: ', undef_output_op.get_shape())
    print('undef_output:', undef_output.shape)
    # This assert will correctly fail even though the shapes are ok because shapes are only partially known
    # assert(undef_input_op.get_shape() == undef_output_op.get_shape())

    valid_concrete_input_op = tf.constant(input_img_np)
    valid_concrete_output_op = tf.nn.convolution(valid_concrete_input_op, kernel, padding='VALID', dilation_rate=np.array([2, 2]))
    valid_concrete_output = sess.run(valid_concrete_output_op)

    print('convolution + CONCRETE + VALID')
    print('valid_concrete_input_op: ', valid_concrete_input_op.get_shape())
    print('valid_concrete_output_op: ', valid_concrete_output_op.get_shape())
    print('valid_concrete_output:', valid_concrete_output.shape)


    valid_undef_input_op = tf.placeholder(tf.float32, shape=(None, 256, 256, 1))
    valid_undef_output_op = tf.nn.convolution(valid_undef_input_op, kernel, padding='VALID', dilation_rate=np.array([2, 2]))
    valid_undef_output = sess.run(valid_undef_output_op, feed_dict={valid_undef_input_op: input_img_np})

    print('convolution + UNDEF + VALID')
    print('valid_undef_input_op: ',  valid_undef_input_op.get_shape())
    print('valid_undef_output_op: ', valid_undef_output_op.get_shape())
    print('valid_undef_output:', valid_undef_output.shape)
    # This assert will correctly fail even though the shapes are ok because shapes are only partially known
    # assert(undef_input_op.get_shape() == undef_output_op.get_shape())
    ############################################################################
    # Now atrous
    concrete_input_op = tf.constant(input_img_np)
    concrete_output_op = tf.nn.atrous_conv2d(concrete_input_op, kernel, padding='SAME', rate=2)
    concrete_output = sess.run(concrete_output_op)

    print('atrous_conv2d + CONCRETE + SAME')
    print('concrete_input_op: ', concrete_input_op.get_shape())
    print('concrete_output_op: ', concrete_output_op.get_shape())
    print('concrete_output_op: ', concrete_output_op.get_shape())
    print('concrete_output:', concrete_output.shape)
    assert(concrete_input_op.get_shape() == concrete_output_op.get_shape())


    undef_input_op = tf.placeholder(tf.float32, shape=(None, 256, 256, 1))
    undef_output_op = tf.nn.atrous_conv2d(undef_input_op, kernel, padding='SAME', rate=2)
    undef_output = sess.run(undef_output_op, feed_dict={undef_input_op: input_img_np})

    print('atrous_conv2d + UNDEF + SAME')
    print('undef_input_op: ', undef_input_op.get_shape())
    print('undef_output_op: ', undef_output_op.get_shape())
    print('undef_output:', undef_output.shape)
    # This assert will correctly fail even though the shapes are ok because shapes are only partially known
    # assert(undef_input_op.get_shape() == undef_output_op.get_shape())

    valid_concrete_input_op = tf.constant(input_img_np)
    valid_concrete_output_op = tf.nn.atrous_conv2d(valid_concrete_input_op, kernel, padding='VALID', rate=2)
    valid_concrete_output = sess.run(valid_concrete_output_op)

    print('atrous_conv2d + CONCRETE + VALID')
    print('valid_concrete_input_op: ', valid_concrete_input_op.get_shape())
    print('valid_concrete_output_op: ', valid_concrete_output_op.get_shape())
    print('valid_concrete_output:', valid_concrete_output.shape)


    valid_undef_input_op = tf.placeholder(tf.float32, shape=(None, 256, 256, 1))
    valid_undef_output_op = tf.nn.atrous_conv2d(valid_undef_input_op, kernel, padding='VALID', rate=2)
    valid_undef_output = sess.run(valid_undef_output_op, feed_dict={valid_undef_input_op: input_img_np})

    print('atrous_conv2d + UNDEF + VALID')
    print('valid_undef_input_op: ',  valid_undef_input_op.get_shape())
    print('valid_undef_output_op: ', valid_undef_output_op.get_shape())
    print('valid_undef_output:', valid_undef_output.shape)
    # This assert will correctly fail even though the shapes are ok because shapes are only partially known
    # assert(undef_input_op.get_shape() == undef_output_op.get_shape())
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
convolution + CONCRETE + SAME
('concrete_input_op: ', TensorShape([Dimension(1), Dimension(256), Dimension(256), Dimension(1)]))
('concrete_output_op: ', TensorShape([Dimension(1), Dimension(256), Dimension(256), Dimension(1)]))
('concrete_output:', (1, 256, 256, 1))
convolution + UNDEF + SAME
('undef_input_op: ', TensorShape([Dimension(None), Dimension(256), Dimension(256), Dimension(1)]))
('undef_output_op: ', TensorShape([Dimension(None), Dimension(256), Dimension(256), Dimension(1)]))
('undef_output:', (1, 256, 256, 1))
convolution + CONCRETE + VALID
('valid_concrete_input_op: ', TensorShape([Dimension(1), Dimension(256), Dimension(256), Dimension(1)]))
('valid_concrete_output_op: ', TensorShape([Dimension(1), Dimension(246), Dimension(246), Dimension(1)]))
('valid_concrete_output:', (1, 246, 246, 1))
convolution + UNDEF + VALID
('valid_undef_input_op: ', TensorShape([Dimension(None), Dimension(256), Dimension(256), Dimension(1)]))
('valid_undef_output_op: ', TensorShape([Dimension(None), Dimension(246), Dimension(246), Dimension(1)]))
('valid_undef_output:', (1, 246, 246, 1))
atrous_conv2d + CONCRETE + SAME
('concrete_input_op: ', TensorShape([Dimension(1), Dimension(256), Dimension(256), Dimension(1)]))
('concrete_output_op: ', TensorShape([Dimension(1), Dimension(256), Dimension(256), Dimension(1)]))
('concrete_output_op: ', TensorShape([Dimension(1), Dimension(256), Dimension(256), Dimension(1)]))
('concrete_output:', (1, 256, 256, 1))
atrous_conv2d + UNDEF + SAME
('undef_input_op: ', TensorShape([Dimension(None), Dimension(256), Dimension(256), Dimension(1)]))
('undef_output_op: ', TensorShape([Dimension(None), Dimension(None), Dimension(None), Dimension(1)]))
('undef_output:', (1, 256, 256, 1))
atrous_conv2d + CONCRETE + VALID
('valid_concrete_input_op: ', TensorShape([Dimension(1), Dimension(256), Dimension(256), Dimension(1)]))
('valid_concrete_output_op: ', TensorShape([Dimension(1), Dimension(246), Dimension(246), Dimension(1)]))
('valid_concrete_output:', (1, 246, 246, 1))
atrous_conv2d + UNDEF + VALID
('valid_undef_input_op: ', TensorShape([Dimension(None), Dimension(256), Dimension(256), Dimension(1)]))
('valid_undef_output_op: ', TensorShape([Dimension(None), Dimension(None), Dimension(None), Dimension(1)]))
('valid_undef_output:', (1, 246, 246, 1))
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

参考文献：

Tensorflow官方文档
知乎：如何理解空洞卷积（dilated convolution）？
https://github.com/tensorflow/tensorflow/issues/4742

张学渣
关注
专栏目录
【深度学习】空洞卷积（Atrous Convolution）
晓峰博客笔记
04-09 5万+
优点：在不做pooling损失信息和相同的计算条件下的情况下，加大了感受野，让每个卷积输出都包含较大范围的信息。空洞卷积经常用在实时图像分割中。当网络层需要较大的感受野，但计算资源有限而无法提高卷积核数量或大小时，可以考虑空洞卷积。 空洞卷积（dilated convolution）是针对图像语义分割问题中下采样会降低图像分辨率、丢失信息而提出的一种卷积思路。利用添加空洞扩大感受野，让原本3x3...
空洞卷积dilated conv
linsen333的博客
08-30 278
空洞卷积 a、b、c图卷积核均为3*3，图a和普通的卷积操作一样，a)图对应3x3的1-dilated conv，b)图对应3x3的2-dilated conv，2-dilated conv的前一层是一个1-dilated conv的话， 那么每个红点就是1-dilated的卷积输出，所以感受野为3x3，所以1-dilated和2-dilated合起来就能达到7x7的conv。c)图是4-dilated conv操作，同理跟在两个1-dilated和 2-dilated conv的后面，能达到15x15的感
Dilated/Atrous conv 空洞卷积/多孔卷积
热门推荐
silence2015的专栏
03-29 1万+
DilatedDilatedDilated convolution/Atrousconvolution/Atrousconvolution/Atrous convolutionconvolution convolution可以叫空洞卷积或者扩张卷积。 空洞卷积诞生于图像分割领域，图像输入到网络中经过CNNCNNCNN提取特征，再经过poolingpoolingpooling降低图像尺度的同时增大...
空洞卷积（扩张卷积，带孔卷积，atrous convolution）的一些总结与理解
lipengfei0427的博客
10-08 6180
空洞卷积（扩张卷积，带孔卷积，atrous convolution）是一种区别于普通卷积的卷积方式，从字面理解，就是卷积层中有洞。 1.一维理解 以一维为例： 图中(a)Input feature表示输入特征，Output feature表示输出特征，这是一个正常的kernel = 3; stride = 1; pad = 1的卷积操作。 图中(b)下面为Input feature，上面为Output feature，与图(a)不同的是pad = 2，同时引入了一个rate = 2，这个rate
Dilated/Atrous Convolution
tuzixini的博客
02-26 1767
Dilated Convolution(或者叫做 Atrous Convolution), 中文称作 空洞卷积/带孔卷积/扩张卷积/膨胀卷积/多孔卷积. 这些名称指的都是同一个意思,都是同一种操作. 为什么需要空洞卷积 在出现空洞卷积之前的CNN分割网络中,习惯于使用Pooling的方式降低图像的尺寸,同时增大网络的感受野.最后再使用Upsampling操作将图像的尺寸恢复到原始的大小,以得到像素...
深度学习基础--卷积--dilate convolution
wydbyxr的博客
11-14 1741
dilate convolution   虽然dilate conv可以增大感受野，不损失信息，但是先前的pooling层具有减小网络规模和参数的作用，较少特征冗余，防止过拟合的作用。 ...
Tensorflow tf.nn.atrous_conv2d如何实现空洞卷积的
12-20
空洞卷积（Dilated Convolution）是一种在卷积神经网络（CNN）中扩大感受野的有效方法，而无需使用池化...在TensorFlow中，`tf.nn.atrous_conv2d`提供了实现空洞卷积的接口，方便开发者在构建深度学习模型时灵活运用。
深度学习之空洞卷积
03-09
深度学习中的空洞卷积，也称为扩张卷积（Dilated Convolution），是一种在卷积神经网络（CNN）中用于图像处理和分析的技术。空洞卷积技术由Fisher Yu和Vladlen Koltun提出，并在2016年的ICLR（International ...
膨胀卷积 / 空洞卷积（Dilated convolution）
weixin_44223170的博客
03-28 2274
视频学习链接：[https://www.bilibili.com/video/BV1Bf4y1g7j8] 1. 认识膨胀卷积 r 为间隙，r = 1 时，就是普通卷积 2. 为什么要使用空洞卷积 提出原因： （1）maxpooling层，会降低特征层的高度和宽度，同时会导致丢失细节信息以及较小目标，丢失的信息和目标无法通过上采样操作进行还原。 （2）如果将maxpooling层去掉，会导致得到的特征图所对应原图的感受野变小 此时选用膨胀卷积，能够： （1）增大感受野 （2）保持原输入特征图的高度和宽度 3
空洞卷积（Atrous Convolution）
ywm_up
02-09 4970
优点：在不做 polling 损失信息和相同的计算条件下的情况下，增大了感受野，让每个卷积输出都包含较大范围的信息。空洞卷积经常应用在实时图像分割中。当网络层需要较大的感受野，但计算资源有限而无法提高卷积核数量或大小时，可以考虑空洞卷积。 空洞卷积（atrous convolutions）又称扩张卷积（dilated convolutions），是针对图像语义分割问题中下采样会降低图像分辨率、丢失信息而提出的一个卷积网络。利用添加空洞扩大感受野，让原本3×3的卷积核，在相同参数量核计算量下拥有5×5（d.
深度学习100问-19：什么是空洞卷积？
weixin_37737254的博客
03-01 1193
深度学习100问Author：louwillMachine Learning Lab 在系列第16问中我们就提到U-shape和空洞卷积在语义分割网络结构中两大经典设计...
深度探索：机器学习中的空洞卷积（Atrous Convolution）算法原理及其应用
最新发布
qq_51320133的博客
04-24 1540
空洞卷积作为一种有效的卷积操作变体，凭借其扩大感受野、保持空间分辨率及参数效率等优点，已在图像识别、语义分割、目标检测等多个领域展现出强大的应用潜力。尽管存在计算复杂度增加、对小物体敏感性下降等问题，但通过合理设置空洞率、结合其他先进组件（如残差连接、注意力机制等），以及硬件加速技术的发展，空洞卷积有望在未来的机器学习研究与应用中发挥更大作用。随着深度学习技术的持续演进，我们期待看到更多基于空洞卷积的创新模型和应用，进一步推动计算机视觉乃至整个机器学习领域的进步。
Pytorch之经典神经网络语义分割(3.1) —— 空洞卷积 Dilated conv/Atrous Conv (膨胀卷积/扩张卷积)(扩张率dilation rate) & pytorch实现
hxxjxw的博客
10-01 6201
使用Pascal VOC2012语义分割数据集 https://blog.csdn.net/qq_43280818/article/details/105916507
FCN(fully convolutional networks),RPN(Region Proposal Network),FPN(feature pyramid networks)反卷积和空洞卷积
weixin_42357472的博客
04-02 1769
FCN(fully convolutional networks 全卷积网络) RPN(Region Proposal Network 区域候选网络) FPN(feature pyramid networks 特征金字塔网络)
Atrous Convolution空洞卷积
03-29
Atrous Convolution，也叫做Dilated Convolution或者Spatially Atrous Convolution，是一种卷积神经网络中的操作，可以增加卷积核的感受野，从而在不增加参数数量的情况下提高网络的性能。 在传统的卷积操作中，卷积核大小和步长是固定的，无法改变。而在Atrous Convolution中，卷积核在进行卷积操作时会在空间上插入一些空洞（也就是dilation rate不为1），使得卷积核的感受野变大，可以覆盖更多的信息。 举个例子，假设我们有一个3x3的卷积核，如果步长为1，则每次卷积操作可以得到一个2x2的输出。但是如果我们在卷积核中插入一个空洞，则可以扩大卷积核的感受野，使得每次卷积操作可以得到一个3x3的输出。 Atrous Convolution在语义分割、图像生成等任务中得到了广泛的应用，可以有效地提高网络的性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值