将约束应用于scipy.optimize.minimize？中的目标函数？ 如0 <=目标<= 1

Question

I'm trying to apply scipy.optimize.minimize to solve this problem, but I haven't been able to apply constraints to the objective function.

In the code, objective function is lamb(weights). However, its value needs to be between -1 and 0 . I tried this with the constraints const15 and const16 , but the solution doesn't seem to be affected.

Can anyone see what's wrong?

PS: I know the code is amateur, I'm still learning Python.

def lamb(weights):
    theta1 = 0.1
    theta2 = 0.2
    theta3 = 0.7
    l = weights[10]
    return (-1 * ((theta1*l) + (theta2*l) + (theta3*l)))

def const1(weights):
    f1 = 0
    for i in range(len(m_ord)):
        f1 += m_ord[i][perfil]*weights[i]
    print(weights[10])

    return ((f1 - lower_bounds[0])/(upper_bounds[0] - lower_bounds[0]) - theta1*weights[10])

def func2(weights):
    f2 = 0
    for i in range(len(m_ord)):
        f2 += retorno_doze[i]*weights[i]
    return f2

def const2(weights):
    f2 = func2(weights)
    return ((f2 - lower_bounds[1])/(upper_bounds[1] - lower_bounds[1]) - theta2*weights[10])

def const3(weights):
    f2 = func2(weights)
    f3 = 0
    for i in range(len(m_ord)):
        f3 += abs(retorno_doze[i] - f2)

    f3 = f3 / (2 * num_fundos)

    return ((upper_bounds[2] - f3)/(upper_bounds[2] - lower_bounds[2]) - theta3*weights[10])

def const4(weights):
    return (weights[0] - (investimento_inicial[0] / financeiro))

def const5(weights):
    return (weights[1] - (investimento_inicial[1] / financeiro))

def const6(weights):
    return (weights[2] - (investimento_inicial[2] / financeiro))

def const7(weights):
    return (weights[3] - (investimento_inicial[3] / financeiro))

def const8(weights):
    return (weights[4] - (investimento_inicial[4] / financeiro))

def const9(weights):
    return (weights[5] - (investimento_inicial[5] / financeiro))

def const10(weights):
    return (weights[6] - (investimento_inicial[6] / financeiro))

def const11(weights):
    return (weights[7] - (investimento_inicial[7] / financeiro))

def const12(weights):
    return (weights[8] - (investimento_inicial[8] / financeiro))

def const13(weights):
    return (weights[9] - (investimento_inicial[9] / financeiro))

#EQUALITY CONSTRAINT
def const14(weights):
    return np.sum(weights[:10]) - 1

def const15(weights):
    return (lamb(weights) + 1)

def const16(weights):
    return (-1 * lamb(weights))

bnds = (0.0, 1.0)
bounds = tuple(bnds for fund in range(len(m_ord)+1))

x0 = (num_fundos+1)*[1./num_fundos,]
x0[10] = -0.5

cons = (
    {'type':'ineq','fun':const1},
    {'type':'ineq','fun':const2},
    {'type':'ineq','fun':const3},
    {'type':'ineq','fun':const4},
    {'type':'ineq','fun':const5},
    {'type':'ineq','fun':const6},
    {'type':'ineq','fun':const7},
    {'type':'ineq','fun':const8},
    {'type':'ineq','fun':const9},
    {'type':'ineq','fun':const10},
    {'type':'ineq','fun':const11},
    {'type':'ineq','fun':const12},
    {'type':'ineq','fun':const13},
    {'type':'eq','fun':const14},
    {'type':'ineq','fun':const15},
    {'type':'ineq','fun':const16},
)

result = sco.minimize(lamb, x0, method='CG', bounds=bounds, constraints=cons)

print(result)

The solution value I'm getting is not between -1 and 0.
Also, you can see that the values of x[0] to x[9] did not change at all.

 fun: -89478484.5
 jac: array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
 message: 'Optimization terminated successfully.'
 nfev: 195
 nit: 1
 njev: 15
 status: 0
 success: True
 x: array([1.00000000e-01, 1.00000000e-01, 1.00000000e-01, 1.00000000e-01,
   1.00000000e-01, 1.00000000e-01, 1.00000000e-01, 1.00000000e-01,
   1.00000000e-01, 1.00000000e-01, 8.94784845e+07])

Answer 1

The first step for debugging would be checking the docs :

constraints{Constraint, dict} or List of {Constraint, dict}, optional

Constraints definition ( only for COBYLA, SLSQP and trust-constr )

As you explicitly enforce the use of method=CG , you should not be surprised that the solver will ignore your constraints.

It should warn you though:

# - constraints or bounds
if (meth in ('nelder-mead', 'powell', 'cg', 'bfgs', 'newton-cg', 'dogleg',
             'trust-ncg') and (bounds is not None or np.any(constraints))):
    warn('Method %s cannot handle constraints nor bounds.' % method,
         RuntimeWarning)