devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

CNN神经网络之一维卷积、二维卷积详解

作者：笔触狂放9 | 2024-06-08 11:04:44

赞

踩

卷积神经网络原一维数据网络结构,转二维的

作者：凌逆战

地址：https://www.cnblogs.com/LXP-Never/p/10763804.html

在看这两个函数之前，我们需要先了解一维卷积(conv1d)和二维卷积(conv2d)，二维卷积是将一个特征图在width和height两个方向进行滑动窗口操作，对应位置进行相乘求和；而一维卷积则只是在width或者height方向上进行滑动窗口并相乘求和。

一维卷积：tf.layers.conv1d()

一维卷积常用于序列数据，如自然语言处理领域。

  1. tf.layers.conv1d(
  2.     inputs,
  3.     filters,
  4.     kernel_size,
  5.     strides=1,
  6.     padding='valid',
  7.     data_format='channels_last',
  8.     dilation_rate=1,
  9.     activation=None,
  10.     use_bias=True,
  11.     kernel_initializer=None,
  12.     bias_initializer=tf.zeros_initializer(),
  13.     kernel_regularizer=None,
  14.     bias_regularizer=None,
  15.     activity_regularizer=None,
  16.     kernel_constraint=None,
  17.     bias_constraint=None,
  18.     trainable=True,
  19.     name=None,
  20.     reuse=None
  21. )

参数：[1]

  • inputs：张量数据输入，一般是[batch, width, length]
  • filters：整数，输出空间的维度，可以理解为卷积核(滤波器)的个数
  • kernel_size：单个整数或元组/列表，指定1D(一维，一行或者一列)卷积窗口的长度。
  • strides：单个整数或元组/列表，指定卷积的步长，默认为1
  • padding："SAME" or "VALID" (不区分大小写)是否用0填充，
      • SAME用0填充；
      • VALID不使用0填充，舍去不匹配的多余项。
  • activation：激活函数
  • ues_bias：该层是否使用偏差
  • kernel_initializer：卷积核的初始化
  • bias_initializer：偏置向量的初始化器
  • kernel_regularizer：卷积核的正则化项
  • bias_regularizer：偏置的正则化项
  • activity_regularizer：输出的正则化函数
  • reuse：Boolean，是否使用相同名称重用前一层的权重
  • trainable：Boolean，如果True，将变量添加到图collection中
  • data_format：一个字符串，一个channels_last(默认)或channels_first。输入中维度的排序。
      • channels_last：对应于形状的输入(batch, length, channels)
      • channels_first：对应于形状输入(batch, channels, length)
  • name = 取一个名字

返回值：

　　一维卷积后的张量，

例子

  1. import tensorflow as tf 
  2.  
  3. x = tf.get_variable(name="x", shape=[32, 512, 1024], initializer=tf.zeros_initializer)
  4. x = tf.layers.conv1d(
  5.     x,
  6.     filters=1,                    # 输出的第三个通道是1
  7.     kernel_size=512,            # 不用管它是多大，都不影响输出的shape
  8.     strides=1,
  9.     padding='same',
  10.     data_format='channels_last',
  11.     dilation_rate=1,
  12.     use_bias=True,
  13.     bias_initializer=tf.zeros_initializer())
  14.  
  15. print(x)            # Tensor("conv1d/BiasAdd:0", shape=(32, 512, 1), dtype=float32)

解析：

  1. 输入数据的维度为[batch, data_length, data_width]=[32, 512, 1024]，一般输入数据input第一维为batch_size，此处为32，意味着有32个样本，第二维度和第三维度分别表示输入的长和宽(512，1024)
  2. 一维卷积核是二维的，也有长和宽，长为卷积核的数量kernel_size=512，因为卷积核的数量只有一个，所以宽为输入数据的宽度data_width=1024，所以一维卷积核的shape为[512,1024]
  3. filteres是卷积核的个数，即输出数据的第三维度。filteres=1，第三维度为1
  4. 所以卷积后的输出数据大小为[32, 512, 1]

二维卷积：tf.layers.conv2d()

二维卷积常用于计算机视觉、图像处理领域

  1. tf.layers.conv2d(
  2.     inputs,
  3.     filters,
  4.     kernel_size,
  5.     strides=(1, 1),
  6.     padding='valid',
  7.     data_format='channels_last',
  8.     dilation_rate=(1, 1),
  9.     activation=None,
  10.     use_bias=True,
  11.     kernel_initializer=None,
  12.     bias_initializer=tf.zeros_initializer(),
  13.     kernel_regularizer=None,
  14.     bias_regularizer=None,
  15.     activity_regularizer=None,
  16.     kernel_constraint=None,
  17.     bias_constraint=None,
  18.     trainable=True,
  19.     name=None,
  20.     reuse=None
  21. )
参数：[4]
  • inputs：张量输入。一般是[batch, width, length，channel]
  • filters：整数，输出空间的维度，可以理解为卷积核(滤波器)的个数
  • kernel_size：2个整数或元组/列表，指定2D卷积窗口的高度和宽度。可以是单个整数，以指定所有空间维度的相同值。
  • strides：2个整数或元组/列表，指定卷积沿高度和宽度方向的步幅。可以是单个整数，以指定所有空间维度的相同值。
  • padding："SAME" or "VALID" (不区分大小写)是否用0填充，
      • SAME用0填充；
      • VALID不使用0填充，舍去不匹配的多余项。
  • data_format：字符串，"channels_last"(默认)或"channels_first"。输入中维度的排序。
      • channels_last：对应于具有形状的输入，(batch, height, width, channels)
      • channels_first：对应于具有形状的输入(batch, channels, height, width)
  • activation：激活函数
  • use_bias：Boolean， 该层是否使用偏差项
  • kernel_initializer：卷积核的初始化
  • bias_initializer：  偏置向量的初始化。如果为None，将使用默认初始值设定项
  • kernel_regularizer：卷积核的正则化项
  • bias_regularizer：  偏置矢量的正则化项
  • activity_regularizer：输出的正则化函数
  • trainable：Boolean，如果True，将变量添加到图collection中
  • name：图层的name
  • reuse：Boolean，是否使用相同名称重用前一层的权重
返回：

　　二维卷积后的张量

例子：

  1. import tensorflow as tf 
  2.  
  3. x = tf.get_variable(name="x", shape=[1, 3, 3, 5], initializer=tf.zeros_initializer)
  4. x = tf.layers.conv2d(
  5.     x,
  6.     filters=1,                    # 结果的第三个通道是1
  7.     kernel_size=[1, 1],            # 不用管它是多大，都不影响输出的shape
  8.     strides=[1, 1],
  9.     padding='same',
  10.     data_format='channels_last',
  11.     use_bias=True,
  12.     bias_initializer=tf.zeros_initializer())
  13.  
  14. print(x)            # shape=(1, 3, 3, 1)

解析：

  1. input输入是1张 3*3 大小的图片，图像通道数是5，输入shape=(batch, data_length， data_width， data_channel)
  2. kernel_size卷积核shape是 1*1，数量filters是1strides步长是[1,1]，第一维和第二维分别为长度方向和宽度方向的步长 = 1。
  3. 最后输出的shape为[1,3,3,1] 的张量，即得到一个3*3的feature map(batch，长，宽，输出通道数)
  4. 长和宽只和strides有关，最后一个维度 = filters。

卷积层中的输出大小计算

　　设输入图片大小W，Filter大小F*F，步长为S，padding为P，输出图片的大小为N：

N=W−F+2PS+1

　　向下取整后再加1。

在Tensoflow中，Padding有2个选型，'SAME'和'VALID' ，下面举例说明差别：

如果 Padding='SAME'，输出尺寸为： W / S(向上取整)

  1. import tensorflow as tf
  2.  
  3. input_image = tf.get_variable(shape=[64, 32, 32, 3], dtype=tf.float32, name="input", initializer=tf.zeros_initializer)
  4. conv0 = tf.layers.conv2d(input_image, 64, kernel_size=[3, 3], strides=[2, 2], padding='same')  # 32/2=16
  5. conv1 = tf.layers.conv2d(input_image, 64, kernel_size=[5, 5], strides=[2, 2], padding='same')  
  6. # kernel_szie不影响输出尺寸
  7. print(conv0)      # shape=(64, 16, 16, 64)
  8. print(conv1)      # shape=(64, 16, 16, 64)

如果 Padding='VALID'，输出尺寸为：(W - F + 1) / S

  1. import tensorflow as tf
  2.  
  3. input_image = tf.get_variable(shape=[64, 32, 32, 3], dtype=tf.float32, name="input", initializer=tf.zeros_initializer)
  4. conv0 = tf.layers.conv2d(input_image, 64, kernel_size=[3, 3], strides=[2, 2], padding='valid')  # (32-3+1)/2=15
  5. conv1 = tf.layers.conv2d(input_image, 64, kernel_size=[5, 5], strides=[2, 2], padding='valid')  # (32-5+1)/2=14
  6. print(conv0)      # shape=(64, 15, 15, 64)
  7. print(conv1)      # shape=(64, 14, 14, 64)

 1x1卷积核的作用，加深一层网络，提取更深特征，数据变维，

有效卷积(valid)、同维卷积(same)、完全卷积(full)

a = [1 2 3 4 5]   原数组
b = [8 7 6] 　　 卷积核数组 kernel

使用b作为卷积核对a数组做一维卷积运算的过程如下：

  1. 原数组：   0  0  1  2  3  4  5  0  0
  2. 卷积数组： 6  7  8
  3.             6  7  8
  4.                6  7  8
  5.                   6  7  8
  6.                      6  7  8
  7.                         6  7  8
  8.                            6  7  8
  9. -------------------------------------
  10. 结果：        44 65  86         有效卷积 (valid)
  11.           23 44 65  86 59      同维卷积 (same)
  12.       8   23 44 65  86 59 30   完全卷积 (full)

参考文献：

[1] tensorflow官方API tf.layers.conv1d

[2] tf.layers.conv1d函数解析(一维卷积)

[3] tf.layer.conv1d、conv2d、conv3d

[4] tensorflow官方API tf.layers.conv2d

  1. import tensorflow as tf
  2.  
  3. # case 2
  4. input = tf.Variable(tf.random_normal([1, 3, 3, 5]))
  5. filter = tf.Variable(tf.random_normal([1, 1, 5, 1]))
  6. op2 = tf.nn.conv2d(input, filter, strides=[1, 1, 1, 1], padding='VALID')  # (1, 3, 3, 1)
  7. # case 3
  8. input = tf.Variable(tf.random_normal([1, 3, 3, 5]))
  9. filter = tf.Variable(tf.random_normal([3, 3, 5, 1]))
  10. op3 = tf.nn.conv2d(input, filter, strides=[1, 1, 1, 1], padding='VALID')  # (1, 1, 1, 1)
  11. # case 4
  12. input = tf.Variable(tf.random_normal([1, 5, 5, 5]))
  13. filter = tf.Variable(tf.random_normal([3, 3, 5, 1]))
  14. op4 = tf.nn.conv2d(input, filter, strides=[1, 1, 1, 1], padding='VALID')  # (1, 3, 3, 1)
  15. # case 5
  16. input = tf.Variable(tf.random_normal([1, 5, 5, 5]))
  17. filter = tf.Variable(tf.random_normal([3, 3, 5, 1]))
  18. op5 = tf.nn.conv2d(input, filter, strides=[1, 1, 1, 1], padding='SAME')  # (1, 5, 5, 1)
  19. # case 6
  20. input = tf.Variable(tf.random_normal([1, 5, 5, 5]))
  21. filter = tf.Variable(tf.random_normal([3, 3, 5, 7]))
  22. op6 = tf.nn.conv2d(input, filter, strides=[1, 1, 1, 1], padding='SAME')  # (1, 5, 5, 7)
  23. # case 7
  24. input = tf.Variable(tf.random_normal([1, 5, 5, 5]))
  25. filter = tf.Variable(tf.random_normal([3, 3, 5, 7]))
  26. op7 = tf.nn.conv2d(input, filter, strides=[1, 2, 2, 1], padding='SAME')  # (1, 3, 3, 7)
  27. # case 8
  28. input = tf.Variable(tf.random_normal([10, 5, 5, 5]))
  29. filter = tf.Variable(tf.random_normal([3, 3, 5, 7]))
  30. op8 = tf.nn.conv2d(input, filter, strides=[1, 2, 2, 1], padding='SAME')  # (10, 3, 3, 7)
  31.  
  32. init = tf.global_variables_initializer()
  33. with tf.Session() as sess:
  34.     sess.run(init)
  35.     print("case 2")
  36.     print(sess.run(op2).shape)  # (1, 3, 3, 1)
  37.     print("case 3")
  38.     print(sess.run(op3).shape)  # (1, 1, 1, 1)
  39.     print("case 4")
  40.     print(sess.run(op4).shape)  # (1, 3, 3, 1)
  41.     print("case 5")
  42.     print(sess.run(op5).shape)  # (1, 5, 5, 1)
  43.     print("case 6")
  44.     print(sess.run(op6).shape)  # (1, 5, 5, 7)
  45.     print("case 7")
  46.     print(sess.run(op7).shape)  # (1, 3, 3, 7)
  47.     print("case 8")
  48.     print(sess.run(op8).shape)  # (10, 3, 3, 7)
View Code
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/689554
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号