4.1 Tensorflow:卷积函数

卷积

卷积神经网络的结构

其中,input为输入,conv为卷积层,由卷积核构成,pool为池层,由池化函数构成最后是全连接层与输出层,其负责对卷积层提取的特征进行处理以获得我们需要的结果
###卷积函数
卷积函数是本篇文章要讲解的内容,在TensorFlow中卷积函数输入的参数其输入参数
主要有input, filter, strides, padding, use_cudnn_on_gpu=None,data_format=None, name=None)
其中

1. input 为输入,一个张量Tensor ,数据类型必须为float32 或者 float64
2. filter 为卷积核,输入类型必须与input一样
3. padding为一个字符串取值 SAME为补零使输入输出的图像大小相同,取值VALLD则允许输入输出的图像大小不一致
4. name,可选,字符串,用于可视化中,为该操作起一个名字
5. strides 是另外一个极其重要的参数,其为一个长度为4 的一维整数类型数组,每一位对应input中每一位对应的移动步长

Input

Input的张量维度:[batch,in_height,in_width,in_channels],例如mnist中的输入图像为 28 * 28 的黑白图像,其张量即为[batch,28,28,1],1代表黑白,RGB彩色图像的通道则为3,而batch 则为输入的图像数量,一次输入10张图片时,其为10,20张时则为20
###filter 卷积核
filter 即为CNN中的卷积核，以我们最常用的tf.nn.conv2d为例 .它要求是一个Tensor，具有[filter_height, filter_width, in_channels, out_channels]这样的shape，(其他的卷积函数其Tensor的具体内容是不一样的,在使用时请注意他们的不同)
tf.nn.conv2d中[filter_height, filter_width, in_channels, channel_multiplierl] 含义为[卷积核的高度，卷积核的宽度，图像通道数，卷积核个数]，要求类型与参数input相同，有一个地方需要注意，第三维in_channels，就是参数input的第四维.

在使用中,因为一般不对Input的第一维和第四维进行卷积操作,所以strides 一般为[1,X,X,1]

strides

正如前面所述,strides 是另外一个极其重要的参数,其为一个长度为4 的一维整数类型数组,每一位对应input中每一位对应的移动步长.
步长为一的卷积操作,不补零:

步长为二的卷积操作,不补零:

padding 与步长

padding=‘SAME’ 时,TensorFlow会自动对原图像进行补零,从而使输入输出的图像大小一致
效果如下:

padding=‘VALLLD’ 时,则会缩小原图像的大小.

输入输出图像大小的计算

此段内容引自我翻译的一篇文章
上面的内容可能会使你混淆每一层的输出尺寸。 所以我决定使用下面的内容让你能够识别输出尺寸。 在卷积层中,有三个关键控制着输出尺寸的大小

1. 过滤器的数量 ——输出音量的深度就等于滤波器应用的数量。 每个滤波器(卷积核)可以输出一个图片,卷积核增加,输出图片的数量增加
   
2. 步长 ——控制着卷积核向下移动的像素值。 高步值长时我们跨过的像素值,因此产生较小的输出量。
3. 补零 ——这有助于我们保持输入图像的大小。 如果只在原始图像周围添加一个补零的层数,并且步长为一,那么输出将保留原始图像的大小。

我们可以应用一个简单的公式来计算输出尺寸。 输出图像的空间大小可以计算**(W-F + 2 p / S)+ 1。 这里,W是输入图片大小,F是卷积核的大小,P是填充应用的数量和S是步长的数量**。 假设我们有一个输入图像的大小32 * 32 * 3,我们应用10过滤器的大小3 * 3 * 3,与单步和补零。

W = 32,F = 3,P = 0和S = 1。 输出深度等于过滤器应用的数量即10。

输出音量的大小将(32-3 + 0)/ 1 + 1 = 30。 因此,输出音量将30 * 30 * 10。

##TensorFlow中常用的卷积函数

tf.nn.conv2d

tf.nn.conv2d:对一个思维的输入数据 input 和四维的卷积核filter 进行操作,然后对输入的数据进行二维的卷积操作,得到卷积之后的结果,也是我们最常用的卷积函数

示例代码:

input_data = tf.Variable(np.random.rand(10, 9, 9, 3), dtype=np.float32)
filter_data = tf.Variable(np.random.rand(2, 2, 3, 2), dtype=np.float32)
y = tf.nn.conv2d(input_data, filter_data, strides=[1, 1, 1, 1], padding='SAME')

print('tf.nn.conv2d : ', y)
# tf.nn.conv2d :  Tensor("Conv2D:0", shape=(10, 9, 9, 2), dtype=float32)
# 在padding='SAME'时输入输出的图像大小是一致的

tf.nn.depthwise_conv2d

1. input 的数据维度 [batch ,in_height,in_wight,in_channels]
2. 卷积核的维度是 [filter_height,filter_heught,in_channel,channel_multiplierl]
3. 讲不通的卷积和独立的应用在in_channels 的每一个通道上(从通道 1 到通道channel_multiplier)
4. 然后将所有结果进行汇总,输出通道的总数是,in_channel * channel_multiplier

代码如下

input_data = tf.Variable(np.random.rand(10, 9, 9, 3), dtype=np.float32)
filter_data = tf.Variable(np.random.rand(2, 2, 3, 2), dtype=np.float32)

y = tf.nn.depthwise_conv2d(input_data, filter_data, strides=[1, 1, 1, 1], padding='SAME')
print('tf.nn.depthwise_conv2d : ', y)

# tf.nn.depthwise_conv2d :  Tensor("depthwise:0", shape=(10, 9, 9, 6), dtype=float32)
# 输出的通道数增加了

其效果类似于多个卷积核运算都是张量的一个维度增加,不同之处在于通道数的增加是卷积核在不同通道上运算的结果,而多个卷积核运算是batch的数量增加

##完整的示例CODE

# - * - coding: utf - 8 -*-
import tensorflow as tf
import os
import numpy as np

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

# tf.nn.convolution
# 计算N维卷积的和

input_data = tf.Variable(np.random.rand(10, 9, 9, 3), dtype=np.float32)
filter_data = tf.Variable(np.random.rand(2, 2, 3, 2), dtype=np.float32)
y = tf.nn.convolution(input_data, filter_data, strides=[1, 1], padding='SAME')

print('1. tf.nn.convolution : ', y)
# 1. tf.nn.convolution :  Tensor("convolution:0", shape=(10, 9, 9, 2), dtype=float32)


# tf.nn.conv2d
# 对一个思维的输入数据 input 和四维的卷积核filter 进行操作,然后对输入的数据进行二维的卷积操作,得到卷积之后的结果
input_data = tf.Variable(np.random.rand(10, 9, 9, 3), dtype=np.float32)
filter_data = tf.Variable(np.random.rand(2, 2, 3, 2), dtype=np.float32)
y = tf.nn.conv2d(input_data, filter_data, strides=[1, 1, 1, 1], padding='SAME')

print('2. tf.nn.conv2d : ', y)
#2. tf.nn.conv2d :  Tensor("Conv2D:0", shape=(10, 9, 9, 2), dtype=float32)

# tf.nn.depthwise_conv2d
# input 的数据维度 [batch ,in_height,in_wight,in_channels]
# 卷积核的维度是 [filter_height,filter_heught,in_channel,channel_multiplierl]
# 讲不通的卷积和独立的应用在in_channels 的每一个通道上(从通道 1 到通道channel_multiplier)
# 然后将所有结果进行汇总,输出通道的总数是,in_channel * channel_multiplier

input_data = tf.Variable(np.random.rand(10, 9, 9, 3), dtype=np.float32)
filter_data = tf.Variable(np.random.rand(2, 2, 3, 2), dtype=np.float32)

y = tf.nn.depthwise_conv2d(input_data, filter_data, strides=[1, 1, 1, 1], padding='SAME')
print('3. tf.nn.depthwise_conv2d : ', y)

# tf.nn.separable_conv2d
# 利用几个分离的卷积核去做卷积,在该函数中,将应用一个二维的卷积核,在每个通道上,以深度channel_multiplier进行卷积
input_data = tf.Variable(np.random.rand(10, 9, 9, 3), dtype=np.float32)
depthwise_filter = tf.Variable(np.random.rand(2, 2, 3, 5), dtype=np.float32)
poinwise_filter = tf.Variable(np.random.rand(1, 1, 15, 20), dtype=np.float32)
# out_channels >= channel_multiplier * in_channels
y = tf.nn.separable_conv2d(input_data, depthwise_filter=depthwise_filter, pointwise_filter=poinwise_filter,
                           strides=[1, 1, 1, 1], padding='SAME')
print('4. tf.nn.separable_conv2d : ', y)

# 计算Atrous卷积,又称孔卷积或者扩张卷积
input_data = tf.Variable(np.random.rand(1, 5, 5, 1), dtype=np.float32)
filters = tf.Variable(np.random.rand(3, 3, 1, 1), dtype=np.float32)
y = tf.nn.atrous_conv2d(input_data, filters, 2, padding='SAME')
print('5. tf.nn.atrous_conv2d : ', y)

# 在解卷积网络(deconvolutional network) 中有时被称为'反卷积',但实际上是conv2d的转置,而不是实际的反卷积
x = tf.random_normal(shape=[1, 3, 3, 1])
kernal = tf.random_normal(shape=[2, 2, 3, 1])
y = tf.nn.conv2d_transpose(x, kernal, output_shape=[1, 5, 5, 3], strides=[1, 2, 2, 1], padding='SAME')
print('6. tf.nn.conv2d_transpose : ', y)

# 与二维卷积类似,用来计算给定三维输入和过滤器的情况下的一维卷积.
# 不同的是,它的输入维度为 3,[batch,in_width,in_channels].
# 卷积核的维度也是三维,[filter_height,in_channel,channel_multiplierl]
# stride 是一个正整数,代表一定每一步的步长
input_data = tf.Variable(np.random.rand(1, 5, 1), dtype=np.float32)
filters = tf.Variable(np.random.rand(3, 1, 3), dtype=np.float32)
y = tf.nn.conv1d(input_data, filters, stride=2, padding='SAME')
print('7. tf.nn.conv1d : ', y)

# 与二维卷积类似,用来计算给定五维输入和过滤器的情况下的三维卷积.
# 不同的是,它的输入维度为 5,[batch,in_depth,in_height,in_width,in_channels].
# 卷积核的维度也是三维,[filter_depth,filter_height,in_channel,channel_multiplierl]
# stride 相较二维卷积多了一维,变为[strides_batch,strides_depth,strides_height,strides_width,strides_channel],必须保证strides[0] = strides[4] =1
input_data = tf.Variable(np.random.rand(1, 2, 5, 5, 1), dtype=np.float32)
filters = tf.Variable(np.random.rand(2, 3, 3, 1, 3), dtype=np.float32)
y = tf.nn.conv3d(input_data, filters, strides=[1, 2, 2, 1, 1], padding='SAME')
print('8. tf.nn.conv3d : ', y)

# 与conv2d_transpose 二维反卷积类似
# 在解卷积网络(deconvolutional network) 中有时被称为'反卷积',但实际上是conv3d的转置,而不是实际的反卷积
x = tf.random_normal(shape=[2, 1, 3, 3, 1])
kernal = tf.random_normal(shape=[2, 2, 2, 3, 1])
y = tf.nn.conv3d_transpose(x, kernal, output_shape=[2, 1, 5, 5, 3], strides=[1, 2, 2, 2, 1], padding='SAME')
print('9. tf.nn.conv3d_transpose : ', y)

RUN

1. tf.nn.convolution :  Tensor("convolution:0", shape=(10, 9, 9, 2), dtype=float32)
2. tf.nn.conv2d :  Tensor("Conv2D:0", shape=(10, 9, 9, 2), dtype=float32)
3. tf.nn.depthwise_conv2d :  Tensor("depthwise:0", shape=(10, 9, 9, 6), dtype=float32)
4. tf.nn.separable_conv2d :  Tensor("separable_conv2d:0", shape=(10, 9, 9, 20), dtype=float32)
5. tf.nn.atrous_conv2d :  Tensor("convolution_1/BatchToSpaceND:0", shape=(1, 5, 5, 1), dtype=float32)
6. tf.nn.conv2d_transpose :  Tensor("conv2d_transpose:0", shape=(1, 5, 5, 3), dtype=float32)
7. tf.nn.conv1d :  Tensor("conv1d/Squeeze:0", shape=(1, 3, 3), dtype=float32)
8. tf.nn.conv3d :  Tensor("Conv3D:0", shape=(1, 1, 3, 5, 3), dtype=float32)
9. tf.nn.conv3d_transpose :  Tensor("conv3d_transpose:0", shape=(2, 1, 5, 5, 3), dtype=float32)