【Scipy优化使用教程】二、Scipy中有约束优化的两种算法

最新推荐文章于 2024-04-17 23:48:23 发布
最新推荐文章于 2024-04-17 23:48:23 发布
阅读量1.2w 收藏 77
点赞数 9
分类专栏： 优化求解工具 文章标签： 算法 python 学习 动态规划 自动驾驶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_w_y/article/details/123109116
版权

参考官网：Scipy.

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

对于有约束的最小化问题，Scipy提供的minimize这个包有三个：trust-constr, SLSQP'和COBYLA。它们要求使用稍微不同的结构来定义约束。
trust-constr需要要求约束被定义成一系列的LinearConstraint 和 NonlinearConstraint两种类型。
SLSQP'和COBYLA需要要求约束条件被定义为一连串的字典，其键为type、fun和jac。
考虑有约束的最小化2个变量的Rosenbrock函数
在这里插入图片描述
这个问题有唯一解： [ x 0 , x 1 ] = [ 0.4149 , 0.1701 ] [x_0,x_1]=[0.4149,0.1701] [x0​,x1​]=[0.4149,0.1701]。

信赖域约束算法(method=‘trust-constr’)

信任域约束方法处理的是约束性最小化问题，其形式为:
在这里插入图片描述
除此之外，单边约束可以通过对np.inf设置上限或下限并加上适当的符号来指定。

定义边界约束

边界限制 0 ≤ x 0 ≤ 1 , − 0.5 ≤ x 1 ≤ 2.0 0≤x_0≤1,-0.5≤x_1≤2.0 0≤x0​≤1,−0.5≤x1​≤2.0被定义如下：

from scipy.optimize import Bounds
bounds = Bounds([0, -0.5], [1.0, 2.0])

定义线性约束

约束 x 0 + 2 x 1 ≤ 1 ， 2 x 0 + x 1 = 1 x_0+2x_1≤1，2x_0+x_1=1 x0​+2x1​≤1，2x0​+x1​=1可以写成如下形式：
在这里插入图片描述
用LinearConstraint去定义：

from scipy.optimize import LinearConstraint
linear_constraint = LinearConstraint([[1, 2], [2, 1]], [-np.inf, 1], [1, 1])

定义非线性约束

非线性约束为：
在这里插入图片描述
其雅可比矩阵(对每个变量求导)为：
在这里插入图片描述
黑塞矩阵的线性组合：
在这里插入图片描述
用NonlinearConstraint去定义：

#定义非线性约束
def cons_f(x):
    return [x[0]**2 + x[1], x[0]**2 - x[1]]
#定义导数
def cons_J(x):
    return [[2*x[0], 1], [2*x[0], -1]]
#定义二阶导数
def cons_H(x, v):
    return v[0]*np.array([[2, 0], [0, 0]]) + v[1]*np.array([[2, 0], [0, 0]])
from scipy.optimize import NonlinearConstraint
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=cons_H)

另外，也可以将Hessian定义为一个稀疏矩阵。

from scipy.sparse import csc_matrix
def cons_H_sparse(x, v):
    return v[0]*csc_matrix([[2, 0], [0, 0]]) + v[1]*csc_matrix([[2, 0], [0, 0]])
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1,
                                           jac=cons_J, hess=cons_H_sparse)

当黑塞矩阵难以计算的时候，可以使用HessianUpdateStrategy，目前可用的策略有：BFGS和SR1。

from scipy.optimize import BFGS
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=BFGS())

另外，Hessian可以用有限差分法进行近似。

nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess='2-point')

雅可比矩阵也可以用有限差分法估计，然而，在这种情况下，黑塞不能用有限差分计算，需要由用户提供或用之前介绍的HessianUpdateStrategy定义：

nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac='2-point', hess=BFGS())

求解

#设置初值
x0 = np.array([0.5, 0])
#这个需要结合之前无约束的算法来计算
res = minimize(rosen, x0, method='trust-constr', jac=rosen_der, hess=rosen_hess,
               constraints=[linear_constraint, nonlinear_constraint],
               options={'verbose': 1}, bounds=bounds)
print(res.x)

无约束代码在这里

`gtol` termination condition is satisfied.
Number of iterations: 12, function evaluations: 8, CG iterations: 7, optimality: 2.99e-09, constraint violation: 0.00e+00, execution time: 0.014 s.
[0.41494531 0.17010937]

完整代码

import numpy as np
from scipy.optimize import minimize
#无约束
def rosen(x):
    """The Rosenbrock function"""
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)

def rosen_der(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 rosen_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

#设置约束
from scipy.optimize import Bounds
bounds = Bounds([0, -0.5], [1.0, 2.0])
from scipy.optimize import LinearConstraint
linear_constraint = LinearConstraint([[1, 2], [2, 1]], [-np.inf, 1], [1, 1])

def cons_f(x):
    return [x[0]**2 + x[1], x[0]**2 - x[1]]
#定义导数
def cons_J(x):
    return [[2*x[0], 1], [2*x[0], -1]]
#定义二阶导数
def cons_H(x, v):
    return v[0]*np.array([[2, 0], [0, 0]]) + v[1]*np.array([[2, 0], [0, 0]])
from scipy.optimize import NonlinearConstraint
nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=cons_H)

#求解
x0 = np.array([0.5, 0])
res = minimize(rosen, x0, method='trust-constr', jac=rosen_der, hess=rosen_hess,
               constraints=[linear_constraint, nonlinear_constraint],
               options={'verbose': 1}, bounds=bounds)

print(res.x)

另外也可以对目标函数的第一和第二导数进行近似，例如，黑塞矩阵可以用SR1准牛顿法近似，梯度可以用有限差分法近似：

from scipy.optimize import SR1
res = minimize(rosen, x0, method='trust-constr',  jac="2-point", hess=SR1(),
               constraints=[linear_constraint, nonlinear_constraint],
               options={'verbose': 1}, bounds=bounds)

`gtol` termination condition is satisfied.
Number of iterations: 12, function evaluations: 24, CG iterations: 7, optimality: 4.48e-09, constraint violation: 0.00e+00, execution time: 0.02 s.
[0.41494531 0.17010937]

序列最小二乘(SLSQP) (method=‘SLSQP’)

SLSQP需要如下形式：
在这里插入图片描述

设置约束

在这里插入图片描述
线性和非线性约束都被定义为字典，其键为type、fun和jac：
首先是定义域：

from scipy.optimize import Bounds
bounds = Bounds([0, -0.5], [1.0, 2.0])

等式与不等式约束：

#不等式约束
ineq_cons = {'type': 'ineq',
             'fun' : lambda x: np.array([1 - x[0] - 2*x[1],
                                         1 - x[0]**2 - x[1],
                                         1 - x[0]**2 + x[1]]),
             #jac是对fun的求导
             'jac' : lambda x: np.array([[-1.0, -2.0],
                                         [-2*x[0], -1.0],
                                         [-2*x[0], 1.0]])}
#等式约束
eq_cons = {'type': 'eq',
           'fun' : lambda x: np.array([2*x[0] + x[1] - 1]),
           'jac' : lambda x: np.array([2.0, 1.0])}

求解

x0 = np.array([0.5, 0])
res = minimize(rosen, x0, method='SLSQP', jac=rosen_der,
               constraints=[eq_cons, ineq_cons], options={'ftol': 1e-9, 'disp': True},
               bounds=bounds)
print(res.x)

Optimization terminated successfully    (Exit mode 0)
            Current function value: 0.34271757499419825
            Iterations: 4
            Function evaluations: 5
            Gradient evaluations: 4
[0.41494475 0.1701105 ]

完整代码

import numpy as np
from scipy.optimize import minimize
#定义无约束的目标函数
def rosen(x):
    """The Rosenbrock function"""
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)

def rosen_der(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 rosen_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

#定义约束
from scipy.optimize import Bounds
bounds = Bounds([0, -0.5], [1.0, 2.0])

ineq_cons = {'type': 'ineq',
             'fun' : lambda x: np.array([1 - x[0] - 2*x[1],
                                         1 - x[0]**2 - x[1],
                                         1 - x[0]**2 + x[1]]),
             'jac' : lambda x: np.array([[-1.0, -2.0],
                                         [-2*x[0], -1.0],
                                         [-2*x[0], 1.0]])}
eq_cons = {'type': 'eq',
           'fun' : lambda x: np.array([2*x[0] + x[1] - 1]),
           'jac' : lambda x: np.array([2.0, 1.0])}
           
#求解
x0 = np.array([0.5, 0])
res = minimize(rosen, x0, method='SLSQP', jac=rosen_der,
               constraints=[eq_cons, ineq_cons], options={'ftol': 1e-9, 'disp': True},
               bounds=bounds)

print(res.x)

PS：大部分 trust-constr方法可用的选项对 SLSQP来说是不可用的。

薯一个蜂蜜牛奶味的愿
关注
  • 9
    点赞
  • 踩
  • 77
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
使用Python求解带约束的最优化问题详解
09-17
在本文中，我们将深入探讨如何使用Python来解决带有约束条件的最优化问题。最优化问题在许多领域，如工程、经济学、数据科学等，都扮演着至关重要的角色。Python提供了强大的库来处理这类问题，例如`sympy`和`scipy`...
浅谈SciPy中的optimize.minimize实现受限优化问题
01-20
问题描述：有一批样本x，每个样本都有几个固定的标签，如（男，24岁，上海），需要从中抽取一批样本，使样本总的标签比例满足分布P(x)，如（男:女=49%:51%、20岁:30岁=9%:11%、……….） 采用KL-散度作为优化目标函数。 KL-散度又叫相对熵 KL-散度在机器学习中，P用来表示样本的真实分布，比如[1,0,0]表示当前样本属于第一类。Q用来表示模型所预测的分布，比如[0.7,0.2,0.1] KL-散度直观的理解就是如果用P来描述样本，那么就非常完美。而用Q来描述样本，虽然可以大致描述，但是不是那么的完美，信息量不足，需要额外的一些“信息增量”才能达到和P一样完美的描述。如果我
scipy.optimize优化器的各种使用
热门推荐
千寻的博客
02-22 5万+
目录 0.scipy.optimize.minimize 1.无约束最小化多元标量函数 1.1Nelder-Mead（单纯形法）  1.2拟牛顿法：BFGS算法 1.3牛顿 - 共轭梯度法：Newton-CG 2 约束最小化多元标量函数 2.1SLSQP(Sequential Least SQuares Programming optimization algorithm)  2....
nlopt非线性优化算法整理
subtitle_的博客
04-17 1395
nlopt非线性优化算法整理
COBYLA_COBYLA_
09-29
COBYLA - Constrained Optimization by Linear ApproximationA gradient-free optimization algorithm capable of handling nonlinear inequality constraints.
【机器学习 | 非线性拟合】梯度下降 vs SLSQP算法，谁更胜一筹？ 解决六个数据点的非线性拟合难题，挑战非线性拟合问题
计算机魔术师的blog
09-27 1756
本文主要介绍了如何使用纯Python实现仅对任意六个点进行非线性拟合，并且满足一阶导数恒大于0的不等式约束。文章从解决问题的起因到解决问题的流程进行了详细的叙述，旨在帮助读者在面对只有几个点的情况下获得高质量的非线性拟合结果。同时，文章还探讨了梯度下降算法在这个问题上的可行性。如何在面对只有几个点的情况下得到高质量的非线性拟合？ 梯度下降算法可行吗？ 极简技巧解决少量数据点的非线性拟合难题，确定不来看看？
4. 吴恩达机器学习--偏差与方差
qq_45069496的博客
06-29 2431
利用水库水位变化预测大坝出水量，数据集为：ex5data1.mat。   很明显，图中数据应该是一个非线性模型，但为了展示欠拟合的效果，现假设模型为线性模型：hθ(x)=θ0+θ1xh_\theta(x) = \theta_0 + \theta_1xhθ​(x)=θ0​+θ1​x   损失函数为：J(θ)=12m∑i=1m(hθ(x(i))−y(i))2+λ2m∑j=1mθj2J(\theta) = \frac{1}{2m}\sum_{i=1}^m{(h_\theta(x...
机器学习学习笔记（十七）—— 优化算法概述
Lancetop的博客
06-21 3381
一、概观 scipy中的optimize子包中提供了常用的最优化算法函数实现。我们可以直接调用这些函数完成我们的优化问题。optimize中函数最典型的特点就是能够从函数名称上看出是使用了什么算法。下面optimize包中函数的概览： 1.非线性最优化 fmin -- 简单Nelder-Mead算法 fmin_powell -- 改进型Powell法 fmin_bfgs -- 拟Newton法 f...
【机器学习 | 回归问题】超越直线:释放多项式回归的潜力 —— 详解线性回归与非线性 （含详细案例、源码）
计算机魔术师的blog
10-09 722
【机器学习 | 回归问题】超越直线:释放多项式回归的潜力 —— 详解线性回归与非线性 （含详细案例、源码）
Python中scipy模块的教程
最新发布
04-28
Python中scipy模块的教程 Scipy是一个开源的Python库，专注于科学计算和工程应用。它是Python科学计算生态系统中的一个核心组件，建立在NumPy库的基础之上，提供了大量高级数学算法和便捷的函数，使得开发者能够高效...
slsqp4j:流行的SLSQP优化器的JVM包装器
05-11
slsqp4j Slsqp4j是Java包装器，用于SciPy中包含的流行的SLSQP非线性优化器。 该API模仿了SciPy，以简化将问题从Python转换为JVM的过程。 大部分的求解是在Dieter Kraft撰写的slsqp.f90中完成的，并在和。 建造 构建Slsqp4j取决于gcc和gfortran。 的Ubuntu 您可以使用sudo apt install gcc gfortran命令安装两者。 此外，您的JAVA_HOME必须指向您的JDK安装目录。 要构建Slsqp4j，只需在项目根目录中运行gradle clean build 。 Mac OSX 此过程已在BigSur上使用了acceptopenjdk8（ brew tap AdoptOpenJDK/openjdk && brew install --cask adoptopenjdk8 ）进行了测试。
Python狼群搜索算法（Wolf Pack Search Algorithm）优化示例代码
08-10
本项目演示了如何使用狼群搜索算法（Wolf Pack Search Algorithm）来优化函数，并绘制优化过程中的收敛曲线。狼群搜索算法（WPS）是一种基于群体智能的优化算法，灵感来自于狼群的行为。WPS算法通过模拟狼群中狼的...
论文阅读笔记《IM2CAD》
深视
11-30 604
核心思想   本文提出一种从二维图像中还原房间布置并重建家具模型的方法。首先，采用逐像素的分类的方法，识别图像中的墙壁、地板和天花板等元素，并将其拟合成盒型形状，得到房间的基础几何形状。然后，使用目标检测算法识别出图像中桌子、椅子、床、书柜等家具目标，利用检测结果从CAD模型数据库中检索得到最接近的三维模型，并预测一个粗略的3D位姿。最后对所有目标的位姿和形状进行迭代优化，得到最佳的位姿和放缩尺度。 实现过程   首先，输入二维场景图像，本文采用FCN网络（全卷积神经网络VGG）对每个像素进行分类，将场景
优化器scipy.optimize参考指南
我不爱机器学习的博客
11-23 2829
优化器scipy.optimize参考指南
NLopt中的无导数算法
qq_38528731的博客
09-06 4374
NLopt中的无导数算法无导数全局最优算法DIRECT和DIRECT-L （本文所涉及各量皆为C风格，即包含头文件的是nlopt.h而非nlopt.hpp） 首先说一下NLopt中算法的命名规则，C风格的命名规则为NLOPT_{G,L}{N,D}_xxxx，其中G/L代表全局最优与局部最优，N/D代表无导数与有导数。例如NLOPT_LN_COBYLA则表示无导数局部最优的COBYLA算法。 这里的导数是我们算完之后填入 if (grad) { /* 各变量的导数 */ } 中的，但是在很多情况下，当问题
浅介绍python中minimize非线性规划用法
m0_74270467的博客
08-09 1965
可选：Nelder-Mead，Powell，CG，BFGS，Newton-CG，L-BFGS-B，TNC，COBYLA，SLSQP，trust-constr，dogleg，trust-ncg，trust-exact，trust-krylov 等选项，一般不要求的情况下可以之间不管。信任域约束优化方法，适用于带有约束的优化问题，支持线性和非线性约束，支持多。bound = （（0，1），（0，1））#两个自变量的范围为0-1。适用于带有约束的优化问题，尤其适用于没有梯度信息的问题。
转载-scipy求有约束优化问题
NananaJ的博客
05-04 427
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/qq_39575835/article/details/101173969 ———————————————— 问题 针对于有约束问题 python的scipy库给出了Sequential Least SQuares Programming (SLSQP) Algorithm。 实例 SLSQP解决模板 对于下面的问题： >&gt
二次无约束二值优化问题 python
06-12
二次无约束二值优化问题可以使用Python中的优化库进行求解，比如使用SciPy库中的minimize函数。 具体的方法是将二次无约束二值优化问题转化为二次无约束优化问题，然后使用优化库进行求解。 假设我们的二次无约束二值优化问题的目标函数为f(x)，其中x为二值变量，可以取值为0或1。我们可以将x表示为： x = (1-t)/2 + (1+t)/2 * y 其中t为一个常数，y为取值为-1或1的实数变量。这样，x的取值就被限制在0和1之间。 将x带入目标函数f(x)中，得到： f(y) = f((1-t)/2 + (1+t)/2 * y) 这是一个二次无约束优化问题，可以使用SciPy库中的minimize函数进行求解。我们可以使用BFGS或L-BFGS-B算法进行优化，这两种算法都是梯度下降算法的变种，可以有效地求解二次无约束优化问题。 下面是一个使用SciPy库中的minimize函数求解二次无约束二值优化问题的示例代码： ```python import numpy as np from scipy.optimize import minimize # 定义目标函数 def f(x): return (x[0]**2 + x[1]**2 - 2*x[0]*x[1] + 2*x[0] - 6*x[1]) # 定义约束条件 def constraint(x): return np.array([x[0]**2 + x[1]**2 - 1]) # 定义初始点 x0 = np.array([0, 0]) # 定义范围 bounds = ((-1, 1), (-1, 1)) # 求解 res = minimize(f, x0, method='L-BFGS-B', bounds=bounds, constraints={'type': 'eq', 'fun': constraint}) # 输出结果 print(res.x) ``` 在这个示例中，我们定义了一个二次无约束二值优化问题的目标函数f(x)，并使用L-BFGS-B算法进行求解。我们还定义了一个约束条件x[0]**2 + x[1]**2 - 1 = 0，这个约束条件限制了x的取值在一个单位圆内。最后，我们使用初始点x0 = [0, 0]进行求解，得到了最优解res.x。 需要注意的是，这个示例中的目标函数和约束条件只是一个例子，实际问题中需要根据具体情况进行定义。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

薯一个蜂蜜牛奶味的愿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值