Class TestMultiObjectiveNumpy

tests/test_convergence.py:371–442

@unittest.skipUnless(numpy, "requires numpy")
class TestMultiObjectiveNumpy(TearDownCreatorTestCase):
    def setUp(self):
        creator.create(FITCLSNAME, base.Fitness, weights=(-1.0, -1.0))
        creator.create(INDCLSNAME, numpy.ndarray, fitness=creator.__dict__[FITCLSNAME])

    def test_mo_cma_es(self):

        def distance(feasible_ind, original_ind):
            """A distance function to the feasibility region."""
            return sum((f - o)**2 for f, o in zip(feasible_ind, original_ind))

        def closest_feasible(individual):
            """A function returning a valid individual from an invalid one."""
            feasible_ind = numpy.array(individual)
            feasible_ind = numpy.maximum(BOUND_LOW, feasible_ind)
            feasible_ind = numpy.minimum(BOUND_UP, feasible_ind)
            return feasible_ind

        def valid(individual):
            """Determines if the individual is valid or not."""
            if any(individual < BOUND_LOW) or any(individual > BOUND_UP):
                return False
            return True

        NDIM = 5
        BOUND_LOW, BOUND_UP = 0.0, 1.0
        MU, LAMBDA = 10, 10
        NGEN = 500

        numpy.random.seed(128)

        # The MO-CMA-ES algorithm takes a full population as argument
        population = [creator.__dict__[INDCLSNAME](x) for x in numpy.random.uniform(BOUND_LOW, BOUND_UP, (MU, NDIM))]

        toolbox = base.Toolbox()
        toolbox.register("evaluate", benchmarks.zdt1)
        toolbox.decorate("evaluate", tools.ClosestValidPenalty(valid, closest_feasible, 1.0e+6, distance))

        for ind in population:
            ind.fitness.values = toolbox.evaluate(ind)

        strategy = cma.StrategyMultiObjective(population, sigma=1.0, mu=MU, lambda_=LAMBDA)

        toolbox.register("generate", strategy.generate, creator.__dict__[INDCLSNAME])
        toolbox.register("update", strategy.update)

        for gen in range(NGEN):
            # Generate a new population
            population = toolbox.generate()

            # Evaluate the individuals
            fitnesses = toolbox.map(toolbox.evaluate, population)
            for ind, fit in zip(population, fitnesses):
                ind.fitness.values = fit

            # Update the strategy with the evaluated individuals
            toolbox.update(population)