neulab/docprompting-conala huggingface dataset:
tf.math.invert_permutation Computes the inverse permutation of a tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.invert_permutation, tf.compat.v1.math.invert_permutation  
tf.math.invert_permutation(
    x, name=None
)
 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.
tf.math.in_top_k       View source on GitHub    Says whether the targets are in the top K predictions.  View aliases  Main aliases 
tf.nn.in_top_k  
tf.math.in_top_k(
    targets, predictions, k, name=None
)
 This outputs a batch_size bool array, an entry out[i] is true if the prediction for the target class is finite (not inf, -inf, or nan) and among the top k predictions among all predictions for example i. Note that the behavior of InTopK differs from the TopK op in its handling of ties; if multiple classes have the same prediction value and straddle the top-k boundary, all of those classes are considered to be in the top k. More formally, let \(predictions_i\) be the predictions for all classes for example i, \(targets_i\) be the target class for example i, \(out_i\) be the output for example i,  $$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$ 
 


 Args
  predictions   A Tensor of type float32. A batch_size x classes tensor.  
  targets   A Tensor. Must be one of the following types: int32, int64. A batch_size vector of class ids.  
  k   An int. Number of top elements to look at for computing precision.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type bool. Computed Precision at k as a bool Tensor.
tf.math.is_finite Returns which elements of x are finite.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.debugging.is_finite, tf.compat.v1.is_finite, tf.compat.v1.math.is_finite  
tf.math.is_finite(
    x, name=None
)
 Example: x = tf.constant([5.0, 4.8, 6.8, np.inf, np.nan])
tf.math.is_finite(x) ==> [True, True, True, False, False]

 


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


 Returns   A Tensor of type bool.  
 Numpy Compatibility Equivalent to np.isfinite
tf.math.is_inf Returns which elements of x are Inf.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.debugging.is_inf, tf.compat.v1.is_inf, tf.compat.v1.math.is_inf  
tf.math.is_inf(
    x, name=None
)
 Example: x = tf.constant([5.0, np.inf, 6.8, np.inf])
tf.math.is_inf(x) ==> [False, True, False, True]

 


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


 Returns   A Tensor of type bool.  
 Numpy Compatibility Equivalent to np.isinf
tf.math.is_nan Returns which elements of x are NaN.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.debugging.is_nan, tf.compat.v1.is_nan, tf.compat.v1.math.is_nan  
tf.math.is_nan(
    x, name=None
)
 Example: x = tf.constant([5.0, np.nan, 6.8, np.nan, np.inf])
tf.math.is_nan(x) ==> [False, True, False, True, False]

 


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


 Returns   A Tensor of type bool.  
 Numpy Compatibility Equivalent to np.isnan
tf.math.is_non_decreasing     View source on GitHub    Returns True if x is non-decreasing.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.debugging.is_non_decreasing, tf.compat.v1.is_non_decreasing, tf.compat.v1.math.is_non_decreasing  
tf.math.is_non_decreasing(
    x, name=None
)
 Elements of x are compared in row-major order. The tensor [x[0],...] is non-decreasing if for every adjacent pair we have x[i] <= x[i+1]. If x has less than two elements, it is trivially non-decreasing. See also: is_strictly_increasing 
x1 = tf.constant([1.0, 1.0, 3.0])
tf.math.is_non_decreasing(x1)
<tf.Tensor: shape=(), dtype=bool, numpy=True>
x2 = tf.constant([3.0, 1.0, 2.0])
tf.math.is_non_decreasing(x2)
<tf.Tensor: shape=(), dtype=bool, numpy=False>

 


 Args
  x   Numeric Tensor.  
  name   A name for this operation (optional). Defaults to "is_non_decreasing"   
 


 Returns   Boolean Tensor, equal to True iff x is non-decreasing.  

 


 Raises
  TypeError   if x is not a numeric tensor.
tf.math.is_strictly_increasing     View source on GitHub    Returns True if x is strictly increasing.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.debugging.is_strictly_increasing, tf.compat.v1.is_strictly_increasing, tf.compat.v1.math.is_strictly_increasing  
tf.math.is_strictly_increasing(
    x, name=None
)
 Elements of x are compared in row-major order. The tensor [x[0],...] is strictly increasing if for every adjacent pair we have x[i] < x[i+1]. If x has less than two elements, it is trivially strictly increasing. See also: is_non_decreasing 
x1 = tf.constant([1.0, 2.0, 3.0])
tf.math.is_strictly_increasing(x1)
<tf.Tensor: shape=(), dtype=bool, numpy=True>
x2 = tf.constant([3.0, 1.0, 2.0])
tf.math.is_strictly_increasing(x2)
<tf.Tensor: shape=(), dtype=bool, numpy=False>

 


 Args
  x   Numeric Tensor.  
  name   A name for this operation (optional). Defaults to "is_strictly_increasing"   
 


 Returns   Boolean Tensor, equal to True iff x is strictly increasing.  

 


 Raises
  TypeError   if x is not a numeric tensor.
tf.math.l2_normalize     View source on GitHub    Normalizes along dimension axis using an L2 norm.  View aliases  Main aliases 
tf.linalg.l2_normalize, tf.nn.l2_normalize  
tf.math.l2_normalize(
    x, axis=None, epsilon=1e-12, name=None
)
 For a 1-D tensor with axis = 0, computes output = x / sqrt(max(sum(x**2), epsilon))
 For x with more dimensions, independently normalizes each 1-D slice along dimension axis.
 


 Args
  x   A Tensor.  
  axis   Dimension along which to normalize. A scalar or a vector of integers.  
  epsilon   A lower bound value for the norm. Will use sqrt(epsilon) as the divisor if norm < sqrt(epsilon).  
  name   A name for this operation (optional).   
 


 Returns   A Tensor with the same shape as x.
tf.math.lbeta       View source on GitHub    Computes \(ln(|Beta(x)|)\), reducing along the last dimension.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.lbeta, tf.compat.v1.math.lbeta  
tf.math.lbeta(
    x, name=None
)
 Given one-dimensional $z = [z_1,...,z_K]$, we define  $$Beta(z) = \frac{\prod_j \Gamma(z_j)}{\Gamma(\sum_j z_j)},$$  where $\Gamma$ is the gamma function. And for $n + 1$ dimensional $x$ with shape $[N_1, ..., N_n, K]$, we define  $$lbeta(x)[i_1, ..., i_n] = \log{|Beta(x[i_1, ..., i_n, :])|}.$$  In other words, the last dimension is treated as the $z$ vector. Note that if $z = [u, v]$, then  $$Beta(z) = \frac{\Gamma(u)\Gamma(v)}{\Gamma(u + v)} = \int_0^1 t^{u-1} (1 - t)^{v-1} \mathrm{d}t,$$  which defines the traditional bivariate beta function. If the last dimension is empty, we follow the convention that the sum over the empty set is zero, and the product is one.
 


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


 Returns   The logarithm of \(|Beta(x)|\) reducing along the last dimension.
tf.math.less Returns the truth value of (x < y) element-wise.  View aliases  Main aliases 
tf.less Compat aliases for migration See Migration guide for more details. tf.compat.v1.less, tf.compat.v1.math.less  
tf.math.less(
    x, y, name=None
)
 
Note: math.less supports broadcasting. More about broadcasting here
 Example: x = tf.constant([5, 4, 6])
y = tf.constant([5])
tf.math.less(x, y) ==> [False, True, False]

x = tf.constant([5, 4, 6])
y = tf.constant([5, 6, 7])
tf.math.less(x, y) ==> [False, True, True]

 


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


 Returns   A Tensor of type bool.
tf.math.less_equal Returns the truth value of (x <= y) element-wise.  View aliases  Main aliases 
tf.less_equal Compat aliases for migration See Migration guide for more details. tf.compat.v1.less_equal, tf.compat.v1.math.less_equal  
tf.math.less_equal(
    x, y, name=None
)
 
Note: math.less_equal supports broadcasting. More about broadcasting here
 Example: x = tf.constant([5, 4, 6])
y = tf.constant([5])
tf.math.less_equal(x, y) ==> [True, True, False]

x = tf.constant([5, 4, 6])
y = tf.constant([5, 6, 6])
tf.math.less_equal(x, y) ==> [True, True, True]

 


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


 Returns   A Tensor of type bool.
tf.math.lgamma Computes the log of the absolute value of Gamma(x) element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.lgamma, tf.compat.v1.math.lgamma  
tf.math.lgamma(
    x, name=None
)
 For positive numbers, this function computes log((input - 1)!) for every element in the tensor. lgamma(5) = log((5-1)!) = log(4!) = log(24) = 3.1780539 Example: x = tf.constant([0, 0.5, 1, 4.5, -4, -5.6])
tf.math.lgamma(x) ==> [inf, 0.5723649, 0., 2.4537368, inf, -4.6477685]

 


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


 Returns   A Tensor. Has the same type as x.
tf.math.log   Computes natural logarithm of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.log, tf.compat.v1.math.log  
tf.math.log(
    x, name=None
)
 I.e., \(y = \log_e x\). Example:  x = tf.constant([0, 0.5, 1, 5]) tf.math.log(x)   See: https://en.wikipedia.org/wiki/Logarithm
 


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


 Returns   A Tensor. Has the same type as x.
tf.math.log1p   Computes natural logarithm of (1 + x) element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.log1p, tf.compat.v1.math.log1p  
tf.math.log1p(
    x, name=None
)
 I.e., \(y = \log_e (1 + x)\). Example: 
x = tf.constant([0, 0.5, 1, 5])
tf.math.log1p(x)
<tf.Tensor: shape=(4,), dtype=float32, numpy=array([0.       , 0.4054651, 0.6931472, 1.7917595], dtype=float32)>

 


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


 Returns   A Tensor. Has the same type as x.
tf.math.logical_and     View source on GitHub    Logical AND function.  View aliases  Main aliases 
tf.logical_and Compat aliases for migration See Migration guide for more details. tf.compat.v1.logical_and, tf.compat.v1.math.logical_and  
tf.math.logical_and(
    x, y, name=None
)
 The operation works for the following input types:  Two single elements of type bool
 One tf.Tensor of type bool and one single bool, where the result will be calculated by applying logical AND with the single element to each element in the larger Tensor. Two tf.Tensor objects of type bool of the same shape. In this case, the result will be the element-wise logical AND of the two input tensors.  Usage: 
a = tf.constant([True])
b = tf.constant([False])
tf.math.logical_and(a, b)
<tf.Tensor: shape=(1,), dtype=bool, numpy=array([False])>
 
c = tf.constant([True])
x = tf.constant([False, True, True, False])
tf.math.logical_and(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False,  True,  True, False])>
 
y = tf.constant([False, False, True, True])
z = tf.constant([False, True, False, True])
tf.math.logical_and(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False, False, False,  True])>

 


 Args
  x   A tf.Tensor type bool.  
  y   A tf.Tensor of type bool.  
  name   A name for the operation (optional).   
 


 Returns   A tf.Tensor of type bool with the same size as that of x or y.
tf.math.logical_not Returns the truth value of NOT x element-wise.  View aliases  Main aliases 
tf.logical_not Compat aliases for migration See Migration guide for more details. tf.compat.v1.logical_not, tf.compat.v1.math.logical_not  
tf.math.logical_not(
    x, name=None
)
 Example: 
tf.math.logical_not(tf.constant([True, False]))
<tf.Tensor: shape=(2,), dtype=bool, numpy=array([False,  True])>

 


 Args
  x   A Tensor of type bool. A Tensor of type bool.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type bool.
tf.math.logical_or Returns the truth value of x OR y element-wise.  View aliases  Main aliases 
tf.logical_or Compat aliases for migration See Migration guide for more details. tf.compat.v1.logical_or, tf.compat.v1.math.logical_or  
tf.math.logical_or(
    x, y, name=None
)
 
Note: math.logical_or supports broadcasting. More about broadcasting here

 


 Args
  x   A Tensor of type bool.  
  y   A Tensor of type bool.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type bool.
tf.math.logical_xor     View source on GitHub    Logical XOR function.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.logical_xor, tf.compat.v1.math.logical_xor  
tf.math.logical_xor(
    x, y, name='LogicalXor'
)
 x ^ y = (x | y) & ~(x & y) The operation works for the following input types:  Two single elements of type bool
 One tf.Tensor of type bool and one single bool, where the result will be calculated by applying logical XOR with the single element to each element in the larger Tensor. Two tf.Tensor objects of type bool of the same shape. In this case, the result will be the element-wise logical XOR of the two input tensors.  Usage: 
a = tf.constant([True])
b = tf.constant([False])
tf.math.logical_xor(a, b)
<tf.Tensor: shape=(1,), dtype=bool, numpy=array([ True])>
 
c = tf.constant([True])
x = tf.constant([False, True, True, False])
tf.math.logical_xor(c, x)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([ True, False, False,  True])>
 
y = tf.constant([False, False, True, True])
z = tf.constant([False, True, False, True])
tf.math.logical_xor(y, z)
<tf.Tensor: shape=(4,), dtype=bool, numpy=array([False,  True,  True, False])>

 


 Args
  x   A tf.Tensor type bool.  
  y   A tf.Tensor of type bool.  
  name   A name for the operation (optional).   
 


 Returns   A tf.Tensor of type bool with the same size as that of x or y.
tf.math.log_sigmoid     View source on GitHub    Computes log sigmoid of x element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.log_sigmoid, tf.compat.v1.math.log_sigmoid  
tf.math.log_sigmoid(
    x, name=None
)
 Specifically, y = log(1 / (1 + exp(-x))). For numerical stability, we use y = -tf.nn.softplus(-x).
 


 Args
  x   A Tensor with type float32 or float64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor with the same type as x.  
 Usage Example: If a positive number is large, then its log_sigmoid will approach to 0 since the formula will be y = log( <large_num> / (1 + <large_num>) ) which approximates to log (1) which is 0. 
x = tf.constant([0.0, 1.0, 50.0, 100.0])
tf.math.log_sigmoid(x)
<tf.Tensor: shape=(4,), dtype=float32, numpy=
array([-6.9314718e-01, -3.1326169e-01, -1.9287499e-22, -0.0000000e+00],
      dtype=float32)>
 If a negative number is large, its log_sigmoid will approach to the number itself since the formula will be y = log( 1 / (1 + <large_num>) ) which is log (1) - log ( (1 + <large_num>) ) which approximates to - <large_num> that is the number itself. 
x = tf.constant([-100.0, -50.0, -1.0, 0.0])
tf.math.log_sigmoid(x)
<tf.Tensor: shape=(4,), dtype=float32, numpy=
array([-100.       ,  -50.       ,   -1.3132616,   -0.6931472],
      dtype=float32)>
tf.math.maximum Returns the max of x and y (i.e. x > y ? x : y) element-wise.  View aliases  Main aliases 
tf.maximum Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.maximum, tf.compat.v1.maximum  
tf.math.maximum(
    x, y, name=None
)
 Example: 
x = tf.constant([0., 0., 0., 0.])
y = tf.constant([-2., 0., 2., 5.])
tf.math.maximum(x, y)
<tf.Tensor: shape=(4,), dtype=float32, numpy=array([0., 0., 2., 5.], dtype=float32)>

 


 Args
  x   A Tensor. Must be one of the following types: bfloat16, half, float32, float64, uint8, int16, 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.math.minimum Returns the min of x and y (i.e. x < y ? x : y) element-wise.  View aliases  Main aliases 
tf.minimum Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.minimum, tf.compat.v1.minimum  
tf.math.minimum(
    x, y, name=None
)
 Both inputs are number-type tensors (except complex). minimum expects that both tensors have the same dtype. Examples: 
x = tf.constant([0., 0., 0., 0.])
y = tf.constant([-5., -2., 0., 3.])
tf.math.minimum(x, y)
<tf.Tensor: shape=(4,), dtype=float32, numpy=array([-5., -2., 0., 0.], dtype=float32)>
 Note that minimum supports broadcast semantics. 
x = tf.constant([-5., 0., 0., 0.])
y = tf.constant([-3.])
tf.math.minimum(x, y)
<tf.Tensor: shape=(4,), dtype=float32, numpy=array([-5., -3., -3., -3.], dtype=float32)>
 If inputs are not tensors, they will be converted to tensors. See tf.convert_to_tensor. 
x = tf.constant([-3.], dtype=tf.float32)
tf.math.minimum([-5], x)
<tf.Tensor: shape=(1,), dtype=float32, numpy=array([-5.], dtype=float32)>

 


 Args
  x   A Tensor. Must be one of the following types: bfloat16, half, float32, float64, uint8, int16, 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.math.multiply     View source on GitHub    Returns an element-wise x * y.  View aliases  Main aliases 
tf.multiply Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.multiply, tf.compat.v1.multiply  
tf.math.multiply(
    x, y, name=None
)
 For example: 
x = tf.constant(([1, 2, 3, 4]))
tf.math.multiply(x, x)
<tf.Tensor: shape=(4,), dtype=..., numpy=array([ 1,  4,  9, 16], dtype=int32)>
 Since tf.math.multiply will convert its arguments to Tensors, you can also pass in non-Tensor arguments: 
tf.math.multiply(7,6)
<tf.Tensor: shape=(), dtype=int32, numpy=42>
 If x.shape is not thes same as y.shape, they will be broadcast to a compatible shape. (More about broadcasting here.) For example: 
x = tf.ones([1, 2]);
y = tf.ones([2, 1]);
x * y  # Taking advantage of operator overriding
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[1., 1.],
     [1., 1.]], dtype=float32)>

 


 Args
  x   A Tensor. Must be one of the following types: bfloat16, 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.
 


 Raises    InvalidArgumentError: When x and y have incomptatible shapes or types.
tf.math.multiply_no_nan     View source on GitHub    Computes the product of x and y and returns 0 if the y is zero, even if x is NaN or infinite.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.multiply_no_nan  
tf.math.multiply_no_nan(
    x, y, name=None
)

 


 Args
  x   A Tensor. Must be one of the following types: float32, float64.  
  y   A Tensor whose dtype is compatible with x.  
  name   A name for the operation (optional).   
 


 Returns   The element-wise value of the x times y.
tf.math.ndtri Compute quantile of Standard Normal.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.ndtri  
tf.math.ndtri(
    x, name=None
)

 


 Args
  x   Tensor with type float or double.  
  name   A name for the operation (optional).   
 


 Returns   Inverse error function of x.
tf.math.negative   Computes numerical negative value element-wise.  View aliases  Main aliases 
tf.negative Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.negative, tf.compat.v1.negative  
tf.math.negative(
    x, name=None
)
 I.e., \(y = -x\).
 


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


 Returns   A Tensor. Has the same type as x. If x is a SparseTensor, returns SparseTensor(x.indices, tf.math.negative(x.values, ...), x.dense_shape)
tf.math.nextafter Returns the next representable value of x1 in the direction of x2, element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.nextafter  
tf.math.nextafter(
    x1, x2, name=None
)
 This operation returns the same result as the C++ std::nextafter function. It can also return a subnormal number.
 


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


 Returns   A Tensor. Has the same type as x1.  
 Cpp Compatibility Equivalent to C++ std::nextafter function.
tf.math.not_equal     View source on GitHub    Returns the truth value of (x != y) element-wise.  View aliases  Main aliases 
tf.not_equal Compat aliases for migration See Migration guide for more details. tf.compat.v1.math.not_equal, tf.compat.v1.not_equal  
tf.math.not_equal(
    x, y, name=None
)
 Performs a broadcast with the arguments and then an element-wise inequality comparison, returning a Tensor of boolean values. For example: 
x = tf.constant([2, 4])
y = tf.constant(2)
tf.math.not_equal(x, y)
<tf.Tensor: shape=(2,), dtype=bool, numpy=array([False,  True])>
 
x = tf.constant([2, 4])
y = tf.constant([2, 4])
tf.math.not_equal(x, y)
<tf.Tensor: shape=(2,), dtype=bool, numpy=array([False,  False])>

 


 Args
  x   A tf.Tensor or tf.sparse.SparseTensor or tf.IndexedSlices.  
  y   A tf.Tensor or tf.sparse.SparseTensor or tf.IndexedSlices.  
  name   A name for the operation (optional).   
 


 Returns   A tf.Tensor of type bool with the same size as that of x or y.  

 


 Raises   tf.errors.InvalidArgumentError: If shapes of arguments are incompatible
tf.math.polygamma   Compute the polygamma function \(\psi^{(n)}(x)\).  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.math.polygamma, tf.compat.v1.polygamma  
tf.math.polygamma(
    a, x, name=None
)
 The polygamma function is defined as: \(\psi^{(a)}(x) = \frac{d^a}{dx^a} \psi(x)\) where \(\psi(x)\) is the digamma function. The polygamma function is defined only for non-negative integer orders \a\.
 


 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.