Setting constraint violation

[michaelarman]

Hello, I have built an optimization system using platypus but this library seems a lot better and well documented. One thing I couldn't find much on was the set_cv function. What is G supposed to be? For example if after a generation I have a list of values that are 0 if feasible and nonzero if not feasible then would that be the G variable I pass to set_cv or is it done a different way? This is for using the ask and tell problem independent approach.

[blankjul]

The constraint violationcv is calculated internally.
You are setting the constraint values G, where positive means the constraint is violated and zero or negative means satisfied.

Checkout the getting started guide for an example:
https://pymoo.org/getting_started/part_1.html

[michaelarman]

Thank you!
Another question: when using the ask and tell approach, should the mutation, sampling and other operators be within the for loop or do I need to make custom operators and pass it to the algorithm? Also where does the selection take place and what happens in the algorithm.tell() method?
E.g.

# set the meta-data of the problem (necessary to initialize the algorithm)
problem = Problem(n_var=30, n_obj=2, n_constr=0, xl=np.zeros(30), xu=np.ones(30))

# create the algorithm object
algorithm = NSGA2(pop_size=100,crossover=None,mutation=None)

# let the algorithm object never terminate and let the loop control it
termination = NoTermination()

# create an algorithm object that never terminates
algorithm.setup(problem, termination=termination)

# fix the random seed manually
np.random.seed(1)

# until the algorithm has no terminated
for n_gen in range(10):

    # ask the algorithm for the next solution to be evaluated
    pop = algorithm.ask()

    # get the design space values of the algorithm
    X = pop.get("X")

    # implement your evluation. here ZDT1
    f1 = X[:, 0]
    v = 1 + 9.0 / (problem.n_var - 1) * np.sum(X[:, 1:], axis=1)
    f2 = v * (1 - np.power((f1 / v), 0.5))

    # objectives
    pop.set("F", np.column_stack([f1, f2]))

    # for constraints
    # pop.set("G", the_constraint_values))

    # this line is necessary to set the CV and feasbility status - even for unconstrained
    set_cv(pop)

    # returned the evaluated individuals which have been evaluated or even modified
    algorithm.tell(infills=pop)

    # use operators 
    X = custom_mutation(X)
    pop.set("X",X)

    # do same more things, printing, logging, storing or even modifying the algorithm object
    print(algorithm.n_gen)


# obtain the result objective from the algorithm
res = algorithm.result()

[blankjul]

For all of that, you need custom operators and pass them during algorithm initialization.
For an example see look here: https://pymoo.org/customization/subset.html

For full customization, you can also implement your own algorithm and override the infill and advance methods.

[michaelarman]

Would it work the same way if I use custom functions for the operators and call them in the loop and initialize the algorithm with None? I'm just concerned with the parallelization of the operators

[blankjul]

I am not sure what you are referring to. Can you be more precise or give an example?

[michaelarman]

Yes, so for instance using the ask and tell approach you can do the evaluation within the for loop. So I was wondering if you can do the same with other operators, instead of creating classes for them and adding them to the algorithm.

e.g.

algorithm = NSGA2(pop_size=100, mutation=None, crossover=None)

for n_gen in range(10):
    # ask the algorithm for the next solution to be evaluated
    # get design space
    # evaluate
    # infill
    # mutation
    # other operators etc

[blankjul]

Yes, that works. In theory, you do not need to take the values from ask directly, but you can provide entirely different ones to tell. Even though that of course means you are running a different algorithm.