SciPy 1.12 中文文档（二十二）

原文：docs.scipy.org/doc/scipy-1.12.0/index.html

`scipy.ndimage.grey_opening`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.grey_opening.html#scipy.ndimage.grey_opening

scipy.ndimage.grey_opening(input, size=None, footprint=None, structure=None, output=None, mode='reflect', cval=0.0, origin=0)

多维灰度开运算。

灰度开运算由灰度侵蚀和灰度膨胀的连续进行组成。

参数：

input 数组类型

用于计算灰度开运算的数组。

size 整数元组

用于灰度开运算的平坦全结构元素的形状。如果提供了 footprint 或 structure，则为可选。

footprint 整数数组，可选

用于灰度开运算的平坦结构元素的非无限元素的位置。

structure 整数数组，可选

用于灰度开运算的结构元素。structure 可以是非平坦的结构元素。

output 数组，可选

可以提供用于存储开运算输出的数组。

mode {‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}，可选

mode 参数确定如何处理数组边界，当 mode 等于 ‘constant’ 时，cval 是数值。默认为 ‘reflect’

cval 标量，可选

如果 mode 为 ‘constant’，则在输入边缘之外填充值的数值。默认为 0.0。

origin 标量，可选

参数 origin 控制滤波器的放置。默认为 0

grey_opening ndarray

input 使用 structure 的灰度开运算的结果。

另请参阅

binary_opening，grey_dilation，grey_erosion，grey_closing

generate_binary_structure

说明

使用平坦结构元素的灰度开运算的作用是平滑高局部最大值，而二值开运算则擦除小对象。

参考文献

[1]

数学形态学

示例

>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.arange(36).reshape((6,6))
>>> a[3, 3] = 50
>>> a
array([[ 0,  1,  2,  3,  4,  5],
 [ 6,  7,  8,  9, 10, 11],
 [12, 13, 14, 15, 16, 17],
 [18, 19, 20, 50, 22, 23],
 [24, 25, 26, 27, 28, 29],
 [30, 31, 32, 33, 34, 35]])
>>> ndimage.grey_opening(a, size=(3,3))
array([[ 0,  1,  2,  3,  4,  4],
 [ 6,  7,  8,  9, 10, 10],
 [12, 13, 14, 15, 16, 16],
 [18, 19, 20, 22, 22, 22],
 [24, 25, 26, 27, 28, 28],
 [24, 25, 26, 27, 28, 28]])
>>> # Note that the local maximum a[3,3] has disappeared

`scipy.ndimage.iterate_structure`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.iterate_structure.html#scipy.ndimage.iterate_structure

scipy.ndimage.iterate_structure(structure, iterations, origin=None)

通过与自身膨胀来迭代结构。

参数：

structure array_like

结构元素（例如布尔数组），用于与自身进行膨胀。

iterations 整数

对结构与自身执行的膨胀次数

origin 可选

如果 origin 为 None，则仅返回迭代后的结构。如果不为 None，则返回迭代后的结构和修改后的原点的元组。

iterate_structure 布尔值的 ndarray

通过将 structure 与自身膨胀 (iterations - 1) 次获得的新结构元素。

另请参见

generate_binary_structure

示例

>>> from scipy import ndimage
>>> struct = ndimage.generate_binary_structure(2, 1)
>>> struct.astype(int)
array([[0, 1, 0],
 [1, 1, 1],
 [0, 1, 0]])
>>> ndimage.iterate_structure(struct, 2).astype(int)
array([[0, 0, 1, 0, 0],
 [0, 1, 1, 1, 0],
 [1, 1, 1, 1, 1],
 [0, 1, 1, 1, 0],
 [0, 0, 1, 0, 0]])
>>> ndimage.iterate_structure(struct, 3).astype(int)
array([[0, 0, 0, 1, 0, 0, 0],
 [0, 0, 1, 1, 1, 0, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [1, 1, 1, 1, 1, 1, 1],
 [0, 1, 1, 1, 1, 1, 0],
 [0, 0, 1, 1, 1, 0, 0],
 [0, 0, 0, 1, 0, 0, 0]])

`scipy.ndimage.morphological_gradient`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.morphological_gradient.html#scipy.ndimage.morphological_gradient

scipy.ndimage.morphological_gradient(input, size=None, footprint=None, structure=None, output=None, mode='reflect', cval=0.0, origin=0)

多维形态学梯度。

形态学梯度计算为输入与给定结构元素的膨胀和腐蚀之间的差异。

参数:

input数组型

用于计算形态学梯度的数组。

size整数元组

用于数学形态学操作的平坦和完整的结构元素的形状。如果提供了footprint或structure，则可选。较大的size会产生更模糊的梯度。

footprint整数数组，可选

用于形态学操作的平坦结构元素的非无穷元素的位置。较大的足迹会产生更模糊的形态学梯度。

structure整数数组，可选

用于形态学操作的结构元素。structure可以是非平坦的结构元素。

output数组，可选

可以提供用于存储形态学梯度输出的数组。

mode{'reflect', 'constant', 'nearest', 'mirror', 'wrap'}，可选

mode参数确定如何处理数组边界，当mode等于'constant'时，cval为值。默认为'reflect'

cval标量，可选

如果mode为'constant'，用于填充输入边缘之外的值。默认为 0.0。

origin标量，可选

origin参数控制滤波器的放置位置。默认值为 0

morphological_gradientn 维数组

input的形态学梯度。

另请参阅

grey_dilation, grey_erosion, gaussian_gradient_magnitude

注释

对于平坦的结构元素，给定点处计算的形态学梯度对应于由以该点为中心的结构元素覆盖的元素中的输入元素之间的最大差异。

参考资料

[1]

zh.wikipedia.org/wiki/数学形态学

示例

>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.zeros((7,7), dtype=int)
>>> a[2:5, 2:5] = 1
>>> ndimage.morphological_gradient(a, size=(3,3))
array([[0, 0, 0, 0, 0, 0, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 0, 1, 1, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [0, 0, 0, 0, 0, 0, 0]])
>>> # The morphological gradient is computed as the difference
>>> # between a dilation and an erosion
>>> ndimage.grey_dilation(a, size=(3,3)) -\
...  ndimage.grey_erosion(a, size=(3,3))
array([[0, 0, 0, 0, 0, 0, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 0, 1, 1, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [0, 0, 0, 0, 0, 0, 0]])
>>> a = np.zeros((7,7), dtype=int)
>>> a[2:5, 2:5] = 1
>>> a[4,4] = 2; a[2,3] = 3
>>> a
array([[0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 3, 1, 0, 0],
 [0, 0, 1, 1, 1, 0, 0],
 [0, 0, 1, 1, 2, 0, 0],
 [0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0]])
>>> ndimage.morphological_gradient(a, size=(3,3))
array([[0, 0, 0, 0, 0, 0, 0],
 [0, 1, 3, 3, 3, 1, 0],
 [0, 1, 3, 3, 3, 1, 0],
 [0, 1, 3, 2, 3, 2, 0],
 [0, 1, 1, 2, 2, 2, 0],
 [0, 1, 1, 2, 2, 2, 0],
 [0, 0, 0, 0, 0, 0, 0]])

`scipy.ndimage.morphological_laplace`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.morphological_laplace.html#scipy.ndimage.morphological_laplace

scipy.ndimage.morphological_laplace(input, size=None, footprint=None, structure=None, output=None, mode='reflect', cval=0.0, origin=0)

多维形态拉普拉斯。

参数：

输入array_like

输入。

大小int 或 int 序列，可选

见结构。

足迹bool 或 ndarray，可选

见结构。

结构structure，可选

必须提供size、footprint或structure中的一个。

输出ndarray，可选

可以选择提供输出数组。

模式{‘reflect’,’constant’,’nearest’,’mirror’, ‘wrap’}，可选

参数mode决定了如何处理数组边界。对于‘constant’模式，超出边界的值将被设为cval。默认为‘reflect’。

cval标量，可选

如果mode为‘constant’，则用于填充输入的边缘的值。默认为 0.0。

原点origin，可选

原点参数控制滤波器的放置位置。

形态拉普拉斯ndarray

输出

`scipy.ndimage.white_tophat`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.white_tophat.html#scipy.ndimage.white_tophat

scipy.ndimage.white_tophat(input, size=None, footprint=None, structure=None, output=None, mode='reflect', cval=0.0, origin=0)

多维白顶帽滤波器。

参数：

input数组形式

输入。

size整数元组

用于滤波器的平坦且完整的结构元素的形状。如果提供footprint或structure，则为可选。

footprint整数数组，可选

用于白顶帽滤波器的平坦结构元素的元素位置。

structure整数数组，可选

用于滤波器的结构元素。structure可以是非平坦的结构元素。

output数组，可选

可以提供用于存储滤波器输出的数组。

mode{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}，可选

参数mode决定如何处理数组边界，其中cval是 mode 等于'constant'时的值。默认为'reflect'。

cval标量，可选

当mode为'constant'时，用于填充输入边缘之外的值。默认为 0.0。

origin标量，可选

参数origin控制滤波器的放置位置。默认为 0。

outputndarray

使用structure对input的滤波器结果。

参见

black_tophat

示例

从亮峰中减去灰色背景。

>>> from scipy.ndimage import generate_binary_structure, white_tophat
>>> import numpy as np
>>> square = generate_binary_structure(rank=2, connectivity=3)
>>> bright_on_gray = np.array([[2, 3, 3, 3, 2],
...                            [3, 4, 5, 4, 3],
...                            [3, 5, 9, 5, 3],
...                            [3, 4, 5, 4, 3],
...                            [2, 3, 3, 3, 2]])
>>> white_tophat(input=bright_on_gray, structure=square)
array([[0, 0, 0, 0, 0],
 [0, 0, 1, 0, 0],
 [0, 1, 5, 1, 0],
 [0, 0, 1, 0, 0],
 [0, 0, 0, 0, 0]])

Orthogonal distance regression (`scipy.odr`)

Original text：docs.scipy.org/doc/scipy-1.12.0/reference/odr.html

Package Content

`Data`(x[, y, we, wd, fix, meta])	要拟合的数据。
`RealData`(x[, y, sx, sy, covx, covy, fix, meta])	数据，带有实际标准偏差和/或协方差作为加权。
`Model`(fcn[, fjacb, fjacd, extra_args, ...])	存储关于您希望拟合的函数的信息的 Model 类。
`ODR`(data, model[, beta0, delta0, ifixb, ...])	ODR 类汇总所有信息并协调主拟合例程的运行。
`Output`(output)	Output 类存储 ODR 运行的输出。
`odr`(fcn, beta0, y, x[, we, wd, fjacb, ...])	ODR 的底层函数。
`OdrWarning`	警告指示传递到 ODR 的数据在传递到 'odr' 时可能会引起问题，用户应该注意。
`OdrError`	拟合中出现错误的异常。
`OdrStop`	停止拟合的异常。
`polynomial`(order)	通用多项式模型的工厂函数。
`exponential`	指数模型
`multilinear`	任意维度线性模型
`unilinear`	单变量线性模型
`quadratic`	二次模型

Usage information

Introduction

为什么要使用正交距离回归（ODR）？有时解释变量（即“自变量”）存在测量误差，而不仅仅是响应变量（即“因变量”）。普通最小二乘（OLS）拟合程序将解释变量的数据视为固定的，即不受任何误差的影响。此外，OLS 程序要求响应变量是解释变量的显式函数；有时使方程显式化是不切实际的和/或会引入误差。ODR 可以轻松处理这两种情况，甚至可以在问题仅需 OLS 的情况下简化处理。

ODRPACK 是一个用于执行可能非线性拟合函数的 FORTRAN-77 库。它使用修改的信赖域 Levenberg-Marquardt 类型算法[1]来估计函数参数。拟合函数由操作 NumPy 数组的 Python 函数提供。所需的导数也可以由 Python 函数提供，或者可以通过数值方法估计。ODRPACK 可以进行显式或隐式 ODR 拟合，或者可以进行 OLS 拟合。输入和输出变量可以是多维的。可以提供权重以考虑观测值的不同方差，甚至可以考虑变量维度之间的协方差。

scipy.odr 包提供了对 ODRPACK 的面向对象接口，除了低级别的 odr 函数。

有关 ODRPACK 的更多背景信息，请参阅ODRPACK 用户指南，推荐阅读。

基本用法

定义要拟合的函数。

def f(B, x):
  '''Linear function y = m*x + b'''
    # B is a vector of the parameters.
    # x is an array of the current x values.
    # x is in the same format as the x passed to Data or RealData.
    #
    # Return an array in the same format as y passed to Data or RealData.
    return B[0]*x + B[1]

创建模型。
```
linear = Model(f) 
```

创建 Data 或 RealData 实例。

mydata = Data(x, y, wd=1./power(sx,2), we=1./power(sy,2))

或者，当实际协方差已知时：

mydata = RealData(x, y, sx=sx, sy=sy)

使用您的数据、模型和初始参数估计来实例化 ODR。
```
myodr = ODR(mydata, linear, beta0=[1., 2.]) 
```
运行拟合。
```
myoutput = myodr.run() 
```
检查输出。
```
myoutput.pprint() 
```

参考文献

[1]

P. T. Boggs 和 J. E. Rogers，在《测量误差模型的统计分析及其应用：1989 年 6 月 10 日至 16 日举行的 AMS-IMS-SIAM 联合暑期研究会议会议录》中，"Orthogonal Distance Regression"一文中讨论了“正交距离回归”，出自《当代数学》，第 112 卷，第 186 页，1990 年。

`scipy.odr.Data`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.Data.html#scipy.odr.Data

class scipy.odr.Data(x, y=None, we=None, wd=None, fix=None, meta=None)

要拟合的数据。

参数：

xarray_like

回归的自变量的观察数据

yarray_like，可选

如果是类数组，用于回归的因变量的观察数据。标量输入意味着要在数据上使用的模型是隐含的。

wearray_like，可选

如果 we 是一个标量，则该值将用于所有数据点（以及响应变量的所有维度）。如果 we 是长度为 q 的秩为 1 的数组（响应变量的维度），则该向量是所有数据点的协变权重矩阵的对角线。如果 we 是长度为 n 的秩为 1 的数组（数据点的数量），则第 i 个元素是第 i 个响应变量观测的权重（仅适用于单维度）。如果 we 是形状为 (q, q) 的秩为 2 的数组，则这是广播到每个观测的完整协变权重矩阵。如果 we 是形状为 (q, n) 的秩为 2 的数组，则 we[:,i] 是第 i 个观测的协变权重矩阵的对角线。如果 we 是形状为 (q, q, n) 的秩为 3 的数组，则 we[:,:,i] 是每个观测的协变权重矩阵的完整规格。如果拟合是隐含的，则只使用正标量值。

wdarray_like，可选

如果 wd 是一个标量，则该值将用于所有数据点（以及输入变量的所有维度）。如果 wd = 0，则每个观测的协变权重矩阵被设置为单位矩阵（因此每个观测的每个维度具有相同的权重）。如果 wd 是长度为 m 的秩为 1 的数组（输入变量的维度），则该向量是所有数据点的协变权重矩阵的对角线。如果 wd 是长度为 n 的秩为 1 的数组（数据点的数量），则第 i 个元素是第 i 个输入变量观测的权重（仅适用于单维度）。如果 wd 是形状为 (m, m) 的秩为 2 的数组，则这是广播到每个观测的完整协变权重矩阵。如果 wd 是形状为 (m, n) 的秩为 2 的数组，则 wd[:,i] 是第 i 个观测的协变权重矩阵的对角线。如果 wd 是形状为 (m, m, n) 的秩为 3 的数组，则 wd[:,:,i] 是每个观测的协变权重矩阵的完整规格。

fixarray_like 的整数，可选

fix 参数与 ODR 类中的 ifixx 相同。它是一个整数数组，与数据 x 具有相同的形状，用于确定哪些输入观测被视为固定。可以使用长度为 m 的序列（输入观测的维度）来为所有观测固定一些维度。值为 0 表示固定观测，值 > 0 表示自由观测。

metadict，可选

自由格式的元数据字典。

注释

每个参数都附加到相同名称的实例成员。 x 和 y 的结构在 Model 类的文档字符串中有描述。如果 y 是整数，则 Data 实例仅可用于适应响应维度等于 y 指定值的隐式模型。

we 参数加权响应变量偏差对拟合的影响。 wd 参数加权输入变量偏差对拟合的影响。为了方便处理多维输入和响应，这些参数的结构首先具有第 n 维轴。这些参数大量使用 ODRPACK 的结构化参数功能，以方便和灵活地支持所有选项。有关这些权重在算法中的使用方式的完整说明，请参见 ODRPACK 用户指南。基本上，对于特定数据点的权重值更高会使该点处的偏差对拟合更具有破坏性。

方法

`set_meta`(**kwds)	使用关键字和数据更新元数据字典。

`scipy.odr.RealData`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.RealData.html#scipy.odr.RealData

class scipy.odr.RealData(x, y=None, sx=None, sy=None, covx=None, covy=None, fix=None, meta=None)

数据，带有实际标准偏差和/或协方差的权重。

参数：

xarray_like

回归自变量的观测数据

yarray_like, optional

如果是类似数组，则是回归因变量的观测数据。标量输入意味着数据上的模型是隐含的。

sxarray_like, optional

x 的标准偏差。sx 是 x 的标准偏差，通过将其平方的倒数来转换为权重。

syarray_like, optional

y 的标准偏差。sy 是 y 的标准偏差，通过将其平方的倒数来转换为权重。

covxarray_like, optional

covx 的协方差矩阵是 x 的协方差矩阵的数组，并通过对每个观测的协方差矩阵进行矩阵求逆来转换为权重。

covyarray_like, optional

covy 的协方差矩阵是一个数组，并通过对每个观测的协方差矩阵进行矩阵求逆来转换为权重。

fixarray_like, optional

参数和成员修复与 Data.fix 和 ODR.ifixx 相同：它是一个与 x 具有相同形状的整数数组，决定哪些输入观测被视为固定。可以使用长度为 m（输入观测的维度）的序列来固定所有观测的某些维度。值为 0 表示固定观测，值 > 0 表示自由观测。

metadict, optional

自由形式的元数据字典。

注释

权重 wd 和 we 从提供的值计算而来，计算方法如下：

sx 和 sy 通过将其平方的倒数来转换为权重。例如，wd = 1./numpy.power(`sx`, 2)。

covx 和 covy 是协方差矩阵的数组，并通过对每个观测的协方差矩阵进行矩阵求逆来转换为权重。例如，we[i] = numpy.linalg.inv(covy[i])。

这些参数遵循与 wd 和 we 相同的结构化参数约定：sx 和 sy 的性质只受限于它们的自然属性：sx 和 sy 不能是三阶的，但 covx 和 covy 可以。

只设置 sx 或 covx（不能同时设置）。同时设置将引发异常。sy 和 covy 亦如此。

方法

`set_meta`(**kwds)	使用关键词提供的关键词和数据更新元数据字典。

`scipy.odr.Model`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.Model.html#scipy.odr.Model

class scipy.odr.Model(fcn, fjacb=None, fjacd=None, extra_args=None, estimate=None, implicit=0, meta=None)

Model 类存储了您希望拟合的函数的信息。

它至少存储函数本身，并可选地存储用于拟合期间计算的雅可比函数。此外，可以提供一个函数，该函数将根据给定的数据集可能提供合理的拟合参数起始值。

参数：

fcn函数

fcn(beta, x) –> y

fjacb函数

对 fcn 关于拟合参数 beta 的雅可比矩阵。

fjacb(beta, x) –> @f_i(x,B)/@B_j

fjacd函数

对 fcn 关于（可能是多维的）输入变量的雅可比矩阵。

fjacd(beta, x) –> @f_i(x,B)/@x_j

额外参数元组，可选

如果指定，extra_args 应为传递给 fcn、fjacb 和 fjacd 的额外参数元组。每个将通过 apply(fcn, (beta, x) + extra_args) 调用。

估计秩-1 的数组类型

提供从数据中估计的拟合参数。

estimate(data) –> estbeta

隐式布尔值

如果为 TRUE，指定模型是隐式的；即 fcn(beta, x) ~= 0，并且没有 y 数据进行拟合。

元字典，可选

模型的自由格式元数据字典

笔记

请注意，fcn、fjacb 和 fjacd 操作于 NumPy 数组并返回 NumPy 数组。 estimate 对象接受 Data 类的实例。

这里是回调函数的参数和返回数组形状的规则：

如果输入数据是单维的，则 x 是一个秩为 1 的数组；即 x = array([1, 2, 3, ...]); x.shape = (n,) 如果输入数据是多维的，则 x 是一个秩为 2 的数组；即 x = array([[1, 2, ...], [2, 4, ...]]); x.shape = (m, n) 在所有情况下，它与传递给 odr 的输入数据数组具有相同的形状。 m 是输入数据的维数， n 是观测值的数量。

如果响应变量是单维的，则 y 是一个秩为 1 的数组，即 y = array([2, 4, ...]); y.shape = (n,)。如果响应变量是多维的，则 y 是一个秩为 2 的数组，即 y = array([[2, 4, ...], [3, 6, ...]]); y.shape = (q, n)，其中 q 是响应变量的维数。

beta

长度为 p 的秩-1 数组，其中 p 是参数的数量；即 beta = array([B_1, B_2, ..., B_p])

fjacb

如果响应变量是多维的，则返回数组的形状是 (q, p, n)，其中 fjacb(x,beta)[l,k,i] = d f_l(X,B)/d B_k 在第 i 个数据点处求值。如果 q == 1，则返回数组仅为秩 2 且形状为 (p, n)。

fjacd

与 fjacb 类似，仅返回数组的形状为*(q, m, n)，使得fjacd(x,beta)[l,j,i] = d f_l(X,B)/d X_j在第 i 个数据点。如果q == 1*，则返回数组的形状为*(m, n)。如果m == 1*，则形状为(q, n)。如果m == q == 1，则形状为*(n,)*。

方法

`set_meta`(**kwds)	使用提供的关键词和数据更新元数据字典。

`scipy.odr.ODR`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.ODR.html#scipy.odr.ODR

class scipy.odr.ODR(data, model, beta0=None, delta0=None, ifixb=None, ifixx=None, job=None, iprint=None, errfile=None, rptfile=None, ndigit=None, taufac=None, sstol=None, partol=None, maxit=None, stpb=None, stpd=None, sclb=None, scld=None, work=None, iwork=None, overwrite=False)

ODR 类收集所有信息并协调主拟合程序的运行。

ODR 类的实例成员与初始化程序的参数名称相同。

参数：

dataData 类实例

Data 类的实例

modelModel 类实例

Model 类的实例

其他参数：

beta0秩-1 的 array_like

初始参数值的秩-1 序列。如果模型提供“estimate”函数来估算这些值，则可选。

delta0浮点数秩-1 的 array_like，可选

用于保存输入变量错误初始值的（双精度）浮点数数组。必须与 data.x 相同形状。

ifixb秩-1 整数的 array_like，可选

与 beta0 长度相同的整数序列，确定哪些参数被固定。值为 0 表示固定参数，值大于 0 表示参数自由。

ifixx与 data.x 形状相同的整数秩-1 array_like，可选

与 data.x 相同形状的整数数组，确定哪些输入观测值被视为固定。可以使用长度为 m（输入观测值的维数）的序列来为所有观测值固定一些维度。值为 0 表示固定观测值，值大于 0 表示自由观测值。

job整数，可选

告诉 ODRPACK 要执行的任务的整数。如果您非常需要在此设置该值，请参阅 ODRPACK 用户指南第 31 页。在初始化后使用 set_job 方法以获得更可读的界面。

iprint整数，可选

告诉 ODRPACK 要打印什么的整数。如果您非常需要在此设置该值，请参阅 ODRPACK 用户指南第 33-34 页。在初始化后使用 set_iprint 方法以获得更可读的界面。

errfile字符串，可选

用于打印 ODRPACK 错误的文件名。如果文件已存在，则会抛出错误。可以使用 overwrite 参数来防止这种情况。不要自行打开此文件！

rptfile字符串，可选

指定要打印 ODRPACK 摘要的文件名。如果文件已存在，则会抛出错误。可以使用 overwrite 参数来防止这种情况。不要自行打开此文件！

ndigit整数，可选

计算函数可靠位数的整数。

taufac浮点数，可选

指定初始信任域的浮点数。默认值为 1。初始信任域等于 taufac 乘以第一个计算的高斯-牛顿步长的长度。taufac 必须小于 1。

sstol浮点数，可选

指定收敛容差的浮点数，基于平方和的相对变化。默认值为 eps**(1/2)，其中 eps 是使得在计算机上进行双精度计算时，1 + eps > 1 的最小值。sstol 必须小于 1。

partolfloat，可选

指定基于估计参数的相对变化的收敛容差的浮点数。默认值对于显式模型是 eps**(2/3)，对于隐式模型是 eps**(1/3)。partol 必须小于 1。

maxitint，可选

指定要执行的最大迭代次数的整数。对于首次运行，maxit 是执行的总迭代次数，默认为 50。对于重新启动，maxit 是要执行的附加迭代次数，默认为 10。

stpbarray_like，可选

序列（len(stpb) == len(beta0)），用于相对步长大小以计算关于参数的有限差分导数。

stpd可选

数组（stpd.shape == data.x.shape 或 stpd.shape == (m,)），用于相对步长大小以计算关于输入变量误差的有限差分导数。如果 stpd 是长度为 m 的秩-1 数组（输入变量的维度），则这些值将广播到所有观测值。

sclbarray_like，可选

序列（len(stpb) == len(beta0)），用于参数的缩放因子。这些缩放因子的目的是将所有参数缩放到大约统一的范围内。如果未指定此参数，则通常会自动计算适当的缩放因子。如果自动过程出现问题，请自行指定。

scldarray_like，可选

数组（scld.shape == data.x.shape 或 scld.shape == (m,)）用于输入变量中errors的缩放因子。如果未提供，则这些因子将自动计算。如果 scld.shape == (m,)，则缩放因子将广播到所有观测值。

workndarray，可选

数组，用于保存双精度工作数据以供 ODRPACK 使用。在重新启动时，其取值为self.output.work。

iworkndarray，可选

数组，用于保存整数值工作数据以供 ODRPACK 使用。在重新启动时，其取值为self.output.iwork。

overwritebool，可选

如果为 True，则会覆盖errfile和rptfile定义的输出文件。默认值为 False。

属性：

dataData

用于此拟合的数据

modelModel

用于拟合的模型

outputOutput

包含从 ODR.run()或 ODR.restart()调用返回的所有数据的 Output 类的实例

方法

`restart`	使用更多迭代次数重新启动运行。
`run`	使用给定的所有信息运行拟合程序，并使用`full_output=1`。
`set_iprint`	设置 iprint 参数以打印计算报告。
`set_job`	以希望易于理解的方式设置“job”参数。

`scipy.odr.Output`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.Output.html#scipy.odr.Output

class scipy.odr.Output(output)

Output 类存储了 ODR 运行的输出结果。

注释

接受一个初始化参数，即来自函数 odr 的返回值。如果 odr 设置为 full_output=1，则上述标注为“可选”的属性才会存在。

属性：

beta ndarray

估计参数值，形状为 (q,) 的数组。

sd_beta ndarray

估计参数的标准偏差，形状为 (p,)。

cov_beta ndarray

估计参数的协方差矩阵，形状为 (p,p)。注意 cov_beta 未按残差方差 res_var 缩放，而 sd_beta 是。这意味着 np.sqrt(np.diag(output.cov_beta * output.res_var)) 和 output.sd_beta 得到的结果相同。

delta ndarray，可选

与 x 相同形状的输入变量估计误差数组。

eps ndarray，可选

与 y 相同形状的响应变量估计误差数组。

xplus ndarray，可选

x + delta 的数组。

y ndarray，可选

数组 y = fcn(x + delta)。

res_var 浮点数，可选

残差方差。

sum_square 浮点数，可选

误差平方和。

sum_square_delta 浮点数，可选

误差 δ 的平方和。

sum_square_eps 浮点数，可选

误差 eps 的平方和。

inv_condnum 浮点数，可选

条件数的倒数（参见 ODRPACK UG 第 77 页）。

rel_error 浮点数，可选

在 fcn 内计算的函数值相对误差。

work ndarray，可选

最终工作数组。

work_ind 字典，可选

用于提取数值的 work 的索引（参见 ODRPACK UG 第 83 页）。

info 整数，可选

ODRPACK 返回的原因（参见 ODRPACK UG 第 38 页）。

stopreason 字符串列表，可选

info 被解释成英文。

方法

`pprint`()	精美打印重要结果。

`scipy.odr.odr`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/odr-function.html#scipy.odr.odr

scipy.odr.odr(fcn, beta0, y, x, we=None, wd=None, fjacb=None, fjacd=None, extra_args=None, ifixx=None, ifixb=None, job=0, iprint=0, errfile=None, rptfile=None, ndigit=0, taufac=0.0, sstol=-1.0, partol=-1.0, maxit=-1, stpb=None, stpd=None, sclb=None, scld=None, work=None, iwork=None, full_output=0)

ODR 的底层函数。

另请参阅

ODR

ODR 类收集所有信息并协调主要拟合例程的运行。

Model

Model 类存储关于您希望拟合的函数的信息。

Data

要拟合的数据。

RealData

数据与实际标准偏差和/或协方差的权重。

注释

这是一个执行与 ODR, Model, 和 Data 类相同操作的函数。此函数的参数在类文档中有解释。

`scipy.odr.OdrWarning`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.OdrWarning.html#scipy.odr.OdrWarning

exception scipy.odr.OdrWarning

警告表明传递给 ODR 的数据在传递给 'odr' 时会导致问题，用户应当注意。

with_traceback()

Exception.with_traceback(tb) – 设置 self.__traceback__ 为 tb 并返回 self。

`scipy.odr.OdrError`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.OdrError.html#scipy.odr.OdrError

exception scipy.odr.OdrError

表示拟合过程中出现的异常。

当拟合过程中发生错误时，odr 会引发此异常。

with_traceback()

Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。

`scipy.odr.OdrStop`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.OdrStop.html#scipy.odr.OdrStop

exception scipy.odr.OdrStop

异常停止拟合。

你可以在你的目标函数中引发这个异常，告诉odr停止拟合。

with_traceback()

Exception.with_traceback(tb) – 设置self.__traceback__为tb并返回self。

`scipy.odr.polynomial`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.polynomial.html#scipy.odr.polynomial

scipy.odr.polynomial(order)

工厂函数用于创建一个通用的多项式模型。

参数：

order整数或序列

如果是一个整数，它将成为要拟合的多项式的阶数。如果是一个数字序列，那么这些数字将是多项式中的显式幂。始终包含一个常数项（幂为 0），因此不要包含 0。因此，polynomial(n)等同于 polynomial(range(1, n+1))。

polynomial模型实例

模型实例。

示例

我们可以使用正交距离回归（ODR）来拟合输入数据，使用一个多项式模型：

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy import odr
>>> x = np.linspace(0.0, 5.0)
>>> y = np.sin(x)
>>> poly_model = odr.polynomial(3)  # using third order polynomial model
>>> data = odr.Data(x, y)
>>> odr_obj = odr.ODR(data, poly_model)
>>> output = odr_obj.run()  # running ODR fitting
>>> poly = np.poly1d(output.beta[::-1])
>>> poly_y = poly(x)
>>> plt.plot(x, y, label="input data")
>>> plt.plot(x, poly_y, label="polynomial ODR")
>>> plt.legend()
>>> plt.show()

../../_images/scipy-odr-polynomial-1.png

`scipy.odr.exponential`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.exponential.html#scipy.odr.exponential

scipy.odr.exponential = <scipy.odr._models._ExponentialModel object>

指数模型

这个模型由公式 (y=\beta_0 + e^{\beta_1 x}) 定义。

示例

我们可以使用指数模型计算正交距离回归：

>>> from scipy import odr
>>> import numpy as np
>>> x = np.linspace(0.0, 5.0)
>>> y = -10.0 + np.exp(0.5*x)
>>> data = odr.Data(x, y)
>>> odr_obj = odr.ODR(data, odr.exponential)
>>> output = odr_obj.run()
>>> print(output.beta)
[-10\.    0.5]

`scipy.odr.multilinear`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.multilinear.html#scipy.odr.multilinear

scipy.odr.multilinear = <scipy.odr._models._MultilinearModel object>

任意维线性模型

这个模型的定义是 (y=\beta_0 + \sum_{i=1}^m \beta_i x_i)

示例

我们可以用任意维线性模型计算正交距离回归：

>>> from scipy import odr
>>> import numpy as np
>>> x = np.linspace(0.0, 5.0)
>>> y = 10.0 + 5.0 * x
>>> data = odr.Data(x, y)
>>> odr_obj = odr.ODR(data, odr.multilinear)
>>> output = odr_obj.run()
>>> print(output.beta)
[10\.  5.]

`scipy.odr.unilinear`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.unilinear.html#scipy.odr.unilinear

scipy.odr.unilinear = <scipy.odr._models._UnilinearModel object>

单变量线性模型

这个模型由 (y = \beta_0 x + \beta_1) 定义

示例

我们可以用单线性模型计算正交距离回归：

>>> from scipy import odr
>>> import numpy as np
>>> x = np.linspace(0.0, 5.0)
>>> y = 1.0 * x + 2.0
>>> data = odr.Data(x, y)
>>> odr_obj = odr.ODR(data, odr.unilinear)
>>> output = odr_obj.run()
>>> print(output.beta)
[1\. 2.]

`scipy.odr.quadratic`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.odr.quadratic.html#scipy.odr.quadratic

scipy.odr.quadratic = <scipy.odr._models._QuadraticModel object>

二次模型

此模型由 (y = \beta_0 x² + \beta_1 x + \beta_2) 定义

示例

我们可以使用二次模型计算正交距离回归：

>>> from scipy import odr
>>> import numpy as np
>>> x = np.linspace(0.0, 5.0)
>>> y = 1.0 * x ** 2 + 2.0 * x + 3.0
>>> data = odr.Data(x, y)
>>> odr_obj = odr.ODR(data, odr.quadratic)
>>> output = odr_obj.run()
>>> print(output.beta)
[1\. 2\. 3.]

优化和根查找（`scipy.optimize`）

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/optimize.html

SciPy optimize 提供了用于最小化（或最大化）目标函数的函数，可能受约束条件限制。它包括非线性问题的求解器（支持局部和全局优化算法）、线性规划、约束和非线性最小二乘法、根查找和曲线拟合。

不同求解器共享的常见函数和对象包括：

`show_options`([solver, method, disp])	显示优化求解器的附加选项文档。
`OptimizeResult`	表示优化结果。
`OptimizeWarning`

优化

标量函数优化

`minimize_scalar`(fun[, bracket, bounds, ...])	对一维标量函数进行局部最小化。

minimize_scalar 函数支持以下方法：

minimize_scalar(method=’brent’)
minimize_scalar(method=’bounded’)
minimize_scalar(method=’golden’)

本地（多变量）优化

`minimize`(fun, x0[, args, method, jac, hess, ...])	对一个或多个变量的标量函数进行最小化。

minimize 函数支持以下方法：

minimize(method=’Nelder-Mead’)
minimize(method=’Powell’)
minimize(method=’CG’)
minimize(method=’BFGS’)
minimize(method=’Newton-CG’)
minimize(method=’L-BFGS-B’)
minimize(method=’TNC’)
minimize(method=’COBYLA’)
minimize(method=’SLSQP’)
minimize(method=’trust-constr’)
minimize(method=’dogleg’)
minimize(method=’trust-ncg’)
minimize(method=’trust-krylov’)
minimize(method=’trust-exact’)

约束以单个对象或来自以下类的对象列表形式传递给minimize函数：

`NonlinearConstraint`(fun, lb, ub[, jac, ...])	变量的非线性约束。
`LinearConstraint`(A[, lb, ub, keep_feasible])	变量的线性约束。

简单的边界约束分别处理，并且有一个专门的类：

`Bounds`([lb, ub, keep_feasible])	变量的边界约束。

实现HessianUpdateStrategy接口的拟牛顿策略可用于在minimize函数中近似黑塞矩阵（仅适用于“trust-constr”方法）。实现此接口的可用拟牛顿方法包括：

`BFGS`([exception_strategy, min_curvature, ...])	BFGS（Broyden-Fletcher-Goldfarb-Shanno）海森更新策略。
`SR1`([min_denominator, init_scale])	对称秩-1 海森更新策略。

全局优化

`basinhopping`(func, x0[, niter, T, stepsize, ...])	使用盆地跳跃算法找到函数的全局最小值。
`brute`(func, ranges[, args, Ns, full_output, ...])	通过蛮力法在给定范围内最小化函数。
`differential_evolution`(func, bounds[, args, ...])	多元函数的全局最小值。
`shgo`(func, bounds[, args, constraints, n, ...])	使用 SHG 优化找到函数的全局最小值。
`dual_annealing`(func, bounds[, args, ...])	使用双退火法找到函数的全局最小值。
`direct`(func, bounds, *[, args, eps, maxfun, ...])	使用 DIRECT 算法寻找函数的全局最小值。

最小二乘和曲线拟合

非线性最小二乘

`least_squares`(fun, x0[, jac, bounds, ...])	解决带有变量边界的非线性最小二乘问题。

线性最小二乘

`nnls`(A, b[, maxiter, atol])	解决 `argmin_x		Ax - b		_2`且`x>=0`。
`lsq_linear`(A, b[, bounds, method, tol, ...])	解决带有变量边界的线性最小二乘问题。
`isotonic_regression`(y, *[, weights, increasing])	非参数等距回归。

曲线拟合

`curve_fit`(f, xdata, ydata[, p0, sigma, ...])	使用非线性最小二乘拟合函数 `f` 到数据。

根查找

标量函数

`root_scalar`(f[, args, method, bracket, ...])	寻找标量函数的根。
`brentq`(f, a, b[, args, xtol, rtol, maxiter, ...])	使用 Brent 方法在一个区间内寻找函数的根。
`brenth`(f, a, b[, args, xtol, rtol, maxiter, ...])	使用 Brent 方法及双曲线外推在一个区间内寻找函数的根。
`ridder`(f, a, b[, args, xtol, rtol, maxiter, ...])	使用 Ridder 方法在一个区间内寻找函数的根。
`bisect`(f, a, b[, args, xtol, rtol, maxiter, ...])	使用二分法在一个区间内寻找函数的根。
`newton`(func, x0[, fprime, args, tol, ...])	使用牛顿-拉弗森（或割线或哈雷）方法寻找实数或复数函数的根。
`toms748`(f, a, b[, args, k, xtol, rtol, ...])	使用 TOMS 算法 748 方法寻找根。
`RootResults`(root, iterations, ...)	表示根查找结果。

root_scalar 函数支持以下方法：

root_scalar(method=’brentq’)
root_scalar(method=’brenth’)
root_scalar(method=’bisect’)
root_scalar(method=’ridder’)
root_scalar(method=’newton’)
root_scalar(method=’toms748’)
root_scalar(method=’secant’)
root_scalar(method=’halley’)

下表列出了情况及适当的方法，以及每次迭代（和每次函数评估）的渐近收敛率，以便成功收敛到简单根(*）。二分法是最慢的，每次函数评估增加一位有效数字，但保证收敛。其他括号法（最终）每次函数评估增加大约 50%的准确位数。基于导数的方法，都建立在newton上，如果初始值接近根，可以相当快速地收敛。它们也可应用于在复平面（的子集上）定义的函数。

函数域	是否括号化？	是否有导数？	求解器
fprime	fprime2	是否保证？	收敛率(*)
---	---	---	---
R	是	N/A	N/A

二分法
brentq
brenth
ridder
toms748

1 “线性”
=1, <= 1.62
=1, <= 1.62
2.0 (1.41)
2.7 (1.65)

R 或 C	否	否	否	切线法	否	1.62 (1.62)
R 或 C	否	是	否	牛顿法	否	2.00 (1.41)
R 或 C	否	是	是	亥姆法	否	3.00 (1.44)

另见

scipy.optimize.cython_optimize – Typed Cython 版本的根查找函数

寻找不动点：

`fixed_point`(func, x0[, args, xtol, maxiter, ...])	查找函数的不动点。

多维的

`root`(fun, x0[, args, method, jac, tol, ...])	查找向量函数的根。

root 函数支持以下方法：

root(method=’hybr’)
root(method=’lm’)
root(method=’broyden1’)
root(method=’broyden2’)
root(method=’anderson’)
root(method=’linearmixing’)
root(method=’diagbroyden’)
root(method=’excitingmixing’)
root(method=’krylov’)
root(method=’df-sane’)

线性规划 / MILP

`milp`(c, *[, integrality, bounds, ...])	混合整数线性规划
`linprog`(c[, A_ub, b_ub, A_eq, b_eq, bounds, ...])	线性规划：最小化线性目标函数，满足线性等式和不等式约束。

linprog 函数支持以下方法：

linprog(method=’simplex’)
linprog(method=’interior-point’)
linprog(method=’revised simplex’)
linprog(method=’highs-ipm’)
linprog(method=’highs-ds’)
linprog(method=’highs’)

简单法、内点法和修订单纯法方法支持回调函数，例如：

`linprog_verbose_callback`(res)	演示 linprog 回调接口的样本回调函数。

分配问题

`linear_sum_assignment`	解决线性求和分配问题。
`quadratic_assignment`(A, B[, method, options])	近似解决二次分配问题和图匹配问题。

quadratic_assignment 函数支持以下方法：

quadratic_assignment(method=’faq’)
quadratic_assignment(method=’2opt’)

实用工具

Finite-difference approximation

`approx_fprime`(xk, f[, epsilon])	标量或向量值函数的有限差分近似导数。
`check_grad`(func, grad, x0, *args[, epsilon, ...])	通过将其与梯度的（前向）有限差分近似比较，检查梯度函数的正确性。

线搜索：

`bracket`(func[, xa, xb, args, grow_limit, ...])	定位函数最小值的区间。
`line_search`(f, myfprime, xk, pk[, gfk, ...])	寻找满足强 Wolfe 条件的 alpha。

Hessian 近似：

`LbfgsInvHessProduct`(args, *kwargs)	L-BFGS 近似逆 Hessian 的线性算子。
`HessianUpdateStrategy`()	实现 Hessian 更新策略的接口。

基准问题：

`rosen`(x)	Rosenbrock 函数。
`rosen_der`(x)	Rosenbrock 函数的导数（即梯度）。
`rosen_hess`(x)	Rosenbrock 函数的 Hessian 矩阵。
`rosen_hess_prod`(x, p)	Rosenbrock 函数的 Hessian 矩阵与向量的乘积。

遗留函数：

下面的函数不建议在新脚本中使用；所有这些方法都可以通过提供的更新、更一致的接口访问。

优化：

通用多元方法：

`fmin`(func, x0[, args, xtol, ftol, maxiter, ...])	使用下降单纯形算法最小化函数。
`fmin_powell`(func, x0[, args, xtol, ftol, ...])	使用修改后的 Powell 方法最小化函数。
`fmin_cg`(f, x0[, fprime, args, gtol, norm, ...])	使用非线性共轭梯度算法最小化函数。
`fmin_bfgs`(f, x0[, fprime, args, gtol, norm, ...])	使用 BFGS 算法最小化函数。
`fmin_ncg`(f, x0, fprime[, fhess_p, fhess, ...])	使用牛顿-CG 方法无约束最小化函数。

约束多元方法：

`fmin_l_bfgs_b`(func, x0[, fprime, args, ...])	使用 L-BFGS-B 算法最小化函数 func。
`fmin_tnc`(func, x0[, fprime, args, ...])	使用截断牛顿算法最小化受界限约束的变量函数，并使用梯度信息。
`fmin_cobyla`(func, x0, cons[, args, ...])	使用线性逼近约束优化（COBYLA）方法最小化函数。
`fmin_slsqp`(func, x0[, eqcons, f_eqcons, ...])	使用顺序最小二乘规划（SLSQP）方法最小化函数。

单变量（标量）最小化方法：

`fminbound`(func, x1, x2[, args, xtol, ...])	标量函数的有界最小化。
`brent`(func[, args, brack, tol, full_output, ...])	给定一个变量函数和可能的区间，返回函数的局部最小化器，精确到 tol 的分数精度。
`golden`(func[, args, brack, tol, ...])	使用黄金分割法返回单变量函数的最小化器。

最小二乘

`leastsq`(func, x0[, args, Dfun, full_output, ...])	最小化一组方程的平方和。

根查找：

一般非线性求解器：

`fsolve`(func, x0[, args, fprime, ...])	找到函数的根。
`broyden1`(F, xin[, iter, alpha, ...])	使用布罗伊登第一雅可比逼近找到函数的根。
`broyden2`(F, xin[, iter, alpha, ...])	使用布罗伊登第二雅可比逼近找到函数的根。

大规模非线性求解器：

`newton_krylov`(F, xin[, iter, rdiff, method, ...])	使用 Krylov 逼近方法求解函数的根，用于逆雅可比矩阵。
`anderson`(F, xin[, iter, alpha, w0, M, ...])	使用（扩展的）安德森混合方法寻找函数的根。
`BroydenFirst`([alpha, reduction_method, max_rank])	使用 Broyden 第一雅可比逼近方法寻找函数的根。
`InverseJacobian`(jacobian)

属性：

`KrylovJacobian`([rdiff, method, ...])	使用 Krylov 逼近方法求解函数的根，用于逆雅可比矩阵。

简单迭代求解器：

`excitingmixing`(F, xin[, iter, alpha, ...])	使用调整的对角雅可比逼近方法寻找函数的根。
`linearmixing`(F, xin[, iter, alpha, verbose, ...])	使用标量雅可比逼近方法寻找函数的根。
`diagbroyden`(F, xin[, iter, alpha, verbose, ...])	使用对角 Broyden 雅可比逼近方法寻找函数的根。

`scipy.optimize.show_options`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.optimize.show_options.html#scipy.optimize.show_options

scipy.optimize.show_options(solver=None, method=None, disp=True)

显示优化求解器附加选项的文档。

这些是可以通过options字典提供的特定于方法的选项。

参数：

solverstr

优化求解器的类型。可为‘minimize’、‘minimize_scalar’、‘root’、‘root_scalar’、‘linprog’或‘quadratic_assignment’之一。

methodstr，可选

如果未指定，则显示指定求解器的所有方法。否则，仅显示指定方法的选项。有效值对应于相应求解器的方法名称（例如，‘minimize’的‘BFGS’）。

dispbool，可选

是否打印结果而非返回结果。

文本

为disp=True时为 None，否则为文本字符串（disp=False）。

注意

求解器特定的方法包括：

scipy.optimize.minimize

Nelder-Mead
Powell
CG
BFGS
Newton-CG
L-BFGS-B
TNC
COBYLA
SLSQP
dogleg
trust-ncg

scipy.optimize.root

hybr
lm
broyden1
broyden2
anderson
linearmixing
diagbroyden
excitingmixing
krylov
df-sane

scipy.optimize.minimize_scalar

brent
golden
bounded

scipy.optimize.root_scalar

bisect
brentq
brenth
ridder
toms748
newton
secant
halley

scipy.optimize.linprog

simplex
interior-point
revised simplex
highs
highs-ds
highs-ipm

scipy.optimize.quadratic_assignment

faq
2opt

Examples

我们可以在标准输出中打印求解器的文档：

>>> from scipy.optimize import show_options
>>> show_options(solver="minimize")
...

可以指定使用的方法：

>>> show_options(solver="minimize", method="Nelder-Mead")
...

我们也可以将文档作为字符串获取：

>>> show_options(solver="minimize", method="Nelder-Mead", disp=False)
Minimization of scalar function of one or more variables using the ...

`scipy.optimize.OptimizeResult`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.optimize.OptimizeResult.html#scipy.optimize.OptimizeResult

class scipy.optimize.OptimizeResult

表示优化结果。

注意事项

根据具体使用的求解器，OptimizeResult 可能不包含此处列出的所有属性，并且可能有其他未列出的属性。由于该类本质上是 dict 的子类，带有属性访问器，可以使用 OptimizeResult.keys 方法查看可用的属性。

属性：

xndarray

优化的解。

success布尔值

优化器是否成功退出。

status整数

优化器的终止状态。其值取决于底层求解器。详细信息请参考 message。

message字符串

终止原因的描述。

fun, jac, hess: ndarray

目标函数的值，其雅可比矩阵及海森矩阵的值（如果可用）。这些海森矩阵可能是近似值，请参阅相关函数的文档。

hess_inv对象

目标函数海森矩阵的逆；可能是一个近似值。并非所有求解器都支持。此属性的类型可以是 np.ndarray 或 scipy.sparse.linalg.LinearOperator。

nfev, njev, nhev整数

目标函数及其雅可比矩阵和海森矩阵的评估次数。

nit整数

优化器执行的迭代次数。

maxcv浮点数

最大约束违规。

方法

`__getitem__`	x.getitem(y) <==> x[y]
`__len__`(/)	返回 len(self)。
`clear`()
`copy`()
`fromkeys`(iterable[, value])	使用来自 iterable 的键创建一个新字典，并将值设置为 value。
`get`(key[, default])	如果字典中存在键 key，则返回其对应的值，否则返回默认值。
`items`()
`keys`()
`pop`(key[, default])	如果未找到 key，则如果提供了 default，则返回 default，否则引发 KeyError 异常。
`popitem`(/)	移除并返回一个(key, value)对，作为一个二元组。
`setdefault`(key[, default])	如果 key 不在字典中，则将 key 插入，并将其值设置为 default。
`update`([E, ]**F)	如果 E 存在并且具有.keys()方法，则执行：对于 k 在 E 中：D[k] = E[k] 如果 E 存在但没有.keys()方法，则执行：对于 k, v 在 E 中：D[k] = v 在任一情况下，随后执行：对于 k 在 F 中：D[k] = F[k]
`values`()

`scipy.optimize.OptimizeWarning`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.optimize.OptimizeWarning.html#scipy.optimize.OptimizeWarning

exception scipy.optimize.OptimizeWarning

with_traceback()

Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。

`scipy.optimize.minimize_scalar`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.optimize.minimize_scalar.html#scipy.optimize.minimize_scalar

scipy.optimize.minimize_scalar(fun, bracket=None, bounds=None, args=(), method=None, tol=None, options=None)

标量函数的局部最小化。

参数：

fun可调用对象

目标函数。标量函数，必须返回一个标量。

bracket序列，可选

对于方法‘brent’和‘golden’，bracket定义了锁定间隔并且是必需的。可以是三元组(xa, xb, xc)，满足xa < xb < xc和func(xb) < func(xa) and func(xb) < func(xc)，或者是一对(xa, xb)，用于进行下山锁定搜索的初始点（参见scipy.optimize.bracket）。最小化器res.x不一定满足xa <= res.x <= xb。

bounds序列，可选

对于方法‘bounded’，bounds是必须的，必须有两个有限项与优化边界相对应。

args元组，可选

传递给目标函数的额外参数。

method字符串或可调用对象，可选

求解器类型。应为以下之一：

Brent

Bounded

Golden

自定义 - 可调用对象（从版本 0.14.0 开始添加），请参见下文

如果提供了边界，则默认为“Bounded”，否则为“Brent”。有关每个求解器的详细信息，请参见‘Notes’部分。

tol浮点数，可选

终止容差。要进行详细控制，请使用特定于解算器的选项。

options字典，可选

求解器选项的字典。

maxiterint

最大迭代次数。

dispbool

设置为 True 以打印收敛消息。

请参阅show_options以获取特定于解算器的选项。

resOptimizeResult

表示优化结果的OptimizeResult对象。重要属性包括：x解决方案数组，success指示优化器是否成功退出的布尔标志，message描述终止原因。参见OptimizeResult以获取其他属性的描述。

另请参见

minimize

用于标量多变量函数的最小化算法接口

show_options

解算器接受的额外选项

注意事项

本节描述了可以通过“method”参数选择的可用求解器。如果传递了bounds，默认方法是"Bounded" Brent 方法；否则是无界的"Brent"方法。

方法 Brent 使用 Brent 算法 [1] 寻找局部最小值。在可能的情况下，该算法使用反向抛物插值来加速黄金分割法的收敛速度。

方法 Golden 使用黄金分割搜索技术 [1]。它使用二分法的类似物来缩小括号内的区间。通常优先选择使用Brent方法。

方法 Bounded 可以执行有界最小化 [2] [3]。它使用 Brent 方法在区间 x1 < xopt < x2 中找到局部最小值。

注意，除非提供了有效的bracket三元组，否则 Brent 和 Golden 方法不能保证成功。如果无法找到三点括号，请考虑使用scipy.optimize.minimize。此外，所有方法仅用于局部最小化。当感兴趣的函数具有多个局部最小值时，请考虑全局优化。

自定义最小化器

当使用一些库的前端来进行minimize_scalar时，传递自定义最小化方法可能很有用。您可以简单地将一个可调用对象作为method参数传递。

可调用对象的调用形式为method(fun, args, **kwargs, **options)，其中kwargs对应于传递给minimize的其他参数（如bracket、tol等），除了options字典，其内容也会一对一地作为method参数传递。该方法应返回一个OptimizeResult对象。

提供的method可调用对象必须能够接受（并可能忽略）任意参数；由于minimize接受的参数集在将来版本中可能会扩展，这些参数也将一一传递给方法。您可以在 scipy.optimize 教程中找到一个例子。

版本 0.11.0 中的新功能。

参考文献

[1] (1,2)

Press, W., S.A. Teukolsky, W.T. Vetterling, and B.P. Flannery. Numerical Recipes in C. Cambridge University Press.

[2]

Forsythe, G.E., M. A. Malcolm, and C. B. Moler. “Mathematical Computations 的计算机方法。” Prentice-Hall Series in Automatic Computation 259 (1977).

[3]

Brent, Richard P. Algorithms for Minimization Without Derivatives. Courier Corporation, 2013.

示例

考虑最小化以下函数的问题。

>>> def f(x):
...     return (x - 2) * x * (x + 2)**2

使用Brent方法，我们找到了局部最小值如下：

>>> from scipy.optimize import minimize_scalar
>>> res = minimize_scalar(f)
>>> res.fun
-9.9149495908

最小化器是：

>>> res.x
1.28077640403

使用Bounded方法，我们找到了具有指定边界的局部最小值如下：

>>> res = minimize_scalar(f, bounds=(-3, -1), method='bounded')
>>> res.fun  # minimum
3.28365179850e-13
>>> res.x  # minimizer
-2.0000002026

`scipy.optimize.minimize`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize

scipy.optimize.minimize(fun, x0, args=(), method=None, jac=None, hess=None, hessp=None, bounds=None, constraints=(), tol=None, callback=None, options=None)

最小化一个或多个变量的标量函数。

参数：

fun 可调用对象

要最小化的目标函数。

fun(x, *args) -> float

其中 x 是形状为 (n,) 的一维数组，args 是一个元组，包含完全指定函数所需的固定参数。

x0 数组，形状为 (n,)

初始猜测。大小为 (n,) 的实数元素数组，其中 n 是独立变量的数量。

args 元组，可选

传递给目标函数及其导数（fun、jac 和 hess 函数）的额外参数。

method 字符串或可调用对象，可选

求解器的类型。应为以下之一：

‘Nelder-Mead’ (详见此处)

‘Powell’ (详见此处)

‘CG’ (详见此处)

‘BFGS’ (详见此处)

‘Newton-CG’ (详见此处)

‘L-BFGS-B’ (详见此处)

‘TNC’ (详见此处)

‘COBYLA’ (详见此处)

‘SLSQP’ (详见此处)

‘trust-constr’(详见此处)

‘dogleg’ (详见此处)

‘trust-ncg’ (详见此处)

‘trust-exact’ (详见此处)

‘trust-krylov’ (详见此处)

custom - 一个可调用对象，请参阅下文进行描述。

如果未提供，则根据问题是否有约束或边界选择 BFGS、L-BFGS-B、SLSQP 中的一种。

jac{callable, ‘2-point’, ‘3-point’, ‘cs’, bool}, optional

计算梯度向量的方法。仅适用于 CG、BFGS、Newton-CG、L-BFGS-B、TNC、SLSQP、dogleg、trust-ncg、trust-krylov、trust-exact 和 trust-constr。如果是可调用对象，则应为返回梯度向量的函数：

jac(x, *args) -> array_like, shape (n,)

其中 x 是形状为 (n,) 的数组，args 是具有固定参数的元组。如果 jac 是布尔值且为 True，则假定 fun 返回包含目标函数和梯度的元组 (f, g)。方法 ‘Newton-CG’、‘trust-ncg’、‘dogleg’、‘trust-exact’ 和 ‘trust-krylov’ 要求提供一个可调用对象，或者 fun 返回目标函数和梯度。如果为 None 或 False，则使用绝对步长进行二点有限差分估计梯度。或者，关键字 {‘2-point’、‘3-point’、‘cs’} 可用于选择用于数值梯度估计的有限差分方案，并使用相对步长。这些有限差分方案遵循任何指定的 bounds。

hess{可调用对象，‘2-point’，‘3-point’，‘cs’，HessianUpdateStrategy}，可选

计算 Hessian 矩阵的方法。仅适用于 Newton-CG、dogleg、trust-ncg、trust-krylov、trust-exact 和 trust-constr。如果是可调用对象，则应返回 Hessian 矩阵：

hess(x, *args) -> {LinearOperator, spmatrix, array}, (n, n)

其中 x 是形状为 (n,) 的 ndarray，args 是具有固定参数的元组。关键字 {‘2-point’、‘3-point’、‘cs’} 也可用于选择用于数值估计 Hessian 的有限差分方案。或者，实现 HessianUpdateStrategy 接口的对象可用于近似 Hessian。实现此接口的可用拟牛顿方法包括：

BFGS;

SR1。

并非每种方法都有所有选项；可参考注释中的可用性。

hessp可调用对象，可选

目标函数的 Hessian 矩阵乘以任意向量 p。仅适用于 Newton-CG、trust-ncg、trust-krylov、trust-constr。hessp 或 hess 之一需要提供。如果提供了 hess，则将忽略 hessp。hessp 必须计算 Hessian 乘以任意向量：

hessp(x, p, *args) -> ndarray 形状 (n,)

其中 x 是形状为 (n,) 的 ndarray，p 是维度为 (n,) 的任意向量，args 是具有固定参数的元组。

bounds序列或 Bounds，可选

变量的界限用于 Nelder-Mead、L-BFGS-B、TNC、SLSQP、Powell、trust-constr 和 COBYLA 方法。有两种指定界限的方式：

Bounds 类的实例。

对于 x 中的每个元素，(min, max) 对用于指定界限。使用 None 表示无界限。

约束{约束，字典} 或约束列表 {约束，字典}，可选

约束定义。仅适用于 COBYLA、SLSQP 和 trust-constr。

‘trust-constr’ 的约束被定义为一个单一对象或指定优化问题约束的对象列表。可用的约束类型包括：

LinearConstraint

NonlinearConstraint

对于 COBYLA、SLSQP，约束被定义为一个包含字段的字典列表：

typestr

约束类型：‘eq’ 表示等式约束，‘ineq’ 表示不等式约束。

funcallable

定义约束的函数。

jaccallable，可选

fun 的雅可比矩阵（仅适用于 SLSQP）。

argssequence，可选

传递给函数和雅可比矩阵的额外参数。

等式约束意味着约束函数的结果应为零，而不等式则意味着其应为非负。请注意，COBYLA 只支持不等式约束。

tolfloat，可选

终止容差。当指定 tol 时，所选的最小化算法设置一些相关的特定解算器容差为 tol。要进行详细的控制，请使用特定于解算器的选项。

optionsdict，可选

解算器选项的字典。除了 TNC 方法外，所有方法都接受以下通用选项：

maxiterint

执行的最大迭代次数。根据方法，每次迭代可能会使用多个函数评估。

对于 TNC 方法，请使用 maxfun 而不是 maxiter。

dispbool

设置为 True 以打印收敛消息。

对于特定方法的选项，请参见 show_options。

callbackcallable，可选

每次迭代后调用的可调用函数。

除了 TNC、SLSQP 和 COBYLA 方法之外的所有方法都支持具有以下签名的可调用函数：

callback(intermediate_result: OptimizeResult)

其中 intermediate_result 是一个关键字参数，包含一个 OptimizeResult，具有参数向量和目标函数当前值的属性。请注意，回调函数必须命名为 intermediate_result，以便传递一个 OptimizeResult。如果回调函数引发 StopIteration，这些方法也将终止。

除了 trust-constr 方法之外的所有方法都支持以下形式的签名：

callback(xk)

其中 xk 是当前的参数向量。

使用内省来确定要调用上述哪种签名。

resOptimizeResult

优化结果表示为 OptimizeResult 对象。重要属性包括：x 解数组，success 表示优化器是否成功退出的布尔标志，message 描述终止原因。请参阅 OptimizeResult 了解其他属性的描述。

参见

minimize_scalar 标量函数最小化接口。

标量单变量函数最小化算法接口

show_options 函数显示选项。

求解器接受的额外选项

注意事项

本节描述可以通过 'method' 参数选择的可用求解器。默认方法为 BFGS。

无约束最小化

方法 CG 使用 Polak 和 Ribiere 的非线性共轭梯度算法，是 Fletcher-Reeves 方法的变种，详见 [5] pp.120-122. 仅使用一阶导数。

方法 BFGS 使用 Broyden、Fletcher、Goldfarb 和 Shanno（BFGS）拟牛顿法 [5] pp. 136. 仅使用一阶导数。即使在非平滑优化中，BFGS 也表现良好。此方法还返回存储在 OptimizeResult 对象的 hess_inv 中的海森矩阵逆的近似值。

方法 Newton-CG 使用 Newton-CG 算法 [5] pp. 168（也称为截断牛顿法）。它使用共轭梯度方法计算搜索方向。参见 TNC 方法，该方法类似，但适用于有边界约束的最小化问题。适用于大规模问题。

方法 dogleg 使用狗腿信任域算法 [5] 进行无约束最小化。该算法需要梯度和海森矩阵；此外，海森矩阵要求正定。

方法 trust-ncg 使用牛顿共轭梯度信任域算法 [5] 进行无约束最小化。该算法需要梯度和海森矩阵或计算给定向量与海森矩阵乘积的函数。适用于大规模问题。

方法 trust-krylov 使用 Newton GLTR 信赖域算法[14]，[15]进行无约束最小化。此算法要求梯度和 Hessian 矩阵或计算给定向量与 Hessian 矩阵乘积的函数。适用于大规模问题。在不定问题上，通常比trust-ncg方法需要更少的迭代，推荐用于中等和大规模问题。

方法 trust-exact 是一种信赖域方法，用于无约束最小化，几乎完全解决二次子问题[13]。此算法要求梯度和 Hessian 矩阵（不要求为正定）。在许多情况下，这种方法收敛迭代较少，是小型和中型问题中最推荐的方法。

边界约束最小化

方法 Nelder-Mead 使用 Simplex 算法[1]，[2]。此算法在许多应用中表现稳健。但是，如果可以信任数值导数的计算，其他利用一阶和/或二阶导数信息的算法可能更适合于其在一般情况下的更好性能。

方法 L-BFGS-B 使用 L-BFGS-B 算法[6]，[7]进行边界约束最小化。

方法 Powell 是 Powell 方法的改进[3]，[4]，它是一种共轭方向方法。它沿着每个方向集合的每个向量（options和info中的direc字段）顺序进行一维最小化，每次主最小化循环迭代时更新。函数不需要可微，也不计算导数。如果未提供边界，则将使用无界线搜索。如果提供了边界，并且初始猜测在边界内，则最小化过程中的每个函数评估都将在边界内。如果提供了边界，初始猜测超出边界，并且direc具有完整秩（默认具有完整秩），则第一次迭代期间的某些函数评估可能超出边界，但第一次迭代后的每个函数评估都将在边界内。如果direc秩不完整，则某些参数可能不会被优化，并且不能保证解在边界内。

方法 TNC 使用截断牛顿算法[5], [8]来最小化带有变量界限的函数。此算法利用梯度信息；它也称为牛顿共轭梯度法。它与上述Newton-CG方法不同，因为它封装了 C 实现，并允许每个变量都有上限和下限。

约束最小化

方法 COBYLA 使用约束优化 BY 线性近似（COBYLA）方法[9], [10], [11]。该算法基于目标函数和每个约束的线性近似。该方法封装了该算法的 FORTRAN 实现。约束函数‘fun’可以返回单个数字或数字数组或列表。

方法 SLSQP 使用顺序最小二乘编程来最小化多变量函数，可以有各种边界、等式和不等式约束的组合。该方法封装了最初由 Dieter Kraft 实现的 SLSQP 优化子程序[12]。请注意，包装器通过将边界中的无限值转换为大浮点值来处理边界中的无限值。

方法 trust-constr 是一种用于约束优化的信赖域算法。它根据问题定义切换两种实现方式。这是 SciPy 中最通用的约束最小化算法，特别适用于大规模问题。对于等式约束问题，它是 Byrd-Omojokun 信赖域 SQP 方法的实现，详见[17]和[5]，第 549 页。当还有不等式约束时，它切换到信赖域内点法，详见[16]。这种内点算法通过引入松弛变量并解决一系列逐渐减小的约束问题，以逐步减小的障碍参数。先前描述的等式约束 SQP 方法用于解决越来越精确的子问题，因为迭代逐渐接近解决方案。

有限差分期权

对于方法 trust-constr ，可以使用三种有限差分方案来近似梯度和海森矩阵：{‘2-point’, ‘3-point’, ‘cs’}。方案 ‘cs’ 可能是最精确的，但它要求函数能够正确处理复杂输入并在复平面上可微分。方案 ‘3-point’ 比 ‘2-point’ 更精确，但需要两倍的操作。如果通过有限差分法估计梯度，则必须使用一种拟牛顿策略来估计海森矩阵。

关于 hess 关键字的方法特定选项

method/Hess	None	callable	‘2-point/’3-point’/’cs’	HUS
Newton-CG	x	(n, n) LO	x	x
dogleg		(n, n)
trust-ncg		(n, n)	x	x
trust-krylov		(n, n)	x	x
trust-exact		(n, n)
trust-constr	x	(n, n) LO sp	x	x

其中 LO=LinearOperator，sp=Sparse matrix，HUS=HessianUpdateStrategy

自定义最小化器

可能在使用此方法的前端（例如scipy.optimize.basinhopping）或其他库时，传递自定义的最小化方法可能很有用。您可以简单地将可调用对象作为method参数传递。

可调用对象被调用为 method(fun, x0, args, **kwargs, **options)，其中 kwargs 对应于传递给minimize的任何其他参数（如 callback, hess 等），除了 options 字典，其内容也会逐对传递为 method 参数。此外，如果 jac 被传递为布尔类型，则 jac 和 fun 将被篡改，使 fun 仅返回函数值，而 jac 被转换为返回雅可比矩阵的函数。该方法应返回一个OptimizeResult对象。

提供的 method 可调用对象必须能够接受（并可能忽略）任意参数；由于minimize接受的参数集可能会在未来版本中扩展，这些参数将被传递给该方法。您可以在 scipy.optimize 教程中找到一个示例。

参考文献

[1]

Nelder, J A 和 R Mead. 1965. 函数最小化的单纯形法。《计算机期刊》 7: 308-13.

[2]

Wright M H. 1996. 直接搜索方法：曾经被蔑视，现在倍受尊重，收录于《数值分析 1995：1995 年邓迪双年会数值分析会议论文集》（主编 D F Griffiths 和 G A Watson）。Addison Wesley Longman, Harlow, UK. 191-208.

[3]

Powell, M J D. 1964. 一种在不计算导数的情况下找到多变量函数最小值的高效方法。《计算机期刊》 7: 155-162.

[4]

Press W, S A Teukolsky, W T Vetterling 和 B P Flannery. Numerical Recipes（任何版本），剑桥大学出版社。

[5] (1,2,3,4,5,6,7,8)

Nocedal, J 和 S J Wright. 2006.数值优化。Springer New York。

[6]

Byrd, R H 和 P Lu 和 J. Nocedal. 1995.用于有界约束优化的有限内存算法。SIAM Journal on Scientific and Statistical Computing 16（5）：1190-1208。

[7]

Zhu, C 和 R H Byrd 和 J Nocedal. 1997. L-BFGS-B：算法 778：L-BFGS-B，FORTRAN 大规模有界约束优化的例程。ACM Transactions on Mathematical Software 23（4）：550-560。

[8]

Nash, S G. 通过 Lanczos 方法的牛顿型最小化。1984. SIAM Journal of Numerical Analysis 21：770-778。

[9]

Powell, M J D. 一种直接搜索优化方法，通过线性插值模拟目标和约束函数。1994.优化和数值分析进展，主编 S. Gomez 和 J-P Hennart，Kluwer Academic（Dordrecht），51-67。

[10]

Powell M J D. 用于优化计算的直接搜索算法。1998. Acta Numerica 7：287-336。

[11]

Powell M J D. 无导数优化算法概览。2007.剑桥大学技术报告 DAMTP 2007/NA03

[12]

Kraft, D. 用于顺序二次规划的软件包。1988. Tech. Rep. DFVLR-FB 88-28，DLR German Aerospace Center – Institute for Flight Mechanics，Koln，Germany。

[13]

Conn, A. R., Gould, N. I.,和 Toint, P. L. 信任区域方法。2000. Siam. pp. 169-200.

[14]

F. Lenders, C. Kirches, A. Potschka: “trlib：用于迭代解决信任区域问题的无向量实现”，arXiv:1611.04718

[15]

N. Gould, S. Lucidi, M. Roma, P. Toint: “使用 Lanczos 方法解决信任区域子问题”，SIAM J. Optim., 9(2), 504–525, (1999).

[16]

Byrd, Richard H., Mary E. Hribar 和 Jorge Nocedal. 1999.大规模非线性规划的内点算法。SIAM Journal on Optimization 9.4：877-900。

[17]

Lalee, Marucha，Jorge Nocedal 和 Todd Plantega. 1998.关于大规模等式约束优化算法的实现。SIAM Journal on Optimization 8.3：682-706。

例子

让我们考虑最小化 Rosenbrock 函数的问题。该函数（及其相应的导数）在rosen（分别在rosen_der，rosen_hess中实现）中。scipy.optimize。

>>> from scipy.optimize import minimize, rosen, rosen_der

Nelder-Mead方法的一个简单应用是：

>>> x0 = [1.3, 0.7, 0.8, 1.9, 1.2]
>>> res = minimize(rosen, x0, method='Nelder-Mead', tol=1e-6)
>>> res.x
array([ 1.,  1.,  1.,  1.,  1.])

现在使用BFGS算法，使用第一阶导数和一些选项：

>>> res = minimize(rosen, x0, method='BFGS', jac=rosen_der,
...                options={'gtol': 1e-6, 'disp': True})
Optimization terminated successfully.
 Current function value: 0.000000
 Iterations: 26
 Function evaluations: 31
 Gradient evaluations: 31
>>> res.x
array([ 1.,  1.,  1.,  1.,  1.])
>>> print(res.message)
Optimization terminated successfully.
>>> res.hess_inv
array([
 [ 0.00749589,  0.01255155,  0.02396251,  0.04750988,  0.09495377],  # may vary
 [ 0.01255155,  0.02510441,  0.04794055,  0.09502834,  0.18996269],
 [ 0.02396251,  0.04794055,  0.09631614,  0.19092151,  0.38165151],
 [ 0.04750988,  0.09502834,  0.19092151,  0.38341252,  0.7664427 ],
 [ 0.09495377,  0.18996269,  0.38165151,  0.7664427,   1.53713523]
])

接下来，考虑一个带有多个约束条件的最小化问题（即来自[5]的示例 16.4）。目标函数是：

>>> fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2

有三个定义为约束条件：

>>> cons = ({'type': 'ineq', 'fun': lambda x:  x[0] - 2 * x[1] + 2},
...         {'type': 'ineq', 'fun': lambda x: -x[0] - 2 * x[1] + 6},
...         {'type': 'ineq', 'fun': lambda x: -x[0] + 2 * x[1] + 2})

变量必须为正数，因此以下是界限：

>>> bnds = ((0, None), (0, None))

优化问题使用 SLSQP 方法求解如下：

>>> res = minimize(fun, (2, 0), method='SLSQP', bounds=bnds,
...                constraints=cons)

它应该收敛到理论解（1.4, 1.7）。

SciPy-1-12-中文文档-二十二-

SciPy 1.12 中文文档（二十二）

scipy.ndimage.grey_opening

scipy.ndimage.iterate_structure

scipy.ndimage.morphological_gradient

scipy.ndimage.morphological_laplace

scipy.ndimage.white_tophat

Orthogonal distance regression (scipy.odr)

Package Content

Usage information

Introduction

基本用法

参考文献

scipy.odr.Data

scipy.odr.RealData

scipy.odr.Model

scipy.odr.ODR

scipy.odr.Output

scipy.odr.odr

scipy.odr.OdrWarning

scipy.odr.OdrError

scipy.odr.OdrStop

scipy.odr.polynomial

scipy.odr.exponential

scipy.odr.multilinear

scipy.odr.unilinear

scipy.odr.quadratic

优化和根查找（scipy.optimize）

优化

标量函数优化

本地（多变量）优化

全局优化

最小二乘和曲线拟合

非线性最小二乘

线性最小二乘

曲线拟合

根查找

标量函数

多维的

线性规划 / MILP

分配问题

实用工具

Finite-difference approximation

线搜索：

Hessian 近似：

基准问题：

遗留函数：

优化：

最小二乘

根查找：

scipy.optimize.show_options

scipy.optimize.OptimizeResult

scipy.optimize.OptimizeWarning

scipy.optimize.minimize_scalar

scipy.optimize.minimize

`scipy.ndimage.grey_opening`

`scipy.ndimage.iterate_structure`

`scipy.ndimage.morphological_gradient`

`scipy.ndimage.morphological_laplace`

`scipy.ndimage.white_tophat`

Orthogonal distance regression (`scipy.odr`)

`scipy.odr.Data`

`scipy.odr.RealData`

`scipy.odr.Model`

`scipy.odr.ODR`

`scipy.odr.Output`

`scipy.odr.odr`

`scipy.odr.OdrWarning`

`scipy.odr.OdrError`

`scipy.odr.OdrStop`

`scipy.odr.polynomial`

`scipy.odr.exponential`

`scipy.odr.multilinear`

`scipy.odr.unilinear`

`scipy.odr.quadratic`

优化和根查找（`scipy.optimize`）

`scipy.optimize.show_options`

`scipy.optimize.OptimizeResult`

`scipy.optimize.OptimizeWarning`

`scipy.optimize.minimize_scalar`

`scipy.optimize.minimize`