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

本文简要介绍 python 语言中 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)#

使用非线性共轭梯度算法最小化函数。

参数 ：：

f： 可调用，f(x, *args)

要最小化的目标函数。这里 x 必须是在搜索最小值时要更改的变量的一维数组，而 args 是 f 的其他(固定)参数。

x0： ndarray

用户提供的 xopt 初始估计值，即 x 的最优值。它必须是一维值数组。

fprime： 可调用，fprime(x, *args)，可选

返回 f 在 x 处的梯度的函数。这里 x 和 args 与上面对 f 的说明相同。返回的值必须是一维数组。默认为 None，在这种情况下，梯度是数值近似的(参见下面的 epsilon)。

args： 元组，可选

传递给的参数值f和fprime.当需要额外的固定参数来完全指定函数时，必须提供f和fprime.

gtol： 浮点数，可选

当梯度的范数小于 gtol 时停止。

norm： 浮点数，可选

用于梯度范数的顺序(-np.inf 是最小值，np.inf 是最大值)。

epsilon： float 或 ndarray，可选

何时使用的步长fprime是数值近似的。可以是标量或一维数组。默认为sqrt(eps), 用 eps 表示浮点机器精度。通常sqrt(eps)约为 1.5e-8。

maxiter： 整数，可选

要执行的最大迭代次数。默认为 200 * len(x0) 。

full_output： 布尔型，可选

如果为 True，除了 xopt 之外，还返回 fopt、func_calls、grad_calls 和 warnflag。有关可选返回值的更多信息，请参阅下面的返回部分。

disp： 布尔型，可选

如果为 True，则返回收敛消息，然后是 xopt。

retall： 布尔型，可选

如果为 True，则将每次迭代的结果添加到返回值中。

callback： 可调用的，可选的

一个可选的用户提供的函数，在每次迭代后调用。称为callback(xk)，其中xk是的当前值x0.

c1： 浮点数，默认：1e-4

Armijo 条件规则的参数。

c2： 浮点数，默认值：0.4

曲率条件规则的参数。

返回 ：：

xopt： ndarray

最小化 f 的参数，即 f(xopt) == fopt 。

fopt： 浮点数，可选

找到最小值，f(xopt)。仅在 full_output 为 True 时返回。

func_calls： 整数，可选

function_calls 的数量。仅在 full_output 为 True 时返回。

grad_calls： 整数，可选

进行的梯度调用次数。仅在 full_output 为 True 时返回。

warnflag： 整数，可选

带有警告状态的整数值，仅在 full_output 为 True 时返回。

0：成功。

1：超过最大迭代次数。

2 梯度和/或函数调用没有改变。可能表明

该精度丢失了，即例程没有收敛。

3：遇到NaN 结果。

allvecs： ndarray 列表，可选

数组列表，包含每次迭代的结果。只有当retall 为True 时才返回。

注意：

这种共轭梯度算法基于 Polak 和 Ribiere [1] 的算法。

在以下情况下，共轭梯度方法往往效果更好：

1. f 具有唯一的全局最小化点，并且没有局部最小值或其他固定点，

2. f 至少是局部地，由变量的二次函数相当好地近似，

3. f 是连续的并且具有连续的梯度，

4. fprime 不太大，例如，范数小于 1000，

5. 初始猜测 x0 相当接近 f 的全局最小化点 xopt。

参数c1和c2必须满足0 < c1 < c2 < 1.

参考：

[1]

Wright & Nocedal，“Numerical Optimization”，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：使用scipy.optimize.minimize函数。 (这关注字典显示了所有可用的选项，尽管实际上只需要非默认值。返回的值将是一个字典。)

>>> 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])