Keras学习记录之网络层结构

Posted 2022-09-28 彭祥.

全连接层（Dense）

keras.layers.Dense(units, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

就是你常用的的全连接层。

Dense 实现以下操作： output = activation(dot(input, kernel) + bias) 其中 activation 是按逐个元素计算的激活函数，kernel 是由网络层创建的权值矩阵，以及 bias 是其创建的偏置向量 (只在 use_bias 为 True 时才有用)。
注意: 如果该层的输入的秩大于2，那么它首先被展平然后 再计算与 kernel 的点乘。
例：

# 作为 Sequential 模型的第一层
model = Sequential()
model.add(Dense(32, input_shape=(16,)))
# 现在模型就会以尺寸为 (*, 16) 的数组作为输入，
# 其输出数组的尺寸为 (*, 32)

# 在第一层之后，你就不再需要指定输入的尺寸了：
model.add(Dense(32))

参数

1. units: 正整数，输出空间维度。
2. activation: 激活函数。 若不指定，则不使用激活函数 (即，「线性」激活: a(x) = x)。
3. use_bias: 布尔值，该层是否使用偏置向量。
4. kernel_initializer: kernel 权值矩阵的初始化器。
5. bias_initializer: 偏置向量的初始化器。
6. kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数 。
7. bias_regularizer: 运用到偏置向的的正则化函数 。
8. activity_regularizer: 运用到层的输出的正则化函数 。
9. kernel_constraint: 运用到 kernel 权值矩阵的约束函数 。
10. bias_constraint: 运用到偏置向量的约束函数。

输入尺寸

nD 张量，尺寸: (batch_size, …, input_dim)。 最常见的情况是一个尺寸为 (batch_size, input_dim) 的 2D 输入。

输出尺寸

nD 张量，尺寸: (batch_size, …, units)。 例如，对于尺寸为 (batch_size, input_dim) 的 2D 输入， 输出的尺寸为 (batch_size, units)。

激活层（Activation）

keras.layers.Activation(activation)

将激活函数应用于输出。

参数

activation: 要使用的激活函数的名称 (详见: activations)， 或者选择一个 Theano 或 TensorFlow操作。

输入尺寸

任意尺寸。 当使用此层作为模型中的第一层时， 使用参数 input_shape （整数元组，不包括样本数的轴）。

输出尺寸

与输入相同。

丢弃层（Dropout）

keras.layers.Dropout(rate, noise_shape=None, seed=None)

将 Dropout 应用于输入。

Dropout 包括在训练中每次更新时， 将输入单元的按比率随机设置为 0， 这有助于防止过拟合。

参数

rate: 在 0 和 1 之间浮动。需要丢弃的输入比例。
noise_shape: 1D 整数张量， 表示将与输入相乘的二进制 dropout 掩层的形状。 例如，如果你的输入尺寸为 (batch_size, timesteps, features)，然后 你希望 dropout 掩层在所有时间步都是一样的， 你可以使用 noise_shape=(batch_size, 1, features)。
seed: 一个作为随机种子的 Python 整数。

扁平层（Flatten）

keras.layers.Flatten(data_format=None)

将输入展平。不影响批量大小。

参数

data_format：一个字符串，其值为 channels_last（默认值）或者 channels_first。它表明输入的维度的顺序。此参数的目的是当模型从一种数据格式切换到另一种数据格式时保留权重顺序。channels_last 对应着尺寸为 (batch, …, channels) 的输入，而 channels_first 对应着尺寸为 (batch, channels, …) 的输入。默认为 image_data_format 的值，你可以在 Keras 的配置文件 ~/.keras/keras.json 中找到它。如果你从未设置过它，那么它将是 channels_last
例

model = Sequential()
model.add(Conv2D(64, (3, 3),
                 input_shape=(3, 32, 32), padding='same',))
# 现在：model.output_shape == (None, 64, 32, 32)

model.add(Flatten())
# 现在：model.output_shape == (None, 65536)

输入（Input）

keras.engine.input_layer.Input()

Input() 用于实例化 Keras 张量。

Keras 张量是底层后端(Theano, TensorFlow 或 CNTK) 的张量对象，我们增加了一些特性，使得能够通过了解模型的输入 和输出来构建 Keras 模型。

例如，如果 a, b 和 c 都是 Keras 张量， 那么以下操作是可行的： model = Model(input=[a, b], output=c)

添加的 Keras 属性是： - _keras_shape: 通过 Keras端的尺寸推理 进行传播的整数尺寸元组。 - _keras_history: 应用于张量的最后一层。 整个网络层计算图可以递归地从该层中检索。

参数

shape: 一个尺寸元组（整数），不包含批量大小。 例如，shape=(32,) 表明期望的输入是按批次的 32 维向量。
batch_shape: 一个尺寸元组（整数），包含批量大小。 例如，batch_shape=(10, 32) 表明期望的输入是 10 个 32 维向量。 batch_shape=(None, 32) 表明任意批次大小的 32 维向量。
name: 一个可选的层的名称的字符串。 在一个模型中应该是唯一的（不可以重用一个名字两次）。 如未提供，将自动生成。
dtype: 输入所期望的数据类型，字符串表示 (float32, float64, int32…)
sparse: 一个布尔值，指明需要创建的占位符是否是稀疏的。
tensor: 可选的可封装到 Input 层的现有张量。 如果设定了，那么这个层将不会创建占位符张量。

返回

一个张量。

例

# 这是 Keras 中的一个逻辑回归
x = Input(shape=(32,))
y = Dense(16, activation='softmax')(x)
model = Model(x, y)

Reshape层

keras.layers.Reshape(target_shape)

将输入重新调整为特定的尺寸。

参数

target_shape: 目标尺寸。整数元组。 不包含表示批量的轴。

输入尺寸

任意，尽管输入尺寸中的所有维度必须是固定的。 当使用此层作为模型中的第一层时， 使用参数 input_shape （整数元组，不包括样本数的轴）。

输出尺寸

(batch_size,) + target_shape

例

# 作为 Sequential 模型的第一层
model = Sequential()
model.add(Reshape((3, 4), input_shape=(12,)))
# 现在：model.output_shape == (None, 3, 4)
# 注意： `None` 是批表示的维度

# 作为 Sequential 模型的中间层
model.add(Reshape((6, 2)))
# 现在： model.output_shape == (None, 6, 2)

# 还支持使用 `-1` 表示维度的尺寸推断
model.add(Reshape((-1, 2, 2)))
# 现在： model.output_shape == (None, 3, 2, 2)

Permute层(维度混洗层）

keras.layers.Permute(dims)

根据给定的模式置换输入的维度。Permute可以同时多次交换tensor的维度
在博主学习的LSTM-FCN模型中也有提到，可提高计算速度。完成维度混洗操作。

在某些场景下很有用，例如将 RNN 和 CNN 连接在一起。

例

model = Sequential()
model.add(Permute((2, 1), input_shape=(10, 64)))
# 现在： model.output_shape == (None, 64, 10)
# 注意： `None` 是批表示的维度

参数

dims: 整数元组。置换模式，不包含样本维度。 索引从 1 开始。 例如, (2, 1) 置换输入的第一和第二个维度。

输入尺寸

任意。当使用此层作为模型中的第一层时， 使用参数 input_shape （整数元组，不包括样本数的轴）。

输出尺寸

与输入尺寸相同，但是维度根据指定的模式重新排列。

RepeatVector层

keras.layers.RepeatVector(n)

将输入重复 n 次。

例

model = Sequential()
model.add(Dense(32, input_dim=32))
# 现在： model.output_shape == (None, 32)
# 注意： `None` 是批表示的维度

model.add(RepeatVector(3))
# 现在： model.output_shape == (None, 3, 32)

参数

n: 整数，重复次数。

输入尺寸

2D 张量，尺寸为 (num_samples, features)。

输出尺寸

3D 张量，尺寸为 (num_samples, n, features)。

Lambda

keras.layers.Lambda(function, output_shape=None, mask=None, arguments=None)

将任意表达式封装为 Layer 对象。

例

# 添加一个 x -> x^2 层
model.add(Lambda(lambda x: x ** 2))
# 添加一个网络层，返回输入的正数部分
# 与负数部分的反面的连接

def antirectifier(x):
    x -= K.mean(x, axis=1, keepdims=True)
    x = K.l2_normalize(x, axis=1)
    pos = K.relu(x)
    neg = K.relu(-x)
    return K.concatenate([pos, neg], axis=1)

def antirectifier_output_shape(input_shape):
    shape = list(input_shape)
    assert len(shape) == 2  # only valid for 2D tensors
    shape[-1] *= 2
    return tuple(shape)

model.add(Lambda(antirectifier,
                 output_shape=antirectifier_output_shape))

参数

function: 需要封装的函数。 将输入张量作为第一个参数。
output_shape: 预期的函数输出尺寸。 只在使用 Theano 时有意义。 可以是元组或者函数。 如果是元组，它只指定第一个维度； 样本维度假设与输入相同： output_shape = (input_shape[0], ) + output_shape 或者，输入是 None 且样本维度也是 None： output_shape = (None, ) + output_shape 如果是函数，它指定整个尺寸为输入尺寸的一个函数： output_shape = f(input_shape)
arguments: 可选的需要传递给函数的关键字参数。

输入尺寸

任意。当使用此层作为模型中的第一层时， 使用参数 input_shape （整数元组，不包括样本数的轴）。

输出尺寸

由 output_shape 参数指定 (或者在使用 TensorFlow 时，自动推理得到)。

ActivityRegularization层

keras.layers.ActivityRegularization(l1=0.0, l2=0.0)

网络层，对基于代价函数的输入活动应用一个更新。

参数

l1: L1 正则化因子 (正数浮点型)。
l2: L2 正则化因子 (正数浮点型)。

输入尺寸

任意。当使用此层作为模型中的第一层时， 使用参数 input_shape （整数元组，不包括样本数的轴）。

输出尺寸

与输入相同。

Masking层

keras.layers.Masking(mask_value=0.0)

使用覆盖值覆盖序列，以跳过时间步。

对于输入张量的每一个时间步（张量的第一个维度）， 如果所有时间步中输入张量的值与 mask_value 相等， 那么这个时间步将在所有下游层被覆盖 (跳过) （只要它们支持覆盖）。

如果任何下游层不支持覆盖但仍然收到此类输入覆盖信息，会引发异常。

例

考虑将要喂入一个 LSTM 层的 Numpy 矩阵 x， 尺寸为 (samples, timesteps, features)。 你想要覆盖时间步 #3 和 #5，因为你缺乏这几个 时间步的数据。你可以：

设置 x[:, 3, :] = 0. 以及 x[:, 5, :] = 0.

在 LSTM 层之前，插入一个 mask_value=0 的 Masking 层：
model = Sequential()
model.add(Masking(mask_value=0., input_shape=(timesteps, features)))
model.add(LSTM(32))

SpatialDropout1D

keras.layers.SpatialDropout1D(rate)

Dropout 的 Spatial 1D 版本

此版本的功能与 Dropout 相同，但它会丢弃整个 1D 的特征图而不是丢弃单个元素。如果特征图中相邻的帧是强相关的（通常是靠前的卷积层中的情况），那么常规的 dropout 将无法使激活正则化，且导致有效的学习速率降低。在这种情况下，SpatialDropout1D 将有助于提高特征图之间的独立性，应该使用它来代替 Dropout。

参数

rate: 0 到 1 之间的浮点数。需要丢弃的输入比例。

输入尺寸

3D 张量，尺寸为：(samples, timesteps, channels)

输出尺寸

与输入相同。

SpatialDropout2D

keras.layers.SpatialDropout2D(rate, data_format=None)

Dropout 的 Spatial 2D 版本

此版本的功能与 Dropout 相同，但它会丢弃整个 2D 的特征图而不是丢弃单个元素。如果特征图中相邻的像素是强相关的（通常是靠前的卷积层中的情况），那么常规的 dropout 将无法使激活正则化，且导致有效的学习速率降低。在这种情况下，SpatialDropout2D 将有助于提高特征图之间的独立性，应该使用它来代替 dropout。

参数

rate: 0 到 1 之间的浮点数。需要丢弃的输入比例。
data_format：channels_first 或者 channels_last。在 channels_first 模式中，通道维度（即深度）位于索引 1，在 channels_last 模式中，通道维度位于索引 3。默认为 image_data_format 的值，你可以在 Keras 的配置文件 ~/.keras/keras.json 中找到它。如果你从未设置过它，那么它将是 channels_last

输入尺寸（与前面的模式对应）

4D 张量，如果 data_format＝channels_first，尺寸为 (samples, channels, rows, cols)，如果 data_format＝channels_last，尺寸为 (samples, rows, cols, channels)

输出尺寸

与输入相同。

SpatialDropout3D

keras.layers.SpatialDropout3D(rate, data_format=None)

Dropout 的 Spatial 3D 版本

**此版本的功能与 Dropout 相同，但它会丢弃整个 3D 的特征图而不是丢弃单个元素。**如果特征图中相邻的体素是强相关的（通常是靠前的卷积层中的情况），那么常规的 dropout 将无法使激活正则化，且导致有效的学习速率降低。在这种情况下，SpatialDropout3D 将有助于提高特征图之间的独立性，应该使用它来代替 dropout。

参数

rate: 0 到 1 之间的浮点数。需要丢弃的输入比例。
data_format：channels_first 或者 channels_last。在 channels_first 模式中，通道维度（即深度）位于索引 1，在 channels_last 模式中，通道维度位于索引 4。默认为 image_data_format 的值，你可以在 Keras 的配置文件 ~/.keras/keras.json 中找到它。如果你从未设置过它，那么它将是 channels_last

输入尺寸

5D 张量，如果 data_format＝channels_first，尺寸为 (samples, channels, dim1, dim2, dim3)，如果 data_format＝channels_last，尺寸为 (samples, dim1, dim2, dim3, channels)

输出尺寸

与输入相同。

RNN（循环神经网络层）

keras.layers.RNN(cell, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)

循环神经网络层基类。

参数

cell: 一个 RNN 单元实例。RNN 单元是一个具有以下几项的类：

一个 call(input_at_t, states_at_t) 方法， 它返回 (output_at_t, states_at_t_plus_1)。 单元的调用方法也可以采引入可选参数 constants， 详见下面的小节「关于给 RNN 传递外部常量的说明」。
一个 state_size 属性。这可以是单个整数（单个状态）， 在这种情况下，它是循环层状态的大小（应该与单元输出的大小相同）。 这也可以是整数表示的列表/元组（每个状态一个大小）。
一个 output_size 属性。 这可以是单个整数或者是一个 TensorShape， 它表示输出的尺寸。出于向后兼容的原因，如果此属性对于当前单元不可用， 则该值将由 state_size 的第一个元素推断。
cell 也可能是 RNN 单元实例的列表，在这种情况下，RNN 的单元将堆叠在另一个单元上，实现高效的堆叠 RNN。
return_sequences: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。
return_state: 布尔值。除了输出之外是否返回最后一个状态。
go_backwards: 布尔值 (默认 False)。 如果为 True，则向后处理输入序列并返回相反的序列。
stateful: 布尔值 (默认 False)。 如果为 True，则批次中索引 i 处的每个样品的最后状态将用作下一批次中索引 i 样品的初始状态。
unroll: 布尔值 (默认 False)。 如果为 True，则网络将展开，否则将使用符号循环。 展开可以加速 RNN，但它往往会占用更多的内存。 展开只适用于短序列。
input_dim: 输入的维度（整数）。 将此层用作模型中的第一层时，此参数（或者，关键字参数 input_shape）是必需的。
input_length: 输入序列的长度，在恒定时指定。 如果你要在上游连接 Flatten 和 Dense 层， 则需要此参数（如果没有它，无法计算全连接输出的尺寸）。 请注意，如果循环神经网络层不是模型中的第一层， 则需要在第一层的层级指定输入长度（例如，通过 input_shape 参数）。

输入尺寸

3D 张量，尺寸为 (batch_size, timesteps, input_dim)。

输出尺寸

如果 return_state：返回张量列表。 第一个张量为输出。剩余的张量为最后的状态， 每个张量的尺寸为 (batch_size, units)。
如果 return_sequences：返回 3D 张量， 尺寸为 (batch_size, timesteps, units)。
否则，返回尺寸为 (batch_size, units) 的 2D 张量。
Masking

该层支持以可变数量的时间步对输入数据进行 masking。 要将 masking 引入你的数据，请使用 Embedding 层， 并将 mask_zero 参数设置为 True。

关于在 RNN 中使用「状态（statefulness）」的说明

你可以将 RNN 层设置为 stateful（有状态的）， 这意味着针对一个批次的样本计算的状态将被重新用作下一批样本的初始状态。 这假定在不同连续批次的样品之间有一对一的映射。

为了使状态有效：

在层构造器中指定 stateful=True。
为你的模型指定一个固定的批次大小， 如果是顺序模型，为你的模型的第一层传递一个 batch_input_shape=(…) 参数。
为你的模型指定一个固定的批次大小， 如果是顺序模型，为你的模型的第一层传递一个 batch_input_shape=(…)。 如果是带有 1 个或多个 Input 层的函数式模型，为你的模型的所有第一层传递一个 batch_shape=(…)。 这是你的输入的预期尺寸，包括批量维度。 它应该是整数的元组，例如 (32, 10, 100)。
在调用 fit() 是指定 shuffle=False。
要重置模型的状态，请在特定图层或整个模型上调用 .reset_states()。

关于指定 RNN 初始状态的说明

您可以通过使用关键字参数 initial_state 调用它们来符号化地指定 RNN 层的初始状态。 initial_state 的值应该是表示 RNN 层初始状态的张量或张量列表。

您可以通过调用带有关键字参数 states 的 reset_states 方法来数字化地指定 RNN 层的初始状态。 states 的值应该是一个代表 RNN 层初始状态的 Numpy 数组或者 Numpy 数组列表。

关于给 RNN 传递外部常量的说明

你可以使用 RNN.call（以及 RNN.call）的 constants 关键字参数将「外部」常量传递给单元。 这要求 cell.call 方法接受相同的关键字参数 constants。 这些常数可用于调节附加静态输入（不随时间变化）上的单元转换，也可用于注意力机制。
例子

# 首先，让我们定义一个 RNN 单元，作为网络层子类。
class MinimalRNNCell(keras.layers.Layer):

    def __init__(self, units, **kwargs):
        self.units = units
        self.state_size = units
        super(MinimalRNNCell, self).__init__(**kwargs)

    def build(self, input_shape):
        self.kernel = self.add_weight(shape=(input_shape[-1], self.units),
                                      initializer='uniform',
                                      name='kernel')
        self.recurrent_kernel = self.add_weight(
            shape=(self.units, self.units),
            initializer='uniform',
            name='recurrent_kernel')
        self.built = True

    def call(self, inputs, states):
        prev_output = states[0]
        h = K.dot(inputs, self.kernel)
        output = h + K.dot(prev_output, self.recurrent_kernel)
        return output, [output]

# 让我们在 RNN 层使用这个单元：

cell = MinimalRNNCell(32)
x = keras.Input((None, 5))
layer = RNN(cell)
y = layer(x)

# 以下是如何使用单元格构建堆叠的 RNN的方法：

cells = [MinimalRNNCell(32), MinimalRNNCell(64)]
x = keras.Input((None, 5))
layer = RNN(cells)
y = layer(x)

LSTM

keras.layers.LSTM(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, implementation=1, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)

长短期记忆网络层（Long Short-Term Memory） - Hochreiter 1997.

参数

units: 正整数，输出空间的维度。
activation: 要使用的激活函数 (详见 activations)。 如果传入 None，则不使用激活函数 (即 线性激活：a(x) = x)。
recurrent_activation: 用于循环时间步的激活函数 (详见 activations)。 默认：分段线性近似 sigmoid (hard_sigmoid)。 如果传入 None，则不使用激活函数 (即 线性激活：a(x) = x)。
use_bias: 布尔值，该层是否使用偏置向量。
kernel_initializer: kernel 权值矩阵的初始化器， 用于输入的线性转换 (详见 initializers)。
recurrent_initializer: recurrent_kernel 权值矩阵 的初始化器，用于循环层状态的线性转换 (详见 initializers)。
bias_initializer:偏置向量的初始化器 (详见initializers).
unit_forget_bias: 布尔值。 如果为 True，初始化时，将忘记门的偏置加 1。 将其设置为 True 同时还会强制 bias_initializer=“zeros”。 这个建议来自 Jozefowicz et al.。
kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数 (详见 regularizer)。
recurrent_regularizer: 运用到 recurrent_kernel 权值矩阵的正则化函数 (详见 regularizer)。
bias_regularizer: 运用到偏置向量的正则化函数 (详见 regularizer)。
activity_regularizer: 运用到层输出（它的激活值）的正则化函数 (详见 regularizer)。
kernel_constraint: 运用到 kernel 权值矩阵的约束函数 (详见 constraints)。
recurrent_constraint: 运用到 recurrent_kernel 权值矩阵的约束函数 (详见 constraints)。
bias_constraint: 运用到偏置向量的约束函数 (详见 constraints)。
dropout: 在 0 和 1 之间的浮点数。 单元的丢弃比例，用于输入的线性转换。
recurrent_dropout: 在 0 和 1 之间的浮点数。 单元的丢弃比例，用于循环层状态的线性转换。
implementation: 实现模式，1 或 2。 模式 1 将把它的操作结构化为更多的小的点积和加法操作， 而模式 2 将把它们分批到更少，更大的操作中。 这些模式在不同的硬件和不同的应用中具有不同的性能配置文件。
return_sequences: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。
return_state: 布尔值。除了输出之外是否返回最后一个状态。
go_backwards: 布尔值 (默认 False)。 如果为 True，则向后处理输入序列并返回相反的序列。
stateful: 布尔值 (默认 False)。 如果为 True，则批次中索引 i 处的每个样品的最后状态 将用作下一批次中索引 i 样品的初始状态。
unroll: 布尔值 (默认 False)。 如果为 True，则网络将展开，否则将使用符号循环。 展开可以加速 RNN，但它往往会占用更多的内存。 展开只适用于短序列。

SimpleRNN

keras.layers.SimpleRNN(units, activation='tanh', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)

全连接的 RNN，其输出将被反馈到输入。

参数

units: 正整数，输出空间的维度。
activation: 要使用的激活函数 (详见 activations)。 默认：双曲正切（tanh）。 如果传入 None，则不使用激活函数 (即 线性激活：a(x) = x)。
use_bias: 布尔值，该层是否使用偏置向量。
kernel_initializer: kernel 权值矩阵的初始化器， 用于输入的线性转换 (详见 initializers)。
recurrent_initializer: recurrent_kernel 权值矩阵 的初始化器，用于循环层状态的线性转换 (详见 initializers)。
bias_initializer:偏置向量的初始化器 (详见initializers).
kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数 (详见 regularizer)。
recurrent_regularizer: 运用到 recurrent_kernel 权值矩阵的正则化函数 (详见 regularizer)。
bias_regularizer: 运用到偏置向量的正则化函数 (详见 regularizer)。
activity_regularizer: 运用到层输出（它的激活值）的正则化函数 (详见 regularizer)。
kernel_constraint: 运用到 kernel 权值矩阵的约束函数 (详见 constraints)。
recurrent_constraint: 运用到 recurrent_kernel 权值矩阵的约束函数 (详见 constraints)。
bias_constraint: 运用到偏置向量的约束函数 (详见 constraints)。
dropout: 在 0 和 1 之间的浮点数。 单元的丢弃比例，用于输入的线性转换。
recurrent_dropout: 在 0 和 1 之间的浮点数。 单元的丢弃比例，用于循环层状态的线性转换。
return_sequences: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。
return_state: 布尔值。除了输出之外是否返回最后一个状态。
go_backwards: 布尔值 (默认 False)。 如果为 True，则向后处理输入序列并返回相反的序列。
stateful: 布尔值 (默认 False)。 如果为 True，则批次中索引 i 处的每个样品 的最后状态将用作下一批次中索引 i 样品的初始状态。
unroll: 布尔值 (默认 False)。 如果为 True，则网络将展开，否则将使用符号循环。 展开可以加速 RNN，但它往往会占用更多的内存。 展开只适用于短序列。

BatchNormalization(批归一化层）

keras.layers.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones', beta_regularizer=None, gamma_regularizer=None, beta_constraint=None, gamma_constraint=None)

批量标准化层 (Ioffe and Szegedy, 2014)。

在每一个批次的数据中标准化前一层的激活项， 即，应用一个维持激活项平均值接近 0，标准差接近 1 的转换。

参数

axis: 整数，需要标准化的轴 （通常是特征轴）。 例如，在 data_format=“channels_first” 的 Conv2D 层之后， 在 BatchNormalization 中设置 axis=1。
momentum: 移动均值和移动方差的动量。
epsilon: 增加到方差的小的浮点数，以避免除以零。
center: 如果为 True，把 beta 的偏移量加到标准化的张量上。 如果为 False， beta 被忽略。
scale: 如果为 True，乘以 gamma。 如果为 False，gamma 不使用。 当下一层为线性层（或者例如 nn.relu）， 这可以被禁用，因为缩放将由下一层完成。
beta_initializer: beta 权重的初始化方法。
gamma_initializer: gamma 权重的初始化方法。
moving_mean_initializer: 移动均值的初始化方法。
moving_variance_initializer: 移动方差的初始化方法。
beta_regularizer: 可选的 beta 权重的正则化方法。
gamma_regularizer: 可选的 gamma 权重的正则化方法。
beta_constraint: 可选的 beta 权重的约束方法。
gamma_constraint: 可选的 gamma 权重的约束方法。

输入尺寸

可以是任意的。如果将这一层作为模型的第一层， 则需要指定 input_shape 参数 （整数元组，不包含样本数量的维度）。

输出尺寸

与输入相同。

Conv1D（一维卷积层）

keras.layers.Conv1D(filters, kernel_size, strides=1, padding='valid', data_format='channels_last', dilation_rate=1, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

1D 卷积层 (例如时序卷积)。

该层创建了一个卷积核，该卷积核以 单个空间（或时间）维上的层输入进行卷积， 以生成输出张量。 如果 use_bias 为 True， 则会创建一个偏置向量并将其添加到输出中。 最后，如果 activation 不是 None，它也会应用于输出。

当使用该层作为模型第一层时，需要提供 input_shape 参数（整数元组或 None）