tf.raw_ops.LoadTPUEmbeddingAdagradParametersGradAccumDebug Load Adagrad embedding parameters with debug support.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingAdagradParametersGradAccumDebug
tf.raw_ops.LoadTPUEmbeddingAdagradParametersGradAccumDebug(
    parameters, accumulators, gradient_accumulators, num_shards, shard_id,
    table_id=-1, table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the Adagrad optimization algorithm.
  accumulators   A Tensor of type float32. Value of accumulators used in the Adagrad optimization algorithm.
  gradient_accumulators   A Tensor of type float32. Value of gradient_accumulators used in the Adagrad optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingADAMParameters Load ADAM embedding parameters.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingADAMParameters
tf.raw_ops.LoadTPUEmbeddingADAMParameters(
    parameters, momenta, velocities, num_shards, shard_id, table_id=-1,
    table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the ADAM optimization algorithm.
  momenta   A Tensor of type float32. Value of momenta used in the ADAM optimization algorithm.
  velocities   A Tensor of type float32. Value of velocities used in the ADAM optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingADAMParametersGradAccumDebug Load ADAM embedding parameters with debug support.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingADAMParametersGradAccumDebug
tf.raw_ops.LoadTPUEmbeddingADAMParametersGradAccumDebug(
    parameters, momenta, velocities, gradient_accumulators, num_shards, shard_id,
    table_id=-1, table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the ADAM optimization algorithm.
  momenta   A Tensor of type float32. Value of momenta used in the ADAM optimization algorithm.
  velocities   A Tensor of type float32. Value of velocities used in the ADAM optimization algorithm.
  gradient_accumulators   A Tensor of type float32. Value of gradient_accumulators used in the ADAM optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingCenteredRMSPropParameters Load centered RMSProp embedding parameters.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingCenteredRMSPropParameters
tf.raw_ops.LoadTPUEmbeddingCenteredRMSPropParameters(
    parameters, ms, mom, mg, num_shards, shard_id, table_id=-1,
    table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the centered RMSProp optimization algorithm.
  ms   A Tensor of type float32. Value of ms used in the centered RMSProp optimization algorithm.
  mom   A Tensor of type float32. Value of mom used in the centered RMSProp optimization algorithm.
  mg   A Tensor of type float32. Value of mg used in the centered RMSProp optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingFTRLParameters Load FTRL embedding parameters.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingFTRLParameters
tf.raw_ops.LoadTPUEmbeddingFTRLParameters(
    parameters, accumulators, linears, num_shards, shard_id, table_id=-1,
    table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the FTRL optimization algorithm.
  accumulators   A Tensor of type float32. Value of accumulators used in the FTRL optimization algorithm.
  linears   A Tensor of type float32. Value of linears used in the FTRL optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingFTRLParametersGradAccumDebug Load FTRL embedding parameters with debug support.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingFTRLParametersGradAccumDebug
tf.raw_ops.LoadTPUEmbeddingFTRLParametersGradAccumDebug(
    parameters, accumulators, linears, gradient_accumulators, num_shards, shard_id,
    table_id=-1, table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the FTRL optimization algorithm.
  accumulators   A Tensor of type float32. Value of accumulators used in the FTRL optimization algorithm.
  linears   A Tensor of type float32. Value of linears used in the FTRL optimization algorithm.
  gradient_accumulators   A Tensor of type float32. Value of gradient_accumulators used in the FTRL optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingMDLAdagradLightParameters Load MDL Adagrad Light embedding parameters.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingMDLAdagradLightParameters
tf.raw_ops.LoadTPUEmbeddingMDLAdagradLightParameters(
    parameters, accumulators, weights, benefits, num_shards, shard_id, table_id=-1,
    table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the MDL Adagrad Light optimization algorithm.
  accumulators   A Tensor of type float32. Value of accumulators used in the MDL Adagrad Light optimization algorithm.
  weights   A Tensor of type float32. Value of weights used in the MDL Adagrad Light optimization algorithm.
  benefits   A Tensor of type float32. Value of benefits used in the MDL Adagrad Light optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingMomentumParameters Load Momentum embedding parameters.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingMomentumParameters
tf.raw_ops.LoadTPUEmbeddingMomentumParameters(
    parameters, momenta, num_shards, shard_id, table_id=-1, table_name='',
    config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the Momentum optimization algorithm.
  momenta   A Tensor of type float32. Value of momenta used in the Momentum optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingMomentumParametersGradAccumDebug Load Momentum embedding parameters with debug support.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingMomentumParametersGradAccumDebug
tf.raw_ops.LoadTPUEmbeddingMomentumParametersGradAccumDebug(
    parameters, momenta, gradient_accumulators, num_shards, shard_id, table_id=-1,
    table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the Momentum optimization algorithm.
  momenta   A Tensor of type float32. Value of momenta used in the Momentum optimization algorithm.
  gradient_accumulators   A Tensor of type float32. Value of gradient_accumulators used in the Momentum optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingProximalAdagradParameters Load proximal Adagrad embedding parameters.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingProximalAdagradParameters
tf.raw_ops.LoadTPUEmbeddingProximalAdagradParameters(
    parameters, accumulators, num_shards, shard_id, table_id=-1,
    table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the proximal Adagrad optimization algorithm.
  accumulators   A Tensor of type float32. Value of accumulators used in the proximal Adagrad optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug Load proximal Adagrad embedding parameters with debug support.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug
tf.raw_ops.LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug(
    parameters, accumulators, gradient_accumulators, num_shards, shard_id,
    table_id=-1, table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the proximal Adagrad optimization algorithm.
  accumulators   A Tensor of type float32. Value of accumulators used in the proximal Adagrad optimization algorithm.
  gradient_accumulators   A Tensor of type float32. Value of gradient_accumulators used in the proximal Adagrad optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingProximalYogiParameters  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingProximalYogiParameters
tf.raw_ops.LoadTPUEmbeddingProximalYogiParameters(
    parameters, v, m, num_shards, shard_id, table_id=-1, table_name='',
    config='', name=None
)

 Args
  parameters   A Tensor of type float32.
  v   A Tensor of type float32.
  m   A Tensor of type float32.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingProximalYogiParametersGradAccumDebug  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingProximalYogiParametersGradAccumDebug
tf.raw_ops.LoadTPUEmbeddingProximalYogiParametersGradAccumDebug(
    parameters, v, m, gradient_accumulators, num_shards, shard_id, table_id=-1,
    table_name='', config='', name=None
)

 Args
  parameters   A Tensor of type float32.
  v   A Tensor of type float32.
  m   A Tensor of type float32.
  gradient_accumulators   A Tensor of type float32.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingRMSPropParameters Load RMSProp embedding parameters.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingRMSPropParameters
tf.raw_ops.LoadTPUEmbeddingRMSPropParameters(
    parameters, ms, mom, num_shards, shard_id, table_id=-1, table_name='',
    config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the RMSProp optimization algorithm.
  ms   A Tensor of type float32. Value of ms used in the RMSProp optimization algorithm.
  mom   A Tensor of type float32. Value of mom used in the RMSProp optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingRMSPropParametersGradAccumDebug Load RMSProp embedding parameters with debug support.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingRMSPropParametersGradAccumDebug
tf.raw_ops.LoadTPUEmbeddingRMSPropParametersGradAccumDebug(
    parameters, ms, mom, gradient_accumulators, num_shards, shard_id, table_id=-1,
    table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the RMSProp optimization algorithm.
  ms   A Tensor of type float32. Value of ms used in the RMSProp optimization algorithm.
  mom   A Tensor of type float32. Value of mom used in the RMSProp optimization algorithm.
  gradient_accumulators   A Tensor of type float32. Value of gradient_accumulators used in the RMSProp optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingStochasticGradientDescentParameters Load SGD embedding parameters.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingStochasticGradientDescentParameters
tf.raw_ops.LoadTPUEmbeddingStochasticGradientDescentParameters(
    parameters, num_shards, shard_id, table_id=-1, table_name='',
    config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the stochastic gradient descent optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LoadTPUEmbeddingStochasticGradientDescentParametersGradAccumDebug Load SGD embedding parameters.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoadTPUEmbeddingStochasticGradientDescentParametersGradAccumDebug
tf.raw_ops.LoadTPUEmbeddingStochasticGradientDescentParametersGradAccumDebug(
    parameters, gradient_accumulators, num_shards, shard_id, table_id=-1,
    table_name='', config='', name=None
)
 An op that loads optimization parameters into HBM for embedding. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up the correct embedding table configuration. For example, this op is used to install parameters that are loaded from a checkpoint before a training loop is executed.

 Args
  parameters   A Tensor of type float32. Value of parameters used in the stochastic gradient descent optimization algorithm.
  gradient_accumulators   A Tensor of type float32. Value of gradient_accumulators used in the Adadelta optimization algorithm.
  num_shards   An int.
  shard_id   An int.
  table_id   An optional int. Defaults to -1.
  table_name   An optional string. Defaults to "".
  config   An optional string. Defaults to "".
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.Log   Computes natural logarithm of x element-wise.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.Log
tf.raw_ops.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.raw_ops.Log1p   Computes natural logarithm of (1 + x) element-wise.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.Log1p
tf.raw_ops.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.raw_ops.LogicalAnd Returns the truth value of x AND y element-wise.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LogicalAnd
tf.raw_ops.LogicalAnd(
    x, y, name=None
)

Note: LogicalAnd 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.raw_ops.LogicalNot Returns the truth value of NOT x element-wise.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LogicalNot
tf.raw_ops.LogicalNot(
    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.raw_ops.LogicalOr Returns the truth value of x OR y element-wise.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LogicalOr
tf.raw_ops.LogicalOr(
    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.raw_ops.LogMatrixDeterminant Computes the sign and the log of the absolute value of the determinant of  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LogMatrixDeterminant
tf.raw_ops.LogMatrixDeterminant(
    input, name=None
)
 one or more square matrices. The input is a tensor of shape [N, M, M] whose inner-most 2 dimensions form square matrices. The outputs are two tensors containing the signs and absolute values of the log determinants for all N input submatrices [..., :, :] such that determinant = sign*exp(log_abs_determinant). The log_abs_determinant is computed as det(P)*sum(log(diag(LU))) where LU is the LU decomposition of the input and P is the corresponding permutation matrix.

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

 Returns   A tuple of Tensor objects (sign, log_abs_determinant).     sign   A Tensor. Has the same type as input.
  log_abs_determinant   A Tensor. Has the same type as input.


tf.raw_ops.LogSoftmax Computes log softmax activations.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LogSoftmax
tf.raw_ops.LogSoftmax(
    logits, name=None
)
 For each batch i and class j we have logsoftmax[i, j] = logits[i, j] - log(sum(exp(logits[i])))

 Args
  logits   A Tensor. Must be one of the following types: half, bfloat16, float32, float64. 2-D with shape [batch_size, num_classes].
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as logits.


tf.raw_ops.LogUniformCandidateSampler Generates labels for candidate sampling with a log-uniform distribution.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LogUniformCandidateSampler
tf.raw_ops.LogUniformCandidateSampler(
    true_classes, num_true, num_sampled, unique, range_max, seed=0, seed2=0,
    name=None
)
 See explanations of candidate sampling and the data formats at go/candidate-sampling. For each batch, this op picks a single set of sampled candidate labels. The advantages of sampling candidates per-batch are simplicity and the possibility of efficient dense matrix multiplication. The disadvantage is that the sampled candidates must be chosen independently of the context and of the true labels.

 Args
  true_classes   A Tensor of type int64. A batch_size * num_true matrix, in which each row contains the IDs of the num_true target_classes in the corresponding original label.
  num_true   An int that is >= 1. Number of true labels per context.
  num_sampled   An int that is >= 1. Number of candidates to randomly sample.
  unique   A bool. If unique is true, we sample with rejection, so that all sampled candidates in a batch are unique. This requires some approximation to estimate the post-rejection sampling probabilities.
  range_max   An int that is >= 1. The sampler will sample integers from the interval [0, range_max).
  seed   An optional int. Defaults to 0. If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed. Otherwise, it is seeded by a random seed.
  seed2   An optional int. Defaults to 0. An second seed to avoid seed collision.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (sampled_candidates, true_expected_count, sampled_expected_count).     sampled_candidates   A Tensor of type int64.
  true_expected_count   A Tensor of type float32.
  sampled_expected_count   A Tensor of type float32.


tf.raw_ops.LookupTableExport Outputs all keys and values in the table.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableExport
tf.raw_ops.LookupTableExport(
    table_handle, Tkeys, Tvalues, name=None
)

 Args
  table_handle   A Tensor of type mutable string. Handle to the table.
  Tkeys   A tf.DType.
  Tvalues   A tf.DType.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (keys, values).     keys   A Tensor of type Tkeys.
  values   A Tensor of type Tvalues.


tf.raw_ops.LookupTableExportV2 Outputs all keys and values in the table.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableExportV2
tf.raw_ops.LookupTableExportV2(
    table_handle, Tkeys, Tvalues, name=None
)

 Args
  table_handle   A Tensor of type resource. Handle to the table.
  Tkeys   A tf.DType.
  Tvalues   A tf.DType.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (keys, values).     keys   A Tensor of type Tkeys.
  values   A Tensor of type Tvalues.


tf.raw_ops.LookupTableFind Looks up keys in a table, outputs the corresponding values.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableFind
tf.raw_ops.LookupTableFind(
    table_handle, keys, default_value, name=None
)
 The tensor keys must of the same type as the keys of the table. The output values is of the type of the table values. The scalar default_value is the value output for keys not present in the table. It must also be of the same type as the table values.

 Args
  table_handle   A Tensor of type mutable string. Handle to the table.
  keys   A Tensor. Any shape. Keys to look up.
  default_value   A Tensor.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as default_value.


tf.raw_ops.LookupTableFindV2 Looks up keys in a table, outputs the corresponding values.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableFindV2
tf.raw_ops.LookupTableFindV2(
    table_handle, keys, default_value, name=None
)
 The tensor keys must of the same type as the keys of the table. The output values is of the type of the table values. The scalar default_value is the value output for keys not present in the table. It must also be of the same type as the table values.

 Args
  table_handle   A Tensor of type resource. Handle to the table.
  keys   A Tensor. Any shape. Keys to look up.
  default_value   A Tensor.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as default_value.


tf.raw_ops.LookupTableImport Replaces the contents of the table with the specified keys and values.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableImport
tf.raw_ops.LookupTableImport(
    table_handle, keys, values, name=None
)
 The tensor keys must be of the same type as the keys of the table. The tensor values must be of the type of the table values.

 Args
  table_handle   A Tensor of type mutable string. Handle to the table.
  keys   A Tensor. Any shape. Keys to look up.
  values   A Tensor. Values to associate with keys.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LookupTableImportV2 Replaces the contents of the table with the specified keys and values.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableImportV2
tf.raw_ops.LookupTableImportV2(
    table_handle, keys, values, name=None
)
 The tensor keys must be of the same type as the keys of the table. The tensor values must be of the type of the table values.

 Args
  table_handle   A Tensor of type resource. Handle to the table.
  keys   A Tensor. Any shape. Keys to look up.
  values   A Tensor. Values to associate with keys.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LookupTableInsert Updates the table to associates keys with values.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableInsert
tf.raw_ops.LookupTableInsert(
    table_handle, keys, values, name=None
)
 The tensor keys must be of the same type as the keys of the table. The tensor values must be of the type of the table values.

 Args
  table_handle   A Tensor of type mutable string. Handle to the table.
  keys   A Tensor. Any shape. Keys to look up.
  values   A Tensor. Values to associate with keys.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LookupTableInsertV2 Updates the table to associates keys with values.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableInsertV2
tf.raw_ops.LookupTableInsertV2(
    table_handle, keys, values, name=None
)
 The tensor keys must be of the same type as the keys of the table. The tensor values must be of the type of the table values.

 Args
  table_handle   A Tensor of type resource. Handle to the table.
  keys   A Tensor. Any shape. Keys to look up.
  values   A Tensor. Values to associate with keys.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LookupTableRemoveV2 Removes keys and its associated values from a table.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableRemoveV2
tf.raw_ops.LookupTableRemoveV2(
    table_handle, keys, name=None
)
 The tensor keys must of the same type as the keys of the table. Keys not already in the table are silently ignored.

 Args
  table_handle   A Tensor of type resource. Handle to the table.
  keys   A Tensor. Any shape. Keys of the elements to remove.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.LookupTableSize Computes the number of elements in the given table.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableSize
tf.raw_ops.LookupTableSize(
    table_handle, name=None
)

 Args
  table_handle   A Tensor of type mutable string. Handle to the table.
  name   A name for the operation (optional).

 Returns   A Tensor of type int64.


tf.raw_ops.LookupTableSizeV2 Computes the number of elements in the given table.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LookupTableSizeV2
tf.raw_ops.LookupTableSizeV2(
    table_handle, name=None
)

 Args
  table_handle   A Tensor of type resource. Handle to the table.
  name   A name for the operation (optional).

 Returns   A Tensor of type int64.


tf.raw_ops.LoopCond Forwards the input to the output.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LoopCond
tf.raw_ops.LoopCond(
    input, name=None
)
 This operator represents the loop termination condition used by the "pivot" switches of a loop.

 Args
  input   A Tensor of type bool. A boolean scalar, representing the branch predicate of the Switch op.
  name   A name for the operation (optional).

 Returns   A Tensor of type bool.


tf.raw_ops.LowerBound Applies lower_bound(sorted_search_values, values) along each row.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LowerBound
tf.raw_ops.LowerBound(
    sorted_inputs, values, out_type=tf.dtypes.int32, name=None
)
 Each set of rows with the same index in (sorted_inputs, values) is treated independently. The resulting row is the equivalent of calling np.searchsorted(sorted_inputs, values, side='left'). The result is not a global index to the entire Tensor, but rather just the index in the last dimension. A 2-D example: sorted_sequence = [[0, 3, 9, 9, 10], [1, 2, 3, 4, 5]] values = [[2, 4, 9], [0, 2, 6]] result = LowerBound(sorted_sequence, values) result == [[1, 2, 2], [0, 1, 5]]

 Args
  sorted_inputs   A Tensor. 2-D Tensor where each row is ordered.
  values   A Tensor. Must have the same type as sorted_inputs. 2-D Tensor with the same numbers of rows as sorted_search_values. Contains the values that will be searched for in sorted_search_values.
  out_type   An optional tf.DType from: tf.int32, tf.int64. Defaults to tf.int32.
  name   A name for the operation (optional).

 Returns   A Tensor of type out_type.


tf.raw_ops.LRN Local Response Normalization.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LRN
tf.raw_ops.LRN(
    input, depth_radius=5, bias=1, alpha=1, beta=0.5, name=None
)
 The 4-D input tensor is treated as a 3-D array of 1-D vectors (along the last dimension), and each vector is normalized independently. Within a given vector, each component is divided by the weighted, squared sum of inputs within depth_radius. In detail, sqr_sum[a, b, c, d] =
    sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
output = input / (bias + alpha * sqr_sum) ** beta
 For details, see Krizhevsky et al., ImageNet classification with deep convolutional neural networks (NIPS 2012).

 Args
  input   A Tensor. Must be one of the following types: half, bfloat16, float32. 4-D.
  depth_radius   An optional int. Defaults to 5. 0-D. Half-width of the 1-D normalization window.
  bias   An optional float. Defaults to 1. An offset (usually positive to avoid dividing by 0).
  alpha   An optional float. Defaults to 1. A scale factor, usually positive.
  beta   An optional float. Defaults to 0.5. An exponent.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as input.


tf.raw_ops.LRNGrad Gradients for Local Response Normalization.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LRNGrad
tf.raw_ops.LRNGrad(
    input_grads, input_image, output_image, depth_radius=5, bias=1, alpha=1,
    beta=0.5, name=None
)

 Args
  input_grads   A Tensor. Must be one of the following types: half, bfloat16, float32. 4-D with shape [batch, height, width, channels].
  input_image   A Tensor. Must have the same type as input_grads. 4-D with shape [batch, height, width, channels].
  output_image   A Tensor. Must have the same type as input_grads. 4-D with shape [batch, height, width, channels].
  depth_radius   An optional int. Defaults to 5. A depth radius.
  bias   An optional float. Defaults to 1. An offset (usually > 0 to avoid dividing by 0).
  alpha   An optional float. Defaults to 1. A scale factor, usually positive.
  beta   An optional float. Defaults to 0.5. An exponent.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as input_grads.


tf.raw_ops.LSTMBlockCell Computes the LSTM cell forward propagation for 1 time step.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LSTMBlockCell
tf.raw_ops.LSTMBlockCell(
    x, cs_prev, h_prev, w, wci, wcf, wco, b, forget_bias=1, cell_clip=3,
    use_peephole=False, name=None
)
 This implementation uses 1 weight matrix and 1 bias vector, and there's an optional peephole connection. This kernel op implements the following mathematical equations: xh = [x, h_prev]
[i, f, ci, o] = xh * w + b
f = f + forget_bias

if not use_peephole:
  wci = wcf = wco = 0

i = sigmoid(cs_prev * wci + i)
f = sigmoid(cs_prev * wcf + f)
ci = tanh(ci)

cs = ci .* i + cs_prev .* f
cs = clip(cs, cell_clip)

o = sigmoid(cs * wco + o)
co = tanh(cs)
h = co .* o

 Args
  x   A Tensor. Must be one of the following types: half, float32. The input to the LSTM cell, shape (batch_size, num_inputs).
  cs_prev   A Tensor. Must have the same type as x. Value of the cell state at previous time step.
  h_prev   A Tensor. Must have the same type as x. Output of the previous cell at previous time step.
  w   A Tensor. Must have the same type as x. The weight matrix.
  wci   A Tensor. Must have the same type as x. The weight matrix for input gate peephole connection.
  wcf   A Tensor. Must have the same type as x. The weight matrix for forget gate peephole connection.
  wco   A Tensor. Must have the same type as x. The weight matrix for output gate peephole connection.
  b   A Tensor. Must have the same type as x. The bias vector.
  forget_bias   An optional float. Defaults to 1. The forget gate bias.
  cell_clip   An optional float. Defaults to 3. Value to clip the 'cs' value to.
  use_peephole   An optional bool. Defaults to False. Whether to use peephole weights.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (i, cs, f, o, ci, co, h).     i   A Tensor. Has the same type as x.
  cs   A Tensor. Has the same type as x.
  f   A Tensor. Has the same type as x.
  o   A Tensor. Has the same type as x.
  ci   A Tensor. Has the same type as x.
  co   A Tensor. Has the same type as x.
  h   A Tensor. Has the same type as x.


tf.raw_ops.LSTMBlockCellGrad Computes the LSTM cell backward propagation for 1 timestep.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.LSTMBlockCellGrad
tf.raw_ops.LSTMBlockCellGrad(
    x, cs_prev, h_prev, w, wci, wcf, wco, b, i, cs, f, o, ci, co, cs_grad, h_grad,
    use_peephole, name=None
)
 This implementation is to be used in conjunction of LSTMBlockCell.

 Args
  x   A Tensor. Must be one of the following types: half, float32. The input to the LSTM cell, shape (batch_size, num_inputs).
  cs_prev   A Tensor. Must have the same type as x. The previous cell state.
  h_prev   A Tensor. Must have the same type as x. The previous h state.
  w   A Tensor. Must have the same type as x. The weight matrix.
  wci   A Tensor. Must have the same type as x. The weight matrix for input gate peephole connection.
  wcf   A Tensor. Must have the same type as x. The weight matrix for forget gate peephole connection.
  wco   A Tensor. Must have the same type as x. The weight matrix for output gate peephole connection.
  b   A Tensor. Must have the same type as x. The bias vector.
  i   A Tensor. Must have the same type as x. The input gate.
  cs   A Tensor. Must have the same type as x. The cell state before the tanh.
  f   A Tensor. Must have the same type as x. The forget gate.
  o   A Tensor. Must have the same type as x. The output gate.
  ci   A Tensor. Must have the same type as x. The cell input.
  co   A Tensor. Must have the same type as x. The cell after the tanh.
  cs_grad   A Tensor. Must have the same type as x. The current gradient of cs.
  h_grad   A Tensor. Must have the same type as x. The gradient of h vector.
  use_peephole   A bool. Whether the cell uses peephole connections.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (cs_prev_grad, dicfo, wci_grad, wcf_grad, wco_grad).     cs_prev_grad   A Tensor. Has the same type as x.
  dicfo   A Tensor. Has the same type as x.
  wci_grad   A Tensor. Has the same type as x.
  wcf_grad   A Tensor. Has the same type as x.
  wco_grad   A Tensor. Has the same type as x.


tf.raw_ops.Lu Computes the LU decomposition of one or more square matrices.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.Lu
tf.raw_ops.Lu(
    input, output_idx_type=tf.dtypes.int32, name=None
)
 The input is a tensor of shape [..., M, M] whose inner-most 2 dimensions form square matrices. The input has to be invertible. The output consists of two tensors LU and P containing the LU decomposition of all input submatrices [..., :, :]. LU encodes the lower triangular and upper triangular factors. For each input submatrix of shape [M, M], L is a lower triangular matrix of shape [M, M] with unit diagonal whose entries correspond to the strictly lower triangular part of LU. U is a upper triangular matrix of shape [M, M] whose entries correspond to the upper triangular part, including the diagonal, of LU. P represents a permutation matrix encoded as a list of indices each between 0 and M-1, inclusive. If P_mat denotes the permutation matrix corresponding to P, then the L, U and P satisfies P_mat * input = L * U.

 Args
  input   A Tensor. Must be one of the following types: float64, float32, half, complex64, complex128. A tensor of shape [..., M, M] whose inner-most 2 dimensions form matrices of size [M, M].
  output_idx_type   An optional tf.DType from: tf.int32, tf.int64. Defaults to tf.int32.
  name   A name for the operation (optional).

 Returns   A tuple of Tensor objects (lu, p).     lu   A Tensor. Has the same type as input.
  p   A Tensor of type output_idx_type.


tf.raw_ops.MakeIterator Makes a new iterator from the given dataset and stores it in iterator.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MakeIterator
tf.raw_ops.MakeIterator(
    dataset, iterator, name=None
)
 This operation may be executed multiple times. Each execution will reset the iterator in iterator to the first element of dataset.

 Args
  dataset   A Tensor of type variant.
  iterator   A Tensor of type resource.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.MapAndBatchDataset Creates a dataset that fuses mapping with batching.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MapAndBatchDataset
tf.raw_ops.MapAndBatchDataset(
    input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder,
    f, output_types, output_shapes, preserve_cardinality=False, name=None
)
 Creates a dataset that applies f to the outputs of input_dataset and then batches batch_size of them. Unlike a "MapDataset", which applies f sequentially, this dataset invokes up to batch_size * num_parallel_batches copies of f in parallel.

 Args
  input_dataset   A Tensor of type variant. A variant tensor representing the input dataset.
  other_arguments   A list of Tensor objects. A list of tensors, typically values that were captured when building a closure for f.
  batch_size   A Tensor of type int64. A scalar representing the number of elements to accumulate in a batch. It determines the number of concurrent invocations of f that process elements from input_dataset in parallel.
  num_parallel_calls   A Tensor of type int64. A scalar representing the maximum number of parallel invocations of the map_fn function. Applying the map_fn on consecutive input elements in parallel has the potential to improve input pipeline throughput.
  drop_remainder   A Tensor of type bool. A scalar representing whether the last batch should be dropped in case its size is smaller than desired.
  f   A function decorated with @Defun. A function to apply to the outputs of input_dataset.
  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.
  preserve_cardinality   An optional bool. Defaults to False.
  name   A name for the operation (optional).

 Returns   A Tensor of type variant.


tf.raw_ops.MapClear Op removes all elements in the underlying container.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MapClear
tf.raw_ops.MapClear(
    dtypes, capacity=0, memory_limit=0, container='',
    shared_name='', name=None
)

 Args
  dtypes   A list of tf.DTypes.
  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   The created Operation.


tf.raw_ops.MapDataset Creates a dataset that applies f to the outputs of input_dataset.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MapDataset
tf.raw_ops.MapDataset(
    input_dataset, other_arguments, f, output_types, output_shapes,
    use_inter_op_parallelism=True, preserve_cardinality=False, name=None
)

 Args
  input_dataset   A Tensor of type variant.
  other_arguments   A list of Tensor objects.
  f   A function decorated with @Defun.
  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.
  use_inter_op_parallelism   An optional bool. Defaults to True.
  preserve_cardinality   An optional bool. Defaults to False.
  name   A name for the operation (optional).

 Returns   A Tensor of type variant.


tf.raw_ops.MapDefun Maps a function on the list of tensors unpacked from arguments on dimension 0.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MapDefun
tf.raw_ops.MapDefun(
    arguments, captured_inputs, output_types, output_shapes, f,
    max_intra_op_parallelism=1, name=None
)
 The function given by f is assumed to be stateless, and is executed concurrently on all the slices; up to batch_size (i.e. the size of the 0th dimension of each argument) functions will be scheduled at once. The max_intra_op_parallelism attr, which defaults to 1, can be used to limit the intra op parallelism. To limit inter-op parallelism, a user can set a private threadpool on the dataset using tf.data.Options's ThreadingOptions. Note that this op is not exposed to users directly, but is invoked in tf.data rewrites.

 Args
  arguments   A list of Tensor objects. A list of tensors whose types are Targuments, corresponding to the inputs the function should be mapped over.
  captured_inputs   A list of Tensor objects. A list of tensors whose types are Tcaptured, corresponding to the captured inputs of the defun.
  output_types   A list of tf.DTypes that has length >= 1. A list of types.
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1. A list of shapes.
  f   A function decorated with @Defun.
  max_intra_op_parallelism   An optional int. Defaults to 1.
  name   A name for the operation (optional).

 Returns   A list of Tensor objects of type output_types.


tf.raw_ops.MapIncompleteSize Op returns the number of incomplete elements in the underlying container.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MapIncompleteSize
tf.raw_ops.MapIncompleteSize(
    dtypes, capacity=0, memory_limit=0, container='',
    shared_name='', name=None
)

 Args
  dtypes   A list of tf.DTypes.
  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 Tensor of type int32.


tf.raw_ops.MapPeek Op peeks at the values at the specified key. If the  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MapPeek
tf.raw_ops.MapPeek(
    key, indices, dtypes, capacity=0, memory_limit=0, container='',
    shared_name='', name=None
)
 underlying container does not contain this key this op will block until it does.

 Args
  key   A Tensor of type int64.
  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 list of Tensor objects of type dtypes.


tf.raw_ops.MapSize Op returns the number of elements in the underlying container.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MapSize
tf.raw_ops.MapSize(
    dtypes, capacity=0, memory_limit=0, container='',
    shared_name='', name=None
)

 Args
  dtypes   A list of tf.DTypes.
  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 Tensor of type int32.


tf.raw_ops.MapStage Stage (key, values) in the underlying container which behaves like a hashtable.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MapStage
tf.raw_ops.MapStage(
    key, indices, values, dtypes, capacity=0, memory_limit=0,
    container='', shared_name='', name=None
)

 Args
  key   A Tensor of type int64. int64
  indices   A Tensor of type int32.
  values   A list of Tensor objects. a list of tensors dtypes A list of data types that inserted values should adhere to.
  dtypes   A list of tf.DTypes.
  capacity   An optional int that is >= 0. Defaults to 0. Maximum number of elements in the Staging Area. If > 0, inserts on the container will block when the capacity is reached.
  memory_limit   An optional int that is >= 0. Defaults to 0.
  container   An optional string. Defaults to "". If non-empty, this queue is placed in the given container. Otherwise, a default container is used.
  shared_name   An optional string. Defaults to "". It is necessary to match this name to the matching Unstage Op.
  name   A name for the operation (optional).

 Returns   The created Operation.


tf.raw_ops.MapUnstage Op removes and returns the values associated with the key  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MapUnstage
tf.raw_ops.MapUnstage(
    key, indices, dtypes, capacity=0, memory_limit=0, container='',
    shared_name='', name=None
)
 from the underlying container. If the underlying container does not contain this key, the op will block until it does.

 Args
  key   A Tensor of type int64.
  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 list of Tensor objects of type dtypes.


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.MatrixDiagPartV3 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.MatrixDiagPartV3
tf.raw_ops.MatrixDiagPartV3(
    input, k, padding_value, align='RIGHT_LEFT', 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) - offset, and x = max(d, 0) - offset. offset is zero except when the alignment of the diagonal is to the right. offset = max_diag_len - diag_len(d) ; if (`align` in {RIGHT_LEFT, RIGHT_RIGHT}
                                           and `d >= 0`) or
                                         (`align` in {LEFT_RIGHT, RIGHT_RIGHT}
                                           and `d <= 0`)
         0                          ; otherwise
 where diag_len(d) = min(cols - max(d, 0), rows + min(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 band from each batch.
tf.matrix_diag_part(input, k = (-1, 2))
  ==> [[[0, 3, 8],  # Output shape: (2, 4, 3)
        [2, 7, 6],
        [1, 6, 7],
        [5, 8, 0]],
       [[0, 3, 4],
        [4, 3, 8],
        [5, 2, 7],
        [1, 6, 0]]]

# LEFT_RIGHT alignment.
tf.matrix_diag_part(input, k = (-1, 2), align="LEFT_RIGHT")
  ==> [[[3, 8, 0],  # Output shape: (2, 4, 3)
        [2, 7, 6],
        [1, 6, 7],
        [0, 5, 8]],
       [[3, 4, 0],
        [4, 3, 8],
        [5, 2, 7],
        [0, 1, 6]]]

# max_diag_len can be shorter than the main diagonal.
tf.matrix_diag_part(input, k = (-2, -1))
  ==> [[[5, 8],
        [9, 0]],
       [[1, 6],
        [5, 0]]]

# padding_value = 9
tf.matrix_diag_part(input, k = (1, 3), padding_value = 9)
  ==> [[[9, 9, 4],  # Output shape: (2, 3, 3)
        [9, 3, 8],
        [2, 7, 6]],
       [[9, 9, 2],
        [9, 3, 4],
        [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.
  align   An optional string from: "LEFT_RIGHT", "RIGHT_LEFT", "LEFT_LEFT", "RIGHT_RIGHT". Defaults to "RIGHT_LEFT". Some diagonals are shorter than max_diag_len and need to be padded. align is a string specifying how superdiagonals and subdiagonals should be aligned, respectively. There are four possible alignments: "RIGHT_LEFT" (default), "LEFT_RIGHT", "LEFT_LEFT", and "RIGHT_RIGHT". "RIGHT_LEFT" aligns superdiagonals to the right (left-pads the row) and subdiagonals to the left (right-pads the row). It is the packing format LAPACK uses. cuSPARSE uses "LEFT_RIGHT", which is the opposite alignment.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as input.


tf.raw_ops.MatrixDiagV2 Returns a batched diagonal tensor with given batched diagonal values.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixDiagV2
tf.raw_ops.MatrixDiagV2(
    diagonal, k, num_rows, num_cols, padding_value, name=None
)
 Returns a tensor with the contents in diagonal as k[0]-th to k[1]-th diagonals of a matrix, with everything else padded with padding. num_rows and num_cols specify the dimension of the innermost matrix of the output. If both are not specified, the op assumes the innermost matrix is square and infers its size from k and the innermost dimension of diagonal. If only one of them is specified, the op assumes the unspecified value is the smallest possible based on other criteria. Let diagonal have r dimensions [I, J, ..., L, M, N]. The output tensor has rank r+1 with shape [I, J, ..., L, M, num_rows, num_cols] when only one diagonal is given (k is an integer or k[0] == k[1]). Otherwise, it has rank r with shape [I, J, ..., L, num_rows, num_cols]. The second innermost dimension of diagonal has double meaning. When k is scalar or k[0] == k[1], M is part of the batch size [I, J, ..., M], and the output tensor is: output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
    padding_value                             ; otherwise
 Otherwise, M is treated as the number of diagonals for the matrix in the same batch (M = k[1]-k[0]+1), and the output tensor is: output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
    padding_value                                     ; otherwise
 where d = n - m, diag_index = k[1] - d, and index_in_diag = n - max(d, 0). For example: # The main diagonal.
diagonal = np.array([[1, 2, 3, 4],            # Input shape: (2, 4)
                     [5, 6, 7, 8]])
tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0],  # Output shape: (2, 4, 4)
                               [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]]]

# A superdiagonal (per batch).
diagonal = np.array([[1, 2, 3],  # Input shape: (2, 3)
                     [4, 5, 6]])
tf.matrix_diag(diagonal, k = 1)
  ==> [[[0, 1, 0, 0],  # Output shape: (2, 4, 4)
        [0, 0, 2, 0],
        [0, 0, 0, 3],
        [0, 0, 0, 0]],
       [[0, 4, 0, 0],
        [0, 0, 5, 0],
        [0, 0, 0, 6],
        [0, 0, 0, 0]]]

# A band of diagonals.
diagonals = np.array([[[1, 2, 3],  # Input shape: (2, 2, 3)
                       [4, 5, 0]],
                      [[6, 7, 9],
                       [9, 1, 0]]])
tf.matrix_diag(diagonals, k = (-1, 0))
  ==> [[[1, 0, 0],  # Output shape: (2, 3, 3)
        [4, 2, 0],
        [0, 5, 3]],
       [[6, 0, 0],
        [9, 7, 0],
        [0, 1, 9]]]

# Rectangular matrix.
diagonal = np.array([1, 2])  # Input shape: (2)
tf.matrix_diag(diagonal, k = -1, num_rows = 3, num_cols = 4)
  ==> [[0, 0, 0, 0],  # Output shape: (3, 4)
       [1, 0, 0, 0],
       [0, 2, 0, 0]]

# Rectangular matrix with inferred num_cols and padding_value = 9.
tf.matrix_diag(diagonal, k = -1, num_rows = 3, padding_value = 9)
  ==> [[9, 9],  # Output shape: (3, 2)
       [1, 9],
       [9, 2]]

 Args
  diagonal   A Tensor. Rank r, where r >= 1
  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].
  num_rows   A Tensor of type int32. The number of rows of the output matrix. If it is not provided, the op assumes the output matrix is a square matrix and infers the matrix size from k and the innermost dimension of diagonal.
  num_cols   A Tensor of type int32. The number of columns of the output matrix. If it is not provided, the op assumes the output matrix is a square matrix and infers the matrix size from k and the innermost dimension of diagonal.
  padding_value   A Tensor. Must have the same type as diagonal. The number 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 diagonal.


tf.raw_ops.MatrixDiagV3 Returns a batched diagonal tensor with given batched diagonal values.  View aliases  Compat aliases for migration
See Migration guide for more details. tf.compat.v1.raw_ops.MatrixDiagV3
tf.raw_ops.MatrixDiagV3(
    diagonal, k, num_rows, num_cols, padding_value, align='RIGHT_LEFT',
    name=None
)
 Returns a tensor with the contents in diagonal as k[0]-th to k[1]-th diagonals of a matrix, with everything else padded with padding. num_rows and num_cols specify the dimension of the innermost matrix of the output. If both are not specified, the op assumes the innermost matrix is square and infers its size from k and the innermost dimension of diagonal. If only one of them is specified, the op assumes the unspecified value is the smallest possible based on other criteria. Let diagonal have r dimensions [I, J, ..., L, M, N]. The output tensor has rank r+1 with shape [I, J, ..., L, M, num_rows, num_cols] when only one diagonal is given (k is an integer or k[0] == k[1]). Otherwise, it has rank r with shape [I, J, ..., L, num_rows, num_cols]. The second innermost dimension of diagonal has double meaning. When k is scalar or k[0] == k[1], M is part of the batch size [I, J, ..., M], and the output tensor is: output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
    padding_value                             ; otherwise
 Otherwise, M is treated as the number of diagonals for the matrix in the same batch (M = k[1]-k[0]+1), and the output tensor is: output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
    padding_value                                     ; otherwise
 where d = n - m, diag_index = [k] - d, and index_in_diag = n - max(d, 0) + offset. offset is zero except when the alignment of the diagonal is to the right. offset = max_diag_len - diag_len(d) ; if (`align` in {RIGHT_LEFT, RIGHT_RIGHT}
                                           and `d >= 0`) or
                                         (`align` in {LEFT_RIGHT, RIGHT_RIGHT}
                                           and `d <= 0`)
         0                          ; otherwise
 where diag_len(d) = min(cols - max(d, 0), rows + min(d, 0)). For example: # The main diagonal.
diagonal = np.array([[1, 2, 3, 4],            # Input shape: (2, 4)
                     [5, 6, 7, 8]])
tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0],  # Output shape: (2, 4, 4)
                               [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]]]

# A superdiagonal (per batch).
diagonal = np.array([[1, 2, 3],  # Input shape: (2, 3)
                     [4, 5, 6]])
tf.matrix_diag(diagonal, k = 1)
  ==> [[[0, 1, 0, 0],  # Output shape: (2, 4, 4)
        [0, 0, 2, 0],
        [0, 0, 0, 3],
        [0, 0, 0, 0]],
       [[0, 4, 0, 0],
        [0, 0, 5, 0],
        [0, 0, 0, 6],
        [0, 0, 0, 0]]]

# A tridiagonal band (per batch).
diagonals = np.array([[[0, 8, 9],  # Input shape: (2, 2, 3)
                       [1, 2, 3],
                       [4, 5, 0]],
                      [[0, 2, 3],
                       [6, 7, 9],
                       [9, 1, 0]]])
tf.matrix_diag(diagonals, k = (-1, 1))
  ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
        [4, 2, 9],
        [0, 5, 3]],
       [[6, 2, 0],
        [9, 7, 3],
        [0, 1, 9]]]

# LEFT_RIGHT alignment.
diagonals = np.array([[[8, 9, 0],  # Input shape: (2, 2, 3)
                       [1, 2, 3],
                       [0, 4, 5]],
                      [[2, 3, 0],
                       [6, 7, 9],
                       [0, 9, 1]]])
tf.matrix_diag(diagonals, k = (-1, 1), align="LEFT_RIGHT")
  ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
        [4, 2, 9],
        [0, 5, 3]],
       [[6, 2, 0],
        [9, 7, 3],
        [0, 1, 9]]]

# Rectangular matrix.
diagonal = np.array([1, 2])  # Input shape: (2)
tf.matrix_diag(diagonal, k = -1, num_rows = 3, num_cols = 4)
  ==> [[0, 0, 0, 0],  # Output shape: (3, 4)
       [1, 0, 0, 0],
       [0, 2, 0, 0]]

# Rectangular matrix with inferred num_cols and padding_value = 9.
tf.matrix_diag(diagonal, k = -1, num_rows = 3, padding_value = 9)
  ==> [[9, 9],  # Output shape: (3, 2)
       [1, 9],
       [9, 2]]

 Args
  diagonal   A Tensor. Rank r, where r >= 1
  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].
  num_rows   A Tensor of type int32. The number of rows of the output matrix. If it is not provided, the op assumes the output matrix is a square matrix and infers the matrix size from k and the innermost dimension of diagonal.
  num_cols   A Tensor of type int32. The number of columns of the output matrix. If it is not provided, the op assumes the output matrix is a square matrix and infers the matrix size from k and the innermost dimension of diagonal.
  padding_value   A Tensor. Must have the same type as diagonal. The number to fill the area outside the specified diagonal band with. Default is 0.
  align   An optional string from: "LEFT_RIGHT", "RIGHT_LEFT", "LEFT_LEFT", "RIGHT_RIGHT". Defaults to "RIGHT_LEFT". Some diagonals are shorter than max_diag_len and need to be padded. align is a string specifying how superdiagonals and subdiagonals should be aligned, respectively. There are four possible alignments: "RIGHT_LEFT" (default), "LEFT_RIGHT", "LEFT_LEFT", and "RIGHT_RIGHT". "RIGHT_LEFT" aligns superdiagonals to the right (left-pads the row) and subdiagonals to the left (right-pads the row). It is the packing format LAPACK uses. cuSPARSE uses "LEFT_RIGHT", which is the opposite alignment.
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as diagonal.


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.MatrixSetDiagV2 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.MatrixSetDiagV2
tf.raw_ops.MatrixSetDiagV2(
    input, diagonal, k, name=None
)
 Given input and diagonal, this operation returns a tensor with the same shape and values as input, except for the specified diagonals of the innermost matrices. These will be overwritten by the values in diagonal. input has r+1 dimensions [I, J, ..., L, M, N]. When k is scalar or k[0] == k[1], diagonal has r dimensions [I, J, ..., L, max_diag_len]. Otherwise, it has r+1 dimensions [I, J, ..., L, num_diags, max_diag_len]. num_diags is the number of diagonals, num_diags = k[1] - k[0] + 1. max_diag_len is the longest diagonal in the range [k[0], k[1]], max_diag_len = min(M + min(k[1], 0), N + min(-k[0], 0)) The output is a tensor of rank k+1 with dimensions [I, J, ..., L, M, N]. If k is scalar or k[0] == k[1]: output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, n-max(k[1], 0)] ; if n - m == k[1]
    input[i, j, ..., l, m, n]              ; otherwise
 Otherwise, output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
    input[i, j, ..., l, m, n]                         ; otherwise
 where d = n - m, diag_index = k[1] - d, and index_in_diag = n - max(d, 0). For example: # The main diagonal.
input = np.array([[[7, 7, 7, 7],              # Input shape: (2, 3, 4)
                   [7, 7, 7, 7],
                   [7, 7, 7, 7]],
                  [[7, 7, 7, 7],
                   [7, 7, 7, 7],
                   [7, 7, 7, 7]]])
diagonal = np.array([[1, 2, 3],               # Diagonal shape: (2, 3)
                     [4, 5, 6]])
tf.matrix_set_diag(diagonal) ==> [[[1, 7, 7, 7],  # Output shape: (2, 3, 4)
                                   [7, 2, 7, 7],
                                   [7, 7, 3, 7]],
                                  [[4, 7, 7, 7],
                                   [7, 5, 7, 7],
                                   [7, 7, 6, 7]]]

# A superdiagonal (per batch).
tf.matrix_set_diag(diagonal, k = 1)
  ==> [[[7, 1, 7, 7],  # Output shape: (2, 3, 4)
        [7, 7, 2, 7],
        [7, 7, 7, 3]],
       [[7, 4, 7, 7],
        [7, 7, 5, 7],
        [7, 7, 7, 6]]]

# A band of diagonals.
diagonals = np.array([[[1, 2, 3],  # Diagonal shape: (2, 2, 3)
                       [4, 5, 0]],
                      [[6, 1, 2],
                       [3, 4, 0]]])
tf.matrix_set_diag(diagonals, k = (-1, 0))
  ==> [[[1, 7, 7, 7],  # Output shape: (2, 3, 4)
        [4, 2, 7, 7],
        [0, 5, 3, 7]],
       [[6, 7, 7, 7],
        [3, 1, 7, 7],
        [7, 4, 2, 7]]]

 Args
  input   A Tensor. Rank r+1, where r >= 1.
  diagonal   A Tensor. Must have the same type as input. Rank r when k is an integer or k[0] == k[1]. Otherwise, it has rank r+1. k >= 1.
  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].
  name   A name for the operation (optional).

 Returns   A Tensor. Has the same type as input.


tf.raw_ops.MatrixSetDiagV3 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.MatrixSetDiagV3
tf.raw_ops.MatrixSetDiagV3(
    input, diagonal, k, align='RIGHT_LEFT', name=None
)
 Given input and diagonal, this operation returns a tensor with the same shape and values as input, except for the specified diagonals of the innermost matrices. These will be overwritten by the values in diagonal. input has r+1 dimensions [I, J, ..., L, M, N]. When k is scalar or k[0] == k[1], diagonal has r dimensions [I, J, ..., L, max_diag_len]. Otherwise, it has r+1 dimensions [I, J, ..., L, num_diags, max_diag_len]. num_diags is the number of diagonals, num_diags = k[1] - k[0] + 1. max_diag_len is the longest diagonal in the range [k[0], k[1]], max_diag_len = min(M + min(k[1], 0), N + min(-k[0], 0)) The output is a tensor of rank k+1 with dimensions [I, J, ..., L, M, N]. If k is scalar or k[0] == k[1]: output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, n-max(k[1], 0)] ; if n - m == k[1]
    input[i, j, ..., l, m, n]              ; otherwise
 Otherwise, output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
    input[i, j, ..., l, m, n]                         ; otherwise
 where d = n - m, diag_index = k[1] - d, and index_in_diag = n - max(d, 0) + offset. offset is zero except when the alignment of the diagonal is to the right. offset = max_diag_len - diag_len(d) ; if (`align` in {RIGHT_LEFT, RIGHT_RIGHT}
                                           and `d >= 0`) or
                                         (`align` in {LEFT_RIGHT, RIGHT_RIGHT}
                                           and `d <= 0`)
         0                          ; otherwise
 where diag_len(d) = min(cols - max(d, 0), rows + min(d, 0)). For example: # The main diagonal.
input = np.array([[[7, 7, 7, 7],              # Input shape: (2, 3, 4)
                   [7, 7, 7, 7],
                   [7, 7, 7, 7]],
                  [[7, 7, 7, 7],
                   [7, 7, 7, 7],
                   [7, 7, 7, 7]]])
diagonal = np.array([[1, 2, 3],               # Diagonal shape: (2, 3)
                     [4, 5, 6]])
tf.matrix_set_diag(input, diagonal)
  ==> [[[1, 7, 7, 7],  # Output shape: (2, 3, 4)
        [7, 2, 7, 7],
        [7, 7, 3, 7]],
       [[4, 7, 7, 7],
        [7, 5, 7, 7],
        [7, 7, 6, 7]]]

# A superdiagonal (per batch).
tf.matrix_set_diag(input, diagonal, k = 1)
  ==> [[[7, 1, 7, 7],  # Output shape: (2, 3, 4)
        [7, 7, 2, 7],
        [7, 7, 7, 3]],
       [[7, 4, 7, 7],
        [7, 7, 5, 7],
        [7, 7, 7, 6]]]

# A band of diagonals.
diagonals = np.array([[[0, 9, 1],  # Diagonal shape: (2, 4, 3)
                       [6, 5, 8],
                       [1, 2, 3],
                       [4, 5, 0]],
                      [[0, 1, 2],
                       [5, 6, 4],
                       [6, 1, 2],
                       [3, 4, 0]]])
tf.matrix_set_diag(input, diagonals, k = (-1, 2))
  ==> [[[1, 6, 9, 7],  # Output shape: (2, 3, 4)
        [4, 2, 5, 1],
        [7, 5, 3, 8]],
       [[6, 5, 1, 7],
        [3, 1, 6, 2],
        [7, 4, 2, 4]]]

# LEFT_RIGHT alignment.
diagonals = np.array([[[9, 1, 0],  # Diagonal shape: (2, 4, 3)
                       [6, 5, 8],
                       [1, 2, 3],
                       [0, 4, 5]],
                      [[1, 2, 0],
                       [5, 6, 4],
                       [6, 1, 2],
                       [0, 3, 4]]])
tf.matrix_set_diag(input, diagonals, k = (-1, 2), align="LEFT_RIGHT")
  ==> [[[1, 6, 9, 7],  # Output shape: (2, 3, 4)
        [4, 2, 5, 1],
        [7, 5, 3, 8]],
       [[6, 5, 1, 7],
        [3, 1, 6, 2],
        [7, 4, 2, 4]]]

 Args
  input   A Tensor. Rank r+1, where r >= 1.
  diagonal   A Tensor. Must have the same type as input. Rank r when k is an integer or k[0] == k[1]. Otherwise, it has rank r+1. k >= 1.
  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].
  align   An optional string from: "LEFT_RIGHT", "RIGHT_LEFT", "LEFT_LEFT", "RIGHT_RIGHT". Defaults to "RIGHT_LEFT". Some diagonals are shorter than max_diag_len and need to be padded. align is a string specifying how superdiagonals and subdiagonals should be aligned, respectively. There are four possible alignments: "RIGHT_LEFT" (default), "LEFT_RIGHT", "LEFT_LEFT", and "RIGHT_RIGHT". "RIGHT_LEFT" aligns superdiagonals to the right (left-pads the row) and subdiagonals to the left (right-pads the row). It is the packing format LAPACK uses. cuSPARSE uses "LEFT_RIGHT", which is the opposite alignment.
  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