非线性规划(scipy.optimize.minimize)

1、minimize() 函数介绍

在 python 里用非线性规划求极值,最常用的就是 scipy.optimize.minimize()。
[官方介绍点这里](Constrained minimization of multivariate scalar functions)

使用格式是:

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

其中:
fun:目标函数,返回单值,
x0:初始迭代值,
args:要输入到目标函数中的参数
method:求解的算法,目前可选的有
		‘Nelder-Mead’
		‘Powell’ 
		‘CG’ 
		‘BFGS’ 
		‘Newton-CG’ 
		‘L-BFGS-B’
		‘TNC’
		‘COBYLA’ 
		‘SLSQP’ 
		‘dogleg’ 
		‘trust-ncg’ 
		以及在 version 0.14.0,还能自定义算法
		以上算法的解释和相关用法见 minimize 函数的官方说明文档,一般求极值多用 'SLSQP'算法
jac:目标函数的雅可比矩阵。可选项,仅适用于CG,BFGS,Newton-CG,L-BFGS-B,TNC,SLSQP,dogleg,trust-ncg。如果jac是布尔值并且为True,则假定fun与目标函数一起返回梯度。如果为False,将以数字方式估计梯度。jac也可以返回目标的梯度。此时,它的参数必须与fun相同。
hess,hessp:可选项,目标函数的Hessian(二阶导数矩阵)或目标函数的Hessian乘以任意向量p。仅适用于Newton-CG,dogleg,trust-ncg。
bounds:可选项,变量的边界(仅适用于L-BFGS-B,TNC和SLSQP)。以(min,max)对的形式定义 x 中每个元素的边界。如果某个参数在 min 或者 max 的一个方向上没有边界,则用 None 标识。如(None, max)
constraints:约束条件(只对 COBYLA 和 SLSQP)。dict 类型。
	type : str, ‘eq’ 表示等于0,‘ineq’ 表示不小于0
	fun : 定义约束的目标函数
	jac : 函数的雅可比矩阵 (只用于 SLSQP),可选项。
	args : fun 和 雅可比矩阵的入参,可选项。
tol:迭代停止的精度。
callback(xk):每次迭代要回调的函数,需要有参数 xk
options:其他选项
	maxiter :  最大迭代次数
	disp :  是否显示过程信息
以上参数更具体的介绍见官网相关页面。

2、talk is cheap, show me the code !

好的,满足你!

1)无约束求极值

计算 1/x+x 的最小值


from scipy.optimize import minimize
import numpy as np
 
def fun(args):
     a=args
     v=lambda x:a/x[0] +x[0]
     return v
 
args = (1)  #a
x0 = np.asarray((2))  # 初始猜测值
res = minimize(fun(args), x0, method='SLSQP')
print(res.fun)
print(res.success)
Out[78]:
2.0000000815356342
True
2)有约束求极值

2-1)计算 (2+x1)/(1+x2) - 3x1+4x3 的最小值 x1,x2,x3 都处于[0.1, 0.9] 区间内。

def fun(args):
    a,b,c,d = args
    v = lambda x: (a+x[0])/(b+x[1]) -c*x[0]+d*x[2]
    return v
    
def con(args):
    # 约束条件 分为eq 和ineq
    # eq表示 函数结果等于0 ; ineq 表示 表达式大于等于0  
    x1min, x1max, x2min, x2max, x3min, x3max = args
    cons = ({'type': 'ineq', 'fun': lambda x: x[0] - x1min},\
    		{'type': 'ineq', 'fun': lambda x: -x[0] + x1max},\
    		{'type': 'ineq', 'fun': lambda x: x[1] - x2min},\
    		{'type': 'ineq', 'fun': lambda x: -x[1] + x2max},\
    		{'type': 'ineq', 'fun': lambda x: x[2] - x3min},\
    		{'type': 'ineq', 'fun': lambda x: -x[2] + x3max})
    return cons
 
# 定义常量值
args = (2,1,3,4)  # a,b,c,d

# 设置参数范围/约束条件
args1 = (0.1,0.9,0.1, 0.9,0.1,0.9)  # x1min, x1max, x2min, x2max
cons = con(args1)

# 设置初始猜测值  
x0 = np.asarray((0.5,0.5,0.5))

res = minimize(fun(args), x0, method='SLSQP',constraints=cons)
print(res.fun)
print(res.success)
print(res.x)
Out[79]:
-0.773684210526435
True
[0.9 0.9 0.1]

2-2)解决以下优化问题
m i n i m i z e x [ 0 ] , x [ 1 ] l o g 2 ( 1 + x [ 0 ] × 2 3 + l o g 2 x [ 1 ] × 3 4 ) minimize_{x[0], x[1]}log_2(1+\frac{x[0]\times2}{3}+log_2\frac{x[1]\times3}{4}) minimizex[0],x[1]log2(1+3x[0]×2+log24x[1]×3)
s.t. :
l o g 2 ( 1 + x [ 0 ] × 2 5 ) ≥ 5 log_2(1+\frac{x[0]\times2}{5})\geq 5 log2(1+5x[0]×2)5
l o g 2 ( 1 + x [ 0 ] × 6 4 ) ≥ 5 log_2(1+\frac{x[0]\times6}{4})\geq 5 log2(1+4x[0]×6)5

# 目标函数
def fun(a,b,c,d):
    def v(x):
        return np.log2(1+x[0]*a/b)+np.log2(1+x[1]*c/d)
    return v
    
#限制条件函数
def con(a,b,i):
    def v(x):
        return np.log2(1 + x[i] * a / b)-5
    return v

# 定义常量值
args = [2, 1, 3, 4]  # a,b,c,d
args1 = [2, 5, 6, 4] 

# 设置初始猜测值
x0 = np.asarray((0.5, 0.5))

#设置限制条件
cons = ({'type': 'ineq', 'fun': con(args1[0],args1[1],0)},
        {'type': 'ineq', 'fun': con(args1[2],args1[3],1)},
        )

res = minimize(fun(args[0], args[1], args[2], args[3]), x0, constraints=cons)
print(res.fun)
print(res.success)
print(res.x)
Out[80}:
11.329796332293162
True
[77.5        20.66666658]

参考资料:
1、python 非线性规划(scipy.optimize.minimize)
2、scipy.optimize优化器的各种使用
3、Scipy优化scipy.optimize.minimize

你可能感兴趣的:(技术综合,python,线性规划)