Keras backends
What is a "backend"?
Keras is a model-level library, providing high-level building blocks for developing deep learning models. It does not handle low-level operations such as tensor products, convolutions and so on itself. Instead, it relies on a specialized, well optimized tensor manipulation library to do so, serving as the "backend engine" of Keras. Rather than picking one single tensor library and making the implementation of Keras tied to that library, Keras handles the problem in a modular way, and several different backend engines can be plugged seamlessly into Keras.
At this time, Keras has three backend implementations available: the TensorFlow backend, the Theano backend, and the CNTK backend.
- TensorFlow is an open-source symbolic tensor manipulation framework developed by Google.
- Theano is an open-source symbolic tensor manipulation framework developed by LISA Lab at Université de Montréal.
- CNTK is an open-source toolkit for deep learning developed by Microsoft.
In the future, we are likely to add more backend options.
Switching from one backend to another
If you have run Keras at least once, you will find the Keras configuration file at:
$HOME/.keras/keras.json
If it isn't there, you can create it.
NOTE for Windows Users: Please replace $HOME
with %USERPROFILE%
.
The default configuration file looks like this:
{
"image_data_format": "channels_last",
"epsilon": 1e-07,
"floatx": "float32",
"backend": "tensorflow"
}
Simply change the field backend
to "theano"
, "tensorflow"
, or "cntk"
, and Keras will use the new configuration next time you run any Keras code.
You can also define the environment variable KERAS_BACKEND
and this will
override what is defined in your config file :
KERAS_BACKEND=tensorflow python -c "from keras import backend"
Using TensorFlow backend.
In Keras it is possible to load more backends than "tensorflow"
, "theano"
, and "cntk"
. Keras can use external backends as well, and this can be performed by changing the keras.json
configuration file, and the "backend"
setting. Suppose you have a Python module called my_module
that you wanted to use as your external backend. The keras.json
configuration file would be changed as follows:
{
"image_data_format": "channels_last",
"epsilon": 1e-07,
"floatx": "float32",
"backend": "my_package.my_module"
}
An external backend must be validated in order to be used, a valid backend must have the following functions: placeholder
, variable
and function
.
If an external backend is not valid due to missing a required entry, an error will be logged notifying which entry/entries are missing.
keras.json details
The keras.json
configuration file contains the following settings:
{
"image_data_format": "channels_last",
"epsilon": 1e-07,
"floatx": "float32",
"backend": "tensorflow"
}
You can change these settings by editing $HOME/.keras/keras.json
.
image_data_format
: String, either"channels_last"
or"channels_first"
. It specifies which data format convention Keras will follow. (keras.backend.image_data_format()
returns it.)- For 2D data (e.g. image),
"channels_last"
assumes(rows, cols, channels)
while"channels_first"
assumes(channels, rows, cols)
. - For 3D data,
"channels_last"
assumes(conv_dim1, conv_dim2, conv_dim3, channels)
while"channels_first"
assumes(channels, conv_dim1, conv_dim2, conv_dim3)
. epsilon
: Float, a numeric fuzzing constant used to avoid dividing by zero in some operations.floatx
: String,"float16"
,"float32"
, or"float64"
. Default float precision.backend
: String,"tensorflow"
,"theano"
, or"cntk"
.
Using the abstract Keras backend to write new code
If you want the Keras modules you write to be compatible with both Theano (th
) and TensorFlow (tf
), you have to write them via the abstract Keras backend API. Here's an intro.
You can import the backend module via:
from keras import backend as K
The code below instantiates an input placeholder. It's equivalent to tf.placeholder()
or th.tensor.matrix()
, th.tensor.tensor3()
, etc.
inputs = K.placeholder(shape=(2, 4, 5))
# also works:
inputs = K.placeholder(shape=(None, 4, 5))
# also works:
inputs = K.placeholder(ndim=3)
The code below instantiates a variable. It's equivalent to tf.Variable()
or 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))
Most tensor operations you will need can be done as you would in TensorFlow or 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()
Returns the name of the current backend (e.g. "tensorflow").
Returns
String, the name of the backend Keras is currently using.
Example
>>> keras.backend.backend()
'tensorflow'
symbolic
keras.backend.symbolic(func)
Decorator used in TensorFlow 2.0 to enter the Keras graph.
Arguments
- func: Function to decorate.
Returns
Decorated function.
eager
keras.backend.eager(func)
Decorator used in TensorFlow 2.0 to exit the Keras graph.
Arguments
- func: Function to decorate.
Returns
Decorated function.
get_uid
keras.backend.get_uid(prefix='')
Provides a unique UID given a string prefix.
Arguments
- prefix: string.
Returns
An integer.
Example
>>> keras.backend.get_uid('dense')
1
>>> keras.backend.get_uid('dense')
2
manual_variable_initialization
keras.backend.manual_variable_initialization(value)
Sets the manual variable initialization flag.
This boolean flag determines whether variables should be initialized as they are instantiated (default), or if the user should handle the initialization.
Arguments
- value: Python boolean.
epsilon
keras.backend.epsilon()
Returns the value of the fuzz factor used in numeric expressions.
Returns
A float.
Example
>>> keras.backend.epsilon()
1e-07
reset_uids
keras.backend.reset_uids()
Resets graph identifiers.
set_epsilon
keras.backend.set_epsilon(e)
Sets the value of the fuzz factor used in numeric expressions.
Arguments
- e: float. New value of 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()
Returns the default float type, as a string. (e.g. 'float16', 'float32', 'float64').
Returns
String, the current default float type.
Example
>>> keras.backend.floatx()
'float32'
set_floatx
keras.backend.set_floatx(floatx)
Sets the default float type.
Arguments
- floatx: String, 'float16', 'float32', or '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)
Cast a Numpy array to the default Keras float type.
Arguments
- x: Numpy array.
Returns
The same Numpy array, cast to its new type.
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 the default image data format convention.
Returns
A string, either 'channels_first'
or 'channels_last'
Example
>>> keras.backend.image_data_format()
'channels_first'
set_image_data_format
keras.backend.set_image_data_format(data_format)
Sets the value of the data format convention.
Arguments
- data_format: string.
'channels_first'
or'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()
Returns the learning phase flag.
The learning phase flag is a bool tensor (0 = test, 1 = train) to be passed as input to any Keras function that uses a different behavior at train time and test time.
Returns
Learning phase (scalar integer tensor or Python integer).
set_learning_phase
keras.backend.set_learning_phase(value)
Sets the learning phase to a fixed value.
Arguments
- value: Learning phase value, either 0 or 1 (integers).
Raises
- ValueError: if
value
is neither0
nor1
.
clear_session
keras.backend.clear_session()
Destroys the current Keras graph and creates a new one.
Useful to avoid clutter from old models / layers.
is_sparse
keras.backend.is_sparse(tensor)
Returns whether a tensor is a sparse tensor.
Arguments
- tensor: A tensor instance.
Returns
A boolean.
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)
Converts a sparse tensor into a dense tensor and returns it.
Arguments
- tensor: A tensor instance (potentially sparse).
Returns
A dense tensor.
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)
Instantiates a variable and returns it.
Arguments
- value: Numpy array, initial value of the tensor.
- dtype: Tensor type.
- name: Optional name string for the tensor.
- constraint: Optional projection function to be applied to the variable after an optimizer update.
Returns
A variable instance (with Keras metadata included).
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)
Creates a constant tensor.
Arguments
- value: A constant value (or list)
- dtype: The type of the elements of the resulting tensor.
- shape: Optional dimensions of resulting tensor.
- name: Optional name for the tensor.
Returns
A Constant Tensor.
is_keras_tensor
keras.backend.is_keras_tensor(x)
Returns whether x
is a Keras tensor.
A "Keras tensor" is a tensor that was returned by a Keras layer,
(Layer
class) or by Input
.
Arguments
- x: A candidate tensor.
Returns
A boolean: Whether the argument is a Keras tensor.
Raises
- ValueError: In case
x
is not a symbolic tensor.
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)
Instantiates a placeholder tensor and returns it.
Arguments
- shape: Shape of the placeholder
(integer tuple, may include
None
entries). - ndim: Number of axes of the tensor.
At least one of {
shape
,ndim
} must be specified. If both are specified,shape
is used. - dtype: Placeholder type.
- sparse: Boolean, whether the placeholder should have a sparse type.
- name: Optional name string for the placeholder.
Returns
Tensor instance (with Keras metadata included).
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)
Returns whether x
is a placeholder.
Arguments
- x: A candidate placeholder.
Returns
Boolean.
shape
keras.backend.shape(x)
Returns the symbolic shape of a tensor or variable.
Arguments
- x: A tensor or variable.
Returns
A symbolic shape (which is itself a tensor).
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)
Returns the shape of tensor or variable as a tuple of int or None entries.
Arguments
- x: Tensor or variable.
Returns
A tuple of integers (or None entries).
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 implementation
def int_shape(x):
return x.shape
ndim
keras.backend.ndim(x)
Returns the number of axes in a tensor, as an integer.
Arguments
- x: Tensor or variable.
Returns
Integer (scalar), number of axes.
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 implementation
def ndim(x):
return x.ndim
size
keras.backend.size(x, name=None)
Returns the size of a tensor.
Arguments
- x: Tensor or variable.
- name: A name for the operation (optional).
Returns
Size of the tensor.
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)
Returns the dtype of a Keras tensor or variable, as a string.
Arguments
- x: Tensor or variable.
Returns
String, dtype of x
.
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 implementation
def dtype(x):
return x.dtype.name
eval
keras.backend.eval(x)
Evaluates the value of a tensor.
Arguments
- x: A tensor.
Returns
A Numpy array.
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 implementation
def eval(x):
return x
zeros
keras.backend.zeros(shape, dtype=None, name=None)
Instantiates an all-zeros variable and returns it.
Arguments
- shape: Tuple of integers, shape of returned Keras variable
- dtype: String, data type of returned Keras variable
- name: String, name of returned Keras variable
Returns
A variable (including Keras metadata), filled with 0.0
.
Note that if shape
was symbolic, we cannot return a variable,
and will return a dynamically-shaped tensor instead.
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 implementation
def zeros(shape, dtype=floatx(), name=None):
return np.zeros(shape, dtype=dtype)
ones
keras.backend.ones(shape, dtype=None, name=None)
Instantiates an all-ones variable and returns it.
Arguments
- shape: Tuple of integers, shape of returned Keras variable.
- dtype: String, data type of returned Keras variable.
- name: String, name of returned Keras variable.
Returns
A Keras variable, filled with 1.0
.
Note that if shape
was symbolic, we cannot return a variable,
and will return a dynamically-shaped tensor instead.
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 implementation
def ones(shape, dtype=floatx(), name=None):
return np.ones(shape, dtype=dtype)
eye
keras.backend.eye(size, dtype=None, name=None)
Instantiate an identity matrix and returns it.
Arguments
- size: Tuple, number of rows and columns. If Integer, number of rows.
- dtype: String, data type of returned Keras variable.
- name: String, name of returned Keras variable.
Returns
A Keras variable, an identity matrix.
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 implementation
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)
Instantiates an all-zeros variable of the same shape as another tensor.
Arguments
- x: Keras variable or Keras tensor.
- dtype: String, dtype of returned Keras variable. None uses the dtype of x.
- name: String, name for the variable to create.
Returns
A Keras variable with the shape of x filled with zeros.
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 implementation
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)
Instantiates an all-ones variable of the same shape as another tensor.
Arguments
- x: Keras variable or tensor.
- dtype: String, dtype of returned Keras variable. None uses the dtype of x.
- name: String, name for the variable to create.
Returns
A Keras variable with the shape of x filled with ones.
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 implementation
def ones_like(x, dtype=floatx(), name=None):
return np.ones_like(x, dtype=dtype)
identity
keras.backend.identity(x, name=None)
Returns a tensor with the same content as the input tensor.
Arguments
- x: The input tensor.
- name: String, name for the variable to create.
Returns
A tensor of the same shape, type and content.
random_uniform_variable
keras.backend.random_uniform_variable(shape, low, high, dtype=None, name=None, seed=None)
Instantiates a variable with values drawn from a uniform distribution.
Arguments
- shape: Tuple of integers, shape of returned Keras variable.
- low: Float, lower boundary of the output interval.
- high: Float, upper boundary of the output interval.
- dtype: String, dtype of returned Keras variable.
- name: String, name of returned Keras variable.
- seed: Integer, random seed.
Returns
A Keras variable, filled with drawn samples.
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 implementation
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)
Instantiates a variable with values drawn from a normal distribution.
Arguments
- shape: Tuple of integers, shape of returned Keras variable.
- mean: Float, mean of the normal distribution.
- scale: Float, standard deviation of the normal distribution.
- dtype: String, dtype of returned Keras variable.
- name: String, name of returned Keras variable.
- seed: Integer, random seed.
Returns
A Keras variable, filled with drawn samples.
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 implementation
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)
Returns the static number of elements in a Keras variable or tensor.
Arguments
- x: Keras variable or tensor.
Returns
Integer, the number of elements in x
, i.e., the product of the
array's static dimensions.
Example
>>> kvar = K.zeros((2,3))
>>> K.count_params(kvar)
6
>>> K.eval(kvar)
array([[ 0., 0., 0.],
[ 0., 0., 0.]], dtype=float32)
Numpy implementation
def count_params(x):
return x.size
cast
keras.backend.cast(x, dtype)
Casts a tensor to a different dtype and returns it.
You can cast a Keras variable but it still returns a Keras tensor.
Arguments
- x: Keras tensor (or variable).
- dtype: String, either (
'float16'
,'float32'
, or'float64'
).
Returns
Keras tensor with dtype 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)
Update the value of x
to new_x
.
Arguments
- x: A
Variable
. - new_x: A tensor of same shape as
x
.
Returns
The variable x
updated.
update_add
keras.backend.update_add(x, increment)
Update the value of x
by adding increment
.
Arguments
- x: A
Variable
. - increment: A tensor of same shape as
x
.
Returns
The variable x
updated.
update_sub
keras.backend.update_sub(x, decrement)
Update the value of x
by subtracting decrement
.
Arguments
- x: A
Variable
. - decrement: A tensor of same shape as
x
.
Returns
The variable x
updated.
moving_average_update
keras.backend.moving_average_update(x, value, momentum)
Compute the moving average of a variable.
Arguments
- x: A
Variable
. - value: A tensor with the same shape as
x
. - momentum: The moving average momentum.
Returns
An operation to update the variable.
dot
keras.backend.dot(x, y)
Multiplies 2 tensors (and/or variables) and returns a tensor.
When attempting to multiply a nD tensor
with a nD tensor, it reproduces the Theano behavior.
(e.g. (2, 3) * (4, 3, 5) -> (2, 4, 5)
)
Arguments
- x: Tensor or variable.
- y: Tensor or variable.
Returns
A tensor, dot product of x
and y
.
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 implementation
def dot(x, y):
return np.dot(x, y)
batch_dot
keras.backend.batch_dot(x, y, axes=None)
Batchwise dot product.
batch_dot
is used to compute dot product of x
and y
when
x
and y
are data in batches, i.e. in a shape of
(batch_size, :)
.
batch_dot
results in a tensor or variable with less dimensions
than the input. If the number of dimensions is reduced to 1,
we use expand_dims
to make sure that ndim is at least 2.
Arguments
- x: Keras tensor or variable with
ndim >= 2
. - y: Keras tensor or variable with
ndim >= 2
. - axes: int or tuple(int, int). Target dimensions to be reduced.
Returns
A tensor with shape equal to the concatenation of x
's shape
(less the dimension that was summed over) and y
's shape
(less the batch dimension and the dimension that was summed over).
If the final rank is 1, we reshape it to (batch_size, 1)
.
Examples
Assume x = [[1, 2], [3, 4]]
and y = [[5, 6], [7, 8]]
batch_dot(x, y, axes=1) = [[17], [53]]
which is the main diagonal
of x.dot(y.T)
, although we never have to calculate the off-diagonal
elements.
Pseudocode:
inner_products = []
for xi, yi in zip(x, y):
inner_products.append(xi.dot(yi))
result = stack(inner_products)
Shape inference:
Let x
's shape be (100, 20)
and y
's shape be (100, 30, 20)
.
If axes
is (1, 2), to find the output shape of resultant tensor,
loop through each dimension in x
's shape and y
's shape:
x.shape[0]
: 100 : append to output shapex.shape[1]
: 20 : do not append to output shape, dimension 1 ofx
has been summed over. (dot_axes[0]
= 1)y.shape[0]
: 100 : do not append to output shape, always ignore first dimension ofy
y.shape[1]
: 30 : append to output shapey.shape[2]
: 20 : do not append to output shape, dimension 2 ofy
has been summed over. (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)
Numpy implementation
Show the Numpy implementation
wzxhzdk:102transpose
keras.backend.transpose(x)
Transposes a tensor and returns it.
Arguments
- x: Tensor or variable.
Returns
A tensor.
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 implementation
def transpose(x):
return np.transpose(x)
gather
keras.backend.gather(reference, indices)
Retrieves the elements of indices indices
in the tensor reference
.
Arguments
- reference: A tensor.
- indices: An integer tensor of indices.
Returns
A tensor of same type as reference
.
Numpy implementation
def gather(reference, indices):
return reference[indices]
max
keras.backend.max(x, axis=None, keepdims=False)
Maximum value in a tensor.
Arguments
- x: A tensor or variable.
- axis: An integer or list of integers in [-rank(x), rank(x)),
the axes to find maximum values. If
None
(default), finds the maximum over all dimensions. - keepdims: A boolean, whether to keep the dimensions or not.
If
keepdims
isFalse
, the rank of the tensor is reduced by 1. Ifkeepdims
isTrue
, the reduced dimension is retained with length 1.
Returns
A tensor with maximum values of x
.
Numpy implementation
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)
Minimum value in a tensor.
Arguments
- x: A tensor or variable.
- axis: An integer or list of integers in [-rank(x), rank(x)),
the axes to find minimum values. If
None
(default), finds the minimum over all dimensions. - keepdims: A boolean, whether to keep the dimensions or not.
If
keepdims
isFalse
, the rank of the tensor is reduced by 1. Ifkeepdims
isTrue
, the reduced dimension is retained with length 1.
Returns
A tensor with miminum values of x
.
Numpy implementation
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)
Sum of the values in a tensor, alongside the specified axis.
Arguments
- x: A tensor or variable.
- axis: An integer or list of integers in [-rank(x), rank(x)),
the axes to sum over. If
None
(default), sums over all dimensions. - keepdims: A boolean, whether to keep the dimensions or not.
If
keepdims
isFalse
, the rank of the tensor is reduced by 1. Ifkeepdims
isTrue
, the reduced dimension is retained with length 1.
Returns
A tensor with sum of x
.
Numpy implementation
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)
Multiplies the values in a tensor, alongside the specified axis.
Arguments
- x: A tensor or variable.
- axis: An integer or list of integers in [-rank(x), rank(x)),
the axes to compute the product. If
None
(default), computes the product over all dimensions. - keepdims: A boolean, whether to keep the dimensions or not.
If
keepdims
isFalse
, the rank of the tensor is reduced by 1. Ifkeepdims
isTrue
, the reduced dimension is retained with length 1.
Returns
A tensor with the product of elements of x
.
Numpy implementation
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)
Cumulative sum of the values in a tensor, alongside the specified axis.
Arguments
- x: A tensor or variable.
- axis: An integer, the axis to compute the sum.
Returns
A tensor of the cumulative sum of values of x
along axis
.
Numpy implementation
def cumsum(x, axis=0):
return np.cumsum(x, axis=axis)
cumprod
keras.backend.cumprod(x, axis=0)
Cumulative product of the values in a tensor, alongside the specified axis.
Arguments
- x: A tensor or variable.
- axis: An integer, the axis to compute the product.
Returns
A tensor of the cumulative product of values of x
along axis
.
Numpy implementation
def cumprod(x, axis=0):
return np.cumprod(x, axis=axis)
var
keras.backend.var(x, axis=None, keepdims=False)
Variance of a tensor, alongside the specified axis.
Arguments
- x: A tensor or variable.
- axis: An integer or list of integers in [-rank(x), rank(x)),
the axes to compute the variance. If
None
(default), computes the variance over all dimensions. - keepdims: A boolean, whether to keep the dimensions or not.
If
keepdims
isFalse
, the rank of the tensor is reduced by 1. Ifkeepdims
isTrue
, the reduced dimension is retained with length 1.
Returns
A tensor with the variance of elements of x
.
Numpy implementation
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)
Standard deviation of a tensor, alongside the specified axis.
Arguments
- x: A tensor or variable.
- axis: An integer or list of integers in [-rank(x), rank(x)),
the axes to compute the standard deviation. If
None
(default), computes the standard deviation over all dimensions. - keepdims: A boolean, whether to keep the dimensions or not.
If
keepdims
isFalse
, the rank of the tensor is reduced by 1. Ifkeepdims
isTrue
, the reduced dimension is retained with length 1.
Returns
A tensor with the standard deviation of elements of x
.
Numpy implementation
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)
Mean of a tensor, alongside the specified axis.
Arguments
- x: A tensor or variable.
- axis: An integer or list of integers in [-rank(x), rank(x)),
the axes to compute the mean. If
None
(default), computes the mean over all dimensions. - keepdims: A boolean, whether to keep the dimensions or not.
If
keepdims
isFalse
, the rank of the tensor is reduced by 1 for each entry inaxis
. Ifkeepdims
isTrue
, the reduced dimensions are retained with length 1.
Returns
A tensor with the mean of elements of x
.
Numpy implementation
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)
Bitwise reduction (logical OR).
Arguments
- x: Tensor or variable.
- axis: An integer or list of integers in [-rank(x), rank(x)),
the axes to compute the logical or. If
None
(default), computes the logical or over all dimensions. - keepdims: whether the drop or broadcast the reduction axes.
Returns
A uint8 tensor (0s and 1s). Numpy implementation
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)
Bitwise reduction (logical AND).
Arguments
- x: Tensor or variable.
- axis: An integer or list of integers in [-rank(x), rank(x)),
the axes to compute the logical and. If
None
(default), computes the logical and over all dimensions. - keepdims: whether the drop or broadcast the reduction axes.
Returns
A uint8 tensor (0s and 1s). Numpy implementation
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)
Returns the index of the maximum value along an axis.
Arguments
- x: Tensor or variable.
- axis: axis along which to perform the reduction.
Returns
A tensor. Numpy implementation
def argmax(x, axis=-1):
return np.argmax(x, axis=axis)
argmin
keras.backend.argmin(x, axis=-1)
Returns the index of the minimum value along an axis.
Arguments
- x: Tensor or variable.
- axis: axis along which to perform the reduction.
Returns
A tensor. Numpy implementation
def argmin(x, axis=-1):
return np.argmin(x, axis=axis)
square
keras.backend.square(x)
Element-wise square.
Arguments
- x: Tensor or variable.
Returns
A tensor.
abs
keras.backend.abs(x)
Element-wise absolute value.
Arguments
- x: Tensor or variable.
Returns
A tensor.
sqrt
keras.backend.sqrt(x)
Element-wise square root.
Arguments
- x: Tensor or variable.
Returns
A tensor. Numpy implementation
def sqrt(x):
y = np.sqrt(x)
y[np.isnan(y)] = 0.
return y
exp
keras.backend.exp(x)
Element-wise exponential.
Arguments
- x: Tensor or variable.
Returns
A tensor.
log
keras.backend.log(x)
Element-wise log.
Arguments
- x: Tensor or variable.
Returns
A tensor.
logsumexp
keras.backend.logsumexp(x, axis=None, keepdims=False)
Computes log(sum(exp(elements across dimensions of a tensor))).
This function is more numerically stable than log(sum(exp(x))). It avoids overflows caused by taking the exp of large inputs and underflows caused by taking the log of small inputs.
Arguments
- x: A tensor or variable.
- axis: axis: An integer or list of integers in [-rank(x), rank(x)),
the axes to compute the logsumexp. If
None
(default), computes the logsumexp over all dimensions. - keepdims: A boolean, whether to keep the dimensions or not.
If
keepdims
isFalse
, the rank of the tensor is reduced by 1. Ifkeepdims
isTrue
, the reduced dimension is retained with length 1.
Returns
The reduced tensor. Numpy implementation
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)
Element-wise rounding to the closest integer.
In case of tie, the rounding mode used is "half to even".
Arguments
- x: Tensor or variable.
Returns
A tensor.
sign
keras.backend.sign(x)
Element-wise sign.
Arguments
- x: Tensor or variable.
Returns
A tensor.
pow
keras.backend.pow(x, a)
Element-wise exponentiation.
Arguments
- x: Tensor or variable.
- a: Python integer.
Returns
A tensor. Numpy implementation
def pow(x, a=1.):
return np.power(x, a)
clip
keras.backend.clip(x, min_value, max_value)
Element-wise value clipping.
Arguments
- x: Tensor or variable.
- min_value: Python float, integer or tensor.
- max_value: Python float, integer or tensor.
Returns
A tensor. Numpy implementation
def clip(x, min_value, max_value):
return np.clip(x, min_value, max_value)
equal
keras.backend.equal(x, y)
Element-wise equality between two tensors.
Arguments
- x: Tensor or variable.
- y: Tensor or variable.
Returns
A bool tensor.
Numpy implementation
def equal(x, y):
return x == y
not_equal
keras.backend.not_equal(x, y)
Element-wise inequality between two tensors.
Arguments
- x: Tensor or variable.
- y: Tensor or variable.
Returns
A bool tensor.
Numpy implementation
def not_equal(x, y):
return x != y
greater
keras.backend.greater(x, y)
Element-wise truth value of (x > y).
Arguments
- x: Tensor or variable.
- y: Tensor or variable.
Returns
A bool tensor.
Numpy implementation
def greater(x, y):
return x > y
greater_equal
keras.backend.greater_equal(x, y)
Element-wise truth value of (x >= y).
Arguments
- x: Tensor or variable.
- y: Tensor or variable.
Returns
A bool tensor.
Numpy implementation
def greater_equal(x, y):
return x >= y
less
keras.backend.less(x, y)
Element-wise truth value of (x < y).
Arguments
- x: Tensor or variable.
- y: Tensor or variable.
Returns
A bool tensor.
Numpy implementation
def less(x, y):
return x < y
less_equal
keras.backend.less_equal(x, y)
Element-wise truth value of (x <= y).
Arguments
- x: Tensor or variable.
- y: Tensor or variable.
Returns
A bool tensor.
Numpy implementation
def less_equal(x, y):
return x <= y
maximum
keras.backend.maximum(x, y)
Element-wise maximum of two tensors.
Arguments
- x: Tensor or variable.
- y: Tensor or variable.
Returns
A tensor.
Numpy implementation
def maximum(x, y):
return np.maximum(x, y)
minimum
keras.backend.minimum(x, y)
Element-wise minimum of two tensors.
Arguments
- x: Tensor or variable.
- y: Tensor or variable.
Returns
A tensor.
Numpy implementation
def minimum(x, y):
return np.minimum(x, y)
sin
keras.backend.sin(x)
Computes sin of x element-wise.
Arguments
- x: Tensor or variable.
Returns
A tensor.
cos
keras.backend.cos(x)
Computes cos of x element-wise.
Arguments
- x: Tensor or variable.
Returns
A tensor.
normalize_batch_in_training
keras.backend.normalize_batch_in_training(x, gamma, beta, reduction_axes, epsilon=0.001)
Computes mean and std for batch then apply batch_normalization on batch.
Arguments
- x: Input tensor or variable.
- gamma: Tensor by which to scale the input.
- beta: Tensor with which to center the input.
- reduction_axes: iterable of integers, axes over which to normalize.
- epsilon: Fuzz factor.
Returns
A tuple length of 3, (normalized_tensor, mean, variance)
.
batch_normalization
keras.backend.batch_normalization(x, mean, var, beta, gamma, axis=-1, epsilon=0.001)
Applies batch normalization on x given mean, var, beta and gamma.
I.e. returns:
output = (x - mean) / sqrt(var + epsilon) * gamma + beta
Arguments
- x: Input tensor or variable.
- mean: Mean of batch.
- var: Variance of batch.
- beta: Tensor with which to center the input.
- gamma: Tensor by which to scale the input.
- axis: Integer, the axis that should be normalized. (typically the features axis).
- epsilon: Fuzz factor.
Returns
A tensor.
Numpy implementation
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)
Concatenates a list of tensors alongside the specified axis.
Arguments
- tensors: list of tensors to concatenate.
- axis: concatenation axis.
Returns
A tensor.
reshape
keras.backend.reshape(x, shape)
Reshapes a tensor to the specified shape.
Arguments
- x: Tensor or variable.
- shape: Target shape tuple.
Returns
A tensor.
permute_dimensions
keras.backend.permute_dimensions(x, pattern)
Permutes axes in a tensor.
Arguments
- x: Tensor or variable.
- pattern: A tuple of
dimension indices, e.g.
(0, 2, 1)
.
Returns
A tensor.
resize_images
keras.backend.resize_images(x, height_factor, width_factor, data_format, interpolation='nearest')
Resizes the images contained in a 4D tensor.
Arguments
- x: Tensor or variable to resize.
- height_factor: Positive integer.
- width_factor: Positive integer.
- data_format: string,
"channels_last"
or"channels_first"
. - interpolation: A string, one of
nearest
orbilinear
.
Returns
A tensor.
Raises
- ValueError: if
data_format
is
neither "channels_last"
or "channels_first"
.
resize_volumes
keras.backend.resize_volumes(x, depth_factor, height_factor, width_factor, data_format)
Resizes the volume contained in a 5D tensor.
Arguments
- x: Tensor or variable to resize.
- depth_factor: Positive integer.
- height_factor: Positive integer.
- width_factor: Positive integer.
- data_format: string,
"channels_last"
or"channels_first"
.
Returns
A tensor.
Raises
- ValueError: if
data_format
is
neither "channels_last"
or "channels_first"
.
repeat_elements
keras.backend.repeat_elements(x, rep, axis)
Repeats the elements of a tensor along an axis, like np.repeat
.
If x
has shape (s1, s2, s3)
and axis
is 1
, the output
will have shape (s1, s2 * rep, s3)
.
Arguments
- x: Tensor or variable.
- rep: Python integer, number of times to repeat.
- axis: Axis along which to repeat.
Returns
A tensor.
repeat
keras.backend.repeat(x, n)
Repeats a 2D tensor.
if x
has shape (samples, dim) and n
is 2
,
the output will have shape (samples, 2, dim)
.
Arguments
- x: Tensor or variable.
- n: Python integer, number of times to repeat.
Returns
A tensor.
arange
keras.backend.arange(start, stop=None, step=1, dtype='int32')
Creates a 1D tensor containing a sequence of integers.
The function arguments use the same convention as Theano's arange: if only one argument is provided, it is in fact the "stop" argument and "start" is 0.
The default type of the returned tensor is 'int32'
to
match TensorFlow's default.
Arguments
- start: Start value.
- stop: Stop value.
- step: Difference between two successive values.
- dtype: Integer dtype to use.
Returns
An integer tensor.
tile
keras.backend.tile(x, n)
Creates a tensor by tiling x
by n
.
Arguments
- x: A tensor or variable
- n: A list of integer. The length must be the same as the number of
dimensions in
x
.
Returns
A tiled tensor.
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 implementation
def tile(x, n):
return np.tile(x, n)
flatten
keras.backend.flatten(x)
Flatten a tensor.
Arguments
- x: A tensor or variable.
Returns
A tensor, reshaped into 1-D
batch_flatten
keras.backend.batch_flatten(x)
Turn a nD tensor into a 2D tensor with same 0th dimension.
In other words, it flattens each data samples of a batch.
Arguments
- x: A tensor or variable.
Returns
A tensor.
expand_dims
keras.backend.expand_dims(x, axis=-1)
Adds a 1-sized dimension at index "axis".
Arguments
- x: A tensor or variable.
- axis: Position where to add a new axis.
Returns
A tensor with expanded dimensions.
squeeze
keras.backend.squeeze(x, axis)
Removes a 1-dimension from the tensor at index "axis".
Arguments
- x: A tensor or variable.
- axis: Axis to drop.
Returns
A tensor with the same data as x
but reduced dimensions.
temporal_padding
keras.backend.temporal_padding(x, padding=(1, 1))
Pads the middle dimension of a 3D tensor.
Arguments
- x: Tensor or variable.
- padding: Tuple of 2 integers, how many zeros to add at the start and end of dim 1.
Returns
A padded 3D tensor.
spatial_2d_padding
keras.backend.spatial_2d_padding(x, padding=((1, 1), (1, 1)), data_format=None)
Pads the 2nd and 3rd dimensions of a 4D tensor.
Arguments
- x: Tensor or variable.
- padding: Tuple of 2 tuples, padding pattern.
- data_format: string,
"channels_last"
or"channels_first"
.
Returns
A padded 4D tensor.
Raises
- ValueError: if
data_format
is
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)
Pads 5D tensor with zeros along the depth, height, width dimensions.
Pads these dimensions with respectively "padding[0]", "padding[1]" and "padding[2]" zeros left and right.
For 'channels_last' data_format, the 2nd, 3rd and 4th dimension will be padded. For 'channels_first' data_format, the 3rd, 4th and 5th dimension will be padded.
Arguments
- x: Tensor or variable.
- padding: Tuple of 3 tuples, padding pattern.
- data_format: string,
"channels_last"
or"channels_first"
.
Returns
A padded 5D tensor.
Raises
- ValueError: if
data_format
is
neither "channels_last"
or "channels_first"
.
stack
keras.backend.stack(x, axis=0)
Stacks a list of rank R
tensors into a rank R+1
tensor.
Arguments
- x: List of tensors.
- axis: Axis along which to perform stacking.
Returns
A tensor.
Numpy implementation
def stack(x, axis=0):
return np.stack(x, axis=axis)
one_hot
keras.backend.one_hot(indices, num_classes)
Computes the one-hot representation of an integer tensor.
Arguments
- indices: nD integer tensor of shape
(batch_size, dim1, dim2, ... dim(n-1))
- num_classes: Integer, number of classes to consider.
Returns
(n + 1)D one hot representation of the input
with shape (batch_size, dim1, dim2, ... dim(n-1), num_classes)
reverse
keras.backend.reverse(x, axes)
Reverses a tensor along the specified axes.
Arguments
- x: Tensor to reverse.
- axes: Integer or iterable of integers. Axes to reverse.
Returns
A tensor.
Numpy implementation
def reverse(x, axes):
if isinstance(axes, list):
axes = tuple(axes)
return np.flip(x, axes)
slice
keras.backend.slice(x, start, size)
Extracts a slice from a tensor.
Arguments
- x: Input tensor.
- start: Integer list/tuple or tensor indicating the start indices of the slice along each axis.
- size: Integer list/tuple or tensor indicating how many dimensions to slice along each axis.
Returns
A sliced tensor:
new_x = x[start[0]: start[0] + size[0], ..., start[-1]: start[-1] + size[-1]]
Raises
- ValueError: if the dimension and the size of indices mismatches.
Numpy implementation
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)
Returns the value of a variable.
Arguments
- x: input variable.
Returns
A Numpy array.
batch_get_value
keras.backend.batch_get_value(ops)
Returns the value of more than one tensor variable.
Arguments
- ops: list of ops to run.
Returns
A list of Numpy arrays.
set_value
keras.backend.set_value(x, value)
Sets the value of a variable, from a Numpy array.
Arguments
- x: Variable to set to a new value.
- value: Value to set the tensor to, as a Numpy array (of the same shape).
batch_set_value
keras.backend.batch_set_value(tuples)
Sets the values of many tensor variables at once.
Arguments
- tuples: a list of tuples
(tensor, value)
.value
should be a Numpy array.
print_tensor
keras.backend.print_tensor(x, message='')
Prints message
and the tensor value when evaluated.
Note that print_tensor
returns a new tensor identical to x
which should be used in the following code. Otherwise the
print operation is not taken into account during evaluation.
Example
>>> x = K.print_tensor(x, message="x is: ")
Arguments
- x: Tensor to print.
- message: Message to print jointly with the tensor.
Returns
The same tensor x
, unchanged.
function
keras.backend.function(inputs, outputs, updates=None)
gradients
keras.backend.gradients(loss, variables)
Returns the gradients of loss
w.r.t. variables
.
Arguments
- loss: Scalar tensor to minimize.
- variables: List of variables.
Returns
A gradients tensor.
stop_gradient
keras.backend.stop_gradient(variables)
Returns variables
but with zero gradient w.r.t. every other variable.
Arguments
- variables: tensor or list of tensors to consider constant with respect to any other variable.
Returns
A single tensor or a list of tensors (depending on the passed argument) that has constant gradient with respect to any other variable.
rnn
keras.backend.rnn(step_function, inputs, initial_states, go_backwards=False, mask=None, constants=None, unroll=False, input_length=None)
Iterates over the time dimension of a tensor.
Arguments
- step_function: Parameters: inputs: Tensor with shape (samples, ...) (no time dimension), representing input for the batch of samples at a certain time step. states: List of tensors. Returns: outputs: Tensor with shape (samples, ...) (no time dimension), new_states: List of tensors, same length and shapes as 'states'.
- inputs: Tensor of temporal data of shape (samples, time, ...) (at least 3D).
- initial_states: Tensor with shape (samples, ...) (no time dimension), containing the initial values for the states used in the step function.
- go_backwards: Boolean. If True, do the iteration over the time dimension in reverse order and return the reversed sequence.
- mask: Binary tensor with shape (samples, time), with a zero for every element that is masked.
- constants: A list of constant values passed at each step.
- unroll: Whether to unroll the RNN or to use a symbolic loop
(
while_loop
orscan
depending on backend). - input_length: Static number of timesteps in the input.
Returns
A tuple, (last_output, outputs, new_states)
.
last_output: The latest output of the rnn, of shape (samples, ...)
outputs: Tensor with shape (samples, time, ...)
where each
entry outputs[s, t]
is the output of the step function
at time t
for sample s
.
new_states: List of tensors, latest states returned by
the step function, of shape (samples, ...)
.
Raises
- ValueError: If input dimension is less than 3.
- ValueError: If
unroll
isTrue
but input timestep is not a fixed number. - ValueError: If
mask
is provided (notNone
) but states is not provided (len(states)
== 0).
Numpy implementation
Show the Numpy implementation
wzxhzdk:206switch
keras.backend.switch(condition, then_expression, else_expression)
Switches between two operations depending on a scalar value.
Note that both then_expression
and else_expression
should be symbolic tensors of the same shape.
Arguments
- condition: tensor (
int
orbool
). - then_expression: either a tensor, or a callable that returns a tensor.
- else_expression: either a tensor, or a callable that returns a tensor.
Returns
The selected tensor.
Raises
- ValueError: If rank of
condition
is greater than rank of expressions.
Numpy implementation
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)
Selects x
in train phase, and alt
otherwise.
Note that alt
should have the same shape as x
.
Arguments
- x: What to return in train phase (tensor or callable that returns a tensor).
- alt: What to return otherwise (tensor or callable that returns a tensor).
- training: Optional scalar tensor (or Python boolean, or Python integer) specifying the learning phase.
Returns
Either x
or alt
based on the training
flag.
the training
flag defaults to K.learning_phase()
.
in_test_phase
keras.backend.in_test_phase(x, alt, training=None)
Selects x
in test phase, and alt
otherwise.
Note that alt
should have the same shape as x
.
Arguments
- x: What to return in test phase (tensor or callable that returns a tensor).
- alt: What to return otherwise (tensor or callable that returns a tensor).
- training: Optional scalar tensor (or Python boolean, or Python integer) specifying the learning phase.
Returns
Either x
or alt
based on K.learning_phase
.
relu
keras.backend.relu(x, alpha=0.0, max_value=None, threshold=0.0)
Rectified linear unit.
With default values, it returns element-wise max(x, 0)
.
Otherwise, it follows:
f(x) = max_value
for x >= max_value
,
f(x) = x
for threshold <= x < max_value
,
f(x) = alpha * (x - threshold)
otherwise.
Arguments
- x: A tensor or variable.
- alpha: A scalar, slope of negative section (default=
0.
). - max_value: float. Saturation threshold.
- threshold: float. Threshold value for thresholded activation.
Returns
A tensor.
Numpy implementation
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)
Exponential linear unit.
Arguments
- x: A tensor or variable to compute the activation function for.
- alpha: A scalar, slope of negative section.
Returns
A tensor.
Numpy implementation
def elu(x, alpha=1.):
return x * (x > 0) + alpha * (np.exp(x) - 1.) * (x < 0)
softmax
keras.backend.softmax(x, axis=-1)
Softmax of a tensor.
Arguments
- x: A tensor or variable.
- axis: The dimension softmax would be performed on. The default is -1 which indicates the last dimension.
Returns
A tensor.
Numpy implementation
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 of a tensor.
Arguments
- x: A tensor or variable.
Returns
A tensor.
Numpy implementation
def softplus(x):
return np.log(1. + np.exp(x))
softsign
keras.backend.softsign(x)
Softsign of a tensor.
Arguments
- x: A tensor or variable.
Returns
A tensor.
Numpy implementation
def softsign(x):
return x / (1 + np.abs(x))
categorical_crossentropy
keras.backend.categorical_crossentropy(target, output, from_logits=False, axis=-1)
Categorical crossentropy between an output tensor and a target tensor.
Arguments
- target: A tensor of the same shape as
output
. - output: A tensor resulting from a softmax
(unless
from_logits
is True, in which caseoutput
is expected to be the logits). - from_logits: Boolean, whether
output
is the result of a softmax, or is a tensor of logits. - axis: Int specifying the channels axis.
axis=-1
corresponds to data formatchannels_last
, andaxis=1
corresponds to data formatchannels_first
.
Returns
Output tensor.
Raises
- ValueError: if
axis
is neither -1 nor one of the axes ofoutput
.
sparse_categorical_crossentropy
keras.backend.sparse_categorical_crossentropy(target, output, from_logits=False, axis=-1)
Categorical crossentropy with integer targets.
Arguments
- target: An integer tensor.
- output: A tensor resulting from a softmax
(unless
from_logits
is True, in which caseoutput
is expected to be the logits). - from_logits: Boolean, whether
output
is the result of a softmax, or is a tensor of logits. - axis: Int specifying the channels axis.
axis=-1
corresponds to data formatchannels_last
, andaxis=1
corresponds to data formatchannels_first
.
Returns
Output tensor.
Raises
- ValueError: if
axis
is neither -1 nor one of the axes ofoutput
.
binary_crossentropy
keras.backend.binary_crossentropy(target, output, from_logits=False)
Binary crossentropy between an output tensor and a target tensor.
Arguments
- target: A tensor with the same shape as
output
. - output: A tensor.
- from_logits: Whether
output
is expected to be a logits tensor. By default, we consider thatoutput
encodes a probability distribution.
Returns
A tensor.
sigmoid
keras.backend.sigmoid(x)
Element-wise sigmoid.
Arguments
- x: A tensor or variable.
Returns
A tensor.
Numpy implementation
def sigmoid(x):
return 1. / (1. + np.exp(-x))
hard_sigmoid
keras.backend.hard_sigmoid(x)
Segment-wise linear approximation of sigmoid.
Faster than sigmoid.
Returns 0.
if x < -2.5
, 1.
if x > 2.5
.
In -2.5 <= x <= 2.5
, returns 0.2 * x + 0.5
.
Arguments
- x: A tensor or variable.
Returns
A tensor.
Numpy implementation
def hard_sigmoid(x):
y = 0.2 * x + 0.5
return np.clip(y, 0, 1)
tanh
keras.backend.tanh(x)
Element-wise tanh.
Arguments
- x: A tensor or variable.
Returns
A tensor.
Numpy implementation
def tanh(x):
return np.tanh(x)
dropout
keras.backend.dropout(x, level, noise_shape=None, seed=None)
Sets entries in x
to zero at random, while scaling the entire tensor.
Arguments
- x: tensor
- level: fraction of the entries in the tensor that will be set to 0.
- noise_shape: shape for randomly generated keep/drop flags,
must be broadcastable to the shape of
x
- seed: random seed to ensure determinism.
Returns
A tensor. Numpy implementation
Show the Numpy implementation
wzxhzdk:231l2_normalize
keras.backend.l2_normalize(x, axis=None)
Normalizes a tensor wrt the L2 norm alongside the specified axis.
Arguments
- x: Tensor or variable.
- axis: axis along which to perform normalization.
Returns
A tensor.
Numpy implementation
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)
Returns whether the targets
are in the top k
predictions
.
Arguments
- predictions: A tensor of shape
(batch_size, classes)
and typefloat32
. - targets: A 1D tensor of length
batch_size
and typeint32
orint64
. - k: An
int
, number of top elements to consider.
Returns
A 1D tensor of length batch_size
and type bool
.
output[i]
is True
if predictions[i, targets[i]]
is within top-k
values of predictions[i]
.
conv1d
keras.backend.conv1d(x, kernel, strides=1, padding='valid', data_format=None, dilation_rate=1)
1D convolution.
Arguments
- x: Tensor or variable.
- kernel: kernel tensor.
- strides: stride integer.
- padding: string,
"same"
,"causal"
or"valid"
. - data_format: string,
"channels_last"
or"channels_first"
. - dilation_rate: integer dilate rate.
Returns
A tensor, result of 1D convolution.
Raises
- ValueError: If
data_format
is neither"channels_last"
nor"channels_first"
.
conv2d
keras.backend.conv2d(x, kernel, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1))
2D convolution.
Arguments
- x: Tensor or variable.
- kernel: kernel tensor.
- strides: strides tuple.
- padding: string,
"same"
or"valid"
. - data_format: string,
"channels_last"
or"channels_first"
. Whether to use Theano or TensorFlow/CNTK data format for inputs/kernels/outputs. - dilation_rate: tuple of 2 integers.
Returns
A tensor, result of 2D convolution.
Raises
- ValueError: If
data_format
is neither"channels_last"
nor"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 deconvolution (i.e. transposed convolution).
Arguments
- x: Tensor or variable.
- kernel: kernel tensor.
- output_shape: 1D int tensor for the output shape.
- strides: strides tuple.
- padding: string,
"same"
or"valid"
. - data_format: string,
"channels_last"
or"channels_first"
. Whether to use Theano or TensorFlow/CNTK data format for inputs/kernels/outputs. - dilation_rate: tuple of 2 integers.
Returns
A tensor, result of transposed 2D convolution.
Raises
- ValueError: If
data_format
is neither"channels_last"
nor"channels_first"
.
separable_conv1d
keras.backend.separable_conv1d(x, depthwise_kernel, pointwise_kernel, strides=1, padding='valid', data_format=None, dilation_rate=1)
1D convolution with separable filters.
Arguments
- x: input tensor
- depthwise_kernel: convolution kernel for the depthwise convolution.
- pointwise_kernel: kernel for the 1x1 convolution.
- strides: stride integer.
- padding: string,
"same"
or"valid"
. - data_format: string,
"channels_last"
or"channels_first"
. - dilation_rate: integer dilation rate.
Returns
Output tensor.
Raises
- ValueError: If
data_format
is neither"channels_last"
nor"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 convolution with separable filters.
Arguments
- x: input tensor
- depthwise_kernel: convolution kernel for the depthwise convolution.
- pointwise_kernel: kernel for the 1x1 convolution.
- strides: strides tuple (length 2).
- padding: string,
"same"
or"valid"
. - data_format: string,
"channels_last"
or"channels_first"
. - dilation_rate: tuple of integers, dilation rates for the separable convolution.
Returns
Output tensor.
Raises
- ValueError: If
data_format
is neither"channels_last"
nor"channels_first"
.
depthwise_conv2d
keras.backend.depthwise_conv2d(x, depthwise_kernel, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1))
2D convolution with separable filters.
Arguments
- x: input tensor
- depthwise_kernel: convolution kernel for the depthwise convolution.
- strides: strides tuple (length 2).
- padding: string,
"same"
or"valid"
. - data_format: string,
"channels_last"
or"channels_first"
. - dilation_rate: tuple of integers, dilation rates for the separable convolution.
Returns
Output tensor.
Raises
- ValueError: If
data_format
is neither"channels_last"
nor"channels_first"
.
conv3d
keras.backend.conv3d(x, kernel, strides=(1, 1, 1), padding='valid', data_format=None, dilation_rate=(1, 1, 1))
3D convolution.
Arguments
- x: Tensor or variable.
- kernel: kernel tensor.
- strides: strides tuple.
- padding: string,
"same"
or"valid"
. - data_format: string,
"channels_last"
or"channels_first"
. Whether to use Theano or TensorFlow/CNTK data format for inputs/kernels/outputs. - dilation_rate: tuple of 3 integers.
Returns
A tensor, result of 3D convolution.
Raises
- ValueError: If
data_format
is neither"channels_last"
nor"channels_first"
.
conv3d_transpose
keras.backend.conv3d_transpose(x, kernel, output_shape, strides=(1, 1, 1), padding='valid', data_format=None)
3D deconvolution (i.e. transposed convolution).
Arguments
- x: input tensor.
- kernel: kernel tensor.
- output_shape: 1D int tensor for the output shape.
- strides: strides tuple.
- padding: string, "same" or "valid".
- data_format: string,
"channels_last"
or"channels_first"
. Whether to use Theano or TensorFlow/CNTK data format for inputs/kernels/outputs.
Returns
A tensor, result of transposed 3D convolution.
Raises
- ValueError: If
data_format
is neither"channels_last"
nor"channels_first"
.
pool2d
keras.backend.pool2d(x, pool_size, strides=(1, 1), padding='valid', data_format=None, pool_mode='max')
2D Pooling.
Arguments
- x: Tensor or variable.
- pool_size: tuple of 2 integers.
- strides: tuple of 2 integers.
- padding: string,
"same"
or"valid"
. - data_format: string,
"channels_last"
or"channels_first"
. - pool_mode: string,
"max"
or"avg"
.
Returns
A tensor, result of 2D pooling.
Raises
- ValueError: if
data_format
is
neither "channels_last"
or "channels_first"
.
- ValueError: if
pool_mode
is neither"max"
or"avg"
.
pool3d
keras.backend.pool3d(x, pool_size, strides=(1, 1, 1), padding='valid', data_format=None, pool_mode='max')
3D Pooling.
Arguments
- x: Tensor or variable.
- pool_size: tuple of 3 integers.
- strides: tuple of 3 integers.
- padding: string,
"same"
or"valid"
. - data_format: string,
"channels_last"
or"channels_first"
. - pool_mode: string,
"max"
or"avg"
.
Returns
A tensor, result of 3D pooling.
Raises
- ValueError: if
data_format
is
neither "channels_last"
or "channels_first"
.
- ValueError: if
pool_mode
is neither"max"
or"avg"
.
local_conv1d
keras.backend.local_conv1d(inputs, kernel, kernel_size, strides, data_format=None)
Apply 1D conv with un-shared weights.
Arguments
- inputs: 3D tensor with shape: (batch_size, steps, input_dim)
- kernel: the unshared weight for convolution, with shape (output_length, feature_dim, filters)
- kernel_size: a tuple of a single integer, specifying the length of the 1D convolution window
- strides: a tuple of a single integer, specifying the stride length of the convolution
- data_format: the data format, channels_first or channels_last
Returns
the tensor after 1d conv with un-shared weights, with shape (batch_size, output_length, filters)
Raises
- ValueError: If
data_format
is neither"channels_last"
nor"channels_first"
.
local_conv2d
keras.backend.local_conv2d(inputs, kernel, kernel_size, strides, output_shape, data_format=None)
Apply 2D conv with un-shared weights.
Arguments
- inputs: 4D tensor with shape: (batch_size, filters, new_rows, new_cols) if data_format='channels_first' or 4D tensor with shape: (batch_size, new_rows, new_cols, filters) if data_format='channels_last'.
- kernel: the unshared weight for convolution, with shape (output_items, feature_dim, filters)
- kernel_size: a tuple of 2 integers, specifying the width and height of the 2D convolution window.
- strides: a tuple of 2 integers, specifying the strides of the convolution along the width and height.
- output_shape: a tuple with (output_row, output_col)
- data_format: the data format, channels_first or channels_last
Returns
A 4d tensor with shape: (batch_size, filters, new_rows, new_cols) if data_format='channels_first' or 4D tensor with shape: (batch_size, new_rows, new_cols, filters) if data_format='channels_last'.
Raises
- ValueError: if
data_format
is neitherchannels_last
orchannels_first
.
bias_add
keras.backend.bias_add(x, bias, data_format=None)
Adds a bias vector to a tensor.
Arguments
- x: Tensor or variable.
- bias: Bias tensor to add.
- data_format: string,
"channels_last"
or"channels_first"
.
Returns
Output tensor.
Raises
ValueError: In one of the two cases below:
1. invalid data_format
argument.
2. invalid bias shape.
the bias should be either a vector or
a tensor with ndim(x) - 1 dimension
Numpy implementation
Show the Numpy implementation
wzxhzdk:248random_normal
keras.backend.random_normal(shape, mean=0.0, stddev=1.0, dtype=None, seed=None)
Returns a tensor with normal distribution of values.
Arguments
- shape: A tuple of integers, the shape of tensor to create.
- mean: A float, mean of the normal distribution to draw samples.
- stddev: A float, standard deviation of the normal distribution to draw samples.
- dtype: String, dtype of returned tensor.
- seed: Integer, random seed.
Returns
A tensor.
random_uniform
keras.backend.random_uniform(shape, minval=0.0, maxval=1.0, dtype=None, seed=None)
Returns a tensor with uniform distribution of values.
Arguments
- shape: A tuple of integers, the shape of tensor to create.
- minval: A float, lower boundary of the uniform distribution to draw samples.
- maxval: A float, upper boundary of the uniform distribution to draw samples.
- dtype: String, dtype of returned tensor.
- seed: Integer, random seed.
Returns
A tensor.
random_binomial
keras.backend.random_binomial(shape, p=0.0, dtype=None, seed=None)
Returns a tensor with random binomial distribution of values.
Arguments
- shape: A tuple of integers, the shape of tensor to create.
- p: A float,
0. <= p <= 1
, probability of binomial distribution. - dtype: String, dtype of returned tensor.
- seed: Integer, random seed.
Returns
A tensor.
truncated_normal
keras.backend.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=None, seed=None)
Returns a tensor with truncated random normal distribution of values.
The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than two standard deviations from the mean are dropped and re-picked.
Arguments
- shape: A tuple of integers, the shape of tensor to create.
- mean: Mean of the values.
- stddev: Standard deviation of the values.
- dtype: String, dtype of returned tensor.
- seed: Integer, random seed.
Returns
A tensor.
ctc_label_dense_to_sparse
keras.backend.ctc_label_dense_to_sparse(labels, label_lengths)
Converts CTC labels from dense to sparse.
Arguments
- labels: dense CTC labels.
- label_lengths: length of the labels.
Returns
A sparse tensor representation of the labels.
ctc_batch_cost
keras.backend.ctc_batch_cost(y_true, y_pred, input_length, label_length)
Runs CTC loss algorithm on each batch element.
Arguments
- y_true: tensor
(samples, max_string_length)
containing the truth labels. - y_pred: tensor
(samples, time_steps, num_categories)
containing the prediction, or output of the softmax. - input_length: tensor
(samples, 1)
containing the sequence length for each batch item iny_pred
. - label_length: tensor
(samples, 1)
containing the sequence length for each batch item iny_true
.
Returns
Tensor with shape (samples,1) containing the CTC loss of each element.
ctc_decode
keras.backend.ctc_decode(y_pred, input_length, greedy=True, beam_width=100, top_paths=1, merge_repeated=False)
Decodes the output of a softmax.
Can use either greedy search (also known as best path) or a constrained dictionary search.
Arguments
- y_pred: tensor
(samples, time_steps, num_categories)
containing the prediction, or output of the softmax. - input_length: tensor
(samples, )
containing the sequence length for each batch item iny_pred
. - greedy: perform much faster best-path search if
True
. This does not use a dictionary. - beam_width: if
greedy
isFalse
: a beam search decoder will be used with a beam of this width. - top_paths: if
greedy
isFalse
, how many of the most probable paths will be returned. - merge_repeated: if
greedy
isFalse
, merge repeated classes in the output beams.
Returns
- Tuple:
List: if
greedy
isTrue
, returns a list of one element that contains the decoded sequence. IfFalse
, returns thetop_paths
most probable decoded sequences. Important: blank labels are returned as-1
. Tensor(top_paths, )
that contains the log probability of each decoded sequence.
control_dependencies
keras.backend.control_dependencies(control_inputs)
A context manager that specifies control dependencies.
Arguments
- control_inputs: A list of Operation or Tensor objects which must be executed or computed before running the operations defined in the context. Can also be None to clear the control dependencies.
Returns
A context manager.
map_fn
keras.backend.map_fn(fn, elems, name=None, dtype=None)
Map the function fn over the elements elems and return the outputs.
Arguments
- fn: Callable that will be called upon each element in elems
- elems: tensor
- name: A string name for the map node in the graph
- dtype: Output data type.
Returns
Tensor with dtype dtype
.
foldl
keras.backend.foldl(fn, elems, initializer=None, name=None)
Reduce elems using fn to combine them from left to right.
Arguments
- fn: Callable that will be called upon each element in elems and an
accumulator, for instance
lambda acc, x: acc + x
- elems: tensor
- initializer: The first value used (
elems[0]
in case of None) - name: A string name for the foldl node in the graph
Returns
Tensor with same type and shape as initializer
.
foldr
keras.backend.foldr(fn, elems, initializer=None, name=None)
Reduce elems using fn to combine them from right to left.
Arguments
- fn: Callable that will be called upon each element in elems and an
accumulator, for instance
lambda acc, x: acc + x
- elems: tensor
- initializer: The first value used (
elems[-1]
in case of None) - name: A string name for the foldr node in the graph
Returns
Tensor with same type and shape as initializer
.


presidents: {{ room }}
play current hand
pass
store current hand
clear current hand
clear stored hands


Popular Areas in ww2 navy men in japan
Through Japanese Eyes: WWII in Japanese Cinema | U.S. Naval ...
Any Japanese film concerning WWII is going to be closely scrutinized by Japanese and . that often include rather negative stereotypes of Japanese soldiers).
http://www.usni.org/through-japanese-eyes-wwii-japanese-cinema
What was General MacArthur's role during World War 2
MacArthur was the General of the Pacific fleet Navy during WWII. He led a southern attack against Japan that began just above Australia and eventually captured every Japanese occupied . Both were strong abd forceful men, likely to clash.
http://wiki.answers.com/Q/What_was_General_MacArthur's_role_during_World_War_2
How many Americans fought in World War 2
Answer. Aproximately 4 million Service men in the Navy Army and Air Force. . How many Japanese Americans fought in World War 2? See film: Go For Broke; .
http://wiki.answers.com/Q/How_many_Americans_fought_in_World_War_2
The Boy Who Became a World War II Veteran at 13 Years Old | Past ...
Dec 19, 2012 . He lined up behind a couple of guys he knew who were already 14 or . With the Japanese Imperial Navy under the impression that it had . Congress Votes WWII Benefits For Boy Sailor, Washington Post, October 23, 1988.
http://blogs.smithsonianmag.com/history/2012/12/the-boy-who-became-a-world-war-ii-veteran-at-13-years-old/
Imperial Japanese Navy Air Force in WWII
The Imperial Japanese Navy Air Force was very conservative and, . the war, that the U.S. Navy and USAAF would have fewer men and fewer planes "up front" .
http://www.combinedfleet.com/ijnaf.htm


All BComponents extend the BComponent class and as a result have the following API as well.
disableAutoIdentifier()
is used to disable automatic generation of id attributes. If you specify an id for a BComponent then an auto identifier will not be used for that BComponent. Call this method in the constructor of your NgModule
to disable auto identifiers.
public static disableAutoIdentifier: () => void
InitializeAttributes()
is used to intialize components in code. Used to assign attribute inputs to a BComponent. Returns itself for method chaining.
public InitializeAttributes: (id: string = "", classes: string = "", styles: string = "", name: string = "", aria: string = "", ariaBy: string = "") => this
getSelector()
returns a JQuery
object of the BComponent.
Note: This and all the following JQuery animation methods only work with auto identifiers enabled or a specified id.
public getSelector: () => JQuery
toggle()
is the equivalent of jQuery's toggle()
.
public toggle: (duration: string | number = 400, callback?: Function) => JQuery
hide()
is the equivalent of jQuery's hide()
.
public hide: (duration: string | number = 400, callback?: Function) => JQuery
show()
is the equivalent of jQuery's show()
.
public show: (duration: string | number = 400, callback?: Function) => JQuery
fadeToggle()
is the equivalent of jQuery's fadeToggle()
.
public fadeToggle: (duration: string | number = 400, callback?: Function) => JQuery
fadeIn()
is the equivalent of jQuery's fadeIn()
.
public fadeIn: (duration: string | number = 400, callback?: Function) => JQuery
fadeOut()
is the equivalent of jQuery's fadeOut()
.
public fadeOut: (duration: string | number = 400, callback?: Function) => JQuery
fadeTo()
is the equivalent of jQuery's fadeTo()
.
public fadeTo: (duration: string | number = 400, opacity: number = 0, callback?: Function) => JQuery
slideToggle()
is the equivalent of jQuery's slideToggle()
.
public slideToggle: (duration: string | number = 400, callback?: Function) => JQuery
slideDown()
is the equivalent of jQuery's slideDown()
.
public slideDown: (duration: string | number = 400, callback?: Function) => JQuery
slideUp()
is the equivalent of jQuery's slideUp()
.
public slideUp: (duration: string | number = 400, callback?: Function) => JQuery


D.O.A. A film review by Shane R. Burridge Copyright 1997 Shane R. Burridge
D.O.A. (1988) 96m.
Remake of 1950 thriller is snappily directed, features popular lead actors (Dennis Quaid, Meg Ryan), and has a great premise, but is ultimately torpedoed by a misconceived script. Quaid is an English professor (and has-been writer) on a Texas campus who finds out that he has been fatally poisoned. With only 24 hours left to live he tries to find out who is responsible. While I thoroughly enjoyed this on first viewing, it doesn't hold up so well the second time around. Story, which belongs to the =91what would you do if the world was going to end in ten minutes=92 school of speculation, treads the path a number of us would no doubt choose - what Quaid wants is answers. What drives D.O.A. is the notion that fear of death can be taken to a further stage - the fear of dying without meaning or reason. In fact Quaid is more preoccupied with solving the mystery behind his imminent death than the physical act of dying itself.
The most puzzling thing for Quaid (and the audience) is the crime=92s motive. There is no apparent reason why anyone should want to kill him. This intriguing element is one of the best things the film has going for it until the denoument, which is so absurd it undermines the whole premise. Worse, it trivializes Quaid=92s death. There are other glitches, most obviously that by the time the bodies start piling up (and there=92s way too many for such a weak motive) there=92s not a lot of suspects left over to pick the murderer from. There=92s also a convoluted exposition scene with Charlotte Rampling that for all purposes is irrelevant to the main story. Nor am I convinced about the neccessity for Meg Ryan=92s character. Her brief interlude with Quaid supposedly reminds him of the quality of life that he has let slip by - but does anybody really need this just before they=92re about to die? On a purely filmic level, however, the film succeeds, and there are enough inventive moments to make it interesting. A promising cinema debut for Annabel Jankel and Rocky Morton - with all its plot holes it might have been a good idea for them to push style over content even further.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Notice
Business update is the Skills Funding Agency’s monthly round-up of business-critical information and news for businesses.
PDF , 138KB , 5 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 423KB , 5 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 297KB , 4 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 265KB , 3 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 198KB , 4 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 208KB , 4 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 119KB , 5 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 222KB , 4 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 205KB , 3 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 245KB , 7 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 224KB , 6 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 204KB , 4 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 196KB , 3 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 202KB , 3 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 217KB , 4 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 316KB , 4 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 221KB , 5 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 297KB , 4 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
PDF , 314KB , 5 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
Each month, Business Update will inform you of our ‘products’ and services and their potential to make a positive impact upon your business.
If you have any feedback, please email<EMAIL_ADDRESS>.
Published: 4 November 2014
Updated: 8 March 2017
From: Skills Funding Agency
Part of: Further education and training


// features = tf.multiply(tf.multiply(degree, features), degree)
// features = tf.transpose(features)
output = mm(output, weight)
output += torch.mm(features, weight)
if bias is not None:
output += bias
def gcn(adj, input, weight, bias=None):
n, m = adj.size()
I = eye(n, m)
adj = adj + I


Comes as an additional offer to the customers.
Fall inluv with the products.
All for you
Take less that becomes more
The service provided by Merva Beauty left everyone who interacted with her dazzling with the service she offered.
I will definately make sure that i pop up at Merva's shop again. The Services are wonderful.
Just stay tune for our latest Product. Now you can subscribe


Company profile - Canadian Company Capabilities
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
The Benchmark Group Inc.
Legal Name:
The Benchmark Group Inc.
Operating Name:
Benchmark Group
Mailing Address:
402-510 King St ETORONTO, Ontario
M5A 0E5
Location Address:
402-510 King St ETORONTO, Ontario
M5A 0E5
Tel.:<PHONE_NUMBER>
Fax:
Company Profile
In the broadest sense, Benchmark Group is a lifestyle brand that integrates functional design with holistic health and fitness, for optimal human performance and longevity. Since its founding in 1999, Benchmark has implemented wellness programming into numerous corporations and partnered with thousands of residential clients in more than 100 condominium buildings to become an industry leader in lifestyle services. Benchmark provides the perfect catalyst to successfully cultivate healthy, vibrant communities and workplaces.
Benchmark founded Movement Haus in fall 2010 to define ‘state-of-the-art’; creating a new standard for residential amenities receiving the most usage - health and fitness amenities. Our Movement Haus brand challenges ineffective design, space allocation and management models by creating innovative amenities and exercise environments that, by design, are replacements for traditional gym memberships.
Movement Haus challenges developers’ very definition of state-of-the-art, traditional form-driven architecture and design; instead focusing on each building’s unique demographic, the ever-changing landscape of fitness and how Millenials and Generation X are exercising in these live and work spaces. Benchmark optimizes resident engagement and effective usage of our Movement Haus amenities by focusing on the design of lifestyle programming first - physical space, second. Historically, these amenity spaces were designed without consideration of functionality and delivered with little thought given to programming. The end result of poor or absent programming; valuable, sellable space often sitting vacant, going unused or worse, requiring future redevelopment because of inadequate space allocation and planning.
Benchmark intuitively develops tailor-made lifestyle programming and Movement Haus health and fitness amenities - designed to synergistically engage each community. Developers leverage Benchmark’s Movement Haus brand to increase the value of their projects, lease rental units, increase and improve development sales and further enhance their brand position. Benchmark has collaborated with development companies and international, award-winning architecture and interior design firms to create Movement Haus branded fitness spaces in nearly 100 residential developments across North America. Our Movement Haus amenities will soon positively shape the health and well-being of more than 55,000 residents in this rapidly growing market segment.
Intimately familiar with Toronto’s condominium demographic, we can apply our research and findings to the commercial segment where many of our residential clients can be found working in offices each day. Millenials not only want to live close to work, they also want to have access to true to form, state-of-the-art health and fitness amenities and complementary programming attune to their specific social and lifestyle needs.
Akin to residential developers attracting Millenial purchasers, commercial development will also want to attract the next generation workforce and retain them with various lifestyle programming, planning and relevant design considerations. Mirroring that of residential, the design and planning of a commercial development will ultimately fuel the success and desirability of its tenants – leading to a shared return on investment for both the developer (leased spaces) and commercial tenants (wellness-specific programming). Unfortunately, a one size fits all approach is often still exercised in commercial environments, where equipment suppliers and traditional corporate wellness companies continue to design and deliver the same (largely ineffective) wellness programming and amenity planning (often in leftover space) they have the past 15 years with little regard to shifting demographics, increasing tenant engagement and fostering and improving human and workplace performance.
In our tireless pursuit of healthy living, we’ve recently introduced Benchmark Living; a strategic partnership with select Canadian companies offering sustainable items to Benchmark clients and communities with a percentage of proceeds funding a foundation currently under development. This serves as part of a lifestyle initiative to further cultivate a healthy life at work and home. Benchmark Living dovetails with our commitment to holistic, sustainable living and our interest in creating WELL Certified buildings – the union of healthy services with healthy buildings.
Full profile
Full profile
Contact information
Company description
611690 - All Other Schools and Instruction
Product / Service / Licensing
Market profile
Alliances:
Strategic alliances:
Would like to form strategic alliances with employee assistanceproviders, property managment companies, condominium
developers, and corporations that are intersted in maximizing
employee wellness through our coaching program.
Industry sector market interests:
- Service Industry
Geographic markets:
Actively pursuing:
- United States
- California
- New York
Sector information
Key / Major clients:
Allied REITAshcroft Homes
Bosa Properties
Castlepoint Realty Partners
Cityzen Development Group
Diamondcorp
Dream Unlimited Corp
Fernbrook Homes
Fortress Real Developments
Glen Rouge Homes
Great Gulf
Harhay Developments
Hullmark Developments
Lanterra Developments
Lifetime Developments
MADY Developments
Minto Group
MOD Developments
Monarch/Mattamy Group
Panoramic Properties
Pemberton Group
Related Group
RioCan REIT
Rockport Group
SigNature Communities
TAS Design Build
Tridel
Urban Capital
WAM Developments
Yorkville Corporation
Zancor Homes
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Contacts
Contact information
Description
Company description
611690 - All Other Schools and Instruction
Products, services and licensing
Product / Service / Licensing
Market
Market profile
Alliances:
Strategic alliances:
Would like to form strategic alliances with employee assistanceproviders, property managment companies, condominium
developers, and corporations that are intersted in maximizing
employee wellness through our coaching program.
Industry sector market interests:
- Service Industry
Geographic markets:
Actively pursuing:
- United States
- California
- New York
Sector
Sector information
Key / Major clients:
Allied REITAshcroft Homes
Bosa Properties
Castlepoint Realty Partners
Cityzen Development Group
Diamondcorp
Dream Unlimited Corp
Fernbrook Homes
Fortress Real Developments
Glen Rouge Homes
Great Gulf
Harhay Developments
Hullmark Developments
Lanterra Developments
Lifetime Developments
MADY Developments
Minto Group
MOD Developments
Monarch/Mattamy Group
Panoramic Properties
Pemberton Group
Related Group
RioCan REIT
Rockport Group
SigNature Communities
TAS Design Build
Tridel
Urban Capital
WAM Developments
Yorkville Corporation
Zancor Homes


Game Over!
Your score:
High score:
Instructions
Move via the arrow keys on the keyboard.
Reach the end to gain a point.
Collect treasure stars to gain 2 points.
Avoid water and enemy bugs.
More bugs will appear as the end is reached multiple times.
If you lose all your lives, it's game over!
Game Settings
Difficulty
Easy
Medium
Hard
Insane
Start the game with
enemies.


{% extends "base.html" %} {% block title %}Community{% endblock %} {% block content %}
Organising something in advance? Or spontaneously during the event? Meet up with other ticketholders on the attendee Slack Channel (sign-up required via below link):
Additionally, on IRC:


|
G24Lib
A set of convenient classes, functions and other utilities mainly for quickly writing numerical code. Provides relatively easy integration with CUDA, general Runge-Kutta methods, linear equation solvers and more.
|
An interface for the object held in the g24_lib::split_member_array
so they can be changed through an operator=
.
More...
Public Member Functions | |
| CUDA_HOS_DEV | split_member_accessor (split_member_array *a, const indexer i) |
| Construct a split_member_accessor. The end-user probably shouldn't need to do this, but... More... | |
| template<g24_lib::Definitions::default_unsigned_indexer I> | |
| CUDA_HOS_DEV auto & | get () |
Returns the i-th element of the struct using the ordering from g24_lib::class_info::true_type , but with 0-indexing. More... | |
| template<g24_lib::Definitions::default_unsigned_indexer I> | |
| CUDA_HOS_DEV const auto & | get () const |
Returns the i-th element of the struct using the ordering from g24_lib::class_info::true_type , but with 0-indexing. More... | |
| template<g24_lib::Definitions::default_unsigned_indexer I> | |
| CUDA_HOS_DEV auto & | get_element () |
Returns the i-th element of the struct using the ordering from g24_lib::class_info::true_type , including 1-indexing. More... | |
| template<g24_lib::Definitions::default_unsigned_indexer I> | |
| CUDA_HOS_DEV const auto & | get_element () const |
Returns the i-th element of the struct using the ordering from g24_lib::class_info::true_type , including 1-indexing. More... | |
| CUDA_ONLY_HOS | operator flat_imitation_struct< Type > () const |
| CUDA_HOS_DEV | operator Type () const |
| CUDA_HOS_DEV split_member_accessor & | operator= (const g24_lib::flat_imitation_struct< Type > &imit) |
An interface for the object held in the g24_lib::split_member_array
so they can be changed through an operator=
.
Definition at line 904 of file split_array.h.
|
inline |
Construct a split_member_accessor. The end-user probably shouldn't need to do this, but...
Definition at line 926 of file split_array.h.
|
inline |
Returns the i-th element of the struct using the ordering from g24_lib::class_info::true_type
, but with 0-indexing.
Provided for compatibility with structured bindings.
Definition at line 983 of file split_array.h.
|
inline |
Returns the i-th element of the struct using the ordering from g24_lib::class_info::true_type
, but with 0-indexing.
Provided for compatibility with structured bindings.
Definition at line 970 of file split_array.h.
|
inline |
Returns the i-th element of the struct using the ordering from g24_lib::class_info::true_type
, including 1-indexing.
Definition at line 957 of file split_array.h.
|
inline |
Returns the i-th element of the struct using the ordering from g24_lib::class_info::true_type
, including 1-indexing.
Definition at line 946 of file split_array.h.
|
inline |
Definition at line 988 of file split_array.h.
|
inline |
Definition at line 993 of file split_array.h.
|
inline |
Definition at line 928 of file split_array.h.


The Destiny of Blacklists
June 2005
In 1997, a group of anti-spam vigilantes called MAPS started a blacklist of mail servers owned by or compromised by spammers. Mail server administrators could use this list to block sources of spam. At least, that was what most of them thought they were getting.
The problem was, as vigilantes so often do, the guys at MAPS got carried away. They started to include servers on the list that they knew weren't sources of spam, to pressure whoever owned the server to do what they wanted. For example, in order to get revenge on people they believed were spamming, MAPS would blacklist the mail server of the company hosting their site.
MAPS knew these mail servers weren't spam sources. But they'd blacklist them anyway. Everyone else sharing that server would then have their mail blocked. And MAPS could insist that the hosting company delete the site of the (supposed) spammer as the price of all the ISP's other, innocent, users having their mail unblocked.
This is, strictly speaking, terrorism: harming innnocent people as a way to pressure some central authority into doing what you want.
The innocent people whose mail got blocked as a result of this kind of trick weren't "collateral damage." They weren't harmed by accident. It was in order to harm these innocent people, and thus put pressure on their ISP, that MAPS blacklisted them.
This kind of tactic gradually brought MAPS into disrepute. Most mail server administrators dropped their list and switched to another blacklist, the Spamhaus SBL, which was created specifically to avoid MAPS-style abuses. They were only going to list real spammers. And for a couple years they did.
Unfortunately, as so often happens, power corrupted them. About a year ago, I started to hear reports that Spamhaus was starting to use the same tactics MAPS had.
John Reid of Spamhaus told me this wasn't true-- that the SBL was still clean, and that they only blacklisted hosting companies' mail servers when they were spam hosts who took on innocent users as camouflage:
The sad fact is, some of these "spammer friendly hosts" will also try load up with as many non-spammers as they can to try and show legitimacy. We try at all costs to avoid listing legit places and people, and only if the host tells us or shows us in no uncertain terms that they don't plan to cease hosting spammers will we list them in their entirety.
I wanted to believe him. But before I could reply to his mail, I got first-hand evidence that the SBL has in fact gone bad.
As of this writing, any filter relying on the SBL is now marking email with the url "paulgraham.com" as spam. Why? Because the guys at the SBL want to pressure Yahoo, where paulgraham.com is hosted, to delete the site of a company they believe is spamming.
This clearly contradicts what John Reid wrote in his email to me. Yahoo is not a "spam friendly" ISP that takes on a few innocent users to "show legitimacy." And Spamhaus knows it. Of the tens of thousands of sites Yahoo hosts, how many do they claim have spammed? Two.
This case illustrates an important failing of blacklists.  And humans are all too likely to abuse the kind of power that blacklists embody. Perhaps someone will start another blacklist that tries to avoid such abuses. But how long before that one becomes corrupt too?
No doubt this particular case will get sorted out, and mail containing my url will stop getting blocked. But this example is enough to prove that the whole idea of blacklists is broken. Blacklists have a structural flaw: there is no one to watch the watchers.
Clarification: Many people seem to assume that Spamhaus merely blacklisted the IP address of a single spammer's site. In fact, as well as the spammer's IP address they also blacklisted <IP_ADDRESS>, aka store.yahoo.com, which is shared by thousands of Yahoo stores.