Keras 后端

什么是 「后端」？

Keras 是一个模型级库，为开发深度学习模型提供了高层次的构建模块。它不处理诸如张量乘积和卷积等低级操作。相反，它依赖于一个专门的、优化的张量操作库来完成这个操作，它可以作为 Keras 的「后端引擎」。相比单独地选择一个张量库，而将 Keras 的实现与该库相关联，Keras 以模块方式处理这个问题，并且可以将几个不同的后端引擎无缝嵌入到 Keras 中。

目前，Keras 有三个后端实现可用: TensorFlow 后端，Theano 后端，CNTK 后端。

• TensorFlow 是由 Google 开发的一个开源符号级张量操作框架。
• Theano 是由蒙特利尔大学的 LISA Lab 开发的一个开源符号级张量操作框架。
• CNTK 是由微软开发的一个深度学习开源工具包。

将来，我们可能会添加更多后端选项。

从一个后端切换到另一个后端

如果您至少运行过一次 Keras，您将在以下位置找到 Keras 配置文件：

$HOME/.keras/keras.json

如果它不在那里，你可以创建它。

Windows用户注意事项： 请将 $HOME 修改为 %USERPROFILE%。

默认的配置文件如下所示：

{
    "image_data_format": "channels_last",
    "epsilon": 1e-07,
    "floatx": "float32",
    "backend": "tensorflow"
}

只需将字段 backend 更改为 theano，tensorflow 或 cntk，Keras 将在下次运行 Keras 代码时使用新的配置。

你也可以定义环境变量 KERAS_BACKEND，这会覆盖配置文件中定义的内容：

KERAS_BACKEND=tensorflow python -c "from keras import backend"
Using TensorFlow backend.

在 Keras 中，可以加载比 "tensorflow", "theano" 和 "cntk" 更多的后端。Keras 也可以使用外部后端，这可以通过更改 keras.json 配置文件和 "backend" 设置来执行。 假设您有一个名为 my_module 的 Python 模块，您希望将其用作外部后端。keras.json 配置文件将更改如下：

{
    "image_data_format": "channels_last",
    "epsilon": 1e-07,
    "floatx": "float32",
    "backend": "my_package.my_module"
}

必须验证外部后端才能使用，有效的后端必须具有以下函数：placeholder, variable and function.

如果由于缺少必需的条目而导致外部后端无效，则会记录错误，通知缺少哪些条目。

keras.json 详细配置

The keras.json 配置文件包含以下设置：

{
    "image_data_format": "channels_last",
    "epsilon": 1e-07,
    "floatx": "float32",
    "backend": "tensorflow"
}

您可以通过编辑 $ HOME/.keras/keras.json 来更改这些设置。

• image_data_format: 字符串，"channels_last" 或者 "channels_first"。它指定了 Keras 将遵循的数据格式约定。(keras.backend.image_data_format() 返回它。)
  • 对于 2D 数据 (例如图像)，"channels_last" 假定为 (rows, cols, channels)，而 "channels_first" 假定为 (channels, rows, cols)。
  • 对于 3D 数据， "channels_last" 假定为 (conv_dim1, conv_dim2, conv_dim3, channels)，而 "channels_first" 假定为 (channels, conv_dim1, conv_dim2, conv_dim3)。
• epsilon: 浮点数，用于避免在某些操作中被零除的数字模糊常量。
• floatx: 字符串，"float16", "float32", 或 "float64"。默认浮点精度。
• backend: 字符串， "tensorflow", "theano", 或 "cntk"。

使用抽象 Keras 后端编写新代码

如果你希望你编写的 Keras 模块与 Theano (th) 和 TensorFlow (tf) 兼容，则必须通过抽象 Keras 后端 API 来编写它们。以下是一个介绍。

您可以通过以下方式导入后端模块：

from keras import backend as K

下面的代码实例化一个输入占位符。它等价于 tf.placeholder() 或 th.tensor.matrix(), th.tensor.tensor3(), 等等。

inputs = K.placeholder(shape=(2, 4, 5))
# 同样可以：
inputs = K.placeholder(shape=(None, 4, 5))
# 同样可以：
inputs = K.placeholder(ndim=3)

下面的代码实例化一个变量。它等价于 tf.Variable() 或 th.shared()。

import numpy as np
val = np.random.random((3, 4, 5))
var = K.variable(value=val)
# 全 0 变量：
var = K.zeros(shape=(3, 4, 5))
# 全 1 变量：
var = K.ones(shape=(3, 4, 5))

你需要的大多数张量操作都可以像在 TensorFlow 或 Theano 中那样完成：

# 使用随机数初始化张量
b = K.random_uniform_variable(shape=(3, 4), low=0, high=1) # 均匀分布
c = K.random_normal_variable(shape=(3, 4), mean=0, scale=1) # 高斯分布
d = K.random_normal_variable(shape=(3, 4), mean=0, scale=1)
# 张量运算
a = b + c * K.abs(d)
c = K.dot(a, K.transpose(b))
a = K.sum(b, axis=1)
a = K.softmax(b)
a = K.concatenate([b, c], axis=-1)
# 等等

后端函数

epsilon

keras.backend.epsilon()

返回数字表达式中使用的模糊因子的值。

返回

一个浮点数。

例子

>>> keras.backend.epsilon()
1e-07

set_epsilon

keras.backend.set_epsilon(e)

设置数字表达式中使用的模糊因子的值。

参数

• e: 浮点数。新的 epsilon 值。

例子

>>> from keras import backend as K
>>> K.epsilon()
1e-07
>>> K.set_epsilon(1e-05)
>>> K.epsilon()
1e-05

floatx

keras.backend.floatx()

以字符串形式返回默认的浮点类型。(例如，'float16', 'float32', 'float64')。

返回

字符串，当前默认的浮点类型。

例子

>>> keras.backend.floatx()
'float32'

set_floatx

keras.backend.set_floatx(floatx)

设置默认的浮点类型。

参数

• floatx: 字符串，'float16', 'float32', 或 'float64'。

例子

>>> from keras import backend as K
>>> K.floatx()
'float32'
>>> K.set_floatx('float16')
>>> K.floatx()
'float16'

cast_to_floatx

keras.backend.cast_to_floatx(x)

将 Numpy 数组转换为默认的 Keras 浮点类型。

参数

• x: Numpy 数组。

返回

相同的 Numpy 数组，转换为它的新类型。

例子

>>> from keras import backend as K
>>> K.floatx()
'float32'
>>> arr = numpy.array([1.0, 2.0], dtype='float64')
>>> arr.dtype
dtype('float64')
>>> new_arr = K.cast_to_floatx(arr)
>>> new_arr
array([ 1.,  2.], dtype=float32)
>>> new_arr.dtype
dtype('float32')

image_data_format

keras.backend.image_data_format()

返回默认图像数据格式约定 ('channels_first' 或 'channels_last')。

返回

一个字符串，'channels_first' 或 'channels_last'

例子

>>> keras.backend.image_data_format()
'channels_first'

set_image_data_format

keras.backend.set_image_data_format(data_format)

设置数据格式约定的值。

参数

• data_format: 字符串。'channels_first' 或 'channels_last'。

例子

>>> from keras import backend as K
>>> K.image_data_format()
'channels_first'
>>> K.set_image_data_format('channels_last')
>>> K.image_data_format()
'channels_last'

reset_uids

keras.backend.reset_uids()

重置图的标识符。

get_uid

keras.backend.get_uid(prefix='')

获取默认计算图的 uid。

参数

• prefix: 图的可选前缀。

返回

图的唯一标识符。

clear_session

keras.backend.clear_session()

销毁当前的 TF 图并创建一个新图。

有用于避免旧模型/网络层混乱。

manual_variable_initialization

keras.backend.manual_variable_initialization(value)

设置变量手动初始化的标志。

这个布尔标志决定了变量是否应该在实例化时初始化（默认），或者用户是否应该自己处理初始化（例如通过 tf.initialize_all_variables()）。

参数

• value: Python 布尔值。

learning_phase

keras.backend.learning_phase()

返回学习阶段的标志。

学习阶段标志是一个布尔张量（0 = test，1 = train），它作为输入传递给任何的 Keras 函数，以在训练和测试时执行不同的行为操作。

返回

学习阶段 (标量整数张量或 python 整数)。

set_learning_phase

keras.backend.set_learning_phase(value)

将学习阶段设置为固定值。

参数

• value: 学习阶段的值，0 或 1（整数）。

异常

• ValueError: 如果 value 既不是 0 也不是 1。

is_sparse

keras.backend.is_sparse(tensor)

判断张量是否是稀疏张量。

参数

• tensor: 一个张量实例。

返回

布尔值。

例子

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

keras.backend.to_dense(tensor)

将稀疏张量转换为稠密张量并返回。

参数

• tensor: 张量实例（可能稀疏）。

返回

一个稠密张量。

例子

>>> from keras import backend as K
>>> b = K.placeholder((2, 2), sparse=True)
>>> print(K.is_sparse(b))
True
>>> c = K.to_dense(b)
>>> print(K.is_sparse(c))
False

variable

keras.backend.variable(value, dtype=None, name=None, constraint=None)

实例化一个变量并返回它。

参数

• value: Numpy 数组，张量的初始值。
• dtype: 张量类型。
• name: 张量的可选名称字符串。
• constraint: 在优化器更新后应用于变量的可选投影函数。

返回

变量实例（包含 Keras 元数据）

例子

>>> from keras import backend as K
>>> val = np.array([[1, 2], [3, 4]])
>>> kvar = K.variable(value=val, dtype='float64', name='example_var')
>>> K.dtype(kvar)
'float64'
>>> print(kvar)
example_var
>>> K.eval(kvar)
array([[ 1.,  2.],
       [ 3.,  4.]])

constant

keras.backend.constant(value, dtype=None, shape=None, name=None)

创建一个常数张量。

参数

• value: 一个常数值（或列表）
• dtype: 结果张量的元素类型。
• shape: 可选的结果张量的尺寸。
• name: 可选的张量的名称。

返回

一个常数张量。

is_keras_tensor

keras.backend.is_keras_tensor(x)

判断 x 是否是 Keras 张量

「Keras张量」是由 Keras 层（Layer类）或 Input 返回的张量。

参数

• x: 候选张量。

返回

布尔值：参数是否是 Keras 张量。

异常

• ValueError: 如果 x 不是一个符号张量。

例子

>>> from keras import backend as K
>>> from keras.layers import Input, Dense
>>> np_var = numpy.array([1, 2])
>>> K.is_keras_tensor(np_var) # 一个 Numpy 数组不是一个符号张量。
ValueError
>>> k_var = tf.placeholder('float32', shape=(1,1))
>>> K.is_keras_tensor(k_var) # 在 Keras 之外间接创建的变量不是 Keras 张量。
False
>>> keras_var = K.variable(np_var)
>>> K.is_keras_tensor(keras_var)  # Keras 后端创建的变量不是 Keras 张量。
False
>>> keras_placeholder = K.placeholder(shape=(2, 4, 5))
>>> K.is_keras_tensor(keras_placeholder)  # 占位符不是 Keras 张量。
False
>>> keras_input = Input([10])
>>> K.is_keras_tensor(keras_input) # 输入 Input 是 Keras 张量。
True
>>> keras_layer_output = Dense(10)(keras_input)
>>> K.is_keras_tensor(keras_layer_output) # 任何 Keras 层输出都是 Keras 张量。
True

is_tensor

keras.backend.is_tensor(x)

placeholder

keras.backend.placeholder(shape=None, ndim=None, dtype=None, sparse=False, name=None)

实例化一个占位符张量并返回它。

参数

• shape: 占位符尺寸(整数元组，可能包含 None 项)。
• ndim: 张量的轴数。{shape, ndim} 至少一个需要被指定。如果两个都被指定，那么使用 shape。
• dtype: 占位符类型。
• sparse: 布尔值，占位符是否应该有一个稀疏类型。
• name: 可选的占位符的名称字符串。

返回

张量实例（包括 Keras 元数据）。

例子

>>> from keras import backend as K
>>> input_ph = K.placeholder(shape=(2, 4, 5))
>>> input_ph._keras_shape
(2, 4, 5)
>>> input_ph
<tf.Tensor 'Placeholder_4:0' shape=(2, 4, 5) dtype=float32>

is_placeholder

keras.backend.is_placeholder(x)

判断 x 是否是占位符。

参数

• x: 候选占位符。

返回

布尔值。

shape

keras.backend.shape(x)

返回张量或变量的符号尺寸。

参数

• x: 张量或变量。

返回

符号尺寸（它本身就是张量）。

例子

# TensorFlow 例子
>>> from keras import backend as K
>>> tf_session = K.get_session()
>>> val = np.array([[1, 2], [3, 4]])
>>> kvar = K.variable(value=val)
>>> inputs = keras.backend.placeholder(shape=(2, 4, 5))
>>> K.shape(kvar)
<tf.Tensor 'Shape_8:0' shape=(2,) dtype=int32>
>>> K.shape(inputs)
<tf.Tensor 'Shape_9:0' shape=(3,) dtype=int32>
# 要得到整数尺寸 (相反，你可以使用 K.int_shape(x))
>>> K.shape(kvar).eval(session=tf_session)
array([2, 2], dtype=int32)
>>> K.shape(inputs).eval(session=tf_session)
array([2, 4, 5], dtype=int32)

int_shape

keras.backend.int_shape(x)

返回张量或变量的尺寸，作为 int 或 None 项的元组。

参数

• x: 张量或变量。

返回

整数元组（或 None 项）。

例子

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

Numpy 实现

def int_shape(x):
    return x.shape

ndim

keras.backend.ndim(x)

以整数形式返回张量中的轴数。

参数

• x: 张量或变量。

返回

整数 (标量), 轴的数量。

例子

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

Numpy 实现

def ndim(x):
    return x.ndim

dtype

keras.backend.dtype(x)

以字符串形式返回 Keras 张量或变量的 dtype。

参数

• x: 张量或变量。

返回

字符串，x 的 dtype。

例子

>>> 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 变量
>>> 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

keras.backend.eval(x)

估计一个变量的值。

参数

• x: 变量。

返回

Numpy 数组。

例子

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

keras.backend.zeros(shape, dtype=None, name=None)

实例化一个全零变量并返回它。

参数

• shape: 整数元组，返回的Keras变量的尺寸。
• dtype: 字符串，返回的 Keras 变量的数据类型。
• name: 字符串，返回的 Keras 变量的名称。

返回

一个变量（包括 Keras 元数据），用 0.0 填充。请注意，如果 shape 是符号化的，我们不能返回一个变量，而会返回一个动态尺寸的张量。

例子

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

keras.backend.ones(shape, dtype=None, name=None)

实例化一个全一变量并返回它。

参数

• shape: 整数元组，返回的Keras变量的尺寸。
• dtype: 字符串，返回的 Keras 变量的数据类型。
• name: 字符串，返回的 Keras 变量的名称。

返回

一个 Keras 变量，用 1.0 填充。请注意，如果 shape 是符号化的，我们不能返回一个变量，而会返回一个动态尺寸的张量。

例子

>>> from keras import backend as K
>>> kvar = K.ones((3,4))
>>> K.eval(kvar)
array([[ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.]], dtype=float32)

eye

keras.backend.eye(size, dtype=None, name=None)

实例化一个单位矩阵并返回它。

参数

• size: 整数，行/列的数目。
• dtype: 字符串，返回的 Keras 变量的数据类型。
• name: 字符串，返回的 Keras 变量的名称。

返回

Keras 变量，一个单位矩阵。

例子

>>> from keras import backend as K
>>> kvar = K.eye(3)
>>> K.eval(kvar)
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]], dtype=float32)

zeros_like

keras.backend.zeros_like(x, dtype=None, name=None)

实例化与另一个张量相同尺寸的全零变量。

参数

• x: Keras 变量或 Keras 张量。
• dtype: 字符串，返回的 Keras 变量的类型。如果为 None，则使用 x 的类型。
• name: 字符串，所创建的变量的名称。

返回

一个 Keras 变量，其形状为 x，用零填充。

例子

>>> from keras import backend as K
>>> kvar = K.variable(np.random.random((2,3)))
>>> kvar_zeros = K.zeros_like(kvar)
>>> K.eval(kvar_zeros)
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]], dtype=float32)

ones_like

keras.backend.ones_like(x, dtype=None, name=None)

实例化与另一个张量相同形状的全一变量。

参数

• x: Keras 变量或张量。
• dtype: 字符串，返回的 Keras 变量的类型。如果为 None，则使用 x 的类型。
• name: 字符串，所创建的变量的名称。

返回

一个 Keras 变量，其形状为 x，用一填充。

例子

>>> from keras import backend as K
>>> kvar = K.variable(np.random.random((2,3)))
>>> kvar_ones = K.ones_like(kvar)
>>> K.eval(kvar_ones)
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)

identity

keras.backend.identity(x, name=None)

返回与输入张量相同内容的张量。

参数

• x: 输入张量。
• name: 字符串，所创建的变量的名称。

返回

一个相同尺寸、类型和内容的张量。

random_uniform_variable

keras.backend.random_uniform_variable(shape, low, high, dtype=None, name=None, seed=None)

使用从均匀分布中抽样出来的值来实例化变量。

参数

• shape: 整数元组，返回的 Keras 变量的尺寸。
• low: 浮点数，输出间隔的下界。
• high: 浮点数，输出间隔的上界。
• dtype: 字符串，返回的 Keras 变量的数据类型。
• name: 字符串，返回的 Keras 变量的名称。
• seed: 整数，随机种子。

返回

一个 Keras 变量，以抽取的样本填充。

例子

# TensorFlow 示例
>>> kvar = K.random_uniform_variable((2,3), 0, 1)
>>> kvar
<tensorflow.python.ops.variables.Variable object at 0x10ab40b10>
>>> K.eval(kvar)
array([[ 0.10940075,  0.10047495,  0.476143  ],
       [ 0.66137183,  0.00869417,  0.89220798]], dtype=float32)

random_normal_variable

keras.backend.random_normal_variable(shape, mean, scale, dtype=None, name=None, seed=None)

使用从正态分布中抽取的值实例化一个变量。

参数

• shape: 整数元组，返回的Keras变量的尺寸。
• mean: 浮点型，正态分布平均值。
• scale: 浮点型，正态分布标准差。
• dtype: 字符串，返回的Keras变量的 dtype。
• name: 字符串，返回的Keras变量的名称。
• seed: 整数，随机种子。

返回

一个 Keras 变量，以抽取的样本填充。

例子

# TensorFlow 示例
>>> kvar = K.random_normal_variable((2,3), 0, 1)
>>> kvar
<tensorflow.python.ops.variables.Variable object at 0x10ab12dd0>
>>> K.eval(kvar)
array([[ 1.19591331,  0.68685907, -0.63814116],
       [ 0.92629528,  0.28055015,  1.70484698]], dtype=float32)

count_params

keras.backend.count_params(x)

返回 Keras 变量或张量中的静态元素数。

参数

• x: Keras 变量或张量。

返回

整数，x 中的元素数量，即，数组中静态维度的乘积。

例子

>>> kvar = K.zeros((2,3))
>>> K.count_params(kvar)
6
>>> K.eval(kvar)
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]], dtype=float32)

cast

keras.backend.cast(x, dtype)

将张量转换到不同的 dtype 并返回。

你可以转换一个 Keras 变量，但它仍然返回一个 Keras 张量。

参数

• x: Keras 张量（或变量）。
• dtype: 字符串， ('float16', 'float32' 或 'float64')。

返回

Keras 张量，类型为 dtype。

例子

>>> from keras import backend as K
>>> input = K.placeholder((2, 3), dtype='float32')
>>> input
<tf.Tensor 'Placeholder_2:0' shape=(2, 3) dtype=float32>
# It doesn't work in-place as below.
>>> K.cast(input, dtype='float16')
<tf.Tensor 'Cast_1:0' shape=(2, 3) dtype=float16>
>>> input
<tf.Tensor 'Placeholder_2:0' shape=(2, 3) dtype=float32>
# you need to assign it.
>>> input = K.cast(input, dtype='float16')
>>> input
<tf.Tensor 'Cast_2:0' shape=(2, 3) dtype=float16>

update

keras.backend.update(x, new_x)

将 x 的值更新为 new_x。

参数

• x: 一个 Variable。
• new_x: 一个与 x 尺寸相同的张量。

返回

更新后的变量 x。

update_add

keras.backend.update_add(x, increment)

通过增加 increment 来更新 x 的值。

参数

• x: 一个 Variable。
• increment: 与 x 形状相同的张量。

返回

更新后的变量 x。

update_sub

keras.backend.update_sub(x, decrement)

通过减 decrement 来更新 x 的值。

参数

• x: 一个 Variable。
• decrement: 与 x 形状相同的张量。

返回

更新后的变量 x。

moving_average_update

keras.backend.moving_average_update(x, value, momentum)

计算变量的移动平均值。

参数

• x: 一个 Variable。
• value: 与 x 形状相同的张量。
• momentum: 移动平均动量。

返回

更新变量的操作。

dot

keras.backend.dot(x, y)

将 2 个张量（和/或变量）相乘并返回一个张量。

当试图将 nD 张量与 nD 张量相乘时，它会重现 Theano 行为。(例如 (2, 3) * (4, 3, 5) -> (2, 4, 5))

参数

• x: 张量或变量。
• y: 张量或变量。

返回

一个张量，x 和 y 的点积。

例子

# 张量之间的点积
>>> 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>

# 张量之间的点积
>>> 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>

# 类 Theano 行为的例子
>>> 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

keras.backend.batch_dot(x, y, axes=None)

批量化的点积。

当 x 和 y 是批量数据时，batch_dot 用于计算 x 和 y 的点积，即尺寸为 (batch_size, :)。

batch_dot 产生一个比输入尺寸更小的张量或变量。 如果维数减少到 1，我们使用 expand_dims 来确保 ndim 至少为 2。

参数

• x: ndim >= 2 的 Keras 张量或变量。
• y: ndim >= 2 的 Keras 张量或变量。
• axes: 表示目标维度的整数或列表。axes[0] 和 axes[1] 的长度必须相同。

返回

一个尺寸等于 x 的尺寸（减去总和的维度）和 y 的尺寸（减去批次维度和总和的维度）的连接的张量。如果最后的秩为 1，我们将它重新转换为 (batch_size, 1)。

例子

假设 x = [[1, 2], [3, 4]] 和 y = [[5, 6], [7, 8]]，batch_dot(x, y, axes=1) = [[17], [53]] 是 x.dot(y.T) 的主对角线，尽管我们不需要计算非对角元素。

伪代码：

inner_products = []
for xi, yi in zip(x, y):
    inner_products.append(xi.dot(yi))
result = stack(inner_products)

尺寸推断：让 x 的尺寸为 (100, 20)，以及 y 的尺寸为 (100, 30, 20)。如果 axes 是 (1, 2)，要找出结果张量的尺寸，循环 x 和 y 的尺寸的每一个维度。

• x.shape[0] : 100 : 附加到输出形状，
• x.shape[1] : 20 : 不附加到输出形状，x 的第一个维度已经被加和了 (dot_axes[0] = 1)。
• y.shape[0] : 100 : 不附加到输出形状，总是忽略 y 的第一维
• y.shape[1] : 30 : 附加到输出形状，
• y.shape[2] : 20 : 不附加到输出形状，y 的第二个维度已经被加和了 (dot_axes[0] = 2)。output_shape = (100, 30)

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

keras.backend.transpose(x)

将张量转置并返回。

参数

• x: 张量或变量。

返回

一个张量。

例子

>>> var = K.variable([[1, 2, 3], [4, 5, 6]])
>>> K.eval(var)
array([[ 1.,  2.,  3.],
       [ 4.,  5.,  6.]], dtype=float32)
>>> var_transposed = K.transpose(var)
>>> K.eval(var_transposed)
array([[ 1.,  4.],
       [ 2.,  5.],
       [ 3.,  6.]], dtype=float32)

>>> inputs = K.placeholder((2, 3))
>>> inputs
<tf.Tensor 'Placeholder_11:0' shape=(2, 3) dtype=float32>
>>> input_transposed = K.transpose(inputs)
>>> input_transposed
<tf.Tensor 'transpose_4:0' shape=(3, 2) dtype=float32>

gather

keras.backend.gather(reference, indices)

在张量 reference 中检索索引 indices 的元素。

参数

• reference: 一个张量。
• indices: 索引的整数张量。

返回

与 reference 类型相同的张量。

Numpy 实现

def gather(reference, indices):
    return reference[indices]

max

keras.backend.max(x, axis=None, keepdims=False)

张量中的最大值。

参数

• x: 张量或变量。
• axis: 一个整数，需要在哪个轴寻找最大值。
• keepdims: 布尔值，是否保留原尺寸。如果 keepdims 为 False，则张量的秩减 1。如果 keepdims 为 True，缩小的维度保留为长度 1。

返回

x 中最大值的张量。

Numpy 实现

def max(x, axis=None, keepdims=False):
    if isinstance(axis, list):
        axis = tuple(axis)
    return np.max(x, axis=axis, keepdims=keepdims)

min

keras.backend.min(x, axis=None, keepdims=False)

张量中的最小值。

参数

• x: 张量或变量。
• axis: 一个整数，需要在哪个轴寻找最大值。
• keepdims: 布尔值，是否保留原尺寸。如果 keepdims 为 False，则张量的秩减 1。如果 keepdims 为 True，缩小的维度保留为长度 1。

返回

x 中最小值的张量。

Numpy 实现

def min(x, axis=None, keepdims=False):
    if isinstance(axis, list):
        axis = tuple(axis)
    return np.min(x, axis=axis, keepdims=keepdims)

sum

keras.backend.sum(x, axis=None, keepdims=False)

计算张量在某一指定轴的和。

参数

• x: 张量或变量。
• axis: 一个整数，需要加和的轴。
• keepdims: 布尔值，是否保留原尺寸。如果 keepdims 为 False，则张量的秩减 1。如果 keepdims 为 True，缩小的维度保留为长度 1。

返回

x 的和的张量。

Numpy 实现

def sum(x, axis=None, keepdims=False):
    if isinstance(axis, list):
        axis = tuple(axis)
    return np.sum(x, axis=axis, keepdims=keepdims)

prod

keras.backend.prod(x, axis=None, keepdims=False)

在某一指定轴，计算张量中的值的乘积。

参数

• x: 张量或变量。
• axis: 一个整数需要计算乘积的轴。
• keepdims: 布尔值，是否保留原尺寸。如果 keepdims 为 False，则张量的秩减 1。如果 keepdims 为 True，缩小的维度保留为长度 1。

返回

x 的元素的乘积的张量。

Numpy 实现

def prod(x, axis=None, keepdims=False):
    if isinstance(axis, list):
        axis = tuple(axis)
    return np.prod(x, axis=axis, keepdims=keepdims)

cumsum

keras.backend.cumsum(x, axis=0)

在某一指定轴，计算张量中的值的累加和。

参数

• x: 张量或变量。
• axis: 一个整数，需要加和的轴。

返回

x 在 axis 轴的累加和的张量。

cumprod

keras.backend.cumprod(x, axis=0)

在某一指定轴，计算张量中的值的累积乘积。

参数

• x: 张量或变量。
• axis: 一个整数，需要计算乘积的轴。

返回

x 在 axis 轴的累乘的张量。

var

keras.backend.var(x, axis=None, keepdims=False)

张量在某一指定轴的方差。

参数

• x: 张量或变量。
• axis: 一个整数，要计算方差的轴。
• keepdims: 布尔值，是否保留原尺寸。如果 keepdims 为 False，则张量的秩减 1。如果 keepdims 为 True，缩小的维度保留为长度 1。

返回

x 元素的方差的张量。

std

keras.backend.std(x, axis=None, keepdims=False)

张量在某一指定轴的标准差。

参数

• x: 张量或变量。
• axis: 一个整数，要计算标准差的轴。
• keepdims: 布尔值，是否保留原尺寸。如果 keepdims 为 False，则张量的秩减 1。如果 keepdims 为 True，缩小的维度保留为长度 1。

返回

x 元素的标准差的张量。

mean

keras.backend.mean(x, axis=None, keepdims=False)

张量在某一指定轴的均值。

参数

• x: A tensor or variable.
• axis: 整数或列表。需要计算均值的轴。
• keepdims: 布尔值，是否保留原尺寸。如果 keepdims 为 False，则 axis 中每一项的张量秩减 1。如果 keepdims 为 True，则缩小的维度保留为长度 1。

返回

x 元素的均值的张量。

any

keras.backend.any(x, axis=None, keepdims=False)

reduction

按位归约（逻辑 OR）。

参数

• x: 张量或变量。
• axis: 执行归约操作的轴。
• keepdims: 是否放弃或广播归约的轴。

返回

一个 uint8 张量 (0s 和 1s)。

all

keras.backend.all(x, axis=None, keepdims=False)

按位归约（逻辑 AND）。

参数

• x: 张量或变量。
• axis: 执行归约操作的轴。
• keepdims: 是否放弃或广播归约的轴。

返回

一个 uint8 张量 (0s 和 1s)。

argmax

keras.backend.argmax(x, axis=-1)

返回指定轴的最大值的索引。

参数

• x: 张量或变量。
• axis: 执行归约操作的轴。

返回

一个张量。

argmin

keras.backend.argmin(x, axis=-1)

返回指定轴的最小值的索引。

参数

• x: 张量或变量。
• axis: 执行归约操作的轴。

返回

一个张量。

square

keras.backend.square(x)

元素级的平方操作。

参数

• x: 张量或变量。

返回

一个张量。

abs

keras.backend.abs(x)

元素级的绝对值操作。

参数

• x: 张量或变量。

返回

一个张量。

sqrt

keras.backend.sqrt(x)

元素级的平方根操作。

参数

• x: 张量或变量。

返回

一个张量。

exp

keras.backend.exp(x)

元素级的指数运算操作。

参数

• x: 张量或变量。

返回

一个张量。

log

keras.backend.log(x)

元素级的对数运算操作。

参数

• x: 张量或变量。

返回

一个张量。

logsumexp

keras.backend.logsumexp(x, axis=None, keepdims=False)

计算 log(sum(exp(张量在某一轴的元素)))。

这个函数在数值上比 log(sum(exp(x))) 更稳定。它避免了求大输入的指数造成的上溢，以及求小输入的对数造成的下溢。

参数

• x: 张量或变量。
• axis: 一个整数，需要归约的轴。
• keepdims: 布尔值，是否保留原尺寸。如果 keepdims 为 False，则张量的秩减 1。如果 keepdims 为 True，缩小的维度保留为长度 1。

返回

归约后的张量。

round

keras.backend.round(x)

元素级地四舍五入到最接近的整数。

在平局的情况下，使用的舍入模式是「偶数的一半」。

参数

• x: 张量或变量。

返回

一个张量。

sign

keras.backend.sign(x)

元素级的符号运算。

参数

• x: 张量或变量。

返回

一个张量。

pow

keras.backend.pow(x, a)

元素级的指数运算操作。

参数

• x: 张量或变量。
• a: Python 整数。

返回

一个张量。

clip

keras.backend.clip(x, min_value, max_value)

元素级裁剪。

参数

• x: 张量或变量。
• min_value: Python 浮点或整数。
• max_value: Python 浮点或整数。

返回

一个张量。

equal

keras.backend.equal(x, y)

逐个元素对比两个张量的相等情况。

参数

• x: 张量或变量。
• y: 张量或变量。

返回

一个布尔张量。

Numpy 实现

def equal(x, y):
    return x == y

not_equal

keras.backend.not_equal(x, y)

逐个元素对比两个张量的不相等情况。

参数

• x: 张量或变量。
• y: 张量或变量。

返回

一个布尔张量。

Numpy 实现

def not_equal(x, y):
    return x != y

greater

keras.backend.greater(x, y)

逐个元素比对 (x > y) 的真值。

参数

• x: 张量或变量。
• y: 张量或变量。

返回

一个布尔张量。

Numpy 实现

def greater(x, y):
    return x > y

greater_equal

keras.backend.greater_equal(x, y)

逐个元素比对 (x >= y) 的真值。

参数

• x: 张量或变量。
• y: 张量或变量。

返回

一个布尔张量。

Numpy 实现

def greater_equal(x, y):
    return x >= y

less

keras.backend.less(x, y)

逐个元素比对 (x < y) 的真值。

参数

• x: 张量或变量。
• y: 张量或变量。

返回

一个布尔张量。

Numpy 实现

def less(x, y):
    return x < y

less_equal

keras.backend.less_equal(x, y)

逐个元素比对 (x <= y) 的真值。

参数

• x: 张量或变量。
• y: 张量或变量。

返回

一个布尔张量。

Numpy 实现

def less_equal(x, y):
    return x <= y

maximum

keras.backend.maximum(x, y)

逐个元素比对两个张量的最大值。

参数

• x: 张量或变量。
• y: 张量或变量。

返回

一个张量。

Numpy 实现

def maximum(x, y):
    return np.maximum(x, y)

minimum

keras.backend.minimum(x, y)

逐个元素比对两个张量的最小值。

参数

• x: 张量或变量。
• y: 张量或变量。

返回

一个张量。

Numpy 实现

def minimum(x, y):
    return np.minimum(x, y)

sin

keras.backend.sin(x)

逐个元素计算 x 的 sin 值。

参数

• x: 张量或变量。

返回

一个张量。

cos

keras.backend.cos(x)

逐个元素计算 x 的 cos 值。

参数

• x: 张量或变量。

返回

一个张量。

normalize_batch_in_training

keras.backend.normalize_batch_in_training(x, gamma, beta, reduction_axes, epsilon=0.001)

计算批次的均值和标准差，然后在批次上应用批次标准化。

参数

• x: 输入张量或变量。
• gamma: 用于缩放输入的张量。
• beta: 用于中心化输入的张量。
• reduction_axes: 整数迭代，需要标准化的轴。
• epsilon: 模糊因子。

返回

长度为 3 个元组，(normalized_tensor, mean, variance)。

batch_normalization

keras.backend.batch_normalization(x, mean, var, beta, gamma, epsilon=0.001)

在给定的 mean，var，beta 和 gamma 上应用批量标准化。

即，返回：output = (x - mean) / (sqrt(var) + epsilon) * gamma + beta

参数

• x: 输入张量或变量。
• mean: 批次的均值。
• var: 批次的方差。
• beta: 用于中心化输入的张量。
• gamma: 用于缩放输入的张量。
• epsilon: 模糊因子。

返回

一个张量。

concatenate

keras.backend.concatenate(tensors, axis=-1)

基于指定的轴，连接张量的列表。

参数

• tensors: 需要连接的张量列表。
• axis: 连接的轴。

返回

一个张量。

reshape

keras.backend.reshape(x, shape)

将张量重塑为指定的尺寸。

参数

• x: 张量或变量。
• shape: 目标尺寸元组。

返回

一个张量。

permute_dimensions

keras.backend.permute_dimensions(x, pattern)

重新排列张量的轴。

参数

• x: 张量或变量。
• pattern: 维度索引的元组，例如 (0, 2, 1)。

返回

一个张量。

resize_images

keras.backend.resize_images(x, height_factor, width_factor, data_format)

调整 4D 张量中包含的图像的大小。

参数

• x: 需要调整的张量或变量。
• height_factor: 正整数。
• width_factor: 正整数。
• data_format: 字符串，"channels_last" 或 "channels_first"。

返回

一个张量。

异常

• ValueError: 如果 data_format 既不是 "channels_last" 也不是 "channels_first"。

resize_volumes

keras.backend.resize_volumes(x, depth_factor, height_factor, width_factor, data_format)

调整 5D 张量中包含的体积。

参数

• x: 需要调整的张量或变量。
• depth_factor: 正整数。
• height_factor: 正整数。
• width_factor: 正整数。
• data_format: 字符串，"channels_last" 或 "channels_first"。

返回

一个张量。

异常

• ValueError: 如果 data_format 既不是 "channels_last" 也不是 "channels_first"。

repeat_elements

keras.backend.repeat_elements(x, rep, axis)

沿某一轴重复张量的元素，如 np.repeat。

如果 x 的尺寸为 (s1，s2，s3) 而 axis 为 1，则输出尺寸为 (s1，s2 * rep，s3）。

参数

• x: 张量或变量。
• rep: Python 整数，重复次数。
• axis: 需要重复的轴。

返回

一个张量。

repeat

keras.backend.repeat(x, n)

重复一个 2D 张量。

如果 x 的尺寸为 (samples, dim) 并且 n 为 2，则输出的尺寸为 (samples, 2, dim)。

参数

• x: 张量或变量。
• n: Python 整数，重复次数。

返回

一个张量。

arange

keras.backend.arange(start, stop=None, step=1, dtype='int32')

创建一个包含整数序列的 1D 张量。

该函数参数与 Theano 的 arange 函数的约定相同：如果只提供了一个参数，那它就是 stop 参数。

返回的张量的默认类型是 int32，以匹配 TensorFlow 的默认值。

参数

• start: 起始值。
• stop: 结束值。
• step: 两个连续值之间的差。
• dtype: 要使用的整数类型。

返回

一个整数张量。

tile

keras.backend.tile(x, n)

创建一个用 n 平铺 的 x 张量。

参数

• x: 张量或变量。
• n: 整数列表。长度必须与 x 中的维数相同。

返回

一个平铺的张量。

flatten

keras.backend.flatten(x)

展平一个张量。

参数

• x: 张量或变量。

返回

一个重新调整为 1D 的张量。

batch_flatten

keras.backend.batch_flatten(x)

将一个 nD 张量变成一个 第 0 维相同的 2D 张量。

换句话说，它将批次中的每一个样本展平。

参数

• x: 张量或变量。

返回

一个张量。

expand_dims

keras.backend.expand_dims(x, axis=-1)

在索引 axis 轴，添加 1 个尺寸的维度。

参数

• x: 张量或变量。
• axis: 需要添加新的轴的位置。

返回

一个扩展维度的轴。

squeeze

keras.backend.squeeze(x, axis)

在索引 axis 轴，移除 1 个尺寸的维度。

参数

• x: 张量或变量。
• axis: 需要丢弃的轴。

返回

一个与 x 数据相同但维度降低的张量。

temporal_padding

keras.backend.temporal_padding(x, padding=(1, 1))

填充 3D 张量的中间维度。

参数

• x: 张量或变量。
• padding: 2 个整数的元组，在第一个维度的开始和结束处添加多少个零。返回

一个填充的 3D 张量。

spatial_2d_padding

keras.backend.spatial_2d_padding(x, padding=((1, 1), (1, 1)), data_format=None)

填充 4D 张量的第二维和第三维。

参数

• x: 张量或变量。
• padding: 2 元组的元组，填充模式。
• data_format: 字符串，"channels_last" 或 "channels_first"。

返回

一个填充的 4D 张量。

异常

• ValueError: 如果 data_format 既不是 "channels_last" 也不是 "channels_first"。

spatial_3d_padding

keras.backend.spatial_3d_padding(x, padding=((1, 1), (1, 1), (1, 1)), data_format=None)

沿着深度、高度宽度三个维度填充 5D 张量。

分别使用 "padding[0]", "padding[1]" 和 "padding[2]" 来左右填充这些维度。

对于 'channels_last' 数据格式，第 2、3、4 维将被填充。对于 'channels_first' 数据格式，第 3、4、5 维将被填充。

参数

• x: 张量或变量。
• padding: 3 元组的元组，填充模式。
• data_format: 字符串，"channels_last" 或 "channels_first"。

返回

一个填充的 5D 张量。

异常

• ValueError: 如果 data_format 既不是 "channels_last" 也不是 "channels_first"。

stack

keras.backend.stack(x, axis=0)

将秩 为 R 的张量列表堆叠成秩为 R + 1 的张量。

参数

• x: 张量列表。
• axis: 需要执行堆叠的轴。

返回

一个张量。

one_hot

keras.backend.one_hot(indices, num_classes)

计算一个整数张量的 one-hot 表示。

参数

• indices: nD 整数，尺寸为(batch_size, dim1, dim2, … dim(n-1))
• num_classes: 整数，需要考虑的类别数。

返回

输入的 (n + 1)D one-hot 表示，尺寸为 (batch_size, dim1, dim2, … dim(n-1), num_classes)。

reverse

keras.backend.reverse(x, axes)

沿指定的轴反转张量。

参数

• x: 需要反转的张量。
• axes: 整数或整数迭代。需要反转的轴。

返回

一个张量。

Numpy 实现

def reverse(x, axes):
    if isinstance(axes, list):
        axes = tuple(axes)
    return np.flip(x, axes)

slice

keras.backend.slice(x, start, size)

从张量中提取一个切片。

参数

• x: 输入张量。
• start: 整数列表/元组，表明每个轴的起始切片索引位置。
• size: 整数列表/元组，表明每个轴上切片多少维度。

返回

一个切片张量：

new_x = x[start[0]: start[0] + size[0], ..., start[-1]: start[-1] + size[-1]]

get_value

keras.backend.get_value(x)

返回一个变量的值。

参数

• x: 输入变量。

返回

一个 Numpy 数组。

batch_get_value

keras.backend.batch_get_value(ops)

返回多个张量变量的值。

参数

• ops: 要运行的操作列表。

返回

一个 Numpy 数组的列表。

set_value

keras.backend.set_value(x, value)

使用 Numpy 数组设置变量的值。

参数

• x: 需要设置新值的张量。
• value: 需要设置的值，一个尺寸相同的 Numpy 数组。

batch_set_value

keras.backend.batch_set_value(tuples)

一次设置多个张量变量的值。

参数

• tuples: 元组 (tensor, value) 的列表。value 应该是一个 Numpy 数组。

print_tensor

keras.backend.print_tensor(x, message='')

在评估时打印 message 和张量的值。

请注意，print_tensor 返回一个与 x 相同的新张量，应该在后面的代码中使用它。否则在评估过程中不会考虑打印操作。

例子

>>> x = K.print_tensor(x, message="x is: ")

参数

• x: 需要打印的张量。
• message: 需要与张量一起打印的消息。

返回

同一个不变的张量 x。

function

keras.backend.function(inputs, outputs, updates=None)

实例化 Keras 函数。

参数

• inputs: 占位符张量列表。
• outputs: 输出张量列表。
• updates: 更新操作列表。
• **kwargs: 需要传递给 tf.Session.run 的参数。

返回

输出值为 Numpy 数组。

异常

• ValueError: 如果无效的 kwargs 被传入。

gradients

keras.backend.gradients(loss, variables)

返回 variables 在 loss 上的梯度。

参数

• loss: 需要最小化的标量张量。
• variables: 变量列表。

返回

一个梯度张量。

stop_gradient

keras.backend.stop_gradient(variables)

返回 variables，但是对于其他变量，其梯度为零。

参数

• variables: 需要考虑的张量或张量列表，任何的其他变量保持不变。

返回

单个张量或张量列表（取决于传递的参数），与任何其他变量具有恒定的梯度。

rnn

keras.backend.rnn(step_function, inputs, initial_states, go_backwards=False, mask=None, constants=None, unroll=False, input_length=None)

在张量的时间维度迭代。

参数

• step_function: RNN 步骤函数，
• inputs: 尺寸为 (samples, …) 的张量(不含时间维度), 表示批次样品在某个时间步的输入。
• states: 张量列表。
• outputs: 尺寸为 (samples, output_dim) 的张量(不含时间维度)
• new_states: 张量列表，与 states 长度和尺寸相同。列表中的第一个状态必须是前一个时间步的输出张量。
• inputs: 时序数据张量 (samples, time, …)(最少 3D)。
• initial_states: 尺寸为 (samples, output_dim) 的张量(不含时间维度)，包含步骤函数中使用的状态的初始值。
• go_backwards: 布尔值。如果为 True，以相反的顺序在时间维上进行迭代并返回相反的序列。
• mask: 尺寸为 (samples, time, 1) 的二进制张量，对于被屏蔽的每个元素都为零。
• constants: 每个步骤传递的常量值列表。
• unroll: 是否展开 RNN 或使用符号循环（依赖于后端的 while_loop或 scan）。
• input_length: 与 TensorFlow 实现不相关。如果使用 Theano 展开，则必须指定。

返回

一个元组，(last_output, outputs, new_states)。

• last_output: rnn 的最后输出，尺寸为 (samples, …)。
• outputs: 尺寸为 (samples, time, …) 的张量，其中每一项 outputs[s, t] 是样本 s 在时间 t 的步骤函数输出值。
• new_states: 张量列表，有步骤函数返回的最后状态，尺寸为 (samples, …)。

异常

• ValueError: 如果输入的维度小于 3。
• ValueError: 如果 unroll 为 True 但输入时间步并不是固定的数字。
• ValueError: 如果提供了 mask (非 None) 但未提供 states (len(states) == 0)。

switch

keras.backend.switch(condition, then_expression, else_expression)

根据一个标量值在两个操作之间切换。

请注意，thenexpression 和 else_expression 都应该是相同尺寸_的符号张量。

参数

• condition: 张量 (int 或 bool)。
• then_expression: 张量或返回张量的可调用函数。
• else_expression: 张量或返回张量的可调用函数。

返回

选择的张量。

异常

• ValueError: 如果 condition 的秩大于两个表达式的秩序。

in_train_phase

keras.backend.in_train_phase(x, alt, training=None)

在训练阶段选择 x，其他阶段选择 alt。

请注意 alt 应该与 x 尺寸相同。

参数

• x: 在训练阶段需要返回的 x (张量或返回张量的可调用函数)。
• alt: 在其他阶段需要返回的 alt (张量或返回张量的可调用函数)。
• training: 可选的标量张量(或 Python 布尔值，或者 Python 整数)，以指定学习阶段。

返回

基于 training 标志，要么返回 x，要么返回 alt。training 标志默认为 K.learning_phase()。

in_test_phase

keras.backend.in_test_phase(x, alt, training=None)

在测试阶段选择 x，其他阶段选择 alt。

请注意 alt 应该与 x 尺寸相同。

参数

• x: 在训练阶段需要返回的 x (张量或返回张量的可调用函数)。
• alt: 在其他阶段需要返回的 alt (张量或返回张量的可调用函数)。
• training: 可选的标量张量(或 Python 布尔值，或者 Python 整数)，以指定学习阶段。

返回

基于 K.learning_phase，要么返回 x，要么返回 alt。

relu

keras.backend.relu(x, alpha=0.0, max_value=None)

ReLU 整流线性单位。

默认情况下，它返回逐个元素的 max(x, 0) 值。

参数

• x: 一个张量或变量。
• alpha: 一个标量，负数部分的斜率（默认为 0.）。
• max_value: 饱和度阈值。

返回

一个张量。

Numpy 实现

def relu(x, alpha=0., max_value=None, threshold=0.):
    if max_value is None:
        max_value = np.inf
    above_threshold = x * (x >= threshold)
    above_threshold = np.clip(above_threshold, 0.0, max_value)
    below_threshold = alpha * (x - threshold) * (x < threshold)
    return below_threshold + above_threshold

elu

keras.backend.elu(x, alpha=1.0)

指数线性单元。

参数