Math

Note: Functions taking Tensor arguments can also take anything accepted by tf.convert_to_tensor.

[TOC]

Note: Elementwise binary operations in TensorFlow follow numpy-style broadcasting.

Arithmetic Operators

TensorFlow provides several operations that you can use to add basic arithmetic operators to your graph.

`tf.add(x, y, name=None)` {#add}

Returns x + y element-wise.

NOTE: Add supports broadcasting. AddN does not. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128, string.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.subtract(x, y, name=None)` {#subtract}

Returns x - y element-wise.

NOTE: tf.subtract supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.multiply(x, y, name=None)` {#multiply}

Returns x * y element-wise.

NOTE: tf.multiply supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.scalar_mul(scalar, x)` {#scalar_mul}

Multiplies a scalar times a Tensor or IndexedSlices object.

Intended for use in gradient code which might deal with IndexedSlices objects, which are easy to multiply by a scalar but more expensive to multiply with arbitrary tensors.

Args:

scalar: A 0-D scalar Tensor. Must have known shape.
x: A Tensor or IndexedSlices to be scaled.

Returns:

scalar * x of the same type (Tensor or IndexedSlices) as x.

Raises:

ValueError: if scalar is not a 0-D scalar.

`tf.div(x, y, name=None)` {#div}

Divides x / y elementwise (using Python 2 division operator semantics).

NOTE: Prefer using the Tensor division operator or tf.divide which obey Python division operator semantics.

This function divides x and y, forcing Python 2.7 semantics. That is, if one of x or y is a float, then the result will be a float. Otherwise, the output will be an integer type. Flooring semantics are used for integer division.

Args:

x: Tensor numerator of real numeric type.
y: Tensor denominator of real numeric type.
name: A name for the operation (optional).

Returns:

x / y returns the quotient of x and y.

`tf.divide(x, y, name=None)` {#divide}

Computes Python style division of x by y.

`tf.truediv(x, y, name=None)` {#truediv}

Divides x / y elementwise (using Python 3 division operator semantics).

NOTE: Prefer using the Tensor operator or tf.divide which obey Python division operator semantics.

This function forces Python 3 division operator semantics where all integer arguments are cast to floating types first. This op is generated by normal x / y division in Python 3 and in Python 2.7 with from __future__ import division. If you want integer division that rounds down, use x // y or tf.floordiv.

x and y must have the same numeric type. If the inputs are floating point, the output will have the same type. If the inputs are integral, the inputs are cast to float32 for int8 and int16 and float64 for int32 and int64 (matching the behavior of Numpy).

Args:

x: Tensor numerator of numeric type.
y: Tensor denominator of numeric type.
name: A name for the operation (optional).

Returns:

x / y evaluated in floating point.

Raises:

TypeError: If x and y have different dtypes.

`tf.floordiv(x, y, name=None)` {#floordiv}

Divides x / y elementwise, rounding toward the most negative integer.

The same as tf.div(x,y) for integers, but uses tf.floor(tf.div(x,y)) for floating point arguments so that the result is always an integer (though possibly an integer represented as floating point). This op is generated by x // y floor division in Python 3 and in Python 2.7 with from __future__ import division.

Note that for efficiency, floordiv uses C semantics for negative numbers (unlike Python and Numpy).

x and y must have the same type, and the result will have the same type as well.

Args:

x: Tensor numerator of real numeric type.
y: Tensor denominator of real numeric type.
name: A name for the operation (optional).

Returns:

x / y rounded down (except possibly towards zero for negative integers).

Raises:

TypeError: If the inputs are complex.

`tf.realdiv(x, y, name=None)` {#realdiv}

Returns x / y element-wise for real types.

If x and y are reals, this will return the floating-point division.

NOTE: Div supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.truncatediv(x, y, name=None)` {#truncatediv}

Returns x / y element-wise for integer types.

Truncation designates that negative numbers will round fractional quantities toward zero. I.e. -7 / 5 = 1. This matches C semantics but it is different than Python semantics. See FloorDiv for a division function that matches Python Semantics.

NOTE: TruncateDiv supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.floor_div(x, y, name=None)` {#floor_div}

Returns x // y element-wise.

NOTE: FloorDiv supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.truncatemod(x, y, name=None)` {#truncatemod}

Returns element-wise remainder of division. This emulates C semantics where

true, this follows C semantics in that the result here is consistent with a flooring divide. E.g. floor(x / y) * y + mod(x, y) = x.

NOTE: Mod supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: int32, int64, float32, float64.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.floormod(x, y, name=None)` {#floormod}

Returns element-wise remainder of division. When x < 0 xor y < 0 is

true, this follows Python semantics in that the result here is consistent with a flooring divide. E.g. floor(x / y) * y + mod(x, y) = x.

NOTE: FloorMod supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: int32, int64, float32, float64.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.mod(x, y, name=None)` {#mod}

Returns element-wise remainder of division. When x < 0 xor y < 0 is

true, this follows Python semantics in that the result here is consistent with a flooring divide. E.g. floor(x / y) * y + mod(x, y) = x.

NOTE: FloorMod supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: int32, int64, float32, float64.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.cross(a, b, name=None)` {#cross}

Compute the pairwise cross product.

a and b must be the same shape; they can either be simple 3-element vectors, or any shape where the innermost dimension is 3. In the latter case, each pair of corresponding 3-element vectors is cross-multiplied independently.

Args:

a: A Tensor. Must be one of the following types: float32, float64, int32, int64, uint8, int16, int8, uint16, half. A tensor containing 3-element vectors.
b: A Tensor. Must have the same type as a. Another tensor, of same type and shape as a.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as a. Pairwise cross product of the vectors in a and b.

Basic Math Functions

TensorFlow provides several operations that you can use to add basic mathematical functions to your graph.

`tf.add_n(inputs, name=None)` {#add_n}

Adds all input tensors element-wise.

Args:

inputs: A list of Tensor objects, each with same shape and type.
name: A name for the operation (optional).

Returns:

A Tensor of same shape and type as the elements of inputs.

Raises:

ValueError: If inputs don't all have same shape and dtype or the shape cannot be inferred.

`tf.abs(x, name=None)` {#abs}

Computes the absolute value of a tensor.

Given a tensor of real numbers x, this operation returns a tensor containing the absolute value of each element in x. For example, if x is an input element and y is an output element, this operation computes \(y = |x|\).

Args:

x: A Tensor or SparseTensor of type float32, float64, int32, or int64.
name: A name for the operation (optional).

Returns:

A Tensor or SparseTensor the same size and type as x with absolute values.

`tf.negative(x, name=None)` {#negative}

Computes numerical negative value element-wise.

I.e., (y = -x).

Args:

x: A Tensor or SparseTensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor or SparseTensor, respectively. Has the same type as x.

`tf.sign(x, name=None)` {#sign}

Returns an element-wise indication of the sign of a number.

y = sign(x) = -1 if x < 0; 0 if x == 0; 1 if x > 0.

For complex numbers, y = sign(x) = x / |x| if x != 0, otherwise y = 0.

Args:

x: A Tensor or SparseTensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor or SparseTensor, respectively. Has the same type as x.

`tf.reciprocal(x, name=None)` {#reciprocal}

Computes the reciprocal of x element-wise.

I.e., \(y = 1 / x\).

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.square(x, name=None)` {#square}

Computes square of x element-wise.

I.e., (y = x * x = x^2).

Args:

x: A Tensor or SparseTensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor or SparseTensor. Has the same type as x.

`tf.round(x, name=None)` {#round}

Rounds the values of a tensor to the nearest integer, element-wise.

Rounds half to even. Also known as bankers rounding. If you want to round according to the current system rounding mode use tf::cint. For example:

# 'a' is [0.9, 2.5, 2.3, 1.5, -4.5]
tf.round(a) ==> [ 1.0, 2.0, 2.0, 2.0, -4.0 ]

Args:

x: A Tensor of type float32 or float64.
name: A name for the operation (optional).

Returns:

A Tensor of same shape and type as x.

`tf.sqrt(x, name=None)` {#sqrt}

Computes square root of x element-wise.

I.e., (y = \sqrt{x} = x^{1/2}).

Args:

x: A Tensor or SparseTensor. Must be one of the following types: half, float32, float64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor or SparseTensor, respectively. Has the same type as x.

`tf.rsqrt(x, name=None)` {#rsqrt}

Computes reciprocal of square root of x element-wise.

I.e., \(y = 1 / \sqrt{x}\).

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.pow(x, y, name=None)` {#pow}

Computes the power of one value to another.

Given a tensor x and a tensor y, this operation computes \(x^y\) for corresponding elements in x and y. For example:

# tensor 'x' is [[2, 2], [3, 3]]
# tensor 'y' is [[8, 16], [2, 3]]
tf.pow(x, y) ==> [[256, 65536], [9, 27]]

Args:

x: A Tensor of type float32, float64, int32, int64, complex64, or complex128.
y: A Tensor of type float32, float64, int32, int64, complex64, or complex128.
name: A name for the operation (optional).

Returns:

A Tensor.

`tf.exp(x, name=None)` {#exp}

Computes exponential of x element-wise. \(y = e^x\).

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.expm1(x, name=None)` {#expm1}

Computes exponential of x - 1 element-wise.

I.e., \(y = (\exp x) - 1\).

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.log(x, name=None)` {#log}

Computes natural logarithm of x element-wise.

I.e., \(y = \log_e x\).

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.log1p(x, name=None)` {#log1p}

Computes natural logarithm of (1 + x) element-wise.

I.e., \(y = \log_e (1 + x)\).

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.ceil(x, name=None)` {#ceil}

Returns element-wise smallest integer in not less than x.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.floor(x, name=None)` {#floor}

Returns element-wise largest integer not greater than x.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.maximum(x, y, name=None)` {#maximum}

Returns the max of x and y (i.e. x > y ? x : y) element-wise.

NOTE: Maximum supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.minimum(x, y, name=None)` {#minimum}

Returns the min of x and y (i.e. x < y ? x : y) element-wise.

NOTE: Minimum supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.cos(x, name=None)` {#cos}

Computes cos of x element-wise.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.sin(x, name=None)` {#sin}

Computes sin of x element-wise.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.lbeta(x, name='lbeta')` {#lbeta}

Computes ln(|Beta(x)|), reducing along the last dimension.

Given one-dimensional z = [z_0,...,z_{K-1}], we define

Beta(z) = \prod_j Gamma(z_j) / Gamma(\sum_j z_j)

And for n + 1 dimensional x with shape [N1, ..., Nn, K], we define lbeta(x)[i1, ..., in] = Log(|Beta(x[i1, ..., in, :])|). In other words, the last dimension is treated as the z vector.

Note that if z = [u, v], then Beta(z) = int_0^1 t^{u-1} (1 - t)^{v-1} dt, which defines the traditional bivariate beta function.

Args:

x: A rank n + 1 Tensor with type float, or double.
name: A name for the operation (optional).

Returns:

The logarithm of |Beta(x)| reducing along the last dimension.

Raises:

ValueError: If x is empty with rank one or less.

`tf.tan(x, name=None)` {#tan}

Computes tan of x element-wise.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.acos(x, name=None)` {#acos}

Computes acos of x element-wise.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.asin(x, name=None)` {#asin}

Computes asin of x element-wise.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.atan(x, name=None)` {#atan}

Computes atan of x element-wise.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.lgamma(x, name=None)` {#lgamma}

Computes the log of the absolute value of Gamma(x) element-wise.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.digamma(x, name=None)` {#digamma}

Computes Psi, the derivative of Lgamma (the log of the absolute value of

Gamma(x)), element-wise.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.erf(x, name=None)` {#erf}

Computes the Gauss error function of x element-wise.

Args:

x: A Tensor of SparseTensor. Must be one of the following types: half, float32, float64.
name: A name for the operation (optional).

Returns:

A Tensor or SparseTensor, respectively. Has the same type as x.

`tf.erfc(x, name=None)` {#erfc}

Computes the complementary error function of x element-wise.

Args:

x: A Tensor. Must be one of the following types: half, float32, float64.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.squared_difference(x, y, name=None)` {#squared_difference}

Returns (x - y)(x - y) element-wise.

NOTE: SquaredDifference supports broadcasting. More about broadcasting here

Args:

x: A Tensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
y: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.igamma(a, x, name=None)` {#igamma}

Compute the lower regularized incomplete Gamma function Q(a, x).

The lower regularized incomplete Gamma function is defined as:

P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)

where

gamma(a, x) = int_{0}^{x} t^{a-1} exp(-t) dt

is the lower incomplete Gamma function.

Note, above Q(a, x) (Igammac) is the upper regularized complete Gamma function.

Args:

a: A Tensor. Must be one of the following types: float32, float64.
x: A Tensor. Must have the same type as a.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as a.

`tf.igammac(a, x, name=None)` {#igammac}

Compute the upper regularized incomplete Gamma function Q(a, x).

The upper regularized incomplete Gamma function is defined as:

Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)

where

Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt

is the upper incomplete Gama function.

Note, above P(a, x) (Igamma) is the lower regularized complete Gamma function.

Args:

a: A Tensor. Must be one of the following types: float32, float64.
x: A Tensor. Must have the same type as a.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as a.

`tf.zeta(x, q, name=None)` {#zeta}

Compute the Hurwitz zeta function \(\zeta(x, q)\).

The Hurwitz zeta function is defined as:

\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}

Args:

x: A Tensor. Must be one of the following types: float32, float64.
q: A Tensor. Must have the same type as x.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.polygamma(a, x, name=None)` {#polygamma}

Compute the polygamma function \(\psi^{(n)}(x)\).

The polygamma function is defined as:

\psi^{(n)}(x) = \frac{d^n}{dx^n} \psi(x)

where \(\psi(x)\) is the digamma function.

Args:

a: A Tensor. Must be one of the following types: float32, float64.
x: A Tensor. Must have the same type as a.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as a.

`tf.betainc(a, b, x, name=None)` {#betainc}

Compute the regularized incomplete beta integral \(I_x(a, b)\).

The regularized incomplete beta integral is defined as:

I_x(a, b) = \frac{B(x; a, b)}{B(a, b)}

where

B(x; a, b) = \int_0^x t^{a-1} (1 - t)^{b-1} dt

is the incomplete beta function and \(B(a, b)\) is the complete beta function.

Args:

a: A Tensor. Must be one of the following types: float32, float64.
b: A Tensor. Must have the same type as a.
x: A Tensor. Must have the same type as a.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as a.

`tf.rint(x, name=None)` {#rint}

Returns element-wise integer closest to x.

If the result is midway between two representable values, the even representable is chosen. For example:

rint(-1.5) ==> -2.0
rint(0.5000001) ==> 1.0
rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) ==> [-2., -2., -0., 0., 2., 2., 2.]

Args:

x: A Tensor. Must be one of the following types: float32, float64.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

Matrix Math Functions

TensorFlow provides several operations that you can use to add linear algebra functions on matrices to your graph.

`tf.diag(diagonal, name=None)` {#diag}

Returns a diagonal tensor with a given diagonal values.

Given a diagonal, this operation returns a tensor with the diagonal and everything else padded with zeros. The diagonal is computed as follows:

Assume diagonal has dimensions [D1,..., Dk], then the output is a tensor of rank 2k with dimensions [D1,..., Dk, D1,..., Dk] where:

output[i1,..., ik, i1,..., ik] = diagonal[i1, ..., ik] and 0 everywhere else.

For example:

# 'diagonal' is [1, 2, 3, 4]
tf.diag(diagonal) ==> [[1, 0, 0, 0]
                       [0, 2, 0, 0]
                       [0, 0, 3, 0]
                       [0, 0, 0, 4]]

Args:

diagonal: A Tensor. Must be one of the following types: float32, float64, int32, int64, complex64, complex128. Rank k tensor where k is at most 3.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as diagonal.

`tf.diag_part(input, name=None)` {#diag_part}

Returns the diagonal part of the tensor.

This operation returns a tensor with the diagonal part of the input. The diagonal part is computed as follows:

Assume input has dimensions [D1,..., Dk, D1,..., Dk], then the output is a tensor of rank k with dimensions [D1,..., Dk] where:

diagonal[i1,..., ik] = input[i1, ..., ik, i1,..., ik].

For example:

# 'input' is [[1, 0, 0, 0]
              [0, 2, 0, 0]
              [0, 0, 3, 0]
              [0, 0, 0, 4]]

tf.diag_part(input) ==> [1, 2, 3, 4]

Args:

input: A Tensor. Must be one of the following types: float32, float64, int32, int64, complex64, complex128. Rank k tensor where k is 2, 4, or 6.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as input. The extracted diagonal.

`tf.trace(x, name=None)` {#trace}

Compute the trace of a tensor x.

trace(x) returns the sum along the main diagonal of each inner-most matrix in x. If x is of rank k with shape [I, J, K, ..., L, M, N], then output is a tensor of rank k-2 with dimensions [I, J, K, ..., L] where

output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])

For example:

# 'x' is [[1, 2],
#         [3, 4]]
tf.trace(x) ==> 5

# 'x' is [[1,2,3],
#         [4,5,6],
#         [7,8,9]]
tf.trace(x) ==> 15

# 'x' is [[[1,2,3],
#          [4,5,6],
#          [7,8,9]],
#         [[-1,-2,-3],
#          [-4,-5,-6],
#          [-7,-8,-9]]]
tf.trace(x) ==> [15,-15]

Args:

x: tensor.
name: A name for the operation (optional).

Returns:

The trace of input tensor.

`tf.transpose(a, perm=None, name='transpose')` {#transpose}

Transposes a. Permutes the dimensions according to perm.

The returned tensor's dimension i will correspond to the input dimension perm[i]. If perm is not given, it is set to (n-1...0), where n is the rank of the input tensor. Hence by default, this operation performs a regular matrix transpose on 2-D input Tensors.

For example:

# 'x' is [[1 2 3]
#         [4 5 6]]
tf.transpose(x) ==> [[1 4]
                     [2 5]
                     [3 6]]

# Equivalently
tf.transpose(x, perm=[1, 0]) ==> [[1 4]
                                  [2 5]
                                  [3 6]]

# 'perm' is more useful for n-dimensional tensors, for n > 2
# 'x' is   [[[1  2  3]
#            [4  5  6]]
#           [[7  8  9]
#            [10 11 12]]]
# Take the transpose of the matrices in dimension-0
tf.transpose(x, perm=[0, 2, 1]) ==> [[[1  4]
                                      [2  5]
                                      [3  6]]

                                     [[7 10]
                                      [8 11]
                                      [9 12]]]

Args:

a: A Tensor.
perm: A permutation of the dimensions of a.
name: A name for the operation (optional).

Returns:

A transposed Tensor.

`tf.eye(num_rows, num_columns=None, batch_shape=None, dtype=tf.float32, name=None)` {#eye}

Construct an identity matrix, or a batch of matrices.

# Construct one identity matrix.
tf.eye(2)
==> [[1., 0.],
     [0., 1.]]

# Construct a batch of 3 identity matricies, each 2 x 2.
# batch_identity[i, :, :] is a 2 x 2 identity matrix, i = 0, 1, 2.
batch_identity = tf.eye(2, batch_shape=[3])

# Construct one 2 x 3 "identity" matrix
tf.eye(2, num_columns=3)
==> [[ 1.,  0.,  0.],
     [ 0.,  1.,  0.]]

Args:

num_rows: Non-negative int32 scalar Tensor giving the number of rows in each batch matrix.
num_columns: Optional non-negative int32 scalar Tensor giving the number of columns in each batch matrix. Defaults to num_rows.
batch_shape: int32 Tensor. If provided, returned Tensor will have leading batch dimensions of this shape.
dtype: The type of an element in the resulting Tensor
name: A name for this Op. Defaults to "eye".

Returns:

A Tensor of shape batch_shape + [num_rows, num_columns]

`tf.matrix_diag(diagonal, name=None)` {#matrix_diag}

Returns a batched diagonal tensor with a given batched diagonal values.

Given a diagonal, this operation returns a tensor with the diagonal and everything else padded with zeros. The diagonal is computed as follows:

Assume diagonal has k dimensions [I, J, K, ..., N], then the output is a tensor of rank k+1 with dimensions [I, J, K, ..., N, N]` where:

output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n].

For example:

# 'diagonal' is [[1, 2, 3, 4], [5, 6, 7, 8]]

and diagonal.shape = (2, 4)

tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0]
                                     [0, 2, 0, 0]
                                     [0, 0, 3, 0]
                                     [0, 0, 0, 4]],
                                    [[5, 0, 0, 0]
                                     [0, 6, 0, 0]
                                     [0, 0, 7, 0]
                                     [0, 0, 0, 8]]]

which has shape (2, 4, 4)

Args:

diagonal: A Tensor. Rank k, where k >= 1.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as diagonal. Rank k+1, with output.shape = diagonal.shape + [diagonal.shape[-1]].

`tf.matrix_diag_part(input, name=None)` {#matrix_diag_part}

Returns the batched diagonal part of a batched tensor.

This operation returns a tensor with the diagonal part of the batched input. The diagonal part is computed as follows:

Assume input has k dimensions [I, J, K, ..., M, N], then the output is a tensor of rank k - 1 with dimensions [I, J, K, ..., min(M, N)] where:

diagonal[i, j, k, ..., n] = input[i, j, k, ..., n, n].

The input must be at least a matrix.

For example:

# 'input' is [[[1, 0, 0, 0]
               [0, 2, 0, 0]
               [0, 0, 3, 0]
               [0, 0, 0, 4]],
              [[5, 0, 0, 0]
               [0, 6, 0, 0]
               [0, 0, 7, 0]
               [0, 0, 0, 8]]]

and input.shape = (2, 4, 4)

tf.matrix_diag_part(input) ==> [[1, 2, 3, 4], [5, 6, 7, 8]]

which has shape (2, 4)

Args:

input: A Tensor. Rank k tensor where k >= 2.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as input. The extracted diagonal(s) having shape diagonal.shape = input.shape[:-2] + [min(input.shape[-2:])].

`tf.matrix_band_part(input, num_lower, num_upper, name=None)` {#matrix_band_part}

Copy a tensor setting everything outside a central band in each innermost matrix

to zero.

The band part is computed as follows: Assume input has k dimensions [I, J, K, ..., M, N], then the output is a tensor with the same shape where

band[i, j, k, ..., m, n] = in_band(m, n) * input[i, j, k, ..., m, n].

The indicator function

in_band(m, n) = (num_lower < 0 || (m-n) <= num_lower)) && (num_upper < 0 || (n-m) <= num_upper).

For example:

# if 'input' is [[ 0,  1,  2, 3]
                 [-1,  0,  1, 2]
                 [-2, -1,  0, 1]
                 [-3, -2, -1, 0]],

tf.matrix_band_part(input, 1, -1) ==> [[ 0,  1,  2, 3]
                                       [-1,  0,  1, 2]
                                       [ 0, -1,  0, 1]
                                       [ 0,  0, -1, 0]],

tf.matrix_band_part(input, 2, 1) ==> [[ 0,  1,  0, 0]
                                      [-1,  0,  1, 0]
                                      [-2, -1,  0, 1]
                                      [ 0, -2, -1, 0]]

Useful special cases:

 tf.matrix_band_part(input, 0, -1) ==> Upper triangular part.
 tf.matrix_band_part(input, -1, 0) ==> Lower triangular part.
 tf.matrix_band_part(input, 0, 0) ==> Diagonal.

Args:

input: A Tensor. Rank k tensor.
num_lower: A Tensor of type int64. 0-D tensor. Number of subdiagonals to keep. If negative, keep entire lower triangle.
num_upper: A Tensor of type int64. 0-D tensor. Number of superdiagonals to keep. If negative, keep entire upper triangle.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as input. Rank k tensor of the same shape as input. The extracted banded tensor.

`tf.matrix_set_diag(input, diagonal, name=None)` {#matrix_set_diag}

Returns a batched matrix tensor with new batched diagonal values.

Given input and diagonal, this operation returns a tensor with the same shape and values as input, except for the main diagonal of the innermost matrices. These will be overwritten by the values in diagonal.

The output is computed as follows:

Assume input has k+1 dimensions [I, J, K, ..., M, N] and diagonal has k dimensions [I, J, K, ..., min(M, N)]. Then the output is a tensor of rank k+1 with dimensions [I, J, K, ..., M, N] where:

output[i, j, k, ..., m, n] = diagonal[i, j, k, ..., n] for m == n.
output[i, j, k, ..., m, n] = input[i, j, k, ..., m, n] for m != n.

Args:

input: A Tensor. Rank k+1, where k >= 1.
diagonal: A Tensor. Must have the same type as input. Rank k, where k >= 1.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as input. Rank k+1, with output.shape = input.shape.

`tf.matrix_transpose(a, name='matrix_transpose')` {#matrix_transpose}

Transposes last two dimensions of tensor a.

For example:

# Matrix with no batch dimension.
# 'x' is [[1 2 3]
#         [4 5 6]]
tf.matrix_transpose(x) ==> [[1 4]
                                 [2 5]
                                 [3 6]]

# Matrix with two batch dimensions.
# x.shape is [1, 2, 3, 4]
# tf.matrix_transpose(x) is shape [1, 2, 4, 3]

Args:

a: A Tensor with rank >= 2.
name: A name for the operation (optional).

Returns:

A transposed batch matrix Tensor.

Raises:

ValueError: If a is determined statically to have rank < 2.

`tf.matmul(a, b, transpose_a=False, transpose_b=False, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False, name=None)` {#matmul}

Multiplies matrix a by matrix b, producing a * b.

The inputs must be matrices (or tensors of rank > 2, representing batches of matrices), with matching inner dimensions, possibly after transposition.

Both matrices must be of the same type. The supported types are: float16, float32, float64, int32, complex64, complex128.

Either matrix can be transposed or adjointed (conjugated and transposed) on the fly by setting one of the corresponding flag to True. These are False by default.

If one or both of the matrices contain a lot of zeros, a more efficient multiplication algorithm can be used by setting the corresponding a_is_sparse or b_is_sparse flag to True. These are False by default. This optimization is only available for plain matrices (rank-2 tensors) with datatypes bfloat16 or float32.

For example:

# 2-D tensor `a`
a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3]) => [[1. 2. 3.]
                                                      [4. 5. 6.]]
# 2-D tensor `b`
b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2]) => [[7. 8.]
                                                         [9. 10.]
                                                         [11. 12.]]
c = tf.matmul(a, b) => [[58 64]
                        [139 154]]


# 3-D tensor `a`
a = tf.constant(np.arange(1, 13, dtype=np.int32),
                shape=[2, 2, 3])                  => [[[ 1.  2.  3.]
                                                       [ 4.  5.  6.]],
                                                      [[ 7.  8.  9.]
                                                       [10. 11. 12.]]]

# 3-D tensor `b`
b = tf.constant(np.arange(13, 25, dtype=np.int32),
                shape=[2, 3, 2])                   => [[[13. 14.]
                                                        [15. 16.]
                                                        [17. 18.]],
                                                       [[19. 20.]
                                                        [21. 22.]
                                                        [23. 24.]]]
c = tf.matmul(a, b) => [[[ 94 100]
                         [229 244]],
                        [[508 532]
                         [697 730]]]

Args:

a: Tensor of type float16, float32, float64, int32, complex64, complex128 and rank > 1.
b: Tensor with same type and rank as a.
transpose_a: If True, a is transposed before multiplication.
transpose_b: If True, b is transposed before multiplication.
adjoint_a: If True, a is conjugated and transposed before multiplication.
adjoint_b: If True, b is conjugated and transposed before multiplication.
a_is_sparse: If True, a is treated as a sparse matrix.
b_is_sparse: If True, b is treated as a sparse matrix.
name: Name for the operation (optional).

Returns:

A Tensor of the same type as a and b where each inner-most matrix is the product of the corresponding matrices in a and b, e.g. if all transpose or adjoint attributes are False:

output[..., i, j] = sum_k (a[..., i, k] * b[..., k, j]), for all indices i, j.

Note: This is matrix product, not element-wise product.

Raises:

ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b are both set to True.

`tf.norm(tensor, ord='euclidean', axis=None, keep_dims=False, name=None)` {#norm}

Computes the norm of vectors, matrices, and tensors.

This function can compute 3 different matrix norms (Frobenius, 1-norm, and inf-norm) and up to 9218868437227405311 different vectors norms.

Args:

tensor: Tensor of types float32, float64, complex64, complex128
ord: Order of the norm. Supported values are 'fro', 'euclidean', 0, 1, 2, np.infand any positive real number yielding the corresponding p-norm. Default is 'euclidean' which is equivalent to Frobenius norm iftensoris a matrix and equivalent to 2-norm for vectors. Some restrictions apply, a) The Frobenius normfrois not defined for vectors, b) If axis is a 2-tuple (matrix-norm), only 'euclidean', 'fro',1, np.infare supported. See the description ofaxis` on how to compute norms for a batch of vectors or matrices stored in a tensor.
axis: If axis is None (the default), the input is considered a vector and a single vector norm is computed over the entire set of values in the tensor, i.e. norm(tensor, ord=ord) is equivalent to norm(reshape(tensor, [-1]), ord=ord). If axis is a Python integer, the input is considered a batch of vectors, and axist determines the axis in tensor over which to compute vector norms. If axis is a 2-tuple of Python integers it is considered a batch of matrices and axis determines the axes in tensor over which to compute a matrix norm. Negative indices are supported. Example: If you are passing a tensor that can be either a matrix or a batch of matrices at runtime, pass axis=[-2,-1] instead of axis=None to make sure that matrix norms are computed.
keep_dims: If True, the axis indicated in axis are kept with size 1. Otherwise, the dimensions in axis are removed from the output shape.
name: The name of the op.

Returns:

output: A Tensor of the same type as tensor, containing the vector or matrix norms. If keep_dims is True then the rank of output is equal to the rank of tensor. Otherwise, if axis is none the output is a scalar, if axis is an integer, the rank of output is one less than the rank of tensor, if axis is a 2-tuple the rank of output is two less than the rank of tensor.

Raises:

ValueError: If ord or axis is invalid.

@compatibility(numpy) Mostly equivalent to numpy.linalg.norm. Not supported: ord <= 0, 2-norm for matrices, nuclear norm.

Other differences:

a) If axis is None, treats the the flattened tensor as a vector regardless of rank. b) Explicitly supports 'euclidean' norm as the default, including for higher order tensors. @end_compatibility

`tf.matrix_determinant(input, name=None)` {#matrix_determinant}

Computes the determinant of one ore more square matrices.

The input is a tensor of shape [..., M, M] whose inner-most 2 dimensions form square matrices. The output is a tensor containing the determinants for all input submatrices [..., :, :].

Args:

input: A Tensor. Must be one of the following types: float32, float64. Shape is [..., M, M].
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as input. Shape is [...].

`tf.matrix_inverse(input, adjoint=None, name=None)` {#matrix_inverse}

Computes the inverse of one or more square invertible matrices or their

adjoints (conjugate transposes).

The input is a tensor of shape [..., M, M] whose inner-most 2 dimensions form square matrices. The output is a tensor of the same shape as the input containing the inverse for all input submatrices [..., :, :].

The op uses LU decomposition with partial pivoting to compute the inverses.

If a matrix is not invertible there is no guarantee what the op does. It may detect the condition and raise an exception or it may simply return a garbage result.

Args:

input: A Tensor. Must be one of the following types: float64, float32. Shape is [..., M, M].
adjoint: An optional bool. Defaults to False.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as input. Shape is [..., M, M].

@compatibility(numpy) Equivalent to np.linalg.inv @end_compatibility

`tf.cholesky(input, name=None)` {#cholesky}

Computes the Cholesky decomposition of one or more square matrices.

The input is a tensor of shape [..., M, M] whose inner-most 2 dimensions form square matrices, with the same constraints as the single matrix Cholesky decomposition above. The output is a tensor of the same shape as the input containing the Cholesky decompositions for all input submatrices [..., :, :].

Args:

input: A Tensor. Must be one of the following types: float64, float32. Shape is [..., M, M].
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as input. Shape is [..., M, M].

`tf.cholesky_solve(chol, rhs, name=None)` {#cholesky_solve}

Solves systems of linear eqns A X = RHS, given Cholesky factorizations.

# Solve 10 separate 2x2 linear systems:
A = ... # shape 10 x 2 x 2
RHS = ... # shape 10 x 2 x 1
chol = tf.cholesky(A)  # shape 10 x 2 x 2
X = tf.cholesky_solve(chol, RHS)  # shape 10 x 2 x 1
# tf.matmul(A, X) ~ RHS
X[3, :, 0]  # Solution to the linear system A[3, :, :] x = RHS[3, :, 0]

# Solve five linear systems (K = 5) for every member of the length 10 batch.
A = ... # shape 10 x 2 x 2
RHS = ... # shape 10 x 2 x 5
...
X[3, :, 2]  # Solution to the linear system A[3, :, :] x = RHS[3, :, 2]

Args:

chol: A Tensor. Must be float32 or float64, shape is [..., M, M]. Cholesky factorization of A, e.g. chol = tf.cholesky(A). For that reason, only the lower triangular parts (including the diagonal) of the last two dimensions of chol are used. The strictly upper part is assumed to be zero and not accessed.
rhs: A Tensor, same type as chol, shape is [..., M, K].
name: A name to give this Op. Defaults to cholesky_solve.

Returns:

Solution to A x = rhs, shape [..., M, K].

`tf.matrix_solve(matrix, rhs, adjoint=None, name=None)` {#matrix_solve}

Solves systems of linear equations.

Matrix is a tensor of shape [..., M, M] whose inner-most 2 dimensions form square matrices. Rhs is a tensor of shape [..., M, K]. The output is a tensor shape [..., M, K]. If adjoint is False then each output matrix satisfies matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]. If adjoint is True then each output matrix satisfies adjoint(matrix[..., :, :]) * output[..., :, :] = rhs[..., :, :].

Args:

matrix: A Tensor. Must be one of the following types: float64, float32, complex64, complex128. Shape is [..., M, M].
rhs: A Tensor. Must have the same type as matrix. Shape is [..., M, K].
adjoint: An optional bool. Defaults to False. Boolean indicating whether to solve with matrix or its (block-wise) adjoint.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as matrix. Shape is [..., M, K].

`tf.matrix_triangular_solve(matrix, rhs, lower=None, adjoint=None, name=None)` {#matrix_triangular_solve}

Solves systems of linear equations with upper or lower triangular matrices by

backsubstitution.

matrix is a tensor of shape [..., M, M] whose inner-most 2 dimensions form square matrices. If lower is True then the strictly upper triangular part of each inner-most matrix is assumed to be zero and not accessed. If lower is False then the strictly lower triangular part of each inner-most matrix is assumed to be zero and not accessed. rhs is a tensor of shape [..., M, K].

The output is a tensor of shape [..., M, K]. If adjoint is True then the innermost matrices in outputsatisfy matrix equationsmatrix[..., :, :] * output[..., :, :] = rhs[..., :, :]. If adjointisFalsethen the strictly then the innermost matrices inoutputsatisfy matrix equationsadjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]`.

Args:

matrix: A Tensor. Must be one of the following types: float64, float32. Shape is [..., M, M].
rhs: A Tensor. Must have the same type as matrix. Shape is [..., M, K].
lower: An optional bool. Defaults to True. Boolean indicating whether the innermost matrices in matrix are lower or upper triangular.
adjoint: An optional bool. Defaults to False. Boolean indicating whether to solve with matrix or its (block-wise) adjoint.

@compatibility(numpy) Equivalent to np.linalg.triangular_solve @end_compatibility
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as matrix. Shape is [..., M, K].

`tf.matrix_solve_ls(matrix, rhs, l2_regularizer=0.0, fast=True, name=None)` {#matrix_solve_ls}

Solves one or more linear least-squares problems.

matrix is a tensor of shape [..., M, N] whose inner-most 2 dimensions form M-by-N matrices. Rhs is a tensor of shape [..., M, K] whose inner-most 2 dimensions form M-by-K matrices. The computed output is a Tensor of shape [..., N, K] whose inner-most 2 dimensions form M-by-K matrices that solve the equations matrix[..., :, :] * output[..., :, :] = rhs[..., :, :] in the least squares sense.

Below we will use the following notation for each pair of matrix and right-hand sides in the batch:

matrix=\(A \in \Re^{m \times n}\), rhs=\(B \in \Re^{m \times k}\), output=\(X \in \Re^{n \times k}\), l2_regularizer=\(\lambda\).

If fast is True, then the solution is computed by solving the normal equations using Cholesky decomposition. Specifically, if \(m \ge n\) then \(X = (A^T A + \lambda I)^{-1} A^T B\), which solves the least-squares problem \(X = \mathrm{argmin}_{Z \in \Re^{n \times k}} ||A Z - B||_F^2 + \lambda ||Z||F^2\). If \(m \lt n\) then output is computed as \(X = A^T (A A^T + \lambda I)^{-1} B\), which (for \(\lambda = 0\)) is the minimum-norm solution to the under-determined linear system, i.e. \(X = \mathrm{argmin}{Z \in \Re^{n \times k}} ||Z||F^2 \), subject to \(A Z = B\). Notice that the fast path is only numerically stable when \(A\) is numerically full rank and has a condition number \(\mathrm{cond}(A) \lt \frac{1}{\sqrt{\epsilon{mach}}}\) or\(\lambda\) is sufficiently large.

If fast is False an algorithm based on the numerically robust complete orthogonal decomposition is used. This computes the minimum-norm least-squares solution, even when \(A\) is rank deficient. This path is typically 6-7 times slower than the fast path. If fast is False then l2_regularizer is ignored.

Args:

matrix: Tensor of shape [..., M, N].
rhs: Tensor of shape [..., M, K].
l2_regularizer: 0-D double Tensor. Ignored if fast=False.
fast: bool. Defaults to True.
name: string, optional name of the operation.

Returns:

output: Tensor of shape [..., N, K] whose inner-most 2 dimensions form M-by-K matrices that solve the equations matrix[..., :, :] * output[..., :, :] = rhs[..., :, :] in the least squares sense.

`tf.qr(input, full_matrices=None, name=None)` {#qr}

Computes the QR decompositions of one or more matrices.

Computes the QR decomposition of each inner matrix in tensor such that tensor[..., :, :] = q[..., :, :] * r[..., :,:])

# a is a tensor.
# q is a tensor of orthonormal matrices.
# r is a tensor of upper triangular matrices.
q, r = qr(a)
q_full, r_full = qr(a, full_matrices=True)

Args:

input: A Tensor. Must be one of the following types: float64, float32, complex64, complex128. A tensor of shape [..., M, N] whose inner-most 2 dimensions form matrices of size [M, N]. Let P be the minimum of M and N.
full_matrices: An optional bool. Defaults to False. If true, compute full-sized q and r. If false (the default), compute only the leading P columns of q.
name: A name for the operation (optional).

Returns:

A tuple of Tensor objects (q, r).

q: A Tensor. Has the same type as input. Orthonormal basis for range of a. If full_matrices is False then shape is [..., M, P]; if full_matrices is True then shape is [..., M, M].
r: A Tensor. Has the same type as input. Triangular factor. If full_matrices is False then shape is [..., P, N]. If full_matrices is True then shape is [..., M, N].

`tf.self_adjoint_eig(tensor, name=None)` {#self_adjoint_eig}

Computes the eigen decomposition of a batch of self-adjoint matrices.

Computes the eigenvalues and eigenvectors of the innermost N-by-N matrices in tensor such that tensor[...,:,:] * v[..., :,i] = e[..., i] * v[...,:,i], for i=0...N-1.

Args:

tensor: Tensor of shape [..., N, N]. Only the lower triangular part of each inner inner matrix is referenced.
name: string, optional name of the operation.

Returns:

e: Eigenvalues. Shape is [..., N].
v: Eigenvectors. Shape is [..., N, N]. The columns of the inner most matrices contain eigenvectors of the corresponding matrices in tensor

`tf.self_adjoint_eigvals(tensor, name=None)` {#self_adjoint_eigvals}

Computes the eigenvalues of one or more self-adjoint matrices.

Args:

tensor: Tensor of shape [..., N, N].
name: string, optional name of the operation.

Returns:

e: Eigenvalues. Shape is [..., N]. The vector e[..., :] contains the N eigenvalues of tensor[..., :, :].

`tf.svd(tensor, full_matrices=False, compute_uv=True, name=None)` {#svd}

Computes the singular value decompositions of one or more matrices.

Computes the SVD of each inner matrix in tensor such that tensor[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(v[..., :, :])

# a is a tensor.
# s is a tensor of singular values.
# u is a tensor of left singular vectors.
#v is a tensor of right singular vectors.
s, u, v = svd(a)
s = svd(a, compute_uv=False)

Args:

tensor: Tensor of shape [..., M, N]. Let P be the minimum of M and N.
full_matrices: If true, compute full-sized u and v. If false (the default), compute only the leading P singular vectors. Ignored if compute_uv is False.
compute_uv: If True then left and right singular vectors will be computed and returned in u and v, respectively. Otherwise, only the singular values will be computed, which can be significantly faster.
name: string, optional name of the operation.

Returns:

s: Singular values. Shape is [..., P].
u: Right singular vectors. If full_matrices is False (default) then shape is [..., M, P]; if full_matrices is True then shape is [..., M, M]. Not returned if compute_uv is False.
v: Left singular vectors. If full_matrices is False (default) then shape is [..., N, P]. If full_matrices is True then shape is [..., N, N]. Not returned if compute_uv is False.

@compatibility(numpy) Mostly equivalent to numpy.linalg.svd, except that the order of output arguments here is s, u, v when compute_uv is True, as opposed to u, s, v for numpy.linalg.svd. @end_compatibility

Tensor Math Function

TensorFlow provides operations that you can use to add tensor functions to your graph.

`tf.tensordot(a, b, axes, name=None)` {#tensordot}

Tensor contraction of a and b along specified axes.

Tensordot (also known as tensor contraction) sums the product of elements from a and b over the indices specified by a_axes and b_axes. The lists a_axes and b_axes specify those pairs of axes along which to contract the tensors. The axis a_axes[i] of a must have the same dimension as axis b_axes[i] of b for all i in range(0, len(a_axes)). The lists a_axes and b_axes must have identical length and consist of unique integers that specify valid axes for each of the tensors.

This operation corresponds to numpy.tensordot(a, b, axes).

Example 1: When a and b are matrices (order 2), the case axes = 1 is equivalent to matrix multiplication.

Example 2: When a and b are matrices (order 2), the case axes = [[1], [0]] is equivalent to matrix multiplication.

Example 3: Suppose that \(a_ijk\) and \(b_lmn\) represent two tensors of order 3. Then, contract(a, b, [0], [2]) is the order 4 tensor \(c_{jklm}\) whose entry corresponding to the indices \((j,k,l,m)\) is given by:

\( c_{jklm} = \sum_i a_{ijk} b_{lmi} \).

In general, order(c) = order(a) + order(b) - 2*len(axes[0]).

Args:

a: Tensor of type float32 or float64.
b: Tensor with the same type as a.
axes: Either a scalar N, or a list or an int32 Tensor of shape [2, k]. If axes is a scalar, sum over the last N axes of a and the first N axes of b in order. If axes is a list or Tensor the first and second row contain the set of unique integers specifying axes along which the contraction is computed, for a and b, respectively. The number of axes for a and b must be equal.
name: A name for the operation (optional).

Returns:

A Tensor with the same type as a.

Raises:

ValueError: If the shapes of a, b, and axes are incompatible.
IndexError: If the values in axes exceed the rank of the corresponding tensor.

Complex Number Functions

TensorFlow provides several operations that you can use to add complex number functions to your graph.

`tf.complex(real, imag, name=None)` {#complex}

Converts two real numbers to a complex number.

Given a tensor real representing the real part of a complex number, and a tensor imag representing the imaginary part of a complex number, this operation returns complex numbers elementwise of the form \(a + bj\), where a represents the real part and b represents the imag part.

The input tensors real and imag must have the same shape.

For example:

# tensor 'real' is [2.25, 3.25]
# tensor `imag` is [4.75, 5.75]
tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]

Args:

real: A Tensor. Must be one of the following types: float32, float64.
imag: A Tensor. Must have the same type as real.
name: A name for the operation (optional).

Returns:

A Tensor of type complex64 or complex128.

`tf.conj(x, name=None)` {#conj}

Returns the complex conjugate of a complex number.

Given a tensor input of complex numbers, this operation returns a tensor of complex numbers that are the complex conjugate of each element in input. The complex numbers in input must be of the form \(a + bj\), where a is the real part and b is the imaginary part.

The complex conjugate returned by this operation is of the form \(a - bj\).

For example:

# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]

If x is real, it is returned unchanged.

Args:

x: Tensor to conjugate. Must have numeric type.
name: A name for the operation (optional).

Returns:

A Tensor that is the conjugate of x (with the same type).

Raises:

TypeError: If x is not a numeric tensor.

`tf.imag(input, name=None)` {#imag}

Returns the imaginary part of a complex number.

Given a tensor input of complex numbers, this operation returns a tensor of type float32 or float64 that is the imaginary part of each element in input. All elements in input must be complex numbers of the form (a + bj), where a is the real part and b is the imaginary part returned by this operation.

For example:

# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.imag(input) ==> [4.75, 5.75]

Args:

input: A Tensor. Must be one of the following types: complex64, complex128.
name: A name for the operation (optional).

Returns:

A Tensor of type float32 or float64.

`tf.real(input, name=None)` {#real}

Returns the real part of a complex number.

Given a tensor input of complex numbers, this operation returns a tensor of type float32 or float64 that is the real part of each element in input. All elements in input must be complex numbers of the form \(a + bj\), where a is the real part returned by this operation and b is the imaginary part.

For example:

# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.real(input) ==> [-2.25, 3.25]

If input is already real, it is returned unchanged.

Args:

input: A Tensor. Must have numeric type.
name: A name for the operation (optional).

Returns:

A Tensor of type float32 or float64.

Fourier Transform Functions

TensorFlow provides several operations that you can use to add discrete Fourier transform functions to your graph.

`tf.fft(input, name=None)` {#fft}

Compute the 1-dimensional discrete Fourier Transform over the inner-most

dimension of input.

Args:

input: A Tensor of type complex64. A complex64 tensor.
name: A name for the operation (optional).

Returns:

A Tensor of type complex64. A complex64 tensor of the same shape as input. The inner-most dimension of input is replaced with its 1D Fourier Transform.

`tf.ifft(input, name=None)` {#ifft}

Compute the inverse 1-dimensional discrete Fourier Transform over the inner-most

dimension of input.

Args:

input: A Tensor of type complex64. A complex64 tensor.
name: A name for the operation (optional).

Returns:

A Tensor of type complex64. A complex64 tensor of the same shape as input. The inner-most dimension of input is replaced with its inverse 1D Fourier Transform.

`tf.fft2d(input, name=None)` {#fft2d}

Compute the 2-dimensional discrete Fourier Transform over the inner-most

2 dimensions of input.

Args:

input: A Tensor of type complex64. A complex64 tensor.
name: A name for the operation (optional).

Returns:

A Tensor of type complex64. A complex64 tensor of the same shape as input. The inner-most 2 dimensions of input are replaced with their 2D Fourier Transform.

@compatibility(numpy) Equivalent to np.fft2 @end_compatibility

`tf.ifft2d(input, name=None)` {#ifft2d}

Compute the inverse 2-dimensional discrete Fourier Transform over the inner-most

2 dimensions of input.

Args:

input: A Tensor of type complex64. A complex64 tensor.
name: A name for the operation (optional).

Returns:

A Tensor of type complex64. A complex64 tensor of the same shape as input. The inner-most 2 dimensions of input are replaced with their inverse 2D Fourier Transform.

@compatibility(numpy) Equivalent to np.ifft2 @end_compatibility

`tf.fft3d(input, name=None)` {#fft3d}

Compute the 3-dimensional discrete Fourier Transform over the inner-most 3

dimensions of input.

Args:

input: A Tensor of type complex64. A complex64 tensor.
name: A name for the operation (optional).

Returns:

A Tensor of type complex64. A complex64 tensor of the same shape as input. The inner-most 3 dimensions of input are replaced with their 3D Fourier Transform.

@compatibility(numpy) Equivalent to np.fft3 @end_compatibility

`tf.ifft3d(input, name=None)` {#ifft3d}

Compute the inverse 3-dimensional discrete Fourier Transform over the inner-most

3 dimensions of input.

Args:

input: A Tensor of type complex64. A complex64 tensor.
name: A name for the operation (optional).

Returns:

A Tensor of type complex64. A complex64 tensor of the same shape as input. The inner-most 3 dimensions of input are replaced with their inverse 3D Fourier Transform.

@compatibility(numpy) Equivalent to np.fft3 @end_compatibility

Reduction

TensorFlow provides several operations that you can use to perform common math computations that reduce various dimensions of a tensor.

`tf.reduce_sum(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_sum}

Computes the sum of elements across dimensions of a tensor.

Reduces input_tensor along the dimensions given in axis. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keep_dims is true, the reduced dimensions are retained with length 1.

If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.

For example:

# 'x' is [[1, 1, 1]
#         [1, 1, 1]]
tf.reduce_sum(x) ==> 6
tf.reduce_sum(x, 0) ==> [2, 2, 2]
tf.reduce_sum(x, 1) ==> [3, 3]
tf.reduce_sum(x, 1, keep_dims=True) ==> [[3], [3]]
tf.reduce_sum(x, [0, 1]) ==> 6

Args:

input_tensor: The tensor to reduce. Should have numeric type.
axis: The dimensions to reduce. If None (the default), reduces all dimensions.
keep_dims: If true, retains reduced dimensions with length 1.
name: A name for the operation (optional).
reduction_indices: The old (deprecated) name for axis.

Returns:

The reduced tensor.

@compatibility(numpy) Equivalent to np.sum @end_compatibility

`tf.reduce_prod(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_prod}

Computes the product of elements across dimensions of a tensor.

Reduces input_tensor along the dimensions given in axis. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keep_dims is true, the reduced dimensions are retained with length 1.

If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.

Args:

input_tensor: The tensor to reduce. Should have numeric type.
axis: The dimensions to reduce. If None (the default), reduces all dimensions.
keep_dims: If true, retains reduced dimensions with length 1.
name: A name for the operation (optional).
reduction_indices: The old (deprecated) name for axis.

Returns:

The reduced tensor.

@compatibility(numpy) Equivalent to np.prod @end_compatibility

`tf.reduce_min(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_min}

Computes the minimum of elements across dimensions of a tensor.

Reduces input_tensor along the dimensions given in axis. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keep_dims is true, the reduced dimensions are retained with length 1.

If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.

Args:

input_tensor: The tensor to reduce. Should have numeric type.
axis: The dimensions to reduce. If None (the default), reduces all dimensions.
keep_dims: If true, retains reduced dimensions with length 1.
name: A name for the operation (optional).
reduction_indices: The old (deprecated) name for axis.

Returns:

The reduced tensor.

@compatibility(numpy) Equivalent to np.min @end_compatibility

`tf.reduce_max(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_max}

Computes the maximum of elements across dimensions of a tensor.

Reduces input_tensor along the dimensions given in axis. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keep_dims is true, the reduced dimensions are retained with length 1.

If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.

Args:

input_tensor: The tensor to reduce. Should have numeric type.
axis: The dimensions to reduce. If None (the default), reduces all dimensions.
keep_dims: If true, retains reduced dimensions with length 1.
name: A name for the operation (optional).
reduction_indices: The old (deprecated) name for axis.

Returns:

The reduced tensor.

@compatibility(numpy) Equivalent to np.max @end_compatibility

`tf.reduce_mean(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_mean}

Computes the mean of elements across dimensions of a tensor.

Reduces input_tensor along the dimensions given in axis. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keep_dims is true, the reduced dimensions are retained with length 1.

If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.

For example:

# 'x' is [[1., 1.]
#         [2., 2.]]
tf.reduce_mean(x) ==> 1.5
tf.reduce_mean(x, 0) ==> [1.5, 1.5]
tf.reduce_mean(x, 1) ==> [1.,  2.]

Args:

input_tensor: The tensor to reduce. Should have numeric type.
axis: The dimensions to reduce. If None (the default), reduces all dimensions.
keep_dims: If true, retains reduced dimensions with length 1.
name: A name for the operation (optional).
reduction_indices: The old (deprecated) name for axis.

Returns:

The reduced tensor.

@compatibility(numpy) Equivalent to np.mean @end_compatibility

`tf.reduce_all(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_all}

Computes the "logical and" of elements across dimensions of a tensor.

Reduces input_tensor along the dimensions given in axis. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keep_dims is true, the reduced dimensions are retained with length 1.

If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.

For example:

# 'x' is [[True,  True]
#         [False, False]]
tf.reduce_all(x) ==> False
tf.reduce_all(x, 0) ==> [False, False]
tf.reduce_all(x, 1) ==> [True, False]

Args:

input_tensor: The boolean tensor to reduce.
axis: The dimensions to reduce. If None (the default), reduces all dimensions.
keep_dims: If true, retains reduced dimensions with length 1.
name: A name for the operation (optional).
reduction_indices: The old (deprecated) name for axis.

Returns:

The reduced tensor.

@compatibility(numpy) Equivalent to np.all @end_compatibility

`tf.reduce_any(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_any}

Computes the "logical or" of elements across dimensions of a tensor.

Reduces input_tensor along the dimensions given in axis. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keep_dims is true, the reduced dimensions are retained with length 1.

If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.

For example:

# 'x' is [[True,  True]
#         [False, False]]
tf.reduce_any(x) ==> True
tf.reduce_any(x, 0) ==> [True, True]
tf.reduce_any(x, 1) ==> [True, False]

Args:

input_tensor: The boolean tensor to reduce.
axis: The dimensions to reduce. If None (the default), reduces all dimensions.
keep_dims: If true, retains reduced dimensions with length 1.
name: A name for the operation (optional).
reduction_indices: The old (deprecated) name for axis.

Returns:

The reduced tensor.

@compatibility(numpy) Equivalent to np.any @end_compatibility

`tf.reduce_logsumexp(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_logsumexp}

Computes log(sum(exp(elements across dimensions of a tensor))).

Reduces input_tensor along the dimensions given in axis. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keep_dims is true, the reduced dimensions are retained with length 1.

If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.

This function is more numerically stable than log(sum(exp(input))). It avoids overflows caused by taking the exp of large inputs and underflows caused by taking the log of small inputs.

For example:

# 'x' is [[0, 0, 0]]
#         [0, 0, 0]]
tf.reduce_logsumexp(x) ==> log(6)
tf.reduce_logsumexp(x, 0) ==> [log(2), log(2), log(2)]
tf.reduce_logsumexp(x, 1) ==> [log(3), log(3)]
tf.reduce_logsumexp(x, 1, keep_dims=True) ==> [[log(3)], [log(3)]]
tf.reduce_logsumexp(x, [0, 1]) ==> log(6)

Args:

input_tensor: The tensor to reduce. Should have numeric type.
axis: The dimensions to reduce. If None (the default), reduces all dimensions.
keep_dims: If true, retains reduced dimensions with length 1.
name: A name for the operation (optional).
reduction_indices: The old (deprecated) name for axis.

Returns:

The reduced tensor.

`tf.count_nonzero(input_tensor, axis=None, keep_dims=False, dtype=tf.int64, name=None, reduction_indices=None)` {#count_nonzero}

Computes number of nonzero elements across dimensions of a tensor.

Reduces input_tensor along the dimensions given in axis. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keep_dims is true, the reduced dimensions are retained with length 1.

If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.

NOTE Floating point comparison to zero is done by exact floating point equality check. Small values are not rounded to zero for purposes of the nonzero check.

For example:

# 'x' is [[0, 1, 0]
#         [1, 1, 0]]
tf.count_nonzero(x) ==> 3
tf.count_nonzero(x, 0) ==> [1, 2, 0]
tf.count_nonzero(x, 1) ==> [1, 2]
tf.count_nonzero(x, 1, keep_dims=True) ==> [[1], [2]]
tf.count_nonzero(x, [0, 1]) ==> 3

Args:

input_tensor: The tensor to reduce. Should be of numeric type, or bool.
axis: The dimensions to reduce. If None (the default), reduces all dimensions.
keep_dims: If true, retains reduced dimensions with length 1.
dtype: The output dtype; defaults to tf.int64.
name: A name for the operation (optional).
reduction_indices: The old (deprecated) name for axis.

Returns:

The reduced tensor (number of nonzero values).

`tf.accumulate_n(inputs, shape=None, tensor_dtype=None, name=None)` {#accumulate_n}

Returns the element-wise sum of a list of tensors.

Optionally, pass shape and tensor_dtype for shape and type checking, otherwise, these are inferred.

NOTE: This operation is not differentiable and cannot be used if inputs depend on trainable variables. Please use tf.add_n for such cases.

For example:

# tensor 'a' is [[1, 2], [3, 4]]
# tensor `b` is [[5, 0], [0, 6]]
tf.accumulate_n([a, b, a]) ==> [[7, 4], [6, 14]]

# Explicitly pass shape and type
tf.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)
  ==> [[7, 4], [6, 14]]

Args:

inputs: A list of Tensor objects, each with same shape and type.
shape: Shape of elements of inputs.
tensor_dtype: The type of inputs.
name: A name for the operation (optional).

Returns:

A Tensor of same shape and type as the elements of inputs.

Raises:

ValueError: If inputs don't all have same shape and dtype or the shape cannot be inferred.

`tf.einsum(equation, *inputs)` {#einsum}

A generalized contraction between tensors of arbitrary dimension.

This function returns a tensor whose elements are defined by equation, which is written in a shorthand form inspired by the Einstein summation convention. As an example, consider multiplying two matrices A and B to form a matrix C. The elements of C are given by:

  C[i,k] = sum_j A[i,j] * B[j,k]

The corresponding equation is:

  ij,jk->ik

In general, the equation is obtained from the more familiar element-wise equation by

removing variable names, brackets, and commas,
replacing "*" with ",",
dropping summation signs, and
moving the output to the right, and replacing "=" with "->".

Many common operations can be expressed in this way. For example:

# Matrix multiplication
>>> einsum('ij,jk->ik', m0, m1)  # output[i,k] = sum_j m0[i,j] * m1[j, k]

# Dot product
>>> einsum('i,i->', u, v)  # output = sum_i u[i]*v[i]

# Outer product
>>> einsum('i,j->ij', u, v)  # output[i,j] = u[i]*v[j]

# Transpose
>>> einsum('ij->ji', m)  # output[j,i] = m[i,j]

# Batch matrix multiplication
>>> einsum('aij,ajk->aik', s, t)  # out[a,i,k] = sum_j s[a,i,j] * t[a, j, k]

This function behaves like numpy.einsum, but does not support:

Ellipses (subscripts like ij...,jk...->ik...)
Subscripts where an axis appears more than once for a single input (e.g. ijj,k->ik).
Subscripts that are summed across multiple inputs (e.g., ij,ij,jk->ik).

Args:

equation: a str describing the contraction, in the same format as numpy.einsum.
inputs: the inputs to contract (each one a Tensor), whose shapes should be consistent with equation.

Returns:

The contracted Tensor, with shape determined by equation.

Raises:

ValueError: If
- the format of equation is incorrect,
- the number of inputs implied by equation does not match len(inputs),
- an axis appears in the output subscripts but not in any of the inputs,
- the number of dimensions of an input differs from the number of indices in its subscript, or
- the input shapes are inconsistent along a particular axis.

Scan

TensorFlow provides several operations that you can use to perform scans (running totals) across one axis of a tensor.

`tf.cumsum(x, axis=0, exclusive=False, reverse=False, name=None)` {#cumsum}

Compute the cumulative sum of the tensor x along axis.

By default, this op performs an inclusive cumsum, which means that the first element of the input is identical to the first element of the output:

tf.cumsum([a, b, c]) ==> [a, a + b, a + b + c]

By setting the exclusive kwarg to True, an exclusive cumsum is performed instead:

tf.cumsum([a, b, c], exclusive=True) ==> [0, a, a + b]

By setting the reverse kwarg to True, the cumsum is performed in the opposite direction:

tf.cumsum([a, b, c], reverse=True) ==> [a + b + c, b + c, c]

This is more efficient than using separate tf.reverse ops.

The reverse and exclusive kwargs can also be combined:

tf.cumsum([a, b, c], exclusive=True, reverse=True) ==> [b + c, c, 0]

Args:

x: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half.
axis: A Tensor of type int32 (default: 0).
reverse: A bool (default: False).
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

`tf.cumprod(x, axis=0, exclusive=False, reverse=False, name=None)` {#cumprod}

Compute the cumulative product of the tensor x along axis.

By default, this op performs an inclusive cumprod, which means that the first element of the input is identical to the first element of the output:

tf.cumprod([a, b, c]) ==> [a, a * b, a * b * c]

By setting the exclusive kwarg to True, an exclusive cumprod is performed instead:

tf.cumprod([a, b, c], exclusive=True) ==> [1, a, a * b]

By setting the reverse kwarg to True, the cumprod is performed in the opposite direction:

tf.cumprod([a, b, c], reverse=True) ==> [a * b * c, b * c, c]

This is more efficient than using separate tf.reverse ops.

The reverse and exclusive kwargs can also be combined:

tf.cumprod([a, b, c], exclusive=True, reverse=True) ==> [b * c, c, 1]

Args:

x: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half.
axis: A Tensor of type int32 (default: 0).
reverse: A bool (default: False).
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x.

Segmentation

TensorFlow provides several operations that you can use to perform common math computations on tensor segments. Here a segmentation is a partitioning of a tensor along the first dimension, i.e. it defines a mapping from the first dimension onto segment_ids. The segment_ids tensor should be the size of the first dimension, d0, with consecutive IDs in the range 0 to k, where k<d0. In particular, a segmentation of a matrix tensor is a mapping of rows to segments.

For example:

c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
tf.segment_sum(c, tf.constant([0, 0, 1]))
  ==>  [[0 0 0 0]
        [5 6 7 8]]

`tf.segment_sum(data, segment_ids, name=None)` {#segment_sum}

Computes the sum along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that \(output_i = \sum_j data_j\) where sum is over j such that segment_ids[j] == i.

Args:

data: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half.
segment_ids: A Tensor. Must be one of the following types: int32, int64. A 1-D tensor whose rank is equal to the rank of data's first dimension. Values should be sorted and can be repeated.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as data. Has same shape as data, except for dimension 0 which has size k, the number of segments.

`tf.segment_prod(data, segment_ids, name=None)` {#segment_prod}

Computes the product along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that \(output_i = \prod_j data_j\) where the product is over j such that segment_ids[j] == i.

Args:

data: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half.
segment_ids: A Tensor. Must be one of the following types: int32, int64. A 1-D tensor whose rank is equal to the rank of data's first dimension. Values should be sorted and can be repeated.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as data. Has same shape as data, except for dimension 0 which has size k, the number of segments.

`tf.segment_min(data, segment_ids, name=None)` {#segment_min}

Computes the minimum along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that \(output_i = \min_j(data_j)\) where min is over j such that segment_ids[j] == i.

Args:

data: A Tensor. Must be one of the following types: float32, float64, int32, int64, uint8, int16, int8, uint16, half.
segment_ids: A Tensor. Must be one of the following types: int32, int64. A 1-D tensor whose rank is equal to the rank of data's first dimension. Values should be sorted and can be repeated.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as data. Has same shape as data, except for dimension 0 which has size k, the number of segments.

`tf.segment_max(data, segment_ids, name=None)` {#segment_max}

Computes the maximum along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that \(output_i = \max_j(data_j)\) where max is over j such that segment_ids[j] == i.

Args:

data: A Tensor. Must be one of the following types: float32, float64, int32, int64, uint8, int16, int8, uint16, half.
segment_ids: A Tensor. Must be one of the following types: int32, int64. A 1-D tensor whose rank is equal to the rank of data's first dimension. Values should be sorted and can be repeated.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as data. Has same shape as data, except for dimension 0 which has size k, the number of segments.

`tf.segment_mean(data, segment_ids, name=None)` {#segment_mean}

Computes the mean along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that \(output_i = \frac{\sum_j data_j}{N}\) where mean is over j such that segment_ids[j] == i and N is the total number of values summed.

Args:

data: A Tensor. Must be one of the following types: float32, float64, int32, int64, uint8, int16, int8, uint16, half.
segment_ids: A Tensor. Must be one of the following types: int32, int64. A 1-D tensor whose rank is equal to the rank of data's first dimension. Values should be sorted and can be repeated.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as data. Has same shape as data, except for dimension 0 which has size k, the number of segments.

`tf.unsorted_segment_sum(data, segment_ids, num_segments, name=None)` {#unsorted_segment_sum}

Computes the sum along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that (output[i] = sum_{j...} data[j...] where the sum is over tuples j... such that segment_ids[j...] == i. Unlike SegmentSum, segment_ids need not be sorted and need not cover all values in the full range of valid values.

If the sum is empty for a given segment ID i, output[i] = 0.

num_segments should equal the number of distinct segment IDs.

Args:

data: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half.
segment_ids: A Tensor. Must be one of the following types: int32, int64. A tensor whose shape is a prefix of data.shape.
num_segments: A Tensor of type int32.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as data. Has same shape as data, except for the first segment_ids.rank dimensions, which are replaced with a single dimension which has size num_segments.

`tf.sparse_segment_sum(data, indices, segment_ids, name=None)` {#sparse_segment_sum}

Computes the sum along sparse segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Like SegmentSum, but segment_ids can have rank less than data's first dimension, selecting a subset of dimension 0, specified by indices.

For example:

c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])

# Select two rows, one segment.
tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))
  ==> [[0 0 0 0]]

# Select two rows, two segment.
tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))
  ==> [[ 1  2  3  4]
       [-1 -2 -3 -4]]

# Select all rows, two segments.
tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))
  ==> [[0 0 0 0]
       [5 6 7 8]]

# Which is equivalent to:
tf.segment_sum(c, tf.constant([0, 0, 1]))

Args:

data: A Tensor. Must be one of the following types: float32, float64, int32, int64, uint8, int16, int8, uint16, half.
indices: A Tensor. Must be one of the following types: int32, int64. A 1-D tensor. Has same rank as segment_ids.
segment_ids: A Tensor of type int32. A 1-D tensor. Values should be sorted and can be repeated.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as data. Has same shape as data, except for dimension 0 which has size k, the number of segments.

`tf.sparse_segment_mean(data, indices, segment_ids, name=None)` {#sparse_segment_mean}

Computes the mean along sparse segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Like SegmentMean, but segment_ids can have rank less than data's first dimension, selecting a subset of dimension 0, specified by indices.

Args:

data: A Tensor. Must be one of the following types: float32, float64.
indices: A Tensor. Must be one of the following types: int32, int64. A 1-D tensor. Has same rank as segment_ids.
segment_ids: A Tensor of type int32. A 1-D tensor. Values should be sorted and can be repeated.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as data. Has same shape as data, except for dimension 0 which has size k, the number of segments.

`tf.sparse_segment_sqrt_n(data, indices, segment_ids, name=None)` {#sparse_segment_sqrt_n}

Computes the sum along sparse segments of a tensor divided by the sqrt of N.

N is the size of the segment being reduced.

Read the section on Segmentation for an explanation of segments.

Args:

data: A Tensor. Must be one of the following types: float32, float64.
indices: A Tensor. Must be one of the following types: int32, int64. A 1-D tensor. Has same rank as segment_ids.
segment_ids: A Tensor of type int32. A 1-D tensor. Values should be sorted and can be repeated.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as data. Has same shape as data, except for dimension 0 which has size k, the number of segments.

Sequence Comparison and Indexing

TensorFlow provides several operations that you can use to add sequence comparison and index extraction to your graph. You can use these operations to determine sequence differences and determine the indexes of specific values in a tensor.

`tf.argmin(input, axis=None, name=None, dimension=None)` {#argmin}

Returns the index with the smallest value across axes of a tensor.

Args:

input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half.
axis: A Tensor. Must be one of the following types: int32, int64. int32, 0 <= axis < rank(input). Describes which axis of the input Tensor to reduce across. For vectors, use axis = 0.
name: A name for the operation (optional).

Returns:

A Tensor of type int64.

`tf.argmax(input, axis=None, name=None, dimension=None)` {#argmax}

Returns the index with the largest value across axes of a tensor.

Args:

input: A Tensor. Must be one of the following types: float32, float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128, qint8, quint8, qint32, half.
axis: A Tensor. Must be one of the following types: int32, int64. int32, 0 <= axis < rank(input). Describes which axis of the input Tensor to reduce across. For vectors, use axis = 0.
name: A name for the operation (optional).

Returns:

A Tensor of type int64.

`tf.setdiff1d(x, y, index_dtype=tf.int32, name=None)` {#setdiff1d}

Computes the difference between two lists of numbers or strings.

Given a list x and a list y, this operation returns a list out that represents all values that are in x but not in y. The returned list out is sorted in the same order that the numbers appear in x (duplicates are preserved). This operation also returns a list idx that represents the position of each out element in x. In other words:

out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]

For example, given this input:

x = [1, 2, 3, 4, 5, 6]
y = [1, 3, 5]

This operation would return:

out ==> [2, 4, 6]
idx ==> [1, 3, 5]

Args:

x: A Tensor. 1-D. Values to keep.
y: A Tensor. Must have the same type as x. 1-D. Values to remove.
out_idx: An optional tf.DType from: tf.int32, tf.int64. Defaults to tf.int32.
name: A name for the operation (optional).

Returns:

A tuple of Tensor objects (out, idx).

out: A Tensor. Has the same type as x. 1-D. Values present in x but not in y.
idx: A Tensor of type out_idx. 1-D. Positions of x values preserved in out.

`tf.where(condition, x=None, y=None, name=None)` {#where}

Return the elements, either from x or y, depending on the condition.

If both x and y are None, then this operation returns the coordinates of true elements of condition. The coordinates are returned in a 2-D tensor where the first dimension (rows) represents the number of true elements, and the second dimension (columns) represents the coordinates of the true elements. Keep in mind, the shape of the output tensor can vary depending on how many true values there are in input. Indices are output in row-major order.

If both non-None, x and y must have the same shape. The condition tensor must be a scalar if x and y are scalar. If x and y are vectors or higher rank, then condition must be either a vector with size matching the first dimension of x, or must have the same shape as x.

The condition tensor acts as a mask that chooses, based on the value at each element, whether the corresponding element / row in the output should be taken from x (if true) or y (if false).

If condition is a vector and x and y are higher rank matrices, then it chooses which row (outer dimension) to copy from x and y. If condition has the same shape as x and y, then it chooses which element to copy from x and y.

Args:

condition: A Tensor of type bool
x: A Tensor which may have the same shape as condition. If condition is rank 1, x may have higher rank, but its first dimension must match the size of condition.
y: A tensor with the same shape and type as x.
name: A name of the operation (optional)

Returns:

A Tensor with the same type and shape as x, y if they are non-None. A Tensor with shape (num_true, dim_size(condition)).

Raises:

ValueError: When exactly one of x or y is non-None.

`tf.unique(x, out_idx=None, name=None)` {#unique}

Finds unique elements in a 1-D tensor.

This operation returns a tensor y containing all of the unique elements of x sorted in the same order that they occur in x. This operation also returns a tensor idx the same size as x that contains the index of each value of x in the unique output y. In other words:

y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]

For example:

# tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
y, idx = unique(x)
y ==> [1, 2, 4, 7, 8]
idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]

Args:

x: A Tensor. 1-D.
out_idx: An optional tf.DType from: tf.int32, tf.int64. Defaults to tf.int32.
name: A name for the operation (optional).

Returns:

A tuple of Tensor objects (y, idx).

y: A Tensor. Has the same type as x. 1-D.
idx: A Tensor of type out_idx. 1-D.

`tf.edit_distance(hypothesis, truth, normalize=True, name='edit_distance')` {#edit_distance}

Computes the Levenshtein distance between sequences.

This operation takes variable-length sequences (hypothesis and truth), each provided as a SparseTensor, and computes the Levenshtein distance. You can normalize the edit distance by length of truth by setting normalize to true.

For example, given the following input:

# 'hypothesis' is a tensor of shape `[2, 1]` with variable-length values:
#   (0,0) = ["a"]
#   (1,0) = ["b"]
hypothesis = tf.SparseTensor(
    [[0, 0, 0],
     [1, 0, 0]],
    ["a", "b"]
    (2, 1, 1))

# 'truth' is a tensor of shape `[2, 2]` with variable-length values:
#   (0,0) = []
#   (0,1) = ["a"]
#   (1,0) = ["b", "c"]
#   (1,1) = ["a"]
truth = tf.SparseTensor(
    [[0, 1, 0],
     [1, 0, 0],
     [1, 0, 1],
     [1, 1, 0]]
    ["a", "b", "c", "a"],
    (2, 2, 2))

normalize = True

This operation would return the following:

# 'output' is a tensor of shape `[2, 2]` with edit distances normalized
# by 'truth' lengths.
output ==> [[inf, 1.0],  # (0,0): no truth, (0,1): no hypothesis
           [0.5, 1.0]]  # (1,0): addition, (1,1): no hypothesis

Args:

hypothesis: A SparseTensor containing hypothesis sequences.
truth: A SparseTensor containing truth sequences.
normalize: A bool. If True, normalizes the Levenshtein distance by length of truth.
name: A name for the operation (optional).

Returns:

A dense Tensor with rank R - 1, where R is the rank of the SparseTensor inputs hypothesis and truth.

Raises:

TypeError: If either hypothesis or truth are not a SparseTensor.

`tf.invert_permutation(x, name=None)` {#invert_permutation}

Computes the inverse permutation of a tensor.

This operation computes the inverse of an index permutation. It takes a 1-D integer tensor x, which represents the indices of a zero-based array, and swaps each value with its index position. In other words, for an output tensor y and an input tensor x, this operation computes the following:

y[x[i]] = i for i in [0, 1, ..., len(x) - 1]

The values must include 0. There can be no duplicate values or negative values.

For example:

# tensor `x` is [3, 4, 0, 2, 1]
invert_permutation(x) ==> [2, 4, 3, 0, 1]

Args:

x: A Tensor. Must be one of the following types: int32, int64. 1-D.
name: A name for the operation (optional).

Returns:

A Tensor. Has the same type as x. 1-D.

Files

math_ops.md

Latest commit

History

math_ops.md

File metadata and controls

Math

Arithmetic Operators

tf.add(x, y, name=None) {#add}

Args:

Returns:

tf.subtract(x, y, name=None) {#subtract}

Args:

Returns:

tf.multiply(x, y, name=None) {#multiply}

Args:

Returns:

tf.scalar_mul(scalar, x) {#scalar_mul}

Args:

Returns:

Raises:

tf.div(x, y, name=None) {#div}

Args:

Returns:

tf.divide(x, y, name=None) {#divide}

tf.truediv(x, y, name=None) {#truediv}

Args:

Returns:

Raises:

tf.floordiv(x, y, name=None) {#floordiv}

Args:

Returns:

Raises:

tf.realdiv(x, y, name=None) {#realdiv}

Args:

Returns:

tf.truncatediv(x, y, name=None) {#truncatediv}

Args:

Returns:

tf.floor_div(x, y, name=None) {#floor_div}

Args:

Returns:

tf.truncatemod(x, y, name=None) {#truncatemod}

Args:

Returns:

tf.floormod(x, y, name=None) {#floormod}

Args:

Returns:

tf.mod(x, y, name=None) {#mod}

Args:

Returns:

tf.cross(a, b, name=None) {#cross}

Args:

Returns:

Basic Math Functions

tf.add_n(inputs, name=None) {#add_n}

Args:

Returns:

Raises:

tf.abs(x, name=None) {#abs}

Args:

Returns:

tf.negative(x, name=None) {#negative}

Args:

Returns:

tf.sign(x, name=None) {#sign}

Args:

Returns:

tf.reciprocal(x, name=None) {#reciprocal}

Args:

Returns:

tf.square(x, name=None) {#square}

Args:

Returns:

tf.round(x, name=None) {#round}

Args:

Returns:

tf.sqrt(x, name=None) {#sqrt}

Args:

Returns:

`tf.add(x, y, name=None)` {#add}

`tf.subtract(x, y, name=None)` {#subtract}

`tf.multiply(x, y, name=None)` {#multiply}

`tf.scalar_mul(scalar, x)` {#scalar_mul}

`tf.div(x, y, name=None)` {#div}

`tf.divide(x, y, name=None)` {#divide}

`tf.truediv(x, y, name=None)` {#truediv}

`tf.floordiv(x, y, name=None)` {#floordiv}

`tf.realdiv(x, y, name=None)` {#realdiv}

`tf.truncatediv(x, y, name=None)` {#truncatediv}

`tf.floor_div(x, y, name=None)` {#floor_div}

`tf.truncatemod(x, y, name=None)` {#truncatemod}

`tf.floormod(x, y, name=None)` {#floormod}

`tf.mod(x, y, name=None)` {#mod}

`tf.cross(a, b, name=None)` {#cross}

`tf.add_n(inputs, name=None)` {#add_n}

`tf.abs(x, name=None)` {#abs}

`tf.negative(x, name=None)` {#negative}

`tf.sign(x, name=None)` {#sign}

`tf.reciprocal(x, name=None)` {#reciprocal}

`tf.square(x, name=None)` {#square}

`tf.round(x, name=None)` {#round}

`tf.sqrt(x, name=None)` {#sqrt}

`tf.rsqrt(x, name=None)` {#rsqrt}

`tf.pow(x, y, name=None)` {#pow}

`tf.exp(x, name=None)` {#exp}

`tf.expm1(x, name=None)` {#expm1}

`tf.log(x, name=None)` {#log}

`tf.log1p(x, name=None)` {#log1p}

`tf.ceil(x, name=None)` {#ceil}

`tf.floor(x, name=None)` {#floor}

`tf.maximum(x, y, name=None)` {#maximum}

`tf.minimum(x, y, name=None)` {#minimum}

`tf.cos(x, name=None)` {#cos}

`tf.sin(x, name=None)` {#sin}

`tf.lbeta(x, name='lbeta')` {#lbeta}

`tf.tan(x, name=None)` {#tan}

`tf.acos(x, name=None)` {#acos}

`tf.asin(x, name=None)` {#asin}

`tf.atan(x, name=None)` {#atan}

`tf.lgamma(x, name=None)` {#lgamma}

`tf.digamma(x, name=None)` {#digamma}

`tf.erf(x, name=None)` {#erf}

`tf.erfc(x, name=None)` {#erfc}