【Scipy优化使用教程】一、Scipy中无约束优化的六大算法

最新推荐文章于 2024-05-17 11:57:42 发布
最新推荐文章于 2024-05-17 11:57:42 发布
阅读量1.7k 收藏 15
点赞数 1
分类专栏： 优化求解工具 文章标签： 算法 python 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_w_y/article/details/123054861
版权

参考官网：Scipy.

无约束的多变量标量函数的最小化

为解决多变量标量函数的无约束和有约束最小化问题，Scipy提供了minimize这个包。
考虑最小化N个变量的Rosenbrock函数的问题。(当所有x都等于1的时候，这个函数有最小值为0)

在这里插入图片描述

PS:Rosenbrock函数及其导数已经包含在scipy.optimize中。

以下各节所示的实现方式提供了如何定义目标函数、雅可比函数和黑塞函数的例子。

Nelder-Mead 算法(method=‘Nelder-Mead’)

import numpy as np
from scipy.optimize import minimize

def fun(x):
    """The Rosenbrock function"""
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)


#设立初始值
x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])

res = minimize(fun, x0, method='nelder-mead',options={'xatol': 1e-8, 'disp': True})

print(res.x)

计算结果

[1. 1. 1. 1. 1.]

对于一个很好求解的方程，这是最简单的方法，但不是最好的。它只需要函数评估，对于简单的最小化问题是一个不错的选择。但由于它不使用任何梯度评价，它可能需要更长的时间来找到最小值。

BFGS(method=‘BFGS’)

为了更快的收敛，应考虑目标函数的梯度。如果用户没有给出梯度，那么就用一阶差分进行近似。
Broyden-Fletcher-Goldfarb-Shanno (BFGS)方法通常比单纯的算法需要更少的函数调用(即使在必须估计梯度的情况下)。
还是使用Rosenbrock函数举例：
先对其求导：
在这里插入图片描述
在这里插入图片描述
首先用python写出这个导数：

def fun_d(x):
    xm = x[1:-1]
    xm_m1 = x[:-2]
    xm_p1 = x[2:]
    der = np.zeros_like(x)
    der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)
    der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])
    der[-1] = 200*(x[-1]-x[-2]**2)
    return der

梯度信息通过jac传入方程，完整代码如下：

import numpy as np
from scipy.optimize import minimize

def fun(x):
    """The Rosenbrock function"""
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)

def fun_d(x):
    xm = x[1:-1]
    xm_m1 = x[:-2]
    xm_p1 = x[2:]
    der = np.zeros_like(x)
    der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)
    der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])
    der[-1] = 200*(x[-1]-x[-2]**2)
    return der

#初始值
x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])


res = minimize(fun, x0, method='BFGS', jac=fun_d, options={'disp': True})

print(res.x)

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 25
         Function evaluations: 30
         Gradient evaluations: 30
[1.00000004 1.0000001  1.00000021 1.00000044 1.00000092]

如果不给jac初始值也可以计算：

import numpy as np
from scipy.optimize import minimize

def fun(x):
    """The Rosenbrock function"""
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)


#初始值
x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])


res = minimize(fun, x0, method='BFGS', options={'disp': True})

print(res.x)

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 25
         Function evaluations: 180
         Gradient evaluations: 30
[0.99999925 0.99999852 0.99999706 0.99999416 0.99998833]

牛顿共轭梯度法(method=‘Newton-CG’)

牛顿-共轭梯度算法是一种改进的牛顿方法，使用共轭梯度算法来（近似）局部Hessian的逆。牛顿方法的基础是将函数局部拟合为一个二次函数形式：
在这里插入图片描述
如果Hessian(即 H ( x 0 ) H(x_0) H(x0​))是正定的，那么这个函数的局部最小值可以通过设置二次函数的梯度为零来找到。
在这里插入图片描述
这里Hessian矩阵的逆是用共轭梯度的方法来评估的。比方说本例中，如果变量是5，那么Hessian矩阵为：
在这里插入图片描述

import numpy as np
from scipy.optimize import minimize

def fun(x):
    """The Rosenbrock function"""
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)
#梯度
def fun_d(x):
    xm = x[1:-1]
    xm_m1 = x[:-2]
    xm_p1 = x[2:]
    der = np.zeros_like(x)
    der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)
    der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])
    der[-1] = 200*(x[-1]-x[-2]**2)
    return der


#黑塞矩阵
def fun_hess(x):
    x = np.asarray(x)
    H = np.diag(-400*x[:-1],1) - np.diag(400*x[:-1],-1)
    diagonal = np.zeros_like(x)
    diagonal[0] = 1200*x[0]**2-400*x[1]+2
    diagonal[-1] = 200
    diagonal[1:-1] = 202 + 1200*x[1:-1]**2 - 400*x[2:]
    H = H + np.diag(diagonal)
    return H
#初始值
x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])


res = minimize(fun, x0, method='Newton-CG',jac=fun_d, hess=fun_hess,options={'xtol': 1e-8, 'disp': True})
print(res.x)

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 24
         Function evaluations: 33
         Gradient evaluations: 33
         Hessian evaluations: 24
[1.         1.         1.         0.99999999 0.99999999]

对于大规模的优化问题，存储整个Hessian矩阵会消耗大量的时间和内存。而牛顿-CG算法只需要Hessian与一个任意矢量的乘积。因此，可以提供代码来计算这个乘积，而不是将完整的Hessian直接送到优化器中。
Rosenbrock的Hessian矩阵与一个任意矢量的乘积并不难计算，对于本例来说：
在这里插入图片描述

import numpy as np
from scipy.optimize import minimize

def fun(x):
    """The Rosenbrock function"""
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)
#梯度
def fun_d(x):
    xm = x[1:-1]
    xm_m1 = x[:-2]
    xm_p1 = x[2:]
    der = np.zeros_like(x)
    der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)
    der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])
    der[-1] = 200*(x[-1]-x[-2]**2)
    return der


#黑塞矩阵与向量乘积
def fun_hess_p(x, p):
    x = np.asarray(x)
    Hp = np.zeros_like(x)
    Hp[0] = (1200*x[0]**2 - 400*x[1] + 2)*p[0] - 400*x[0]*p[1]
    Hp[1:-1] = -400*x[:-2]*p[:-2]+(202+1200*x[1:-1]**2-400*x[2:])*p[1:-1] \
               -400*x[1:-1]*p[2:]
    Hp[-1] = -400*x[-2]*p[-2] + 200*p[-1]
    return Hp
#初始值
x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])


res = minimize(fun, x0, method='Newton-CG',jac=fun_d, hessp=fun_hess_p,options={'xtol': 1e-8, 'disp': True})
print(res.x)

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 24
         Function evaluations: 33
         Gradient evaluations: 33
         Hessian evaluations: 66
[1.         1.         1.         0.99999999 0.99999999]

信赖域牛顿共轭梯度法(method=‘trust-ncg’)

牛顿-CG方法是一种线搜索方法：它找到一个搜索方向，使函数的二次方近似值最小，然后用一维搜索算法找到该方向的（近似）最佳步长。
另一种方法是，首先，固定步长限制Δ，然后通过解决以下二次方子问题，在给定的信任半径内找到最佳步骤：
在这里插入图片描述
然后进行迭代： x k + 1 = x k + p x_{k+1} = x_k + p xk+1​=xk​+p，信任半径Δ根据二次模型与实际函数的一致程度进行调整。这一类型的方法被称为信任区域方法。Trust-ncg算法是一种信任区域方法，使用共轭梯度算法来解决信任区域子问题 。
使用Hessian矩阵求解：

res = minimize(fun, x0, method='trust-ncg',
               jac=fun_d, hess=fun_hess,
               options={'gtol': 1e-8, 'disp': True})

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 20
         Function evaluations: 21
         Gradient evaluations: 20
         Hessian evaluations: 19
[1. 1. 1. 1. 1.]

使用Hessian矩阵点乘向量求解：

res = minimize(fun, x0, method='trust-ncg',
               jac=fun_d, hessp=fun_hess_p,
               options={'gtol': 1e-8, 'disp': True})

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 20
         Function evaluations: 21
         Gradient evaluations: 20
         Hessian evaluations: 74
[1. 1. 1. 1. 1.]

信赖域截断广义兰佐斯算法/共轭梯度法(method=‘trust-krylov’)

与trust-ncg方法类似，trust-krylov方法是一种适用于大规模问题的方法，因为它通过矩阵-向量乘积的方式，仅将Hessian作为线性算子。它比Trust-ncg方法更精准地求解二次方子问题。对于不确定的问题，通常使用这种方法更好，因为与trust-ncg方法相比，它减少了非线性迭代的数量，但代价是每个子问题的求解要多一些矩阵-向量乘积。
使用Hessian矩阵求解：

res = minimize(fun, x0, method='trust-krylov',
               jac=fun_d, hess=fun_hess,
               options={'gtol': 1e-8, 'disp': True})

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 19
         Function evaluations: 20
         Gradient evaluations: 20
         Hessian evaluations: 18
[1. 1. 1. 1. 1.]

使用Hessian矩阵点乘向量求解：

res = minimize(fun, x0, method='trust-krylov',
               jac=fun_d, hessp=fun_hess_p,
               options={'gtol': 1e-8, 'disp': True})


Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 19
         Function evaluations: 20
         Gradient evaluations: 20
         Hessian evaluations: 65
[1. 1. 1. 1. 1.]

信赖域近似精确算法 (method=‘trust-exact’)

前面所有的算法，如Newton-CG、trust-ncg和trust-krylov方法都适用于处理大规模问题（有数千个变量的问题）。这是因为共轭梯度算法通过迭代近似解决了信任区域的子问题（或Hessian矩阵的逆），而不需要明确的Hessian矩阵。由于只需要Hessian矩阵与任意向量的乘积，该算法特别适合于处理稀疏的Hessians矩阵，使那些稀疏问题的存储要求低，并能大大节省时间。
对于中等规模的问题，Hessian的存储和因子化成本并不重要，通过解决信任区域的子问题，有可能在较少的迭代中获得一个解决方案。
为了实现这一目标，对每个二次元子问题迭代求解某些非线性方程，这个解决方案通常需要对Hessian矩阵进行3或4次Cholesky分解。因此，该方法以较少的迭代次数收敛，与其他已实现的信任区域方法相比，需要较少的目标函数评估。该算法不支持Hessian点乘。下面是一个使用Rosenbrock函数的例子：

res = minimize(fun, x0, method='trust-exact',
               jac=fun_d, hess=fun_hess,
               options={'gtol': 1e-8, 'disp': True})

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 13
         Function evaluations: 14
         Gradient evaluations: 13
         Hessian evaluations: 14
[1. 1. 1. 1. 1.]
薯一个蜂蜜牛奶味的愿
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【数据分析与可视化】Scipy中的优化、数据拟合及稀疏矩阵处理（超详细 附源码）
showswoller的博客
01-17 939
【数据分析与可视化】Scipy中的优化、数据拟合及稀疏矩阵处理（超详细 附源码）
python科学计算——scipy.optimize
It’s All Uphill From Here
09-05 6776
SciPy的optimize模块提供了许多数值优化算法，下面对其中的一些记录。 非线性规划（scipy.optimize.minimize） 一.背景： 现...
【Scipy高级计算】(1) 定积分、二重积分，附python完整代码
博观而约取，厚积而薄发
04-17 8581
大家好，偶然接触到了python的Scipy高级科学计算库，可以看作是numpy的高级版，它可以很方便的求解线性代数、积分、插值、傅里叶变换等计算。今天和大家分享一下Scipy库的积分计算。 ''' 安装： pip install scipy 主要模块 # ---------------------------------------------------------- # scipy.cluster 层次聚类模块，包含适量优化、k-means等 scipy.constants 数学
python 非线性规划（scipy.optimize.minimize）
热门推荐
ronaldo-liu的博客
08-09 12万+
一.背景：现在项目上有一个用python 实现非线性规划的需求。非线性规划可以简单分两种，目标函数为凸函数 or 非凸函数。 凸函数的 非线性规划，比如fun=x^2+y^2+x*y，有很多常用的python库来完成，网上也有很多资料，比如CVXPY 非凸函数的 非线性规划（求极值），从处理方法来说，可以尝试以下几种： 1.纯数学方法，求导求极值； 2.使用神经网络，深度学习来处理，可参考...
Python 科学计算学习二：SciPy-数值计算库
Yangchenju的博客
07-31 1538
1 最小二乘拟合 2 函数最小值 3 非线性方程组求解 4 B-Spline样条曲线 5 数值积分 6 7 8 SciPy函数库在NumPy库的基础上增加了众多的数学、科学以及工程计算中常用的库函数。例如线性 代数、常微分方程数值求解、信号处理、图像处理、稀疏矩阵等等。 注：python版本不同，语法会略微有所差异。 我所使用的是Python 3.6.5 |Anaconda...
SciPy 优化
吴吃辣
10-22 1460
章节SciPy 介绍 SciPy 安装 SciPy 基础功能 SciPy 特殊函数 SciPy k均值聚类 SciPy 常量 SciPy fftpack(傅里叶变换) SciPy 积分 SciPy 插值 SciPy 输入输出 SciPy 线性代数 SciPy 图像处理 SciPy 优化 SciPy 信号处理 SciPy 统计 优化是指在某些约束条件下，求解目标函数最优解的过程。机器学习、人工智...
SciPy中的经典优化算法
KaelCui的博客
10-22 737
SciPy中的经典优化算法 | msgsxj'blog
python模块：Scipy.optimize.minimize规划问题求解
qq_58539881的博客
08-19 1万+
多元标量函数的最小化，是数学规划模型中更为一般的模型，该模块包括有限制性约束和无限制性约束的最小化，而对于限制性约束又分为线性约束和非线性约束。这种更为一般的模型需要针对具体的问题假设选择特定的方法进行求解。 在数学规划模型中，minimize提供的方法能够解决无/有（线性、非线性）约束的多个决策变量目标函数的最优化问题，但是由于该模块是依据函数导数与梯度进行求解，不能够求解整数规划、01规划等问题。
scipy最优化
KPer_Yang的博客
11-04 2025
学习scipy求解最优化问题
Python数据分析库 Scipy：科学计算与数据分析的利器！
2201_75362610的博客
10-31 5436
Scipy（Scientific Python）在现代科学研究和数据分析中是一个不可或缺的库。它建立在NumPy的基础上，提供了更多的高级科学计算功能，包括优化、信号处理、统计分析、插值、线性代数等。
浅谈SciPy中的optimize.minimize实现受限优化问题
01-20
KL-散度在机器学习中，P用来表示样本的真实分布，比如[1,0,0]表示当前样本属于第一类。Q用来表示模型所预测的分布，比如[0.7,0.2,0.1] KL-散度直观的理解就是如果用P来描述样本，那么就非常完美。而用Q来描述样本，...
Python中scipy模块的教程
04-28
Python中scipy模块的教程 Scipy是一个开源的Python库，专注于科学计算和工程应用。它是Python科学计算生态系统中的一个核心组件，建立在NumPy库的基础之上，提供了大量高级数学算法和便捷的函数，使得开发者能够高效...
python简单实现最大似然估计&scipy库的使用详解
09-17
主要介绍了python简单实现最大似然估计&scipy库的使用详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
python scipy optimize_python – 当不满足约束时,Scipy optimize.minimize成功退出
weixin_39805364的博客
12-22 846
我一直在使用scipy.optimize.minimize(docs)当我定义一个无法满足约束的问题时,我注意到了一些奇怪的行为.这是一个例子：from scipy import optimize# minimize f(x) = x^2 - 4xdef f(x):return x**2 - 4*xdef x_constraint(x, sign, value):return sign*(x - ...
Python中优化模块scipy.optimize的优化算法介绍
Pandas120的博客
01-16 1069
如果你有一个特殊的优化问题，你可以使用对象来自定义问题的求解。# 自定义目标函数# 自定义优化问题custom_problem.fun = custom_objective_function # 目标函数custom_problem.x = [1, 1] # 初始猜测# 执行优化# 打印结果在上述例子中，我们自定义了一个对象，并指定了目标函数和初始猜测，然后使用minimize函数进行求解。Scipy的优化模块提供了丰富的功能，适用于各种优化问题。
最优化方法Python计算：无约束优化应用——回归模型的测试
u012958850的博客
12-28 955
回归模型的测试。
一种基于牛顿-cg的增广拉格朗日方法来求解非凸等式约束优化的二阶平稳点(高概率非凸)
jj18839161636的博客
02-09 431
摘要研究了在已知近似可行点的情况下，寻找非凸等式约束优化的二阶平稳点（SOSP）。特别地，我们首先提出了一种新的纽顿CG方法来寻找无约束优化的近似SOSP，并表明它比牛顿-CG方法[56]具有明显更好的复杂性。然后，我们提出了一种基于牛顿-cg的增强拉格朗日（AL）方法来寻找非凸等式约束优化的近似SOSP，其中提出的牛顿-cg方法作为子问题求解器。我们表明，在广义线性独立约束条件（GLICQ），我们的方法享有总内部迭代的复杂性o（−7/2）和操作复杂性的o（−7/2分钟{n，−3/4}）找到一个（√）-SO
Scipy 中级教程——优化
Echo_Wish的博客
01-10 608
Scipy 的优化模块提供了多种工具，适用于不同类型的优化问题。通过本篇博客的介绍，你可以更好地理解和使用 Scipy 中的优化功能。在实际应用中，根据具体问题的特点选择合适的优化方法，并深入学习相关的数学理论和算法，将有助于更好地解决实际问题。希望这篇博客对你有所帮助！
【算法】二分算法——x的平方根
最新发布
2302_79031646的博客
05-17 789
用二分边界算法来求解——x的平方根，从暴力求解到二分的优化细说
用Scipy库求解一个带多个约束的优化问题
07-15
要使用Scipy库求解带多个约束的优化问题，可以使用Scipy的optimize模块中的minimize函数。下面是一个求解带多个约束的优化问题的示例代码： ```python from scipy.optimize import minimize # 定义目标函数 def objective(x): return x[0]**2 + x[1]**2 # 定义约束条件 def constraint1(x): return x[0] - x[1] def constraint2(x): return x[0] + x[1] - 1 # 定义初始猜测值 x0 = [0.5, 0.5] # 定义约束条件 cons = [{'type': 'ineq', 'fun': constraint1}, {'type': 'eq', 'fun': constraint2}] # 求解优化问题 res = minimize(objective, x0, constraints=cons) # 输出结果 print(res) ``` 在上述代码中，首先定义了目标函数`objective`，约束条件`constraint1`和`constraint2`。然后定义了初始猜测值`x0`和约束条件`cons`，其中`cons`是一个字典列表，每个字典表示一个约束条件，包括约束类型和约束函数。最后使用`minimize`函数求解优化问题，并将结果存储在变量`res`中。 需要注意的是，`minimize`函数的参数`constraints`用于指定约束条件，其中约束类型有两种，'eq'表示等式约束，'ineq'表示不等式约束。在定义约束函数时，等式约束的函数返回值应为0，不等式约束的函数返回值应为大于等于0。 以上是一个简单的带多个约束的优化问题示例，你可以根据具体的问题定义自己的目标函数和约束条件。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

薯一个蜂蜜牛奶味的愿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值