torch.lstsq

torch.lstsq(input, A, *, out=None)

Computes the solution to the least squares and least norm problems for a full rank matrix $A$ of size $(m \times n)$ and a matrix $B$ of size $(m \times k)$.

If $m \geq n$, lstsq() solves the least-squares problem:

$$\begin{array}{ll} \min_X & \|AX-B\|_2. \end{array}$$

If $m < n$, lstsq() solves the least-norm problem:

$$\begin{array}{llll} \min_X & \|X\|_2 & \text{subject to} & AX = B. \end{array}$$

Returned tensor $X$ has shape $(\max(m, n) \times k)$. The first $n$ rows of $X$ contains the solution. If $m \geq n$, the residual sum of squares for the solution in each column is given by the sum of squares of elements in the remaining $m - n$ rows of that column.

Warning

torch.lstsq() is deprecated in favor of torch.linalg.lstsq() and will be removed in a future PyTorch release. torch.linalg.lstsq() has reversed arguments and does not return the QR decomposition in the returned tuple, (it returns other information about the problem). The returned solution in torch.lstsq() stores the residuals of the solution in the last m - n columns in the case m > n. In torch.linalg.lstsq(), the residuals are in the field ‘residuals’ of the returned named tuple.

Unpacking the solution as X = torch.lstsq(B, A).solution[:A.size(1)] should be replaced with

X = torch.linalg.lstsq(A, B).solution

Note

The case when $m < n$ is not supported on the GPU.

Parameters

• input (Tensor) – the matrix $B$

• A (Tensor) – the $m$ by $n$ matrix $A$

Keyword Arguments

out (tuple, optional) – the optional destination tensor

Returns

A namedtuple (solution, QR) containing:

• solution (Tensor): the least squares solution

• QR (Tensor): the details of the QR factorization

Return type

(Tensor, Tensor)

Note

The returned matrices will always be transposed, irrespective of the strides of the input matrices. That is, they will have stride (1, m) instead of (m, 1).

Example:

>>> A = torch.tensor([[1., 1, 1],
...                   [2, 3, 4],
...                   [3, 5, 2],
...                   [4, 2, 5],
...                   [5, 4, 3]])
>>> B = torch.tensor([[-10., -3],
...                   [ 12, 14],
...                   [ 14, 12],
...                   [ 16, 16],
...                   [ 18, 16]])
>>> X, _ = torch.lstsq(B, A)
>>> X
tensor([[  2.0000,   1.0000],
        [  1.0000,   1.0000],
        [  1.0000,   2.0000],
        [ 10.9635,   4.8501],
        [  8.9332,   5.2418]])