tf.nn，tf.layers， tf.contrib概述：
我们在使用tensorflow时，会发现tf.nn，tf.layers， tf.contrib模块有很多功能是重复的，尤其是卷积操作，在使用的时候，我们可以根据需要现在不同的模块。但有些时候可以一起混用。 下面是对三个模块的简述： （1）tf.nn ：提供神经网络相关操作的支持，包括卷积操作（conv）、池化操作（pooling）、归一化、loss、分类操作、embedding、RNN、Evaluation。 （2）tf.layers：主要提供的高层的神经网络，主要和卷积相关的，个人感觉是对tf.nn的进一步封装，tf.nn会更底层一些。 （3）tf.contrib：tf.contrib.layers提供够将计算图中的 网络层、正则化、摘要操作、是构建计算图的高级操作，但是tf.contrib包含不稳定和实验代码，有可能以后API会改变。
以上三个模块的封装程度是逐个递进的。

tf.layers模块介绍：
Layers模块属于TensorFlow的一个稳定的中层API，其源码位于tensorflow/python/layers/layers.py，其官方文档地址为https://www.tensorflow.org/api_docs/python/tf/layers ref1

tf.layers这个中层API基本上可以算是tf.nn模块的抽象，可以极大地加快模型的构建速度。

tf.layers里面有很多封装好的类和函数。

tf.layers模块提供的API：
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(…): 二维深度可分离卷积层
1. input
tf.layers.Input() 这个方法是用于输入数据的方法，其实类似于 tf.placeholder，相当于一个占位符的作用，当然也可以通过传入 tensor 参数来进行赋值。Input这个类在1.8里面去除掉了。只能用tf.placeholder了, 所以在新版本中使用tf.placeholder是最好的选择

用法
Input(
    shape=None,
    batch_size=None,
    name=None,
    dtype=tf.float32,
    sparse=False,
    tensor=None
)
1
2
3
4
5
6
7
8
参数说明如下：
shape：可选，默认 None，是一个数字组成的元组或列表，但是这个 shape 比较特殊，它不包含 batch_size，比如传入的 shape 为 [32]，那么它会将 shape 转化为 [?, 32]，这里一定需要注意。
batch_size：可选，默认 None，代表输入数据的 batch size，可以是数字或者 None。
name：可选，默认 None，输入层的名称。
dtype：可选，默认 tf.float32，元素的类型。
sparse：可选，默认 False，指定是否以稀疏矩阵的形式来创建 placeholder。
tensor：可选，默认 None，如果指定，那么创建的内容便不再是一个 placeholder，会用此 Tensor 初始化。
返回值：
返回一个包含历史 Meta Data 的 Tensor。
实例:
x = tf.layers.Input(shape=[32])
print(x)
y = tf.layers.dense(x, 16, activation=tf.nn.softmax)
print(y)
1
2
3
4
首先我们用 Input() 方法初始化了一个 placeholder，这时我们没有传入 tensor 参数，然后调用了 dense() 方法构建了一个全连接网络，激活函数使用 softmax，然后将二者输出，结果如下：

Tensor("input_layer_1:0", shape=(?, 32), dtype=float32)
Tensor("dense/Softmax:0", shape=(?, 16), dtype=float32)
1
2
这时我们发现，shape 它给我们做了转化，本来是 [32]，结果它给转化成了 [?, 32]，即第一维代表 batch_size，所以我们需要注意，在调用此方法的时候不需要去关心 batch_size 这一维。

如果我们在初始化的时候传入一个已有 Tensor，例如：

data = tf.constant([1, 2, 3])
x = tf.layers.Input(tensor=data)
print(x)
1
2
3
结果如下：

Tensor("Const:0", shape=(3,), dtype=int32)
1
可以看到它可以自动计算出其 shape 和 dtype。

2. batch_normalization
此方法是批量标准化的方法，经过处理之后可以加速训练速度，其定义在 tensorflow/python/layers/normalization.py，论文可以参考：http://arxiv.org/abs/1502.03167“Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift”。

用法
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
)
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
参数说明如下：

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

实例
其用法很简单，在输入数据后面加一层 batch_normalization() 即可：
x = tf.layers.Input(shape=[32])
x = tf.layers.batch_normalization(x)
y = tf.layers.dense(x, 20)
1
2
3
3. 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
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
参数说明如下：

inputs：必需，即需要进行操作的输入数据。
units：必须，即神经元的数量。
activation：可选，默认为 None，如果为 None 则是线性激活。
use_bias：可选，默认为 True，是否使用偏置。
kernel_initializer：可选，默认为 None，即权重的初始化方法，如果为 None，则使用默认的 Xavier 初始化方法。
bias_initializer：可选，默认为零值初始化，即偏置的初始化方法。
kernel_regularizer：可选，默认为 None，施加在权重上的正则项。
bias_regularizer：可选，默认为 None，施加在偏置上的正则项。
activity_regularizer：可选，默认为 None，施加在输出上的正则项。
kernel_constraint，可选，默认为 None，施加在权重上的约束项。
bias_constraint，可选，默认为 None，施加在偏置上的约束项。
trainable：可选，默认为 True，布尔类型，如果为 True，则将变量添加到 GraphKeys.TRAINABLE_VARIABLES 中。
name：可选，默认为 None，卷积层的名称。
reuse：可选，默认为 None，布尔类型，如果为 True，那么如果 name 相同时，会重复利用。
返回值：
全连接网络处理后的 Tensor。

实例：

x = tf.layers.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)
1
2
3
4
5
6
首先我们用 Input 定义了 [?, 32] 的输入数据，然后经过第一层全连接网络，此时指定了神经元个数为 16，激活函数为 relu，接着输出结果经过第二层全连接网络，此时指定了神经元个数为 5，激活函数为 sigmoid，最后输出，结果如下：

Tensor("input_layer_1:0", shape=(?, 32), dtype=float32)
Tensor("dense/Relu:0", shape=(?, 16), dtype=float32)
Tensor("dense_2/Sigmoid:0", shape=(?, 5), dtype=float32)
1
2
3
可以看到输出结果的最后一维度就等于神经元的个数，这是非常容易理解的。

4. convolution
convolution，即卷积，这里提供了多个卷积方法，如 conv1d()、conv2d()、conv3d()，分别代表一维、二维、三维卷积，另外还有 conv2d_transpose()、conv3d_transpose()，分别代表二维和三维反卷积，还有 separable_conv2d() 方法代表二维深度可分离卷积。它们定义在 tensorflow/python/layers/convolutional.py 中，其用法都是类似的，在这里以 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
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
参数说明如下：

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

实例：

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=2, padding='same')
print(y)
1
2
3
这里我们首先声明了一个 [?, 20, 20, 3] 的输入 x，然后将其传给 conv2d() 方法，filters 设定为 6，即输出通道为 6，kernel_size 为 2，即卷积核大小为 2 x 2，padding 方式设置为 same，那么输出结果的宽高和原来一定是相同的，但是输出通道就变成了 6，结果如下：

Tensor("conv2d/BiasAdd:0", shape=(?, 20, 20, 6), dtype=float32)
1
但如果我们将 padding 方式不传入，使用默认的 valid 模式，代码改写如下：

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=2)
print(y)
1
2
3
结果如下：

Tensor("conv2d/BiasAdd:0", shape=(?, 19, 19, 6), dtype=float32)
1
结果就变成了 [?, 19, 19, 6]，这是因为步长默认为 1，卷积核大小为 2 x 2，所以得到的结果的高宽即为 [(20 - 2)/1 + 1)] x [(20 - 2)/1 + 1] = 19 x 19。

当然卷积核我们也可以变换大小，传入一个列表形式：

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=[2, 3])
print(y)
1
2
3
这时我们的卷积核大小变成了 2 x 3，即高为 2，宽为 3，结果就变成了 [?, 19, 18, 6]，这是因为步长默认为 1，卷积核大小为 2 x 2，所以得到的结果的高宽即为 [(20 - 2)/1 + 1)] x (20 - 3)/1 + 1)] = 19 x 18。

如果我们将步长也设置一下，也传入列表形式：

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=[2, 3], strides=[2, 2])
print(y)
1
2
3
这时卷积核大小变成了 2 x 3，步长变成了 2 x 2，所以结果的高宽为 [(20 - 2)/2 + 1)] x [(20 - 3)/2 + 1)] = 10 x 9，得到的结果即为 [?, 10, 9, 6]。

另外我们还可以传入激活函数，或者禁用 bias 等操作，实例如下：

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d(x, filters=6, kernel_size=2, activation=tf.nn.relu, use_bias=False)
print(y)
1
2
3
这样我们就将激活函数改成了 relu，同时禁用了 bias，运行结果如下：

Tensor("conv2d_5/Relu:0", shape=(?, 19, 19, 6), dtype=float32)
1
另外还有反卷积操作，反卷积顾名思义即卷积的反向操作，即输入卷积的结果，得到卷积前的结果，其参数用法是完全一样的，例如：

x = tf.layers.Input(shape=[20, 20, 3])
y = tf.layers.conv2d_transpose(x, filters=6, kernel_size=2, strides=2)
print(y)
1
2
3
例如此处输入的图像高宽为 20 x 20，经过卷积核为 2，步长为 2 的反卷积处理，得到的结果高宽就变为了 40 x 40，结果如下：

Tensor("conv2d_transpose/BiasAdd:0", shape=(?, 40, 40, 6), dtype=float32)
1
5. 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
)
1
2
3
4
5
6
7
8
参数说明如下：

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

实例

x = tf.layers.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)
1
2
3
4
5
6
在这里我们首先指定了输入 x，shape 为 [20, 20, 3]，然后对其进行了卷积计算，然后池化，最后得到池化后的结果。结果如下：

Tensor("input_layer_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)
1
2
3
可以看到这里池化窗口用的是 2，步长也是 2，所以原本卷积后 shape 为 [?, 20, 20, 6] 的结果就变成了 [?, 10, 10, 6]。

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

用法
dropout(
    inputs,
    rate=0.5,
    noise_shape=None,
    seed=None,
    training=False,
    name=None
)
1
2
3
4
5
6
7
8
参数说明如下：

inputs：必须，即输入数据。
rate：可选，默认为 0.5，即 dropout rate，如设置为 0.1，则意味着会丢弃 10% 的神经元。
noise_shape：可选，默认为 None，int32 类型的一维 Tensor，它代表了 dropout mask 的 shape，dropout mask 会与 inputs 相乘对 inputs 做转换，例如 inputs 的 shape 为 (batch_size, timesteps, features)，但我们想要 droput mask 在所有 timesteps 都是相同的，我们可以设置 noise_shape=[batch_size, 1, features]。
seed：可选，默认为 None，即产生随机熟的种子值。
training：可选，默认为 False，布尔类型，即代表了是否标志为 training 模式。
name：可选，默认为 None，dropout 层的名称。
返回：
经过 dropout 层之后的 Tensor。

实例：

x = tf.layers.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)
1
2
3
4
5
6
运行结果：

Tensor("input_layer_1:0", shape=(?, 32), dtype=float32)
Tensor("dense/Softmax:0", shape=(?, 16), dtype=float32)
Tensor("dropout/Identity:0", shape=(?, 16), dtype=float32)
1
2
3
在这里我们使用 dropout() 方法实现了 droput 操作，并制定 dropout rate 为 0.2，最后输出结果的 shape 和原来是一致的。

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

flatten(
    inputs,
    name=None
)
1
2
3
4
参数说明如下：

inputs：必需，即输入数据。
name：可选，默认为 None，即该层的名称。
返回结果：
展平后的 Tensor。

实例：

x = tf.layers.Input(shape=[5, 6])
print(x)
y = tf.layers.flatten(x)
print(y)
1
2
3
4
运行结果：

Tensor("input_layer_1:0", shape=(?, 5, 6), dtype=float32)
Tensor("flatten/Reshape:0", shape=(?, 30), dtype=float32)
1
2
这里输入数据的 shape 为 [?, 5, 6]，经过 flatten 层之后，就会变成 [?, 30]，即将除了第一维的数据维度相乘，对原 Tensor 进行展平。

假如第一维是一个已知的数的话，它依然还是同样的处理，示例如下：

x = tf.placeholder(shape=[5, 6, 2], dtype=tf.float32)
print(x)
y = tf.layers.flatten(x)
print(y)
1
2
3
4
结果如下：

Tensor("Placeholder:0", shape=(5, 6, 2), dtype=float32)
Tensor("flatten_2/Reshape:0", shape=(5, 12), dtype=float32)
1
2
8. 类
除了如上的方法，其实我们还可以直接使用类来进行操作，实际上看方法的实现就是实例化了其对应的类，下面我们首先说明一下有哪些类可以使用：

class AveragePooling1D: 一维平均池化层类
class AveragePooling2D: 二维平均池化层类
class AveragePooling3D: 三维平均池化层类
class BatchNormalization: 批量标准化层类
class Conv1D: 一维卷积层类
class Conv2D: 二维卷积层类
class Conv2DTranspose: 二维反卷积层类
class Conv3D: 三维卷积层类
class Conv3DTranspose: 三维反卷积层类
class Dense: 全连接层类
class Dropout: Dropout 层类
class Flatten: Flatten 层类
class InputSpec: Input 层类
class Layer: 基类、父类
class MaxPooling1D: 一维最大池化层类
class MaxPooling2D: 二维最大池化层类
class MaxPooling3D: 三维最大池化层类
class SeparableConv2D: 二维深度可分离卷积层类
其实类这些类都和上文介绍的方法是一一对应的，关于它的用法我们可以在方法的源码实现里面找到，下面我们以 Dense 类的用法为例来说明一下这些类的具体调用方法：
x = tf.layers.Input(shape=[32])
dense = tf.layers.Dense(16, activation=tf.nn.relu)
y = dense.apply(x)
print(y)
1
2
3
4
这里我们初始化了一个 Dense 类，它只接受一个必须参数，那就是 units，相比 dense() 方法来说它没有了 inputs，因此这个实例化的类和 inputs 是无关的，这样就相当于创建了一个 16 个神经元的全连接层。

但创建了不调用是没有用的，我们要将这个层构建到网络之中，需要调用它的 apply() 方法，而 apply() 方法就接收 inputs 这个参数，返回计算结果，运行结果如下：

Tensor("dense/Relu:0", shape=(?, 16), dtype=float32)
1
因此我们可以发现，这些类在初始化的时候实际上是比其对应的方法少了 inputs 参数，其他的参数都是完全一致的，另外需要调用 apply() 方法才可以应用该层并将其构建到模型中。

所以其他的类的用法在此就不一一赘述了，初始化的参数可以类比其对应的方法，实例化类之后，调用 apply() 方法，可以达到同样的构建模型的效果。
---------------------
作者：Never-Giveup
来源：CSDN
原文：https://blog.csdn.net/qq_36653505/article/details/81132354
版权声明：本文为博主原创文章，转载请附上博文链接！

奈斯