neulab/docprompting-conala huggingface dataset:
tf.raw_ops.MapUnstageNoKey Op removes and returns a random (key, value)  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MapUnstageNoKey  
tf.raw_ops.MapUnstageNoKey(
    indices, dtypes, capacity=0, memory_limit=0, container='',
    shared_name='', name=None
)
 from the underlying container. If the underlying container does not contain elements, the op will block until it does.
 


 Args
  indices   A Tensor of type int32.  
  dtypes   A list of tf.DTypes that has length >= 1.  
  capacity   An optional int that is >= 0. Defaults to 0.  
  memory_limit   An optional int that is >= 0. Defaults to 0.  
  container   An optional string. Defaults to "".  
  shared_name   An optional string. Defaults to "".  
  name   A name for the operation (optional).   
 


 Returns   A tuple of Tensor objects (key, values).     key   A Tensor of type int64.  
  values   A list of Tensor objects of type dtypes.
tf.raw_ops.MatchingFiles Returns the set of files matching one or more glob patterns.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatchingFiles  
tf.raw_ops.MatchingFiles(
    pattern, name=None
)
 Note that this routine only supports wildcard characters in the basename portion of the pattern, not in the directory portion. Note also that the order of filenames returned is deterministic.
 


 Args
  pattern   A Tensor of type string. Shell wildcard pattern(s). Scalar or vector of type string.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type string.
tf.raw_ops.MatchingFilesDataset  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatchingFilesDataset  
tf.raw_ops.MatchingFilesDataset(
    patterns, name=None
)

 


 Args
  patterns   A Tensor of type string.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type variant.
tf.raw_ops.MatMul Multiply the matrix "a" by the matrix "b".  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatMul  
tf.raw_ops.MatMul(
    a, b, transpose_a=False, transpose_b=False, name=None
)
 The inputs must be two-dimensional matrices and the inner dimension of "a" (after being transposed if transpose_a is true) must match the outer dimension of "b" (after being transposed if transposed_b is true). 
Note: The default kernel implementation for MatMul on GPUs uses cublas.

 


 Args
  a   A Tensor. Must be one of the following types: bfloat16, half, float32, float64, int32, int64, complex64, complex128.  
  b   A Tensor. Must have the same type as a.  
  transpose_a   An optional bool. Defaults to False. If true, "a" is transposed before multiplication.  
  transpose_b   An optional bool. Defaults to False. If true, "b" is transposed before multiplication.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as a.
tf.raw_ops.MatrixBandPart Copy a tensor setting everything outside a central band in each innermost matrix to zero.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixBandPart  
tf.raw_ops.MatrixBandPart(
    input, num_lower, num_upper, name=None
)
 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. Must be one of the following types: int32, int64. 0-D tensor. Number of subdiagonals to keep. If negative, keep entire lower triangle.  
  num_upper   A Tensor. Must have the same type as num_lower. 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.
tf.raw_ops.MatrixDeterminant Computes the determinant of one or more square matrices.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixDeterminant  
tf.raw_ops.MatrixDeterminant(
    input, name=None
)
 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: half, float32, float64, complex64, complex128. Shape is [..., M, M].  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as input.
tf.raw_ops.MatrixDiag Returns a batched diagonal tensor with a given batched diagonal values.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixDiag  
tf.raw_ops.MatrixDiag(
    diagonal, name=None
)
 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.
tf.raw_ops.MatrixDiagPart Returns the batched diagonal part of a batched tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixDiagPart  
tf.raw_ops.MatrixDiagPart(
    input, name=None
)
 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.
tf.raw_ops.MatrixDiagPartV2 Returns the batched diagonal part of a batched tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixDiagPartV2  
tf.raw_ops.MatrixDiagPartV2(
    input, k, padding_value, name=None
)
 Returns a tensor with the k[0]-th to k[1]-th diagonals of the batched input. Assume input has r dimensions [I, J, ..., L, M, N]. Let max_diag_len be the maximum length among all diagonals to be extracted, max_diag_len = min(M + min(k[1], 0), N + min(-k[0], 0)) Let num_diags be the number of diagonals to extract, num_diags = k[1] - k[0] + 1. If num_diags == 1, the output tensor is of rank r - 1 with shape [I, J, ..., L, max_diag_len] and values: diagonal[i, j, ..., l, n]
  = input[i, j, ..., l, n+y, n+x] ; if 0 <= n+y < M and 0 <= n+x < N,
    padding_value                 ; otherwise.
 where y = max(-k[1], 0), x = max(k[1], 0). Otherwise, the output tensor has rank r with dimensions [I, J, ..., L, num_diags, max_diag_len] with values: diagonal[i, j, ..., l, m, n]
  = input[i, j, ..., l, n+y, n+x] ; if 0 <= n+y < M and 0 <= n+x < N,
    padding_value                 ; otherwise.
 where d = k[1] - m, y = max(-d, 0), and x = max(d, 0). The input must be at least a matrix. For example: input = np.array([[[1, 2, 3, 4],  # Input shape: (2, 3, 4)
                   [5, 6, 7, 8],
                   [9, 8, 7, 6]],
                  [[5, 4, 3, 2],
                   [1, 2, 3, 4],
                   [5, 6, 7, 8]]])

# A main diagonal from each batch.
tf.matrix_diag_part(input) ==> [[1, 6, 7],  # Output shape: (2, 3)
                                [5, 2, 7]]

# A superdiagonal from each batch.
tf.matrix_diag_part(input, k = 1)
  ==> [[2, 7, 6],  # Output shape: (2, 3)
       [4, 3, 8]]

# A tridiagonal band from each batch.
tf.matrix_diag_part(input, k = (-1, 1))
  ==> [[[2, 7, 6],  # Output shape: (2, 3, 3)
        [1, 6, 7],
        [5, 8, 0]],
       [[4, 3, 8],
        [5, 2, 7],
        [1, 6, 0]]]

# Padding value = 9
tf.matrix_diag_part(input, k = (1, 3), padding_value = 9)
  ==> [[[4, 9, 9],  # Output shape: (2, 3, 3)
        [3, 8, 9],
        [2, 7, 6]],
       [[2, 9, 9],
        [3, 4, 9],
        [4, 3, 8]]]

 


 Args
  input   A Tensor. Rank r tensor where r >= 2.  
  k   A Tensor of type int32. Diagonal offset(s). Positive value means superdiagonal, 0 refers to the main diagonal, and negative value means subdiagonals. k can be a single integer (for a single diagonal) or a pair of integers specifying the low and high ends of a matrix band. k[0] must not be larger than k[1].  
  padding_value   A Tensor. Must have the same type as input. The value to fill the area outside the specified diagonal band with. Default is 0.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as input.
tf.raw_ops.MatrixExponential Deprecated, use python implementation tf.linalg.matrix_exponential.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixExponential  
tf.raw_ops.MatrixExponential(
    input, name=None
)

 


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


 Returns   A Tensor. Has the same type as input.
tf.raw_ops.MatrixInverse Computes the inverse of one or more square invertible matrices or their adjoints (conjugate transposes).  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixInverse  
tf.raw_ops.MatrixInverse(
    input, adjoint=False, name=None
)
 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, half, complex64, complex128. 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.
tf.raw_ops.MatrixLogarithm   Computes the matrix logarithm of one or more square matrices:  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixLogarithm  
tf.raw_ops.MatrixLogarithm(
    input, name=None
)
 \(log(exp(A)) = A\) This op is only defined for complex matrices. If A is positive-definite and real, then casting to a complex matrix, taking the logarithm and casting back to a real matrix will give the correct result. This function computes the matrix logarithm using the Schur-Parlett algorithm. Details of the algorithm can be found in Section 11.6.2 of: Nicholas J. Higham, Functions of Matrices: Theory and Computation, SIAM 2008. ISBN 978-0-898716-46-7. 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 exponential for all input submatrices [..., :, :].
 


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


 Returns   A Tensor. Has the same type as input.
tf.raw_ops.MatrixSetDiag Returns a batched matrix tensor with new batched diagonal values.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixSetDiag  
tf.raw_ops.MatrixSetDiag(
    input, diagonal, name=None
)
 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.
tf.raw_ops.MatrixSolve Solves systems of linear equations.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixSolve  
tf.raw_ops.MatrixSolve(
    matrix, rhs, adjoint=False, name=None
)
 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, half, 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.
tf.raw_ops.MatrixSolveLs   Solves one or more linear least-squares problems.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixSolveLs  
tf.raw_ops.MatrixSolveLs(
    matrix, rhs, l2_regularizer, fast=True, name=None
)
 matrix is a tensor of shape [..., M, N] whose inner-most 2 dimensions form real or complex matrices of size [M, N]. Rhs is a tensor of the same type as matrix and shape [..., M, K]. The output is a tensor shape [..., N, K] where each output matrix solves each of the equations matrix[..., :, :] * output[..., :, :] = rhs[..., :, :] in the least squares sense. We use the following notation for (complex) matrix and right-hand sides in the batch: matrix=\(A \in \mathbb{C}^{m \times n}\), rhs=\(B \in \mathbb{C}^{m \times k}\), output=\(X \in \mathbb{C}^{n \times k}\), l2_regularizer=\(\lambda \in \mathbb{R}\). 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^H A + \lambda I)^{-1} A^H 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^H (A A^H + \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 \mathbb{C}^{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   A Tensor. Must be one of the following types: float64, float32, half, complex64, complex128. Shape is [..., M, N].  
  rhs   A Tensor. Must have the same type as matrix. Shape is [..., M, K].  
  l2_regularizer   A Tensor of type float64. Scalar tensor.  
  fast   An optional bool. Defaults to True.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as matrix.  
 Numpy Compatibility Equivalent to np.linalg.lstsq
tf.raw_ops.MatrixSquareRoot Computes the matrix square root of one or more square matrices:  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixSquareRoot  
tf.raw_ops.MatrixSquareRoot(
    input, name=None
)
 matmul(sqrtm(A), sqrtm(A)) = A The input matrix should be invertible. If the input matrix is real, it should have no eigenvalues which are real and negative (pairs of complex conjugate eigenvalues are allowed). The matrix square root is computed by first reducing the matrix to quasi-triangular form with the real Schur decomposition. The square root of the quasi-triangular matrix is then computed directly. Details of the algorithm can be found in: Nicholas J. Higham, "Computing real square roots of a real matrix", Linear Algebra Appl., 1987. 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 matrix square root for all input submatrices [..., :, :].
 


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


 Returns   A Tensor. Has the same type as input.
tf.raw_ops.MatrixTriangularSolve Solves systems of linear equations with upper or lower triangular matrices by backsubstitution.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixTriangularSolve  
tf.raw_ops.MatrixTriangularSolve(
    matrix, rhs, lower=True, adjoint=False, name=None
)
 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, N]. The output is a tensor of shape [..., M, N]. If adjoint is True then the innermost matrices in output satisfy matrix equations matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]. If adjoint is False then the strictly then the innermost matrices in output satisfy matrix equations adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]. Note, the batch shapes for the inputs only need to broadcast. Example: 
a = tf.constant([[3,  0,  0,  0],
                 [2,  1,  0,  0],
                 [1,  0,  1,  0],
                 [1,  1,  1,  1]], dtype=tf.float32)

b = tf.constant([[4],
                 [2],
                 [4],
                 [2]], dtype=tf.float32)

x = tf.linalg.triangular_solve(a, b, lower=True)
x
# <tf.Tensor: shape=(4, 1), dtype=float32, numpy=
# array([[ 1.3333334 ],
#        [-0.66666675],
#        [ 2.6666665 ],
#        [-1.3333331 ]], dtype=float32)>

# in python3 one can use `a@x`
tf.matmul(a, x)
# <tf.Tensor: shape=(4, 1), dtype=float32, numpy=
# array([[4.       ],
#        [2.       ],
#        [4.       ],
#        [1.9999999]], dtype=float32)>

 


 Args
  matrix   A Tensor. Must be one of the following types: float64, float32, half, complex64, complex128. 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.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as matrix.  
 Numpy Compatibility Equivalent to scipy.linalg.solve_triangular
tf.raw_ops.Max Computes the maximum of elements across dimensions of a tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.Max  
tf.raw_ops.Max(
    input, axis, keep_dims=False, name=None
)
 Reduces input 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.
 


 Args
  input   A Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, int64, bfloat16, uint16, half, uint32, uint64, qint8, quint8, qint32, qint16, quint16. The tensor to reduce.  
  axis   A Tensor. Must be one of the following types: int32, int64. The dimensions to reduce. Must be in the range [-rank(input), rank(input)).  
  keep_dims   An optional bool. Defaults to False. If true, retain reduced dimensions with length 1.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as input.
tf.raw_ops.Maximum Returns the max of x and y (i.e. x > y ? x : y) element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.Maximum  
tf.raw_ops.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.raw_ops.MaxIntraOpParallelismDataset Creates a dataset that overrides the maximum intra-op parallelism.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.MaxIntraOpParallelismDataset  
tf.raw_ops.MaxIntraOpParallelismDataset(
    input_dataset, max_intra_op_parallelism, output_types, output_shapes, name=None
)

 


 Args
  input_dataset   A Tensor of type variant.  
  max_intra_op_parallelism   A Tensor of type int64. Identifies the maximum intra-op parallelism to use.  
  output_types   A list of tf.DTypes that has length >= 1.  
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type variant.