SciPy 1.12 中文文档（二十六）
scipy.optimize.fmin_l_bfgs_b
scipy.optimize.fmin_l_bfgs_b(func, x0, fprime=None, args=(), approx_grad=0, bounds=None, m=10, factr=10000000.0, pgtol=1e-05, epsilon=1e-08, iprint=-1, maxfun=15000, maxiter=15000, disp=None, callback=None, maxls=20)
使用 L-BFGS-B 算法最小化函数 func。
参数：
funccallable f(x,*args)
要最小化的函数。
x0ndarray
初始猜测。
fprimecallable fprime(x,*args)，可选
func的梯度。如果为 None，则func返回函数值和梯度（f, g = func(x, *args)），除非approx_grad为 True，在这种情况下func仅返回f。
args序列，可选
传递给func和fprime的参数。
approx_grad布尔值，可选
是否数值近似梯度（此时func仅返回函数值）。
bounds列表，可选
对于 x 中每个元素的(min, max)对，定义该参数的边界。当该方向上没有边界时使用 None 或+-inf。
m整数，可选
用于定义有限内存矩阵的最大变量度量修正数。（有限内存 BFGS 方法不存储完整的 Hessian 矩阵，而是使用这么多项的近似值。）
factr浮点数，可选
当(f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= factr * eps时，迭代停止，其中eps是代码自动生成的机器精度。factr的典型值为：低精度为 1e12；中等精度为 1e7；极高精度为 10.0。请参见注释以了解与ftol的关系，后者由scipy.optimize.minimize接口暴露给 L-BFGS-B，而不是factr。
pgtol浮点数，可选
当max{|proj g_i | i = 1, ..., n} <= pgtol时，迭代将停止，其中proj g_i是投影梯度的第 i 个分量。
epsilon浮点数，可选
当approx_grad为 True 时使用的步长，用于数值计算梯度。
iprint整数，可选
控制输出频率。iprint < 0 表示无输出；iprint = 0 仅在最后一次迭代打印一行；0 < iprint < 99 每 iprint 次迭代还打印 f 和|proj g|；iprint = 99 每次迭代都打印详细信息，除了 n-向量；iprint = 100 还打印活跃集的变化和最终 x；iprint > 100 每次迭代都打印详细信息，包括 x 和 g。
disp整数，可选
如果为零，则没有输出。如果为正数，则覆盖iprint（即iprint取disp的值）。
maxfun整数，可选
最大函数评估次数。请注意，由于通过数值微分计算梯度，此函数可能会违反限制。
maxiter整数，可选
最大迭代次数。
callbackcallable，可选
在每次迭代后调用，作为callback(xk)，其中xk是当前参数向量。
maxlsint，可选
最大线搜索步骤数（每次迭代）。默认为 20。
返回：
xarray_like
最小值的估计位置。
ffloat
func 在最小值处的值。
ddict
信息字典。
-
d[‘warnflag’] 是
-
如果收敛则为 0，
-
如果函数评估或迭代次数过多则为 1，
-
如果由于其他原因停止，则为 2，具体原因见 d[‘task’]
-
-
d[‘grad’] 是最小值处的梯度（应该接近 0）。
-
d[‘funcalls’] 是进行的函数调用次数。
-
d[‘nit’] 是迭代次数。
另见
minimize
多变量函数的最小化算法接口。特别查看 ‘L-BFGS-B’ 方法。请注意，ftol 选项通过该接口提供，而 factr 则通过此接口提供，其中 factr 是将默认机器浮点精度乘以以计算 ftol 的因子：ftol = factr * numpy.finfo(float).eps。
注意
L-BFGS-B 的许可证（FORTRAN 代码）：
此处包含的版本（Fortran 代码）为 3.0（2011 年 4 月 25 日发布）。由 Ciyou Zhu、Richard Byrd 和 Jorge Nocedal 编写 nocedal@ece.nwu.edu。其使用条件如下：
本软件可自由使用，但我们期望所有使用该软件的工作或商业产品至少引用下列参考文献中的一篇。本软件根据 BSD 许可证发布。
参考文献
-
R. H. Byrd, P. Lu 和 J. Nocedal。有界约束优化的有限内存算法（1995），SIAM 科学与统计计算杂志，16，5，第 1190-1208 页。
-
C. Zhu, R. H. Byrd 和 J. Nocedal。L-BFGS-B：算法 778：大规模有界约束优化的 FORTRAN 例程（1997），ACM 数学软件交易，23，4，第 550 - 560 页。
-
J.L. Morales 和 J. Nocedal。L-BFGS-B：关于算法 778 的注记：大规模有界约束优化的 FORTRAN 例程（2011），ACM 数学软件交易，38，1。
scipy.optimize.fmin_tnc
scipy.optimize.fmin_tnc(func, x0, fprime=None, args=(), approx_grad=0, bounds=None, epsilon=1e-08, scale=None, offset=None, messages=15, maxCGit=-1, maxfun=None, eta=-1, stepmx=0, accuracy=0, fmin=0, ftol=-1, xtol=-1, pgtol=-1, rescale=-1, disp=None, callback=None)
使用截断牛顿算法中的梯度信息最小化受限变量的函数。此方法包装了算法的 C 实现。
参数：
funccallable func(x, *args)
要最小化的函数。必须执行以下操作之一：
-
返回 f 和 g，其中 f 是函数的值，g 是其梯度（一个浮点数列表）。
-
返回函数值，但单独提供梯度函数作为 fprime。
-
返回函数值并设置
approx_grad=True。
如果函数返回 None，则最小化过程中止。
x0array_like
最小值的初始估计。
fprimecallable fprime(x, *args)，可选
func 的梯度。如果为 None，则 func 必须返回函数值和梯度 (f,g = func(x, *args))，或者 approx_grad 必须为 True。
args元组，可选
传递给函数的参数。
approx_grad布尔值，可选
如果为真，则通过数值方法近似梯度。
bounds列表，可选
x0 中每个元素的（最小值，最大值）对，定义该参数的边界。当某个方向没有边界时，使用 None 或 +/-inf。
epsilon浮点数，可选
如果 approx_grad 为 True，则使用有限差分逼近中的步长。
scalearray_like，可选
应用于每个变量的缩放因子。如果为 None，则对于区间边界变量，因子是上限-下限，对于其他变量，因子是 1+|x|。默认为 None。
offsetarray_like，可选
从每个变量中减去的值。如果为 None，则对于区间边界变量，偏移量为 (上限+下限)/2，对于其他变量，偏移量为 x。
messages整数，可选
位掩码用于选择在最小化过程中显示的消息，值在 MSGS 字典中定义。默认为 MGS_ALL。
disp整数，可选
消息的整数界面。0 = 无消息，5 = 所有消息
maxCGit整数，可选
每次主迭代中的 Hessian*vector 评估的最大次数。如果 maxCGit == 0，则选择的方向为 -gradient；如果 maxCGit < 0，则 maxCGit 被设置为 max(1,min(50,n/2))。默认为 -1。
maxfun整数，可选
最大函数评估次数。如果为 None，则 maxfun 被设置为 max(100, 10*len(x0))。默认为 None。请注意，由于通过数值微分评估梯度，此函数可能会违反限制。
eta浮点数，可选
线搜索的严重性。如果 < 0 或 > 1，则设置为 0.25。默认为 -1。
stepmx浮点数，可选
线搜索的最大步长。可能在调用过程中增加。如果太小，则设置为 10.0。默认为 0。
accuracy浮点数，可选
有限差分计算的相对精度。如果 <= 机器精度，则设置为 sqrt(机器精度)。默认为 0。
fmin浮点数，可选
最小函数值估计。默认为 0。
ftol浮点数，可选
在停止标准中的 f 值的精度目标。如果 ftol < 0.0，则将 ftol 设置为 0.0，默认为-1。
xtolfloat，可选
在停止标准中的 x 值的精度目标（应用 x 缩放因子后）。如果 xtol < 0.0，则将 xtol 设置为 sqrt(machine_precision)。默认为-1。
pgtolfloat，可选
在停止标准中的投影梯度值的精度目标（应用 x 缩放因子后）。如果 pgtol < 0.0，则将 pgtol 设置为 1e-2 * sqrt(accuracy)。不建议将其设置为 0.0。默认为-1。
rescalefloat，可选
触发 f 值重新缩放的使用的缩放因子（以 log10 为单位）。如果为 0，则在每次迭代时重新缩放。如果为大值，则永不重新缩放。如果< 0，则将 rescale 设置为 1.3。
callbackcallable，可选
在每次迭代后调用，作为 callback(xk)，其中 xk 为当前参数向量。
返回：
xndarray
解决方案。
nfevalint
函数评估次数。
rcint
返回代码，请参见下文
亦可参见
minimize
多元函数最小化算法的接口。特别是请参见‘TNC’ 方法。
注释
底层算法为截断牛顿法，也称为牛顿共轭梯度。该方法与 scipy.optimize.fmin_ncg 不同之处在于
-
它包装了该算法的 C 实现
-
它允许为每个变量设定上下界。
该算法通过确定下降方向来整合约束条件，就像在无约束的截断牛顿法中一样，但从不采取足以离开可行 x 空间的步长。该算法跟踪一组当前活动约束，并在计算最小允许步长时忽略它们。（与活动约束相关联的 x 被保持不变。）如果最大允许步长为零，则添加新约束。在每次迭代结束时，可能会被认为不再活动并删除一个约束。如果当前活动但变量梯度向内从约束点，那么约束被认为不再活动。具体删除的约束是与不再活动约束的最大索引变量相关联的约束。
返回代码如下定义：
-1 : Infeasible (lower bound > upper bound)
0 : Local minimum reached (|pg| ~= 0)
1 : Converged (|f_n-f_(n-1)| ~= 0)
2 : Converged (|x_n-x_(n-1)| ~= 0)
3 : Max. number of function evaluations reached
4 : Linear search failed
5 : All lower bounds are equal to the upper bounds
6 : Unable to progress
7 : User requested end of minimization
参考文献
Wright S., Nocedal J.（2006 年），‘Numerical Optimization’
Nash S.G.（1984 年），“通过 Lanczos 方法的牛顿型最小化”，SIAM 数值分析期刊 21，pp. 770-778
scipy.optimize.fmin_cobyla
scipy.optimize.fmin_cobyla(func, x0, cons, args=(), consargs=None, rhobeg=1.0, rhoend=0.0001, maxfun=1000, disp=None, catol=0.0002, *, callback=None)
使用约束优化线性逼近（COBYLA）方法最小化函数。该方法封装了算法的 FORTRAN 实现。
参数：
func可调用对象
要最小化的函数。形式为 func(x, *args)。
x0数组
初始猜测。
cons序列
约束函数；必须全部>=0（如果只有一个约束，则为单个函数）。每个函数将参数 x 作为其第一个参数，并可以返回单个数字或数字的数组或列表。
args元组，可选
传递给函数的额外参数。
consargs元组，可选
传递给约束函数的额外参数（默认为 None 意味着使用与传递给 func 相同的额外参数）。使用 () 表示无额外参数。
rhobeg浮点数，可选
变量的合理初始更改。
rhoend浮点数，可选
优化中的最终精度（不能完全保证）。这是信任域大小的下界。
disp{0, 1, 2, 3}，可选
控制输出频率；0 表示无输出。
maxfun整数，可选
最大函数评估次数。
catol浮点数，可选
绝对容忍约束违规。
callback可调用对象，可选
在每次迭代后调用，格式为 callback(x)，其中 x 是当前参数向量。
返回：
x数组
最小化 f 的参数。
另请参阅
minimize
多元函数最小化算法的界面。特别参见‘COBYLA’ 方法。
注：
此算法基于目标函数和每个约束的线性逼近。我们简要描述算法。
假设正在对 k 个变量进行最小化函数。在第 j 次迭代中，算法具有 k+1 点 v_1, …, v_(k+1)，一个近似解 x_j，和一个半径 RHO_j。 (即线性加一个常数) 目标函数和约束函数的近似值使得它们在 k+1 点 v_1,.., v_(k+1) 上的函数值与线性逼近一致。这提供了一个要解决的线性程序（其中约束函数的线性逼近被限制为非负）。
然而，线性逼近可能仅在当前单纯形附近是良好的近似，因此线性程序还有进一步的要求，即解决方案，即将成为 x_(j+1)，必须在从 x_j 到 RHO_j 的范围内。 RHO_j 只会减少，不会增加。初始 RHO_j 是 rhobeg，最终 RHO_j 是 rhoend。通过这种方式，COBYLA 的迭代表现得像一个信任域算法。
此外，线性程序可能不一致，或者近似可能带来很差的改进。有关这些问题如何解决的详细信息，以及点 v_i 如何更新，请参考下面的源代码或参考资料。
参考资料
Powell M.J.D. (1994), “一种通过线性插值模拟目标和约束函数的直接搜索优化方法”, 在《优化与数值分析进展》中，主编 S. Gomez 和 J-P Hennart，Kluwer Academic（多德雷赫特），pp. 51-67
Powell M.J.D. (1998), “用于优化计算的直接搜索算法”, Acta Numerica 7, 287-336
Powell M.J.D. (2007), “无导数优化算法的一种观点”, 剑桥大学技术报告 DAMTP 2007/NA03
示例
最小化目标函数 f(x,y) = x*y，受限于约束 x2 + y2 < 1 且 y > 0：
>>> def objective(x):
... return x[0]*x[1]
...
>>> def constr1(x):
... return 1 - (x[0]**2 + x[1]**2)
...
>>> def constr2(x):
... return x[1]
...
>>> from scipy.optimize import fmin_cobyla
>>> fmin_cobyla(objective, [0.0, 0.1], [constr1, constr2], rhoend=1e-7)
array([-0.70710685, 0.70710671])
精确解是 (-sqrt(2)/2, sqrt(2)/2)。
scipy.optimize.fmin_slsqp
scipy.optimize.fmin_slsqp(func, x0, eqcons=(), f_eqcons=None, ieqcons=(), f_ieqcons=None, bounds=(), fprime=None, fprime_eqcons=None, fprime_ieqcons=None, args=(), iter=100, acc=1e-06, iprint=1, disp=None, full_output=0, epsilon=1.4901161193847656e-08, callback=None)
使用顺序最小二乘编程来最小化函数
最初由 Dieter Kraft 实现的 SLSQP 优化子程序的 Python 接口函数。
参数：
func可调用函数*f(x,args)
目标函数。必须返回一个标量。
x0浮点数的 1-D ndarray
独立变量的初始猜测。
eqcons列表，可选
一个长度为 n 的函数列表，使得 eqconsj == 0.0 在成功优化的问题中。
f_eqcons可调用函数*f(x,args)，可选
在成功优化的问题中，返回一个 1-D 数组，其中每个元素必须等于 0.0。如果指定了 f_eqcons，则忽略 eqcons。
ieqcons列表，可选
一个长度为 n 的函数列表，使得在成功优化的问题中，ieqconsj >= 0.0。
f_ieqcons可调用函数*f(x,args)，可选
在成功优化的问题中，返回一个 1-D ndarray，其中每个元素必须大于或等于 0.0。如果指定了 f_ieqcons，则忽略 ieqcons。
bounds列表，可选
一个元组列表，指定每个独立变量的下限和上限[(xl0, xu0),(xl1, xu1),…] 无限值将被解释为大浮点值。
fprime可调用函数*f(x,args)，可选
一个评估 func 的偏导数的函数。
fprime_eqcons可调用函数*f(x,args)，可选
一个形式为*f(x, *args)*的函数，返回 m 乘 n 的等式约束法线数组。如果未提供，则将近似法线。fprime_eqcons 返回的数组大小应为(len(eqcons), len(x0))。
fprime_ieqcons可调用函数*f(x,args)，可选
一个形式为*f(x, *args)*的函数，返回 m 乘 n 的不等式约束法线数组。如果未提供，则将近似法线。fprime_ieqcons 返回的数组大小应为(len(ieqcons), len(x0))。
args序列，可选
传递给 func 和 fprime 的额外参数。
iter整数，可选
最大迭代次数。
acc浮点数，可选
请求的精度。
iprint整数，可选
fmin_slsqp的详细输出：
-
iprint <= 0：静默操作
-
iprint == 1：在完成时打印总结（默认）
-
iprint >= 2：打印每次迭代的状态和总结
disp整数，可选
覆盖 iprint 界面（首选）。
full_output布尔值，可选
如果为 False，则仅返回 func 的最小化器（默认）。否则，输出最终的目标函数和总结信息。
epsilon浮点数，可选
有限差分导数估计的步长。
callback可调用函数，可选
在每次迭代后被调用，形式为callback(x)，其中x是当前的参数向量。
返回：
out浮点数的 ndarray
func 的最终最小化器。
fx浮点数的 ndarray，如果full_output为真
目标函数的最终值。
其int，如果full_output为真
迭代次数。
imodeint，如果full_output为真
优化器的退出模式（见下文）。
smodestring，如果full_output为真
描述优化器退出模式的消息。
另请参阅
minimize
多元函数最小化算法接口。特别查看‘SLSQP’ 方法。
注意事项
退出模式定义如下
-1 : Gradient evaluation required (g & a)
0 : Optimization terminated successfully
1 : Function evaluation required (f & c)
2 : More equality constraints than independent variables
3 : More than 3*n iterations in LSQ subproblem
4 : Inequality constraints incompatible
5 : Singular matrix E in LSQ subproblem
6 : Singular matrix C in LSQ subproblem
7 : Rank-deficient equality constraint subproblem HFTI
8 : Positive directional derivative for linesearch
9 : Iteration limit reached
举例
示例见教程中。
scipy.optimize.fminbound
scipy.optimize.fminbound(func, x1, x2, args=(), xtol=1e-05, maxfun=500, full_output=0, disp=1)
标量函数的有界最小化。
参数：
funccallable f(x,*args)
要最小化的目标函数（必须接受并返回标量）。
x1, x2float or array scalar
有限优化边界。
argstuple, optional
传递给函数的额外参数。
xtolfloat, optional
收敛容差。
maxfunint, optional
允许的最大函数评估次数。
full_outputbool, optional
如果为 True，则返回可选输出。
dispint, optional
如果非零，则打印消息。
0：无消息打印。1：仅非收敛通知消息。2：也打印收敛消息。3：打印迭代结果。
返回：
xoptndarray
在给定区间内最小化目标函数的参数。
fvalnumber
（可选输出）在最小化器处评估的函数值。
ierrint
（可选输出）错误标志（如果收敛则为 0，如果达到最大函数调用次数则为 1）。
numfuncint
（可选输出）进行的函数调用次数。
另请参见
标量单变量函数最小化算法的接口。特别是参见‘Bounded’ 方法。
注意
使用 Brent 方法在区间 x1 < xopt < x2 中找到标量函数 func 的局部最小化器。（参见brent 自动括号。）
引用
[1]
Forsythe, G.E., M. A. Malcolm, and C. B. Moler. “数学计算的计算机方法。” Prentice-Hall 自动计算系列 259 (1977).
[2]
Brent, Richard P. 无导数最小化算法。 Courier Corporation, 2013.
示例
fminbound 在给定范围内找到函数的最小化器。以下示例说明此功能。
>>> from scipy import optimize
>>> def f(x):
... return (x-1)**2
>>> minimizer = optimize.fminbound(f, -4, 4)
>>> minimizer
1.0
>>> minimum = f(minimizer)
>>> minimum
0.0
>>> res = optimize.fminbound(f, 3, 4, full_output=True)
>>> minimizer, fval, ierr, numfunc = res
>>> minimizer
3.000005960860986
>>> minimum = f(minimizer)
>>> minimum, fval
(4.000023843479476, 4.000023843479476)
scipy.optimize.brent
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.optimize.brent.html#scipy.optimize.brent
scipy.optimize.brent(func, args=(), brack=None, tol=1.48e-08, full_output=0, maxiter=500)
给定一个单变量函数和可能的 bracket，返回被孤立到 tol 分数精度的函数的局部最小值。
参数：
func可调用的 f(x,*args)
目标函数。
args元组，可选
额外的参数（如果存在）。
brack元组，可选
要么是满足xa < xb < xc且func(xb) < func(xa) and func(xb) < func(xc)的三元组(xa, xb, xc)，要么是用于下山搜索的初始点对(xa, xb)（参见scipy.optimize.bracket）。最小化器x不一定满足xa <= x <= xb。
tol浮点数，可选
解决方案xopt中可接受的相对误差。
full_output布尔型，可选
如果为真，则返回所有输出参数（xmin、fval、iter、funcalls）。
maxiter整数，可选
解决方案中的最大迭代次数。
返回值：
xminndarray
最优点。
fval浮点数
（可选输出）最优函数值。
iter整数
（可选输出）迭代次数。
funcalls整数
（可选输出）进行的目标函数评估次数。
参见
minimize_scalar
标量单变量函数最小化算法接口。详见特定的“Brent” 方法。
注意事项
在可能时使用反向抛物线插值来加速黄金分割法的收敛。
不保证最小值位于brack指定的范围内。参见scipy.optimize.fminbound。
示例
我们展示了在brack大小为 2 和 3 时函数的行为。在brack形式为(xa, xb)的情况下，我们可以看到对于给定的值，输出并不一定位于区间(xa, xb)内。
>>> def f(x):
... return (x-1)**2
>>> from scipy import optimize
>>> minimizer = optimize.brent(f, brack=(1, 2))
>>> minimizer
1
>>> res = optimize.brent(f, brack=(-1, 0.5, 2), full_output=True)
>>> xmin, fval, iter, funcalls = res
>>> f(xmin), fval
(0.0, 0.0)
scipy.optimize.golden
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.optimize.golden.html#scipy.optimize.golden
scipy.optimize.golden(func, args=(), brack=None, tol=1.4901161193847656e-08, full_output=0, maxiter=5000)
使用黄金分割法返回单变量函数的最小化器。
给定一个单变量函数和可能的括号区间，返回函数的最小化器，精确到 tol 的分数精度。
参数：
funccallable func(x,*args)
要最小化的目标函数。
argstuple, optional
如果存在其他参数，则传递给 func。
bracktuple, optional
要么是一个三元组 (xa, xb, xc)，其中 xa < xb < xc 且 func(xb) < func(xa) 且 func(xb) < func(xc)，要么是一对 (xa, xb)，用作向下搜索初始点的起始点（参见 scipy.optimize.bracket）。最小化器 x 不一定满足 xa <= x <= xb。
tolfloat, optional
x 容差停止准则
full_outputbool, optional
如果为 True，则返回可选输出。
maxiterint
要执行的最大迭代次数。
返回：
xminndarray
最优点。
fvalfloat
（可选输出）最优函数值。
funcallsint
（可选输出）执行的目标函数评估次数。
另请参阅
minimize_scalar
标量单变量函数最小化算法的接口。特别是参见“Golden” 方法。
注意事项
使用二分法的类似方法来缩小括号区间。
示例
我们演示了当 brack 的大小分别为 2 和 3 时函数的行为。在 brack 为 (xa, xb) 形式的情况下，我们可以看到对于给定的值，输出不一定在 (xa, xb) 范围内。
>>> def f(x):
... return (x-1)**2
>>> from scipy import optimize
>>> minimizer = optimize.golden(f, brack=(1, 2))
>>> minimizer
1
>>> res = optimize.golden(f, brack=(-1, 0.5, 2), full_output=True)
>>> xmin, fval, funcalls = res
>>> f(xmin), fval
(9.925165290385052e-18, 9.925165290385052e-18)
scipy.optimize.leastsq
scipy.optimize.leastsq(func, x0, args=(), Dfun=None, full_output=False, col_deriv=False, ftol=1.49012e-08, xtol=1.49012e-08, gtol=0.0, maxfev=0, epsfcn=None, factor=100, diag=None)
最小化一组方程的平方和。
x = arg min(sum(func(y)**2,axis=0))
y
参数：
func：callable
应至少接受一个（可能长度为N的向量）参数，并返回M个浮点数。不能返回 NaN，否则拟合可能失败。M必须大于或等于N。
x0：ndarray
最小化的起始估计。
args：tuple，可选
任何额外的参数放在这个元组中传递给func。
Dfun：callable，可选
计算横跨行的函数或方法来计算func的雅可比矩阵。如果为None，则将估计雅可比矩阵。
full_output：bool，可选
如果True，返回所有可选输出（而不仅仅是x和ier）。
col_deriv：bool，可选
如果True，指定雅可比函数计算列方向的导数（更快，因为没有转置操作）。
ftol：float，可选
在平方和的近似解中期望的相对误差。
xtol：float，可选
在近似解中期望的相对误差。
gtol：float，可选
功能向量和雅可比矩阵列之间期望的正交性。
maxfev：int，可选
函数的最大调用次数。如果提供了Dfun，则默认maxfev为 100*(N+1)，其中 N 是 x0 中的元素数，否则默认maxfev为 200*(N+1)。
epsfcn：float，可选
用于确定前向差分法雅可比矩阵适当步长的变量（对于Dfun=None）。通常实际步长将是 sqrt(epsfcn)*x，如果 epsfcn 小于机器精度，则假定相对误差为机器精度的量级。
factor：float，可选
一个参数，确定初始步长界限（factor * || diag * x||）。应在区间(0.1, 100)内。
diag：sequence，可选
作为变量的比例因子的 N 个正数条目。
返回：
x：ndarray
解决方案（或最后一次迭代的结果，对于未成功调用）。
cov_x：ndarray
海森的逆。fjac和ipvt用于构造参数x中曲率的估计。None 值表示奇异矩阵，这意味着参数x中的曲率在数值上是平坦的。要获取参数x的协方差矩阵，必须将cov_x乘以残差的方差 - 见 curve_fit。仅在full_output为True时返回。
infodict：dict
一个包含可选输出的字典，带有以下键：
nfev
函数调用的次数
fvec
在输出处评估的函数
fjac
一次 QR 分解的 R 矩阵的排列，以列存储。与 ipvt 一起，可以近似估计协方差。
ipvt
长度为 N 的整数数组，定义置换矩阵 p，使得 fjacp = qr，其中 r 是上三角矩阵，对角线元素不增加。p 的第 j 列是单位矩阵的第 ipvt(j) 列。
qtf
向量 (transpose(q) * fvec)。
仅当 full_output 为 True 时返回。
mesg 字符串
给出失败原因的字符串消息。仅当 full_output 为 True 时返回。
ier 整数
一个整数标志。如果它等于 1、2、3 或 4，则找到了解决方案。否则，未找到解决方案。无论哪种情况，可选输出变量 ‘mesg’ 提供更多信息。
另请参阅
least_squares
较新的接口用于解决带有变量界限的非线性最小二乘问题。特别查看 method='lm'。
注记
“leastsq” 是 MINPACK 的 lmdif 和 lmder 算法的封装。
cov_x 是最小二乘目标函数 Hessian 矩阵的雅可比近似。该近似假定目标函数基于观察到的目标数据 (ydata) 和参数 f(xdata, params) 的差异（非线性函数）。
func(params) = ydata - f(xdata, params)
使目标函数为
min sum((ydata - f(xdata, params))**2, axis=0)
params
解 x 总是一个一维数组，无论 x0 的形状如何，或者 x0 是否为标量。
示例
>>> from scipy.optimize import leastsq
>>> def func(x):
... return 2*(x-3)**2+1
>>> leastsq(func, 0)
(array([2.99999999]), 1)
scipy.optimize.fsolve
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.optimize.fsolve.html#scipy.optimize.fsolve
scipy.optimize.fsolve(func, x0, args=(), fprime=None, full_output=0, col_deriv=0, xtol=1.49012e-08, maxfev=0, band=None, epsfcn=None, factor=100, diag=None)
查找函数的根。
给定起始估计，返回func(x) = 0（非线性）方程的根。
参数：
funccallable f(x, *args)
一个至少需要一个（可能是向量）参数并返回相同长度值的函数。
x0ndarray
用于func(x) = 0根的起始估计。
argstuple，可选
传递给func的任何额外参数。
fprimecallable f(x, *args)，可选
一个计算func雅可比矩阵及其导数的函数。默认情况下，将估计雅可比矩阵。
full_outputbool，可选
如果为 True，则返回可选输出。
col_derivbool，可选
指定雅可比函数是否沿列计算导数（更快，因为没有转置操作）。
xtolfloat，可选
如果两次迭代之间的相对误差最多为xtol，则计算将终止。
maxfevint，可选
函数调用的最大次数。如果为零，则100*(N+1)是最大的，其中 N 是x0中元素的数量。
bandtuple，可选
如果设置为包含雅可比矩阵带内子和超对角线数的二元序列，则认为雅可比矩阵是带状的（仅适用于fprime=None）。
epsfcnfloat，可选
正向差分近似雅可比矩阵的合适步长（对于fprime=None）。如果epsfcn小于机器精度，则假定函数中的相对误差为机器精度的数量级。
factorfloat，可选
确定初始步长边界的参数（factor * || diag * x||）。应在区间(0.1, 100)内。
diagsequence，可选
用作变量的比例因子的正数输入。
返回：
xndarray
解决方案（或对于不成功的调用的最后迭代的结果）。
infodictdict
具有键的可选输出的字典：
nfev
函数调用次数
njev
雅可比调用的次数
fvec
在输出处评估的函数
fjac
正交矩阵 q，由最终近似雅可比矩阵的 QR 分解以列方式存储
r
由相同矩阵的 QR 分解产生的上三角矩阵
qtf
向量(转置(q) * fvec)
ierint
一个整数标志。如果找到解，则设置为 1，否则请参阅mesg获取更多信息。
mesgstr
如果找不到解，则mesg详细说明失败原因。
另请参见
多元函数的根查找算法接口。特别是参见method='hybr'。
注释
fsolve是 MINPACK 的 hybrd 和 hybrj 算法的包装器。
示例
找出方程组的解：x0*cos(x1) = 4, x1*x0 - x1 = 5。
>>> import numpy as np
>>> from scipy.optimize import fsolve
>>> def func(x):
... return [x[0] * np.cos(x[1]) - 4,
... x[1] * x[0] - x[1] - 5]
>>> root = fsolve(func, [1, 1])
>>> root
array([6.50409711, 0.90841421])
>>> np.isclose(func(root), [0.0, 0.0]) # func(root) should be almost 0.0.
array([ True, True])
scipy.optimize.broyden1
scipy.optimize.broyden1(F, xin, iter=None, alpha=None, reduction_method='restart', max_rank=None, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)
使用 Broyden 的第一个 Jacobian 近似找到函数的根。
此方法也称为“Broyden 的好方法”。
参数：
Ffunction(x) -> f
要查找其根的函数；应接受并返回一个类似数组的对象。
xinarray_like
解的初始猜测
alphafloat, optional
Jacobian 的初始猜测是(-1/alpha)。
reduction_methodstr or tuple, optional
用于确保 Broyden 矩阵排名保持低的方法。可以是一个字符串，给出方法的名称，或者是一个元组形式(method, param1, param2, ...)，给出方法的名称和额外参数的值。
方法可用：
restart: 丢弃所有矩阵列。没有额外参数。simple: 丢弃最老的矩阵列。没有额外参数。svd: 仅保留最重要的 SVD 分量。在进行秩减少时，采用额外参数to_retain，确定要保留的 SVD 分量数量。默认为max_rank - 2。
max_rankint, optional
Broyden 矩阵的最大排名。默认为无穷大（即无排名降低）。
iterint, optional
执行的迭代次数。如果省略（默认），则执行所需的迭代次数以满足容差。
verbosebool, optional
在每次迭代时将状态打印到标准输出。
maxiterint, optional
执行的最大迭代次数。如果需要更多次迭代以达到收敛性，将引发NoConvergence。
f_tolfloat, optional
相对于残差的最大范数的绝对容差。如果省略，默认为 6e-6。
f_rtolfloat, optional
相对残差的相对容差。如果省略，则不使用。
x_tolfloat, optional
从 Jacobian 近似中确定的绝对最小步长。如果步长小于此值，则优化被视为成功终止。如果省略，则不使用。
x_rtolfloat, optional
相对最小步长。如果省略，则不使用。
tol_normfunction(vector) -> scalar, optional
用于收敛检查的范数。默认为最大范数。
line_search{None, ‘armijo’ (default), ‘wolfe’}, optional
用于确定由 Jacobian 近似给出的方向中的步长大小的线搜索类型。默认为'armijo'。
callbackfunction, optional
可选的回调函数。每次迭代时调用，callback(x, f)其中x是当前解，f是相应的残差。
返回：
solndarray
包含最终解的数组（与x0具有相似的数组类型）。
引发：
NoConvergence
当未找到解决方案时。
另请参阅
多变量函数的根查找算法接口。特别是查看method='broyden1'。
注释
此算法实现了逆雅可比拟牛顿更新
[H_+ = H + (dx - H df) dx^\dagger H / ( dx^\dagger H df)]
对应于 Broyden 的第一个雅可比更新
[J_+ = J + (df - J dx) dx^\dagger / dx^\dagger dx]
参考文献
[1]
B.A. van der Rotten，博士论文，"用于解决高维非线性方程组的有限记忆 Broyden 方法"。荷兰莱顿大学数学研究所 (2003)。
web.archive.org/web/20161022015821/http://www.math.leidenuniv.nl/scripties/Rotten.pdf
示例
以下函数定义了一个非线性方程组
>>> def fun(x):
... return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0,
... 0.5 * (x[1] - x[0])**3 + x[1]]
可以按如下方式获得解决方案。
>>> from scipy import optimize
>>> sol = optimize.broyden1(fun, [0, 0])
>>> sol
array([0.84116396, 0.15883641])
scipy.optimize.broyden2
scipy.optimize.broyden2(F, xin, iter=None, alpha=None, reduction_method='restart', max_rank=None, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)
使用布罗伊登第二个雅可比近似找到函数的根。
此方法也称为“布罗伊登的坏方法”。
参数：
F 函数(x) -> f
求根的函数；应接受并返回一个类似数组的对象。
xin 数组样式
解的初始猜测
alpha 浮点数，可选
雅可比矩阵的初始猜测为(-1/alpha)。
reduction_method 字符串或元组，可选
用于确保布罗伊登矩阵秩保持低的方法。可以是一个给出方法名称的字符串，也可以是一个形如(method, param1, param2, ...)的元组，提供方法名称和额外参数的值。
方法可用：
restart：丢弃所有矩阵列。没有额外参数。simple：丢弃最旧的矩阵列。没有额外参数。svd：仅保留最显著的奇异值分解组件。带有额外参数to_retain，确定在降秩时保留的奇异值分解组件数量。默认为max_rank - 2。
max_rank 整数，可选
布罗伊登矩阵的最大秩。默认为无穷大（即无降秩）。
iter 整数，可选
要执行的迭代次数。如果省略（默认），则执行所需次数以满足公差。
verbose 布尔值，可选
在每次迭代中将状态打印到标准输出。
maxiter 整数，可选
要执行的最大迭代次数。如果需要更多次迭代以满足收敛性，则引发NoConvergence。
f_tol 浮点数，可选
残差的绝对容差（在最大范数中）。如果省略，默认为 6e-6。
f_rtol 浮点数，可选
残差的相对容差。如果省略，则不使用。
x_tol 浮点数，可选
绝对最小步长，根据雅可比近似确定。如果步长小于此值，则优化被视为成功终止。如果省略，不使用。
x_rtol 浮点数，可选
相对最小步长。如果省略，不使用。
tol_norm 函数(向量) -> 标量，可选
用于收敛检查的规范。默认为最大范数。
line_search {None, ‘armijo’ (默认), ‘wolfe’}，可选
用于确定雅可比近似方向上步长的线搜索类型。默认为‘armijo’。
callback 函数，可选
可选的回调函数。每次迭代时调用为callback(x, f)，其中x为当前解，f为相应的残差。
返回：
sol ndarray
包含最终解的数组（与x0类型相似）。
异常：
NoConvergence
未找到解时。
另请参阅
root
多元函数根查找算法的接口。特别查看method='broyden2'。
注：
该算法实现了逆雅各比拟牛顿更新
[H_+ = H + (dx - H df) df^\dagger / ( df^\dagger df)]
对应于布罗伊登第二方法。
参考文献
[1]
B.A. van der Rotten 博士论文，“解高维非线性方程组的有限内存布罗伊登方法”。荷兰莱顿大学数学研究所 (2003 年)。
web.archive.org/web/20161022015821/http://www.math.leidenuniv.nl/scripties/Rotten.pdf
例子
以下函数定义了一组非线性方程组
>>> def fun(x):
... return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0,
... 0.5 * (x[1] - x[0])**3 + x[1]]
可以如下获得一个解决方案。
>>> from scipy import optimize
>>> sol = optimize.broyden2(fun, [0, 0])
>>> sol
array([0.84116365, 0.15883529])
scipy.optimize.newton_krylov
scipy.optimize.newton_krylov(F, xin, iter=None, rdiff=None, method='lgmres', inner_maxiter=20, inner_M=None, outer_k=10, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)
寻找函数的根，使用基于克里洛夫逆雅可比矩阵近似的方法。
该方法适用于解决大规模问题。
参数：
Ffunction(x) -> f
要找根的函数；应接受并返回类似数组的对象。
xinarray_like
解的初始猜测
rdifffloat，可选
在数值微分中使用的相对步长。
methodstr 或可调用对象，可选
用于近似雅可比矩阵的克里洛夫方法。可以是字符串，或者实现与scipy.sparse.linalg中迭代求解器相同接口的函数。如果是字符串，则必须是以下之一：'lgmres'、'gmres'、'bicgstab'、'cgs'、'minres'、'tfqmr'。
默认为scipy.sparse.linalg.lgmres。
inner_maxiterint，可选
传递给“内部”克里洛夫求解器的参数：最大迭代次数。即使未达到指定的容差，迭代也将在 maxiter 步之后停止。
inner_MLinearOperator 或 InverseJacobian
内部克里洛夫迭代的预处理器。注意，您也可以使用逆雅可比矩阵作为（自适应）预处理器。例如，
>>> from scipy.optimize import BroydenFirst, KrylovJacobian
>>> from scipy.optimize import InverseJacobian
>>> jac = BroydenFirst()
>>> kjac = KrylovJacobian(inner_M=InverseJacobian(jac))
如果预处理器有一个名为‘update’的方法，它将在每个非线性步骤后被调用，参数为update(x, f)，其中x为当前点，f为当前函数值。
outer_kint，可选
在 LGMRES 非线性迭代过程中保留的子空间大小。详见scipy.sparse.linalg.lgmres了解详情。
inner_kwargskwargs
“内部”克里洛夫求解器的关键参数（由method定义）。参数名必须以inner_前缀开头，在传递给内部方法之前将被剥离。详见，例如scipy.sparse.linalg.gmres了解详情。
iterint，可选
要进行的迭代次数。如果省略（默认），则进行所需数量的迭代以满足容差。
verbosebool，可选
在每次迭代时将状态打印到标准输出。
maxiterint，可选
最大迭代次数。如果需要更多次迭代以满足收敛性，将引发NoConvergence异常。
f_tolfloat，可选
残差的绝对容差（在最大范数下）。如果省略，默认为 6e-6。
f_rtolfloat，可选
残差的相对容差。如果省略，则不使用。
x_tolfloat，可选
绝对最小步长，根据雅可比近似确定。如果步长小于此值，则优化成功终止。如果省略，则不使用。
x_rtol浮点数，可选
相对最小步长。如果省略，则不使用。
tol_norm函数（向量）->标量，可选
用于收敛检查的范数。默认为最大范数。
line_search{None, ‘armijo’ (default), ‘wolfe’}, 可选
用于确定由雅可比近似给出的方向上的步长的线搜索类型。默认为‘armijo’。
callback函数，可选
可选回调函数。每次迭代时调用callback(x, f)，其中x是当前解决方案，f是相应的残差。
返回：
solndarray
一个包含最终解决方案的数组（与x0类型相似）。
Raises:
NoConvergence
当未找到解决方案时。
另见
root
多变量函数根查找算法的接口。特别查看method='krylov'。
scipy.sparse.linalg.gmres
scipy.sparse.linalg.lgmres
注意事项
此函数实现了一个牛顿-克莱罗夫求解器。其基本思想是使用迭代的克莱罗夫方法计算雅可比矩阵的逆。这些方法只需要评估雅可比向量乘积，这些乘积可以方便地通过有限差分近似：
[J v \approx (f(x + \omega*v/|v|) - f(x)) / \omega]
由于使用迭代矩阵逆，这些方法可以处理大型非线性问题。
SciPy 的scipy.sparse.linalg模块提供了一系列可供选择的克莱罗夫求解器。默认选择lgmres，这是一种重启的 GMRES 迭代的变体，它重复利用先前牛顿步骤中获取的某些信息来反转雅可比矩阵。
有关牛顿-克莱罗夫方法的评论，请参见例如[1]，以及关于 LGMRES 稀疏逆方法，请参见[2]。
参考文献
[1]
C. T. Kelley，《使用牛顿法解非线性方程》，SIAM，第 57-83 页，2003 年。DOI:10.1137/1.9780898718898.ch3
[2]
D.A. Knoll 和 D.E. Keyes，《J. Comp. Phys. 193，357（2004 年）》。DOI:10.1016/j.jcp.2003.08.010
[3]
A.H. Baker 和 E.R. Jessup 和 T. Manteuffel，《SIAM J. Matrix Anal. Appl. 26，962（2005 年）》。DOI:10.1137/S0895479803422014
示例
以下函数定义了一个非线性方程系统
>>> def fun(x):
... return [x[0] + 0.5 * x[1] - 1.0,
... 0.5 * (x[1] - x[0]) ** 2]
可通过以下方式获得解决方案。
>>> from scipy import optimize
>>> sol = optimize.newton_krylov(fun, [0, 0])
>>> sol
array([0.66731771, 0.66536458])
scipy.optimize.anderson
scipy.optimize.anderson(F, xin, iter=None, alpha=None, w0=0.01, M=5, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)
使用（扩展）安德森混合查找函数的根。
雅可比矩阵由在最后M向量所张成的空间中为“最佳”解形成。因此，只需要进行 MxM 矩阵反演和 MxN 乘法。[Ey]
参数：
Ffunction(x) -> f
要找到其根的函数；应接受并返回一个类似数组的对象。
xinarray_like
解决方案的初始猜测
alphafloat, 可选
雅可比矩阵的初始猜测为（-1/alpha）。
Mfloat, 可选
要保留的先前向量数。默认为 5。
w0float, 可选
用于数值稳定性的正则化参数。与单位相比，阶数为 0.01 的良好值。
iterint, 可选
要进行的迭代次数。如果省略（默认），则进行所需数量的迭代以满足容差。
verbosebool, 可选
在每次迭代时向标准输出打印状态。
maxiterint, 可选
最大迭代次数。如果需要更多迭代以达到收敛，将引发NoConvergence。
f_tolfloat, 可选
绝对残差（在最大范数中）。如果省略，默认值为 6e-6。
f_rtolfloat, 可选
相对残差的容差。如果省略，则不使用。
x_tolfloat, 可选
绝对最小步长，由雅可比近似确定。如果步长小于此值，则优化被视为成功终止。如果省略，则不使用。
x_rtolfloat, 可选
相对最小步长。如果省略，则不使用。
tol_norm函数（向量）->标量，可选
在收敛检查中使用的范数。默认为最大范数。
line_search{None, ‘armijo’ (默认), ‘wolfe’}, 可选
用于确定由雅可比近似给定方向上的步长大小的线搜索类型。默认为“armijo”。
callback函数，可选
可选回调函数。每次迭代时调用callback(x, f)，其中x为当前解决方案，f为相应残差。
返回：
solndarray
包含最终解的类似x0的数组（相似的数组类型）。
引发：
未收敛
未找到解决方案时。
另见
root
多变量函数根查找算法的接口。特别查看method='anderson'。
参考文献
[Ey]
- Eyert，J. Comp. Phys.，124，271（1996）。
示例
以下函数定义了一个非线性方程组
>>> def fun(x):
... return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0,
... 0.5 * (x[1] - x[0])**3 + x[1]]
可以通过以下方法获得解决方案。
>>> from scipy import optimize
>>> sol = optimize.anderson(fun, [0, 0])
>>> sol
array([0.84116588, 0.15883789])
scipy.optimize.BroydenFirst
class scipy.optimize.BroydenFirst(alpha=None, reduction_method='restart', max_rank=None)
使用布罗伊登的第一个雅可比逼近找到一个函数的根。
这种方法也被称为“布罗伊登的良好方法”。
参数：
%(params_basic)s
%(broyden_params)s
%(params_extra)s
参见
多元函数根查找算法的接口。特别是查看 method='broyden1'。
注意事项
此算法实现了逆雅可比拟牛顿更新。
[H_+ = H + (dx - H df) dx^\dagger H / ( dx^\dagger H df)]
对应于布罗伊登的第一个雅可比更新
[J_+ = J + (df - J dx) dx^\dagger / dx^\dagger dx]
参考文献
[1]
B.A. van der Rotten，博士论文，"用于解决高维非线性方程组的有限记忆布罗伊登方法"。荷兰莱顿大学数学研究所（2003 年）。
web.archive.org/web/20161022015821/http://www.math.leidenuniv.nl/scripties/Rotten.pdf
例子
下列函数定义了一个非线性方程组
>>> def fun(x):
... return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0,
... 0.5 * (x[1] - x[0])**3 + x[1]]
可以通过以下方式获得解决方案。
>>> from scipy import optimize
>>> sol = optimize.broyden1(fun, [0, 0])
>>> sol
array([0.84116396, 0.15883641])
方法
| aspreconditioner | |
|---|---|
| matvec | |
| rmatvec | |
| rsolve | |
| setup | |
| solve | |
| todense | |
| update |
scipy.optimize.InverseJacobian
class scipy.optimize.InverseJacobian(jacobian)
属性：
dtype
shape
scipy.optimize.KrylovJacobian
class scipy.optimize.KrylovJacobian(rdiff=None, method='lgmres', inner_maxiter=20, inner_M=None, outer_k=10, **kw)
使用克莱洛夫近似求解函数的根，用于求解逆雅可比矩阵。
此方法适用于解决大规模问题。
参数：
%(params_basic)s
rdifffloat，可选项
在数值微分中使用的相对步长。
methodstr 或 callable，可选项
用于近似雅可比矩阵的克莱洛夫方法。可以是字符串，也可以是实现与scipy.sparse.linalg中迭代求解器相同接口的函数。如果是字符串，必须是以下之一：'lgmres'、'gmres'、'bicgstab'、'cgs'、'minres'、'tfqmr'。
默认为scipy.sparse.linalg.lgmres。
inner_maxiterint，可选项
传递给“内部”克莱洛夫求解器的参数：最大迭代次数。即使未达到指定的容差，迭代也将在 maxiter 步后停止。
inner_MLinearOperator 或 InverseJacobian
内部克莱洛夫迭代的预处理器。注意，您也可以使用逆雅可比矩阵作为（自适应）预处理器。例如，
>>> from scipy.optimize import BroydenFirst, KrylovJacobian
>>> from scipy.optimize import InverseJacobian
>>> jac = BroydenFirst()
>>> kjac = KrylovJacobian(inner_M=InverseJacobian(jac))
如果预处理器有一个名为‘update’的方法，则在每个非线性步骤后将其作为update(x, f)调用，其中x为当前点，f为当前函数值。
outer_kint，可选项
在 LGMRES 非线性迭代中保留的子空间大小。详见scipy.sparse.linalg.lgmres。
inner_kwargskwargs
“内部”克莱洛夫求解器的关键参数（使用method定义）。参数名必须以inner_前缀开头，在传递给内部方法之前将被剥离。例如详见scipy.sparse.linalg.gmres。
%(params_extra)s
参见
root
多变量函数根查找算法的接口。特别是查看method='krylov'。
scipy.sparse.linalg.gmres
scipy.sparse.linalg.lgmres
注意
此函数实现了牛顿-克莱洛夫求解器。其基本思想是使用迭代克莱洛夫方法计算雅可比矩阵的逆。这些方法仅需评估雅可比向量积，这可以通过有限差分方便地近似：
[J v \approx (f(x + \omega*v/|v|) - f(x)) / \omega]
由于使用迭代矩阵逆，这些方法可以处理大型非线性问题。
SciPy 的scipy.sparse.linalg模块提供了多种选择的 Krylov 求解器。默认选择是lgmres，这是重启 GMRES 迭代的一种变体，它在后续步骤中重复使用前几步中获得的一些信息以求解雅可比矩阵的逆。
关于 Newton-Krylov 方法的评论，例如见[1]，以及关于 LGMRES 稀疏逆方法，见[2]。
参考文献
[1]
C.T. Kelley, 用 Newton 方法解非线性方程, SIAM, pp.57-83, 2003. DOI:10.1137/1.9780898718898.ch3
[2]
D.A. Knoll 和 D.E. Keyes, J. Comp. Phys. 193, 357 (2004). DOI:10.1016/j.jcp.2003.08.010
[3]
A.H. Baker 和 E.R. Jessup 和 T. Manteuffel, SIAM J. Matrix Anal. Appl. 26, 962 (2005). DOI:10.1137/S0895479803422014
示例
以下函数定义了一组非线性方程系统。
>>> def fun(x):
... return [x[0] + 0.5 * x[1] - 1.0,
... 0.5 * (x[1] - x[0]) ** 2]
可以按照以下步骤获得解决方案。
>>> from scipy import optimize
>>> sol = optimize.newton_krylov(fun, [0, 0])
>>> sol
array([0.66731771, 0.66536458])
方法
| aspreconditioner | |
|---|---|
| matvec | |
| setup | |
| solve | |
| update |
scipy.optimize.excitingmixing
scipy.optimize.excitingmixing(F, xin, iter=None, alpha=None, alphamax=1.0, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)
使用调整后的对角雅可比近似值找到函数的根。
雅可比矩阵是对角的，并且在每次迭代中都进行调整。
警告
此算法可能对特定问题有用，但其有效性可能严重依赖于问题本身。
参数：
F 函数(x) -> f
要找到其根的函数；应接受并返回类似数组的对象。
xin 类似数组
解决方案的初始猜测
alpha 浮点数，可选
初始雅可比近似值为 (-1/alpha)。
alphamax 浮点数，可选
对角雅可比矩阵的条目保持在范围 [alpha, alphamax] 内。
iter 整数，可选
要进行的迭代次数。如果省略（默认），则进行足够多的迭代以满足容差。
verbose 布尔值，可选
在每次迭代中将状态打印到标准输出。
maxiter 整数，可选
最大迭代次数。如果需要更多迭代以满足收敛性，则会引发 NoConvergence。
f_tol 浮点数，可选
绝对容差（在最大范数中）用于残差。如果省略，默认值为 6e-6。
f_rtol 浮点数，可选
相对残差的容差。如果省略，则不使用。
x_tol 浮点数，可选
绝对最小步长，根据雅可比近似值确定。如果步长小于此值，则优化成功终止。如果省略，则不使用。
x_rtol 浮点数，可选
相对最小步长。如果省略，则不使用。
tol_norm 函数（向量）-> 标量，可选
用于收敛检查的范数。默认为最大范数。
line_search {None, ‘armijo’（默认），‘wolfe’}，可选
要使用的线搜索类型，以确定在雅可比近似值给定方向中采取的步长。默认为 ‘armijo’。
callback 函数，可选
可选的回调函数。每次迭代时调用 callback(x, f)，其中 x 是当前解，f 是相应的残差。
返回：
sol ndarray
包含最终解的类似x0的数组（相同数组类型）。
Raises:
NoConvergence
未找到解时。
参见
多元函数根查找算法的接口。特别查看 method='excitingmixing'。
scipy.optimize.linearmixing
scipy.optimize.linearmixing(F, xin, iter=None, alpha=None, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)
使用标量雅可比近似查找函数的根。
警告
此算法可能对特定问题有用，但其是否有效可能严重依赖于问题的性质。
参数：
F函数(x) -> f
要查找其根的函数；应接受并返回类似数组的对象。
xin类数组对象
解的初始猜测
alpha浮点数，可选
雅可比近似为(-1/alpha)。
iter整数，可选
要进行的迭代次数。如果省略（默认），则进行足够的迭代以满足公差要求。
verbose布尔值，可选
在每次迭代时将状态打印到标准输出。
maxiter整数，可选
最大迭代次数。如果需要更多迭代以满足收敛性，则引发NoConvergence。
f_tol浮点数，可选
残差的最大范数的绝对容差。如果省略，默认为 6e-6。
f_rtol浮点数，可选
残差的相对容差。如果省略，则不使用。
x_tol浮点数，可选
绝对最小步长，由雅可比近似确定。如果步长小于此值，则优化作为成功终止。如果省略，则不使用。
x_rtol浮点数，可选
相对最小步长。如果省略，则不使用。
tol_norm函数（向量）-> 标量，可选
收敛检查中使用的范数。默认为最大范数。
line_search{None, 'armijo'（默认）, 'wolfe'}，可选
用于确定由雅可比近似给定方向上的步长大小的线搜索类型。默认为'armijo'。
callback函数，可选
可选回调函数。每次迭代调用为callback(x, f)，其中x为当前解，f为相应残差。
返回：
solndarray
一个包含最终解的数组（与x0相似的数组类型）。
引发：
NoConvergence
当未找到解决方案时。
另见
多元函数的根查找算法接口。特别查看method='linearmixing'。
