Conv1D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

keras.layers.convolutional.Conv1D(
	filters(int),
	kernel_size(int),
	strides=1,
	padding='valid',
	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
)

一维卷积层（即时域卷积）

• 说明

  • 用以在一维输入信号上进行邻域滤波
  • 作为首层时，需要提供关键字参数input_shape
  • 该层生成将输入信号与卷积核按照单一的空域（或时域） 方向进行卷积
  • 可以将Convolution1D看作Convolution2D的快捷版

• 参数

  • filters：卷积核的数目（即输出的维度）

  • kernel_size：整数或由单个整数构成的list/tuple， 卷积核的空域或时域窗长度

  • strides：整数或由单个整数构成的list/tuple，为卷积 步长

    • 任何不为1的strides均与任何不为1的dilation_rate 均不兼容

  • padding：补0策略

  • activation：激活函数

  • dilation_rate：整数或由单个整数构成的list/tuple， 指定dilated convolution中的膨胀比例

    • 任何不为1的dilation_rate均与任何不为1的strides 均不兼容

  • use_bias：布尔值，是否使用偏置项

  • kernel_initializer：权值初始化方法

    • 预定义初始化方法名的字符串
    • 用于初始化权重的初始化器（参考initializers）

  • bias_initializer：偏置初始化方法

    • 为预定义初始化方法名的字符串
    • 用于初始化偏置的初始化器

  • kernel_regularizer：施加在权重上的正则项，为 Regularizer对象

  • bias_regularizer：施加在偏置向量上的正则项

  • activity_regularizer：施加在输出上的正则项

  • kernel_constraints：施加在权重上的约束项

  • bias_constraints：施加在偏置上的约束项

• 输入：形如(batch, steps, input_dim)的3D张量

• 输出：形如(batch, new_steps, filters)的3D张量

  • 因为有向量填充的原因，steps的值会改变

Conv2D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

keras.layers.convolutional.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：单个整数或由两个整数构成的list/tuple， 卷积核的宽度和长度

    • 如为单个整数，则表示在各个空间维度的相同长度

  • strides：单个整数或由两个整数构成的list/tuple， 卷积的步长

    • 如为单个整数，则表示在各个空间维度的相同步长
    • 任何不为1的strides均与任何不为1的dilation_rate 均不兼容

  • padding：补0策略

  • activation：激活函数

  • dilation_rate：单个或两个整数构成的list/tuple， 指定dilated convolution中的膨胀比例

    • 任何不为1的dilation_rate均与任何不为1的strides 均不兼容

• 输入：(batch, channels, rows, cols) （”channels_first”）4D张量

• 输出：(batch, filters, new_rows, new_cols) （”channels_first”）4D张量

  • 输出的行列数可能会因为填充方法而改变

SeparableConv2D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

keras.layers.convolutional.SeparableConv2D(
	filters,
	kernel_size,
	strides=(1, 1),
	padding='valid',
	data_format=None,
	depth_multiplier=1,
	activation=None,
	use_bias=True,
	depthwise_initializer='glorot_uniform',
	pointwise_initializer='glorot_uniform',
	bias_initializer='zeros',
	depthwise_regularizer=None,
	pointwise_regularizer=None,
	bias_regularizer=None,
	activity_regularizer=None,
	depthwise_constraint=None,
	pointwise_constraint=None,
	bias_constraint=None
)

该层是在深度方向上的可分离卷积。

• 说明

  • 首先按深度方向进行卷积（对每个输入通道分别卷积）
  • 然后逐点卷积，将上步卷积结果混合到输出通道中
  • 直观来说，可分离卷积可以看做讲一个卷积核分解为两个小 卷积核，或看作Inception模块的一种极端情况

• 参数

  • depth_multiplier：按深度卷积的步骤中，每个输入通道 使用（产生）多少个输出通道

  • depthwise_regularizer：按深度卷积的权重上的正则项

  • pointwise_regularizer：按点卷积的权重上的正则项

  • depthwise_constraint：按深度卷积权重上的约束项

  • pointwise_constraint：在按点卷积权重的约束项

• 输入：(batch, channels, rows, cols)4DT （”channels_first”)

• 输出：(batch, filters, new_rows, new_cols)4DTK （”channels_first”）

  • 输出的行列数可能会因为填充方法而改变

Conv2DTranspose

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

keras.layers.convolutional.Conv2DTranspose(
	filters,
	kernel_size,
	strides=(1, 1),
	padding="valid",
	output_padding=None/int/tuple,
	data_format=None,
	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
)

该层是反卷积操作（转置卷积）

• 说明

  • 通常发生在用户想要对普通卷积的结果做反方向的变换
  • 参考文献
    • A guide to convolution arithmetic for deep learning
    • Transposed convolution arithmetic
    • Deconvolutional Networks

• 参数

  • output_padding：指定输出的长、宽padding
    • 必须小于相应的stride

• 输入：(batch, rows, cols, channels)4DT （”channels_last”)

• 输出：(batch, new_rows, new_cols, filters)4DT （”channels_last”）

  • 输出的行列数可能会因为填充方法而改变

Conv3D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

三维卷积对三维的输入（视频）进行滑动窗卷积

• 输入：(batch, channels, conv_dim1, conv_dim2, conv_dim3) 5D张量（”channnels_first”）

Cropping1D

1
2
3

keras.layers.convolutional.Cropping1D(
	cropping=(1, 1)/tuple/int
)

在时间轴上对1D输入（即时间序列）进行裁剪

• 参数

  • cropping：指定在序列的首尾要裁剪掉多少个元素
    • 单值表示首尾裁剪相同

• 输入：(batch, axis_to_crop, features)的3DT

• 输出：(batch, cropped_axis, features)的3DT

Cropping2D

1
2
3
4

keras.layers.convolutional.Cropping2D(
	cropping=((0, 0), (0, 0)),
	data_format=None
)

对2D输入（图像）进行裁剪

• 说明

  • 将在空域维度，即宽和高的方向上裁剪

• 参数

  • cropping：长为2的整数tuple，分别为宽和高方向上头部 与尾部需要裁剪掉的元素数
    • 单值表示宽高、首尾相同
    • 单元组类似

• 输入：(batch, rows, cols, channels)4DT（”channels_last”）

• 输出：(batch, cropped_rows, cropped_cols, channels)

1
2
3
4
5
6
7
8

	# Crop the input 2D images or feature maps
model = Sequential()
model.add(Cropping2D(cropping=((2, 2), (4, 4)),
                     input_shape=(28, 28, 3)))
	# now model.output_shape == (None, 24, 20, 3)
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Cropping2D(cropping=((2, 2), (2, 2))))
	# now model.output_shape == (None, 20, 16, 64)

Cropping3D

1
2
3
4

keras.layers.convolutional.Cropping3D(
	cropping=((1, 1), (1, 1), (1, 1)),
	data_format=None
)

对3D输入（空间、时空）进行裁剪

• 参数

  • cropping：长为3的整数tuple，分别为三个方向上头部 与尾部需要裁剪掉的元素数

• 输入：(batch, depth, first_axis_to_crop, second_axis_to_crop, third_axis_to_crop) （”channels_first”）

• 输出：(batch, depth, first_cropped_axis, second_cropped_axis, third_cropped_axis)

UpSampling1D

1
2
3

keras.layers.convolutional.UpSampling1D(
	size=2/integer
)

在时间轴上，将每个时间步重复size次

• 参数

  • size：轴上采样因子

• 输入：(batch, steps, features)的3D张量

• 输出：(batch, upsampled_steps, feature)的3D张量

UpSampling2D

1
2
3
4

keras.layers.convolutional.UpSampling2D(
	size=(2, 2)/tuple/int,
	data_format=None
)

将数据的行和列分别重复size[0]和size[1]次

• 参数

  • size：分别为行和列上采样因子

• 输入：(batch, channels, rows, cols)的4D张量 （”channels_first”）

• 输出：(batch, channels, upsampled_rows, upsampled_cols)

UpSampling3D

1
2
3
4

keras.layers.convolutional.UpSampling3D(
	size=(2, 2, 2)/tuple/int,
	data_format=None
)

将数据的三个维度上分别重复size次

• 说明

  • 本层目前只能在使用Theano为后端时可用

• 参数

  • size：代表在三个维度上的上采样因子

• 输入：(batch, dim1, dim2, dim3, channels)5DT （”channels_last”）

• 输出：(batch, upsampled_dim1, upsampled_dim2, upsampled_dim3, channels)

ZeroPadding1D

1
2
3

keras.layers.convolutional.ZeroPadding1D(
	padding=1/int
)

对1D输入的首尾端（如时域序列）填充0

• 说明

  • 以控制卷积以后向量的长度

• 参数

  • padding：整数，在axis 1起始和结束处填充0数目

• 输入：(batch, axis_to_pad, features)3DT

• 输出：(batch, paded_axis, features)3DT

ZeroPadding2D

1
2
3
4

keras.layers.convolutional.ZeroPadding2D(
	padding=(1, 1)/tuple/int,
	data_format=None
)

对2D输入（如图片）的边界填充0

• 说明

  • 以控制卷积以后特征图的大小

• 参数

  • padding：在要填充的轴的起始和结束处填充0的数目

ZeroPadding3D

1
2
3
4

keras.layers.convolutional.ZeroPadding3D(
	padding=(1, 1, 1),
	data_format=None
)

将数据的三个维度上填充0

• 说明
  • 本层目前只能在使用Theano为后端时可用

结束处填充0的数目

ZeroPadding3D

1
2
3
4

keras.layers.convolutional.ZeroPadding3D(
	padding=(1, 1, 1),
	data_format=None
)

将数据的三个维度上填充0

• 说明
  • 本层目前只能在使用Theano为后端时可用

?时可用

Layer方法

所有的Keras层对象都有如下方法：

• layer.get_weights()：返回层的权重NDA

• layer.set_weights(weights)：从NDA中将权重加载到该层中 ，要求NDA的形状与layer.get_weights()的形状相同

• layer.get_config()：返回当前层配置信息的字典，层也可以 借由配置信息重构

• layer.from_config(config)：根据config配置信息重构层

  1 2 3

  layer = Dense(32) config = layer.get_config() reconstructed_layer = Dense.from_config(config)

  1 2 3 4 5

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

非共享层

如果层仅有一个计算节点（即该层不是共享层），则可以通过下列 方法获得

• 输入张量：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)

参数

shape类型

• batch_size

  • batch_size在实际数据输入中为首维（0维）
  • shape类型参数传递的tuple中一般不包括batch_size维度
  • 输出时使用None表示(batch_size,...)

• time_step

  • 对时序数据，time_step在实际数据输入中第二维（1维）

input_shape

• 是Layer的初始化参数，所有Layer子类都具有

• 如果Layer是首层，需要传递该参数指明输入数据形状，否则 无需传递该参数

  • 有些子类有类似于input_dim等参数具有input_shape 部分功能

• None：表示该维度变长

输入、输出

• channels/depth/features：时间、空间单位上独立的数据， 卷积应该在每个channal分别“独立”进行

  • 对1维时序（时间），channels就是每时刻的features
  • 对2维图片（空间），channels就是色彩通道
  • 对3维视频（时空），channels就是每帧色彩通道
  • 中间数据，channnels就是每个filters的输出

• 1D：(batch, dim, channels)（channels_last）

• 2D：(batch, dim_1, dim_2, channels) （channels_last）

• 3D：(batch, dim_1, dim_2, dim_3, channels) （channels_last）

LeakyReLU

1

keras.layers.LeakyReLU(alpha=0.3)

带泄漏的修正线性单元。

• 返回值：当神经元未激活时，它仍可以赋予其一个很小的梯度

  • x < 0：alpha * x
  • x >= 0：x

• 输入尺寸

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

• 输出尺寸：与输入相同

• 参数

  • alpha：float >= 0，负斜率系数。

• 参考文献

  • Rectifier Nonlinearities Improve Neural Network Acoustic Models

PReLU

1
2
3
4
5
6

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

参数化的修正线性单元。

• 返回值

  • x < 0：alpha * x
  • x >= 0：x

• 参数

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

• 参考文献

  • Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification

ELU

1

keras.layers.ELU(alpha=1.0)

指数线性单元

• 返回值

  • x < 0：alpha * (exp(x) - 1.)
  • x >= 0：x

• 参数

  • alpha：负因子的尺度。

• 参考文献

  • Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)

ThresholdedReLU

1

keras.layers.ThresholdedReLU(theta=1.0)

带阈值的修正线性单元。

• 返回值

  • x > theta：x
  • x <= theta：0

• 参数

  • theta：float >= 0激活的阈值位。

• 参考文献

  • Zero-Bias Autoencoders and the Benefits of Co-Adapting Features

Softmax

1

keras.layers.Softmax(axis=-1)

Softmax激活函数

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

ReLU

1

keras.layers.ReLU(max_value=None)

ReLU激活函数

• 参数
  • max_value：浮点数，最大的输出值。

常用层对应于core模块，core内部定义了一系列常用的网络层，包括 全连接、激活层等

Dense层

1
2
3
4
5
6
7
8
9
10
11
12

keras.layers.core.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才会添加

• 参数

  • units：大于0的整数，代表该层的输出维度。

  • activation：激活函数

    • 为预定义的激活函数名（参考激活函数）
    • 逐元素（element-wise）的Theano函数
    • 不指定该参数，将不会使用任何激活函数 （即使用线性激活函数：a(x)=x）

  • use_bias: 布尔值，是否使用偏置项

  • kernel_initializer：权值初始化方法

    • 预定义初始化方法名的字符串
    • 用于初始化权重的初始化器（参考initializers）

  • bias_initializer：偏置向量初始化方法

    • 为预定义初始化方法名的字符串
    • 用于初始化偏置向量的初始化器（参考initializers）

  • kernel_regularizer：施加在权重上的正则项，为 Regularizer对象

  • bias_regularizer：施加在偏置向量上的正则项，为 Regularizer对象

  • activity_regularizer：施加在输出上的正则项，为 Regularizer对象

  • kernel_constraints：施加在权重上的约束项，为
    Constraints对象

  • bias_constraints：施加在偏置上的约束项，为 Constraints对象

• 输入

  • 形如(batch_size, ..., input_dim)的NDT，最常见情况 为(batch_size, input_dim)的2DT
  • 数据的维度大于2，则会先被压为与kernel相匹配的大小

• 输出

  • 形如(batch_size, ..., units)的NDT，最常见的情况为 $(batch_size, units)$的2DT

Activation层

1
2
3
4

keras.layers.core.Activation(
	activation,
	input_shape
)

激活层对一个层的输出施加激活函数

• 参数

  • activation：将要使用的激活函数
    • 预定义激活函数名
    • Tensorflow/Theano的函数（参考激活函数）

• 输入：任意，使用激活层作为第一层时，要指定input_shape

• 输出：与输入shape相同

Dropout层

1
2
3
4
5

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

为输入数据施加Dropout

• 说明

  • Dropout将在训练过程中每次更新参数时按一定概率rate 随机断开输入神经元

  • 可以用于防止过拟合

  • 参考文献：Dropout: A Simple Way to Prevent Neural Networks from Overfitting

• 参数

  • rate：0~1的浮点数，控制需要断开的神经元的比例

  • noise_shape：整数张量，为将要应用在输入上的二值 Dropout mask的shape

  • seed：整数，使用的随机数种子

• 输入

  • 例：(batch_size, timesteps, features)，希望在各个 时间步上Dropout mask都相同，则可传入 noise_shape=(batch_size, 1, features)

Flatten层

1

keras.layers.core.Flatten()

Flatten层用来将输入“压平”，把多维的输入一维化

• 常用在从卷积层到全连接层的过渡
• Flatten不影响batch的大小。

1
2
3
4
5
6
7
8

model = Sequential()
model.add(Convolution2D(64, 3, 3,
            border_mode='same',
            input_shape=(3, 32, 32)))
	# now: model.output_shape == (None, 64, 32, 32)

model.add(Flatten())
	# now: model.output_shape == (None, 65536)

Reshape层

1
2
3
4

keras.layers.core.Reshape(
	target_shape,
	input_shape
)

Reshape层用来将输入shape转换为特定的shape

• 参数

  • target_shape：目标shape，为整数的tuple，不包含样本 数目的维度（batch大小）
    • 包含-1表示推断该维度大小

• 输入：输入的shape必须固定（和target_shape积相同）

• 输出：(batch_size, *target_shape)

• 例

  1 2 3 4 5 6 7 8 9 10 11

  model = Sequential() model.add(Reshape((3, 4), input_shape=(12,))) # now: model.output_shape == (None, 3, 4) # note: `None` is the batch dimension model.add(Reshape((6, 2))) # now: model.output_shape == (None, 6, 2) # also supports shape inference using `-1` as dimension model.add(Reshape((-1, 2, 2))) # now: model.output_shape == (None, 3, 2, 2)

Permute层

1
2
3

keras.layers.core.Permute(
	dims(tuple)
)

Permute层将输入的维度按照给定模式进行重排

• 说明

  • 当需要将RNN和CNN网络连接时，可能会用到该层。

• 参数

  • dims：指定重排的模式，不包含样本数的维度（即下标 从1开始）

• 输出shape

  • 与输入相同，但是其维度按照指定的模式重新排列

• 例

  1 2 3

  model = Sequential() model.add(Permute((2, 1), input_shape=(10, 64))) # now: model.output_shape == (None, 64, 10)

RepeatVector层

1
2
3

keras.layers.core.RepeatVector(
	n(int)
)

RepeatVector层将输入重复n次

• 参数

  • n：整数，重复的次数

• 输入：形如(batch_size, features)的张量

• 输出：形如(bathc_size, n, features)的张量

• 例

  1 2 3 4 5 6

  model = Sequential() model.add(Dense(32, input_dim=32)) # now: model.output_shape == (None, 32) model.add(RepeatVector(3)) # now: model.output_shape == (None, 3, 32)

Lambda层

1
2
3
4
5
6

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

对上一层的输出施以任何Theano/TensorFlow表达式

• 参数

  • function：要实现的函数，该函数仅接受一个变量，即 上一层的输出

  • output_shape：函数应该返回的值的shape，可以是一个 tuple，也可以是一个根据输入shape计算输出shape的函数

  • mask: 掩膜

  • arguments：可选，字典，用来记录向函数中传递的其他 关键字参数

• 输出：output_shape参数指定的输出shape，使用TF时可自动 推断

• 例

  1 2	model.add(Lambda(lambda x: x ** 2)) # add a x -> x^2 layer

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  # add a layer that returns the concatenation # of the positive part of the input and # the opposite of the negative part 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))

ActivityRegularizer层

1
2
3
4

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

经过本层的数据不会有任何变化，但会基于其激活值更新损失函数值

• 参数
  • l1：1范数正则因子（正浮点数）
  • l2：2范数正则因子（正浮点数）

Masking层

1

keras.layers.core.Masking(mask_value=0.0)

使用给定的值对输入的序列信号进行“屏蔽”

• 说明

  • 用以定位需要跳过的时间步
  • 对于输入张量的时间步，如果输入张量在该时间步上都等于 mask_value，则该时间步将在模型接下来的所有层 （只要支持masking）被跳过（屏蔽）。
  • 如果模型接下来的一些层不支持masking，却接受到masking 过的数据，则抛出异常

• 输入：形如(samples,timesteps,features)的张量

• 例：缺少时间步为3和5的信号，希望将其掩盖
  • 方法：赋值x[:,3,:] = 0., x[:,5,:] = 0.
  • 在LSTM层之前插入mask_value=0.的Masking层

    1 2 3

    model = Sequential() model.add(Masking(mask_value=0., input_shape=(timesteps, features))) model.add(LSTM(32))

.`的Masking层

1
2
3

model = Sequential()
model.add(Masking(mask_value=0., input_shape=(timesteps, features)))
model.add(LSTM(32))

```

LocallyConnnected和Conv差不多，只是Conv每层共享卷积核， 这里不同位置卷积核独立

LocallyConnected1D层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

keras.layers.local.LocallyConnected1D(
	filters,
	kernel_size,
	strides=1,
	padding="valid",
	data_format=None,
	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
)

类似于Conv1D，单卷积核权重不共享

LocallyConnected2D层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

keras.layers.local.LocallyConnected2D(
	filters,
	kernel_size,
	strides=(1, 1),
	padding="valid",
	data_format=None,
	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
)

类似Conv2D，区别是不进行权值共享

• 说明
  • 输出的行列数可能会因为填充方法而改变
• 例

  1 2 3 4 5 6 7 8 9 10

  model = Sequential() model.add(LocallyConnected2D(64, (3, 3), input_shape=(32, 32, 3))) # apply a 3x3 unshared weights convolution with 64 output filters on a 32x32 image # with `data_format="channels_last"`: # now model.output_shape == (None, 30, 30, 64) # notice that this layer will consume (30*30)*(3*3*3*64) + (30*30)*64 parameters model.add(LocallyConnected2D(32, (3, 3))) # now model.output_shape == (None, 28, 28, 32) # add a 3x3 unshared weights convolution on top, with 32 output filters:

MaxPooling1D

1
2
3
4
5
6

keras.layers.pooling.MaxPooling1D(
	pool_size=2/int,
	strides=None/int,
	padding="valid"
	data_format=None
)

对时域1D信号进行最大值池化

• 参数

  • pool_size：整数，池化窗口大小
  • strides：整数或None，下采样因子，例如设2将会使得 输出shape为输入的一半，若为None则默认值为pool_size。

MaxPooling2D

1
2
3
4
5
6

keras.layers.pooling.MaxPooling2D(
	pool_size=(2, 2),
	strides=None/int/(int),
	padding="valid"/"same",
	data_format=None
)

为空域2D信号施加最大值池化

MaxPooling3D层

1
2
3
4
5
6

keras.layers.pooling.MaxPooling3D(
	pool_size=(2, 2, 2),
	strides=None/int/(int),
	padding="valid"/"same",
	data_format=None
)

为3D信号（空域或时空域）施加最大值池化

AveragePooling1D层

1
2
3
4
5
6

keras.layers.pooling.AveragePooling1D(
	pool_size=2,
	strides=None,
	padding="valid"
	data_format=None
)

对1D信号（时域）进行平均值池化

AveragePooling2D层

1
2
3
4
5
6

keras.layers.pooling.AveragePooling2D(
	pool_size=(2, 2),
	strides=None,
	padding="valid",
	data_format=None
)

为2D（空域）信号施加平均值池化

AveragePooling3D层

1
2
3
4
5
6

keras.layers.pooling.AveragePooling3D(
	pool_size=(2, 2, 2),
	strides=None,
	padding="valid",
	data_format=None
)

为3D信号（空域或时空域）施加平均值池化

GlobalMaxPooling1D层

1
2
3

keras.layers.pooling.GlobalMaxPooling1D(
	data_format="channels_last"
)

对于1D（时间）信号的全局最大池化

GlobalAveragePooling1D层

1
2
3

keras.layers.pooling.GlobalAveragePooling1D(
	data_forma="channels_last"
)

为时域信号施加全局平均值池化

GlobalMaxPooling2D层

1
2
3

keras.layers.pooling.GlobalMaxPooling2D(
	data_format=None
)

为空域信号施加全局最大值池化

GlobalAveragePooling2D层

1
2
3

keras.layers.pooling.GlobalAveragePooling2D(
	data_format=None
)

为2D（空域）信号施加全局平均值池化

RNN

1
2
3
4
5
6
7
8

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

循环神经网络层基类：抽象类、无法实例化对象

• 参数

  • cell：RNN单元实例、列表，为RNN单元列表时，单元 堆叠放置，实现高效堆叠RNN

  • return_sequences：返回输出序列最后值/全部序列

  • return_state：是否返回最后一个状态

  • go_backwards：是否向后处理输入序列并返回相反的序列。

  • stateful：批次中索引i处的每个样品的最后状态将 用作下一批次中索引i样品的初始状态

  • unroll：是否将网络展开（否则将使用符号循环）

    • 展开可以加速 RNN，但它往往会占用更多的内存
    • 展开只适用于短序列

  • input_dim：输入的维度（整数）

    • 将此层用作模型中的第一层时，此参数是必需的 （或者关键字参数 input_shape）

  • input_length： 输入序列的长度，在恒定时指定

    • 如果你要在上游连接 Flatten 和 Dense 层，则 需要此参数（没有它，无法计算全连接输出的尺寸）
    • 如果循环神经网络层不是模型中的第一层，则需要在 第一层的层级指定输入长度 （或通过关键字参数input_shape）

• 输入：(batch_size, timesteps, input_dim)3D张量

• 输出

  • return_state=True：则返回张量列表，第一个张量为 输出、剩余的张量为最后的状态，每个张量的尺寸为 (batch_size, units)。
  • return_state=False：(batch_size, units)2D张量

说明

• 屏蔽覆盖：支持以可变数量的时间步长对输入数据进行屏蔽覆盖

• 使用状态：可以将 RNN 层设置为 stateful（有状态的）

  • 这意味着针对一批中的样本计算的状态将被重新用作下一批 样品的初始状态

  • 这假定在不同连续批次的样品之间有一对一的映射。

  • 为了使状态有效：

    • 在层构造器中指定 stateful=True。
    • 为模型指定一个固定的批次大小
      • 顺序模型：为模型的第一层传递一个 batch_input_shape=(...) 参数
      • 带有Input层的函数式模型，为的模型的所有i 第一层传递一个batch_shape=(...)，这是输入 预期尺寸，包括批量维度
    • 在调用 fit() 是指定 shuffle=False。

  • 要重置模型的状态，请在特定图层或整个模型上调用 .reset_states()

• 初始状态

  • 通过使用关键字参数initial_state调用它们来符号化地 指定 RNN 层的初始状态（值应该是表示RNN层初始状态的 张量或张量列表）
  • 通过调用带有关键字参数states的reset_states方法 来数字化地指定 RNN 层的初始状态（值应该是一个代表RNN 层初始状态的NDA/[NDA]）

• RNN单元对象需要具有

  • call(input_at_t, states_at_t)方法，它返回 (output_at_t, states_at_t_plus_1)，单元的调用 方法也可以采用可选参数 constants
  • state_size属性
    • 单个整数（单个状态）：在这种情况下，它是循环层 状态大小（应该与单元输出的大小相同）
    • 整数的列表/元组（每个状态一个大小）：第一项应该 与单元输出的大小相同

• 传递外部常量

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

例子

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
27
28
29
30
31
32
33
34
35
36
37

class MinimalRNNCell(keras.layers.Layer):
	# 定义RNN细胞单元（网络层子类）
	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]

cell = MinimalRNNCell(32)
	# 在RNN层使用这个单元：
x = keras.Input((None, 5))
layer = RNN(cell)
y = layer(x)


cells = [MinimalRNNCell(32), MinimalRNNCell(64)]
	# 用单元格构建堆叠的RNN的方法：
x = keras.Input((None, 5))
layer = RNN(cells)
y = layer(x)

SimpleRNN

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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：要使用的激活函数

    • tanh：默认
    • None：则不使用激活函数，即线性激活：a(x) = x

  • use_bias：布尔值，该层是否使用偏置向量。

  • kernel_initializer：kernel权值矩阵的初始化器

  • recurrent_initializer：recurrent_kernel权值矩阵

  • bias_initializer：偏置向量的初始化器

  • 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：单元的丢弃比例，用于循环层状态线性 转换

  • return_sequences：返回输出序列中的全部序列

    • 默认：返回最后最后一个输出

  • return_state：除输出之外是否返回最后一个状态

  • go_backwards：向后处理输入序列并返回相反的序列

  • stateful：批次中索引 i 处的每个样品的最后状态，将用作 下一批次中索引 i 样品的初始状态

  • unroll：展开网络

GRU

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

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
)

门限循环单元网络

• 说明：有两种变体

  • 默认的基于1406.1078v3，并且在矩阵乘法之前将复位门 应用于隐藏状态

  • 另一种基于1406.1078v1并且顺序倒置

    • 兼容CuDNNGRU(GPU-only)，并且允许在 CPU 上进行 推理

    • 对于kernel和recurrent_kernel有可分离偏置 reset_after=True和recurrent_activation=sigmoid 。

• 参数

  • recurrent_activation：用于循环时间步的激活函数

  • implementation：实现模式

    • 1：将把它的操作结构化为更多的小的点积和加法操作

    • 2：将把它们分批到更少，更大的操作中

    • 这些模式在不同的硬件和不同的应用中具有不同的性能配置 文件

  • reset_after：GRU公约，在矩阵乘法之后使用重置门

• 参考文献

  • Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation
  • On the Properties of Neural Machine Translation：Encoder-Decoder Approaches
  • Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling
  • A Theoretically Grounded Application of Dropout in Recurrent Neural Networks

LSTM

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

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
)

长短期记忆网络层（Hochreiter 1997）

• 参数

  • unit_forget_bias
    • True：初始化时，将忘记门的偏置加 1，同时还会强制 bias_initializer="zeros"（这个建议来自 Jozefowicz et al.）

• 参考文献

  • Long short-term memory (original 1997 paper)
  • Learning to forget：Continual prediction with LSTM
  • Supervised sequence labeling with recurrent neural networks
  • A Theoretically Grounded Application of Dropout in Recurrent Neural Networks

ConvLSTM2D

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
27

keras.layers.ConvLSTM2D(
	filters(int),
	kernel_size(tuple(int, int)),
	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
)

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

• 说明

  • 当前的实现不包括单元输出的反馈回路

• 参数

  • dilation_rate：用于膨胀卷积的膨胀率
    • stride!=1与dilation_rate!=1两者不兼容。

• 输入尺寸

  • data_format="channels_first"：尺寸为 (batch, time, channels, rows, cols)
  • data_format="channels_last"：尺寸为 (batch, time, rows, cols, channels)

• 输出尺寸

  • return_sequences=True

    • data_format="channels_first"：返回尺寸为 (batch, time, filters, output_row, output_col)

    • data_format="channels_last"：返回尺寸为 (batch, time, output_row, output_col, filters)

  • return_seqences=False

    • data_format ="channels_first"：返回尺寸为 (batch, filters, output_row, output_col)

    • data_format="channels_last"：返回尺寸为 (batch, output_row, output_col, filters)

• 参考文献

  • Convolutional LSTM Network：A Machine Learning Approach for Precipitation Nowcasting

SimpleRNNCell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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
)

SimpleRNN的单元类

GRUCell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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
)

GRU层的单元类

LSTMCell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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
)

LSTM层的单元类

StackedRNNCells

1

keras.layers.StackedRNNCells(cells)

将一堆RNN单元表现为一个单元的封装器

• 说明

  • 用于实现高效堆叠的 RNN。

• 参数

  • cells：RNN 单元实例的列表

例子

1
2
3
4
5
6
7
8

cells = [
    keras.layers.LSTMCell(output_dim),
    keras.layers.LSTMCell(output_dim),
    keras.layers.LSTMCell(output_dim),
]

inputs = keras.Input((timesteps, input_dim))
x = keras.layers.RNN(cells)(inputs)

CuDNNGRU

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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
)

由 CuDNN 支持的快速GRU实现

• 说明

  • 只能以TensorFlow后端运行在GPU上

CuDNNLSTM

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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
)

由 CuDNN 支持的快速LSTM实现

• 说明

  • 只能以TensorFlow后端运行在GPU上