Keras学习笔记3——keras.layers

参考:
Keras入门简介

>>> import keras
>>> dir(keras.layers)
['Activation', 'ActivityRegularization', 'Add', 'AlphaDropout', 'AtrousConvolution1D', 'AtrousConvolution2D', 'Average', 'AveragePooling1D', 'AveragePooling2D', 'AveragePooling3D', 'AvgPool1D', 'AvgPool2D', 'AvgPool3D', 'BatchNormalization', 'Bidirectional', 'Concatenate', 'Conv1D', 'Conv2D', 'Conv2DTranspose', 'Conv3D', 'Conv3DTranspose', 'ConvLSTM2D', 'ConvLSTM2DCell', 'ConvRecurrent2D', 'Convolution1D', 'Convolution2D', 'Convolution3D', 'Cropping1D', 'Cropping2D', 'Cropping3D', 'CuDNNGRU', 'CuDNNLSTM', 'Deconvolution2D', 'Deconvolution3D', 'Dense', 'DepthwiseConv2D', 'Dot', 'Dropout', 'ELU', 'Embedding', 'Flatten', 'GRU', 'GRUCell', 'GaussianDropout', 'GaussianNoise', 'GlobalAveragePooling1D', 'GlobalAveragePooling2D', 'GlobalAveragePooling3D', 'GlobalAvgPool1D', 'GlobalAvgPool2D', 'GlobalAvgPool3D', 'GlobalMaxPool1D', 'GlobalMaxPool2D', 'GlobalMaxPool3D', 'GlobalMaxPooling1D', 'GlobalMaxPooling2D', 'GlobalMaxPooling3D', 'Highway', 'Input', 'InputLayer', 'InputSpec', 'LSTM', 'LSTMCell', 'Lambda', 'Layer', 'LeakyReLU', 'LocallyConnected1D', 'LocallyConnected2D', 'Masking', 'MaxPool1D', 'MaxPool2D', 'MaxPool3D', 'MaxPooling1D', 'MaxPooling2D', 'MaxPooling3D', 'Maximum', 'MaxoutDense', 'Minimum', 'Multiply', 'PReLU', 'Permute', 'RNN', 'ReLU', 'Recurrent', 'RepeatVector', 'Reshape', 'SeparableConv1D', 'SeparableConv2D', 'SimpleRNN', 'SimpleRNNCell', 'Softmax', 'SpatialDropout1D', 'SpatialDropout2D', 'SpatialDropout3D', 'StackedRNNCells', 'Subtract', 'ThresholdedReLU', 'TimeDistributed', 'UpSampling1D', 'UpSampling2D', 'UpSampling3D', 'ZeroPadding1D', 'ZeroPadding2D', 'ZeroPadding3D', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', 'absolute_import', 'add', 'advanced_activations', 'average', 'concatenate', 'convolutional', 'convolutional_recurrent', 'core', 'cudnn_recurrent', 'deserialize', 'deserialize_keras_object', 'dot', 'embeddings', 'local', 'maximum', 'merge', 'minimum', 'multiply', 'noise', 'normalization', 'pooling', 'recurrent', 'serialize', 'subtract', 'wrappers']

0. 函数

layer.get_weights(): 以含有Numpy矩阵的列表形式返回层的权重。
layer.set_weights(weights): 从含有Numpy矩阵的列表中设置层的权重（与get_weights的输出形状相同）。
layer.get_config(): 返回包含层配置的字典。此图层可以通过以下方式重置：

from keras import layers
layer = Dense(32)
config = layer.get_config()
reconstructed_layer = Dense.from_config(config)

或:

config = layer.get_config()
layer = layers.deserialize({'class_name': layer.__class__.__name__,
                            'config': config})

如果一个层具有单个节点 (i.e. 如果它不是共享层), 你可以得到它的输入张量、输出张量、输入尺寸和输出尺寸:
layer.input
layer.output
layer.input_shape
layer.output_shape

如果层有多个节点，可以使用以下函数:
layer.get_input_at(node_index)
layer.get_output_at(node_index)
layer.get_input_shape_at(node_index)
layer.get_output_shape_at(node_index)

1. 全连接层

output = activation( dot(input, kernel) + bias )

其中，

• activation 是按逐个元素计算的激活函数，
• kernel 是由网络层创建的权重矩阵，
• bias 是其创建的偏置向量 (只在 use_bias 为 True 时才有用)。

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)

参数说明：

• units: 正整数，全连接层输出的维度，即下一层神经元的个数。
• activation：激活函数，若不指定，则不使用激活函数 (即，「线性」激活: a(x) = x)。
• use_bias: 布尔值，该层是否使用bias偏置向量。
• kernel_initializer: kernel 权值矩阵的初始化器。
• bias_initializer: 偏置向量的初始化器 。
• kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数。
• bias_regularizer: 运用到偏置向的的正则化函数。
• activity_regularizer: 运用到层的输出的正则化函数 (它的 “activation”)。
• kernel_constraint: 运用到 kernel 权值矩阵的约束函数。
• bias_constraint: 运用到偏置向量的约束函数。

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

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

2. 激活层

对上一层的输出应用激活函数。

keras.layers.Activation(activation)

参数说明：
activation：想要使用的激活函数，如：’relu’、’tanh’、‘sigmoid’等。

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

输出尺寸:
与输入相同。

3. Dropout层

Dropout 应用于输入。Dropout 包括在训练中每次更新时， 对输入单元随机选取一定比例的失活，不更新，但是权重仍然保留，这有助于防止过拟合。

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

参数说明:

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

4. Flatten层

将一个维度大于或等于3的高维矩阵，“压扁”为一个二维矩阵。即保留第一个维度（如：batch的个数），然后将剩下维度的值相乘作为“压扁”矩阵的第二个维度。将输入展平。不影响批量大小。

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.output_shape == (None, 64, 32, 32)
model.add(Conv2D(64, (3, 3), input_shape=(3, 32, 32), padding='same',))
# 现在：model.output_shape == (None, 65536)
model.add(Flatten())

5. 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)

6. 卷积层

来源
卷积操作分为一维、二维、三维，分别为Conv1D、Conv2D、Conv3D。一维卷积主要应用于以时间序列数据或文本数据，二维卷积通常应用于图像数据。由于这三种的使用和参数都基本相同，所以主要以处理图像数据的Conv2D进行说明。

Conv2D

keras.layers.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid', 
data_format=None, dilation_rate=(1, 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)

参数说明：

• filters: 整数，输出空间的维度 （即卷积中滤波器的输出数量）。
• kernel_size: 一个整数，或者 2 个整数表示的元组或列表， 指明 2D 卷积窗口的宽度和高度。 可以是一个整数，为所有空间维度指定相同的值。
• strides: 一个整数，或者 2 个整数表示的元组或列表， 指明卷积沿宽度和高度方向的步长。 可以是一个整数，为所有空间维度指定相同的值。 指定任何 stride 值 != 1 与指定 dilation_rate 值 != 1 两者不兼容。
• padding: “valid” 或 “same” (大小写敏感)。补“0”策略，’valid‘指卷积后的大小与原来的大小可以不同，’same‘则卷积后大小与原来大小一致。"valid" 表示「不填充」。 "same" 表示填充输入以使输出具有与原始输入相同的长度。 “causal” 表示因果（膨胀）卷积， 例如，output[t] 不依赖于 input[t+1:]， 在模型不应违反时间顺序的时间数据建模时非常有用。
• data_format: 字符串， channels_last (默认) 或 channels_first 之一，表示输入中维度的顺序。 channels_last 对应输入尺寸为 (batch, height, width, channels)， channels_first 对应输入尺寸为 (batch, channels, height, width)。 它默认为从 Keras 配置文件 ~/.keras/keras.json 中 找到的 image_data_format 值。 如果你从未设置它，将使用 channels_last。
• dilation_rate: 一个整数或 2 个整数的元组或列表， 指定膨胀卷积的膨胀率。 可以是一个整数，为所有空间维度指定相同的值。 当前，指定任何 dilation_rate 值 != 1 与 指定 stride 值 != 1 两者不兼容。
• activation: 要使用的激活函数。 如果你不指定，则不使用激活函数 (即线性激活： a(x) = x)。
• use_bias: 布尔值，该层是否使用偏置向量。
• kernel_initializer: kernel 权值矩阵的初始化器。
• bias_initializer: 偏置向量的初始化器 。
• kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数。
• bias_regularizer: 运用到偏置向量的正则化函数。
• activity_regularizer: 运用到层输出（它的激活值）的正则化函数。
• kernel_constraint: 运用到 kernel 权值矩阵的约束函数。
• bias_constraint: 运用到偏置向量的约束函数。

data_format	输入尺寸	输出尺寸
‘channels_first’	(samples, channels, rows, cols)	(samples, filters, new_rows, new_cols)
‘channels_last’	(samples, rows, cols, channels)	(samples, new_rows, new_cols, filters)

由于填充的原因， rows 和 cols 值可能已更改。

卷积核的运算过程
例如输入224x224x3（rgb三通道，3张feature map），输出是32位深度（filters=32），卷积核尺寸为5x5（kernel_size=(5, 5)）。

model = Sequential()
model.add(Conv2D(32, (5, 5), padding='same', input_shape=x_train.shape[1:]))

那么我们需要32个卷积核，每一个的尺寸为5x5x3（最后的3就是原图的rgb位深3），每一个卷积核的每一层是5x5（共3层）分别与原图的每层224x224卷积，然后将得到的三张新图叠加（算术求和），变成一张新的feature map。 每一个卷积核都这样操作，就可以得到32张新的feature map了。 也就是说：不管输入图像的深度为多少，经过一个卷积核（filter），最后都变成一个深度为1的特征图。不同的filter可以卷积得到不同的特征，也就是得到不同的feature map。

函数	卷积层
Conv1D	1D 卷积层 (例如时序卷积)
Conv2D	2D 卷积层 (例如对图像的空间卷积)
SeparableConv1D	深度方向的可分离 1D 卷积
SeparableConv2D	深度方向的可分离 2D 卷积
DepthwiseConv2D	深度可分离 2D 卷积
Conv2DTranspose	转置卷积层 (有时被成为反卷积)
Conv3D	3D 卷积层 (例如立体空间卷积)
Conv3DTranspose	转置卷积层 (有时被成为反卷积)
Cropping1D	1D 输入的裁剪层（例如时间序列）
Cropping2D	2D 输入的裁剪层（例如图像）
Cropping3D	3D 数据的裁剪层（例如空间或时空）
UpSampling1D	1D 输入的上采样层
UpSampling2D	2D 输入的上采样层
UpSampling3D	3D 输入的上采样层
ZeroPadding1D	1D 输入的零填充层（例如，时间序列）
ZeroPadding2D	2D 输入的零填充层（例如图像）
ZeroPadding3D	3D 数据的零填充层（空间或时空）

LocallyConnected2D

2D 输入的局部连接层。
LocallyConnected2D 层与 Conv2D 层的工作方式相同，除了权值不共享外， 也就是说，在输入的每个不同部分应用不同的一组过滤器。

7. 池化层

来源
与卷积层一样，最大统计量池化和平均统计量池化也有三种，分别为MaxPooling1D、MaxPooling2D、MaxPooling3D和AveragePooling1D、AveragePooling2D、AveragePooling3D，由于使用和参数基本相同，所以主要以MaxPooling2D进行说明。

keras.layers.MaxPooling2D(pool_size=(2, 2), strides=None, 
padding='valid', data_format=None)

参数说明：

• pool_size: 整数，或者 2 个整数表示的元组， 沿（垂直，水平）方向缩小比例的因数。 （2，2）会把输入张量的两个维度都缩小一半。 如果只使用一个整数，那么两个维度都会使用同样的窗口长度。
• strides: 整数，2 个整数表示的元组，或者是 None。 表示步长值。 如果是 None，那么默认值是 pool_size。
• padding: “valid” 或者 “same” （区分大小写）。
• data_format: 字符串，channels_last (默认)或 channels_first 之一。 表示输入各维度的顺序。 channels_last 代表尺寸是 (batch, height, width, channels) 的输入张量， 而 channels_first 代表尺寸是 (batch, channels, height, width) 的输入张量。 默认值根据 Keras 配置文件 ~/.keras/keras.json 中的 image_data_format 值来设置。 如果还没有设置过，那么默认值就是 “channels_last”。

data_format	输入尺寸	输出尺寸
‘channels_first’	(batch_size, channels, rows, cols)	(batch_size, channels, pooled_rows, pooled_cols)
‘channels_last’	(batch_size, rows, cols, channels)	(batch_size, pooled_rows, pooled_cols, channels)

函数	池化层
MaxPooling1D	对于时序数据的最大池化
MaxPooling2D	对于空间数据的最大池化
MaxPooling3D	对于 3D（空间，或时空间）数据的最大池化
AveragePooling1D	对于时序数据的平均池化
AveragePooling2D	对于空间数据的平均池化
AveragePooling3D	对于3D（空间，或时空间）数据的平均池化
GlobalMaxPooling1D	对于时序数据的全局最大池化
GlobalMaxPooling2D	对于空间数据的全局最大池化
GlobalMaxPooling3D	对于3D数据的全局最大池化
GlobalAveragePooling1D	对于时序数据的全局平均池化
GlobalAveragePooling2D	对于空间数据的全局平均池化
GlobalAveragePooling3D	对于3D数据的全局平均池化

8. 循环层

来源
循环神经网络中的RNN、LSTM和GRU都继承本层，所以该父类的参数同样使用于对应的子类SimpleRNN、LSTM和GRU。

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：控制返回的类型，“False”返回输出序列的最后一个输出，“True”则返回整个序列。当我们要搭建多层神经网络（如深层LSTM）时，若不是最后一层，则需要将该参数设为True。

• 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)

SimpleRNN

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

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)

GRU

门限循环单元网络（Gated Recurrent Unit） - Cho et al. 2014.

keras.layers.GRU(units, activation='tanh', recurrent_activation='hard_sigmoid', 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, implementation=1, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False, reset_after=False)

LSTM

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

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)

参数：

• units: 正整数，输出空间的维度。
• activation: 要使用的激活函数。 如果传入 None，则不使用激活函数 (即 线性激活：a(x) = x)。
• recurrent_activation: 用于循环时间步的激活函数。 默认：分段线性近似 sigmoid (hard_sigmoid)。 如果传入 None，则不使用激活函数 (即 线性激活：a(x) = x)。
• use_bias: 布尔值，该层是否使用偏置向量。
• kernel_initializer: kernel 权值矩阵的初始化器， 用于输入的线性转换。
• recurrent_initializer: recurrent_kernel 权值矩阵 的初始化器，用于循环层状态的线性转换。
• bias_initializer:偏置向量的初始化器.
• unit_forget_bias: 布尔值。 如果为 True，初始化时，将忘记门的偏置加 1。 将其设置为 True 同时还会强制bias_initializer=“zeros”。 这个建议来自 Jozefowicz et al.。
• kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数。
• recurrent_regularizer: 运用到 recurrent_kernel 权值矩阵的正则化函数。
• bias_regularizer: 运用到偏置向量的正则化函数。
• activity_regularizer: 运用到层输出的正则化函数。
• kernel_constraint: 运用到 kernel 权值矩阵的约束函数。
• recurrent_constraint: 运用到 recurrent_kernel 权值矩阵的约束函数。
• bias_constraint: 运用到偏置向量的约束函数。
• 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，但它往往会占用更多的内存。 展开只适用于短序列。

输入尺寸
如果 data_format=‘channels_first’， 输入 5D 张量，尺寸为： (samples,time, channels, rows, cols)。
如果 data_format=‘channels_last’， 输入 5D 张量，尺寸为： (samples,time, rows, cols, channels)。

输出尺寸
如果 return_sequences，
如果 data_format=‘channels_first’，返回 5D 张量，尺寸为：(samples, time, filters, output_row, output_col)。
如果 data_format=‘channels_last’，返回 5D 张量，尺寸为：(samples, time, output_row, output_col, filters)。
否则，
如果 data_format =‘channels_first’，返回 4D 张量，尺寸为：(samples, filters, output_row, output_col)。
如果 data_format=‘channels_last’，返回 4D 张量，尺寸为：(samples, output_row, output_col, filters)。
o_row 和 o_col 取决于 filter 和 padding 的尺寸。

ConvLSTM2D

卷积 LSTM。它类似于 LSTM 层，但输入变换和循环变换都是卷积的。

keras.layers.ConvLSTM2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), 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, return_sequences=False, go_backwards=False, stateful=False, dropout=0.0, recurrent_dropout=0.0)

SimpleRNNCell

SimpleRNN 的单元类。

keras.layers.SimpleRNNCell(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, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0)

GRUCell

GRU 层的单元类。

keras.layers.GRUCell(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, implementation=1, reset_after=False)

LSTMCell

LSTM 层的单元类。

keras.layers.LSTMCell(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, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, implementation=1)

CuDNNGRU

由 CuDNN 支持的快速 GRU 实现。只能以 TensorFlow 后端运行在 GPU 上。

keras.layers.CuDNNGRU(units, 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, return_sequences=False, return_state=False, stateful=False)

CuDNNLSTM

由 CuDNN 支持的快速 LSTM 实现。只能以 TensorFlow 后端运行在 GPU 上。

keras.layers.CuDNNLSTM(units, 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, return_sequences=False, return_state=False, stateful=False)

9. 嵌入层

该层只能用在模型的第一层，是将所有索引标号的稀疏矩阵映射到致密的低维矩阵。如我们对文本数据进行处理时，我们对每个词编号后，我们希望将词编号变成词向量就可以使用嵌入层。将正整数（索引值）转换为固定尺寸的稠密向量。 例如： [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]

keras.layers.Embedding(input_dim, output_dim, embeddings_initializer='uniform', embeddings_regularizer=None, activity_regularizer=None, embeddings_constraint=None, mask_zero=False, input_length=None)

参数说明：

• input_dim: int > 0。词汇表大小， 即，最大整数 index + 1。
• output_dim: int >= 0。词向量的维度。
• embeddings_initializer: embeddings 矩阵的初始化方法 (详见 initializers)。
• embeddings_regularizer: embeddings matrix 的正则化方法 (详见 regularizer)。
• embeddings_constraint: embeddings matrix 的约束函数 (详见 constraints)。
• mask_zero: 是否把 0 看作为一个应该被遮蔽的特殊的 “padding” 值。 这对于可变长的 循环神经网络层 十分有用。 如果设定为 True，那么接下来的所有层都必须支持 masking，否则就会抛出异常。 如果 mask_zero 为 True，作为结果，索引 0 就不能被用于词汇表中 （input_dim 应该与 vocabulary + 1 大小相同）。
• input_length: 输入序列的长度，当它是固定的时。 如果你需要连接 Flatten 和 Dense 层，则这个参数是必须的 （没有它，dense 层的输出尺寸就无法计算）。

输入尺寸
尺寸为 (batch_size, sequence_length) 的 2D 张量。

输出尺寸
尺寸为 (batch_size, sequence_length, output_dim) 的 3D 张量。

该层可能有点费解，举个例子，当我们有一个文本，该文本有100句话，我们已经通过一系列操作，使得文本变成一个(100,32)矩阵，每行代表一句话，每个元素代表一个词，我们希望将该词变为64维的词向量：
Embedding(100, 64, input_length=32)
则输出的矩阵的shape变为(100, 32, 64)：即每个词已经变成一个64维的词向量。
可以发现Keras在搭建模型比起Tensorflow等简单太多了，如Tensorflow需要定义每一层的权重矩阵，输入用占位符等，这些在Keras中都不需要，我们只要在第一层定义输入维度，其他层定义输出维度就可以搭建起模型，通俗易懂，方便高效，这是Keras的一个显著的优势。

model = Sequential()
model.add(Embedding(1000, 64, input_length=10))
# 模型将输入一个大小为 (batch, input_length) 的整数矩阵。
# 输入中最大的整数（即词索引）不应该大于 999 （词汇表大小）
# 现在 model.output_shape == (None, 10, 64)，其中 None 是 batch 的维度。

input_array = np.random.randint(1000, size=(32, 10))

model.compile('rmsprop', 'mse')
output_array = model.predict(input_array)
assert output_array.shape == (32, 10, 64)

10. 融合层 Merge

Add

计算输入张量列表的和。

keras.layers.Add()

它接受一个张量的列表， 所有的张量必须有相同的输入尺寸， 然后返回一个张量（和输入张量尺寸相同）。

例子

import keras

input1 = keras.layers.Input(shape=(16,))
x1 = keras.layers.Dense(8, activation='relu')(input1)
input2 = keras.layers.Input(shape=(32,))
x2 = keras.layers.Dense(8, activation='relu')(input2)
# 相当于 added = keras.layers.add([x1, x2])
added = keras.layers.Add()([x1, x2])  

out = keras.layers.Dense(4)(added)
model = keras.models.Model(inputs=[input1, input2], outputs=out)

Subtract

keras.layers.Subtract()

计算两个输入张量的差。

它接受一个长度为 2 的张量列表， 两个张量必须有相同的尺寸，然后返回一个值为 (inputs[0] - inputs[1]) 的张量， 输出张量和输入张量尺寸相同。

例子

import keras

input1 = keras.layers.Input(shape=(16,))
x1 = keras.layers.Dense(8, activation='relu')(input1)
input2 = keras.layers.Input(shape=(32,))
x2 = keras.layers.Dense(8, activation='relu')(input2)
# 相当于 subtracted = keras.layers.subtract([x1, x2])
subtracted = keras.layers.Subtract()([x1, x2])

out = keras.layers.Dense(4)(subtracted)
model = keras.models.Model(inputs=[input1, input2], outputs=out)

Multiply

keras.layers.Multiply()

计算输入张量列表的（逐元素间的）乘积。
它接受一个张量的列表， 所有的张量必须有相同的输入尺寸， 然后返回一个张量（和输入张量尺寸相同）。

Average

keras.layers.Average()

计算输入张量列表的平均值。
它接受一个张量的列表， 所有的张量必须有相同的输入尺寸， 然后返回一个张量（和输入张量尺寸相同）。

Maximum

keras.layers.Maximum()

计算输入张量列表的（逐元素间的）最大值。
它接受一个张量的列表， 所有的张量必须有相同的输入尺寸， 然后返回一个张量（和输入张量尺寸相同）。

Concatenate

keras.layers.Concatenate(axis=-1)

连接一个输入张量的列表。

它接受一个张量的列表， 除了连接轴之外，其他的尺寸都必须相同， 然后返回一个由所有输入张量连接起来的输出张量。

参数
axis: 连接的轴。
**kwargs: 层关键字参数。

Dot

keras.layers.Dot(axes, normalize=False)

计算两个张量之间样本的点积。

例如，如果作用于输入尺寸为 (batch_size, n) 的两个张量 a 和 b， 那么输出结果就会是尺寸为 (batch_size, 1) 的一个张量。 在这个张量中，每一个条目 i 是 a[i] 和 b[i] 之间的点积。

参数
axes: 整数或者整数元组， 一个或者几个进行点积的轴。
normalize: 是否在点积之前对即将进行点积的轴进行 L2 标准化。 如果设置成 True，那么输出两个样本之间的余弦相似值。
**kwargs: 层关键字参数。

add

keras.layers.add(inputs)

Add 层的函数式接口。

参数
inputs: 一个输入张量的列表（列表大小至少为 2）。
**kwargs: 层关键字参数。

返回
一个张量，所有输入张量的和。

例子

import keras

input1 = keras.layers.Input(shape=(16,))
x1 = keras.layers.Dense(8, activation='relu')(input1)
input2 = keras.layers.Input(shape=(32,))
x2 = keras.layers.Dense(8, activation='relu')(input2)
added = keras.layers.add([x1, x2])

out = keras.layers.Dense(4)(added)
model = keras.models.Model(inputs=[input1, input2], outputs=out)

subtract

keras.layers.subtract(inputs)

Subtract 层的函数式接口。

参数
inputs: 一个列表的输入张量（列表大小准确为 2）。
**kwargs: 层的关键字参数。

返回
一个张量，两个输入张量的差。

例子

import keras

input1 = keras.layers.Input(shape=(16,))
x1 = keras.layers.Dense(8, activation='relu')(input1)
input2 = keras.layers.Input(shape=(32,))
x2 = keras.layers.Dense(8, activation='relu')(input2)
subtracted = keras.layers.subtract([x1, x2])

out = keras.layers.Dense(4)(subtracted)
model = keras.models.Model(inputs=[input1, input2], outputs=out)

multiply

keras.layers.multiply(inputs)

Multiply 层的函数式接口。

参数
inputs: 一个列表的输入张量（列表大小至少为 2）。
**kwargs: 层的关键字参数。

返回
一个张量，所有输入张量的逐元素乘积。

average

keras.layers.average(inputs)

Average 层的函数式接口。

参数
inputs: 一个列表的输入张量（列表大小至少为 2）。
**kwargs: 层的关键字参数。

返回
一个张量，所有输入张量的平均值。

maximum

keras.layers.maximum(inputs)

Maximum 层的函数式接口。

参数
inputs: 一个列表的输入张量（列表大小至少为 2）。
**kwargs: 层的关键字参数。

返回
一个张量，所有张量的逐元素的最大值。

concatenate

keras.layers.concatenate(inputs, axis=-1)

Concatenate 层的函数式接口。

参数
inputs: 一个列表的输入张量（列表大小至少为 2）。
axis: 串联的轴。
**kwargs: 层的关键字参数。

返回
一个张量，所有输入张量通过 axis 轴串联起来的输出张量。

dot

keras.layers.dot(inputs, axes, normalize=False)

Dot 层的函数式接口。

参数
inputs: 一个列表的输入张量（列表大小至少为 2）。
axes: 整数或者整数元组， 一个或者几个进行点积的轴。
normalize: 是否在点积之前对即将进行点积的轴进行 L2 标准化。 如果设置成 True，那么输出两个样本之间的余弦相似值。
**kwargs: 层的关键字参数。

返回
一个张量，所有输入张量样本之间的点积。

11. 高级激活层 Advanced Activations

来源

ReLU

ReLU 激活函数。

keras.layers.ReLU(max_value=None, negative_slope=0.0, threshold=0.0)

使用默认值时（max_value=None, negative_slope=0.0, threshold=0.0），它返回逐个元素的 max(x，0)。
否则：
如果 x >= max_value，返回 f(x) = max_value，
如果 threshold <= x < max_value，返回 f(x) = x,
否则，返回 f(x) = negative_slope * (x - threshold)。

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

输出尺寸
与输入相同。

参数
max_value: 浮点数，最大的输出值。
negative_slope: float >= 0. 负斜率系数。
threshold: float。“thresholded activation” 的阈值。

Softmax

Softmax 激活函数。

keras.layers.Softmax(axis=-1)

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

输出尺寸
与输入相同。

参数
axis: 整数，应用 softmax 标准化的轴。

ThresholdedReLU

带阈值的修正线性单元。

keras.layers.ThresholdedReLU(theta=1.0)

形式： f(x) = x for x > theta, f(x) = 0 otherwise.

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

输出尺寸
与输入相同。

参数
theta: float >= 0。激活的阈值位。

LeakyReLU

带泄漏的 ReLU。

keras.layers.LeakyReLU(alpha=0.3)

当神经元未激活时，它仍允许赋予一个很小的梯度： f(x) = alpha * x for x < 0, f(x) = x for x >= 0.

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

输出尺寸
与输入相同。

参数
alpha: float >= 0。负斜率系数。

PReLU

参数化的 ReLU。

keras.layers.PReLU(alpha_initializer='zeros', alpha_regularizer=None, alpha_constraint=None, shared_axes=None)

形式： f(x) = alpha * x for x < 0, f(x) = x for x >= 0, 其中 alpha 是一个可学习的数组，尺寸与 x 相同。

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

输出尺寸
与输入相同。

参数

• alpha_initializer: 权重的初始化函数。
• alpha_regularizer: 权重的正则化方法。
• alpha_constraint: 权重的约束。
• shared_axes: 激活函数共享可学习参数的轴。 例如，如果输入特征图来自输出形状为 (batch, height, width, channels) 的 2D 卷积层，而且你希望跨空间共享参数，以便每个滤波器只有一组参数， 可设置 shared_axes=[1, 2]。

ELU

指数线性单元。

keras.layers.ELU(alpha=1.0)

形式： f(x) = alpha * (exp(x) - 1.) for x < 0, f(x) = x for x >= 0.

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

输出尺寸
与输入相同。

参数
alpha: 负因子的尺度。

12. 标准化层 Normalization

BatchNormalization

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

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)

在每一个批次的数据中标准化前一层的激活项， 即，应用一个维持激活项平均值接近 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 参数 （整数元组，不包含样本数量的维度）。

输出尺寸
与输入相同。

13. 噪声层 Noise

来源

GaussianNoise

应用以 0 为中心的加性高斯噪声。

keras.layers.GaussianNoise(stddev)

这对缓解过拟合很有用 （你可以将其视为随机数据增强的一种形式）。 高斯噪声（GS）是对真实输入的腐蚀过程的自然选择。

由于它是一个正则化层，因此它只在训练时才被激活。

参数
stddev: float，噪声分布的标准差。

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

输出尺寸
与输入相同。

GaussianDropout

keras.layers.GaussianDropout(rate)

应用以 1 为中心的 乘性高斯噪声。
由于它是一个正则化层，因此它只在训练时才被激活。

参数
rate: float，丢弃概率（与 Dropout 相同）。 这个乘性噪声的标准差为 sqrt(rate / (1 - rate))。

AlphaDropout

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

将 Alpha Dropout 应用到输入。

Alpha Dropout 是一种 Dropout， 它保持输入的平均值和方差与原来的值不变， 以确保即使在 dropout 后也能实现自我归一化。 通过随机将激活设置为负饱和值， Alpha Dropout 非常适合按比例缩放的指数线性单元（SELU）。

参数

• rate: float，丢弃概率（与 Dropout 相同）。 这个乘性噪声的标准差为 sqrt(rate / (1 - rate))。
• seed: 用作随机种子的 Python 整数。

14. 层封装器 wrappers

TimeDistributed

这个封装器将一个层应用于输入的每个时间片。

keras.layers.TimeDistributed(layer)

输入至少为 3D，且第一个维度应该是时间所表示的维度。考虑 32 个样本的一个 batch， 其中每个样本是 10 个 16 维向量的序列。 那么这个 batch 的输入尺寸为 (32, 10, 16)， 而 input_shape 不包含样本数量的维度，为 (10, 16)。

你可以使用 TimeDistributed 来将 Dense 层独立地应用到 这 10 个时间步的每一个：

# 作为模型第一层
model = Sequential()
model.add(TimeDistributed(Dense(8), input_shape=(10, 16)))
# 现在 model.output_shape == (None, 10, 8)

输出的尺寸为 (32, 10, 8)。
在后续的层中，将不再需要 input_shape：

model.add(TimeDistributed(Dense(32)))
# 现在 model.output_shape == (None, 10, 32)

输出的尺寸为 (32, 10, 32)。

TimeDistributed 可以应用于任意层，不仅仅是 Dense， 例如运用于 Conv2D 层：

model = Sequential()
model.add(TimeDistributed(Conv2D(64, (3, 3)),
                          input_shape=(10, 299, 299, 3)))

参数
layer: 一个网络层实例。

Bidirectional

RNN 的双向封装器，对序列进行前向和后向计算。

keras.layers.Bidirectional(layer, merge_mode='concat', weights=None)

参数

• layer: Recurrent 实例。
• merge_mode: 前向和后向 RNN 的输出的结合模式。 为 {‘sum’, ‘mul’, ‘concat’, ‘ave’, None} 其中之一。 如果是 None，输出不会被结合，而是作为一个列表被返回。

例

model = Sequential()
model.add(Bidirectional(LSTM(10, return_sequences=True),
                        input_shape=(5, 10)))
model.add(Bidirectional(LSTM(10)))
model.add(Dense(5))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

15. 其他

Input

用于实例化 Keras 张量。

keras.Input(shape=None, batch_shape=None, name=None, dtype=None, sparse=False, tensor=None)

Keras 张量是底层后端 的张量对象，我们增加了一些特性，使得能够通过模型的输入和输出来构建 Keras 模型。例如，如果 a, b 和 c 都是 Keras 张量， 那么以下操作是可行的： model = keras.models.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,), dtype='float32')
y = Dense(16, activation='softmax')(x)
model = Model(x, y)

Permute

根据给定的模式置换输入的维度。相当于2维矩阵的转置。

keras.layers.Permute(dims)

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

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

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

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

RepeatVector

将输入重复 n 次。

keras.layers.RepeatVector(n)

参数：
n: 整数，重复次数。

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

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

例：

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)

Lambda

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

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

参数

• 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 时，自动推理得到)。

例：

# 添加一个 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))

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)

输出尺寸
与输入相同。