TensorFlow之layers模块

  TensorFlow的layers模块提供用于深度学习的更高层次封装的API，利用它可以轻松地构建模型。tf.layers模块提供的方法有：

方法	说明
Input	用于实例化一个输入Tensor，作为神经网络的输入
average_pooling1d	一维平均池化层
average_pooling2d	二维平均池化层
average_pooling3d	三维平均池化层
batch_normalization	批量标准化层
conv1d	一维卷积层
conv2d	二维卷积层
conv2d_transpose	二维反卷积层
conv3d	三维卷积层
conv3d_transpose	三维反卷积层
dense	全连接层
dropout	Dropout层
flatten	Flatten层，把一个Tensor展平
max_pooling1d	一维最大池化层
max_pooling2d	二维最大池化层
max_pooling3d	三维最大池化层
separable_conv2d	二维深度可分离卷积层

Input

  tf.layers.Input(目前已更名为tf.keras.Input)这个方法用于输入数据，类似于tf.placeholder，相当于一个占位符，可以通过传入tensor参数来进行赋值：

Input(
    shape=None, batch_size=None, name=None,
    dtype=tf.float32, sparse=False, tensor=None)

• shape：可选参数，是一个由数字组成的元组或列表。这个shape比较特殊，它不包含batch_size，比如传入的shape为[32]，那么它会将shape转化为[?, 32]。
• batch_size：可选参数，代表输入数据的batch_size，可以是数字或者None。
• name：可选参数，输入层的名称。
• dtype：可选参数，元素的类型。
• sparse：可选参数，指定是否以稀疏矩阵的形式来创建placeholder。
• tensor：可选参数，如果指定的话，那么创建的内容便不再是一个placeholder，会用此Tensor初始化。

import tensorflow as tf

x = tf.keras.Input(shape=[32])
print(x)
y = tf.layers.dense(x, 16, activation=tf.nn.softmax)
print(y)

首先用Input方法初始化了一个placeholder，注意这时我们没有传入tensor参数。然后调用了dense方法构建了一个全连接网络，激活函数使用softmax。执行结果如下：

Tensor("input_1:0", shape=(?, 32), dtype=float32)
Tensor("dense/Softmax:0", shape=(?, 16), dtype=float32)

注意此时shape给我们做了转化，本来是[32]，结果转化成了[?, 32]，第一维代表batch_size。所以我们需要注意，在调用此方法时不需要去关心batch_size这一维。
  如果我们在初始化时传入一个Tensor：

import tensorflow as tf

data = tf.constant([1, 2, 3])
x = tf.keras.Input(tensor=data)
print(x)

执行结果如下，可以看到它可以自动计算出其shape和dtype：

Tensor("Const:0", shape=(3,), dtype=int32)

batch_normalization

  此方法是批量标准化的方法，对数据经过处理之后可以加快训练速度。

batch_normalization(
    inputs, axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True,
    beta_initializer=tf.zeros_initializer(), gamma_initializer=tf.ones_initializer(),
    moving_mean_initializer=tf.zeros_initializer(), moving_variance_initializer=tf.ones_initializer(),
    beta_regularizer=None, gamma_regularizer=None, beta_constraint=None, gamma_constraint=None,
    training=False, trainable=True, name=None, reuse=None, renorm=False, renorm_clipping=None,
    renorm_momentum=0.99, fused=None, virtual_batch_size=None, adjustment=None)

• inputs：输入数据。
• axis：可选参数，进行标准化操作时操作数据的维度。
• momentum：可选参数，动态均值的动量。
• epsilon：可选参数，大于0的小浮点数，用于防止除0错误。
• center：可选参数，若设为True，将会把beta作为偏置加上去，否则忽略参数beta。
• scale：可选参数，若设为True，则会乘以gamma，否则不使用gamma。
• beta_initializer：可选参数，beta权重的初始方法。
• gamma_initializer：可选参数，gamma的初始化方法。
• moving_mean_initializer：可选参数，动态均值的初始化方法。
• moving_variance_initializer：可选参数，动态方差的初始化方法。
• beta_regularizer: 可选参数，beta的正则化方法。
• gamma_regularizer: 可选参数，gamma的正则化方法。
• beta_constraint: 可选参数，加在beta上的约束项。
• gamma_constraint: 可选参数，加在gamma上的约束项。
• training：可选参数，返回结果是training模式。
• trainable：可选参数，布尔类型。如果为True，则将变量添加到GraphKeys.TRAINABLE_VARIABLES中。
• name：可选参数，层名称。
• reuse：可选参数，根据层名判断是否重复利用。
• renorm：可选参数，是否要用Batch Renormalization。
• renorm_clipping：可选参数，是否要用rmax、rmin、dmax来scalar Tensor。
• renorm_momentum：可选参数，用来更新动态均值和标准差的Momentum值。
• fused：可选参数，是否使用一个更快的、融合的实现方法。
• virtual_batch_size：可选参数，int类型数字，指定一个虚拟batch size。
• adjustment：可选参数，对标准化后的结果进行适当调整。详细用法参考https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization。

该函数的用法是在输入数据后面加一层batch_normalization即可：

x = tf.keras.Input(shape=[32])
x = tf.layers.batch_normalization(x)
y = tf.layers.dense(x, 20)

dense

  dense是全连接网络，layers模块提供了一个dense方法来实现此操作，定义在tensorflow/python/layers/core.py中：

dense(
    inputs, units, activation=None, use_bias=True, kernel_initializer=None,
    bias_initializer=tf.zeros_initializer(), kernel_regularizer=None,
    bias_regularizer=None, activity_regularizer=None, kernel_constraint=None,
    bias_constraint=None, trainable=True, name=None, reuse=None)

• inputs：输入数据。
• units：神经元的数量。
• activation：可选参数，如果为None，则是线性激活。
• use_bias：可选参数，是否使用偏置。
• kernel_initializer：可选参数，权重的初始化方法。如果为None，则使用默认的Xavier初始化方法。
• bias_initializer：可选参数，偏置的初始化方法。
• kernel_regularizer：可选参数，施加在权重上的正则项。
• bias_regularizer：可选参数，施加在偏置上的正则项。
• activity_regularizer：可选参数，施加在输出上的正则项。
• kernel_constraint：可选参数，施加在权重上的约束项。
• bias_constraint：可选参数，施加在偏置上的约束项。
• trainable：可选参数，布尔类型。如果为True，则将变量添加到GraphKeys.TRAINABLE_VARIABLES中。
• name：可选参数，卷积层的名称。
• reuse：可选参数，布尔类型。

该函数返回全连接网络处理后的Tensor。

import tensorflow as tf

x = tf.keras.Input(shape=[32])
print(x)
y1 = tf.layers.dense(x, 16, activation=tf.nn.relu)
print(y1)
y2 = tf.layers.dense(y1, 5, activation=tf.nn.sigmoid)
print(y2)

首先我们用Input定义了[?, 32]的输入数据，然后经过第一层全连接网络，此时指定了神经元个数为16，激活函数为relu。接着输出结果经过第二层全连接网络，此时指定了神经元个数为5，激活函数为sigmoid。执行结果如下，可以看到输出结果的最后一维度就等于神经元的个数：

Tensor("input_1:0", shape=(?, 32), dtype=float32)
Tensor("dense/Relu:0", shape=(?, 16), dtype=float32)
Tensor("dense_1/Sigmoid:0", shape=(?, 5), dtype=float32)

convolution

  convolution就是卷积，layers层提供了多个卷积方法，例如conv1d、conv2d和conv3d分别代表一维、二维、三维卷积。另外还有conv2d_transpose、conv3d_transpose，分别代表二维和三维反卷积，还有separable_conv2d方法代表二维深度可分离卷积。

conv2d(
    inputs, filters, kernel_size, strides=(1, 1), padding='valid', data_format='channels_last',
    dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer=None,
    bias_initializer=tf.zeros_initializer(), kernel_regularizer=None, bias_regularizer=None,
    activity_regularizer=None, kernel_constraint=None, bias_constraint=None,
    trainable=True, name=None, reuse=None)

• inputs：需要进行操作的输入数据。
• filters：输出通道的个数，即output_channels。
• kernel_size：卷积核大小，必须是一个数字(高和宽都是此数字)或者长度为2的列表(分别代表高、宽)。
• strides：可选参数，卷积步长，必须是一个数字(高和宽都是此数字)或者长度为2的列表(分别代表高、宽)。
• padding：可选参数，padding的模式，有valid和same两种，大小写不区分。
• data_format：可选参数，分为channels_last和channels_first两种模式，代表了输入数据的维度类型。如果是channels_last，那么输入数据的shape为(batch, height, width, channels)；如果是channels_first，那么输入数据的shape为(batch, channels, height, width)。
• dilation_rate：可选参数，卷积的扩张率。例如当扩张率为2时，卷积核内部就会有边距，3 * 3的卷积核就会变成5 * 5。
• activation：可选参数。如果为None，则是线性激活。
• use_bias：可选参数，是否使用偏置。
• kernel_initializer：可选参数，权重的初始化方法。如果为None，则使用默认的Xavier初始化方法。
• bias_initializer：可选参数，偏置的初始化方法。
• kernel_regularizer：可选参数，施加在权重上的正则项。
• bias_regularizer：可选参数，施加在偏置上的正则项。
• activity_regularizer：可选参数，施加在输出上的正则项。
• kernel_constraint：可选参数，施加在权重上的约束项。
• bias_constraint：可选参数，施加在偏置上的约束项。
• trainable：可选参数，布尔类型。如果为True，则将变量添加到GraphKeys.TRAINABLE_VARIABLES中。
• name：可选参数，卷积层的名称。
• reuse：可选参数，布尔类型。

该函数返回卷积后的Tensor。

import tensorflow as tf

x = tf.keras.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=2, padding='same')
print(y)

首先声明了一个[?, 20, 20, 3]的输入x，然后将其传给conv2d方法。filters设定为6，即输出通道为6；kernel_size为2，即卷积核大小为2 * 2；padding方式设置为same，那么输出结果的宽高和原来一定是相同的，结果如下：

Tensor("conv2d/BiasAdd:0", shape=(?, 20, 20, 6), dtype=float32)

如果我们让padding使用默认的valid模式：

import tensorflow as tf

x = tf.keras.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=2)
print(y)

执行结果如下所示，这是因为步长默认为1，卷积核大小为2 * 2，所以得到的结果的高宽即为(20 - (2 - 1)) * (20 - (2 - 1)) = 19 * 19：

Tensor("conv2d/BiasAdd:0", shape=(?, 19, 19, 6), dtype=float32)

对于卷积核的大小，我们可以传入一个列表：

import tensorflow as tf

x = tf.keras.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=[2, 3])
print(y)

执行结果如下：

Tensor("conv2d/BiasAdd:0", shape=(?, 19, 18, 6), dtype=float32)

这时卷积核的大小变成了2 * 3，即高为2，宽为3，结果就变成了[?, 19, 18, 6]。这是因为步长默认为1，卷积核大小为2 * 2，所以结果的高宽即为(20 - (2 - 1)) * (20 - (3 - 1)) = 19 * 18。
  对于步长，我们也可以传入一个列表：

import tensorflow as tf

x = tf.keras.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=[2, 3], strides=[2, 2])
print(y)

这时卷积核大小变成了2 * 3，步长变成了2 * 2，所以结果的高宽为ceil(20 - (2 - 1)) / 2 * ceil(20 - (3 - 1)) / 2 = 10 * 9，得到的结果即为[?, 10, 9, 6]：

Tensor("conv2d/BiasAdd:0", shape=(?, 10, 9, 6), dtype=float32)

我们还可以传入激活函数，或者禁用bias等操作：

import tensorflow as tf

x = tf.keras.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=2, activation=tf.nn.relu, use_bias=False)
print(y)

执行结果如下：

Tensor("conv2d/Relu:0", shape=(?, 19, 19, 6), dtype=float32)

  另外还有反卷积操作，反卷积顾名思义即卷积的反向操作，即输入卷积的结果，输出卷积前的结果：

import tensorflow as tf

x = tf.keras.Input(shape=[20, 20, 3])
y = tf.layers.conv2d_transpose(x, filters=6, kernel_size=2, strides=2)
print(y)

例如此处输入的图像高宽为20 * 20，经过卷积核为2，步长为2的反卷积处理，得到的结果高宽就变为了40 * 40，执行结果如下：

Tensor("conv2d_transpose/BiasAdd:0", shape=(?, 40, 40, 6), dtype=float32)

pooling

  pooling即池化层，layers模块提供了多个池化方法，这些池化方法都是类似的，包括max_pooling1d、max_pooling2d、max_pooling3d、average_pooling1d、average_pooling2d和average_pooling3d，分别代表一维、二维、三维、最大和平均池化方法，它们都定义在tensorflow/python/layers/pooling.py中。这里以max_pooling2d方法为例进行介绍：

max_pooling2d(
    inputs, pool_size, strides, padding='valid',
    data_format='channels_last', name=None)

• inputs: 需要池化的输入对象，必须是4维的。
• pool_size：池化窗口大小，必须是一个数字(高和宽都是此数字)或者长度为2的列表(分别代表高、宽)。
• strides：池化步长，必须是一个数字(高和宽都是此数字)或者长度为2的列表(分别代表高、宽)。
• padding：可选参数，padding的方法，可选valid或者same，大小写不区分。
• data_format：可选参数，分为channels_last和channels_first两种模式，代表了输入数据的维度类型。如果是channels_last，那么输入数据的shape为(batch, height, width, channels)；如果是channels_first，那么输入数据的shape为(batch, channels, height, width)。
• name：可选参数，池化层的名称。

该函数返回经过池化处理后的Tensor。

import tensorflow as tf

x = tf.keras.Input(shape=[20, 20, 3])
print(x)
y = tf.layers.conv2d(x, filters=6, kernel_size=3, padding='same')
print(y)
p = tf.layers.max_pooling2d(y, pool_size=2, strides=2)
print(p)

首先指定了输入x的shape为[20, 20, 3]，然后对其进行了卷积以及池化操作，最后得到池化后的结果。执行结果如下：

Tensor("input_1:0", shape=(?, 20, 20, 3), dtype=float32)
Tensor("conv2d/BiasAdd:0", shape=(?, 20, 20, 6), dtype=float32)
Tensor("max_pooling2d/MaxPool:0", shape=(?, 10, 10, 6), dtype=float32)

这里池化窗口的大小是2 * 2，步长也是2，所以原本卷积后的shape为[?, 20, 20, 6]，结果就变成了[?, 10, 10, 6]。

dropout

  dropout是指在深度学习网络的训练过程中，对于神经网络单元，按照一定的概率将其暂时从网络中丢弃，可以用来防止过拟合。layers模块提供了dropout方法来实现这一操作，定义在tensorflow/python/layers/core.py：

dropout(inputs, rate=0.5, noise_shape=None, seed=None, training=False, name=None)

• inputs：输入数据。
• rate：可选参数，即dropout rate。如果设置为0.1，则会丢弃10%的神经元。
• noise_shape：可选参数，int32类型的一维Tensor，它代表了dropout mask的shape。
• seed：可选参数，产生随机数的种子值。
• training：可选参数，布尔类型，代表是否标志为training模式。
• name：可选参数，dropout层的名称。

该函数返回经过dropout层之后的Tensor。

import tensorflow as tf

x = tf.keras.Input(shape=[32])
print(x)
y = tf.layers.dense(x, 16, activation=tf.nn.softmax)
print(y)
d = tf.layers.dropout(y, rate=0.2)
print(d)

这里我们使用dropout方法实现了droput操作，并制定dropout rate为0.2，最后输出结果的shape和原来是一致的：

Tensor("input_1:0", shape=(?, 32), dtype=float32)
Tensor("dense/Softmax:0", shape=(?, 16), dtype=float32)
Tensor("dropout/Identity:0", shape=(?, 16), dtype=float32)

flatten

  flatten方法可以对Tensor进行展平操作，定义在tensorflow/python/layers/core.py：

flatten(inputs, name=None)

参数inputs是输入数据，name是该层的名称，该函数返回展平后的Tensor。

import tensorflow as tf

x = tf.keras.Input(shape=[5, 6])
print(x)
y = tf.layers.flatten(x)
print(y)

这里输入数据的shape为[?, 5, 6]，经过flatten层之后，就会变成[?, 30]，也就是将除了第一维的数据维度相乘，对原Tensor进行展平：

Tensor("input_1:0", shape=(?, 5, 6), dtype=float32)
Tensor("flatten/Reshape:0", shape=(?, 30), dtype=float32)

如果第一维是一个已知数据的话，它依然进行同样的处理：

import tensorflow as tf

x = tf.placeholder(shape=[5, 6, 2], dtype=tf.float32)
print(x)
y = tf.layers.flatten(x)
print(y)

执行结果：

Tensor("Placeholder:0", shape=(5, 6, 2), dtype=float32)
Tensor("flatten/Reshape:0", shape=(5, 12), dtype=float32)