精华内容
下载资源
问答
  • scipy.optimize.minimize参数
    千次阅读
    2020-08-05 17:47:59

    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:ndarray,shape=(n,) 大小为(n,)的实元素数组,其中“n”是自变量的数目。

    args:可选。传递给目标函数及其导数(fun、jac和hess函数)的额外参数。

    method:str或callable,可选
    解算器的类型:
    “Nelder Mead”
    “Powell”
    ‘CG’
    ‘BFGS’
    “Newton-CG”
    ‘L-BFGS-B’
    “TNC”
    ‘COBYLA’)
    “SLSQP”
    “trust-constr”
    “dogleg”
    “trust-ncg”
    “trust-exact”
    “trust-krylov”
    custom-自定义-一个可调用的对象(在0.14.0版中添加)
    如果没有给定,则选择BFGS,L-BFGS-B,SLSQP中的一个,这取决于问题是否有约束或边界。

    jac:{callable,‘2-point’,‘3-point’,cs’,bool},可选
    计算梯度向量的方法。仅适用于CG、BFGS、Newton CG、L-BFGS-B、TNC、SLSQP、dogleg、trust ncg、trust krylov、trust exact和trust Construct。
    如果它是可调用的,它应该是一个返回梯度向量的函数: jac(x,*args)->array_like,shape(n,).其中x是(n,)的数组,args是具有固定参数的元组。
    如果jac是布尔值且为真,则假定fun返回objective和gradient作为(f,g)元组。“Newton CG”、“trust ncg”、“dogleg”、“trust exact”和“trust krylov”方法要求提供可调用函数,或者fun返回目标和梯度。
    如果None或False,则使用绝对步长的两点有限差分估计来估计梯度。或者,关键字{‘2-point’、‘3-point’、‘cs’}可用于选择具有相对步长的梯度的数值估计的有限差分格式。这些有限差分格式服从任何指定的边界。

    hess:{callable,‘2-point’,3-point’,cs’,HessianUpdateStrategy},可选
    计算Hessian矩阵的方法。只适用于Newton CG、dogleg、trust ncg、trust krylov、trust exact和trust constr。如果它是可调用的,它应该返回Hessian矩阵:
    hess(x,*args)->{linearerator,spmatrix,array},(n,n)
    其中x是(n,)ndarray,args是具有固定参数的元组。lineroperator和稀疏矩阵返回只允许用于“trust constr”方法。或者,关键字{‘2-point’、‘3-point’、‘cs’}选择一个有限差分格式进行数值估计。或者,实现HessianUpdateStrategy接口的对象可以用来近似Hessian。实现该接口的可用拟牛顿方法有:
    BFGS; SR1。
    当用有限差分法估计梯度时,Hessian不能用选项{‘2-point’、‘3-point’、‘cs’}来估计,需要使用一种拟牛顿策略来估计。有限差分选项{‘2-point’、‘3-point’、‘cs’}和HessianUpdateStrategy仅适用于“trust constr”方法。

    hessp:可调用,可选
    目标函数的Hessian乘以任意向量p。仅适用于Newton CG,trust ncg,trust krylov,trust constr。只需提供一个hessp或hess。如果提供了hess,则hessp将被忽略。hessp必须计算Hessian乘以任意向量:
    hessp(x,p,*args)->ndarray shape(n,)
    其中x是(n,)ndarray,p是维数为(n,)的任意向量,args是具有固定参数的元组。

    bounds:序列或边界,可选
    L-BFGS-B、TNC、SLSQP、Powell和trust constr方法的变量边界。有两种方法可以指定边界: Bounds类的实例。
    x中每个元素的(min,max)对序列。None用于指定不绑定。

    constraints:{Constraint,dict}或{Constraint,dict}列表,可选 约束定义(仅适用于COBYLA、SLSQP和trust constr)。“trust constr”的约束被定义为单个对象或指定优化问题约束的对象列表。可用的约束包括: 线性约束 非线性约束
    COBYLA、SLSQP的约束定义为字典列表。每个包含字段的词典:
    类型:字符串 约束类型:“eq”表示相等,“ineq”表示不等式
    函数:的定义约束的函数。
    jac:callable,可选(只适用于SLSQP)。
    argssequence,可选 传递给函数和Jacobian的额外参数。
    等式约束意味着约束函数的结果是零,而不等式意味着它是非负的。注意COBYLA只支持不等式约束。

    tol:可选。终止公差。对于详细的控制,请使用特定于解算器的选项。

    options:dict,可选。解算器选项词典。
    可以是maxiter:int。 要执行的最大迭代数。例如:{‘maxiter’: 250}
    也可以是disp:布尔型。 设置为True可打印聚合消息。例如:{‘disp’: True}

    callback:callable,可选。在每次迭代后调用。对于“trust constr”,它是一个可调用的签名: 回调(xk,OptimizeResult state)->bool
    其中xk是当前参数向量。state是一个OptimizeResult对象,其字段与返回中的字段相同。如果回调返回True,则终止算法执行。对于所有其他方法,签名为:
    回叫(xk) 其中xk是当前参数向量。 退换商品 解析结果
    表示为OptimizeResult对象的优化结果。重要的属性是:x解决方案数组,success一个指示优化器是否成功退出的布尔标志,以及描述终止原因的消息。有关其他属性的说明,请参见OptimizeResult。

    更多相关内容
  • 一、背景: 现在项目上有一个用python 实现非线性规划的需求。非线性规划可以简单分两种,...3.寻找一些python库来做,本文介绍scipy.optimize.minimize的使用方法 二、库方法介绍 官方文档:https://docs.scipy.org/do
  • python -m pip install git+https://github.com/gngdb/pytorch-minimize.git 或通过克隆存储库然后安装: git clone https://github.com/gngdb/pytorch-minimize.git cd pytorch-minimize python -m pip install ....
  • Least-Squares-SIR-Example:使用最小二乘和scipy.optimize.minimize将基本SIR模型拟合到数据
  • 在实际的数学建模应用中,我们会遇到很多约束条件是二次的,...官方文档:SciPy API referencehttps://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize scipy.o

    在实际的数学建模应用中,我们会遇到很多约束条件是二次的,三次的或者是高次函数的情况,这样用 optimize.linprog()来解决就显得不适用了,因此我们使用scipy.optimize下得minimize函数来解决这个问题。

    官方文档:
    SciPy API referencehttps://docs.scipy.org/doc/scipy/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:是目标函数,是一个函数形式传入,

     x0:初步猜测。大小为 (n,) 的实数元素数组,其中 n 是自变量的数量。

    constraints:约束定义。仅适用于COBYLA,SLSQP和trust-constr.传入字典类型的数据,其数据是约束条件,可以是等式,也可以是不等式约束。

    bounds:参数范围限定,即限定求解的x的取值范围。

    求解约束条件下得最小值:

    导入头文件,建立目标函数:

    from scipy import optimize
    
    f = lambda x: x[0] ** 2 + x[1] **2 + x[2] ** 2 + 8
    

     建立约束条件函数:

    cons = ({'type': 'ineq', 'fun': lambda x: x[0]**2 - x[1] + x[2]**2},
            {'type': 'ineq', 'fun': lambda x: -x[0] - x[1] - x[2]**3 + 20},
            {'type': 'eq', 'fun': lambda x: -x[0] - x[1]**2 + 2},
            {'type': 'eq', 'fun': lambda x: x[1] + 2 * x[2]**2 - 3})

    type表示约束条件的等式类型,如ineq是不等式,eq是等式。

    初始化x,限定x范围,传入参数:

    x=(0,0,0)
    bounds=[[0,None],[0,None],[0,None]]
    
    res = optimize.minimize(f, x0=x,bounds=bounds, constraints=cons)

    得到结果如下:

     最小值为10.65,x的取值为0.55,1.20,0.94

    同时也可以无约束求最值:不传入约束条件即可

    res = optimize.minimize(f, x0=x,bounds=bounds)

    结果:

    展开全文
  • 在 python 里用非线性规划求极值,最常用的就是 scipy.optimize.minimize()。 [官方介绍点这里](Constrained minimization of multivariate scalar functions) 使用格式是: scipy.optimize.minimize(fun, x0, args=...

    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

    展开全文
  • 今天小编就为大家分享一篇浅谈SciPy中的optimize.minimize实现受限优化问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Scipy优化scipy.optimize.minimize

    千次阅读 2020-08-03 23:56:40
    scipy,optimize.minimize

    如果喜欢请点赞,收藏,谢谢!
    要解决一个优化问题

    m i n i m i z e x [ 0 ] , x [ 1 ] \mathrm{minimize}_{x[0],x[1]} minimizex[0],x[1] log ⁡ 2 ( 1 + x [ 0 ] 2 3 ) + log ⁡ 2 ( 1 + x [ 1 ] 3 4 ) \log_{2}(1+\frac{x[0]2}{3})+\log_{2}(1+\frac{x[1]3}{4}) log2(1+3x[0]2)+log2(1+4x[1]3)

    c o n s t r a i n t s \mathrm{constraints} constraints

    log ⁡ 2 ( 1 + x [ 0 ] 2 5 ) ≥ 5 \log2(1+\frac{x[0]2}{5})\geq5 log2(1+5x[0]2)5
    log ⁡ 2 ( 1 + x [ 1 ] 6 4 ) ≥ 5 \log2(1+\frac{x[1]6}{4})\geq5 log2(1+4x[1]6)5

    程序示例

    # coding=utf-8
    from scipy.optimize import minimize
    from scipy.optimize import NonlinearConstraint
    import numpy as np
    
    
    # 目标函数
    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
    
    
    
    if __name__ == "__main__":
        # 定义常量值
        args = [2, 1, 3, 4]  # a,b,c,d
        args1 = [2, 5, 6, 4] 
        # 设置初始猜测值
        x0 = np.asarray((0.5, 0.5))
        #设置限制条件
        '''Equality constraint means that the constraint function result is
         to be zero whereas inequality means that it is to be non-negative'''
        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)
    

    参考文献
    scipy,optimize.minimize
    ronaldo_liu2018的博客: python 非线性规划(scipy.optimize.minimize)

    展开全文
  • python中,如何用scipy.optimize.minimize进行多变量的最小化? yjj8h487 LV8 2017-08-06 我用这个测试>>>sq=lambdax,y:x**2+y**2>>>fromscipy.optimizeimportminimize>>>minimize(sq,[1...
  • 我将逐行检查您的代码,并强调一些问题:from scipy.optimize import minimizeimport numpy as npprices=np.array([[1.5,50,30]])xp =np.array([[1.5,50,30]])prices和xp是向量,不是矩阵,使用np.array([1.5,50,30]...
  • scipy.optimize.minimize限制为整数值

    千次阅读 2021-01-11 21:58:03
    from scipy.optimize import brute import itertools def f(x): return (481.79/(5+x[0]))+(412.04/(4+x[1]))+(365.54/(3+x[2])) ranges = (slice(0, 9, 1),) * 3 result = brute(f, ranges, disp=True, finish=None...
  • # 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:变量...
  • from scipy.optimize import brute import itertools def f(x): return (481.79/(5+x[0]))+(412.04/(4+x[1]))+(365.54/(3+x[2])) ranges = (slice(0, 9, 1),) * 3 result = brute(f, ranges, disp=True, finish=...
  • args = (arg1,arg2,...,argm) # 这是函数的其他不用回归的已知的输入参数 res = minimize(func(args), x_init , method = 'SLSQP', bounds = bds_ ) 得到的结果是自变量x0,x1,...,xn的一组值,它们是使得函数real...
  • 师哥发给我一份他改写的scipy.optimize.minimize的函数,说是用这个就可以定出位置,然后让我好好看一看,最好能看懂,如下(注释是我自己写的,不知道都对不对) def opt_location(range, anchors): #range是真实测...
  • python 非线性规划(scipy.optimize.minimize

    万次阅读 多人点赞 2018-08-09 13:48:34
    https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html 来看下改方法的入参  scipy.optimize.minimize(fun, x0, args=(), method=None, jac=None, hess=None, hessp=None, ...
  • from scipy.optimize import minimize # optimize 1 # f(x) = 2xy + 2x - x^2 - 2y^2; x^3 - y = 0; y - 1 >=0 def func(x, sign=1.0): return sign * (2*x[0]*x[1] + 2*x[0] -x[0]**2 -2*x[1]**2) def func_...
  • import numpy as npimport pandas as pdfrom scipy.optimize import minimizedef get_y_hat(x_, y_, args):return (x_ * 100) / (1 + args[0]) + (x_ * 100 + y_) / (1 + args[1]) ** 2def opt_target(args, df):# ...
  • scipy.optimize.minimize()函数中的method参数可以选择'L-BFGS-B',想要知道它的原理,但是网上介绍的都是L-BFGS算法,它们之间关系是什么?L-BFGS-B是什么原理?
  • 问题1:IndexError: too ...而我是由于用scipy.optimize.minimize()做优化时,传入的参数x0 = theta的shape为矩阵,而官方要求是向量的形式!(哎,太粗心啦) 问题2:ValueError: shapes (2,2) and (1,2) not align...
  • 1 # coding=utf-8 ... 3 from scipy import optimize 4 import numpy as np 5 15 def get(args): 16 a, b, c, d, e, f, g, h = args 17 fun = lambda x:a*x[0]**g+b*x[0]*x[1]+c*x[1]**h...
  • minimize(cost_function,x_center,method='nelder-mead',options={'initial_simplex':x0,'xatol': xatol,'fatol': fatol, 'disp': True}) print(res.x) x_ = np.array([x[0] for x in xs]) y_ = np.array([x[1] for ...
  • Python中scipy.optimize求解有无约束的最优化算法举例(附代码)
  • scipy.optimize.minimize

    2020-12-13 14:31:27
    def fff(x1,x2,x3): return (x1[0]-x2)**2+(x1[1]-x3)**2 ...result = minimize(fff, [0,1], (1,2)) # x0可以是列表,但只对应相应函数的第一个位置,args必须是tuple,对应所有剩下位置。 result.x # 参数拟合值

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,900
精华内容 760
关键字:

scipy.optimize.minimize