Module: tf.math

Math Operations.

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

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

TensorFlow provides a variety of math functions including:

• Basic arithmetic operators and trigonometric functions.
• Special math functions (like: tf.math.igamma and tf.math.zeta)
• Complex number functions (like: tf.math.imag and tf.math.angle)
• Reductions and scans (like: tf.math.reduce_mean and tf.math.cumsum)
• Segment functions (like: tf.math.segment_sum)

See: tf.linalg for matrix and tensor functions.

About 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.math.segment_sum(c, tf.constant([0, 0, 1]))
#  ==>  [[0 0 0 0]
#        [5 6 7 8]]

The standard segment_* functions assert that the segment indices are sorted. If you have unsorted indices use the equivalent unsorted_segment_ function. These functions take an additional argument num_segments so that the output tensor can be efficiently allocated.

c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
tf.math.unsorted_segment_sum(c, tf.constant([0, 1, 0]), num_segments=2)
# ==> [[ 6,  8, 10, 12],
#       [-1, -2, -3, -4]]

Modules

special module: Public API for tf.math.special namespace.

Functions

abs(...): Computes the absolute value of a tensor.

accumulate_n(...): Returns the element-wise sum of a list of tensors.

acos(...): Computes acos of x element-wise.

acosh(...): Computes inverse hyperbolic cosine of x element-wise.

add(...): Returns x + y element-wise.

add_n(...): Adds all input tensors element-wise.

angle(...): Returns the element-wise argument of a complex (or real) tensor.

argmax(...): Returns the index with the largest value across axes of a tensor.

argmin(...): Returns the index with the smallest value across axes of a tensor.

asin(...): Computes the trignometric inverse sine of x element-wise.

asinh(...): Computes inverse hyperbolic sine of x element-wise.

atan(...): Computes the trignometric inverse tangent of x element-wise.

atan2(...): Computes arctangent of y/x element-wise, respecting signs of the arguments.

atanh(...): Computes inverse hyperbolic tangent of x element-wise.

bessel_i0(...): Computes the Bessel i0 function of x element-wise.

bessel_i0e(...): Computes the Bessel i0e function of x element-wise.

bessel_i1(...): Computes the Bessel i1 function of x element-wise.

bessel_i1e(...): Computes the Bessel i1e function of x element-wise.

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

bincount(...): Counts the number of occurrences of each value in an integer array.

ceil(...): Return the ceiling of the input, element-wise.

confusion_matrix(...): Computes the confusion matrix from predictions and labels.

conj(...): Returns the complex conjugate of a complex number.

cos(...): Computes cos of x element-wise.

cosh(...): Computes hyperbolic cosine of x element-wise.

count_nonzero(...): Computes number of nonzero elements across dimensions of a tensor.

cumprod(...): Compute the cumulative product of the tensor x along axis.

cumsum(...): Compute the cumulative sum of the tensor x along axis.

cumulative_logsumexp(...): Compute the cumulative log-sum-exp of the tensor x along axis.

digamma(...): Computes Psi, the derivative of Lgamma (the log of the absolute value of

divide(...): Computes Python style division of x by y.

divide_no_nan(...): Computes a safe divide which returns 0 if y (denominator) is zero.

equal(...): Returns the truth value of (x == y) element-wise.

erf(...): Computes the Gauss error function of x element-wise. In statistics, for non-negative values of \(x\), the error function has the following interpretation: for a random variable \(Y\) that is normally distributed with mean 0 and variance \(1/\sqrt{2}\), \(erf(x)\) is the probability that \(Y\) falls in the range \([−x, x]\).

erfc(...): Computes the complementary error function of x element-wise.

erfcinv(...): Computes the inverse of complementary error function.

erfinv(...): Compute inverse error function.

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

expm1(...): Computes exp(x) - 1 element-wise.

floor(...): Returns element-wise largest integer not greater than x.

floordiv(...): Divides x / y elementwise, rounding toward the most negative integer.

floormod(...): Returns element-wise remainder of division.

greater(...): Returns the truth value of (x > y) element-wise.

greater_equal(...): Returns the truth value of (x >= y) element-wise.

igamma(...): Compute the lower regularized incomplete Gamma function P(a, x).

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

imag(...): Returns the imaginary part of a complex (or real) tensor.

in_top_k(...): Says whether the targets are in the top K predictions.

invert_permutation(...): Computes the inverse permutation of a tensor.

is_finite(...): Returns which elements of x are finite.

is_inf(...): Returns which elements of x are Inf.

is_nan(...): Returns which elements of x are NaN.

is_non_decreasing(...): Returns True if x is non-decreasing.

is_strictly_increasing(...): Returns True if x is strictly increasing.

l2_normalize(...): Normalizes along dimension axis using an L2 norm. (deprecated arguments)

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

less(...): Returns the truth value of (x < y) element-wise.

less_equal(...): Returns the truth value of (x <= y) element-wise.

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

log(...): Computes natural logarithm of x element-wise.

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

log_sigmoid(...): Computes log sigmoid of x element-wise.

log_softmax(...): Computes log softmax activations.

logical_and(...): Returns the truth value of x AND y element-wise.

logical_not(...): Returns the truth value of NOT x element-wise.

logical_or(...): Returns the truth value of x OR y element-wise.

logical_xor(...): Logical XOR function.

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

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

mod(...): Returns element-wise remainder of division.

multiply(...): Returns an element-wise x * y.

multiply_no_nan(...): Computes the product of x and y and returns 0 if the y is zero, even if x is NaN or infinite.

ndtri(...): Compute quantile of Standard Normal.

negative(...): Computes numerical negative value element-wise.

nextafter(...): Returns the next representable value of x1 in the direction of x2, element-wise.

not_equal(...): Returns the truth value of (x != y) element-wise.

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

polyval(...): Computes the elementwise value of a polynomial.

pow(...): Computes the power of one value to another.

real(...): Returns the real part of a complex (or real) tensor.

reciprocal(...): Computes the reciprocal of x element-wise.

reciprocal_no_nan(...): Performs a safe reciprocal operation, element wise.

reduce_all(...): Computes tf.math.logical_and of elements across dimensions of a tensor.

reduce_any(...): Computes tf.math.logical_or of elements across dimensions of a tensor.

reduce_euclidean_norm(...): Computes the Euclidean norm of elements across dimensions of a tensor.

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

reduce_max(...): Computes tf.math.maximum of elements across dimensions of a tensor.

reduce_mean(...): Computes the mean of elements across dimensions of a tensor.

reduce_min(...): Computes the tf.math.minimum of elements across dimensions of a tensor.

reduce_prod(...): Computes tf.math.multiply of elements across dimensions of a tensor.

reduce_std(...): Computes the standard deviation of elements across dimensions of a tensor.

reduce_sum(...): Computes the sum of elements across dimensions of a tensor.

reduce_variance(...): Computes the variance of elements across dimensions of a tensor.

rint(...): Returns element-wise integer closest to x.

round(...): Rounds the values of a tensor to the nearest integer, element-wise.

rsqrt(...): Computes reciprocal of square root of x element-wise.

scalar_mul(...): Multiplies a scalar times a Tensor or IndexedSlices object.

segment_max(...): Computes the maximum along segments of a tensor.

segment_mean(...): Computes the mean along segments of a tensor.

segment_min(...): Computes the minimum along segments of a tensor.

segment_prod(...): Computes the product along segments of a tensor.

segment_sum(...): Computes the sum along segments of a tensor.

sigmoid(...): Computes sigmoid of x element-wise.

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

sin(...): Computes sine of x element-wise.

sinh(...): Computes hyperbolic sine of x element-wise.

sobol_sample(...): Generates points from the Sobol sequence.

softmax(...): Computes softmax activations.

softplus(...): Computes elementwise softplus: softplus(x) = log(exp(x) + 1).

softsign(...): Computes softsign: features / (abs(features) + 1).

sqrt(...): Computes element-wise square root of the input tensor.

square(...): Computes square of x element-wise.

squared_difference(...): Returns conj(x - y)(x - y) element-wise.

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

tan(...): Computes tan of x element-wise.

tanh(...): Computes hyperbolic tangent of x element-wise.

top_k(...): Finds values and indices of the k largest entries for the last dimension.

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

unsorted_segment_max(...): Computes the maximum along segments of a tensor.

unsorted_segment_mean(...): Computes the mean along segments of a tensor.

unsorted_segment_min(...): Computes the minimum along segments of a tensor.

unsorted_segment_prod(...): Computes the product along segments of a tensor.

unsorted_segment_sqrt_n(...): Computes the sum along segments of a tensor divided by the sqrt(N).

unsorted_segment_sum(...): Computes the sum along segments of a tensor.

xdivy(...): Returns 0 if x == 0, and x / y otherwise, elementwise.

xlog1py(...): Compute x * log1p(y).

xlogy(...): Returns 0 if x == 0, and x * log(y) otherwise, elementwise.

zero_fraction(...): Returns the fraction of zeros in value.

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