TypeError: x must be a python list of GEKKO parameters, variables, or expressions

user_14905377 0
Viewed 238

I try to solve an optimization problem with Gekko in google Collab and this error is shown (in line 91 m.Obj(m.sum(m.sum(((xl[i](D_input[i] + D_output[i])/0.5)+ (xf[i][j]((D_input[i] / ru[i][j]) + (D_output[i] / rd[i][j]) +((D_input[i] + D_output[i]) / rf[i][j])))+ (xc*((D_input[i] / ru[i][j]) + (D_output[i] / rd...): TypeError: x must be a python list of GEKKO parameters, variables, or expressions

 !pip install gekko
 from gekko import GEKKO
 m = GEKKO() 
 MU = 5
 FN = 3
 Cloud = 1
 D_input = m.Param(value=[2, 4, 7, 6, 9])   
 D_output = m.Param(value=[0.2, 0.25, 0.6, 0.35, 0.81])        
 RF_total = m.Param(value=[10, 10, 10])       
 RU_total = m.Param(value=[72, 72, 72]) 
 RD_total = m.Param(value=[72, 72, 72])
 c = m.Param(value=[0.2, 0.4, 0.7, 0.6, 0.9]) 
 tr = m.Param(value=[10, 10, 10, 10, 10]) 
 fl = m.Param(value=[0.5, 0.5, 0.5, 0.5, 0.5]) 
 nu = m.Const(1.37)
 fc = m.Const(10)
 wc = m.Const(5)
 eu = m.Const(0.142)
 ed = m.Const(0.142) 
 euc = m.Const(0.658) 
 edc = m.Const(0.278)
 el = m.Param(value=[0.0, 0.0, 0.0, 0.0, 0.0]) 
 eed = m.Param(value=[[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 
 0.0]])
 eeu = m.Param(value=[[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 
 0.0]])
 eedc = m.Param(value=[0.0, 0.0, 0.0, 0.0, 0.0])
 eeuc = m.Param(value=[0.0, 0.0, 0.0, 0.0, 0.0])
 eef = m.Param(value=[[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 
 0.0]])
 eec = m.Param(value=[0.0, 0.0, 0.0, 0.0, 0.0])

 for i in range(MU) :
    el[i] = nu * c[i]
 for i in range(MU) :
  for j in range(FN) :
    eed[i][j] = D_output[i] * ed  
    eeu[i][j] = D_input[i] * eu 
 for i in range(MU) :
   for j in range(FN) :
     eef[i][j] = eeu[i][j] + eed[i][j]
 for i in range(MU) :
   eedc[i] = edc * D_output[i]
   eeuc[i] = euc * D_input[i]
 for i in range(MU) :
    eec[i] = eeuc[i] + eedc[i]


 xf = [[m.Var(value=0,lb=0,ub=1,integer=True) for j in range(FN)] for i in range(MU)]
 xc = m.Var(value=0,lb=0,ub=1,integer=True) 
 xl = [m.Var(value=0,lb=0,ub=1,integer=True) for i in range(MU)]

 ru = [[m.Var(value=0.01, lb=0.01, ub=72.0) for j in range(FN)] for i in range(MU)]
 rd = [[m.Var(value=0.01, lb=0.01, ub=72.0) for j in range(FN)] for i in range(MU)]
 rf = [[m.Var(value=0.01, lb=0.01, ub=10.0) for j in range(FN)] for i in range(MU)]

 for j in range(FN):
   m.Equation(sum(rf[i][j] for i in range(MU)) <= 10)
 for j in range(FN):
   m.Equation(sum(ru[i][j] for i in range(MU)) <= 72)
 for j in range(FN):
   m.Equation(sum(rd[i][j] for i in range(MU)) <= 72)
 for i in range(MU):
   m.Equation(xc + xl[i] + sum(xf[i][j] for j in range(FN)) == 1)
 for i in range(MU):
   m.Equation(xl[i]*(( D_input[i] + D_output[i])/0.5) <= 7) 
 for j in range(FN):
   for i in range(MU):
     m.Equation(((xf[i][j]*((D_input[i] / ru[i][j]) + (D_output[i] / rd[i][j]) + ((D_input[i] + 
 D_output[i]) / rf[i][j])))) <= 7)
 for i in range(MU):
   m.Equation(((xc*((D_input[i] / ru[i][j]) + (D_output[i] / rd[i][j]) + (3*(D_input[i] + 
   D_output[i]) / 10)))) <= 7) 
 for i in range(MU):
    m.Equation(((D_input[i] + D_output[i])/0.5) <= tr[i]) 
 for j in range(FN):
   for i in range(MU):
      m.Equation(((((D_input[i] / ru[i][j]) + (D_output[i] / rd[i][j]) + ((D_input[i] + D_output[i]) 
  / rf[i][j])))) <= tr[i])
 for i in range(MU):
    m.Equation(((((D_input[i] / ru[i][j]) + (D_output[i] / rd[i][j]) + (3*(D_input[i] + D_output[i]) / 10)))) <= tr[i])           
                
 m.Obj(m.sum(m.sum(((xl[i]*(D_input[i] + D_output[i])/0.5)+\
         (xf[i][j]*((D_input[i] / ru[i][j]) + (D_output[i] / rd[i][j]) +((D_input[i] + D_output[i]) / 
  rf[i][j])))+\
         (xc*((D_input[i] / ru[i][j]) + (D_output[i] / rd[i][j]) + (3*(D_input[i] + D_output[i]) / 
  10))))+\
     (xf[i][j]*eef[i][j]) + (xc*eec[i]) + (xl[i]*el[i]) for i in range(MU)) for j in range(FN)))

 m.options.SOLVER=1  
 m.solver_options = ['minlp_maximum_iterations 500', \
                # minlp iterations with integer solution
                'minlp_max_iter_with_int_sol 10', \
                # treat minlp as nlp
                'minlp_as_nlp 0', \
                # nlp sub-problem max iterations
                'nlp_maximum_iterations 50', \
                # 1 = depth first, 2 = breadth first
                'minlp_branch_method 1', \
                # maximum deviation from whole number
                'minlp_integer_tol 0.05', \
                # covergence tolerance
                'minlp_gap_tol 0.01']

 m.solve()
 print('Results')
 print('Objective: ' + str(m.options.objfcnval))

please help me Thanks.

gekko optimization python
2 Answers
xf = [[m.Var(value=0,lb=0,ub=1,integer=True) for j in range(FN)] for i in range(MU)]
xc = m.Var(value=0,lb=0,ub=1,integer=True) 
xl = [m.Var(value=0,lb=0,ub=1,integer=True) for i in range(MU)]

ru = [[m.Var(value=0.01, lb=0.01, ub=72.0) for j in range(FN)] for i in range(MU)]
rd = [[m.Var(value=0.01, lb=0.01, ub=72.0) for j in range(FN)] for i in range(MU)]
rf = [[m.Var(value=0.01, lb=0.01, ub=10.0) for j in range(FN)] for i in range(MU)]

They are lists of lists of m.Var() objects.
We need to make it a list of m.Var() objects.
Not so familiar with Gekko but still hope this could help.

user_83291960

Use m.Array() to define multidimensional m.Param and m.Var values.

D_input = m.Array(m.Param,5)
for v in [2,4,7,6,9]:
    D_input[i].value = v

or

eef = m.Array(m.Param,(5,3),value=0)

Here is a minimal example problem:

from gekko import GEKKO
import numpy as np
m = GEKKO(remote=False)
ni = 3; nj = 2; nk = 4
# solve AX=B
A = m.Array(m.Var,(ni,nj),lb=0)
X = m.Array(m.Var,(nj,nk),lb=0)
AX = np.dot(A,X)
B = m.Array(m.Var,(ni,nk),lb=0)
# equality constraints
m.Equations([AX[i,j]==B[i,j] for i in range(ni) \
                             for j in range(nk)])
m.Equation(5==m.sum([m.sum([A[i][j] for i in range(ni)]) \
                                    for j in range(nj)]))
m.Equation(2==m.sum([m.sum([X[i][j] for i in range(nj)]) \
                                    for j in range(nk)]))
# objective function
m.Minimize(m.sum([m.sum([B[i][j] for i in range(ni)]) \
                                 for j in range(nk)]))
m.solve()
print(A)
print(X)
print(B)

Here are some additional matrix operations with Numpy:

import numpy as np
from gekko import GEKKO

m = GEKKO(remote=False)

# Random 3x3
A = np.random.rand(3,3)
# Random 3x1
b = np.random.rand(3,1)
# Gekko array 3x3
p = m.Array(m.Param,(3,3))
# Gekko array 3x1
y = m.Array(m.Var,(3,1))

# Dot product of A p
x = np.dot(A,p)
# Dot product of x y
w = np.dot(x,y)
# Dot product of p y
z = np.dot(p,y)
# Trace (sum of diag) of p
t = np.trace(p)

# solve Ax = b
s = m.axb(A,b)
m.solve()
user_23669410
Related