torch.linalg.lu_factor¶

torch.linalg.
lu_factor
(A, *, bool pivot=True, out=None) > (Tensor, Tensor)¶ Computes a compact representation of the LU factorization with partial pivoting of a matrix.
This function computes a compact representation of the decomposition given by
torch.linalg.lu()
. If the matrix is square, this representation may be used intorch.linalg.lu_solve()
to solve system of linear equations that share the matrixA
.The returned decomposition is represented as a named tuple (LU, pivots). The
LU
matrix has the same shape as the input matrixA
. Its upper and lower triangular parts encode the nonconstant elements ofL
andU
of the LU decomposition ofA
.The returned permutation matrix is represented by a 1indexed vector. pivots[i] == j represents that in the ith step of the algorithm, the ith row was permuted with the j1th row.
On CUDA, one may use
pivot
= False. In this case, this function returns the LU decomposition without pivoting if it exists.Supports inputs of float, double, cfloat and cdouble dtypes. Also supports batches of matrices, and if the inputs are batches of matrices then the output has the same batch dimensions.
Note
When inputs are on a CUDA device, this function synchronizes that device with the CPU. For a version of this function that does not synchronize, see
torch.linalg.lu_factor_ex()
.Warning
The LU decomposition is almost never unique, as often there are different permutation matrices that can yield different LU decompositions. As such, different platforms, like SciPy, or inputs on different devices, may produce different valid decompositions.
Gradient computations are only supported if the input matrix is fullrank. If this condition is not met, no error will be thrown, but the gradient may not be finite. This is because the LU decomposition with pivoting is not differentiable at these points.
See also
torch.linalg.lu_solve()
solves a system of linear equations given the output of this function provided the input matrix was square and invertible.torch.linalg.lu()
computes the LU decomposition with partial pivoting of a possibly nonsquare matrix.torch.linalg.solve()
solves a system of linear equations. It is a composition oflu_factor()
andlu_solve()
. Parameters
A (Tensor) – tensor of shape (*, m, n) where * is zero or more batch dimensions.
 Keyword Arguments
 Returns
A named tuple (LU, pivots).
 Raises
RuntimeError – if the
A
matrix is not invertible or any matrix in a batchedA
is not invertible.
Examples:
>>> A = torch.randn(2, 3, 3) >>> B1 = torch.randn(2, 3, 4) >>> B2 = torch.randn(2, 3, 7) >>> A_factor = torch.linalg.lu_factor(A) >>> X1 = torch.linalg.lu_solve(A_factor, B1) >>> X2 = torch.linalg.lu_solve(A_factor, B2) >>> torch.allclose(A @ X1, B1) True >>> torch.allclose(A @ X2, B2) True