编程技术网

关注微信公众号,定时推送前沿、专业、深度的编程技术资料。

 找回密码
 立即注册

QQ登录

只需一步,快速开始

极客时间

Keras 中文文档

Agostino keras 2022-5-7 08:07 17人围观

腾讯云服务器

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 更改为 theanotensorflowcntk,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: 张量或变量。

返回

一个张量,xy 的点积。

例子

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

批量化的点积。

xy 是批量数据时, batch_dot 用于计算 xy 的点积, 即尺寸为 (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: 布尔值,是否保留原尺寸。 如果 keepdimsFalse,则张量的秩减 1。 如果 keepdimsTrue,缩小的维度保留为长度 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: 布尔值,是否保留原尺寸。 如果 keepdimsFalse,则张量的秩减 1。 如果 keepdimsTrue,缩小的维度保留为长度 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: 布尔值,是否保留原尺寸。 如果 keepdimsFalse,则张量的秩减 1。 如果 keepdimsTrue,缩小的维度保留为长度 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: 布尔值,是否保留原尺寸。 如果 keepdimsFalse,则张量的秩减 1。 如果 keepdimsTrue,缩小的维度保留为长度 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: 一个整数,需要加和的轴。

返回

xaxis 轴的累加和的张量。


cumprod

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

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

参数

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

返回

xaxis 轴的累乘的张量。


var

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

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

参数

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

返回

x 元素的方差的张量。


std

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

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

参数

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

返回

x 元素的标准差的张量。


mean

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

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

参数

  • x: A tensor or variable.
  • axis: 整数或列表。需要计算均值的轴。
  • keepdims: 布尔值,是否保留原尺寸。 如果 keepdimsFalse,则 axis 中每一项的张量秩减 1。 如果 keepdimsTrue,则缩小的维度保留为长度 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: 布尔值,是否保留原尺寸。 如果 keepdimsFalse,则张量的秩减 1。 如果 keepdimsTrue,缩小的维度保留为长度 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)axis1, 则输出尺寸为 (s1,s2 * rep,s3)

参数

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

返回

一个张量。


repeat

keras.backend.repeat(x, n)

重复一个 2D 张量。

如果 x 的尺寸为 (samples, dim) 并且 n2, 则输出的尺寸为 (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)

返回 variablesloss 上的梯度。

参数

  • 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_loopscan)。
  • 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: 如果 unrollTrue 但输入时间步并不是固定的数字。
  • ValueError: 如果提供了 mask (非 None) 但未提供 states (len(states) == 0)。

switch

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

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

请注意,then_expressionelse_expression 都应该是相同尺寸的符号张量。

参数

  • condition: 张量 (intbool)。
  • 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,要么返回 alttraining 标志默认为 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)

指数线性单元。

参数

  • x: 用于计算激活函数的张量或变量。
  • alpha: 一个标量,负数部分的斜率。

返回

一个张量。

Numpy 实现

def elu(x, alpha=1.):
    return x * (x > 0) + alpha * (np.exp(x) - 1.) * (x < 0)

softmax

keras.backend.softmax(x)

张量的 Softmax 值。

参数

  • x: 张量或变量。

返回

一个张量。

Numpy 实现

def softmax(x, axis=-1):
    y = np.exp(x - np.max(x, axis, keepdims=True))
    return y / np.sum(y, axis, keepdims=True)

softplus

keras.backend.softplus(x)

张量的 Softplus 值。

参数

  • x: 张量或变量。

返回

一个张量。

Numpy 实现

def softplus(x):
    return np.log(1. + np.exp(x))

softsign

keras.backend.softsign(x)

张量的 Softsign 值。

参数

  • x: 张量或变量。

返回

一个张量。


categorical_crossentropy

keras.backend.categorical_crossentropy(target, output, from_logits=False)

输出张量与目标张量之间的分类交叉熵。

参数

  • target: 与 output 尺寸相同的张量。
  • output: 由 softmax 产生的张量 (除非 from_logits 为 True, 在这种情况下 output 应该是对数形式)。
  • from_logits: 布尔值,output 是 softmax 的结果, 还是对数形式的张量。

返回

输出张量。


sparse_categorical_crossentropy

keras.backend.sparse_categorical_crossentropy(target, output, from_logits=False)

稀疏表示的整数值目标的分类交叉熵。

参数

  • target: 一个整数张量。
  • output: 由 softmax 产生的张量 (除非 from_logits 为 True, 在这种情况下 output 应该是对数形式)。
  • from_logits: 布尔值,output 是 softmax 的结果, 还是对数形式的张量。

返回

输出张量。


binary_crossentropy

keras.backend.binary_crossentropy(target, output, from_logits=False)

输出张量与目标张量之间的二进制交叉熵。

参数

  • target: 与 output 尺寸相同的张量。
  • output: 一个张量。
  • from_logits: output 是否是对数张量。 默认情况下,我们认为 output 编码了概率分布。

返回

一个张量。


sigmoid

keras.backend.sigmoid(x)

逐个元素求 sigmoid 值。

参数

  • x: 一个张量或变量。

返回

一个张量。

Numpy 实现

def sigmoid(x):
    return 1. / (1. + np.exp(-x))

hard_sigmoid

keras.backend.hard_sigmoid(x)

分段的 sigmoid 线性近似。速度比 sigmoid 更快。

  • 如果 x < -2.5,返回 0
  • 如果 x > 2.5,返回 1
  • 如果 -2.5 <= x <= 2.5,返回 0.2 * x + 0.5

参数

  • x: 一个张量或变量。

返回

一个张量。

Numpy 实现

def hard_sigmoid(x):
    y = 0.2 * x + 0.5
    return np.clip(y, 0, 1)

tanh

keras.backend.tanh(x)

逐个元素求 tanh 值。

参数

  • x: 一个张量或变量。

返回

一个张量。

Numpy 实现

def tanh(x):
    return np.tanh(x)

dropout

keras.backend.dropout(x, level, noise_shape=None, seed=None)

x 中的某些项随机设置为零,同时缩放整个张量。

参数

  • x: 张量
  • level: 张量中将被设置为 0 的项的比例。
  • noise_shape: 随机生成的 保留/丢弃 标志的尺寸, 必须可以广播到 x 的尺寸。
  • seed: 保证确定性的随机种子。

返回

一个张量。


l2_normalize

keras.backend.l2_normalize(x, axis=None)

在指定的轴使用 L2 范式 标准化一个张量。

参数

  • x: 张量或变量。
  • axis: 需要执行标准化的轴。

返回

一个张量。

Numpy 实现

def l2_normalize(x, axis=-1):
    y = np.max(np.sum(x ** 2, axis, keepdims=True), axis, keepdims=True)
    return x / np.sqrt(y)

in_top_k

keras.backend.in_top_k(predictions, targets, k)

判断 targets 是否在 predictions 的前 k 个中。

参数

  • predictions: 一个张量,尺寸为 (batch_size, classes),类型为 float32
  • targets: 一个 1D 张量,长度为 batch_size,类型为 int32int64
  • k: 一个 int,要考虑的顶部元素的数量。

返回

一个 1D 张量,长度为 batch_size,类型为 bool。 如果 predictions[i, targets[i]]predictions[i] 的 top-k 值中, 则 output[i]True


conv1d

keras.backend.conv1d(x, kernel, strides=1, padding='valid', data_format=None, dilation_rate=1)

1D 卷积。

参数

  • x: 张量或变量。
  • kernel: 核张量。
  • strides: 步长整型。
  • padding: 字符串,"same", "causal""valid"
  • data_format: 字符串,"channels_last""channels_first"
  • dilation_rate: 整数膨胀率。

返回

一个张量,1D 卷积结果。

异常

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

conv2d

keras.backend.conv2d(x, kernel, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1))

2D 卷积。

参数

  • x: 张量或变量。
  • kernel: 核张量。
  • strides: 步长元组。
  • padding: 字符串,"same""valid"
  • data_format: 字符串,"channels_last""channels_first"。 对于输入/卷积核/输出,是否使用 Theano 或 TensorFlow/CNTK数据格式。
  • dilation_rate: 2 个整数的元组。

返回

一个张量,2D 卷积结果。

异常

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

conv2d_transpose

keras.backend.conv2d_transpose(x, kernel, output_shape, strides=(1, 1), padding='valid', data_format=None)

2D 反卷积 (即转置卷积)。

参数

  • x: 张量或变量。
  • kernel: 核张量。
  • output_shape: 表示输出尺寸的 1D 整型张量。
  • strides: 步长元组。
  • padding: 字符串,"same""valid"
  • data_format: 字符串,"channels_last""channels_first"。 对于输入/卷积核/输出,是否使用 Theano 或 TensorFlow/CNTK数据格式。

返回

一个张量,转置的 2D 卷积的结果。

异常

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

separable_conv1d

keras.backend.separable_conv1d(x, depthwise_kernel, pointwise_kernel, strides=1, padding='valid', data_format=None, dilation_rate=1)

带可分离滤波器的 1D 卷积。

参数

  • x: 输入张量。
  • depthwise_kernel: 用于深度卷积的卷积核。
  • pointwise_kernel: 1x1 卷积核。
  • strides: 步长整数。
  • padding: 字符串,"same""valid"
  • data_format: 字符串,"channels_last""channels_first"
  • dilation_rate: 整数膨胀率。

返回

输出张量。

异常

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

separable_conv2d

keras.backend.separable_conv2d(x, depthwise_kernel, pointwise_kernel, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1))

带可分离滤波器的 2D 卷积。

参数

  • x: 输入张量。
  • depthwise_kernel: 用于深度卷积的卷积核。
  • pointwise_kernel: 1x1 卷积核。
  • strides: 步长元组 (长度为 2)。
  • padding: 字符串,"same""valid"
  • data_format: 字符串,"channels_last""channels_first"
  • dilation_rate: 整数元组,可分离卷积的膨胀率。

返回

输出张量。

异常

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

depthwise_conv2d

keras.backend.depthwise_conv2d(x, depthwise_kernel, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1))

带可分离滤波器的 2D 卷积。

参数

  • x: 输入张量。
  • depthwise_kernel: 用于深度卷积的卷积核。
  • strides: 步长元组 (长度为 2)。
  • padding: 字符串,"same""valid"
  • data_format: 字符串,"channels_last""channels_first"
  • dilation_rate: 整数元组,可分离卷积的膨胀率。

返回

输出张量。

异常

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

conv3d

keras.backend.conv3d(x, kernel, strides=(1, 1, 1), padding='valid', data_format=None, dilation_rate=(1, 1, 1))

3D 卷积。

参数

  • x: 张量或变量。
  • kernel: 核张量。
  • strides: 步长元组。
  • padding: 字符串,"same""valid"
  • data_format: 字符串,"channels_last""channels_first"
  • dilation_rate: 3 个整数的元组。

返回

一个张量,3D 卷积的结果。

异常

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

conv3d_transpose

keras.backend.conv3d_transpose(x, kernel, output_shape, strides=(1, 1, 1), padding='valid', data_format=None)

3D 反卷积 (即转置卷积)。

参数

  • x: 输入张量。
  • kernel: 核张量。
  • output_shape: 表示输出尺寸的 1D 整数张量。
  • strides: 步长元组。
  • padding: 字符串,"same""valid"
  • data_format: 字符串,"channels_last""channels_first"。 对于输入/卷积核/输出,是否使用 Theano 或 TensorFlow/CNTK数据格式。

返回

一个张量,3D 转置卷积的结果。

异常

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

pool2d

keras.backend.pool2d(x, pool_size, strides=(1, 1), padding='valid', data_format=None, pool_mode='max')

2D 池化。

参数

  • x: 张量或变量。
  • pool_size: 2 个整数的元组。
  • strides: 2 个整数的元组。
  • padding: 字符串,"same""valid"
  • data_format: 字符串,"channels_last""channels_first"
  • pool_mode: 字符串,"max""avg"

返回

一个张量,2D 池化的结果。

异常

  • ValueError: 如果 data_format 既不是 channels_last 也不是 channels_first
  • ValueError: if pool_mode 既不是 "max" 也不是 "avg"

pool3d

keras.backend.pool3d(x, pool_size, strides=(1, 1, 1), padding='valid', data_format=None, pool_mode='max')

3D 池化。

参数

  • x: 张量或变量。
  • pool_size: 3 个整数的元组。
  • strides: 3 个整数的元组。
  • padding: 字符串,"same""valid"
  • data_format: 字符串,"channels_last""channels_first"
  • pool_mode: 字符串,"max""avg"

返回

一个张量,3D 池化的结果。

异常

  • ValueError: 如果 data_format 既不是 channels_last 也不是 channels_first
  • ValueError: if pool_mode 既不是 "max" 也不是 "avg"

bias_add

keras.backend.bias_add(x, bias, data_format=None)

给张量添加一个偏置向量。

参数

  • x: 张量或变量。
  • bias: 需要添加的偏置向量。
  • data_format: 字符串,"channels_last""channels_first"

返回

输出张量。

异常

  • ValueError: 以下两种情况之一:
  • 无效的 data_format 参数。
  • 无效的偏置向量尺寸。 偏置应该是一个 ndim(x)-1 维的向量或张量。

random_normal

keras.backend.random_normal(shape, mean=0.0, stddev=1.0, dtype=None, seed=None)

返回正态分布值的张量。

参数

  • shape: 一个整数元组,需要创建的张量的尺寸。
  • mean: 一个浮点数,抽样的正态分布平均值。
  • stddev: 一个浮点数,抽样的正态分布标准差。
  • dtype: 字符串,返回的张量的数据类型。
  • seed: 整数,随机种子。

返回

一个张量。


random_uniform

keras.backend.random_uniform(shape, minval=0.0, maxval=1.0, dtype=None, seed=None)

返回均匀分布值的张量。

参数

  • shape: 一个整数元组,需要创建的张量的尺寸。
  • minval: 一个浮点数,抽样的均匀分布下界。
  • maxval: 一个浮点数,抽样的均匀分布上界。
  • dtype: 字符串,返回的张量的数据类型。
  • seed: 整数,随机种子。

返回

一个张量。


random_binomial

keras.backend.random_binomial(shape, p=0.0, dtype=None, seed=None)

返回随机二项分布值的张量。

参数

  • shape: 一个整数元组,需要创建的张量的尺寸。
  • p: 一个浮点数,0. <= p <= 1,二项分布的概率。
  • dtype: 字符串,返回的张量的数据类型。
  • seed: 整数,随机种子。

返回

一个张量。


truncated_normal

keras.backend.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=None, seed=None)

返回截断的随机正态分布值的张量。

生成的值遵循具有指定平均值和标准差的正态分布, 此外,其中数值大于平均值两个标准差的将被丢弃和重新挑选。

参数

  • shape: 一个整数元组,需要创建的张量的尺寸。
  • mean: 平均值。
  • stddev: 标准差。
  • dtype: 字符串,返回的张量的数据类型。
  • seed: 整数,随机种子。

返回

一个张量。


ctc_label_dense_to_sparse

keras.backend.ctc_label_dense_to_sparse(labels, label_lengths)

将 CTC 标签从密集转换为稀疏表示。

参数

  • labels: 密集 CTC 标签。
  • label_lengths: 标签长度。

返回

一个表示标签的稀疏张量。


ctc_batch_cost

keras.backend.ctc_batch_cost(y_true, y_pred, input_length, label_length)

在每个批次元素上运行 CTC 损失算法。

参数

  • y_true: 张量 (samples, max_string_length), 包含真实标签。
  • y_pred: 张量 (samples, time_steps, num_categories), 包含预测值,或 softmax 输出。
  • input_length: 张量 (samples, 1), 包含 y_pred 中每个批次样本的序列长度。
  • label_length: 张量 (samples, 1), 包含 y_true 中每个批次样本的序列长度。

返回

尺寸为 (samples,1) 的张量,包含每一个元素的 CTC 损失。


ctc_decode

keras.backend.ctc_decode(y_pred, input_length, greedy=True, beam_width=100, top_paths=1)

解码 softmax 的输出。

可以使用贪心搜索(也称为最优路径)或受限字典搜索。

参数

  • y_pred: 张量 (samples, time_steps, num_categories), 包含预测值,或 softmax 输出。
  • input_length: 张量 (samples,), 包含 y_pred 中每个批次样本的序列长度。
  • greedy: 如果为 True,则执行更快速的最优路径搜索,而不使用字典。
  • beam_width: 如果 greedyfalse,将使用该宽度的 beam 搜索解码器搜索。
  • top_paths: 如果 greedyfalse, 将返回多少条最可能的路径。

返回

  • Tuple:
  • List: 如果 greedytrue,返回包含解码序列的一个元素的列表。 如果为 false,返回最可能解码序列的 top_paths
  • Important: 空白标签返回为 -1。包含每个解码序列的对数概率的张量 (top_paths,)

map_fn

keras.backend.map_fn(fn, elems, name=None, dtype=None)

将函数fn映射到元素 elems 上并返回输出。

参数

  • fn: 将在每个元素上调用的可调用函数。
  • elems: 张量。
  • name: 映射节点在图中的字符串名称。
  • dtype: 输出数据格式。

返回

数据类型为 dtype 的张量。


foldl

keras.backend.foldl(fn, elems, initializer=None, name=None)

使用 fn 归约 elems,以从左到右组合它们。

参数

  • fn: 将在每个元素和一个累加器上调用的可调用函数,例如 lambda acc, x: acc + x
  • elems: 张量。
  • initializer: 第一个使用的值 (如果为 None,使用elems[0])。
  • name: foldl 节点在图中的字符串名称。

返回

initializer 类型和尺寸相同的张量。


foldr

keras.backend.foldr(fn, elems, initializer=None, name=None)

使用 fn 归约 elems,以从右到左组合它们。

参数

  • fn: 将在每个元素和一个累加器上调用的可调用函数,例如 lambda acc, x: acc + x
  • elems: 张量。
  • initializer: 第一个使用的值 (如果为 None,使用elems[-1])。
  • name: foldr 节点在图中的字符串名称。

返回

initializer 类型和尺寸相同的张量。


local_conv1d

keras.backend.local_conv1d(inputs, kernel, kernel_size, strides, data_format=None)

在不共享权值的情况下,运用 1D 卷积。

参数

  • inputs: 3D 张量,尺寸为 (batch_size, steps, input_dim)
  • kernel: 卷积的非共享权重, 尺寸为 (output_items, feature_dim, filters)
  • kernel_size: 一个整数的元组, 指定 1D 卷积窗口的长度。
  • strides: 一个整数的元组, 指定卷积步长。
  • data_format: 数据格式,channels_first 或 channels_last。

返回

运用不共享权重的 1D 卷积之后的张量,尺寸为 (batch_size, output_length, filters)。

异常

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

local_conv2d

keras.backend.local_conv2d(inputs, kernel, kernel_size, strides, output_shape, data_format=None)

在不共享权值的情况下,运用 2D 卷积。

参数

  • inputs: 如果 data_format='channels_first', 则为尺寸为 (batch_size, filters, new_rows, new_cols) 的 4D 张量。 如果 data_format='channels_last', 则为尺寸为 (batch_size, new_rows, new_cols, filters) 的 4D 张量。
  • kernel: 卷积的非共享权重, 尺寸为 (output_items, feature_dim, filters)
  • kernel_size: 2 个整数的元组, 指定 2D 卷积窗口的宽度和高度。
  • strides: 2 个整数的元组, 指定 2D 卷积沿宽度和高度方向的步长。
  • output_shape: 元组 (output_row, output_col) 。
  • data_format: 数据格式,channels_first 或 channels_last。

返回

一个 4D 张量。

  • 如果 data_format='channels_first',尺寸为 (batch_size, filters, new_rows, new_cols)。
  • 如果 data_format='channels_last',尺寸为 (batch_size, new_rows, new_cols, filters)

异常

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

backend

backend.backend()

公开可用的方法,以确定当前后端。

返回

字符串,Keras 目前正在使用的后端名。

例子

>>> keras.backend.backend()
'tensorflow'
腾讯云服务器 阿里云服务器
关注微信
^