Keras backends

What is a "backend"?

Keras是一个模型级库,为开发深度学习模型提供了高级构建块. 它本身不处理诸如张量积,卷积之类的底层操作. 取而代之的是,它依靠一个专门的,经过优化的张量操纵库来实现,它是Keras的"后端引擎". Keras不用选择一个张量库并使Keras的实现与该库绑定在一起,而是以模块化的方式处理该问题,并且可以将多个不同的后端引擎无缝地插入Keras中.

目前,Keras提供了三种后端实现: TensorFlow后端, Theano后端和CNTK后端.

  • TensorFlow是Google开发的开源符号张量操纵框架.
  • Theano是由蒙特利尔大学的LISA Lab开发的开源符号张量操纵框架.
  • CNTK是由Microsoft开发的用于深度学习的开源工具包.

将来,我们可能会添加更多后端选项.


Switching from one backend to another

如果您至少运行过一次Keras,则可以在以下位置找到Keras配置文件:

$HOME/.keras/keras.json

如果不存在,则可以创建它.

Windows用户注意:请用%USERPROFILE%替换$HOME .

默认配置文件如下所示:

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

只需将字段backend更改为"theano""tensorflow""cntk" ,下次您运行任何Keras代码时, "cntk"将使用新配置.

您还可以定义环境变量KERAS_BACKEND ,这将覆盖配置文件中定义的内容:

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

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

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

外部后端必须经过验证才能使用,有效后端必须具有以下功能: placeholdervariablefunction .

如果外部后端由于缺少必需的条目而无效,则将记录一条错误,通知缺少哪些条目.


keras.json details

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 :Float,一个数字模糊常数,用于在某些操作中避免被零除.
  • floatx :字符串, "float16""float32""float64" . 默认浮点精度.
  • backend :字符串, "tensorflow""theano""cntk" .

Using the abstract Keras backend to write new code

如果希望编写的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))
# 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 functions

backend

keras.backend.backend()

返回当前后端的名称(例如" tensorflow").

Returns

字符串,当前使用的后端Keras的名称.

Example

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

symbolic

keras.backend.symbolic(func)

TensorFlow 2.0中使用的Decorator进入Keras图.

Arguments

  • func :装饰功能.

Returns

装饰功能.


eager

keras.backend.eager(func)

TensorFlow 2.0中使用的Decorator退出Keras图.

Arguments

  • func :装饰功能.

Returns

装饰功能.


get_uid

keras.backend.get_uid(prefix='')

提供给定字符串前缀的唯一UID.

Arguments

  • 前缀 :字符串.

Returns

一个整数.

Example

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

manual_variable_initialization

keras.backend.manual_variable_initialization(value)

设置手动变量初始化标志.

此布尔值标志确定是否应在实例化变量时对其进行初始化(默认值),或者用户是否应处理初始化.

Arguments

  • :Python布尔值.

epsilon

keras.backend.epsilon()

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

Returns

一个浮标.

Example

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

reset_uids

keras.backend.reset_uids()

Resets graph identifiers.

set_epsilon

keras.backend.set_epsilon(e)

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

Arguments

  • e :浮动. epsilon的新值.

Example

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

floatx

keras.backend.floatx()

以字符串形式返回默认的float类型. (例如," float16"," float32"," float64").

Returns

String,当前的默认浮点类型.

Example

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

set_floatx

keras.backend.set_floatx(floatx)

设置默认的浮点类型.

Arguments

  • floatx :字符串," float16"," float32"或" float64".

Example

>>> 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浮点类型.

Arguments

  • x :Numpy数组.

Returns

相同的Numpy数组,强制转换为其新类型.

Example

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

返回默认的图像数据格式约定.

Returns

字符串, 'channels_first''channels_last'

Example

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

set_image_data_format

keras.backend.set_image_data_format(data_format)

设置数据格式约定的值.

Arguments

  • data_format :字符串. 'channels_first''channels_last' .

Example

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

learning_phase

keras.backend.learning_phase()

返回学习阶段标志.

学习阶段标志是布尔张量(0 =测试,1 =火车),作为输入传递给在火车时间和测试时间使用不同行为的任何Keras函数.

Returns

学习阶段(标量整数张量或Python整数).


set_learning_phase

keras.backend.set_learning_phase(value)

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

Arguments

  • value :学习阶段值,0或1(整数).

Raises

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

clear_session

keras.backend.clear_session()

销毁当前的Keras图并创建一个新的图.

有助于避免旧模型/图层造成混乱.


is_sparse

keras.backend.is_sparse(tensor)

返回张量是否为稀疏张量.

Arguments

  • 张量 :张量实例.

Returns

一个布尔值.

Example

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

将稀疏张量转换为密集张量并将其返回.

Arguments

  • 张量 :一个张量实例(可能是稀疏的).

Returns

密集的张量.

Examples

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

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

Arguments

  • value :Numpy数组,张量的初始值.
  • dtype :张量类型.
  • name :张量的可选名称字符串.
  • 约束 :在优化程序更新后将应用于变量的可选投影函数.

Returns

变量实例(包括Keras元数据).

Examples

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

keras.backend.is_variable(x)

constant

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

创建一个常数张量.

Arguments

  • value :一个常数值(或列表)
  • dtype :所得张量元素的类型.
  • shape :生成的张量的可选尺寸.
  • name :张量的可选名称.

Returns

恒定张量.


is_keras_tensor

keras.backend.is_keras_tensor(x)

返回x是否为Keras张量.

" Keras张量"是Keras图层( Layer类)或Input返回的张量.

Arguments

  • x :候选张量.

Returns

布尔值:参数是否为Keras张量.

Raises

  • ValueError :如果x不是符号张量.

Examples

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

keras.backend.is_tensor(x)

placeholder

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

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

Arguments

  • shape :占位符的形状(整数元组,可能包含None条目).
  • ndim :张量的轴数. 必须至少指定{ shapendim }之一. 如果同时指定了shape则使用shape .
  • dtype :占位符类型.
  • sparse :布尔值,占位符是否应为稀疏类型.
  • name: Optional name string for the placeholder.

Returns

Tensor实例(包括Keras元数据).

Examples

>>> 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是否为占位符.

Arguments

  • x :候选占位符.

Returns

Boolean.


shape

keras.backend.shape(x)

返回张量或变量的符号形状.

Arguments

  • x :张量或变量.

Returns

一个符号形状(本身就是张量).

Examples

# 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

keras.backend.int_shape(x)

以int或None条目的元组形式返回张量或变量的形状.

Arguments

  • x :张量或变量.

Returns

整数(或无条目)的元组.

Examples

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

返回张量中的轴数(整数).

Arguments

  • x :张量或变量.

Returns

整数(标量),轴数.

Examples

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

size

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

返回张量的大小.

Arguments

  • x :张量或变量.
  • name :操作的名称(可选).

Returns

张量的大小.

Examples

>>> 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.backend.dtype(x)

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

Arguments

  • x :张量或变量.

Returns

字符串, x dtype.

Examples

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

keras.backend.eval(x)

评估张量的值.

Arguments

  • x :张量.

Returns

一个Numpy数组.

Examples

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

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

实例化全零变量并将其返回.

Arguments

  • shape :整数元组,返回的Keras变量的形状
  • dtype :字符串,返回的Keras变量的数据类型
  • name :字符串,返回的Keras变量的名称

Returns

一个变量(包括Keras元数据),填充为0.0 . 请注意,如果shape是符号性的,则无法返回变量,而将返回动态成形的张量.

Example

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

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

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

Arguments

  • shape :整数元组,返回的Keras变量的形状.
  • dtype :字符串,返回的Keras变量的数据类型.
  • name :字符串,返回的Keras变量的名称.

Returns

一个Keras变量,填充有1.0 . 请注意,如果shape是符号性的,则无法返回变量,而将返回动态成形的张量.

Example

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

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

实例化一个身份矩阵并返回它.

Arguments

  • size :元组,行数和列数. 如果为Integer,则为行数.
  • dtype :字符串,返回的Keras变量的数据类型.
  • name :字符串,返回的Keras变量的名称.

Returns

Keras变量,单位矩阵.

Example

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

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

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

Arguments

  • x :Keras变量或Keras张量.
  • dtype :字符串,返回的Keras变量的dtype. 没有使用x的dtype.
  • name :字符串,要创建的变量的名称.

Returns

x形状为零的Keras变量.

Example

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

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

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

Arguments

  • x :Keras变量或张量.
  • dtype :字符串,返回的Keras变量的dtype. 没有使用x的dtype.
  • name :字符串,要创建的变量的名称.

Returns

x形状的Keras变量用1填充.

Example

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

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

返回与输入张量具有相同内容的张量.

Arguments

  • x: The input tensor.
  • name :字符串,要创建的变量的名称.

Returns

具有相同形状,类型和内容的张量.


random_uniform_variable

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

使用从均匀分布中得出的值实例化变量.

Arguments

  • shape :整数元组,返回的Keras变量的形状.
  • :浮动,输出间隔的下边界.
  • :浮动,输出间隔的上限.
  • dtype :字符串,返回的Keras变量的dtype.
  • name :字符串,返回的Keras变量的名称.
  • 种子 :整数,随机种子.

Returns

Keras变量,填充有绘制的样本.

Example

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

使用从正态分布中得出的值实例化变量.

Arguments

  • shape :整数元组,返回的Keras变量的形状.
  • 平均值 :浮点数,正态分布的平均值.
  • 标度 :浮点,正态分布的标准偏差.
  • dtype :字符串,返回的Keras变量的dtype.
  • name :字符串,返回的Keras变量的名称.
  • 种子 :整数,随机种子.

Returns

Keras变量,填充有绘制的样本.

Example

# 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.backend.count_params(x)

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

Arguments

  • x :Keras变量或张量.

Returns

整数, x的元素数,即数组静态尺寸的乘积.

Example

>>> 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.backend.cast(x, dtype)

将张量转换为其他dtype并返回它.

您可以强制转换Keras变量,但仍返回Keras张量.

Arguments

  • x :Keras张量(或变量).
  • dtype :字符串,( 'float16''float32''float64' ).

Returns

Keras张量D型dtype .

Example

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

Arguments

  • x :一个Variable .
  • new_x :与x形状相同的张量.

Returns

变量x已更新.


update_add

keras.backend.update_add(x, increment)

通过添加increment更新x的值.

Arguments

  • x :一个Variable .
  • 增量 :与x形状相同的张量.

Returns

变量x已更新.


update_sub

keras.backend.update_sub(x, decrement)

通过减去decrement更新x的值.

Arguments

  • x :一个Variable .
  • 减量 :与x形状相同的张量.

Returns

变量x已更新.


moving_average_update

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

计算变量的移动平均值.

Arguments

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

Returns

更新变量的操作.


dot

keras.backend.dot(x, y)

将2张量(和/或变量)相乘并返回张量 .

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

Arguments

  • x :张量或变量.
  • y: Tensor or variable.

Returns

xy张量点积.

Examples

# 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

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

分批点积.

xy是批量数据时,即(batch_size, :)形状时, batch_dot用于计算xy点积. batch_dot导致张量或变量的尺寸小于输入的尺寸. 如果尺寸数减少到1,我们使用expand_dims来确保ndim至少为2.

Arguments

  • xndim >= 2张量或ndim >= 2变量.
  • yndim >= 2张量或ndim >= 2变量.
  • axes :int或tuple(int,int). 目标尺寸要减小.

Returns

一个张量,其形状等于x的形状(减去求和的尺寸)和y的形状(减去批处理的尺寸和求和的尺寸)的串联. 如果最终等级为1,我们将其重塑为(batch_size, 1) .

Examples

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

Pseudocode:

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尺寸1已累加. ( dot_axes[0] = 1)
  • y.shape[0] :100:不附加到输出形状,始终忽略y第一个尺寸
  • y.shape[1] :30:附加到输出形状
  • y.shape[2] :20:不附加到输出形状, y尺寸2已累加. ( dot_axes[1] = 2) output_shape = (100, 30) 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)

numpy的实现

显示Numpy实施 wzxhzdk:102

transpose

keras.backend.transpose(x)

转置张量并返回它.

Arguments

  • x :张量或变量.

Returns

张量.

Examples

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

keras.backend.gather(reference, indices)

检索张量reference的指标indices的元素.

Arguments

  • 参考 :张量.
  • index索引的整数张量.

Returns

reference相同类型的张量.

numpy的实现

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

max

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

张量的最大值.

Arguments

  • x :张量或变量.
  • axis :[-rank(x),rank(x))中的整数或整数列表,用于查找最大值的轴. 如果为None (默认),则查找所有尺寸的最大值.
  • keepdims :一个布尔值,是否保留尺寸. 如果keepdimsFalse ,则张量的秩减小1.如果keepdimsTrue ,则减小的维数保留为长度1.

Returns

最大值为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)

张量中的最小值.

Arguments

  • x :张量或变量.
  • axis :[-rank(x),rank(x))中的整数或整数列表,用于查找最小值的轴. 如果为None (默认),则查找所有尺寸的最小值.
  • keepdims :一个布尔值,是否保留尺寸. 如果keepdimsFalse ,则张量的秩减小1.如果keepdimsTrue ,则减小的维数保留为长度1.

Returns

最小值为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)

张量中指定轴旁边的值之和.

Arguments

  • x :张量或变量.
  • axis :[-rank(x),rank(x))中的整数或整数列表,求和的轴. 如果为" None (默认),则将对所有尺寸求和.
  • keepdims :一个布尔值,是否保留尺寸. 如果keepdimsFalse ,则张量的秩减小1.如果keepdimsTrue ,则减小的维数保留为长度1.

Returns

张量为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)

将值与指定轴旁边的张量相乘.

Arguments

  • x :张量或变量.
  • axis :[-rank(x),rank(x))中的整数或整数列表,用于计算乘积的轴. 如果为None (默认),则在所有尺寸上计算乘积.
  • keepdims :一个布尔值,是否保留尺寸. 如果keepdimsFalse ,则张量的秩减小1.如果keepdimsTrue ,则减小的维数保留为长度1.

Returns

张量与元素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)

张量中指定轴旁边的值的累积总和.

Arguments

  • x :张量或变量.
  • axis :整数,用于计算总和的轴.

Returns

沿axis x的值的累加总和的张量. numpy的实现

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

cumprod

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

沿指定轴的张量中值的累积积.

Arguments

  • x :张量或变量.
  • axis :整数,用于计算乘积的轴.

Returns

沿axis x的值的累积乘积的张量. numpy的实现

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

var

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

与指定轴相邻的张量方差.

Arguments

  • x :张量或变量.
  • axis :[-rank(x),rank(x))中的整数或整数列表,用于计算方差的轴. 如果为None (默认),则计算所有维度的方差.
  • keepdims :一个布尔值,是否保留尺寸. 如果keepdimsFalse ,则张量的秩减小1.如果keepdimsTrue ,则减小的维数保留为长度1.

Returns

张量为x的元素的方差. numpy的实现

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

std

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

张量的标准偏差,沿着指定的轴.

Arguments

  • x :张量或变量.
  • axis :[-rank(x),rank(x))中的整数或整数列表,用于计算标准偏差的轴. 如果为None (默认),则计算所有尺寸上的标准偏差.
  • keepdims :一个布尔值,是否保留尺寸. 如果keepdimsFalse ,则张量的秩减小1.如果keepdimsTrue ,则减小的维数保留为长度1.

Returns

具有x元素的标准偏差的张量. numpy的实现

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

mean

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

与指定轴并列的张量的平均值.

Arguments

  • x :张量或变量.
  • axis :[-rank(x),rank(x))中的整数或整数列表,用于计算平均值的轴. 如果为None (默认),则计算所有维度的平均值.
  • keepdims :一个布尔值,是否保留尺寸. 如果keepdimsFalse ,则在axis每个条目张量的秩都减小1. 如果keepdimsTrue ,则减小的尺寸将保留为长度1.

Returns

张量为x的均值的张量. numpy的实现

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

any

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

按位归约(逻辑或).

Arguments

  • x :张量或变量.
  • axis :[-rank(x),rank(x))中的整数或整数列表,用于计算逻辑或的轴. 如果为None (默认),则计算逻辑或所有维.
  • keepdims :下降还是广播缩小轴.

Returns

一个uint8张量(0和1). numpy的实现

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

all

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

按位归约(逻辑与).

Arguments

  • x :张量或变量.
  • axis :[-rank(x),rank(x))中的整数或整数列表,用于计算逻辑和的轴. 如果为None (默认),则计算逻辑和所有维.
  • keepdims :下降还是广播缩小轴.

Returns

A uint8 tensor (0s and 1s). numpy的实现

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

argmax

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

返回沿轴的最大值的索引.

Arguments

  • x :张量或变量.
  • axis :执行缩减所沿的轴.

Returns

张量. numpy的实现

def argmax(x, axis=-1):
    return np.argmax(x, axis=axis)

argmin

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

返回沿轴的最小值的索引.

Arguments

  • x :张量或变量.
  • axis :执行缩减所沿的轴.

Returns

张量. numpy的实现

def argmin(x, axis=-1):
    return np.argmin(x, axis=axis)

square

keras.backend.square(x)

元素明智的正方形.

Arguments

  • x :张量或变量.

Returns

张量.


abs

keras.backend.abs(x)

逐元素的绝对值.

Arguments

  • x :张量或变量.

Returns

张量.


sqrt

keras.backend.sqrt(x)

元素明智的平方根.

Arguments

  • x :张量或变量.

Returns

张量. numpy的实现

def sqrt(x):
    y = np.sqrt(x)
    y[np.isnan(y)] = 0.
    return y

exp

keras.backend.exp(x)

按元素指数.

Arguments

  • x :张量或变量.

Returns

张量.


log

keras.backend.log(x)

按元素的日志.

Arguments

  • x :张量或变量.

Returns

张量.


logsumexp

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

计算log(sum(exp(横跨张量维的元素))).

该函数在数值上比log(sum(exp(x(x))))更稳定. 它避免了因取大输入而引起的上溢和因取小输入的对数而引起的下溢.

Arguments

  • x :张量或变量.
  • axis :axis:[-rank(x),rank(x))中的整数或整数列表,用于计算logumexp的轴. 如果为None (默认),则计算所有维度上的logsumexp.
  • keepdims :一个布尔值,是否保留尺寸. 如果keepdimsFalse ,则张量的秩减小1.如果keepdimsTrue ,则减小的维数保留为长度1.

Returns

缩减张量. numpy的实现

def logsumexp(x, axis=None, keepdims=False):
    if isinstance(axis, list):
        axis = tuple(axis)
    return sp.special.logsumexp(x, axis=axis, keepdims=keepdims)

round

keras.backend.round(x)

按元素舍入到最接近的整数.

如果出现平局,则使用的舍入模式为"一半至偶数".

Arguments

  • x :张量或变量.

Returns

张量.


sign

keras.backend.sign(x)

元素明智的标志.

Arguments

  • x :张量或变量.

Returns

张量.


pow

keras.backend.pow(x, a)

逐元素取幂.

Arguments

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

Returns

张量. numpy的实现

def pow(x, a=1.):
    return np.power(x, a)

clip

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

逐元素值裁剪.

Arguments

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

Returns

张量. numpy的实现

def clip(x, min_value, max_value):
    return np.clip(x, min_value, max_value)

equal

keras.backend.equal(x, y)

两个张量之间的按元素相等.

Arguments

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

Returns

布尔张量.

numpy的实现

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

not_equal

keras.backend.not_equal(x, y)

两个张量之间的逐元素不等式.

Arguments

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

Returns

布尔张量.

numpy的实现

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

greater

keras.backend.greater(x, y)

(x> y)的元素明智值.

Arguments

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

Returns

布尔张量.

Numpy implementation

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

greater_equal

keras.backend.greater_equal(x, y)

(x> = y)的元素明智值.

Arguments

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

Returns

布尔张量.

numpy的实现

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

less

keras.backend.less(x, y)

(x <y)的元素明智值.

Arguments

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

Returns

布尔张量.

numpy的实现

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

less_equal

keras.backend.less_equal(x, y)

(x <= y)的元素明智值.

Arguments

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

Returns

布尔张量.

numpy的实现

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

maximum

keras.backend.maximum(x, y)

两个张量在元素方面的最大值.

Arguments

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

Returns

张量.

numpy的实现

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

minimum

keras.backend.minimum(x, y)

元素方面的最小值为两个张量.

Arguments

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

Returns

张量.

numpy的实现

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

sin

keras.backend.sin(x)

计算x元素的正弦值.

Arguments

  • x :张量或变量.

Returns

张量.


cos

keras.backend.cos(x)

按元素计算x的cos.

Arguments

  • x :张量或变量.

Returns

张量.


normalize_batch_in_training

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

计算批处理的均值和标准差,然后对批处理应用batch_normalization.

Arguments

  • x :输入张量或变量.
  • gamma :用于缩放输入的张量.
  • beta :将输入居中的张量.
  • reduction_axes :整数的可迭代值,要对其进行标准化的轴.
  • epsilon :模糊因素.

Returns

元组长度为3 (normalized_tensor, mean, variance) .


batch_normalization

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

在给定的均值,var,beta和gamma值上对x应用批量归一化.

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

Arguments

  • x :输入张量或变量.
  • 平均值 :批次平均值.
  • var :批次的方差.
  • beta :将输入居中的张量.
  • gamma :用于缩放输入的张量.
  • axis :整数,应标准化的轴. (通常是特征轴).
  • epsilon :模糊因素.

Returns

张量.

numpy的实现

def batch_normalization(x, mean, var, beta, gamma, axis=-1, epsilon=0.001):
    return ((x - mean) / sqrt(var + epsilon)) * gamma + beta

concatenate

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

在指定轴旁边串联一个张量列表.

Arguments

  • 张量 :要连接的张列表.
  • axis :串联轴.

Returns

张量.


reshape

keras.backend.reshape(x, shape)

将张量重塑为指定的形状.

Arguments

  • x :张量或变量.
  • shape :目标形状元组.

Returns

张量.


permute_dimensions

keras.backend.permute_dimensions(x, pattern)

在张量中置换轴.

Arguments

  • x :张量或变量.
  • 模式 :尺寸索引的元组,例如(0, 2, 1) .

Returns

张量.


resize_images

keras.backend.resize_images(x, height_factor, width_factor, data_format, interpolation='nearest')

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

Arguments

  • x :要调整大小的张量或变量.
  • height_factor :正整数.
  • width_factor :正整数.
  • data_format :字符串, "channels_last""channels_first" .
  • 插值 :字符串, nearestbilinear .

Returns

张量.

Raises

  • ValueError :如果data_format

neither "channels_last" or "channels_first".


resize_volumes

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

调整5D张量中包含的体积的大小.

Arguments

  • x :要调整大小的张量或变量.
  • depth_factor :正整数.
  • height_factor :正整数.
  • width_factor :正整数.
  • data_format :字符串, "channels_last""channels_first" .

Returns

张量.

Raises

  • ValueError :如果data_format

neither "channels_last" or "channels_first".


repeat_elements

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

沿轴重复张量的元素,例如np.repeat .

如果x具有形状(s1, s2, s3)并且axis1 ,则输出将具有形状(s1, s2 * rep, s3) .

Arguments

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

Returns

张量.


repeat

keras.backend.repeat(x, n)

Repeats a 2D tensor.

如果x具有形状(samples,dim)且n2 ,则输出将具有形状(samples, 2, dim) .

Arguments

  • x :张量或变量.
  • n :Python整数,重复次数.

Returns

张量.


arange

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

创建一个包含整数序列的一维张量.

函数参数使用与Theano的arange相同的约定:如果仅提供一个参数,则实际上是" stop"参数," start"为0.

返回的张量的默认类型为'int32'以匹配TensorFlow的默认值.

Arguments

  • start :起始值.
  • stop :停止值.
  • 步骤 :两个连续值之间的差.
  • dtype :要使用的整数dtype.

Returns

整数张量.


tile

keras.backend.tile(x, n)

通过将x乘以n创建张量.

Arguments

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

Returns

平铺的张量.

Example

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

numpy的实现

def tile(x, n):
    return np.tile(x, n)

flatten

keras.backend.flatten(x)

展平张量.

Arguments

  • x :张量或变量.

Returns

将张量整形为一维


batch_flatten

keras.backend.batch_flatten(x)

将nD张量转换为第0维的2D张量.

换句话说,它展平了批次中的每个数据样本.

Arguments

  • x :张量或变量.

Returns

张量.


expand_dims

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

在索引"轴"处添加1尺寸的尺寸.

Arguments

  • x :张量或变量.
  • axis :添加新轴的位置.

Returns

具有扩展尺寸的张量.


squeeze

keras.backend.squeeze(x, axis)

从张量的索引"轴"移除一维.

Arguments

  • x :张量或变量.
  • axis :要下降的轴.

Returns

具有与x相同的数据但尺寸减小的张量.


temporal_padding

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

填充3D张量的中间尺寸.

Arguments

  • x :张量或变量.
  • padding :2个整数的元组,在dim 1的开始和结束处要添加多少个零.

Returns

带填充的3D张量.


spatial_2d_padding

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

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

Arguments

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

Returns

填充的4D张量.

Raises

  • ValueError :如果data_format

neither "channels_last" or "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"数据格式,将填充第二,第三和第四维. 对于" channels_first"数据格式,将填充第3,第4和第5维.

Arguments

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

Returns

带填充的5D张量.

Raises

  • ValueError :如果data_format

neither "channels_last" or "channels_first".


stack

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

将等级R张量的列表堆叠到等级R+1张量中.

Arguments

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

Returns

张量.

numpy的实现

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

one_hot

keras.backend.one_hot(indices, num_classes)

计算整数张量的一热表示.

Arguments

  • index :形状的nD整数张量(batch_size, dim1, dim2, ... dim(n-1))
  • num_classes :整数,要考虑的类数.

Returns

(n + 1)D个形状为输入的热表示形式(batch_size, dim1, dim2, ... dim(n-1), num_classes)


reverse

keras.backend.reverse(x, axes)

沿指定轴反转张量.

Arguments

  • × :张量反转.
  • axes :整数或整数. 轴反转.

Returns

张量.

numpy的实现

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

slice

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

从张量提取切片.

Arguments

  • x :输入张量.
  • start :整数列表/元组或张量,指示沿每个轴的切片的起始索引.
  • size :整数列表/元组或张量,指示沿每个轴切片多少个维度.

Returns

切片张量:

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

Raises

  • ValueError :如果索引的尺寸和大小不匹配.

numpy的实现

def slice(x, start, size):
    slices = [py_slice(i, i + j) for i, j in zip(start, size)]
    return x[tuple(slices)]

get_value

keras.backend.get_value(x)

返回变量的值.

Arguments

  • x :输入变量.

Returns

一个Numpy数组.


batch_get_value

keras.backend.batch_get_value(ops)

返回多个张量变量的值.

Arguments

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

Returns

Numpy数组的列表.


set_value

keras.backend.set_value(x, value)

从Numpy数组中设置变量的值.

Arguments

  • x :设置为新值的变量.
  • value :将张量设置为Numpy数组(具有相同形状)的值.

batch_set_value

keras.backend.batch_set_value(tuples)

一次设置许多张量变量的值.

Arguments

  • 元组元组列表(tensor, value) . value应为Numpy数组.

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

在评估时打印message和张量值.

请注意, print_tensor返回的新张量与x相同,应在以下代码中使用. 否则在评估过程中将不考虑打印操作.

Example

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

Arguments

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

Returns

相同的张量x不变.


function

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

gradients

keras.backend.gradients(loss, variables)

返回loss wrt variables的梯度.

Arguments

  • 损失 :将标量张量最小化.
  • variables变量列表.

Returns

渐变张量.


stop_gradient

keras.backend.stop_gradient(variables)

返回variables但每个其他变量的梯度为零.

Arguments

  • 变量 :张量或张量列表,以考虑相对于任何其他变量的常数.

Returns

单个张量或张量列表(取决于传递的参数),相对于任何其他变量具有恒定的梯度.


rnn

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

在张量的时间维度上迭代.

Arguments

  • step_function :参数:输入:具有形状(样品,...)(无时间维度)的张量,表示在特定时间步长下一批样品的输入. 状态:张量列表. 返回:输出:具有形状(样本,...)(无时间维度)的张量,new_states:张量列表,长度和形状与"状态"相同.
  • 输入 :形状(样本,时间,...)(至少3D)的时间数据的张量.
  • initial_states :具有形状(样本,...)(无时间维度)的张量,包含用于步进函数的状态的初始值.
  • go_backwards :布尔值. 如果为True,则以相反的顺序在时间维度上进行迭代,并返回相反的序列.
  • mask :具有形状(样本,时间)的二进制张量,每个被掩码的元素都为零.
  • 常量 :在每个步骤传递的常量值列表.
  • unroll :是展开RNN还是使用符号循环( while_loopscan取决于后端).
  • input_length :输入中静态的时间步数.

Returns

元组, (last_output, outputs, new_states) .

last_output:形状(samples, ...)的rnn的最新输出输出:形状(samples, time, ...)张量,其中每个条目的outputs[s, t]是时间处阶跃函数的输出t代表样本s . new_states:张量列表,阶跃函数返回的最新状态,形状为(samples, ...) .

Raises

  • ValueError :如果输入尺寸小于3.
  • ValueError: If unroll is True but input timestep is not a fixed number.
  • ValueError :如果提供了mask (不提供None ),但没有提供len(states)len(states) == 0).

numpy的实现

显示Numpy实施 wzxhzdk:206

switch

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

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

注意then_expressionelse_expression都应是相同形状的符号张量.

Arguments

  • 条件 :张量( intbool ).
  • then_expression :张量或返回张量的可调用对象.
  • else_expression :张量或返回张量的可调用对象.

Returns

选定的张量.

Raises

  • ValueError :如果condition等级大于表达式等级.

numpy的实现

def switch(condition, then_expression, else_expression):
    cond_float = condition.astype(floatx())
    while cond_float.ndim < then_expression.ndim:
        cond_float = cond_float[..., np.newaxis]
    return cond_float * then_expression + (1 - cond_float) * else_expression

in_train_phase

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

在训练阶段选择x ,否则选择alt .

请注意, alt形状应与x 相同 .

Arguments

  • x :在训练阶段返回的内容(张量或可返回张量的可调用对象).
  • alt :否则返回的内容(张量或可调用的返回张量).
  • training :指定学习阶段的可选标量张量(或Python布尔值或Python整数).

Returns

基于training标志的xalt . training标志默认为K.learning_phase() .


in_test_phase

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

在测试阶段选择x ,否则选择alt .

请注意, alt形状应与x 相同 .

Arguments

  • x :在测试阶段要返回的内容(张量或返回张量的可调用对象).
  • alt :否则返回的内容(张量或可调用的返回张量).
  • training :指定学习阶段的可选标量张量(或Python布尔值或Python整数).

Returns

基于K.learning_phase xalt .


relu

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

整流线性单元.

使用默认值时,它将返回逐元素的max(x, 0) .

否则,得出: f(x) = max_value x >= max_valuef(x) = xthreshold <= x < max_valuef(x) = alpha * (x - threshold)否则.

Arguments

  • x :张量或变量.
  • alpha :负部分的标量斜率(默认= 0. .).
  • max_value :浮点型. 饱和度阈值.
  • 门槛 :浮动. 阈值激活的阈值.

Returns

张量.

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)

指数线性单位.

Arguments

  • x :一个张量或变量,用于为其计算激活函数.
  • alpha :负截面的标量斜率.

Returns

张量.

numpy的实现

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

softmax

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

张量的Softmax.

Arguments

  • x :张量或变量.
  • axis :将在其上执行softmax尺寸. 默认值为-1,表示最后一个尺寸.

Returns

张量.

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.

Arguments

  • x :张量或变量.

Returns

张量.

numpy的实现

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

softsign

keras.backend.softsign(x)

张量的软符号.

Arguments

  • x :张量或变量.

Returns

张量.

numpy的实现

def softsign(x):
    return x / (1 + np.abs(x))

categorical_crossentropy

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

输出张量和目标张量之间的分类交叉熵.

Arguments

  • 目标 :与output形状相同的张量.
  • 输出 :由softmax产生的张量(除非from_logits为True,在这种情况下,预期output为logits).
  • from_logits :布尔值,是output是softmax的结果还是logits的张量.
  • axis :指定通道轴的整数. axis=-1对应于数据格式channels_last ,而axis=1对应于数据格式channels_first .

Returns

输出张量.

Raises

  • ValueError :如果axis既不是-1也不是output轴之一.

sparse_categorical_crossentropy

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

具有整数目标的分类交叉熵.

Arguments

  • target :一个整数张量.
  • 输出 :由softmax产生的张量(除非from_logits为True,在这种情况下,预期output为logits).
  • from_logits :布尔值,是output是softmax的结果还是logits的张量.
  • axis :指定通道轴的整数. axis=-1对应于数据格式channels_last ,而axis=1对应于数据格式channels_first .

Returns

输出张量.

Raises

  • ValueError :如果axis既不是-1也不是output轴之一.

binary_crossentropy

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

输出张量和目标张量之间的二元互熵.

Arguments

  • 目标 :与output形状相同的张量.
  • 输出 :张量.
  • from_logits :是否期望output为logits张量. 默认情况下,我们认为output编码概率分布.

Returns

张量.


sigmoid

keras.backend.sigmoid(x)

按元素的乙状结肠.

Arguments

  • x :张量或变量.

Returns

张量.

numpy的实现

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

hard_sigmoid

keras.backend.hard_sigmoid(x)

乙状结肠的分段线性近似.

比乙状结肠更快. 返回0.如果x < -2.51.如果x > 2.5 . 在-2.5 <= x <= 2.5 ,返回0.2 * x + 0.5 .

Arguments

  • x :张量或变量.

Returns

张量.

numpy的实现

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

tanh

keras.backend.tanh(x)

明智的tanh.

Arguments

  • x :张量或变量.

Returns

张量.

numpy的实现

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

dropout

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

在缩放整个张量的同时,将x条目随机设置为零.

Arguments

  • x :张量
  • level :张量中将被设置为0的条目的分数.
  • noise_shape :随机生成的保留/删除标志的形状,必须可广播为x的形状
  • 种子 :确保确定性的随机种子.

Returns

张量. numpy的实现

显示Numpy实施 wzxhzdk:231

l2_normalize

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

使用指定轴旁边的L2范数归一化张量.

Arguments

  • x :张量或变量.
  • axis :执行标准化的轴.

Returns

张量.

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是否在前k predictions .

Arguments

  • 预测 :形状(batch_size, classes)和类型float32张量.
  • 目标 :一维张量,长度为batch_size ,类型为int32int64 .
  • k :一个int ,要考虑的顶级元素数.

Returns

一维张量,长度为batch_size ,类型为bool . 如果predictions[i, targets[i]]predictions[i] k值之内,则output[i]True .


conv1d

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

一维卷积.

Arguments

  • x :张量或变量.
  • kernel :内核张量.
  • 步幅 :步幅整数.
  • 填充 :字符串, "same""causal""valid" .
  • data_format: string, "channels_last" or "channels_first".
  • dilation_rate :整数膨胀率.

Returns

张量,一维卷积的结果.

Raises

  • 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卷积.

Arguments

  • x :张量或变量.
  • kernel :内核张量.
  • 大步走 :大步走元组.
  • padding :字符串, "same""valid" .
  • data_format :字符串, "channels_last""channels_first" . 是否将Theano或TensorFlow / CNTK数据格式用于输入/内核/输出.
  • dilation_rate :2个整数的元组.

Returns

张量,是2D卷积的结果.

Raises

  • 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, dilation_rate=(1, 1))

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

Arguments

  • x :张量或变量.
  • kernel :内核张量.
  • output_shape :输出形状的1D int张量.
  • 大步走 :大步走元组.
  • padding :字符串, "same""valid" .
  • data_format :字符串, "channels_last""channels_first" . 是否将Theano或TensorFlow / CNTK数据格式用于输入/内核/输出.
  • dilation_rate :2个整数的元组.

Returns

张量,转置2D卷积的结果.

Raises

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

具有可分离滤镜的一维卷积.

Arguments

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

Returns

输出张量.

Raises

  • 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卷积.

Arguments

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

Returns

输出张量.

Raises

  • 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卷积.

Arguments

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

Returns

输出张量.

Raises

  • 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卷积.

Arguments

  • x :张量或变量.
  • kernel :内核张量.
  • 大步走 :大步走元组.
  • padding :字符串, "same""valid" .
  • data_format :字符串, "channels_last""channels_first" . 是否将Theano或TensorFlow / CNTK数据格式用于输入/内核/输出.
  • dilation_rate :3个整数的元组.

Returns

张量,是3D卷积的结果.

Raises

  • 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反卷积(即转置卷积).

Arguments

  • x :输入张量.
  • kernel :内核张量.
  • output_shape :输出形状的1D int张量.
  • 大步走 :大步走元组.
  • padding :字符串,"相同"或"有效".
  • data_format :字符串, "channels_last""channels_first" . 是否将Theano或TensorFlow / CNTK数据格式用于输入/内核/输出.

Returns

张量,转置3D卷积的结果.

Raises

  • 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池化.

Arguments

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

Returns

张量,二维池化的结果.

Raises

  • ValueError :如果data_format

neither "channels_last" or "channels_first".

  • ValueError :如果pool_mode既不是"max"也不是"avg" .

pool3d

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

3D池化.

Arguments

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

Returns

张量,是3D合并的结果.

Raises

  • ValueError: if data_format is

neither "channels_last" or "channels_first".

  • ValueError :如果pool_mode既不是"max"也不是"avg" .

local_conv1d

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

应用未共享权重的一维转换.

Arguments

  • 输入 :形状为(batch_size,steps,input_dim)的3D张量
  • 内核 :卷积的非共享权重,具有形状(output_length,feature_dim,滤镜)
  • kernel_size :一个整数的元组,指定一维卷积窗口的长度
  • 步幅 :一个整数的元组,指定卷积的步幅长度
  • data_format :数据格式,channels_first或channels_last

Returns

1d转换后具有非共享权重的张量,形状为(batch_size,output_length,filters)

Raises

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

local_conv2d

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

应用具有未共享权重的2D转换.

Arguments

  • 输入 :如果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,滤镜)
  • kernel_size :2个整数的元组,指定2D卷积窗口的宽度和高度.
  • 步幅 :2个整数的元组,指定卷积沿宽度和高度的步幅.
  • output_shape :具有(output_row,output_col)的元组
  • data_format :数据格式,channels_first或channels_last

Returns

如果data_format ='channels_first',则形状为(batch_size,filters,new_rows,new_cols)的4d张量;如果data_format ='channels_last',则形状为:(batch_size,new_rows,new_cols,filters)的4D张量.

Raises

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

bias_add

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

向张量添加偏差向量.

Arguments

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

Returns

输出张量.

Raises

ValueError:在以下两种情况之一中:1.无效的data_format参数. 2.无效的偏置形状. 偏差应为具有ndim(x)-1维Numpy实现的向量或张量

显示Numpy实施 wzxhzdk:248

random_normal

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

返回具有正态值分布的张量.

Arguments

  • shape :一个整数元组,创建张量的形状.
  • 均值 :浮点数,正态分布的平均值,以抽取样本.
  • stddev :绘制样本的正态分布的浮点标准偏差.
  • dtype :字符串,返回的张量的dtype.
  • 种子 :整数,随机种子.

Returns

张量.


random_uniform

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

返回具有均匀值分布的张量.

Arguments

  • shape :一个整数元组,创建张量的形状.
  • minval :用于绘制样本的均匀分布的下浮动边界.
  • maxval :绘制样本的均匀分布的浮动上限.
  • dtype :字符串,返回的张量的dtype.
  • 种子 :整数,随机种子.

Returns

张量.


random_binomial

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

返回具有随机二项式值分布的张量.

Arguments

  • shape: A tuple of integers, the shape of tensor to create.
  • p :浮点数, 0. <= p <= 1 ,二项式分布的概率.
  • dtype :字符串,返回的张量的dtype.
  • 种子 :整数,随机种子.

Returns

张量.


truncated_normal

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

返回具有截断的随机正态值分布的张量.

生成的值遵循具有指定均值和标准偏差的正态分布,不同之处在于,会删除并重新选择幅度大于均值两个标准差的值.

Arguments

  • shape :一个整数元组,创建张量的形状.
  • 平均值 :值的平均值.
  • stddev :值的标准偏差.
  • dtype :字符串,返回的张量的dtype.
  • 种子 :整数,随机种子.

Returns

张量.


ctc_label_dense_to_sparse

keras.backend.ctc_label_dense_to_sparse(labels, label_lengths)

将CTC标签从密集转换为稀疏.

Arguments

  • 标签 :密集的CTC标签.
  • label_lengths :标签的长度.

Returns

标签的稀疏张量表示.


ctc_batch_cost

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

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

Arguments

  • y_true :包含真值标签的张量(samples, max_string_length) .
  • y_pred :包含预测或softmax输出的张量(samples, time_steps, num_categories) .
  • input_length :张量(samples, 1)包含y_pred每个批处理项目的序列长度.
  • label_length :张量(samples, 1)包含y_true每个批处理项目的序列长度.

Returns

包含每个元素的CTC损失的形状(样本1)的张量.


ctc_decode

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

解码softmax的输出.

可以使用贪婪搜索(也称为最佳路径)或受约束的字典搜索.

Arguments

  • y_pred :包含预测或softmax输出的张量(samples, time_steps, num_categories) .
  • input_length :张量(samples, )包含y_pred每个批处理项目的序列长度.
  • 贪婪 :如果为True则执行更快的最佳路径搜索. 这不使用字典.
  • beam_width :如果greedyFalse :波束搜索解码器将与该宽度的波束一起使用.
  • top_paths :如果greedyFalse ,则将返回多少个最可能的路径.
  • merge_repeated :如果greedyFalse ,则在输出光束中合并重复的类.

Returns

  • 元组 :列表:如果greedyTrue ,则返回包含已解码序列的一个元素的列表. 如果为False ,则返回top_paths最可能的解码序列. 重要提示:空白标签返回-1 . 张量(top_paths, ) ,其中包含每个解码序列的对数概率.

control_dependencies

keras.backend.control_dependencies(control_inputs)

指定控件依赖项的上下文管理器.

Arguments

  • control_inputs :操作或张量对象的列表,在运行上下文中定义的操作之前必须执行或计算这些对象. 也可以设置为None以清除控件依赖项.

Returns

上下文管理器.


map_fn

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

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

Arguments

  • fn :可调用的,将在elems中的每个元素上调用
  • elems :张量
  • name :图形中地图节点的字符串名称
  • dtype :输出数据类型.

Returns

具有dtype dtype张量.


foldl

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

使用fn缩小元素,从左到右组合它们.

Arguments

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

Returns

具有与initializer相同的类型和形状的张量.


foldr

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

使用fn缩小元素,从右到左组合它们.

Arguments

  • fn :可调用的元素,将在elems中的每个元素和一个累加器上调用,例如lambda acc, x: acc + x
  • elems :张量
  • 初始值设定项:使用的第一个值(如果为None, elems[-1]
  • name :图形中文件夹节点的字符串名称

Returns

Tensor with same type and shape as initializer.