TensorFlow教程之API DOC 6.3.9. MATH OPS

简介:

本文档为TensorFlow参考文档,本转载已得到TensorFlow中文社区授权。


Math

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

Contents

Math

Arithmetic Operators

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


tf.add(x, y, name=None)

Returns x + y element-wise.

NOTE: Add supports broadcasting. AddN does not.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int8int16int32complex64int64.
  • y: A Tensor. Must have the same type as x.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.sub(x, y, name=None)

Returns x - y element-wise.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • y: A Tensor. Must have the same type as x.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.mul(x, y, name=None)

Returns x * y element-wise.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int8int16int32complex64int64.
  • y: A Tensor. Must have the same type as x.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.div(x, y, name=None)

Returns x / y element-wise.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • y: A Tensor. Must have the same type as x.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.mod(x, y, name=None)

Returns element-wise remainder of division.

Args:
  • x: A Tensor. Must be one of the following types: int32int64float32float64.
  • y: A Tensor. Must have the same type as x.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.

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 all input tensors element wise.

Args:
  • inputs: A list of at least 1 Tensor objects of the same type in: float32float64int64int32uint8int16int8complex64qint8quint8qint32. Must all be the same size and shape.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as inputs.


tf.abs(x, name=None)

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 gif.latex?y%20=%20|x|.

See tf.complex_abs() to compute the absolute value of a complex number.

Args:
  • x: A Tensor of type floatdoubleint32, or int64.
  • name: A name for the operation (optional).
Returns:

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


tf.neg(x, name=None)

Computes numerical negative value element-wise.

I.e., gif.latex?y%20=%20-x.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.sign(x, name=None)

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.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32int64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.inv(x, name=None)

Computes the reciprocal of x element-wise.

I.e., %20x.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.square(x, name=None)

Computes square of x element-wise.

I.e., gif.latex?y%20=%20x%20*%20x%20=%20x^2.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.round(x, name=None)

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

For example:

# 'a' is [0.9, 2.5, 2.3, -4.4]
tf.round(a) ==> [ 1.0, 3.0, 2.0, -4.0 ]
Args:
  • x: A Tensor of type float or double.
  • name: A name for the operation (optional).
Returns:

Tensor of same shape and type as x.


tf.sqrt(x, name=None)

Computes square root of x element-wise.

I.e., 2}.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.rsqrt(x, name=None)

Computes reciprocal of square root of x element-wise.

I.e., %20\sqrt{x}.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.pow(x, y, name=None)

Computes the power of one value to another.

Given a tensor x and a tensor y, this operation computes gif.latex?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 floatdoubleint32complex64, or int64.
  • y: A Tensor of type floatdoubleint32complex64, or int64.
  • name: A name for the operation (optional).
Returns:

Tensor.


tf.exp(x, name=None)

Computes exponential of x element-wise. gif.latex?y%20=%20e^x.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.log(x, name=None)

Computes natural logrithm of x element-wise.

I.e., gif.latex?y%20=%20\log_e%20x.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.ceil(x, name=None)

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

Args:
  • x: A Tensor. Must be one of the following types: float32float64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.floor(x, name=None)

Returns element-wise largest integer not greater than x.

Args:
  • x: A Tensor. Must be one of the following types: float32float64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.maximum(x, y, name=None)

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

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32int64.
  • y: A Tensor. Must have the same type as x.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.minimum(x, y, name=None)

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

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32int64.
  • y: A Tensor. Must have the same type as x.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.cos(x, name=None)

Computes cos of x element-wise.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.


tf.sin(x, name=None)

Computes sin of x element-wise.

Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64int64.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x.

Matrix Math Functions

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


tf.diag(diagonal, name=None)

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: float32float64int32int64. Rank k tensor where k is at most 3.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as diagonal.


tf.transpose(a, perm=None, name='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=[0, 1]) ==> [[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(b, 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.matmul(a, b, transpose_a=False, transpose_b=False, a_is_sparse=False, b_is_sparse=False, name=None)

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

The inputs must be two-dimensional matrices, with matching inner dimensions, possibly after transposition.

Both matrices must be of the same type. The supported types are: floatdoubleint32complex64.

Either matrix can be transposed on the fly by setting the corresponding flag to True. This is 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.

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]]
Args:
  • aTensor of type floatdoubleint32 or complex64.
  • bTensor with same type as a.
  • transpose_a: If Truea is transposed before multiplication.
  • transpose_b: If Trueb is transposed before multiplication.
  • a_is_sparse: If Truea is treated as a sparse matrix.
  • b_is_sparse: If Trueb is treated as a sparse matrix.
  • name: Name for the operation (optional).
Returns:

Tensor of the same type as a.


tf.batch_matmul(x, y, adj_x=None, adj_y=None, name=None)

Multiplies slices of two tensors in batches.

Multiplies all slices of Tensor x and y (each slice can be viewed as an element of a batch), and arranges the individual results in a single output tensor of the same batch size. Each of the individual slices can optionally be adjointed (to adjoint a matrix means to transpose and conjugate it) before multiplication by setting the adj_x or adj_y flag to True, which are by default False.

The input tensors x and y are 3-D or higher with shape [..., r_x, c_x] and [..., r_y, c_y].

The output tensor is 3-D or higher with shape [..., r_o, c_o], where:

r_o = c_x if adj_x else r_x
c_o = r_y if adj_y else c_y

It is computed as:

out[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])
Args:
  • x: A Tensor. Must be one of the following types: float32float64int32complex64. 3-D or higher with shape [..., r_x, c_x].
  • y: A Tensor. Must have the same type as x. 3-D or higher with shape [..., r_y, c_y].
  • adj_x: An optional bool. Defaults to False. If True, adjoint the slices of x. Defaults to False.
  • adj_y: An optional bool. Defaults to False. If True, adjoint the slices of y. Defaults to False.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as x. 3-D or higher with shape [..., r_o, c_o]


tf.matrix_determinant(input, name=None)

Calculates the determinant of a square matrix.

Args:
  • input: A Tensor. Must be one of the following types: float32float64. A tensor of shape [M, M].
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as input. A scalar, equal to the determinant of the input.


tf.batch_matrix_determinant(input, name=None)

Calculates the determinants for a batch of square matrices.

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

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

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


tf.matrix_inverse(input, name=None)

Calculates the inverse of a square invertible matrix. Checks for invertibility.

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

Tensor. Has the same type as input. Shape is [M, M] containing the matrix inverse of the input.


tf.batch_matrix_inverse(input, name=None)

Calculates the inverse of square invertible matrices. Checks for invertibility.

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 [..., :, :].

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

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


tf.cholesky(input, name=None)

Calculates the Cholesky decomposition of a square matrix.

The input has to be symmetric and positive definite. Only the lower-triangular part of the input will be used for this operation. The upper-triangular part will not be read.

The result is the lower-triangular matrix of the Cholesky decomposition of the input.

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

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


tf.batch_cholesky(input, name=None)

Calculates the Cholesky decomposition of a batch of 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: float64float32. Shape is [..., M, M].
  • name: A name for the operation (optional).
Returns:

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

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)

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 computes complex numbers elementwise of the form gif.latex?a%20+%20bj, where a represents the real part and b represents the imag part.

The input tensors real and imag must be 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.74j], [3.25 + 5.75j]]
Args:
  • real: A Tensor of type float.
  • imag: A Tensor of type float.
  • name: A name for the operation (optional).
Returns:

Tensor of type complex64.


tf.complex_abs(x, name=None)

Computes the complex absolute value of a tensor.

Given a tensor x of complex numbers, this operation returns a tensor of type float that is the absolute value of each element in x. All elements in x must be complex numbers of the form gif.latex?a%20+%20bj. The absolute value is computed as gif.latex?%20\sqrt{a^2%20+%20b^2}.

For example:

# tensor 'x' is [[-2.25 + 4.75j], [-3.25 + 5.75j]]
tf.complex_abs(x) ==> [5.25594902, 6.60492229]
Args:
  • x: A Tensor of type complex64.
  • name: A name for the operation (optional).
Returns:

Tensor of type float32.


tf.conj(in_, name=None)

Returns the complex conjugate of a complex number.

Given a tensor in of complex numbers, this operation returns a tensor of complex numbers that are the complex conjugate of each element in in. The complex numbers in in must be of the form gif.latex?a%20+%20bj, where a is the real part and b is the imaginary part.

The complex conjugate returned by this operation is of the form gif.latex?a%20-%20bj.

For example:

# tensor 'in' is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.conj(in) ==> [-2.25 - 4.75j, 3.25 - 5.75j]
Args:
  • in_: A Tensor of type complex64.
  • name: A name for the operation (optional).
Returns:

Tensor of type complex64.


tf.imag(in_, name=None)

Returns the imaginary part of a complex number.

Given a tensor in of complex numbers, this operation returns a tensor of type float that is the imaginary part of each element in in. All elements in in must be complex numbers of the form gif.latex?a%20+%20bj, where a is the real part and b is the imaginary part returned by this operation.

For example:

# tensor 'in' is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.imag(in) ==> [4.75, 5.75]
Args:
  • in_: A Tensor of type complex64.
  • name: A name for the operation (optional).
Returns:

Tensor of type float32.


tf.real(in_, name=None)

Returns the real part of a complex number.

Given a tensor in of complex numbers, this operation returns a tensor of type float that is the real part of each element in in. All elements in in must be complex numbers of the form gif.latex?a%20+%20bj, where a is the real part returned by this operation and b is the imaginary part.

For example:

# tensor 'in' is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.real(in) ==> [-2.25, 3.25]
Args:
  • in_: A Tensor of type complex64.
  • name: A name for the operation (optional).
Returns:

Tensor of type float32.

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, reduction_indices=None, keep_dims=False, name=None)

Computes the sum of elements across dimensions of a tensor.

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

If reduction_indices 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.
  • reduction_indices: The dimensions to reduce. If None (the defaut), reduces all dimensions.
  • keep_dims: If true, retains reduced dimensions with length 1.
  • name: A name for the operation (optional).
Returns:

The reduced tensor.


tf.reduce_prod(input_tensor, reduction_indices=None, keep_dims=False, name=None)

Computes the product of elements across dimensions of a tensor.

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

If reduction_indices 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.
  • reduction_indices: The dimensions to reduce. If None (the defaut), reduces all dimensions.
  • keep_dims: If true, retains reduced dimensions with length 1.
  • name: A name for the operation (optional).
Returns:

The reduced tensor.


tf.reduce_min(input_tensor, reduction_indices=None, keep_dims=False, name=None)

Computes the minimum of elements across dimensions of a tensor.

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

If reduction_indices 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.
  • reduction_indices: The dimensions to reduce. If None (the defaut), reduces all dimensions.
  • keep_dims: If true, retains reduced dimensions with length 1.
  • name: A name for the operation (optional).
Returns:

The reduced tensor.


tf.reduce_max(input_tensor, reduction_indices=None, keep_dims=False, name=None)

Computes the maximum of elements across dimensions of a tensor.

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

If reduction_indices 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.
  • reduction_indices: The dimensions to reduce. If None (the defaut), reduces all dimensions.
  • keep_dims: If true, retains reduced dimensions with length 1.
  • name: A name for the operation (optional).
Returns:

The reduced tensor.


tf.reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None)

Computes the mean of elements across dimensions of a tensor.

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

If reduction_indices 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.
  • reduction_indices: The dimensions to reduce. If None (the defaut), reduces all dimensions.
  • keep_dims: If true, retains reduced dimensions with length 1.
  • name: A name for the operation (optional).
Returns:

The reduced tensor.


tf.reduce_all(input_tensor, reduction_indices=None, keep_dims=False, name=None)

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

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

If reduction_indices 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.
  • reduction_indices: The dimensions to reduce. If None (the defaut), reduces all dimensions.
  • keep_dims: If true, retains reduced dimensions with length 1.
  • name: A name for the operation (optional).
Returns:

The reduced tensor.


tf.reduce_any(input_tensor, reduction_indices=None, keep_dims=False, name=None)

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

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

If reduction_indices 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.
  • reduction_indices: The dimensions to reduce. If None (the defaut), reduces all dimensions.
  • keep_dims: If true, retains reduced dimensions with length 1.
  • name: A name for the operation (optional).
Returns:

The reduced tensor.


tf.accumulate_n(inputs, shape=None, tensor_dtype=None, name=None)

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.

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:

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.

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)

Computes the sum along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that gif.latex?output_i%20=%20\sum_j%20data_j where sum is over j such that segment_ids[j] == i.

Args:
  • data: A Tensor. Must be one of the following types: float32float64int32int64uint8int16int8.
  • segment_ids: A Tensor. Must be one of the following types: int32int64. 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:

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)

Computes the product along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that gif.latex?output_i%20=%20\prod_j%20data_ where the product is over j such that segment_ids[j] == i.

Args:
  • data: A Tensor. Must be one of the following types: float32float64int32int64uint8int16int8.
  • segment_ids: A Tensor. Must be one of the following types: int32int64. 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:

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)

Computes the minimum along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that gif.latex?output_i%20=%20\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: float32float64int32int64uint8int16int8.
  • segment_ids: A Tensor. Must be one of the following types: int32int64. 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:

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)

Computes the maximum along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that gif.latex?output_i%20=%20\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: float32float64int32int64uint8int16int8.
  • segment_ids: A Tensor. Must be one of the following types: int32int64. 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:

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)

Computes the mean along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that gif.latex?output_i%20=%20\frac{\sum_j%20 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: float32float64int32int64uint8int16int8.
  • segment_ids: A Tensor. Must be one of the following types: int32int64. 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:

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)

Computes the sum along segments of a tensor.

Read the section on Segmentation for an explanation of segments.

Computes a tensor such that gif.latex?output_i%20=%20\sum_j%20data_j where sum is over j such that segment_ids[j] == i. Unlike SegmentSumsegment_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 ioutput[i] = 0.

num_segments should equal the number of distinct segment IDs.

Args:
  • data: A Tensor. Must be one of the following types: float32float64int32int64uint8int16int8.
  • segment_ids: A Tensor. Must be one of the following types: int32int64. A 1-D tensor whose rank is equal to the rank of data's first dimension.
  • num_segments: A Tensor of type int32.
  • name: A name for the operation (optional).
Returns:

Tensor. Has the same type as data. Has same shape as data, except for dimension_0 which has size num_segments.


tf.sparse_segment_sum(data, indices, segment_ids, name=None)

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: float32float64int32int64uint8int16int8.
  • indices: A Tensor of type int32. 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:

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)

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: float32float64.
  • indices: A Tensor of type int32. 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:

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, dimension, name=None)

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

Args:
  • input: A Tensor. Must be one of the following types: float32float64int64int32uint8int16int8complex64qint8quint8qint32.
  • dimension: A Tensor of type int32. int32, 0 <= dimension < rank(input). Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0.
  • name: A name for the operation (optional).
Returns:

Tensor of type int64.


tf.argmax(input, dimension, name=None)

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

Args:
  • input: A Tensor. Must be one of the following types: float32float64int64int32uint8int16int8complex64qint8quint8qint32.
  • dimension: A Tensor of type int32. int32, 0 <= dimension < rank(input). Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0.
  • name: A name for the operation (optional).
Returns:

Tensor of type int64.


tf.listdiff(x, y, name=None)

Computes the difference between two lists of numbers.

Given a list x and a list y, this operation returns a list out that represents all numbers that are in xbut 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.
  • 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 int32. 1-D. Positions of x values preserved in out.

tf.where(input, name=None)

Returns locations of true values in a boolean tensor.

This operation returns the coordinates of true elements in input. 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.

For example:

# 'input' tensor is [[True, False]
#                    [True, False]]
# 'input' has two true values, so output has two coordinates.
# 'input' has rank of 2, so coordinates have two indices.
where(input) ==> [[0, 0],
                  [1, 0]]

# `input` tensor is [[[True, False]
#                     [True, False]]
#                    [[False, True]
#                     [False, True]]
#                    [[False, False]
#                     [False, True]]]
# 'input' has 5 true values, so output has 5 coordinates.
# 'input' has rank of 3, so coordinates have three indices.
where(input) ==> [[0, 0, 0],
                  [0, 1, 0],
                  [1, 0, 1],
                  [1, 1, 1],
                  [2, 1, 1]]
Args:
  • input: A Tensor of type bool.
  • name: A name for the operation (optional).
Returns:

Tensor of type int64.


tf.unique(x, name=None)

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.
  • 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 int32. 1-D.

tf.edit_distance(hypothesis, truth, normalize=True, name='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)

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 ouput 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 of type int32. 1-D.
  • name: A name for the operation (optional).
Returns:

Tensor of type int32. 1-D.

相关文章
|
3月前
|
机器学习/深度学习 JSON JavaScript
图文讲解 Stable Diffusion API 调用教程
Stable Diffusion 是一个先进的深度学习模型,用于创造和修改图像。这个模型能够基于文本描述来生成图像,让机器理解和实现用户的创意。使用这项技术的关键在于掌握其 API,通过编程来操控图像生成的过程。
|
19小时前
|
数据采集 监控 安全
各种业务场景调用API代理的API接口教程
API代理的API接口在各种业务场景中具有广泛的应用,本文将介绍哪些业务场景可以使用API代理的API接口,并提供详细的调用教程和代码演示,同时,我们还将讨论在不同场景下使用API代理的API接口所带来的好处。
|
2天前
|
存储 负载均衡 API
部署大模型API的实战教程
部署大模型API的实战教程可以分为以下步骤:
|
24天前
|
机器学习/深度学习 人工智能 API
人工智能应用工程师技能提升系列2、——TensorFlow2——keras高级API训练神经网络模型
人工智能应用工程师技能提升系列2、——TensorFlow2——keras高级API训练神经网络模型
14 0
|
3月前
|
存储 API 数据安全/隐私保护
2021年最新最全Flink系列教程__Flink高级API(四)
2021年最新最全Flink系列教程__Flink高级API(四)
31 0
|
3月前
|
消息中间件 API 数据安全/隐私保护
2021年最新最全Flink系列教程__Flink高级API(三)
2021年最新最全Flink系列教程__Flink高级API(三)
12 0
|
10天前
|
数据采集 数据挖掘 API
主流电商平台数据采集API接口|【Python爬虫+数据分析】采集电商平台数据信息采集
随着电商平台的兴起,越来越多的人开始在网上购物。而对于电商平台来说,商品信息、价格、评论等数据是非常重要的。因此,抓取电商平台的商品信息、价格、评论等数据成为了一项非常有价值的工作。本文将介绍如何使用Python编写爬虫程序,抓取电商平台的商品信息、价格、评论等数据。 当然,如果是电商企业,跨境电商企业,ERP系统搭建,我们经常需要采集的平台多,数据量大,要求数据稳定供应,有并发需求,那就需要通过接入电商API数据采集接口,封装好的数据采集接口更方便稳定高效数据采集。
|
1天前
|
API 开发者 Python
亚马逊API接口推荐:亚马逊商品详情数据接口和商品列表数据接口
亚马逊API接口推荐:亚马逊商品详情数据接口和商品列表数据接口
10 0
|
1天前
|
API PHP 开发者
大麦网 API 接口商品详情信息 API
为了让更多用户了解到大麦网的商品详情,并能够方便地获取相关信息,大麦网推出了商品详情 API 接口。本文将介绍大麦网商品详情 API 接口的作用、使用方法和注意事项,帮助广大开发者更加方便地接入大麦网的产品。
|
3天前
|
API 开发工具 数据安全/隐私保护
API接口的对接流程和注意事项
随着互联网技术的发展和应用的普及,API接口已经成为不同系统、不同应用之间进行交互和数据交换的重要方式。API接口使得不同的系统能够互相调用对方的功能,提高了系统的灵活性和扩展性。但是,在进行API接口对接的过程中,需要注意一些流程和事项,以确保对接的顺利进行和系统的稳定运行。

相关产品