Computes the LU factorization of a matrix or batches of matrices
A. Returns a tuple containing the LU factorization and pivots of
A. Pivoting is done if
pivotis set to
The returned permutation matrix for every matrix in the batch is represented by a 1-indexed vector of size
pivots[i] == jrepresents that in the
i-th step of the algorithm, the
i-th row was permuted with the
LU factorization with
Falseis not available for CPU, and attempting to do so will throw an error. However, LU factorization with
Falseis available for CUDA.
This function does not check if the factorization was successful or not if
Truesince the status of the factorization is present in the third element of the return tuple.
In the case of batches of square matrices with size less or equal to 32 on a CUDA device, the LU factorization is repeated for singular matrices due to the bug in the MAGMA library (see magma issue 13).
Pcan be derived using
The gradients of this function will only be finite when
Ais full rank. This is because the LU decomposition is just differentiable at full rank matrices. Furthermore, if
Ais close to not being full rank, the gradient will be numerically unstable as it depends on the computation of and .
A (Tensor) – the tensor to factor of size
pivot (bool, optional) – controls whether pivoting is done. Default:
get_infos (bool, optional) – if set to
True, returns an info IntTensor. Default:
out (tuple, optional) – optional output tuple. If
True, then the elements in the tuple are Tensor, IntTensor, and IntTensor. If
False, then the elements in the tuple are Tensor, IntTensor. Default:
A tuple of tensors containing
factorization (Tensor): the factorization of size
pivots (IntTensor): the pivots of size .
pivotsstores all the intermediate transpositions of rows. The final permutation
permcould be reconstructed by applying
swap(perm[i], perm[pivots[i] - 1])for
i = 0, ..., pivots.size(-1) - 1, where
permis initially the identity permutation of elements (essentially this is what
infos (IntTensor, optional): if
True, this is a tensor of size where non-zero values indicate whether factorization for the matrix or each minibatch has succeeded or failed
- Return type
(Tensor, IntTensor, IntTensor (optional))
>>> A = torch.randn(2, 3, 3) >>> A_LU, pivots = torch.lu(A) >>> A_LU tensor([[[ 1.3506, 2.5558, -0.0816], [ 0.1684, 1.1551, 0.1940], [ 0.1193, 0.6189, -0.5497]], [[ 0.4526, 1.2526, -0.3285], [-0.7988, 0.7175, -0.9701], [ 0.2634, -0.9255, -0.3459]]]) >>> pivots tensor([[ 3, 3, 3], [ 3, 3, 3]], dtype=torch.int32) >>> A_LU, pivots, info = torch.lu(A, get_infos=True) >>> if info.nonzero().size(0) == 0: ... print('LU factorization succeeded for all samples!') LU factorization succeeded for all samples!