ML Community Day is November 9! Join us for updates from TensorFlow, JAX, and more Learn more


LinearOperator acting like a [batch] square identity matrix.

Inherits From: LinearOperator, Module

This operator acts like a [batch] identity matrix A with shape [B1,...,Bb, N, N] for some b >= 0. The first b indices index a batch member. For every batch index (i1,...,ib), A[i1,...,ib, : :] is an N x N matrix. This matrix A is not materialized, but for purposes of broadcasting this shape will be relevant.

LinearOperatorIdentity is initialized with num_rows, and optionally batch_shape, and dtype arguments. If batch_shape is None, this operator efficiently passes through all arguments. If batch_shape is provided, broadcasting may occur, which will require making copies.

# Create a 2 x 2 identity matrix.
operator = LinearOperatorIdentity(num_rows=2, dtype=tf.float32)

==> [[1., 0.]
     [0., 1.]]

==> [2, 2]

==> 0.

x = ... Shape [2, 4] Tensor
==> Shape [2, 4] Tensor, same as x.

y = tf.random.normal(shape=[3, 2, 4])
# Note that y.shape is compatible with operator.shape because operator.shape
# is broadcast to [3, 2, 2].
# This broadcast does NOT require copying data, since we can infer that y
# will be passed through without changing shape.  We are always able to infer
# this if the operator has no batch_shape.
x = operator.solve(y)
==> Shape [3, 2, 4] Tensor, same as y.

# Create a 2-batch of 2x2 identity matrices
operator = LinearOperatorIdentity(num_rows=2, batch_shape=[2])
==> [[[1., 0.]
      [0., 1.]],
     [[1., 0.]
      [0., 1.]]]

# Here, even though the operator has a batch shape, the input is the same as
# the output, so x can be passed through without a copy.  The operator is able
# to detect that no broadcast is necessary because both x and the operator
# have statically defined shape.
x = ... Shape [2, 2, 3]
==> Shape [2, 2, 3] Tensor, same as x

# Here the operator and x have different batch_shape, and are broadcast.
# This requires a copy, since the output is different size than the input.
x = ... Shape [1, 2, 3]
==> Shape [2, 2, 3] Tensor, equal to [x, x]

Shape compatibility

This operator acts on [batch] matrix with compatible shape. x is a batch matrix with compatible shape for matmul and solve if

operator.shape = [B1,...,Bb] + [N, N],  with b >= 0
x.shape =   [C1,...,Cc] + [N, R],
and [C1,...,Cc] broadcasts with [B1,...,Bb] to [D1,...,Dd]


If batch_shape initialization arg is None:

  • operator.matmul(x) is O(1)
  • operator.solve(x) is O(1)
  • operator.determinant() is O(1)

If batch_shape initialization arg is provided, and static checks cannot rule out the need to broadcast:

  • operator.matmul(x) is O(D1*...*Dd*N*R)
  • operator.solve(x) is O(D1*...*Dd*N*R)
  • operator.determinant() is O(B1*...*Bb)

Matrix property hints

This LinearOperator is initialized with boolean flags of the form is_X, for X = non_singular, self_adjoint, positive_definite, square. These have the following meaning:

  • I