Keras 后端

2025 年 3 月 17 日 | 阅读 26 分钟

Keras 是一个模型级库，提供高级构建块，可用于开发深度学习模型。它不直接支持张量乘积、卷积等低级操作，而是依赖于专门优化张量操作的后端引擎。它不会只选择一个张量库来实现 Keras 并将其绑定到该特定库。它通过无缝地将许多不同的后端引擎插入 Keras 来模块化地处理这种情况。

以下是三种可用的后端实现：

TensorFlow： 这是由 Google 开发的用于符号张量操作的开源框架。
Theano： 这也是一个由蒙特利尔大学 LISA 实验室开发的用于符号张量操作的开源框架。
CNTK： 它是由 Microsoft 开发的，也是一个开源的深度学习工具包。

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

你可能会在以下位置找到 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.json 和 "backend" 设置来完成。假设你有一个名为 my_module 的 Python 模块作为外部后端使用；那么，在这种情况下，keras.json 文件可能会发生一些变化，如下所示：

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

为了使用外部后端，它必须经过验证并包含像 placeholder、variable 和 function 这样的函数。

如果外部后端无效，则可能会生成包含所有缺失条目的错误。

keras.json 详细信息

以下是 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 遵循的数据格式约定。（它由 backend.image_data_format() 返回）。
对于任何二维数据（例如图像），"channels_last" 将假定 (行, 列, 通道)，而 "channels_first" 将假定 (通道, 行, 列)。
对于任何三维数据，"channels_last" 将对应于 (conv_dim1, conv_dim2, conv_dim3, 通道)，而 "channels_first" 将对应于 (通道, conv_dim1, conv_dim2, conv_dim3)。
epsilon： 它指的是一个浮点数，这是一个模糊的数字常数，用于避免某些操作中的除以零。
floatx： 它表示字符串 "float16"、"float32" 或 "float64"。默认情况下，它是浮点精度。
backend： 它指的是字符串 "tensorflow"、"theano" 或 "cntk"。

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

借助抽象 Keras 后端 API，你可以使你编写的 Keras 模块与 Theano (th) 和 TensorFlow (tf) 兼容。以下是对此的介绍：

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

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

inputs = K.placeholder(shape=(2, 4, 5))
# also works:
inputs = K.placeholder(shape=(None, 4, 5))
# also works:
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)

# all-zeros variable:
var = K.zeros(shape=(3, 4, 5))
# all-ones:
var = K.ones(shape=(3, 4, 5))

你可能需要的大多数张量操作将以与你在 TensorFlow 或 Theano 中相同的方式执行，如下所示：

 # Initializing Tensors with Random Numbers
b = K.random_uniform_variable(shape=(3, 4), low=0, high=1) # Uniform distribution
c = K.random_normal_variable(shape=(3, 4), mean=0, scale=1) # Gaussian distribution
d = K.random_normal_variable(shape=(3, 4), mean=0, scale=1)

# Tensor Arithmetic
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)
# etc...

后端函数

backend

backend 函数用于返回当前后端名称。

返回值

它返回一个与正在使用的后端当前名称相关的字符串。

示例

>>> keras.backend.backend()
'tensorflow'

symbolic

它可以定义为一个装饰器，在 TensorFlow 2.0 中用于进入 Keras 图。

参数

func： 它指的是用于装饰的函数。

返回值

它返回一个装饰函数。

eager

它可以定义为一个装饰器，在 TensorFlow 2.0 中用于退出 Keras 图。

参数

func： 它指的是用于装饰的函数。

返回值

它返回一个装饰函数。

get_uid

它提供了一个唯一的 UID，给出字符串前缀。

参数

prefix： 它指的是一个字符串。

返回值

此后端函数返回一个整数。

示例

>>> keras.backend.get_uid('dense')
1
>>> keras.backend.get_uid('dense')
2

此函数用于设置手动变量初始化标志。该标志是一个布尔值，用于控制变量是否初始化，或者用户必须处理初始化，因为它们默认是自实例化的。

参数

value： 它指的是 Python 的布尔值。

epsilon

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

返回值

它返回一个浮点数。

示例

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

reset_uids

它用于重置图标识符。

epsilon

它输出数值表达式中使用的模糊因子值。

返回值

它返回一个浮点值。

示例

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

set_epsilon

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

参数

e：它可以定义为一个浮点值，表示 epsilon 的新值。

示例

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

floatx

它用于输出浮点类型字符串，例如 'float16'、'float32'、'float64'。

返回值

它返回当前默认浮点类型字符串。

示例

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

set_floatx

它用于设置默认浮点类型值。

参数

floatx： 它指的是浮点类型字符串，例如 'float16'、'float32' 或 'float64'。

示例

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

引发

ValueError： 每当出现无效值时，将生成 ValueError。

cast_to_floatx

它用于将 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

它用于返回默认图像数据格式约定。

返回值

它返回字符串 'channels_first' 或 'channels_last'

示例

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

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

引发

ValueError： 每当 data_format 值无效时，它将生成 ValueError。

learning_phase

它输出学习阶段的标志，它指的是布尔张量（0 = 测试，1 = 训练），作为输入传递给任何 Keras 函数，该函数在训练和测试时使用不同的行为。

返回值

它返回学习阶段的标量整数张量或 Python 整数。

set_learning_phase

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

参数

value： 它可以定义为表示学习阶段值（0 或 1）的整数。

引发

ValueError： 如果值既不是 0 也不是 1，则会引发此错误。

clear_session

它用于重置 Keras 生成的每个状态。用于实现函数式模型构建 API 以及使自动生成的层名唯一的全局状态由 Keras 处理。

当在循环中构建多个模型时，全局状态将在一定时间段内消耗越来越多的内存，你希望清除它。

它用于销毁当前的 Keras 图并创建一个新的图。它非常有用，因为它避免了旧模型/层的混乱。

示例 1：在循环中创建模型时调用 clear_session()。

for _ in range(100):
  # Without `clear_session()`, each iteration of this loop will
  # slightly increase the size of the global state managed by Keras
  model = tf.keras.Sequential([tf.keras.layers.Dense(10) for _ in range(10)])

for _ in range(100):
  # With `clear_session()` called at the beginning,
  # Keras starts with a blank state at each iteration
  # and memory consumption is constant over time.
  tf.keras.backend.clear_session()
  model = tf.keras.Sequential([tf.keras.layers.Dense(10) for _ in range(10)])

示例 2：重置层名生成计数器。

>>> import tensorflow as tf
>>> layers = [tf.keras.layers.Dense(10) for _ in range(10)]
>>> new_layer = tf.keras.layers.Dense(10)
>>> print(new_layer.name)
dense_10
>>> tf.keras.backend.set_learning_phase(1)
>>> print(tf.keras.backend.learning_phase())
1
>>> tf.keras.backend.clear_session()
>>> new_layer = tf.keras.layers.Dense(10)
>>> print(new_layer.name)
dense

is_sparse

它用于返回张量是否是稀疏张量。

参数

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

它用于将稀疏张量转换为密集张量并返回它。

参数

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

它有助于实例化变量并返回它。

参数

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

is_variable

常数

它导致创建唯一的张量。

参数

value： 它指的是常量值或列表。
dtype： 它指的是张量的类型。
name： 对于张量，它表示字符串名称。
shape： 它可以定义为结果张量的维度，它是可选的。

返回值

它还返回一个唯一的张量。

is_keras_tensor

它输出 x 是否是 Keras 张量。 "Keras 张量" 是由 Keras 层 (Layer 类) 或 Input 返回的张量。

参数

x：它指的是候选张量。

返回值

它返回一个布尔值，表示参数是否是 Keras 张量。

引发

如果 x 不是符号张量，则会引发 ValueError。

示例

>>> from keras import backend as K
>>> from keras.layers import Input, Dense
>>> np_var = numpy.array([1, 2])
>>> K.is_keras_tensor(np_var) # A numpy array is not a symbolic tensor.
ValueError
>>> k_var = tf.placeholder('float32', shape=(1,1))
>>> # A variable indirectly created outside of keras is not a Keras tensor.
>>> K.is_keras_tensor(k_var)
False
>>> keras_var = K.variable(np_var)
>>> # A variable created with the keras backend is not a Keras tensor.
>>> K.is_keras_tensor(keras_var)
False
>>> keras_placeholder = K.placeholder(shape=(2, 4, 5))
>>> # A placeholder is not a Keras tensor.
>>> K.is_keras_tensor(keras_placeholder)
False
>>> keras_input = Input([10])
>>> K.is_keras_tensor(keras_input) # An Input is a Keras tensor.
True
>>> keras_layer_output = Dense(10)(keras_input)
>>> # Any Keras layer output is a Keras tensor.
>>> K.is_keras_tensor(keras_layer_output)
True

is_tensor

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

它返回 x 是否是占位符。

参数

x：它可以定义为候选占位符。

返回值

它返回一个布尔值。

shape

它输出张量或变量的符号形状。

参数

x：它指的是张量或变量。

返回值

它返回符号形状的张量。

示例

# TensorFlow example
>>> 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>
# 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(inputs).eval(session=tf_session)
array([2, 4, 5], dtype=int32)

int_shape

它可以定义为整数元组或 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

它指的是一个整数，作为张量中的轴数返回。

参数

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

大小

它输出张量大小。

参数

x：它可以定义为张量或变量。
name： 它是一个可选的关键字参数，表示操作的名称。

返回值

它返回张量的大小。

示例

>>> from keras import backend as K
>>> val = np.array([[1, 2], [3, 4]])
>>> kvar = K.variable(value=val)
>>> K.size(inputs)
<tf.Tensor: id=9, shape=(), dtype=int32, numpy=4>

dtype

它可以定义为字符串，作为 Keras 张量或变量的数据类型返回。

参数

x：它可以定义为张量或变量。

返回值

对于 x，它返回其数据类型。

示例

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

Numpy 实现

def dtype(x):
    return x.dtype.name

eval

它有助于评估张量值。

参数

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)

Numpy 实现

def eval(x):
    return x

zeros

它有助于实例化所有零的变量，然后返回它。

参数

shape： 它可以定义为整数元组，表示返回的 Keras 变量的形状。
dtype： 它指的是与返回的 Keras 变量数据类型对应的字符串。
name： 它指的是表示返回的 Keras 变量名称的字符串。

返回值

它返回一个包含 Keras 元数据的变量，该变量填充为 0.0。需要注意的是，如果它是符号 n 形状，则不能返回变量，而是返回动态形状的张量。

示例

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

Numpy 实现

def zeros(shape, dtype=floatx(), name=None):
    return np.zeros(shape, dtype=dtype)

ones

它有助于实例化一个全为一的变量，然后返回它。

参数

shape： 它可以定义为整数元组，表示返回的 Keras 变量的形状。
dtype： 它指的是与返回的 Keras 变量数据类型对应的字符串。
name： 它指的是表示返回的 Keras 变量名称的字符串。

返回值

它返回一个 Keras 变量，填充为 0.0。需要注意的是，如果它是符号 n 形状，则不能返回变量，而是返回动态形状的张量。

示例

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

Numpy 实现

def ones(shape, dtype=floatx(), name=None):
    return np.ones(shape, dtype=dtype)

eye

它有助于实例化一个单位矩阵，然后返回它。

参数

size： 它可以定义为定义行数和列数的元组，或者表示行数的整数。
dtype： 它指的是与返回的 Keras 变量数据类型对应的字符串。
name： 它指的是表示返回的 Keras 变量名称的字符串。

返回值

它输出表示单位矩阵的 Keras 变量。

示例

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

Numpy 实现

def eye(size, dtype=None, name=None):
    if isinstance(size, (list, tuple)):
        n, m = size
    else:
        n, m = size, size
    return np.eye(n, m, dtype=dtype)

zeros_like

它有助于实例化与另一个张量具有相同形状的全部为零的变量。

参数

x：它可以定义为 Keras 变量或 Keras 张量。
dtype： 它指的是与返回的 Keras 变量数据类型对应的字符串。此处 None 表示使用 x 数据类型。
name： 它指的是表示返回的 Keras 变量名称的字符串。

返回值

它返回一个 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)

Numpy 实现

def zeros_like(x, dtype=floatx(), name=None):
    return np.zeros_like(x, dtype=dtype)

ones_like

它有助于实例化与另一个张量具有相同形状的全部为一的变量。

参数

x：它可以定义为 Keras 变量或 Keras 张量。
dtype： 它指的是与返回的 Keras 变量数据类型对应的字符串。此处 None 表示使用 x 数据类型。
name： 它指的是表示返回的 Keras 变量名称的字符串。

返回值

它返回一个 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)

Numpy 实现

def ones_like(x, dtype=floatx(), name=None):
    return np.ones_like(x, dtype=dtype)

identity （标识）

它输出一个张量，其内容与输入张量相同。

参数

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

Numpy 实现

def random_uniform_variable(shape, low, high, dtype=None, name=None, seed=None):
    return (high - low) * np.random.random(shape).astype(dtype) + low

random_normal_variable

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

它有助于实例化一个变量，其值从正态分布中抽取。

参数

shape： 它可以定义为整数元组，表示返回的 Keras 变量的形状
mean： 它指的是一个浮点数，表示正态分布的均值。
scale： 它指的是一个浮点数，表示正态分布的标准差。
dtype： 它可以定义为字符串，表示返回的 Keras 变量的数据类型。
name： 它指的是表示返回的 Keras 变量名称的字符串。
seed： 它指的是表示随机种子的整数。

返回值

它输出一个 Keras 变量，该变量已填充了抽取样本。

示例

# TensorFlow example
>>> 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)

Numpy 实现

def random_normal_variable(shape, mean, scale, dtype=None, name=None, seed=None):
    return scale * np.random.randn(*shape).astype(dtype) + mean

count_params

它输出 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)

Numpy 实现

def count_params(x):
    return x.size

cast

它有助于将张量转换为不同的数据类型，然后返回它。如果，如果你转换 Keras 变量，它也将产生 Keras 张量。

参数

x：它可以定义为 Keras 张量或变量。
dtype： 它指的是字符串 'float16'、'float32' 或 'float64'。

返回值

它输出一个数据类型为 dtype 的 Keras 张量。

示例

>>> 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（更新）

它有助于将 x 的值更新为 new_x。

参数

x：它指的是一个变量。
new_x： 它可以定义为与 x 具有相似形状的张量。

返回值

它产生更新后的 x 变量。

update_add

它添加一个增量，有助于更新 x 的值。

参数

x：它指的是一个变量。
increment： 它可以定义为与 x 具有相似形状的张量。

返回值

它返回更新后的 x 变量。

update_sub

它减去递减量以更新 x 的值。

参数

x：它可以定义为变量。
decrement： 它指的是与 x 具有相似形状的张量。

返回值

它返回更新后的 x 变量。

moving_average_update

对于变量，它计算其移动平均值。

参数

x：它指的是一个变量。
value： 它可以定义为与 x 具有相同形状的张量。
momentum： 它指的是静态平均动量。

返回值

它输出用于更新变量的操作。

dot

它通过乘以 2 个张量或变量来返回一个张量。

在将 nD 张量乘以另一个 nD 张量时，会重现 Theano 行为。(例如 (2, 3) * (4, 3, 5) -> (2, 4, 5))

参数

x：它指的是张量或变量。
y：它指的是张量或变量。

返回值

它返回在 x 和 y 之间进行点积后生成的张量。

示例

# dot product between tensors
>>> 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>
# dot product between tensors
>>> 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-like behavior example
>>> 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)

Numpy 实现

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

batch_dot

batch_dot 有助于计算 x 和 y 之间的批处理点积，其中 x 和 y 是批处理中的数据（即形状为 (batch_size, :)）。它输出一个维度少于输入的张量或变量。如果我们将维度数量减少到 1，那么我们可以使用 expand_dims，它确保 ndim 至少为 2。

参数

x：它指的是 Keras 张量或变量，其 ndim 大于或等于 2。
y：它指的是 Keras 张量或变量，其 ndim 大于或等于 2。
axes： 它可以定义为 int 或 tuple(int, int)，它强调要减少的目标维度。

返回值

它返回一个张量，其形状与 x 的形状和 y 的形状的拼接相同 ()。这里 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 的形状中的每个维度：

shape[0] : 100 : 添加到输出形状
shape[1] : 20 : 不添加到输出形状，x 的维度 1 已被求和。(dot_axes[0] = 1)
shape[0] : 100 : 不添加到输出形状，始终忽略 y 的第一个维度
shape[1] : 30 : 添加到输出形状
shape[2] : 20 : 不添加到输出形状，y 的维度 2 已被求和。(dot_axes[1] = 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

它用于转置张量，然后返回它。

参数

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>

Numpy 实现

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

gather

它有助于在张量 reference 中检索索引 indices 元素。

参数

reference： 它指的是一个张量。
indices： 它可以定义为表示索引张量的整数。

返回值

它输出一个与 reference 类型相同的张量。

Numpy 实现

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

max

它计算张量的最大值。

参数

x：它可以定义为张量或变量。
axis： 它指的是 [-rank(x), rank(x)) 内的整数或整数列表，用于计算最大值的轴。如果设置为 None（默认），则计算所有维度上的最大值。
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

它计算张量中的最小值。

参数

x：它可以定义为张量或变量。
axis： 它指的是 [-rank(x), rank(x)) 内的整数或整数列表，用于计算最小值的轴。如果设置为 None（默认），则计算所有维度上的最小值。
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

它输出张量中指定轴上的值总和。

参数

x：它可以定义为张量或变量。
axis： 它指的是 [-rank(x), rank(x)) 内的整数或整数列表，用于计算和的轴。如果设置为 None（默认），则计算所有维度上的和。
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

结合特定轴，它计算张量中值的乘积。

参数

x：它可以定义为张量或变量。
axis： 它指的是 [-rank(x), rank(x)) 内的整数或整数列表，用于计算乘积的轴。如果设置为 None（默认），则计算所有维度上的总乘积。
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

结合特定轴，它计算张量中值的累积和。

参数

x：它可以定义为张量或变量。
axis： 它指的是一个整数，它是用于计算和的轴。

返回值

它返回一个包含 x 沿轴值的累积和的张量。

Numpy 实现

def cumsum(x, axis=0):
    return np.cumsum(x, axis=axis)

cumprod

结合特定轴，它计算张量中值的累积乘积。

参数

x：它可以定义为张量或变量。
axis： 它指的是一个整数，它是用于计算乘积的轴。

返回值

它返回一个包含 x 沿轴值的累积乘积的张量。

Numpy 实现

def cumprod(x, axis=0):
    return np.cumprod(x, axis=axis)

var

结合特定轴，它计算张量的方差。

参数

x：它可以定义为张量或变量。
axis： 它指的是 [-rank(x), rank(x)) 内的整数或整数列表，用于计算方差的轴。如果设置为 None（默认），则计算所有维度上的总方差。
keepdims： 它是一个布尔值，决定是否保留维度。如果 keepdims 设置为 False，则张量的秩将减少 1。否则，如果 keepdims 设置为 True，则减少的维度将保留长度为 1。

返回值

它返回 x 中元素张量的方差。

Numpy 实现

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

rnn

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

它有助于在张量维度上方重复。

参数

step_function： 它被称为 RNN 步函数。它包含以下给定参数：
- input： 它包括一个形状为 (样本, ...) 的张量，表示在特定时间步的批处理样本输入。它不包括时间维度。
- states： 它可以定义为张量列表。
- new_states： 它可以定义为张量列表，其形状和长度与状态相同，以便初始状态必须是列表中上一个时间步的输出张量。

返回值

它输出形状为 (样本, output_dim) 的张量。

inputs： 它指的是至少三维的时间数据张量，形状为 (样本, 时间, ...)，或者嵌套张量，每个张量形状为 (样本, 时间, ...)。
initial_states： 它可以定义为形状为 (样本, state_size) 的张量，包含要在步函数中使用的状态初始值。当 state_size 具有嵌套形状时，initial_states 也将遵循嵌套结构。
go_backwards： 它可以定义为布尔值，如果设置为 True，则将以相反顺序在时间维度上方执行迭代，然后返回反转序列。
mask： 它指的是形状为 (样本, 时间, 1) 的二进制张量，包括每个被掩码的零元素。
constants： 它可以定义为常量值列表，每个步骤都分发。
unroll： 它说明 RNN 应该展开还是使用符号 while 循环。
input_length： 它可以定义为整数或一维张量，取决于时间维度是否具有固定长度。如果未指定掩码时设置为可变长度输入，则将用于掩码。
time_major： 它可以定义为布尔值。如果设置为 true，则输入和输出的形状将为 (时间步批次, ...)，否则如果设置为 false 则为 (批次, 时间步, ...)。使用 time_major = True 是一项相当高效的任务，因为它避免了在 RNN 计算开始和结束时进行转置。但是，大多数情况下，由于 TensorFlow 数据主要存在于批处理中，因此默认情况下，此函数以批处理主要的形式接受输入并发出输出。
zero_output_for_mask： 它指的是一个布尔值，如果设置为 true，则被掩码时间步输出将为零，否则将返回上一步输出。

返回值

它返回形状为 (last_output, outputs, new_states) 的元组，其中 last_output 指的是 rnn 最新的输出，形状为 (样本, ...)，outputs 指的是形状为 (样本, 时间, ...) 的张量，使得每个条目 outputs[s, t] 对应于样本 s 和时间 t 的步函数输出，而 new_states 可以定义为张量列表，表示最新的状态，这些状态由形状为 (样本, ...) 的步函数返回。

引发

ValueError： 如果输入维度小于 3，则会生成 ValueError。
ValueError： 如果 unroll 设置为 True，而输入时间步不是静态数字，也可能引发此错误。
ValueError： 如果提供了 mask 但未设置为 None 并且未提供状态（即 len(states) ==0），则也会生成此错误。

下一主题Keras 模型