常用参数说明

• 函数书写声明同Python全局说明
• 以下常用参数如不特殊注明，按照此解释

Common

• seed=None/int

  • 含义：随机数种子

• padding="valid"/"same"/"causal"

  • 含义：补0策略
    • “valid”：只进行有效有效卷积，忽略边缘数据，输入 数据比输出数据shape减小
    • “same”：保留边界处卷积结果，输入数据和数据shape 相同
    • “causal”：产生膨胀（因果卷积），即output[t] 不依赖input[t+1:]，对不能违反时间顺序的时序 信号建模时有用
  • 默认：valid

Layers

• input_shape=None/(int,...)

  • 含义：输入数据shape
    • Layers只有首层需要传递该参数，之后层可自行推断
    • 传递tuple中None表示改维度边长
  • 默认：None，由Layers自行推断

• data_format=None/"channels_last"/"channels_first"

  • 含义：通道轴位置
    • 类似于dim_ordering，但是是Layer参数
  • 默认
    • 大部分：None由配置文件（默认”channels_last”） 、环境变量决定
    • Conv1DXX：”channels_last”
    • 其实也不一定，最好每次手动指定

• dim_ordering=None/"th"/"tf"

  • 含义：中指定channals轴位置(thbatch后首、tf尾）
  • 默认：None以Keras配置为准
  • 注意：Deprecated，Keras1.x中使用

Conv Layers

• filters(int)

  • 含义：输出维度
    • 对于卷积层，就是卷积核数目，因为卷积共享卷积核
    • 对于局部连接层，是卷积核组数，不共享卷积核 ，实际上对每组有很多不同权重

• kernel_size(int/(int)/[int])

  • 含义：卷积核形状，单值则各方向等长

• strides(int/(int)/[int])

  • 含义：卷积步长，单值则各方向相同
  • 默认：1移动一个步长

• dilation_rate(int/(int)/[int])

  • 含义：膨胀比例
    • 即核元素之间距离
    • dilation_rate、strides最多只能有一者为1， 即核膨胀、移动扩张最多只能出现一种
  • 默认：1不膨胀，核中个元素相距1

• use_bias=True/False

  • 含义：是否使用偏置项
  • 默认：True使用偏置项

• activation=str/func

  • 含义：该层激活函数
    • str：预定义激活函数字符串
    • func：自定义element-wise激活函数
  • 默认：None不做处理（即线性激活函数）

• kernel_initializer=str/func

  • 含义：权值初始化方法
    • str：预定义初始化方法名字符串 （参考Keras Initializer）
    • func：初始化权重的初始化器
  • 默认：glorot_uniform初始化为平均值

• bias_initializer=str/func

  • 含义：偏置初始化方法
    • str：预定义初始化方法名字符串
    • func：初始化权重的初始化器
  • 默认：zeros初始化为全0

• kernel_regularizer=None/obj

  • 含义：施加在权重上的正则项 （参考Keras Regularizer对象）
  • 默认：None不使用正则化项

• bias_regularizer=None/obj

  • 含义：施加在偏置上的正则项 （参考Keras Regularizer对象）
  • 默认：None不使用正则化项

• activity_regularizer=None/obj

  • 含义：施加在输出上的正则项 （参考Keras Regularizer对象）
  • 默认：None不使用正则化项

• kernel_constraint=None/obj

  • 含义：施加在权重上的约束项 （参考Keras Constraints）
  • 默认：None不使用约束项

• bias_constraint=None

  • 含义：施加在偏置上的约束项 （参考Keras Constraints）
  • 默认：None不使用约束项

• 通过设置单独的激活层实现

  1 2 3 4

  from keras.layers import Activation, Dense model.add(Dense(64)) model.add(Activation('tanh'))

• 也可以在构造层对象时通过传递activation参数实现

  1	model.add(Dense(64, activation='tanh'))

• 可以通过传递一个逐元素运算的Theano/TensorFlow/CNTK函数 来作为激活函数

  1 2 3 4

  from keras import backend as K model.add(Dense(64, activation=K.tanh)) model.add(Activation(K.tanh))

  softmax

1
2
3
4

softmax(
	x(tensor),
	axis=-1/int
)

Softmax激活函数

• 参数

  • x：张量
  • axis：整数，代表softmax所作用的维度

• 返回值：softmax变换后的张量。

• 异常：

  • ValueError： In case dim(x) == 1

elu

1
2
3
4

elu(
	x,
	alpha=1.0/num
)

指数线性单元

• 参数

  • alpha：一个标量，表示负数部分的斜率。

• 返回值：线性指数激活

  • 如果 x > 0，返回值为 x
  • 如果 x < 0 返回值为 alpha * (exp(x)-1)

• 参考文献

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

selu

1

selu(x)

可伸缩的指数线性单元（SELU）。

• 参数

  • x: 一个用来用于计算激活函数的张量或变量。

• 返回值：可伸缩线性指数激活

  • 可伸缩的指数线性激活：scale * elu(x, alpha) （scale, alpha应该是预定义常数？）

• 注意

  • 与「lecun_normal」初始化方法一起使用。
  • 与 dropout 的变种「AlphaDropout」一起使用。
  • 只要正确初始化权重（参见 lecun_normal 初始化方法） 并且输入的数量「足够大」（参见参考文献获得更多信息） ，选择合适的alpha和scale的值，就可以在两个连续层 之间保留输入的均值和方差

• 参考文献

  • Self-Normalizing Neural Networks

softplus

1

softplus(x)

Softplus 激活函数

• 返回值：$log(exp(x) + 1)$

softsign

1

softsign(x)

Softsign 激活函数

• 返回值：$x / (abs(x) + 1)$

relu

1
2
3
4
5

relu(
	x,
	alpha=0.0,
	max_value=None
)

线性修正单元。

• 参数

  • alpha：负数部分的斜率。默认为 0。
  • max_value：输出的最大值

• 返回值：线性修正单元激活

  • x > 0：返回值为 x
  • x < 0：返回值为 alpha * x
  • 如果定义了max_value，则结果将截断为此值

tanh

1

tanh(x)

双曲正切激活函数

sigmoid

1

sigmoid(x)

Sigmoid 激活函数

hard_sigmoid

1

hard_sigmoid(x)

Hard sigmoid 激活函数。

• 说明

  • 计算速度比 sigmoid 激活函数更快。

• 返回值：Hard sigmoid 激活：

  • x < -2.5：返回 0
  • x > 2.5：返回 1
  • -2.5 <= x <= 2.5：返回 0.2 * x + 0.5

linear

1

linear(x)

线性激活函数（即不做任何改变）

Keras配置文件

$HOME/.keras/keras.json

1
2
3
4
5
6
7
8
9
10

{
	"image_data_format": "channel_last",
		# 指定Keras将要使用数据维度顺序
	"epsilon": 1e-07,
		# 防止除0错误数字
	"flaotx": "float32",
		# 浮点数精度
	"backend": "tensorflow"
		# 指定Keras所使用后端
}

Keras后端

Keras是一个模型级的库，提供了快速构建深度学习网络的模块

• Keras并不处理如张量乘法、卷积等底层操作，而是依赖于某种 特定的、优化良好的张量操作库

• Keras依赖于处理张量的库就称为“后端引擎”

  • [Theano][Theano]：开源的符号主义张量操作框架，由 蒙特利尔大学LISA/MILA实验室开发
  • [Tensorflow][Tensorflow]：符号主义的张量操作框架， 由Google开发
  • [CNTK][CNTK]：由微软开发的商业级工具包

• Keras将其函数统一封装，使得用户可以以同一个接口调用不同 后端引擎的函数

• [Theano]: http://deeplearning.net/software/theano/
• [TensorFlow]: http://www.tensorflow.org/
• [CNTK]: https://www.microsoft.com/en-us/cognitive-toolkit/

切换后端

• 修改Keras配置文件
• 定义环境变量KERAS_BACKEND覆盖配置文件中设置（见python 修改环境变量的3中方式）

Keras后端抽象

可以通过Keras后端接口来编写代码，使得Keras模块能够同时在 Theano和TensorFlow两个后端上使用

• 大多数张量操作都可以通过统一的Keras后端接口完成，不必 关心具体执行后端

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

from keras import backend as K

input = K.placeholder(shape=(2, 4, 5))
input = K.placeholder(shape=(None, 4, 5))
input = K.placeholder(ndim=3)
	# 实例化输出占位符

val = np.random.random((3, 4, 5))
var = K.variable(value=val)
	# 实例化共享变量
	# 等价于`tf.Variable`、`theano.shared`
var = K.zeros(shape=(3, 4, 5))
var = K.ones(shape=(3, 4, 5))

配置相关函数

backend

返回当前后端

epsilon

1

K.epsilon()

返回数字表达式使用fuzz factor

set_epsilon

1

K.set_epsilon(e(float))

设置模糊因子的值

floatx

1

K.floatx()

返回默认的浮点数数据类型

• float16
• float32
• float64

set_floatx

1
2
3

K.set_floatx(
	floatx="float16"/"float32"/"float64"
)

设置默认的浮点数数据类型（字符串表示）

cast_to_floatx

1

K.cast_to_floatx(x)

将NDA转换为默认的Keras floatx类型（的NDA）

• 例子

  1 2 3 4 5 6 7 8

  K.floatx() # "float32" arr = np.array([1.0, 2.0], dtype="flaot64") arr.dtype # "float64" new_arr = K.cast_to_float(arr) new_arr.dtype # "float32"

image_data_format

1

K.image_data_format()

返回图像的默认维度顺序

• channels_last
• channels_first

set_image_data_format

1
2
3

K.set_image_data_format(
	data_format="channel_first"/"channel_last"
)

设置图像的默认维度顺序

辅助函数

is_keras_tensor

判断是否是Keras Tensor对象

1
2
3
4
5
6
7
8
9
10
11

np_var = np.array([1, 2])
K.is_keras_tensor(np_var)
	# False
keras_var = K.variable(np_var)
K.is_keras_tensor(keras_var)
	# A variable is not a Tensor.
	# False
keras_placeholder = K.placeholder(shape=(2, 4, 5))
K.is_keras_tensor(keras_placeholder)
	# A placeholder is a Tensor.
	# True

get_uid

1

K.get_uid(prefix=''/str)

获得默认计算图的uid

• 说明

  • 依据给定的前缀提供一个唯一的UID

• 参数

  • prefix：图的可选前缀

• 返回值：图的唯一标识符

reset_uids

1

K.reset_uids()

重置图的标识符

clear_session

1

K.clear_session()

结束当前的TF计算图，并创建新图

• 说明
  • 有效的避免模型/网络层的混乱

manual_variable_initialization

1
2
3

K.manual_variable_initialization(
	value=False/True
)

设置变量手动初始化标志

• 参数

  • value

    • False：默认，变量在实例时出事的（由其默认值 初始化）

    • True：用户自行初始化，如 tf.initialize_all_variables()

learning_phase

返回学习阶段标致

• 返回值：布尔张量

  • 0：测试模式
  • 1：训练模式

set_learning_phase

1
2
3

K.set_learning_phase(
	value=0/1
)

设置学习阶段为固定值

• 参数
  • value：学习阶段值
    • 0：测试模式
    • 1：训练模式

OPs、Tensors

is_sparse

判断一个Tensor是不是一个稀疏的Tensor

• 返回值：布尔值

稀不稀疏由Tensor的类型决定，而不是Tensor实际上有多稀疏

1
2
3
4
5
6
7

from keras import backend as K
a = K.placeholder((2, 2), sparse=False)
print(K.is_sparse(a))
	# False
b = K.placeholder((2, 2), sparse=True)
print(K.is_sparse(b))
	# True

to_dense

将一个稀疏tensor转换一个不稀疏的tensor并返回

variable

1
2
3
4
5

def variable(
	value,
	dtype='float32'/str,
	name=None
)

实例化一个张量，返回之

• 参数
  • value：用来初始化张量的值
  • dtype：张量数据类型
  • name：张量的名字（可选）

placeholder

1
2
3
4
5
6

def placeholder(
	shape=None,
	ndim=None,
	dtype='float32'/str,
	name=None
)

实例化一个占位符

• 参数

  • shape：占位符的shape（整数tuple，可能包含None）
  • ndim: 占位符张量的阶数
    • 要初始化占位符，至少指定shape和ndim之一， 如果都指定则使用shape
  • dtype: 占位符数据类型
  • name: 占位符名称（可选）

shape

1

def shape(x)

返回张量的符号shape

• 返回值：OPs（需要执行才能得到值）

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

from keras import backend as K
tf_session = K.get_session()
val = np.array([[1, 2], [3, 4]])
kvar = K.variable(value=val)
input = keras.backend.placeholder(shape=(2, 4, 5))
K.shape(kvar)
	# <tf.Tensor 'Shape_8:0' shape=(2,) dtype=int32>
K.shape(input)
	# <tf.Tensor 'Shape_9:0' shape=(3,) dtype=int32>
	# To get integer shape (Instead, you can use K.int_shape(x))
K.shape(kvar).eval(session=tf_session)
	# array([2, 2], dtype=int32)
K.shape(input).eval(session=tf_session)
	# array([2, 4, 5], dtype=int32)

int_shape

1

def int_shape(x)

返回张量shape

• 返回值：tuple(int)/None

1
2
3
4
5
6
7
8

from keras import backend as K
input = K.placeholder(shape=(2, 4, 5))
K.int_shape(input)
	# (2, 4, 5)
val = np.array([[1, 2], [3, 4]])
kvar = K.variable(value=val)
K.int_shape(kvar)
	# (2, 2)

ndim

1

def ndim(x)

返回张量的阶数

• 返回值：int

1
2
3
4
5
6
7
8

from keras import backend as K
input = K.placeholder(shape=(2, 4, 5))
val = np.array([[1, 2], [3, 4]])
kvar = K.variable(value=val)
K.ndim(input)
	# 3
K.ndim(kvar)
	# 2

dtype

1

def dtype(x)

返回张量的数据类型

• 返回值：str
  • float32
  • float32_ref

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

from keras import backend as K
K.dtype(K.placeholder(shape=(2,4,5)))
	# 'float32'
K.dtype(K.placeholder(shape=(2,4,5), dtype='float32'))
	# 'float32'
K.dtype(K.placeholder(shape=(2,4,5), dtype='float64'))
	# 'float64'__Keras variable__

kvar = K.variable(np.array([[1, 2], [3, 4]]))
K.dtype(kvar)
	# 'float32_ref'
kvar = K.variable(np.array([[1, 2], [3, 4]]), dtype='float32')
K.dtype(kvar)
	# 'float32_ref'

eval

1

def eval(x)

求得张量的值

• 返回值：NDA

1
2
3
4
5

from keras import backend as K
kvar = K.variable(np.array([[1, 2], [3, 4]]), dtype='float32')
K.eval(kvar)
	# array([[ 1.,  2.],
	#	[ 3.,  4.]], dtype=float32)

`zeros

1
2
3
4
5

def zeros(
	shape,
	dtype='float32',
	name=None
)

生成shape大小的全0张量

1
2
3
4
5
6

from keras import backend as K
kvar = K.zeros((3,4))
K.eval(kvar)
	# array([[ 0.,  0.,  0.,  0.],
	#	[ 0.,  0.,  0.,  0.],
	#	[ 0.,  0.,  0.,  0.]], dtype=float32)

ones

1
2
3
4
5

def ones(
	shape,
	dtype='float32',
	name=None
)

生成shape大小的全1张量

eye

1
2
3
4
5

def eye(
	size,
	dtype='float32',
	name=None
)

生成size大小的单位阵

zeros_like

1
2
3
4

def zeros_like(
	x,
	name=None
)

生成与x shape相同的全0张量

ones_like

1
2
3
4

def ones_like(
	x,
	name=None
)

生成与x shape相同的全1张量

随机常量OPs

random_uniform_variable

1
2
3
4
5
6
7
8

def random_uniform_variable(
	shape,
	low,
	high,
	dtype=None,
	name=None,
	seed=None
)

初始化均匀分布常量OPs

• 参数
  • low：浮点数，均匀分布之下界
  • high：浮点数，均匀分布之上界
  • dtype：数据类型
  • name：张量名
  • seed：随机数种子

count_params

1

def count_params(x)

返回张量中标量的个数

cast

1

def cast(x, dtype)

改变张量的数据类型

• 参数
  • dtype：float16/float32/float64

update

1

def update(x, new_x)

用new_x更新x

update_add

1

def update_add(x, increment)

将x增加increment并更新x

update_sub

1

def update_sub(x, decrement)

将x减少decrement并更新x

moving_average_update

1
2
3
4
5

def moving_average_update(
	x,
	value,
	momentum
)

使用移动平均更新x

dot

1

def dot(x, y)

求两个张量的点乘

1
2
3
4
5

x = K.placeholder(shape=(2, 3))
y = K.placeholder(shape=(3, 4))
xy = K.dot(x, y)
xy
	# <tf.Tensor 'MatMul_9:0' shape=(2, 4) dtype=float32>

• 当试图计算两个N阶张量的乘积时，与Theano行为相同 (2, 3).(4, 3, 5) = (2, 4, 5))

  1 2 3 4 5

  x = K.placeholder(shape=(32, 28, 3)) y = K.placeholder(shape=(3, 4)) xy = K.dot(x, y) xy # <tf.Tensor 'MatMul_9:0' shape=(32, 28, 4) dtype=float32>

  1 2 3 4 5

  x = K.random_uniform_variable(shape=(2, 3), low=0, high=1) y = K.ones((4, 3, 5)) xy = K.dot(x, y) K.int_shape(xy) # (2, 4, 5)

batch_dot

1

def batch_dot(x, y, axes=None)

按批进行张量x和y的点积

• 参数
  • x：按batch分块的数据
  • y；同x
  • axes：指定进行点乘的轴

1
2
3
4
5

x_batch = K.ones(shape=(32, 20, 1))
y_batch = K.ones(shape=(32, 30, 20))
xy_batch_dot = K.batch_dot(x_batch, y_batch, axes=[1, 2])
K.int_shape(xy_batch_dot)
	# (32, 1, 30)

transpose

1

def transpose(x)

张量转置

gather

1

def gather(reference, indices)

在给定的张量中检索给定下标的向量

• 参数

  • reference：张量
  • indices：整数张量，其元素为要查询的下标

• 返回值：同reference数据类型相同的张量

max

1
2
3
4
5

def max(
	x,
	axis=None/int,
	keepdims=False
)

求张量中的最大值

min

1

def min(x, axis=None, keepdims=False)

求张量中的最小值

sum

1

sum(x, axis=None, keepdims=False)

计算张量中元素之和

prod

1

prod(x, axis=None, keepdims=False)

计算张量中元素之积

cumsum

1

def cumsum(x, axis=0)

在给定轴上求张量的累积和

cumprod

1

cumprod(x, axis=0)

在给定轴上求张量的累积积

var

1

def var(x, axis=None, keepdims=False)

在给定轴上计算张量方差

std

1

def std(x, axis=None, keepdims=False)

在给定轴上求张量元素之标准差

mean

1

def mean(x, axis=None, keepdims=False)

在给定轴上求张量元素之均值

any

1

def any(x, axis=None, keepdims=False)

按位或，返回数据类型为uint8的张量（元素为0或1）

all

1

def any(x, axis=None, keepdims=False)

按位与，返回类型为uint8de tensor

argmax

1

def argmax(x, axis=-1)

在给定轴上求张量之最大元素下标

argmin

1

def argmin(x, axis=-1)

在给定轴上求张量之最小元素下标

Element-Wise OPs

square

1

def square(x)

逐元素平方

abs

1

def abs(x)

逐元素绝对值

sqrt

1

sqrt(x)

逐元素开方

exp

1

def exp(x)

逐元素求自然指数

log

1

def log(x)

逐元素求自然对数

logsumexp

1

def logsumexp(x, axis=None, keepdims=False)

在给定轴上计算log(sum(exp()))

• 该函数在数值稳定性上超过手动计算log(sum(exp()))，可以 避免由exp和log导致的上溢和下溢

round

1

def round(x)

逐元素四舍五入

sign

1

def sign(x)

逐元素求元素的符号

• 返回值
  • +1
  • -1

pow

1

def pow(x, a)

逐元素求x的a次方

clip

1
2
3
4
5

def clip(
	x,
	min_value,
	max_value
)

逐元素clip（将超出指定范围的数强制变为边界值）

equal

1

def equal(x, y)

逐元素判相等关系

• 返回值：布尔张量OP

not_equal

1

def not_equal(x, y)

逐元素判不等关系

greater

1

def greater(x,y)

逐元素判断x>y关系

greater_equal

1

def greater_equal(x,y)

逐元素判断x>=y关系

lesser

1

def lesser(x,y)

逐元素判断x<y关系

lesser_equal

1

def lesser_equal(x,y)

逐元素判断x<=y关系

maximum

1

def maximum(x, y)

逐元素取两个张量的最大值

minimum

1

def minimum(x, y)

逐元素取两个张量的最小值

sin

1

def sin(x)

逐元素求正弦值

cos

1

def cos(x)

逐元素求余弦值

变换OPs

batch_normalization

1
2
3
4
5
6
7
8

def batch_normalization(
	x,
	mean,
	var,
	beta,
	gamma,
	epsilon=0.0001
)

对batch的数据进行batch_normalization，计算公式为： $output = (x-mean)/(\sqrt(var)+\epsilon)*\gamma+\beta$

• 手动指定mean、var

normalize_batch_in_training

1
2
3
4
5
6
7

def normalize_batch_in_training(
	x,
	gamma,
	beta,
	reduction_axes,
	epsilon=0.0001
)

对batch数据先计算其均值和方差，然后再进行 batch_normalization

concatenate

1

def concatenate(tensors, axis=-1)

在给定轴上将一个列表中的张量串联为一个张量

reshape

1

def reshape(x, shape)

将张量的shape变换为指定shape

permute_dimensions

1
2
3
4

def permute_dimensions(
	x,
	pattern(tuple(int))
)

按照给定的模式重排一个张量的轴

• 参数
  • pattern：代表维度下标的tuple如(0, 2, 1)

resize_images

1
2
3
4
5
6

def resize_images(
	X,
	height_factor(uint),
	width_factor(uint),
	dim_ordering=None/'th'/'tf'
)

依据给定的缩放因子height_factor、width_factor，改变batch 数据（图片）的shape

• 参数
  • height_factor/width_factor：正整数

resize_volumes

1
2
3
4
5
6
7

def resize_volumes(
	X,
	depth_factor,
	height_factor,
	width_factor,
	dim_ordering
)

依据给定的缩放因子，改变一个5D张量数据的shape

repeat_elements

1

def repeat_elements(x, rep, axis)

在给定轴上重复张量元素rep次

• 与np.repeat类似

repeat

1

def repeat(x, n)

重复2D张量

arange

1
2
3
4
5
6

def arange(
	start,
	stop=None,
	step=1,
	dtype="int32"
)

生成1D的整数序列张量

• 参数：同np.arange

  • 如果只有一个参数被提供了，则0~stop

• 返回值：默认数据类型是int32的张量

tile

1

def tile(x, n)

将x在各个维度上重复n[i]次

batch_flatten

1

def batch_flatten(x)

将n阶张量转变为2阶张量，第一维度保留不变

expand_dims

1

def expand_dims(x, dim=-1)

在dim指定轴后增加一维（轴）

squeeze

1

def squeeze(x, axis)

将axis指定的轴从张量中移除（保留轴上首组张量切片）

temporal_padding

1

def temporal_padding(x, padding=1)

向3D张量中间那个维度的左右两端填充padding个0值

asymmetric_temporal_padding

1
2
3
4
5

def asymmetric_temporal_padding(
	x,
	left_pad=1,
	right_pad=1
)

向3D张量中间的那个维度的左右分别填充0值

spatial_2d_padding

1
2
3
4
5

def spatial_2d_padding(
	x,
	padding=(1, 1),
	dim_ordering='th'
)

向4D张量高度、宽度左右两端填充padding[0]和padding[1] 个0值

spatial_3d_padding

1
2
3
4
5

def spatial_3d_padding(
	x,
	padding=(1, 1, 1),
	dim_ordering='th'
)

向5D张量深度、高度、宽度三个维度上填充0值

stack

1

def stack(x, axis=0)

将列表x中张量堆积起来形成维度+1的新张量

one_hot

1

def one_hot(indices, nb_classes)

为张量indices进行one_hot编码

• 参数
  • indices：n维的整数张量
  • nb_classes：one_hot编码列表
• 输出：n+1维整数张量，最后维为编码

reverse

1

def reverse(x, axes)

将一个张量在给定轴上反转

get_value

1

def get_value(x)

以NDA的形式返回张量的值

batch_get_value

1

def batch_get_value(x)

以[NDA]的形式返回多个张量的值

set_value

1

def set_value(x, value)

从NDA将值载入张量中

batch_set_value

1

def batch_set_value(tuples)

将多个值载入多个张量变量中

print_tensor

1

def print_tensor(x, message='')

在求值时打印张量的信息，并返回原张量

function

1

def function(inputs, outputs, updates=[])

实例化一个Keras函数

• 参数
  • inputs：列表，其元素为占位符或张量变量
  • outputs：输出张量的列表
  • updates：张量列表

gradients

1

def gradients(loss, variables)

返回loss函数关于variables的梯度

stop_gradient

1

def stop_gradient(variables)

Returns variables but with zero gradient with respect to every other variables.

rnn

1
2
3
4
5
6
7
8
9
10

def rnn(
	step_function,
	inputs,
	initial_states,
	go_backwards=False,
	mask=None,
	constants=None,
	unroll=False,
	input_length=None
)

在张量的时间维上迭代

• 参数：

  • inputs：时域信号的张量，阶数至少为3

  • step_function：每个时间步要执行的函数

    参数

    • input：不含时间维张量，代表某时间步batch样本
    • states：张量列表

    返回值

    • output：形如(samples, ...)的张量
    • new_states：张量列表，与states的长度相同

  • initial_states：包含step_function状态初始值

  • go_backwards：逆向迭代序列

  • mask：需要屏蔽的数据元素上值为1

  • constants：按时间步传递给函数的常数列表

  • unroll

    • 当使用TF时，RNN总是展开的’
    • 当使用Theano时，设置该值为True将展开递归网络

  • input_length

    • TF：不需要此值
    • Theano：如果要展开递归网络，必须指定输入序列

• 返回值：形如(last_output, outputs, new_states)的张量

  • last_output：RNN最后的输出
  • outputs：每个在[s,t]点的输出对应于样本s在t时间的输出
  • new_states: 每个样本的最后一个状态列表

switch

1
2
3
4
5

def switch(
	condition,
	then_expression,
	else_expression
)

依据给定condition（整数或布尔值）在两个表达式之间切换

• 参数
  • condition：标量张量
  • then_expression：TensorFlow表达式
  • else_expression: TensorFlow表达式

in_train_phase

1

def in_train_phase(x, alt)

如果处于训练模式，则选择x，否则选择alt

• 注意alt应该与x的shape相同

in_test_phase

1

def in_test_phase(x, alt)

如果处于测试模式，则选择x，否则选择alt

• 注意：alt应该与x的shape相同

预定义（激活）函数

relu

1
2
3
4
5

def relu(
	x,
	alpha=0.0,
	max_value=None
)

修正线性单元

• 参数
  • alpha：负半区斜率
  • max_value: 饱和门限

elu

1

def elu(x, alpha=1.0)

指数线性单元

• 参数
  • x：输入张量
  • alpha: 标量

softmax

1

def softmax(x)

计算张量的softmax值

softplus

1

def softplus(x)

返回张量的softplus值

softsign

1

def softsign(x)

返回张量的softsign值

sigmoid

1

def sigmoid(x)

逐元素计算sigmoid值

hard_sigmoid

1

def hard_sigmoid(x)

分段线性近似的sigmoid，计算速度更快

tanh

1

def tanh(x)

逐元素计算tanh值

预定义目标函数

categorical_crossentropy

1
2
3
4
5

def categorical_crossentropy(
	output,
	target,
	from_logits=False
)

计算output、target的Categorical Crossentropy（类别交叉熵）

• 参数
  • output/target：shape相等

sparse_categorical_crossentropy

1
2
3
4
5

def sparse_categorical_crossentropy(
	output,
	target,
	from_logits=False
)

计算output、target的Categorical Crossentropy（类别交叉熵）

• 参数
  • output
  • target：同output shape相等，需为整形张量

binary_crossentropy

1
2
3
4
5

def binary_crossentropy(
	output,
	target,
	from_logits=False
)

计算输出张量和目标张量的交叉熵

dropout

1

def dropout(x, level, seed=None)

随机将x中一定比例的值设置为0，并放缩整个Tensor

l2_normalize

1

def l2_normalize(x, axis)

在给定轴上对张量进行L2范数规范化

in_top_k

1

def in_top_k(predictions, targets, k)

判断目标是否在predictions的前k大值位置

参数

• predictions：预测值张量
• targets：真值张量
• k：整数

conv1d

1
2
3
4
5
6
7
8

def conv1d(
	x,
	kernel,
	strides=1,
	border_mode="valid"/"same",
	image_shape=None,
	filter_shape=None
)

1D卷积

• 参数
  • kernel：卷积核张量
  • strides：步长，整型
  • border_mode
    • “same”：
    • “valid”：

conv2d

1
2
3
4
5
6
7
8
9

def conv2d(
	x,
	kernel,
	strides=(1, 1),
	border_mode="valid"/"same",
	dim_ordering="th"/"tf",
	image_shape=None,
	filter_shape=None
)

2D卷积

• 参数
  • kernel：卷积核张量
  • strides：步长，长为2的tuple

deconv2d

1
2
3
4
5
6
7
8
9
10

def deconv2d(
	x,
	kernel,
	output_shape,
	strides=(1, 1),
	border_mode="valid"/"same",
	dim_ordering="th"/"tf",
	image_shape=None,
	filter_shape=None
)

2D反卷积（转置卷积）

• 参数
  • x：输入张量
  • kernel：卷积核张量
  • output_shape: 输出shape的1D的整数张量
  • strides：步长，tuple类型

conv3d

1
2
3
4
5
6
7
8
9

def conv3d(
	x,
	kernel,
	strides=(1, 1, 1),
	border_mode="valid"/"same",
	dim_ordering="th"/"tf",
	volume_shape=None,
	filter_shape=None
)

3D卷积

pool2d

1
2
3
4
5
6
7
8

def pool2d(
	x,
	pool_size,
	strides=(1, 1),
	border_mode="valid"/"same",
	dim_ordering="th"/"tf",
	pool_mode="max"/"avg"
)

2D池化

• 参数
  • pool_size：含有两个整数的tuple，池的大小
  • strides：含有两个整数的tuple，步长
  • pool_mode: “max”，“avg”之一，池化方式

pool3d

1
2
3
4
5
6
7
8

def pool3d(
	x,
	pool_size,
	strides=(1, 1, 1),
	border_mode="valid"/"same",
	dim_ordering="th"/"tf",
	pool_mode="max"/"avg"
)

3D池化

bias_add

1

def bias_add(x, bias, data_format=None)

为张量增加一个偏置项

random_normal

1
2
3
4
5
6
7

def random_normal(
	shape,
	mean=0.0,
	stddev=1.0,
	dtype=None,
	seed=None
)

生成服从正态分布的张量

• 参数
  • mean：均值
  • stddev：标准差

random_uniform

1
2
3
4
5
6
7

def random_uniform(
	shape,
	minval=0.0,
	maxval=1.0,
	dtype=None,
	seed=None
)

生成服从均匀分布值的张量

• 参数
  • minval：上界
  • maxval：上界

random_binomial

1
2
3
4
5
6

def random_binomial(
	shape,
	p=0.0,
	dtype=None,
	seed=None
)

返回具有二项分布值的张量

• 参数
  • p：二项分布参数

truncated_normall

1
2
3
4
5
6
7

def truncated_normal(
	shape,
	mean=0.0,
	stddev=1.0,
	dtype=None,
	seed=None
)

生成服从截尾正态分布值的张量，即在距离均值两个标准差之外的 数据将会被截断并重新生成

ctc_label_dense_to_sparse

1

def ctc_label_dense_to_sparse(labels, label_lengths)

将ctc标签从稠密形式转换为稀疏形式

ctc_batch_cost

1
2
3
4
5
6

def ctc_batch_cost(
	y_true,
	y_pred,
	input_length,
	label_length
)

在batch上运行CTC损失算法

• 参数

  • y_true：包含标签的真值张量
  • y_pred：包含预测值或输出的softmax值的张量
  • input_length：包含y_pred中每个batch的序列长
  • label_length：包含y_true中每个batch的序列长张量

• 返回值：包含了每个元素的CTC损失的张量

ctc_decode

1
2
3
4
5
6
7
8

def ctc_decode(
	y_pred,
	input_length,
	greedy=True,
	beam_width=None,
	dict_seq_lens=None,
	dict_values=None
)

使用贪婪算法或带约束的字典搜索算法解码softmax的输出

• 参数

  • y_pred：包含预测值或输出的softmax值的张量
  • input_length：包含y_pred中每个batch序列长的张量
  • greedy：使用贪婪算法
  • dict_seq_lens：dic_values列表中各元素的长度
  • dict_values：列表的列表，代表字典

• 返回值：包含了路径可能性（以softmax概率的形式）张量

• 注意仍然需要一个用来取出argmax和处理空白标签的函数

map_fn

1

def map_fn(fn, elems, name=None)

元素elems在函数fn上的映射，并返回结果

• 参数

  • fn：函数
  • elems：张量
  • name：节点的名字

• 返回值：张量的第一维度等于elems，第二维度取决于fn

foldl

1
2
3
4
5
6

def foldl(
	fn,
	elems,
	initializer=None,
	name=None
)

用fn从左到右连接它们，以减少elems值

• 参数

  • fn：函数，例如：lambda acc, x: acc + x
  • elems：张量
  • initializer：初始化的值(elems[0])
  • name：节点名

• 返回值：与initializer类型和形状一致

foldr

1
2
3
4
5
6

def foldr(
	fn,
	elems,
	initializer=None,
	name=None
)

减少elems，用fn从右到左连接它们

• 参数

  • fn：函数，例如：lambda acc, x: acc + x
  • elems：张量
  • initializer：初始化的值（elems[-1]）
  • name：节点名

• 返回值：与initializer类型和形状一致

_width=None, dict_seq_lens=None, dict_values=None )

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

使用贪婪算法或带约束的字典搜索算法解码softmax的输出

-	参数

	-	`y_pred`：包含预测值或输出的softmax值的张量
	-	`input_length`：包含`y_pred`中每个batch序列长的张量
	-	`greedy`：使用贪婪算法
	-	`dict_seq_lens`：`dic_values`列表中各元素的长度
	-	`dict_values`：列表的列表，代表字典

-	返回值：包含了路径可能性（以softmax概率的形式）张量

-	注意仍然需要一个用来取出argmax和处理空白标签的函数

####	`map_fn`

```python
def map_fn(fn, elems, name=None)

元素elems在函数fn上的映射，并返回结果

• 参数

  • fn：函数
  • elems：张量
  • name：节点的名字

• 返回值：张量的第一维度等于elems，第二维度取决于fn

foldl

1
2
3
4
5
6

def foldl(
	fn,
	elems,
	initializer=None,
	name=None
)

用fn从左到右连接它们，以减少elems值

• 参数

  • fn：函数，例如：lambda acc, x: acc + x
  • elems：张量
  • initializer：初始化的值(elems[0])
  • name：节点名

• 返回值：与initializer类型和形状一致

foldr

1
2
3
4
5
6

def foldr(
	fn,
	elems,
	initializer=None,
	name=None
)

减少elems，用fn从右到左连接它们

• 参数

  • fn：函数，例如：lambda acc, x: acc + x
  • elems：张量
  • initializer：初始化的值（elems[-1]）
  • name：节点名

• 返回值：与initializer类型和形状一致

• name：节点名

• 返回值：与initializer类型和形状一致

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