Python SciPy optimize.lsq_linear用法及代码示例

本文简要介绍 python 语言中 scipy.optimize.lsq_linear 的用法。

用法:

scipy.optimize.lsq_linear(A, b, bounds=(-inf, inf), method='trf', tol=1e-10, lsq_solver=None, lsmr_tol=None, max_iter=None, verbose=0, *, lsmr_maxiter=None)#

求解具有变量界限的线性最小二乘问题。

给定 m-by-n 设计矩阵 A 和具有 m 个元素的目标向量 b，lsq_linear 解决以下优化问题：

minimize 0.5 * ||A x - b||**2
subject to lb <= x <= ub

这个优化问题是凸的，因此保证找到的最小值(如果迭代已经收敛)是全局的。

参数 ：：

A： 数组，LinearOperator 的稀疏矩阵，形状 (m, n)

设计矩阵。可以是 scipy.sparse.linalg.LinearOperator 。

b： 数组, 形状 (m,)

目标向量。

bounds： 数组 或 Bounds 的 2 元组，可选

参数的下限和上限。默认为无限制。有两种方法可以指定边界：

• Instance of Bounds class.

• 2-tuple of array_like: Each element of the tuple must be either an array with the length equal to the number of parameters, or a scalar (in which case the bound is taken to be the same for all parameters). Use np.inf with an appropriate sign to disable bounds on all or some parameters.

method： ‘trf’ 或 ‘bvls’，可选

执行最小化的方法。

• ‘trf’ : Trust Region Reflective algorithm adapted for a linear least-squares problem. This is an interior-point-like method and the required number of iterations is weakly correlated with the number of variables.

• ‘bvls’ : Bounded-variable least-squares algorithm. This is an active set method, which requires the number of iterations comparable to the number of variables. Can’t be used when A is sparse or LinearOperator.

默认为‘trf’。

tol： 浮点数，可选

公差参数。如果成本函数的相对变化小于最后一次迭代的 tol，则算法终止。此外，还考虑了first-order 最优性度量：

• method='trf' terminates if the uniform norm of the gradient, scaled to account for the presence of the bounds, is less than tol.

• method='bvls' terminates if Karush-Kuhn-Tucker conditions are satisfied within tol tolerance.

lsq_solver： {无，‘exact’, ‘lsmr’}，可选

在整个迭代过程中求解无界最小二乘问题的方法：

• ‘exact’ : Use dense QR or SVD decomposition approach. Can’t be used when A is sparse or LinearOperator.

• ‘lsmr’ : Use scipy.sparse.linalg.lsmr iterative procedure which requires only matrix-vector product evaluations. Can’t be used with method='bvls'.

如果无(默认)，则根据 A 的类型选择求解器。

lsmr_tol： 无，浮点数或‘auto’，可选

scipy.sparse.linalg.lsmr 的公差参数 ‘atol’ 和 ‘btol’ 如果无(默认)，则设置为 1e-2 * tol 。如果‘auto’，容差将根据当前迭代的最优性进行调整，这可以加快优化过程，但并不总是可靠。

max_iter： 无或整数，可选

终止前的最大迭代次数。如果为 None(默认)，则将 method='trf' 设置为 100，或者将 method='bvls' 设置为变量数(不计算 ‘bvls’ 初始化的迭代次数)。

verbose： {0, 1, 2}，可选

算法的详细程度：

• 0 : work silently (default).

• 1 : display a termination report.

• 2 : display progress during iterations.

lsmr_maxiter： 无或整数，可选

lsmr 最小二乘求解器的最大迭代次数(如果使用的话)(通过设置lsq_solver='lsmr')。如果无(默认)，则使用 lsmr 的默认值min(m, n)其中m和n是行数和列数A， 分别。没有影响，如果lsq_solver='exact'.

返回 ：：

OptimizeResult 定义了以下字段：

x： ndarray，形状(n，)

找到解决方案。

cost： 浮点数

解决方案的成本函数值。

fun： ndarray，形状(m，)

解处的残差向量。

optimality： 浮点数

First-order 最优性度量。具体含义取决于方法，参考 tol 参数的说明。

active_mask： int的ndarray，形状(n，)

每个组件显示相应的约束是否处于活动状态(即变量是否在边界处)：

• 0 : a constraint is not active.

• -1 : a lower bound is active.

• 1 : an upper bound is active.

trf 方法可能有些随意，因为它会生成一系列严格可行的迭代，并且 active_mask 在容差阈值内确定。

unbounded_sol： 元组

最小二乘求解器返回的无界最小二乘解元组(设置为lsq_solver选项)。如果lsq_solver未设置或设置为'exact'，该元组包含一个具有无界解的形状为 (n,) 的 ndarray、一个具有残差平方和的 ndarray、一个排名为 的 intA，以及一个具有奇异值的 ndarrayA(参见 NumPy 的linalg.lstsq了解更多信息)。如果lsq_solver被设定为'lsmr'，该元组包含一个具有无界解的形状 (n,) 的 ndarray、一个具有退出代码的 int、一个具有迭代次数的 int 以及具有各种范数和条件数的五个浮点数A(参见 SciPy 的sparse.linalg.lsmr了解更多信息)。此输出可用于确定最小二乘求解器的收敛性，特别是迭代求解器'lsmr'求解器。无界最小二乘问题是最小化0.5 * ||A x - b||**2.

nit： int

迭代次数。如果无约束解是最优的，则为零。

status： int

算法终止原因：

• -1 : the algorithm was not able to make progress on the last iteration.

• 0 : the maximum number of iterations is exceeded.

• 1 : the first-order optimality measure is less than tol.

• 2 : the relative change of the cost function is less than tol.

• 3 : the unconstrained solution is optimal.

message： str

终止原因的口头说明。

success： bool

如果满足收敛标准之一(状态 > 0)，则为真。

注意：

该算法首先计算无约束最小二乘解：numpy.linalg.lstsq或者scipy.sparse.linalg.lsmr根据lsq_solver.如果该解决方案位于边界内，则该解决方案将作为最佳解决方案返回。

方法 ‘trf’ 针对线性最小二乘问题运行 [STIR] 中说明的算法的改编。迭代本质上与非线性最小二乘算法相同，但由于二次函数模型始终准确，因此我们不需要跟踪或修改信任区域的半径。当选定的步骤不会降低成本函数时，线搜索(回溯)用作安全网。在 scipy.optimize.least_squares 中阅读该算法的更多详细说明。

方法 ‘bvls’ 运行 [BVLS] 中说明的算法的 Python 实现。该算法维护活跃和自由的变量集，在每次迭代时选择一个新变量从活跃集移动到自由集，然后解决自由变量上的无约束最小二乘问题。该算法保证最终给出准确的解决方案，但对于具有 n 个变量的问题可能需要最多 n 次迭代。此外，还实施了一个临时初始化过程，该过程确定最初要设置空闲或活动的变量。在实际 BVLS 开始之前需要进行一定次数的迭代，但可以显著减少进一步迭代的次数。

参考：

[STIR]

M. A. Branch、T. F. Coleman 和 Y. Li，“Large-Scale Bound-Constrained 最小化问题的子空间、内部和共轭梯度方法”，SIAM 科学计算杂志，卷。 21，第 1 期，第 1-23 页，1999 年。

[BVLS]

P. B. Start 和 R. L. Parker，“Bounded-Variable 最小二乘：算法和应用”，计算统计，10, 129-141, 1995。

例子：

在此示例中，解决了大型稀疏矩阵和变量界限的问题。

>>> import numpy as np
>>> from scipy.sparse import rand
>>> from scipy.optimize import lsq_linear
>>> rng = np.random.default_rng()
...
>>> m = 20000
>>> n = 10000
...
>>> A = rand(m, n, density=1e-4, random_state=rng)
>>> b = rng.standard_normal(m)
...
>>> lb = rng.standard_normal(n)
>>> ub = lb + 1
...
>>> res = lsq_linear(A, b, bounds=(lb, ub), lsmr_tol='auto', verbose=1)
# may vary
The relative change of the cost function is less than `tol`.
Number of iterations 16, initial cost 1.5039e+04, final cost 1.1112e+04,
first-order optimality 4.66e-08.