Can Pymoo optimize the matrix as a variable?

[hangtianzhang]

First of all, I think Pymoo is a very powerful and comprehensive tool, thanks Julian!
Now I have some trouble optimizing my own problem with Pymoo:

1. Can Pymoo optimize the matrix? My question contains 6 variables, each of which contains the value corresponding to 24 hours, so the result of my request is a matrix with dimension (24,6), but now I don't know if this is feasible.
2. When running the code I wrote, the problem of dimension mismatch always appears：

[blankjul]

If you optimize a matrix this is not a big deal. Let the algorithm optimize the array which is flattend (1 dimensional) and then just reshape in your function evaluation.
Using elementwise_evaluation=True makes your life easier in this case (see Getting Started Guide). Or you can do a 3d reshape too.

import numpy as np

from pymoo.algorithms.so_genetic_algorithm import GA
from pymoo.model.problem import Problem
from pymoo.optimize import minimize


class MyProblem(Problem):

    def __init__(self, **kwargs):
        super().__init__(n_var=6 * 24,
                         n_obj=1,
                         n_constr=0,
                         xl=0,
                         xu=1,
                         type_var=np.double,
                         elementwise_evaluation=True,
                         **kwargs)

    def _evaluate(self, x, out, *args, **kwargs):
        x = x.reshape(6, 24)
        out["F"] = x.sum(axis=1).prod()


algorithm = GA()
res = minimize(MyProblem(),
               algorithm,
               ('n_gen', 200),
               seed=1,
               verbose=True)

print(res.X)
print(res.F)

[hangtianzhang]

Thank you for your quick reply! What you said is very helpful, but I still have two questions:
1). If the boundary of the variable has a specific value, my variable is a 246 array, and I want to optimize each element in this array. So does my variable boundary also have to be a 246 array, and set the corresponding element value in the boundary array to limit the range of the element?
2). As you said, setting the lower boundary to 0 and the upper boundary to 1 will indeed work. But now I want to set a more realistic boundary. I don't know how to do it.
Please see the picture for the problem description

[blankjul]

Why an array with 246 values? 24 * 6 = 144?
And the answer is yes. For the algorithm it is just a vector with one dimension and does not care that you encode it to a matrix in the _evaluate function.

As said you have to flatten the array to one dimension for xl and xu too.

For instance:

import numpy as np

from pymoo.algorithms.so_genetic_algorithm import GA
from pymoo.model.problem import Problem
from pymoo.optimize import minimize


class MyProblem(Problem):

    def __init__(self, **kwargs):

        n_columns = 6
        n_rows = 24

        xl = np.array([0, 0, 0, 0, 0, 0])
        xu = np.array([1000, 1000, 50, 213, 120, 200])

        super().__init__(n_var=n_rows * n_columns,
                         n_obj=1,
                         n_constr=0,
                         xl=xl[None, :].repeat(n_rows, axis=0).flatten(),
                         xu=xu[None, :].repeat(n_rows, axis=0).flatten(),
                         type_var=np.double,
                         elementwise_evaluation=True,
                         **kwargs)

    def _evaluate(self, x, out, *args, **kwargs):
        x = x.reshape(24, 6)
        out["F"] = x.sum(axis=1).sum()


algorithm = GA()
res = minimize(MyProblem(),
               algorithm,
               ('n_gen', 200),
               seed=1,
               verbose=True)

print(res.X)
print(res.F)

[hangtianzhang]

Thank you for your answers. My problem seems to have been resolved. thank you very much. I want to learn Pymoo in depth and apply it to engineering optimization problems. However, I can't understand Pymoo's underlying calculation process in depth by looking at the API reference documentation, so I hope you can give some suggestions:

1. Can I just learn the API and then set the parameters?
2. Is it necessary to learn the underlying calculation process of Pymoo?

[blankjul]

For the API I usually refer to our documentation. It is not perfect for sure but I think it covers for most algorithms how to get started and what parameters are available.

If you work in the field and you intend to design or there is a need for you to customize algorithms, then you will need to understand more of the internals. But before you should be comfortable with the algorithms itself and the papers published by the others before you start looking at the code. (or in general to know the basics of evolutionary and/or multi-objective optimization)

[hangtianzhang]

Sorry to bother you again, but now I have encountered a new problem. After I adjust the data structure, the program always shows the error "<=' not supported between instances of'NoneType' and'int". I paste the entire program here, I hope you can help me see it

`import matplotlib.pyplot as plt
import numpy as np

from pymoo.algorithms.nsga2 import NSGA2
from pymoo.algorithms.so_genetic_algorithm import GA
from pymoo.model.problem import Problem
from pymoo.optimize import minimize
from pymoo.visualization.scatter import Scatter

power_price=np.array([0.233,0.233,0.233,0.233,0.233,0.233,0.233,0.233,0.886,0.886,0.886,0.559,0.559,0.559,0.559,0.559,0.559,0.886,0.886,0.559,0.559,0.559,0.233,0.233]).reshape(24,)
gas_price=np.zeros([24,])+3.45

raw_lower_bound=np.array([19.4,0,20,20,20,0])
raw_upper_bound=np.array([65,1000,200,200,200,180])

lower_bound=np.tile(raw_lower_bound,24)
upper_bound=np.tile(raw_upper_bound,24)

Le=np.array([190.39, 174.68, 159.89, 169.13, 146.95, 82.26, 132.16, 146.95,229.21, 223.66, 235.67, 252.31, 260.63, 255.08, 251.39, 265.25,275.42, 296.67, 251.39, 292.98, 300.37, 303.14, 280.04, 248.61]).reshape(24,)
Lc=np.array([299.81, 304.42, 341.57, 358.97, 285.71, 278.69, 208.93, 221.67,341.34, 332. , 363.34, 371.44, 377.21, 382.99, 388.76, 351.53,370.09, 353.78, 347.93, 333.94, 328.1 , 342. , 318.72, 296.6 ]).reshape(24,)
Lh=np.array([102.36, 108.78, 133.65, 137.31, 130.81, 140 , 121.51, 129.78,145.43, 152.77, 159.19, 187.75, 212.62, 193.21, 161.81, 131.33,106.38, 125.72, 178.27, 191.14, 218.78, 197.53, 152.29, 202.07]).reshape(24,)

class MyProblem(Problem):

def __init__(self,**kwargs):
    '''
xu=[65,1000,200,200,200,180]    
X=[Vmt,Pgrid,Cec,Qeb,Cac,Qhe_out]
xl=[19.4,0,20,20,20,0]

min(Vmt*gas_price+Pgrid*power_price)

s.t. 
Le-Pgrid-Vmt*0.32*9.7+Cec*0.25+Qeb/0.94<=0
Lh-Qeb-Qhe_out<=0
Lc-Cac-Cec<=0
Cac/1.69+Qhe_out/0.9-Vmt*9.7*0.6<=0

19.4<=Vmt<=65
0<=Pgird<=1000
20<=Cec<=200
20<=Qeb<=200
0<=Qhe_out<=180
    '''
    super().__init__(n_var=24*6,
                     n_obj=1,
                     n_constr=4,
                     xl=raw_lower_bound[None, :].repeat(24, axis=0).flatten(),
                     xu=raw_upper_bound[None, :].repeat(24, axis=0).flatten(),
                     type_var=np.double,
                     elementwise_evaluation=True,
                     **kwargs)

def _evaluate(self,X,out,*args,**kwargs):
    
    X=X.reshape(24,6)
    #define a objective function
    # min(Vmt*gas_price+Pgrid*power_price)
    f1=np.sum((X[:,0].reshape(24,1)*gas_price)+(X[:,1].reshape(24,1)*power_price))
    
    g1=Le-X[:,1]-X[:,0]*0.32*9.7+X[:,2]*0.25+X[:,3]/0.94
    g2=Lh-X[:,3]-X[:,5]
    g3=Lc-X[:,2]-X[:,4]
    g4=X[:,4]/1.69+X[:,5]/0.9-X[:,0]*0.6*9.7
    
    
    
    out['F']=X.sum(axis=1).sum()

problem = MyProblem()
algorithm=NSGA2()
res=minimize(problem,
algorithm,
('n_gen',200),
seed=1,
verbose=True)

print(res.X)
`

[blankjul]

Please post your question in a readable format and make sure that one can copy the code directly. Also, you will have to learn debugging to quickly figure out what is going wrong. Your code did not run for a couple of reasons.
You have not assigned the objective and the constraints at all in your problem. Moreover, g1 to g4 are not scalars as they are supposed to be if elementwise_evaluation is set to true.

Please have another look at the Getting Started Guide for such matters.

I am not sure what exactly you are intending to do, but this might be it:

import numpy as np

from pymoo.algorithms.nsga2 import NSGA2
from pymoo.model.problem import Problem
from pymoo.optimize import minimize

power_price = np.array(
    [0.233, 0.233, 0.233, 0.233, 0.233, 0.233, 0.233, 0.233, 0.886, 0.886, 0.886, 0.559, 0.559, 0.559, 0.559, 0.559,
     0.559, 0.886, 0.886, 0.559, 0.559, 0.559, 0.233, 0.233]).reshape(24, )
gas_price = np.zeros([24, ]) + 3.45

raw_lower_bound = np.array([19.4, 0, 20, 20, 20, 0])
raw_upper_bound = np.array([65, 1000, 200, 200, 200, 180])

lower_bound = np.tile(raw_lower_bound, 24)
upper_bound = np.tile(raw_upper_bound, 24)

Le = np.array(
    [190.39, 174.68, 159.89, 169.13, 146.95, 82.26, 132.16, 146.95, 229.21, 223.66, 235.67, 252.31, 260.63, 255.08,
     251.39, 265.25, 275.42, 296.67, 251.39, 292.98, 300.37, 303.14, 280.04, 248.61]).reshape(24, )
Lc = np.array(
    [299.81, 304.42, 341.57, 358.97, 285.71, 278.69, 208.93, 221.67, 341.34, 332., 363.34, 371.44, 377.21, 382.99,
     388.76, 351.53, 370.09, 353.78, 347.93, 333.94, 328.1, 342., 318.72, 296.6]).reshape(24, )
Lh = np.array(
    [102.36, 108.78, 133.65, 137.31, 130.81, 140, 121.51, 129.78, 145.43, 152.77, 159.19, 187.75, 212.62, 193.21,
     161.81, 131.33, 106.38, 125.72, 178.27, 191.14, 218.78, 197.53, 152.29, 202.07]).reshape(24, )


class MyProblem(Problem):

    def __init__(self, **kwargs):
        super().__init__(n_var=24 * 6,
                         n_obj=1,
                         n_constr=4,
                         xl=raw_lower_bound[None, :].repeat(24, axis=0).flatten(),
                         xu=raw_upper_bound[None, :].repeat(24, axis=0).flatten(),
                         type_var=np.double,
                         elementwise_evaluation=True,
                         **kwargs)

    def _evaluate(self, X, out, *args, **kwargs):
        X = X.reshape(24, 6)
        f1 = np.sum((X[:, 0].reshape(24, 1) * gas_price) + (X[:, 1].reshape(24, 1) * power_price))

        g1 = Le - X[:, 1] - X[:, 0] * 0.32 * 9.7 + X[:, 2] * 0.25 + X[:, 3] / 0.94
        g2 = Lh - X[:, 3] - X[:, 5]
        g3 = Lc - X[:, 2] - X[:, 4]
        g4 = X[:, 4] / 1.69 + X[:, 5] / 0.9 - X[:, 0] * 0.6 * 9.7

        out['F'] = f1
        out['G'] = np.array([g1.max(), g2.max(), g3.max(), g4.max()])


problem = MyProblem()
algorithm = NSGA2()
res = minimize(problem,
               algorithm,
               ('n_gen', 200),
               seed=1,
               verbose=True)

print(res.X)

[hangtianzhang]

Sorry to interrupt you again, I have been looking at pymoo's documentation these days. However, it may be that my python level is too low, and I still can't figure out the meaning of the constraint part in the out dictionary, so I still have two questions for you:

1. What does the following code snippet represent?

out['F']=[f1.min(),f2.min()] out['G'] =np.array([g1.max(), g2.max(), g3.max(), g4.max()])
2. The result of the multi-objective optimization process I wrote through your code and examples in the document does not contain the Pareto front and the Pareto solution set. When printing the Pareto solution set of the problem, the result is displayed as empty value?
I did not find anything related to out information in the document

[blankjul]

1. g1 is a vector of size 24. But if you are setting n_constr=4 and you have g1 to g4 it can only be a scalar right?
   did you right down a complete mathematical definition of your problem? Taking the max makes sure none of the entries in g1 to g4 are bigger than zero.

2. The code you send me had only f1 and no second objective. It can't be a nds front for that reason.
   Also you have to increase n_gen because it takes a while to find a feasible solution for your problem. A GA on your single-objective problem is able to find a feasible solution after about 500 generations.