可变约束Sci Py最小化

如何解决可变约束Sci Py最小化

我正在尝试进行以下优化。这是来自更大模型的MWE。

它旨在通过更多的时间步长来优化函数，以控制两个变量alfa和beta。

我想施加一个约束，使Z> 0.5。

我试图将其强加如下：

opt.minimize(obj... constraints={'type':'ineq','fun':lambda Z: -Z+0.5})```
but it seems getting ignored,and I get values of Z greater than constraint. 

MWE follows. 

import numpy as np
import scipy.optimize as opt

#defining timesteps

t = np.arange(1,11)
NT = len(t)


#defining bounds for control variables and initial values 

alfa_l=np.full(NT,0)
alfa_h=np.full(NT,1)
bnds_alfa=[]

for i in range(NT):
    bnds_alfa.append((alfa_l[i],alfa_h[i]))  

beta_l=np.full(NT,0.7)
beta_h=np.full(NT,1.1)

bnds_beta=[]

for i in range(NT):
    bnds_beta.append((beta_l[i],beta_h[i]))


alfa_start=0.99*alfa_h
alfa_start[alfa_start < alfa_l] = alfa_l[alfa_start < alfa_l]
alfa_start[alfa_start > alfa_h] = alfa_l[alfa_start > alfa_h]

beta_start = 0.99*beta_h
beta_start[beta_start < beta_l] = beta_l[beta_start < beta_l]
beta_start[beta_start > beta_h] = beta_h[beta_start > beta_h]

bnds=bnds_alfa+bnds_beta
x_start = np.concatenate([alfa_start,beta_start])

定义变量的初始值：

Y=np.zeros(NT)
Z=np.zeros(NT)
alfa=np.zeros(NT)
beta=np.zeros(NT)

定义函数和目标函数：

def fY(iY,ibeta,ialfa,index):
    
    if index==0:
        return 1
    else:
        return iY[index-1]*((ialfa[index]*0.5-ibeta[index]*0.2))


def fZ(iZ,index):
    
    if index==0:
        return 1 
    else:
        return iZ[index-1]*((ibeta[index]*0.3-ialfa[index]*0.1))

def foutput(iY,iZ,output,index):
    
     output[0]=iY[index]*iZ[index]

定义目标函数：对于每个时间步，它都会找到alfa和beta的值以最小化输出

def Obj(x,sign,iY,iNT):
    
    ialfa=x[0:NT]
    ibeta=x[NT:(2*NT)]

    for i in range(iNT):
        iY[i]=fY(iY,i)
        iZ[i]=fZ(iZ,i)
        
    output=np.zeros(1)
    foutput(iY,i)
    
    return sign*output

最后，以下函数返回最佳值。

def Optimality(x,iNT):
    ialfa=x[0:NT]
    ibeta=x[NT:(2*NT)]
    
    for i in range(iNT):
        iY[i]=fY(iY,i)
        output=np.zeros(1)
        foutput(iY,i)
        
    return (-1*output,iNT)


result=opt.minimize(Obj,x_start,args=(-1,Y,Z,NT),method='SLSQP',bounds = tuple(bnds),options={'disp': True,'maxiter':1000},constraints={'type':'ineq','fun':lambda Z: -Z+0.5})


Values=Optimality(result.x,NT)