SciPy-1-12-中文文档-十一-
SciPy 1.12 中文文档（十一）
scipy.optimize.linprog_verbose_callback
scipy.optimize.linprog_verbose_callback(res)
A sample callback function demonstrating the linprog callback interface. This callback produces detailed output to sys.stdout before each iteration and after the final iteration of the simplex algorithm.
参数：
res一个包含以下字段的scipy.optimize.OptimizeResult：
x1-D array
优化线性规划问题的独立变量向量。
funfloat
目标函数的值。
successbool
如果算法成功找到最优解，则为 True。
slack1-D array
松弛变量的值。每个松弛变量对应一个不等式约束。如果松弛为零，则相应约束活跃。
con1-D array
等式约束的残差（通常为零），即 b - A_eq @ x
phaseint
正在执行的优化阶段。在第 1 阶段，寻找基本可行解，并且 T 有一行额外表示备用目标函数。
statusint
优化的退出状态的整数表示：
0 : Optimization terminated successfully
1 : Iteration limit reached
2 : Problem appears to be infeasible
3 : Problem appears to be unbounded
4 : Serious numerical difficulties encountered
nitint
执行的迭代次数。
messagestr
优化退出状态的字符串描述。
scipy.optimize.linear_sum_assignment
scipy.optimize.linear_sum_assignment()
解决线性和分配问题。
参数：
cost_matrix数组
二分图的成本矩阵。
maximize布尔值（默认为 False）
计算最大权重匹配是否为真。
返回：
row_ind, col_ind数组
一个包含行索引和相应列索引的数组，给出最优分配。可以计算分配的成本为cost_matrix[row_ind, col_ind].sum()。行索引将被排序；在方形成本矩阵的情况下，它们将等于numpy.arange(cost_matrix.shape[0])。
另见
scipy.sparse.csgraph.min_weight_full_bipartite_matching
用于稀疏输入
注意
线性和分配问题[1]也称为双分图中的最小权重匹配。问题实例由矩阵 C 描述，其中每个 C[i,j]是第一部分集合的顶点 i（一个“工作者”）和第二部分集合的顶点 j（一个“工作”）匹配的成本。目标是找到最小成本的工作者与工作的完全分配。
形式上，设 X 是一个布尔矩阵，其中(X[i,j] = 1)当且仅当第 i 行分配给第 j 列。然后，最优分配的成本为
[\min \sum_i \sum_j C_{i,j} X_{i,j}]
在矩阵 X 是方形的情况下，每行被分配给恰好一个列，每列被分配给恰好一个行。
此函数还可以解决经典分配问题的一般化，其中成本矩阵是矩形的。如果它的行数多于列数，则不需要将每行都分配给列，反之亦然。
此实现是一个修改的 Jonker-Volgenant 算法，没有初始化，描述在参考文献中。[2]。
0.17.0 版中的新功能。
参考
[1]
en.wikipedia.org/wiki/Assignment_problem
[2]
DF Crouse. On implementing 2D rectangular assignment algorithms. IEEE Transactions on Aerospace and Electronic Systems, 52(4):1679-1696, August 2016, DOI:10.1109/TAES.2016.140952
示例
>>> import numpy as np
>>> cost = np.array([[4, 1, 3], [2, 0, 5], [3, 2, 2]])
>>> from scipy.optimize import linear_sum_assignment
>>> row_ind, col_ind = linear_sum_assignment(cost)
>>> col_ind
array([1, 0, 2])
>>> cost[row_ind, col_ind].sum()
5
scipy.optimize.quadratic_assignment
scipy.optimize.quadratic_assignment(A, B, method='faq', options=None)
近似解决二次分配问题和图匹配问题。
二次分配解决以下形式的问题：
[\begin{split}\min_P & \ {\ \text{trace}(A^T P B P^T)}\ \mbox{s.t. } & {P \ \epsilon \ \mathcal{P}}\\end{split}]
其中(\mathcal{P})是所有排列矩阵的集合，(A)和(B)是方阵。
图匹配试图最大化相同的目标函数。此算法可以看作是找到两个图的节点对齐，使得诱导边不一致的数量最小，或者在加权图的情况下，边权重差的平方和最小。
注意，二次分配问题是 NP-难的。这里给出的结果是近似值，并不保证最优。
参数：
A2-D 数组，方阵
目标函数中的方阵(A)。
B2-D 数组，方阵
目标函数中的方阵(B)。
methodstr in {‘faq’, ‘2opt’}（默认：‘faq’）
解决问题的算法。‘faq’（默认）和‘2opt’可用。
optionsdict，可选
求解器选项的字典。所有求解器都支持以下内容：
maximizebool（默认：False）
如果为True，则最大化目标函数。
partial_match2-D 整数数组，可选（默认：None）
修复匹配的部分，也称为“种子”[2]。
partial_match的每一行指定了匹配节点对：A 的节点partial_match[i, 0]与B的节点partial_match[i, 1]匹配。数组的形状为(m, 2)，其中m不大于节点数\(n\)。
rng{None, int, numpy.random.Generator,
如果seed为 None（或np.random），则使用numpy.random.RandomState单例。如果seed为整数，则使用一个带有seed种子的新RandomState实例。如果seed已经是Generator或RandomState实例，则使用该实例。
有关特定方法的选项，请参阅show_options('quadratic_assignment')。
返回：
resOptimizeResult
OptimizeResult 包含以下字段。
col_ind1-D 数组
对应于B节点的最佳排列的列索引。
funfloat
解决方案的目标值。
nitint
在优化过程中执行的迭代次数。
注释
默认方法‘faq’ 使用快速近似 QAP 算法 [1]; 它通常提供了速度和精度的最佳组合。方法‘2opt’ 可能计算成本高，但可能是一个有用的替代方案，或者用来优化另一种方法返回的解。
参考文献
[1]
J.T. Vogelstein, J.M. Conroy, V. Lyzinski, L.J. Podrazik, S.G. Kratzer, E.T. Harley, D.E. Fishkind, R.J. Vogelstein, 和 C.E. Priebe，“用于图匹配的快速近似二次规划”，PLOS one，vol. 10, no. 4, p. e0121002, 2015, DOI:10.1371/journal.pone.0121002
[2]
D. Fishkind, S. Adali, H. Patsolic, L. Meng, D. Singh, V. Lyzinski, C. Priebe，“种子图匹配”，Pattern Recognit. 87 (2019): 203-215, DOI:10.1016/j.patcog.2018.09.014
[3]
“2-opt”，维基百科。en.wikipedia.org/wiki/2-opt
示例
>>> import numpy as np
>>> from scipy.optimize import quadratic_assignment
>>> A = np.array([[0, 80, 150, 170], [80, 0, 130, 100],
... [150, 130, 0, 120], [170, 100, 120, 0]])
>>> B = np.array([[0, 5, 2, 7], [0, 0, 3, 8],
... [0, 0, 0, 3], [0, 0, 0, 0]])
>>> res = quadratic_assignment(A, B)
>>> print(res)
fun: 3260
col_ind: [0 3 2 1]
nit: 9
查看col_ind 和 fun 之间的关系，使用col_ind 形成找到的最佳排列矩阵，然后评估目标函数 (f(P) = trace(A^T P B P^T )).
>>> perm = res['col_ind']
>>> P = np.eye(len(A), dtype=int)[perm]
>>> fun = np.trace(A.T @ P @ B @ P.T)
>>> print(fun)
3260
或者，为了避免显式构造排列矩阵，直接对距离矩阵的行和列进行排列。
>>> fun = np.trace(A.T @ B[perm][:, perm])
>>> print(fun)
3260
尽管一般情况下不能保证，quadratic_assignment 恰好找到了全局最优解。
>>> from itertools import permutations
>>> perm_opt, fun_opt = None, np.inf
>>> for perm in permutations([0, 1, 2, 3]):
... perm = np.array(perm)
... fun = np.trace(A.T @ B[perm][:, perm])
... if fun < fun_opt:
... fun_opt, perm_opt = fun, perm
>>> print(np.array_equal(perm_opt, res['col_ind']))
True
这是一个例子，其中默认方法‘faq’ 找不到全局最优解。
>>> A = np.array([[0, 5, 8, 6], [5, 0, 5, 1],
... [8, 5, 0, 2], [6, 1, 2, 0]])
>>> B = np.array([[0, 1, 8, 4], [1, 0, 5, 2],
... [8, 5, 0, 5], [4, 2, 5, 0]])
>>> res = quadratic_assignment(A, B)
>>> print(res)
fun: 178
col_ind: [1 0 3 2]
nit: 13
如果精度很重要，请考虑使用‘2opt’ 来优化解决方案。
>>> guess = np.array([np.arange(len(A)), res.col_ind]).T
>>> res = quadratic_assignment(A, B, method="2opt",
... options = {'partial_guess': guess})
>>> print(res)
fun: 176
col_ind: [1 2 3 0]
nit: 17
scipy.optimize.approx_fprime
scipy.optimize.approx_fprime(xk, f, epsilon=1.4901161193847656e-08, *args)
标量或向量值函数的有限差分近似的导数。
如果函数从(Rn)映射到(Rm)，其导数形成一个称为雅可比矩阵的 m-by-n 矩阵，其中元素((i, j))是f[i]对xk[j]的偏导数。
参数：
xkarray_like
要确定f的梯度的坐标向量。
fcallable
要估计其导数的函数。具有签名f(xk, *args)的函数，其中xk是形状为 1-D 数组的参数，args是一个元组，包含完全指定函数所需的任何其他固定参数。传递给该函数的参数xk是形状为(n,)的 ndarray（即使 n=1 也不是标量）。它必须返回形状为(m,)的类似 1-D 数组或标量。
从版本 1.9.0 开始更改：f现在能够返回类似 1-D 数组的值，其中估计了((m, n))雅可比矩阵。
epsilon，可选
用于确定函数梯度的xk的增量。如果是标量，则对所有偏导数使用相同的有限差分增量。如果是数组，则应该包含xk的每个元素的一个值。默认为sqrt(np.finfo(float).eps)，大约是 1.49e-08。
*argsargs，可选
传递给f的其他参数。
返回：
jacndarray
f对xk的偏导数。
另请参见
check_grad
检查梯度函数相对于 approx_fprime 的正确性。
注意
函数梯度由前向有限差分公式确定：
f(xk[i] + epsilon[i]) - f(xk[i])
f'[i] = ---------------------------------
epsilon[i]
示例
>>> import numpy as np
>>> from scipy import optimize
>>> def func(x, c0, c1):
... "Coordinate vector `x` should be an array of size two."
... return c0 * x[0]**2 + c1*x[1]**2
>>> x = np.ones(2)
>>> c0, c1 = (1, 200)
>>> eps = np.sqrt(np.finfo(float).eps)
>>> optimize.approx_fprime(x, func, [eps, np.sqrt(200) * eps], c0, c1)
array([ 2\. , 400.00004198])
scipy.optimize.check_grad
scipy.optimize.check_grad(func, grad, x0, *args, epsilon=1.4901161193847656e-08, direction='all', seed=None)
通过将其与梯度的（前向）有限差逼近比较来检查梯度函数的正确性。
参数：
funccallable func(x0, *args)
要检查其导数的函数。
gradcallable grad(x0, *args)
func的雅可比矩阵。
x0ndarray
检查 grad 是否与使用 func 的前向差分逼近的梯度一致的点。
args*args, optional
传递给 func 和 grad 的额外参数。
epsilonfloat, optional
用于有限差逼近的步长大小。默认为 sqrt(np.finfo(float).eps)，约为 1.49e-08。
directionstr, optional
如果设为 'random'，则使用沿随机向量的梯度来检查 grad 是否与使用 func 的前向差分逼近一致。默认情况下为 'all'，此时考虑所有的单热方向向量以检查 grad。如果 func 是矢量值函数，则只能使用 'all'。
seed{None, int, numpy.random.Generator, numpy.random.RandomState}, optional
如果 seed 为 None（或 np.random），则使用numpy.random.RandomState 单例。如果 seed 是整数，则使用新的 RandomState 实例，并以 seed 为种子。如果 seed 已经是 Generator 或 RandomState 实例，则使用该实例。指定 seed 可以重现此函数的返回值。使用此种子生成的随机数影响计算梯度的随机向量。注意当 direction 参数设置为 ‘random’ 时才使用 seed。
返回：
errfloat
两个向量之间差的平方和的平方根（即 2-范数），即 grad(x0, *args) 和在点 x0 使用 func 的有限差逼近 grad 的差异。
另请参见
approx_fprime
示例
>>> import numpy as np
>>> def func(x):
... return x[0]**2 - 0.5 * x[1]**3
>>> def grad(x):
... return [2 * x[0], -1.5 * x[1]**2]
>>> from scipy.optimize import check_grad
>>> check_grad(func, grad, [1.5, -1.5])
2.9802322387695312e-08 # may vary
>>> rng = np.random.default_rng()
>>> check_grad(func, grad, [1.5, -1.5],
... direction='random', seed=rng)
2.9802322387695312e-08
scipy.optimize.bracket
scipy.optimize.bracket(func, xa=0.0, xb=1.0, args=(), grow_limit=110.0, maxiter=1000)
确定函数的最小值。
给定一个函数和不同的初始点，沿着向下的方向（由初始点定义）搜索并返回三个括号内的函数最小值点。
参数：
funccallable f(x,*args)
要最小化的目标函数。
xa, xbfloat, optional
初始点。默认xa为 0.0，xb为 1.0。局部最小值不一定包含在此区间内。
argstuple, optional
附加参数（如果存在），传递给func。
grow_limitfloat, optional
最大生长限制。默认为 110.0
maxiterint, optional
要执行的最大迭代次数。默认为 1000。
返回：
xa, xb, xcfloat
括号的最终点。
fa, fb, fcfloat
目标函数在括号点处的值。
funcallsint
执行的函数评估数量。
引发：
BracketError
如果在算法终止前未找到有效的括号。请参阅有效括号的条件说明。
注释
算法尝试找到三个严格排序的点（即 (x_a < x_b < x_c) 或 (x_c < x_b < x_a)），满足 (f(x_b) ≤ f(x_a)) 和 (f(x_b) ≤ f(x_c)) 的条件之一必须严格满足，所有 (x_i) 必须是有限的。
示例
此函数可以找到函数的向下凸区域：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.optimize import bracket
>>> def f(x):
... return 10*x**2 + 3*x + 5
>>> x = np.linspace(-2, 2)
>>> y = f(x)
>>> init_xa, init_xb = 0.1, 1
>>> xa, xb, xc, fa, fb, fc, funcalls = bracket(f, xa=init_xa, xb=init_xb)
>>> plt.axvline(x=init_xa, color="k", linestyle="--")
>>> plt.axvline(x=init_xb, color="k", linestyle="--")
>>> plt.plot(x, y, "-k")
>>> plt.plot(xa, fa, "bx")
>>> plt.plot(xb, fb, "rx")
>>> plt.plot(xc, fc, "bx")
>>> plt.show()
请注意，初始点都在最小值的右侧，并且第三个点是在“向下”的方向找到的：函数看起来在减少的方向（向左）。最终点是严格排序的，中间点的函数值小于端点的函数值；因此，最小值必须位于括号内。
scipy.optimize.line_search
scipy.optimize.line_search(f, myfprime, xk, pk, gfk=None, old_fval=None, old_old_fval=None, args=(), c1=0.0001, c2=0.9, amax=None, extra_condition=None, maxiter=10)
找到满足强 Wolfe 条件的 alpha。
参数：
fcallable f(x,*args)
目标函数。
myfprimecallable f’(x,*args)
目标函数梯度。
xkndarray
起始点。
pkndarray
搜索方向。搜索方向必须是算法收敛的下降方向。
gfkndarray，可选
x=xk 处的梯度值（xk 为当前参数估计）。如果省略，则将重新计算。
old_fvalfloat，可选
x=xk 处的函数值。如果省略，则将重新计算。
old_old_fvalfloat，可选
x=xk 之前点的函数值。
argstuple，可选
传递给目标函数的额外参数。
c1float，可选
Armijo 条件规则的参数。
c2float，可选
曲率条件规则的参数。
amaxfloat，可选
最大步长
extra_conditioncallable，可选
形如 extra_condition(alpha, x, f, g) 的可调用对象，返回布尔值。参数是建议的步长 alpha 及其相应的 x、f 和 g 值。只有在满足强 Wolfe 条件的迭代中才接受 alpha 的值。如果步长的可调用对象返回假，则算法将继续进行新的迭代。只有在满足强 Wolfe 条件的迭代中才会调用该可调用对象。
maxiterint，可选
执行的最大迭代次数。
返回：
alphafloat 或 None
Alpha 使得 x_new = x0 + alpha * pk，如果线搜索算法未收敛，则为 None。
fcint
执行的函数评估次数。
gcint
执行的梯度评估次数。
new_fvalfloat 或 None
新函数值 f(x_new)=f(x0+alpha*pk)，如果线搜索算法未收敛，则为 None。
old_fvalfloat
旧函数值 f(x0)。
new_slopefloat 或 None
在新值处沿搜索方向的局部斜率 <myfprime(x_new), pk>，如果线搜索算法未收敛，则为 None。
注意事项
使用线搜索算法来强制实施强 Wolfe 条件。参见 Wright 和 Nocedal，《Numerical Optimization》，1999 年，第 59-61 页。
搜索方向 pk 必须是下降方向（例如 -myfprime(xk)）以找到满足强 Wolfe 条件的步长。如果搜索方向不是下降方向（例如 myfprime(xk)），则 alpha、new_fval 和 new_slope 将为 None。
示例
>>> import numpy as np
>>> from scipy.optimize import line_search
定义了一个目标函数及其梯度。
>>> def obj_func(x):
... return (x[0])**2+(x[1])**2
>>> def obj_grad(x):
... return [2*x[0], 2*x[1]]
我们可以找到满足强 Wolfe 条件的 alpha。
>>> start_point = np.array([1.8, 1.7])
>>> search_gradient = np.array([-1.0, -1.0])
>>> line_search(obj_func, obj_grad, start_point, search_gradient)
(1.0, 2, 1, 1.1300000000000001, 6.13, [1.6, 1.4])
scipy.optimize.LbfgsInvHessProduct
class scipy.optimize.LbfgsInvHessProduct(*args, **kwargs)
L-BFGS 近似逆海森线性操作器。
该操作器使用 L-BFGS 有限存储逆海森近似，在优化过程中累积的目标函数海森逆的向量与向量的乘积。
本类对象实现了scipy.sparse.linalg.LinearOperator接口。
参数：
skarray_like, shape=(n_corr, n)
n_corr最近的解向量更新数组（见[1]）。
ykarray_like, shape=(n_corr, n)
n_corr最近的梯度更新数组（见[1]）。
参考文献
[1]
Nocedal, Jorge. “使用有限存储更新拟牛顿矩阵。” 计算数学 35.151 (1980): 773-782.
属性：
H
共轭转置。
T
转置此线性操作器。
方法：
__call__(x) |
作为函数调用自身。 |
|---|---|
adjoint() |
共轭转置。 |
dot(x) |
矩阵-矩阵或矩阵-向量乘法。 |
matmat(X) |
矩阵-矩阵乘法。 |
matvec(x) |
矩阵-向量乘法。 |
rmatmat(X) |
共轭矩阵-矩阵乘法。 |
rmatvec(x) |
共轭矩阵-向量乘法。 |
todense() |
返回此操作器的密集数组表示。 |
transpose() |
转置这个线性操作符。 |
| mul |
scipy.optimize.HessianUpdateStrategy
class scipy.optimize.HessianUpdateStrategy
实现 Hessian 更新策略的接口。
许多优化方法使用 Hessian（或逆 Hessian）的近似值，如拟牛顿方法 BFGS、SR1、L-BFGS。然而，其中一些近似方法实际上不需要存储整个矩阵，或者可以以非常高效的方式计算内部矩阵与给定向量的乘积。这个类作为优化算法和拟牛顿更新策略之间的抽象接口，允许以尽可能高效的方式存储和更新内部矩阵的实现自由。不同的初始化和更新过程选择会导致不同的拟牛顿策略。
派生类应实现四种方法：initialize，update，dot 和 get_matrix。
注意事项
实现此接口的任何类的实例，都可以被方法 minimize 接受，并由兼容的求解器使用，以近似优化算法使用的 Hessian（或逆 Hessian）。
方法
dot(p) |
计算内部矩阵与给定向量的乘积。 |
|---|---|
get_matrix() |
返回当前内部矩阵。 |
initialize(n, approx_type) |
初始化内部矩阵。 |
update(delta_x, delta_grad) |
更新内部矩阵。 |
scipy.optimize.rosen
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.optimize.rosen.html#scipy.optimize.rosen
scipy.optimize.rosen(x)
Rosenbrock 函数。
计算的函数是：
sum(100.0*(x[1:] - x[:-1]**2.0)**2.0 + (1 - x[:-1])**2.0)
参数：
xarray_like
要计算 Rosenbrock 函数的点的 1-D 数组。
返回：
ffloat
Rosenbrock 函数的值。
另请参见
rosen_der, rosen_hess, rosen_hess_prod
示例
>>> import numpy as np
>>> from scipy.optimize import rosen
>>> X = 0.1 * np.arange(10)
>>> rosen(X)
76.56
对于高维输入，rosen 进行了广播。在下面的示例中，我们使用这一点来绘制二维景观。请注意，rosen_hess 不会以这种方式进行广播。
>>> import matplotlib.pyplot as plt
>>> from mpl_toolkits.mplot3d import Axes3D
>>> x = np.linspace(-1, 1, 50)
>>> X, Y = np.meshgrid(x, x)
>>> ax = plt.subplot(111, projection='3d')
>>> ax.plot_surface(X, Y, rosen([X, Y]))
>>> plt.show()
scipy.optimize.rosen_der
scipy.optimize.rosen_der(x)
Rosenbrock 函数的导数（即梯度）。
参数：
xarray_like
1-D 数组，用于计算导数的点。
返回值：
rosen_der(N,) ndarray
Rosenbrock 函数在 x 处的梯度。
另请参见：
rosen, rosen_hess, rosen_hess_prod
示例：
>>> import numpy as np
>>> from scipy.optimize import rosen_der
>>> X = 0.1 * np.arange(9)
>>> rosen_der(X)
array([ -2\. , 10.6, 15.6, 13.4, 6.4, -3\. , -12.4, -19.4, 62\. ])
scipy.optimize.rosen_hess
scipy.optimize.rosen_hess(x)
Rosenbrock 函数的黑塞矩阵。
参数：
xarray_like
要计算黑塞矩阵的点的一维数组。
返回值：
rosen_hessndarray
Rosenbrock 函数在 x 处的黑塞矩阵。
参见
rosen, rosen_der, rosen_hess_prod
示例
>>> import numpy as np
>>> from scipy.optimize import rosen_hess
>>> X = 0.1 * np.arange(4)
>>> rosen_hess(X)
array([[-38., 0., 0., 0.],
[ 0., 134., -40., 0.],
[ 0., -40., 130., -80.],
[ 0., 0., -80., 200.]])
scipy.optimize.rosen_hess_prod
scipy.optimize.rosen_hess_prod(x, p)
Rosenbrock 函数的 Hessian 矩阵与向量的乘积。
参数：
x 数组样式
1-D 点数组，其中将计算 Hessian 矩阵。
p 数组样式
1-D 数组，将与 Hessian 矩阵相乘的向量。
返回：
rosen_hess_prod ndarray
x 处的 Rosenbrock 函数的 Hessian 矩阵与向量 p 的乘积。
另请参阅
rosen, rosen_der, rosen_hess
示例
>>> import numpy as np
>>> from scipy.optimize import rosen_hess_prod
>>> X = 0.1 * np.arange(9)
>>> p = 0.5 * np.arange(9)
>>> rosen_hess_prod(X, p)
array([ -0., 27., -10., -95., -192., -265., -278., -195., -180.])
scipy.optimize.fmin
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.optimize.fmin.html#scipy.optimize.fmin
scipy.optimize.fmin(func, x0, args=(), xtol=0.0001, ftol=0.0001, maxiter=None, maxfun=None, full_output=0, disp=1, retall=0, callback=None, initial_simplex=None)
使用下山单纯形算法最小化函数。
该算法仅使用函数值，不使用导数或二阶导数。
参数：
funccallable func(x,*args)
要最小化的目标函数。
x0ndarray
初始猜测。
argstuple，可选
传递给 func 的额外参数，即f(x,*args)。
xtolfloat，可选
在迭代之间可接受的 xopt 中的绝对误差，以收敛为目标。
ftolnumber，可选
在迭代之间 func(xopt)的绝对误差，以收敛为目标。
maxiterint，可选
执行的最大迭代次数。
maxfunnumber，可选
最大函数评估次数。
full_outputbool，可选
如果需要 fopt 和 warnflag 输出，则设置为 True。
dispbool，可选
设置为 True 以打印收敛消息。
retallbool, 可选
设置为 True 以返回每次迭代的解列表。
callbackcallable，可选
在每次迭代后调用，作为 callback(xk)，其中 xk 为当前的参数向量。
initial_simplexarray_like，形状为(N + 1, N)，可选
初始单纯形。如果提供，则覆盖x0。initial_simplex[j,:]应包含单纯形中第 j 个顶点的 N+1 个顶点的坐标，其中 N 是维度。
返回：
xoptndarray
最小化函数的参数。
foptfloat
函数在最小值处的值：fopt = func(xopt)。
iterint
执行的迭代次数。
funcallsint
执行的函数调用次数。
warnflagint
1：执行的最大函数评估次数。2：达到的最大迭代次数。
allvecslist
每次迭代的解。
另见
多元函数最小化算法接口。特别参见‘Nelder-Mead’ 方法。
注意
使用 Nelder-Mead 单纯形算法寻找一个或多个变量函数的最小值。
该算法在应用中有着悠久的成功历史。但通常比使用一阶或二阶导数信息的算法慢。在实践中，它在高维问题中表现不佳，并且不适用于最小化复杂函数。此外，目前没有完整的理论描述算法何时会成功收敛到最小值，或者如果成功收敛，收敛速度如何。必须同时满足 ftol 和 xtol 标准以实现收敛。
参考文献
[1]
Nelder, J.A. 和 Mead, R. (1965), “A simplex method for function minimization”, The Computer Journal, 7, pp. 308-313
[2]
Wright, M.H. (1996), “Direct Search Methods: Once Scorned, Now Respectable”, in Numerical Analysis 1995, Proceedings of the 1995 Dundee Biennial Conference in Numerical Analysis, D.F. Griffiths and G.A. Watson (Eds.), Addison Wesley Longman, Harlow, UK, pp. 191-208.
示例
>>> def f(x):
... return x**2
>>> from scipy import optimize
>>> minimum = optimize.fmin(f, 1)
Optimization terminated successfully.
Current function value: 0.000000
Iterations: 17
Function evaluations: 34
>>> minimum[0]
-8.8817841970012523e-16
scipy.optimize.fmin_powell
scipy.optimize.fmin_powell(func, x0, args=(), xtol=0.0001, ftol=0.0001, maxiter=None, maxfun=None, full_output=0, disp=1, retall=0, callback=None, direc=None)
使用修改后的 Powell 方法最小化函数。
此方法仅使用函数值，不使用导数。
参数：
func可调用函数 f(x,*args)
要最小化的目标函数。
x0数组
初始猜测。
args元组，可选
传递给 func 的额外参数。
xtol浮点数，可选
线搜索错误容忍度。
ftol浮点数，可选
func(xopt) 的相对误差，用于收敛。
maxiter整数，可选
执行的最大迭代次数。
maxfun整数，可选
要执行的最大函数评估次数。
full_output布尔值，可选
如果为 True，则返回 fopt、xi、direc、iter、funcalls 和 warnflag。
disp布尔值，可选
如果为 True，则打印收敛信息。
retall布尔值，可选
如果为 True，则返回每次迭代的解列表。
callback可调用，可选
可选的用户提供的函数，在每次迭代后调用。调用方式为 callback(xk)，其中 xk 是当前的参数向量。
direc数组，可选
初始拟合步骤和参数顺序设置为 (N, N) 数组，其中 N 是 x0 中拟合参数的数量。默认步长为 1.0，同时拟合所有参数 (np.eye((N, N)))。若要防止初始考虑步骤中的值或更改初始步长，请将其设置为 0 或所需步长在第 M 块的第 J 位置，其中 J 是 x0 中的位置，M 是所需的评估步骤，步骤将按索引顺序进行评估。随着最小化的进行，步长和顺序将自由变化。
返回：
xopt数组
最小化 func 的参数。
fopt数字
在最小值处函数的值：fopt = func(xopt)。
direc数组
当前的方向设置。
iter整数
迭代次数。
funcalls整数
执行的函数调用次数。
warnflag整数
整数警告标志：
1：最大函数评估次数。2：最大迭代次数。3：遇到 NaN 结果。4：结果超出提供的边界。
allvecs列表
每次迭代的解列表。
另请参见
用于多元函数的无约束最小化算法的接口。特别查看‘Powell’方法。
注意事项
使用修改后的 Powell 方法找到 N 个变量的函数的最小值。Powell 方法是一种共轭方向方法。
该算法有两个循环。外部循环仅在内部循环上迭代。内部循环在方向集合中每个当前方向上进行最小化。在内部循环结束时，如果满足某些条件，则舍弃给出最大减少的方向，并用当前估计的 x 与内部循环开始时的估计 x 之间的差异替换。
替换最大增量方向的技术条件是检查
-
从该迭代中最大增量方向上无法再获得进一步的增益。
-
最大增量方向占内部循环迭代中函数值减少的大部分。
参考文献
Powell M.J.D. (1964) 一种在不计算导数的情况下找到多变量函数最小值的高效方法，计算机学报，7 (2):155-162。
Press W., Teukolsky S.A., Vetterling W.T., and Flannery B.P.: 数值计算方法（任何版本），剑桥大学出版社
示例
>>> def f(x):
... return x**2
>>> from scipy import optimize
>>> minimum = optimize.fmin_powell(f, -1)
Optimization terminated successfully.
Current function value: 0.000000
Iterations: 2
Function evaluations: 16
>>> minimum
array(0.0)
scipy.optimize.fmin_cg
scipy.optimize.fmin_cg(f, x0, fprime=None, args=(), gtol=1e-05, norm=inf, epsilon=1.4901161193847656e-08, maxiter=None, full_output=0, disp=1, retall=0, callback=None, c1=0.0001, c2=0.4)
使用非线性共轭梯度算法最小化函数。
参数：
fcallable，f(x, *args)
要最小化的目标函数。这里x必须是要在搜索最小值时更改的变量的 1-D 数组，args是f的其他（固定）参数。
x0ndarray
xopt的用户提供的初始估计值，即x的最优值。必须是值的 1-D 数组。
fprimecallable，fprime(x, *args)，可选
返回f在x处的梯度的函数。这里x和args如上所述为f。返回的值必须是 1-D 数组。默认为 None，此时数值上近似梯度（见下面的epsilon）。
argstuple，可选
传递给f和fprime的参数值。每当需要额外的固定参数完全指定f和fprime函数时，必须提供。
gtolfloat，可选
当梯度的范数小于gtol时停止。
normfloat，可选
用于梯度范数的顺序（-np.inf是最小值，np.inf是最大值）。
epsilonfloat 或 ndarray，可选
当fprime被数值近似时使用的步长。可以是标量或 1-D 数组。默认为sqrt(eps)，其中 eps 是浮点数机器精度。通常sqrt(eps)约为 1.5e-8。
maxiterint，可选
要执行的最大迭代次数。默认为200 * len(x0)。
full_outputbool，可选
如果为 True，则除了xopt之外，还返回fopt、func_calls、grad_calls和warnflag。有关可选返回值的详细信息，请参见下面的 Returns 部分。
dispbool，可选
如果为 True，则返回一个收敛消息，然后是xopt。
retallbool，可选
如果为 True，则将每次迭代的结果添加到返回值中。
callbackcallable，可选
一个可选的用户提供的函数，在每次迭代后调用。以callback(xk)的形式调用，其中xk是x0的当前值。
c1float，默认值：1e-4
Armijo 条件规则的参数。
c2float，默认值：0.4
曲率条件规则的参数。
返回：
xoptndarray
最小化 f 的参数，即f(xopt) == fopt。
foptfloat，可选
找到的最小值，f(xopt)。仅当full_output为 True 时返回。
func_callsint，可选
进行的函数调用次数。仅当full_output为 True 时返回。
grad_callsint，可选
进行的梯度调用次数。仅当full_output为 True 时返回。
warnflagint，可选
警告状态的整数值，仅当full_output为 True 时返回。
0：成功。
1：超过了最大迭代次数。
2：梯度和/或函数调用未更改。可能表示
即精度丢失，即例程未收敛。
3：遇到 NaN 结果。
allvecs 是一个 ndarray 的列表，可选
数组列表，包含每次迭代的结果。仅在 retall 为 True 时返回。
另请参见
minimize
scipy.optimize 的所有算法，无论是多变量函数的无约束还是有约束最小化，都有一个共同的接口。它提供了一种通过指定 method='CG' 来调用 fmin_cg 的替代方式。
注意事项
此共轭梯度算法基于 Polak 和 Ribiere 的算法 [1]。
共轭梯度方法在以下情况下表现更好：
-
f 有一个唯一的全局最小点，并且没有局部最小值或其他静止点，
-
f 至少在局部范围内可以被变量的二次函数合理逼近，
-
f 是连续的，并且具有连续的梯度，
-
fprime 不应过大，例如其范数应小于 1000，
-
初始猜测 x0 应该足够接近 f 的全局最小点 xopt。
参数 c1 和 c2 必须满足 0 < c1 < c2 < 1。
参考文献
[1]
Wright & Nocedal，《数值优化》，1999 年，第 120-122 页。
示例
示例 1：寻找给定参数值和初始猜测 (u, v) = (0, 0) 下表达式 a*u**2 + b*u*v + c*v**2 + d*u + e*v + f 的最小值。
>>> import numpy as np
>>> args = (2, 3, 7, 8, 9, 10) # parameter values
>>> def f(x, *args):
... u, v = x
... a, b, c, d, e, f = args
... return a*u**2 + b*u*v + c*v**2 + d*u + e*v + f
>>> def gradf(x, *args):
... u, v = x
... a, b, c, d, e, f = args
... gu = 2*a*u + b*v + d # u-component of the gradient
... gv = b*u + 2*c*v + e # v-component of the gradient
... return np.asarray((gu, gv))
>>> x0 = np.asarray((0, 0)) # Initial guess.
>>> from scipy import optimize
>>> res1 = optimize.fmin_cg(f, x0, fprime=gradf, args=args)
Optimization terminated successfully.
Current function value: 1.617021
Iterations: 4
Function evaluations: 8
Gradient evaluations: 8
>>> res1
array([-1.80851064, -0.25531915])
示例 2：使用 minimize 函数解决相同问题。（myopts 字典显示所有可用选项，实际应用中通常只需要非默认值。返回值将是一个字典。）
>>> opts = {'maxiter' : None, # default value.
... 'disp' : True, # non-default value.
... 'gtol' : 1e-5, # default value.
... 'norm' : np.inf, # default value.
... 'eps' : 1.4901161193847656e-08} # default value.
>>> res2 = optimize.minimize(f, x0, jac=gradf, args=args,
... method='CG', options=opts)
Optimization terminated successfully.
Current function value: 1.617021
Iterations: 4
Function evaluations: 8
Gradient evaluations: 8
>>> res2.x # minimum found
array([-1.80851064, -0.25531915])
scipy.optimize.fmin_bfgs
scipy.optimize.fmin_bfgs(f, x0, fprime=None, args=(), gtol=1e-05, norm=inf, epsilon=1.4901161193847656e-08, maxiter=None, full_output=0, disp=1, retall=0, callback=None, xrtol=0, c1=0.0001, c2=0.9, hess_inv0=None)
使用 BFGS 算法最小化函数。
参数：
f可调用函数 f(x,*args)
要最小化的目标函数。
x0ndarray
初始猜测，形状为 (n,)
fprime可调用函数 f'(x,*args)，可选
f 的梯度。
args元组，可选
传递给 f 和 fprime 的额外参数。
gtol浮点数，可选
如果梯度范数小于 gtol，则成功终止。
norm浮点数，可选
范数的顺序（Inf 为最大，-Inf 为最小）
epsilon整数或 ndarray，可选
如果 fprime 是近似的，则使用此值作为步长。
callback可调用对象，可选
每次迭代后调用的可选用户提供的函数。调用方式为 callback(xk)，其中 xk 是当前的参数向量。
maxiter整数，可选
要执行的最大迭代次数。
full_output布尔值，可选
如果为 True，则除了 xopt 外还返回 fopt、func_calls、grad_calls 和 warnflag。
disp布尔值，可选
如果为 True，则打印收敛消息。
retall布尔值，可选
如果为 True，则返回每次迭代的结果列表。
xrtol浮点数，默认值：0
x 的相对容差。如果步长小于 xk * xrtol，其中 xk 是当前的参数向量，则成功终止。
c1浮点数，默认值：1e-4
用于 Armijo 条件规则的参数。
c2浮点数，默认值：0.9
曲率条件规则的参数。
hess_inv0None 或 ndarray，可选``
初始逆海森估计，形状为 (n, n)。如果为 None（默认），则使用单位矩阵。
返回：
xoptndarray
最小化函数 f 的参数，即 f(xopt) == fopt。
fopt浮点数
最小值。
goptndarray
最小值处的梯度值，即 f’(xopt)，应接近 0。
Boptndarray
f’’(xopt) 的倒数值，即逆海森矩阵。
func_calls整数
函数调用数。
grad_calls整数
进行的梯度调用数。
warnflag整数
1：超过最大迭代次数。2：梯度和/或函数调用未更改。3：遇到 NaN 结果。
allvecs列表
xopt 在每次迭代时的值。仅在 retall 为 True 时返回。
另请参见
多变量函数最小化算法的接口。特别是看 method='BFGS'。
注意
优化函数 f，其梯度由 fprime 给出，使用 Broyden、Fletcher、Goldfarb 和 Shanno（BFGS）的拟牛顿方法。
参数 c1 和 c2 必须满足 0 < c1 < c2 < 1。
参考
Wright 和 Nocedal，《数值优化》，1999 年，第 198 页。
示例
>>> import numpy as np
>>> from scipy.optimize import fmin_bfgs
>>> def quadratic_cost(x, Q):
... return x @ Q @ x
...
>>> x0 = np.array([-3, -4])
>>> cost_weight = np.diag([1., 10.])
>>> # Note that a trailing comma is necessary for a tuple with single element
>>> fmin_bfgs(quadratic_cost, x0, args=(cost_weight,))
Optimization terminated successfully.
Current function value: 0.000000
Iterations: 7 # may vary
Function evaluations: 24 # may vary
Gradient evaluations: 8 # may vary
array([ 2.85169950e-06, -4.61820139e-07])
>>> def quadratic_cost_grad(x, Q):
... return 2 * Q @ x
...
>>> fmin_bfgs(quadratic_cost, x0, quadratic_cost_grad, args=(cost_weight,))
Optimization terminated successfully.
Current function value: 0.000000
Iterations: 7
Function evaluations: 8
Gradient evaluations: 8
array([ 2.85916637e-06, -4.54371951e-07])
scipy.optimize.fmin_ncg
scipy.optimize.fmin_ncg(f, x0, fprime, fhess_p=None, fhess=None, args=(), avextol=1e-05, epsilon=1.4901161193847656e-08, maxiter=None, full_output=0, disp=1, retall=0, callback=None, c1=0.0001, c2=0.9)
使用 Newton-CG 方法进行无约束函数最小化。
参数：
fcallable f(x, *args)
要最小化的目标函数。
x0ndarray
初始猜测。
fprimecallable f'(x, *args)
f 的梯度。
fhess_pcallable fhess_p(x, p, *args), optional
计算 f 的 Hessian 矩阵乘以任意向量 p 的函数。
fhesscallable fhess(x, *args), optional
计算 f 的 Hessian 矩阵的函数。
argstuple, optional
传递给 f、fprime、fhess_p 和 fhess 的额外参数（这些函数的所有额外参数相同）。
epsilonfloat 或 ndarray, optional
如果 fhess 是近似的，则使用此值作为步长大小。
callbackcallable, optional
每次迭代后调用的可选用户提供函数。作为 callback(xk)调用，其中 xk 是当前参数向量。
avextolfloat, optional
当最小化器中的平均相对误差低于此值时，假定收敛。
maxiterint, optional
执行的最大迭代次数。
full_outputbool, optional
如果为 True，则返回可选的输出。
dispbool, optional
如果为 True，则打印收敛消息。
retallbool, optional
如果为 True，则返回每次迭代的结果列表。
c1float，默认值：1e-4
Armijo 条件规则的参数。
c2float，默认值：0.9
曲率条件规则的参数
返回：
xoptndarray
使 f 最小化的参数，即f(xopt) == fopt。
foptfloat
函数在 xopt 处的值，即fopt = f(xopt)。
fcallsint
调用的函数次数。
gcallsint
调用的梯度次数。
hcallsint
调用黑塞矩阵的次数。
warnflagint
算法生成的警告。1：超过最大迭代次数。2：线搜索失败（精度丢失）。3：遇到 NaN 结果。
allvecslist
每次迭代的结果，如果 retall 为 True（见下文）。
另请参阅
minimize
用于多元函数最小化算法的接口。特别查看‘Newton-CG’method。
注意事项
只需给出fhess_p或fhess中的一个。如果提供了fhess，则将忽略fhess_p。如果未提供fhess或fhess_p，则将使用fprime上的有限差分近似计算 Hessian 乘积。fhess_p必须计算任意向量的 Hessian 乘积。如果未给出，将使用fprime上的有限差分计算它。
Newton-CG 方法也称为截断 Newton 方法。此函数与 scipy.optimize.fmin_tnc 不同，因为
-
scipy.optimize.fmin_ncg 是纯用 Python 和 NumPy 编写的。
而
scipy同时调用了scipy.optimize.fmin_tnc来调用一个 C 函数。 -
scipy.optimize.fmin_ncg仅适用于无约束最小化。而
scipy.optimize.fmin_tnc则适用于无约束最小化或者箱约束最小化。（箱约束为每个变量分别给出下限和上限。）
参数 c1 和 c2 必须满足 0 < c1 < c2 < 1。
参考文献
Wright & Nocedal，《数值优化》，1999 年，第 140 页。
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 表示无输出。
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, 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, 可选
用于确定由雅可比近似给出的方向上的步长的线搜索类型。默认为‘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, 可选
用于确定由雅可比近似给定方向上的步长大小的线搜索类型。默认为“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，可选
用于确定由雅可比近似给定方向上的步长大小的线搜索类型。默认为'armijo'。
callback函数，可选
可选回调函数。每次迭代调用为callback(x, f)，其中x为当前解，f为相应残差。
返回：
solndarray
一个包含最终解的数组（与x0相似的数组类型）。
引发：
NoConvergence
当未找到解决方案时。
另见
多元函数的根查找算法接口。特别查看method='linearmixing'。
scipy.optimize.diagbroyden
scipy.optimize.diagbroyden(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)
查找函数的根，使用对角布罗伊登雅各比近似法。
雅各比近似法源自先前迭代，仅保留布罗伊登矩阵的对角线。
警告
这种算法可能对特定问题有用，但其是否有效可能严重依赖于问题本身。
参数：
Ffunction(x) -> f
要找其根的函数；应接受并返回类似数组的对象。
xinarray_like
解的初始猜测
alphafloat，可选
雅各比的初始猜测为(-1/alpha)。
iterint，可选
要进行的迭代次数。如果省略（默认），则进行足够多次迭代以满足容差要求。
verbosebool，可选
在每次迭代时将状态打印到标准输出。
maxiterint，可选
要进行的最大迭代次数。如果需要更多次迭代以满足收敛性，将引发NoConvergence。
f_tolfloat，可选
残差的绝对容差（最大范数）。如果省略，默认为 6e-6。
f_rtolfloat，可选
相对残差的相对容差。如果省略，则不使用。
x_tolfloat，可选
绝对最小步长，根据雅各比近似法确定。如果步长小于此值，则优化将成功终止。如果省略，则不使用。
x_rtolfloat，可选
相对最小步长。如果省略，则不使用。
tol_normfunction(vector) -> scalar，可选
用于收敛检查的范数。默认为最大范数。
line_search，可选
决定由雅各比近似给出的方向上的步长时，使用哪种类型的线搜索。默认为‘armijo’。
callbackfunction，可选
可选回调函数。在每次迭代时调用，参数为callback(x, f)，其中x为当前解，f为对应残差。
返回：
solndarray
包含最终解的数组（与x0具有相似的数组类型）。
引发：
NoConvergence
当未找到解时。
另请参见
root
用于多元函数根查找算法的接口。特别查看method='diagbroyden'。
示例
下面的函数定义了一个非线性方程组的系统。
>>> 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.diagbroyden(fun, [0, 0])
>>> sol
array([0.84116403, 0.15883384])
信号处理（scipy.signal）
卷积
convolve(in1, in2[, mode, method]) |
对两个 N 维数组进行卷积。 |
|---|---|
correlate(in1, in2[, mode, method]) |
对两个 N 维数组进行交叉相关。 |
fftconvolve(in1, in2[, mode, axes]) |
使用 FFT 对两个 N 维数组进行卷积。 |
oaconvolve(in1, in2[, mode, axes]) |
使用重叠-加法方法对两个 N 维数组进行卷积。 |
convolve2d(in1, in2[, mode, boundary, fillvalue]) |
对两个二维数组进行卷积。 |
correlate2d(in1, in2[, mode, boundary, ...]) |
对两个二维数组进行交叉相关。 |
sepfir2d(input, hrow, hcol) |
使用二维可分离 FIR 滤波器进行卷积。 |
choose_conv_method(in1, in2[, mode, measure]) |
查找最快的卷积/相关方法。 |
correlation_lags(in1_len, in2_len[, mode]) |
计算 1D 交叉相关的滞后/位移索引数组。 |
B 样条曲线
bspline(x, n) |
B 样条基函数。 |
|---|
自版本 1.11.0 起已弃用。
|
cubic(x) |
三次曲线插值。 |
|---|
自版本 1.11.0 起已弃用。
|
quadratic(x) |
二次曲线插值。 |
|---|
自版本 1.11.0 起已弃用。
|
gauss_spline(x, n) |
高斯逼近的 B 样条基函数（n 阶）。 |
|---|---|
cspline1d(signal[, lamb]) |
计算一维秩为 1 的三次样条插值系数。 |
qspline1d(signal[, lamb]) |
计算一维秩为 1 的二次样条插值系数。 |
cspline2d(input[, lambda, precision]) |
二维三次 B 样条的系数。 |
qspline2d(input[, lambda, precision]) |
二维二次 B 样条的系数： |
cspline1d_eval(cj, newx[, dx, x0]) |
在新点集上评估一维三次样条。 |
qspline1d_eval(cj, newx[, dx, x0]) |
在新点集上评估一维二次样条。 |
spline_filter(Iin[, lmbda]) |
对二维数组进行平滑样条（三次）滤波。 |
Filtering
order_filter(a, domain, rank) |
在 N 维数组上执行阶次滤波。 |
|---|---|
medfilt(volume[, kernel_size]) |
对 N 维数组执行中值滤波。 |
medfilt2d(input[, kernel_size]) |
对二维数组进行中值滤波。 |
wiener(im[, mysize, noise]) |
对 N 维数组执行维纳滤波。 |
symiirorder1(input, c0, z1[, precision]) |
使用第一阶段级联实现具有镜像对称边界条件的平滑 IIR 滤波器。第二阶段使用反向序列。 |
symiirorder2(input, r, omega[, precision]) |
使用第二阶段级联实现具有镜像对称边界条件的平滑 IIR 滤波器。第二阶段使用反向序列。 |
lfilter(b, a, x[, axis, zi]) |
使用 IIR 或 FIR 滤波器沿着一维对数据进行滤波。 |
lfiltic(b, a, y[, x]) |
给定输入和输出向量，构造 lfilter 的初始条件。 |
lfilter_zi(b, a) |
构造 lfilter 的初始条件，用于阶跃响应的稳态。 |
filtfilt |
对信号进行前向和后向数字滤波。 |
savgol_filter |
对数组应用 Savitzky-Golay 滤波器。 |
deconvolve |
使用逆滤波器将divisor从signal中去卷积出来。 |
sosfilt |
使用级联的二阶段沿着一个维度对数据进行滤波。 |
sosfilt_zi |
构造 sosfilt 的初始条件，用于步响应稳态。 |
sosfiltfilt |
使用级联的二阶段进行前向-后向数字滤波。 |
hilbert |
使用 Hilbert 变换计算解析信号。 |
hilbert2 |
计算x的二维解析信号。 |
decimate |
在应用抗混叠滤波器后对信号进行下采样。 |
detrend |
从数据中沿着指定轴去除线性趋势。 |
resample |
使用傅里叶方法沿给定轴对x进行num样本的重采样。 |
resample_poly |
使用多相滤波器沿指定轴对x进行重采样。 |
upfirdn |
上采样、FIR 滤波和下采样。 |
Filter design
bilinear |
使用双线性变换从模拟滤波器返回数字 IIR 滤波器。 |
|---|---|
bilinear_zpk |
使用双线性变换从模拟滤波器返回数字 IIR 滤波器。 |
findfreqs(num, den, N[, kind]) |
查找用于计算模拟滤波器响应的频率数组。 |
firls(numtaps, bands, desired, *[, weight, ...]) |
使用最小二乘误差最小化设计 FIR 滤波器。 |
firwin(numtaps, cutoff, *[, width, window, ...]) |
使用窗口方法设计 FIR 滤波器。 |
firwin2(numtaps, freq, gain, *[, nfreqs, ...]) |
使用窗口方法设计 FIR 滤波器。 |
freqs(b, a[, worN, plot]) |
计算模拟滤波器的频率响应。 |
freqs_zpk(z, p, k[, worN]) |
计算模拟滤波器的频率响应。 |
freqz(b[, a, worN, whole, plot, fs, ...]) |
计算数字滤波器的频率响应。 |
freqz_zpk(z, p, k[, worN, whole, fs]) |
计算 ZPK 形式数字滤波器的频率响应。 |
sosfreqz(sos[, worN, whole, fs]) |
计算 SOS 格式数字滤波器的频率响应。 |
gammatone(freq, ftype[, order, numtaps, fs]) |
Gammatone 滤波器设计。 |
group_delay(system[, w, whole, fs]) |
计算数字滤波器的群延迟。 |
iirdesign(wp, ws, gpass, gstop[, analog, ...]) |
完成 IIR 数字和模拟滤波器设计。 |
iirfilter(N, Wn[, rp, rs, btype, analog, ...]) |
给定阶数和关键点，设计 IIR 数字和模拟滤波器。 |
kaiser_atten(numtaps, width) |
计算 Kaiser FIR 滤波器的衰减。 |
kaiser_beta(a) |
给定衰减a，计算 Kaiser 参数beta。 |
kaiserord(ripple, width) |
确定 Kaiser 窗口方法的滤波器窗口参数。 |
minimum_phase(h[, method, n_fft]) |
将线性相位 FIR 滤波器转换为最小相位。 |
savgol_coeffs(window_length, polyorder[, ...]) |
计算 1-D Savitzky-Golay FIR 滤波器的系数。 |
remez(numtaps, bands, desired, *[, weight, ...]) |
使用 Remez 交换算法计算最小最大化优化滤波器。 |
unique_roots(p[, tol, rtype]) |
从根列表中确定唯一的根及其重数。 |
residue(b, a[, tol, rtype]) |
计算 b(s) / a(s) 的部分分数展开。 |
residuez(b, a[, tol, rtype]) |
计算 b(z) / a(z) 的部分分数展开。 |
invres(r, p, k[, tol, rtype]) |
从部分分数展开中计算 b(s) 和 a(s)。 |
invresz(r, p, k[, tol, rtype]) |
从部分分数展开中计算 b(z) 和 a(z)。 |
BadCoefficients |
关于条件不佳的滤波器系数的警告。 |
低级滤波器设计函数：
abcd_normalize([A, B, C, D]) |
检查状态空间矩阵并确保其为二维。 |
|---|---|
band_stop_obj(wp, ind, passb, stopb, gpass, ...) |
频带阻止目标函数，用于最小化阶数。 |
besselap(N[, norm]) |
返回 N 阶贝塞尔滤波器的模拟原型 (z, p, k)。 |
buttap(N) |
返回 N 阶巴特沃斯滤波器的模拟原型 (z, p, k)。 |
cheb1ap(N, rp) |
返回 N 阶切比雪夫类型 I 模拟低通滤波器的 (z, p, k)。 |
cheb2ap(N, rs) |
返回 N 阶切比雪夫类型 II 模拟低通滤波器的 (z, p, k)。 |
cmplx_sort(p) |
|
ellipap(N, rp, rs) |
返回第 N 阶椭圆模拟低通滤波器的 (z,p,k)。 |
lp2bp(b, a[, wo, bw]) |
将低通滤波器原型转换到带通滤波器。 |
lp2bp_zpk(z, p, k[, wo, bw]) |
将低通滤波器原型转换到带通滤波器。 |
lp2bs(b, a[, wo, bw]) |
将低通滤波器原型转换到带阻滤波器。 |
lp2bs_zpk(z, p, k[, wo, bw]) |
将低通滤波器原型转换到带阻滤波器。 |
lp2hp(b, a[, wo]) |
将低通滤波器原型转换到高通滤波器。 |
lp2hp_zpk(z, p, k[, wo]) |
将低通滤波器原型转换到高通滤波器。 |
lp2lp(b, a[, wo]) |
将低通滤波器原型转换到不同的频率。 |
lp2lp_zpk(z, p, k[, wo]) |
将低通滤波器原型转换到不同的频率。 |
normalize(b, a) |
归一化连续时间传递函数的分子/分母。 |
Matlab 风格 IIR 滤波器设计
butter(N, Wn[, btype, analog, output, fs]) |
Butterworth 数字和模拟滤波器设计。 |
|---|---|
buttord(wp, ws, gpass, gstop[, analog, fs]) |
Butterworth 滤波器阶数选择。 |
cheby1(N, rp, Wn[, btype, analog, output, fs]) |
Chebyshev I 数字和模拟滤波器设计。 |
cheb1ord(wp, ws, gpass, gstop[, analog, fs]) |
Chebyshev I 滤波器阶数选择。 |
cheby2(N, rs, Wn[, btype, analog, output, fs]) |
Chebyshev II 数字和模拟滤波器设计。 |
cheb2ord(wp, ws, gpass, gstop[, analog, fs]) |
Chebyshev II 滤波器阶数选择。 |
ellip(N, rp, rs, Wn[, btype, analog, output, fs]) |
椭圆（考尔）数字和模拟滤波器设计。 |
ellipord(wp, ws, gpass, gstop[, analog, fs]) |
椭圆（考尔）滤波器阶数选择。 |
bessel(N, Wn[, btype, analog, output, norm, fs]) |
Bessel/Thomson 数字和模拟滤波器设计。 |
iirnotch(w0, Q[, fs]) |
设计二阶 IIR 陷波数字滤波器。 |
iirpeak(w0, Q[, fs]) |
设计二阶 IIR 峰值（共振）数字滤波器。 |
iircomb(w0, Q[, ftype, fs, pass_zero]) |
设计 IIR 凹凸或峰值数字梳状滤波器。 |
连续时间线性系统
lti(*system) |
连续时间线性时不变系统基类。 |
|---|---|
StateSpace(*system, **kwargs) |
状态空间形式的线性时不变系统。 |
TransferFunction(*system, **kwargs) |
传递函数形式的线性时不变系统类。 |
ZerosPolesGain(*system, **kwargs) |
零极点增益形式的线性时不变系统类。 |
lsim(system, U, T[, X0, interp]) |
模拟连续时间线性系统的输出。 |
lsim2(system[, U, T, X0]) |
使用 ODE 求解器 scipy.integrate.odeint 模拟连续时间线性系统的输出。 |
impulse(system[, X0, T, N]) |
连续时间系统的冲激响应。 |
impulse2(system[, X0, T, N]) |
单输入连续时间线性系统的冲激响应。 |
step(system[, X0, T, N]) |
连续时间系统的阶跃响应。 |
step2(system[, X0, T, N]) |
连续时间系统的阶跃响应。 |
freqresp(system[, w, n]) |
计算连续时间系统的频率响应。 |
bode(system[, w, n]) |
计算连续时间系统的波德幅度和相位数据。 |
离散时间线性系统
dlti(*system, **kwargs) |
离散时间线性时不变系统基类。 |
|---|---|
StateSpace(*system, **kwargs) |
状态空间形式的线性时不变系统。 |
TransferFunction(*system, **kwargs) |
传递函数形式的线性时不变系统类。 |
ZerosPolesGain(*system, **kwargs) |
零点、极点、增益形式的线性时不变系统类。 |
dlsim(system, u[, t, x0]) |
模拟离散时间线性系统的输出。 |
dimpulse(system[, x0, t, n]) |
离散时间系统的冲激响应。 |
dstep(system[, x0, t, n]) |
离散时间系统的阶跃响应。 |
dfreqresp(system[, w, n, whole]) |
计算离散时间系统的频率响应。 |
dbode(system[, w, n]) |
计算离散时间系统的波德幅度和相位数据。 |
LTI 表示
tf2zpk(b, a) |
从分子、分母表示的线性滤波器返回零点、极点、增益（z, p, k）表示。 |
|---|---|
tf2sos(b, a[, pairing, analog]) |
从传递函数表示返回二阶段节。 |
tf2ss(num, den) |
传递函数到状态空间表示。 |
zpk2tf(z, p, k) |
从零点和极点返回多项式传递函数表示。 |
zpk2sos(z, p, k[, pairing, analog]) |
从系统的零点、极点和增益返回二阶段节。 |
zpk2ss(z, p, k) |
零极点增益表示转换为状态空间表示 |
ss2tf(A, B, C, D[, input]) |
状态空间到传递函数的转换。 |
ss2zpk(A, B, C, D[, input]) |
状态空间表示转换为零极点增益表示。 |
sos2zpk(sos) |
返回一系列二阶段的零点、极点和增益 |
sos2tf(sos) |
从一系列二阶段得到单一传递函数 |
cont2discrete(system, dt[, method, alpha]) |
将连续状态空间系统转换为离散系统。 |
place_poles(A, B, poles[, method, rtol, maxiter]) |
计算 K 使得特征值（A - dot(B, K))=poles。 |
波形
chirp(t, f0, t1, f1[, method, phi, vertex_zero]) |
频率扫描余弦波生成器。 |
|---|---|
gausspulse(t[, fc, bw, bwr, tpr, retquad, ...]) |
返回高斯调制正弦波： |
max_len_seq(nbits[, state, length, taps]) |
最大长度序列（MLS）生成器。 |
sawtooth(t[, width]) |
返回周期锯齿波形或三角波形。 |
square(t[, duty]) |
返回周期方波波形。 |
sweep_poly(t, poly[, phi]) |
频率扫描余弦波生成器，具有时间相关的频率。 |
unit_impulse(shape[, idx, dtype]) |
单位冲激信号（离散δ函数）或单位基向量。 |
窗口函数
对于窗口函数，请参见scipy.signal.windows命名空间。
在scipy.signal命名空间中，有一个方便的函数可通过名称获取这些窗口：
get_window(window, Nx[, fftbins]) |
返回指定长度和类型的窗口。 |
|---|
小波
cascade(hk[, J]) |
从滤波器系数返回 dyadic 点K/2**J处的(x, phi, psi)。 |
|---|---|
daub(p) |
产生 Daubechies 小波的 FIR 低通滤波器系数。 |
morlet(M[, w, s, complete]) |
复杂 Morlet 小波。 |
qmf(hk) |
从低通滤波器返回高通 qmf 滤波器。 |
ricker(points, a) |
返回一个 Ricker 小波，也称为“墨西哥帽小波”。 |
morlet2(M, s[, w]) |
复杂 Morlet 小波，专为与cwt一起使用而设计。 |
cwt(data, wavelet, widths[, dtype]) |
连续小波变换。 |
峰值检测
argrelmin(data[, axis, order, mode]) |
计算data的相对最小值。 |
|---|---|
argrelmax(data[, axis, order, mode]) |
计算data的相对最大值。 |
argrelextrema(data, comparator[, axis, ...]) |
计算data的相对极值。 |
find_peaks(x[, height, threshold, distance, ...]) |
基于峰值特性在信号内部找到峰值。 |
find_peaks_cwt(vector, widths[, wavelet, ...]) |
使用小波变换在 1-D 数组中找到峰值。 |
peak_prominences(x, peaks[, wlen]) |
计算信号中每个峰值的显著性。 |
peak_widths(x, peaks[, rel_height, ...]) |
计算信号中每个峰值的宽度。 |
谱分析
periodogram(x[, fs, window, nfft, detrend, ...]) |
使用周期图估算功率谱密度。 |
|---|---|
welch(x[, fs, window, nperseg, noverlap, ...]) |
使用 Welch 方法估算功率谱密度。 |
csd(x, y[, fs, window, nperseg, noverlap, ...]) |
使用 Welch 方法估计交叉功率谱密度 Pxy。 |
coherence(x, y[, fs, window, nperseg, ...]) |
使用 Welch 方法估计离散时间信号 X 和 Y 的幅度平方相干估计 Cxy。 |
spectrogram(x[, fs, window, nperseg, ...]) |
使用连续傅里叶变换计算谱图。 |
lombscargle(x, y, freqs) |
计算朗伯-斯卡戈尔周期图。 |
vectorstrength(events, period) |
确定与给定周期对应的事件的向量强度。 |
ShortTimeFFT(win, hop, fs, *[, fft_mode, ...]) |
提供参数化的离散短时傅里叶变换（STFT）及其逆变换（ISTFT）。 |
stft(x[, fs, window, nperseg, noverlap, ...]) |
计算短时傅里叶变换（STFT）。 |
istft(Zxx[, fs, window, nperseg, noverlap, ...]) |
执行逆短时傅里叶变换（iSTFT）。 |
check_COLA(window, nperseg, noverlap[, tol]) |
检查是否满足恒定重叠添加（COLA）约束。 |
check_NOLA(window, nperseg, noverlap[, tol]) |
检查非零重叠添加（NOLA）约束是否满足。 |
Chirp Z-transform and Zoom FFT
czt(x[, m, w, a, axis]) |
计算 Z 平面上螺旋周围的频率响应。 |
|---|---|
zoom_fft(x, fn[, m, fs, endpoint, axis]) |
仅计算范围内频率 fn 的 x 的离散傅里叶变换（DFT）。 |
CZT(n[, m, w, a]) |
创建可调用的啁啾 Z 变换函数。 |
ZoomFFT(n, fn[, m, fs, endpoint]) |
创建可调用的缩放 FFT 变换函数。 |
czt_points(m[, w, a]) |
返回进行啁啾 Z 变换的点。 |
函数比类更易于使用，但在对许多长度相同的数组执行相同变换时效率较低，因为它们在每次调用时都会重复生成相同的啁啾信号。在这些情况下，使用类来创建可重复使用的函数更为合适。
scipy.signal.convolve
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.convolve.html#scipy.signal.convolve
scipy.signal.convolve(in1, in2, mode='full', method='auto')
对两个 N 维数组进行卷积。
使用mode参数确定输出大小，对in1和in2进行卷积。
参数：
in1array_like
第一个输入。
in2array_like
第二输入。应与in1具有相同数量的维度。
modestr {‘full’, ‘valid’, ‘same’}，可选
一个表示输出大小的字符串：
full
输出是输入的完整离散线性卷积。（默认）
valid
输出仅包含那些不依赖于零填充的元素。在‘valid’模式下，in1或in2必须至少在每个维度上与另一个一样大。
same
输出与in1相同大小，并相对于‘full’输出中心化。
methodstr {‘auto’, ‘direct’, ‘fft’}，可选
一个表示计算卷积使用的方法的字符串。
direct
卷积直接来自求和，即卷积的定义。
fft
通过调用fftconvolve使用傅立叶变换执行卷积。
auto
根据估计选择直接方法或傅立叶方法（默认）以提高速度。更多详细信息请参见注释。
新版本 0.19.0 中引入。
返回：
convolvearray
包含in1与in2的离散线性卷积子集的 N 维数组。
警告：
RuntimeWarning
在包含 NAN 或 INF 的输入上使用 FFT 卷积将导致整个输出为 NAN 或 INF。当输入包含 NAN 或 INF 值时，请使用 method=’direct’。
另请参见
执行多项式乘法（相同操作，但还接受 poly1d 对象）
choose_conv_method
选择最快适当的卷积方法
fftconvolve
始终使用 FFT 方法。
oaconvolve
使用重叠-添加方法进行卷积，当输入数组大且大小显著不同时通常更快。
注释
默认情况下，convolve 和 correlate 使用 method='auto'，这会调用 choose_conv_method 来选择最快的方法，使用预先计算的值（choose_conv_method 还可以通过关键字参数测量真实世界的时间）。因为 fftconvolve 依赖于浮点数，所以存在某些约束可能会强制使用 method=direct（详细信息请参见 choose_conv_method 文档字符串）。
示例
使用汉宁窗口平滑方波脉冲：
>>> import numpy as np
>>> from scipy import signal
>>> sig = np.repeat([0., 1., 0.], 100)
>>> win = signal.windows.hann(50)
>>> filtered = signal.convolve(sig, win, mode='same') / sum(win)
>>> import matplotlib.pyplot as plt
>>> fig, (ax_orig, ax_win, ax_filt) = plt.subplots(3, 1, sharex=True)
>>> ax_orig.plot(sig)
>>> ax_orig.set_title('Original pulse')
>>> ax_orig.margins(0, 0.1)
>>> ax_win.plot(win)
>>> ax_win.set_title('Filter impulse response')
>>> ax_win.margins(0, 0.1)
>>> ax_filt.plot(filtered)
>>> ax_filt.set_title('Filtered signal')
>>> ax_filt.margins(0, 0.1)
>>> fig.tight_layout()
>>> fig.show()
scipy.signal.correlate
scipy.signal.correlate(in1, in2, mode='full', method='auto')
交叉相关两个 N 维数组。
对 in1 和 in2 进行交叉相关，输出大小由 mode 参数确定。
参数：
in1array_like
第一个输入。
in2array_like
第二个输入。应与 in1 具有相同数量的维度。
modestr {‘full’, ‘valid’, ‘same’}, 可选
一个指示输出大小的字符串：
full
输出是输入的完整离散线性交叉相关。（默认）
valid
输出仅包含不依赖于零填充的元素。在“有效”模式下，in1 或 in2 在每个维度上至少与另一个一样大。
same
输出与 in1 相同大小，相对于“full”输出居中。
methodstr {‘auto’, ‘direct’, ‘fft’}, 可选
表示计算相关性的方法的字符串。
direct
相关性直接根据总和确定。
fft
使用快速傅里叶变换来更快地执行相关性计算（仅适用于数值数组）。
auto
基于估计的速度更快的直接或傅里叶方法（默认）自动选择。详细信息请参阅 convolve 说明。
从版本 0.19.0 开始新添加。
返回：
correlatearray
包含 in1 与 in2 的离散线性交叉相关的子集的 N 维数组。
另请参阅
choose_conv_method
包含更多关于 method 的文档。
correlation_lags
计算 1D 交叉相关的滞后/位移索引数组。
注意
两个 d 维数组 x 和 y 的相关性 z 定义为：
z[...,k,...] = sum[..., i_l, ...] x[..., i_l,...] * conj(y[..., i_l - k,...])
因此，如果 x 和 y 是 1-D 数组，并且 z = correlate(x, y, 'full')，则
[z[k] = (x * y)(k - N + 1) = \sum_{l=0}^{||x||-1}x_l y_{l-k+N-1}^{*}]
对于 (k = 0, 1, ..., ||x|| + ||y|| - 2)
其中 (||x||) 是 x 的长度，(N = \max(||x||,||y||))，当 m 超出 y 的范围时，(y_m) 为 0。
method='fft' 仅适用于数值数组，因为它依赖于 fftconvolve。在某些情况下（例如，对象数组或者当四舍五入整数可能会丢失精度时），始终使用 method='direct'。
在使用偶数长度输入的“same”模式时，correlate 和 correlate2d 的输出不同：它们之间有一个 1 索引偏移。
示例
使用互相关实现匹配滤波器，以恢复通过噪声通道传输的信号。
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
>>> sig = np.repeat([0., 1., 1., 0., 1., 0., 0., 1.], 128)
>>> sig_noise = sig + rng.standard_normal(len(sig))
>>> corr = signal.correlate(sig_noise, np.ones(128), mode='same') / 128
>>> clock = np.arange(64, len(sig), 128)
>>> fig, (ax_orig, ax_noise, ax_corr) = plt.subplots(3, 1, sharex=True)
>>> ax_orig.plot(sig)
>>> ax_orig.plot(clock, sig[clock], 'ro')
>>> ax_orig.set_title('Original signal')
>>> ax_noise.plot(sig_noise)
>>> ax_noise.set_title('Signal with noise')
>>> ax_corr.plot(corr)
>>> ax_corr.plot(clock, corr[clock], 'ro')
>>> ax_corr.axhline(0.5, ls=':')
>>> ax_corr.set_title('Cross-correlated with rectangular pulse')
>>> ax_orig.margins(0, 0.1)
>>> fig.tight_layout()
>>> plt.show()
计算带噪声信号与原始信号的互相关。
>>> x = np.arange(128) / 128
>>> sig = np.sin(2 * np.pi * x)
>>> sig_noise = sig + rng.standard_normal(len(sig))
>>> corr = signal.correlate(sig_noise, sig)
>>> lags = signal.correlation_lags(len(sig), len(sig_noise))
>>> corr /= np.max(corr)
>>> fig, (ax_orig, ax_noise, ax_corr) = plt.subplots(3, 1, figsize=(4.8, 4.8))
>>> ax_orig.plot(sig)
>>> ax_orig.set_title('Original signal')
>>> ax_orig.set_xlabel('Sample Number')
>>> ax_noise.plot(sig_noise)
>>> ax_noise.set_title('Signal with noise')
>>> ax_noise.set_xlabel('Sample Number')
>>> ax_corr.plot(lags, corr)
>>> ax_corr.set_title('Cross-correlated signal')
>>> ax_corr.set_xlabel('Lag')
>>> ax_orig.margins(0, 0.1)
>>> ax_noise.margins(0, 0.1)
>>> ax_corr.margins(0, 0.1)
>>> fig.tight_layout()
>>> plt.show()
scipy.signal.fftconvolve
scipy.signal.fftconvolve(in1, in2, mode='full', axes=None)
使用 FFT 对两个 N 维数组进行卷积。
使用快速 Fourier 变换方法对 in1 和 in2 进行卷积，输出大小由 mode 参数确定。
对于大数组（n > ~500），这通常比 convolve 快得多，但是当仅需要少数输出值时可能较慢，并且只能输出浮点数数组（整数或对象数组输入将转换为浮点数）。
自 v0.19 起，convolve 根据哪种方法更快的估计自动选择。
参数:
in1array_like
第一个输入。
in2array_like
第二个输入。应与 in1 具有相同数量的维度。
modestr {'full', 'valid', 'same'}，可选
指示输出大小的字符串:
full
输出是输入的完整离散线性卷积。(默认)
valid
输出仅包含不依赖于零填充的元素。在 'valid' 模式下，in1 或 in2 在每个维度上必须至少与另一个一样大。
same
输出与 in1 大小相同，相对于 'full' 输出居中。
axesint 或 array_like 的整数或 None，可选
计算卷积的轴。默认为所有轴。
返回:
outarray
包含 in1 与 in2 的离散线性卷积的子集的 N 维数组。
另请参阅
convolve
根据速度选择直接卷积或 FFT 卷积算法。
oaconvolve
当输入数组大且尺寸显著不同时，使用重叠-添加方法进行卷积通常更快。
示例
白噪声的自相关是一个脉冲。
>>> import numpy as np
>>> from scipy import signal
>>> rng = np.random.default_rng()
>>> sig = rng.standard_normal(1000)
>>> autocorr = signal.fftconvolve(sig, sig[::-1], mode='full')
>>> import matplotlib.pyplot as plt
>>> fig, (ax_orig, ax_mag) = plt.subplots(2, 1)
>>> ax_orig.plot(sig)
>>> ax_orig.set_title('White noise')
>>> ax_mag.plot(np.arange(-len(sig)+1,len(sig)), autocorr)
>>> ax_mag.set_title('Autocorrelation')
>>> fig.tight_layout()
>>> fig.show()
使用 FFT 卷积实现高斯模糊。请注意图像周围的黑暗边界，这是由于超出其边界的零填充所致。convolve2d 函数允许其他类型的图像边界，但速度较慢。
>>> from scipy import datasets
>>> face = datasets.face(gray=True)
>>> kernel = np.outer(signal.windows.gaussian(70, 8),
... signal.windows.gaussian(70, 8))
>>> blurred = signal.fftconvolve(face, kernel, mode='same')
>>> fig, (ax_orig, ax_kernel, ax_blurred) = plt.subplots(3, 1,
... figsize=(6, 15))
>>> ax_orig.imshow(face, cmap='gray')
>>> ax_orig.set_title('Original')
>>> ax_orig.set_axis_off()
>>> ax_kernel.imshow(kernel, cmap='gray')
>>> ax_kernel.set_title('Gaussian kernel')
>>> ax_kernel.set_axis_off()
>>> ax_blurred.imshow(blurred, cmap='gray')
>>> ax_blurred.set_title('Blurred')
>>> ax_blurred.set_axis_off()
>>> fig.show()
scipy.signal.oaconvolve
scipy.signal.oaconvolve(in1, in2, mode='full', axes=None)
使用重叠添加方法对两个 N 维数组进行卷积。
使用重叠添加方法对in1和in2进行卷积，输出大小由mode参数确定。
对于大数组（n > ~500），这通常比convolve快得多，并且通常比fftconvolve快得多，当一个数组远大于另一个数组时，但当仅需要少量输出值或数组在形状上非常相似时，可能会更慢，并且只能输出浮点数组（int 或 object 数组输入将被转换为 float）。
参数：
in1array_like
第一个输入。
in2array_like
第二输入。应该与in1具有相同的维数。
modestr {‘full’, ‘valid’, ‘same’}，可选
指示输出大小的字符串：
full
输出是输入的完整离散线性卷积。（默认）
valid
输出仅由不依赖于零填充的元素组成。在“valid”模式下，in1或in2必须在每个维度上至少与另一个一样大。
same
输出与in1大小相同，相对于“full”输出居中。
axesint 或 int 数组或 None，可选
要计算卷积的轴。默认在所有轴上。
返回：
outarray
包含in1与in2离散线性卷积子集的 N 维数组。
另请参阅
convolve
根据哪个更快，使用直接卷积或 FFT 卷积算法。
fftconvolve
使用 FFT 实现的卷积。
注意事项
新版本 1.4.0 中引入。
参考文献
[1]
Wikipedia，“重叠添加方法”。en.wikipedia.org/wiki/Overlap-add_method
[2]
Richard G. Lyons. 《理解数字信号处理》，第三版，2011。第 13.10 章。ISBN 13: 978-0137-02741-5
示例
用 512 个样本的滤波器卷积一个 100,000 个样本的信号。
>>> import numpy as np
>>> from scipy import signal
>>> rng = np.random.default_rng()
>>> sig = rng.standard_normal(100000)
>>> filt = signal.firwin(512, 0.01)
>>> fsig = signal.oaconvolve(sig, filt)
>>> import matplotlib.pyplot as plt
>>> fig, (ax_orig, ax_mag) = plt.subplots(2, 1)
>>> ax_orig.plot(sig)
>>> ax_orig.set_title('White noise')
>>> ax_mag.plot(fsig)
>>> ax_mag.set_title('Filtered noise')
>>> fig.tight_layout()
>>> fig.show()
scipy.signal.convolve2d
scipy.signal.convolve2d(in1, in2, mode='full', boundary='fill', fillvalue=0)
对两个二维数组进行卷积。
用于计算输出大小的模式以及由 boundary 和 fillvalue 决定的边界条件对 in1 和 in2 进行卷积。
参数：
in1 类似数组
First input.
in2 类似数组
第二个输入。应该与 in1 具有相同数量的维度。
mode 字符串 {‘full’, ‘valid’, ‘same’}，可选
表示输出大小的字符串：
full
输出是输入的完整离散线性卷积。（默认）
valid
输出仅包含不依赖于零填充的元素。在“valid”模式下，in1 或 in2 在每个维度上至少必须与另一个一样大。
same
输出与 in1 相同大小，并相对于“full”输出居中。
boundary 字符串 {‘fill’, ‘wrap’, ‘symm’}，可选
一个指示如何处理边界的标志：
fill
用 fillvalue 填充输入数组。（默认）
wrap
循环边界条件。
symm
对称边界条件。
fillvalue 标量，可选
用于填充输入数组的值。默认为 0。
返回：
out ndarray
包含 in1 与 in2 离散线性卷积子集的二维数组。
示例
使用复杂的 Scharr 算子通过 2D 卷积计算图像的梯度。（水平操作符是实部，垂直是虚部。）使用对称边界条件避免在图像边界创建边缘。
>>> import numpy as np
>>> from scipy import signal
>>> from scipy import datasets
>>> ascent = datasets.ascent()
>>> scharr = np.array([[ -3-3j, 0-10j, +3 -3j],
... [-10+0j, 0+ 0j, +10 +0j],
... [ -3+3j, 0+10j, +3 +3j]]) # Gx + j*Gy
>>> grad = signal.convolve2d(ascent, scharr, boundary='symm', mode='same')
>>> import matplotlib.pyplot as plt
>>> fig, (ax_orig, ax_mag, ax_ang) = plt.subplots(3, 1, figsize=(6, 15))
>>> ax_orig.imshow(ascent, cmap='gray')
>>> ax_orig.set_title('Original')
>>> ax_orig.set_axis_off()
>>> ax_mag.imshow(np.absolute(grad), cmap='gray')
>>> ax_mag.set_title('Gradient magnitude')
>>> ax_mag.set_axis_off()
>>> ax_ang.imshow(np.angle(grad), cmap='hsv') # hsv is cyclic, like angles
>>> ax_ang.set_title('Gradient orientation')
>>> ax_ang.set_axis_off()
>>> fig.show()
scipy.signal.correlate2d
scipy.signal.correlate2d(in1, in2, mode='full', boundary='fill', fillvalue=0)
交叉相关两个二维数组。
用mode确定输出大小，boundary和fillvalue确定边界条件交叉相关in1和in2。
参数：
in1array_like
第一个输入。
in2array_like
第二个输入。应与in1具有相同数量的维度。
modestr {‘full’, ‘valid’, ‘same’}，可选
指示输出大小的字符串：
full
输出是输入的完整离散线性交叉相关。（默认）
valid
输出仅包含那些不依赖于零填充的元素。在“valid”模式下，in1或in2必须至少在每个维度上与另一个一样大。
same
输出与in1相同大小，相对于“full”输出居中。
boundarystr {‘fill’, ‘wrap’, ‘symm’}，可选
指示如何处理边界的标志：
fill
用 fillvalue 填充输入数组。（默认）
wrap
循环边界条件。
symm
对称边界条件。
fillvaluescalar，可选
用于填充填充输入数组的值。默认为 0。
返回：
correlate2dndarray
包含in1与in2的离散线性交叉相关子集的二维数组。
注意事项
使用偶数长度输入的“same”模式时，correlate和correlate2d的输出不同：它们之间存在 1 索引偏移。
示例
使用 2D 交叉相关在嘈杂图像中找到模板的位置：
>>> import numpy as np
>>> from scipy import signal
>>> from scipy import datasets
>>> rng = np.random.default_rng()
>>> face = datasets.face(gray=True) - datasets.face(gray=True).mean()
>>> template = np.copy(face[300:365, 670:750]) # right eye
>>> template -= template.mean()
>>> face = face + rng.standard_normal(face.shape) * 50 # add noise
>>> corr = signal.correlate2d(face, template, boundary='symm', mode='same')
>>> y, x = np.unravel_index(np.argmax(corr), corr.shape) # find the match
>>> import matplotlib.pyplot as plt
>>> fig, (ax_orig, ax_template, ax_corr) = plt.subplots(3, 1,
... figsize=(6, 15))
>>> ax_orig.imshow(face, cmap='gray')
>>> ax_orig.set_title('Original')
>>> ax_orig.set_axis_off()
>>> ax_template.imshow(template, cmap='gray')
>>> ax_template.set_title('Template')
>>> ax_template.set_axis_off()
>>> ax_corr.imshow(corr, cmap='gray')
>>> ax_corr.set_title('Cross-correlation')
>>> ax_corr.set_axis_off()
>>> ax_orig.plot(x, y, 'ro')
>>> fig.show()
scipy.signal.sepfir2d
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.sepfir2d.html#scipy.signal.sepfir2d
scipy.signal.sepfir2d(input, hrow, hcol)
用二维可分离 FIR 滤波器进行卷积。
将二阶排列输入数组与由一阶数组 hrow 和 hcol 定义的可分离滤波器卷积。假设使用镜像对称边界条件。此函数可用于根据其 B-样条表示找到图像。
参数：
inputndarray
输入信号。必须是二阶数组。
hrowndarray
定义滤波器行方向的一阶数组。必须是奇数长度。
hcolndarray
定义滤波器列方向的一阶数组。必须是奇数长度。
返回：
outputndarray
过滤后的信号。
示例
示例显示在教程中。
scipy.signal.choose_conv_method
scipy.signal.choose_conv_method(in1, in2, mode='full', measure=False)
找到最快的卷积/相关方法。
主要用于在卷积和相关的method='auto'选项期间调用。它还可用于确定许多相同 dtype/shape 的卷积的method的值。此外，它支持根据特定输入和/或硬件的时间来调整method的值。
参数：
in1类数组
传递给卷积函数的第一个参数。
in2类数组
传递给卷积函数的第二个参数。
模式字符串 {‘full’, ‘valid’, ‘same’}，可选
输出大小的字符串指示：
full
输出是输入的完整离散线性卷积。（默认）
valid
输出仅包含不依赖于零填充的元素。
same
输出与in1相同大小，相对于‘full’输出居中。
测量布尔值，可选
如果为 True，则使用两种方法运行和计时in1和in2的卷积，并返回最快的方法。如果为 False（默认），则使用预计算的值预测最快方法。
返回：
方法字符串
指示哪种卷积方法最快的字符串，可以是‘direct’或‘fft’
times字典，可选
包含每种方法所需时间（以秒为单位）的字典。仅当measure=True时才返回此值。
另见
卷积
相关
注意
一般来说，对于随机选择的输入尺寸，此方法在 2D 信号中的准确率为 99%，在 1D 信号中为 85%。为了精度，使用measure=True来找到计算卷积所需的最快方法。这可以用来避免稍后找到最快method的最小开销，或者根据特定输入集合调整method的值。
实验在 Amazon EC2 r5a.2xlarge 机器上运行，以测试此函数。这些实验测量了使用method='auto'时所需的时间与最快方法（即ratio = time_auto / min(time_fft, time_direct)）之间的比率。在这些实验中，我们发现：
-
对于 1D 信号，这个比率小于 1.5 的可能性为 95%，对于 2D 信号，这个比率小于 2.5 的可能性为 99%。
-
对于 1D/2D 信号，这个比率始终小于 2.5/5。
-
此函数在处理
method='direct'的 1D 卷积时最不准确，耗时介于 1 到 10 毫秒之间。在我们的实验中，这个值的一个良好代理是1e6 <= in1.size * in2.size <= 1e7。
2D 结果几乎可以肯定地推广到 3D/4D 等，因为实现是相同的（1D 实现是不同的）。
上述所有数字都特定于 EC2 机器。然而，我们确实发现该函数在不同硬件上表现相当良好。速度测试的质量与调整此函数数字的机器相似（一台 2014 年中期的 15 英寸 MacBook Pro，配备 16GB RAM 和 2.5GHz 的 Intel i7 处理器）。
存在一些情况，fftconvolve支持输入，但此函数返回direct（例如，为了防止浮点整数精度问题）。
从 0.19 版本开始新增。
示例
估算给定输入的最快方法：
>>> import numpy as np
>>> from scipy import signal
>>> rng = np.random.default_rng()
>>> img = rng.random((32, 32))
>>> filter = rng.random((8, 8))
>>> method = signal.choose_conv_method(img, filter, mode='same')
>>> method
'fft'
然后可以应用于相同数据类型和形状的其他数组：
>>> img2 = rng.random((32, 32))
>>> filter2 = rng.random((8, 8))
>>> corr2 = signal.correlate(img2, filter2, mode='same', method=method)
>>> conv2 = signal.convolve(img2, filter2, mode='same', method=method)
此函数的输出(method)与correlate和convolve一起使用。
scipy.signal.correlation_lags
scipy.signal.correlation_lags(in1_len, in2_len, mode='full')
计算一维交叉相关的滞后/位移索引数组。
参数：
in1_len整数
第一个输入大小。
in2_len整数
第二个输入大小。
模式str {‘full’, ‘valid’, ‘same’}，可选
指示输出大小的字符串。有关更多信息，请参阅文档correlate。
返回：
lags数组
返回一个包含交叉相关滞后/位移索引的数组。可以使用相关性的 np.argmax 来索引 lag/displacement。
另请参阅
计算 N 维交叉相关。
注意事项
连续函数(f)和(g)的交叉相关定义为：
[\left ( f\star g \right )\left ( \tau \right ) \triangleq \int_{t_0}^{t_0 +T} \overline{f\left ( t \right )}g\left ( t+\tau \right )dt]
其中(\tau)定义为位移，也称为滞后。
离散函数(f)和(g)的交叉相关定义为：
[\left ( f\star g \right )\left [ n \right ] \triangleq \sum_{-\infty}^{\infty} \overline{f\left [ m \right ]}g\left [ m+n \right ]]
其中(n)为滞后。
示例
信号与其自身延迟的交叉相关。
>>> import numpy as np
>>> from scipy import signal
>>> rng = np.random.default_rng()
>>> x = rng.standard_normal(1000)
>>> y = np.concatenate([rng.standard_normal(100), x])
>>> correlation = signal.correlate(x, y, mode="full")
>>> lags = signal.correlation_lags(x.size, y.size, mode="full")
>>> lag = lags[np.argmax(correlation)]
scipy.signal.bspline
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.bspline.html#scipy.signal.bspline
scipy.signal.bspline(x, n)
自版本 1.11.0 起已弃用：scipy.signal.bspline 在 SciPy 1.11 中已弃用，并将在 SciPy 1.13 中移除。
对于浮点数组 x 的精确等价物是：
>>> import numpy as np
>>> from scipy.interpolate import BSpline
>>> knots = np.arange(-(n+1)/2, (n+3)/2)
>>> out = BSpline.basis_element(knots)(x)
>>> out[(x < knots[0]) | (x > knots[-1])] = 0.0
阶数为 n 的 B 样条基函数。
参数：
xarray_like
一个结点向量
nint
样条的阶数。必须是非负的，即 n >= 0
返回：
resndarray
B 样条基函数值
另请参见
cubic
一个立方 B 样条。
quadratic
一个二次 B 样条。
注意事项
使用 numpy.piecewise 和自动函数生成器。
示例
我们可以计算几个阶数的 B 样条基函数：
>>> import numpy as np
>>> from scipy.signal import bspline, cubic, quadratic
>>> bspline(0.0, 1)
1
>>> knots = [-1.0, 0.0, -1.0]
>>> bspline(knots, 2)
array([0.125, 0.75, 0.125])
>>> np.array_equal(bspline(knots, 2), quadratic(knots))
True
>>> np.array_equal(bspline(knots, 3), cubic(knots))
True
浙公网安备 33010602011771号