pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/core/infill.py

@@ -0,0 +1,65 @@
+from pymoo.core.duplicate import NoDuplicateElimination
+from pymoo.core.population import Population
+from pymoo.core.repair import NoRepair
+
+
+class InfillCriterion:
+
+    def __init__(self,
+                 repair=None,
+                 eliminate_duplicates=None,
+                 n_max_iterations=100,
+                 **kwargs):
+
+        super().__init__()
+        self.n_max_iterations = n_max_iterations
+        self.eliminate_duplicates = eliminate_duplicates if eliminate_duplicates is not None else NoDuplicateElimination()
+        self.repair = repair if repair is not None else NoRepair()
+
+    def __call__(self, problem, pop, n_offsprings, random_state=None, **kwargs):
+        return self.do(problem, pop, n_offsprings, random_state=random_state, **kwargs)
+
+    def do(self, problem, pop, n_offsprings, random_state=None, n_max_iterations=None, **kwargs):
+        if n_max_iterations is None:
+            n_max_iterations = self.n_max_iterations
+
+        # the population object to be used
+        off = Population.create()
+
+        # infill counter - counts how often the mating needs to be done to fill up n_offsprings
+        n_infills = 0
+
+        # iterate until enough offsprings are created
+        while len(off) < n_offsprings:
+
+            # how many offsprings are remaining to be created
+            n_remaining = n_offsprings - len(off)
+
+            # do the mating
+            _off = self._do(problem, pop, n_remaining, random_state=random_state, **kwargs)
+
+            # repair the individuals if necessary - disabled if repair is NoRepair
+            _off = self.repair(problem, _off, random_state=random_state, **kwargs)
+
+            # eliminate the duplicates
+            _off = self.eliminate_duplicates.do(_off, pop, off)
+
+            # if more offsprings than necessary - truncate them randomly
+            if len(off) + len(_off) > n_offsprings:
+
+                # IMPORTANT: Interestingly, this makes a difference in performance for some algorithms
+                n_remaining = n_offsprings - len(off)
+                _off = _off[:n_remaining]
+
+            # add to the offsprings and increase the mating counter
+            off = Population.merge(off, _off)
+            n_infills += 1
+
+            # if no new offsprings can be generated within a pre-specified number of generations
+            if n_infills >= n_max_iterations:
+                break
+
+        return off
+
+    def _do(self, problem, pop, n_offsprings, random_state=None, **kwargs):
+        pass

pymoo/core/initialization.py

@@ -0,0 +1,44 @@
+import numpy as np
+
+from pymoo.core.duplicate import NoDuplicateElimination
+from pymoo.core.population import Population
+from pymoo.core.repair import NoRepair
+from pymoo.util import default_random_state
+from pymoo.util.misc import at_least_2d_array
+
+
+class Initialization:
+
+    def __init__(self,
+                 sampling,
+                 repair=None,
+                 eliminate_duplicates=None) -> None:
+
+        super().__init__()
+        self.sampling = sampling
+        self.eliminate_duplicates = eliminate_duplicates if eliminate_duplicates else NoDuplicateElimination()
+        self.repair = repair if repair is not None else NoRepair()
+
+    @default_random_state
+    def do(self, problem, n_samples, random_state=None, **kwargs):
+
+        # provide a whole population object - (individuals might be already evaluated)
+        if isinstance(self.sampling, Population):
+            pop = self.sampling
+
+        else:
+            if isinstance(self.sampling, np.ndarray):
+                sampling = at_least_2d_array(self.sampling)
+                pop = Population.new(X=sampling)
+            else:
+                pop = self.sampling(problem, n_samples, random_state=random_state, **kwargs)
+
+        # repair all solutions that are not already evaluated
+        not_eval_yet = [k for k in range(len(pop)) if len(pop[k].evaluated) == 0]
+        if len(not_eval_yet) > 0:
+            pop[not_eval_yet] = self.repair(problem, pop[not_eval_yet], random_state=random_state, **kwargs)
+
+        # filter duplicate in the population
+        pop = self.eliminate_duplicates.do(pop)
+
+        return pop

pymoo/core/mating.py

@@ -0,0 +1,39 @@
+import math
+
+from pymoo.core.infill import InfillCriterion
+
+
+class Mating(InfillCriterion):
+
+    def __init__(self,
+                 selection,
+                 crossover,
+                 mutation,
+                 **kwargs):
+
+        super().__init__(**kwargs)
+        self.selection = selection
+        self.crossover = crossover
+        self.mutation = mutation
+
+    def _do(self, problem, pop, n_offsprings, parents=None, random_state=None, **kwargs):
+
+        # how many parents need to be select for the mating - depending on number of offsprings remaining
+        n_matings = math.ceil(n_offsprings / self.crossover.n_offsprings)
+
+        # if the parents for the mating are not provided directly - usually selection will be used
+        if parents is None:
+
+            # select the parents for the mating - just an index array
+            parents = self.selection(problem, pop, n_matings, n_parents=self.crossover.n_parents, random_state=random_state, **kwargs)
+
+        # do the crossover using the parents index and the population - additional data provided if necessary
+        off = self.crossover(problem, parents, random_state=random_state, **kwargs)
+
+        # do the mutation on the offsprings created through crossover
+        off = self.mutation(problem, off, random_state=random_state, **kwargs)
+
+        return off
+
+
+

pymoo/core/meta.py

@@ -0,0 +1,21 @@
+from copy import deepcopy
+
+
+class Meta(object):
+
+    def __init__(self, object, copy=True, clazz=None):
+        if clazz is None:
+            clazz = self.__class__
+
+        wrapped = object
+        if copy:
+            wrapped = deepcopy(wrapped)
+
+        self.__class__ = type(clazz.__name__,
+                              tuple([clazz] + wrapped.__class__.mro()),
+                              {})
+
+        self.__dict__ = wrapped.__dict__
+        self.__object__ = object
+        self.__super__ = wrapped
+

pymoo/core/mixed.py

@@ -0,0 +1,164 @@
+import math
+
+import numpy as np
+
+from pymoo.algorithms.base.genetic import GeneticAlgorithm
+from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival
+from pymoo.core.duplicate import ElementwiseDuplicateElimination
+from pymoo.core.individual import Individual
+from pymoo.core.infill import InfillCriterion
+from pymoo.core.population import Population
+from pymoo.core.problem import Problem
+from pymoo.core.sampling import Sampling
+from pymoo.core.variable import Choice, Real, Integer, Binary
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.crossover.ux import UX
+from pymoo.operators.mutation.bitflip import BFM
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.mutation.rm import ChoiceRandomMutation
+from pymoo.operators.repair.rounding import RoundingRepair
+from pymoo.operators.selection.rnd import RandomSelection
+from pymoo.util.display.single import SingleObjectiveOutput
+
+
+class MixedVariableMating(InfillCriterion):
+
+    def __init__(self,
+                 selection=RandomSelection(),
+                 crossover=None,
+                 mutation=None,
+                 repair=None,
+                 eliminate_duplicates=True,
+                 n_max_iterations=100,
+                 **kwargs):
+
+        super().__init__(repair, eliminate_duplicates, n_max_iterations, **kwargs)
+
+        if crossover is None:
+            crossover = {
+                Binary: UX(),
+                Real: SBX(),
+                Integer: SBX(vtype=float, repair=RoundingRepair()),
+                Choice: UX(),
+            }
+
+        if mutation is None:
+            mutation = {
+                Binary: BFM(),
+                Real: PM(),
+                Integer: PM(vtype=float, repair=RoundingRepair()),
+                Choice: ChoiceRandomMutation(),
+            }
+
+        self.selection = selection
+        self.crossover = crossover
+        self.mutation = mutation
+
+    def _do(self, problem, pop, n_offsprings, parents=False, random_state=None, **kwargs):
+
+        # So far we assume all crossover need the same amount of parents and create the same number of offsprings
+        XOVER_N_PARENTS = 2
+        XOVER_N_OFFSPRINGS = 2
+
+        # the variables with the concrete information
+        vars = problem.vars
+
+        # group all the variables by their types
+        vars_by_type = {}
+        for k, v in vars.items():
+            clazz = type(v)
+
+            if clazz not in vars_by_type:
+                vars_by_type[clazz] = []
+            vars_by_type[clazz].append(k)
+
+        # # all different recombinations (the choices need to be split because of data types)
+        recomb = []
+        for clazz, list_of_vars in vars_by_type.items():
+            if clazz == Choice:
+                for e in list_of_vars:
+                    recomb.append((clazz, [e]))
+            else:
+                recomb.append((clazz, list_of_vars))
+
+        # create an empty population that will be set in each iteration
+        off = Population.new(X=[{} for _ in range(n_offsprings)])
+
+        if not parents:
+            n_select = math.ceil(n_offsprings / XOVER_N_OFFSPRINGS)
+            pop = self.selection(problem, pop, n_select, XOVER_N_PARENTS, random_state=random_state, **kwargs)
+
+        for clazz, list_of_vars in recomb:
+
+            crossover = self.crossover[clazz]
+            assert crossover.n_parents == XOVER_N_PARENTS and crossover.n_offsprings == XOVER_N_OFFSPRINGS
+
+            _parents = [
+                [Individual(X=np.array([parent.X[var] for var in list_of_vars], dtype="O" if clazz is Choice else None)) 
+                  for parent in parents] 
+                for parents in pop
+            ]
+
+            _vars = {e: vars[e] for e in list_of_vars}
+            _xl = np.array([vars[e].lb if hasattr(vars[e], "lb") else None for e in list_of_vars])
+            _xu = np.array([vars[e].ub if hasattr(vars[e], "ub") else None for e in list_of_vars])
+            _problem = Problem(vars=_vars, xl=_xl, xu=_xu)
+
+            _off = crossover(_problem, _parents, random_state=random_state, **kwargs)
+
+            mutation = self.mutation[clazz]
+            _off = mutation(_problem, _off, random_state=random_state, **kwargs)
+
+            for k in range(n_offsprings):
+                for i, name in enumerate(list_of_vars):
+                    off[k].X[name] = _off[k].X[i]
+
+        return off
+
+
+class MixedVariableSampling(Sampling):
+
+    def _do(self, problem, n_samples, random_state=None, **kwargs):
+        V = {name: var.sample(n_samples, random_state=random_state) for name, var in problem.vars.items()}
+
+        X = []
+        for k in range(n_samples):
+            X.append({name: V[name][k] for name in problem.vars.keys()})
+
+        return X
+
+
+class MixedVariableDuplicateElimination(ElementwiseDuplicateElimination):
+
+    def is_equal(self, a, b):
+        a, b = a.X, b.X
+        for k, v in a.items():
+            if k not in b or b[k] != v:
+                return False
+        return True
+
+
+def groups_of_vars(vars):
+    ret = {}
+    for name, var in vars.items():
+        if var.__class__ not in ret:
+            ret[var.__class__] = []
+
+        ret[var.__class__].append((name, var))
+
+    return ret
+
+
+class MixedVariableGA(GeneticAlgorithm):
+
+    def __init__(self,
+                 pop_size=50,
+                 n_offsprings=None,
+                 output=SingleObjectiveOutput(),
+                 sampling=MixedVariableSampling(),
+                 mating=MixedVariableMating(eliminate_duplicates=MixedVariableDuplicateElimination()),
+                 eliminate_duplicates=MixedVariableDuplicateElimination(),
+                 survival=FitnessSurvival(),
+                 **kwargs):
+        super().__init__(pop_size=pop_size, n_offsprings=n_offsprings, sampling=sampling, mating=mating,
+                         eliminate_duplicates=eliminate_duplicates, output=output, survival=survival, **kwargs)

pymoo/core/mutation.py

@@ -0,0 +1,44 @@
+from copy import deepcopy
+
+from pymoo.core.operator import Operator
+from pymoo.core.variable import Real, get
+from pymoo.util import default_random_state
+
+
+class Mutation(Operator):
+
+    def __init__(self, prob=1.0, prob_var=None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.prob = Real(prob, bounds=(0.7, 1.0), strict=(0.0, 1.0))
+        self.prob_var = Real(prob_var, bounds=(0.0, 0.25), strict=(0.0, 1.0)) if prob_var is not None else None
+
+    @default_random_state
+    def do(self, problem, pop, inplace=True, *args, random_state=None, **kwargs):
+
+        # if not inplace copy the population first
+        if not inplace:
+            pop = deepcopy(pop)
+
+        n_mut = len(pop)
+
+        # get the variables to be mutated
+        X = pop.get("X")
+
+        # retrieve the mutation variables
+        Xp = self._do(problem, X, *args, random_state=random_state, **kwargs)
+
+        # the likelihood for a mutation on the individuals
+        prob = get(self.prob, size=n_mut)
+        mut = random_state.random(size=n_mut) <= prob
+
+        # store the mutated individual back to the population
+        pop[mut].set("X", Xp[mut])
+
+        return pop
+
+    def _do(self, problem, X, *args, random_state=None, **kwargs):
+        return X
+
+    def get_prob_var(self, problem, **kwargs):
+        prob_var = self.prob_var if self.prob_var is not None else min(0.5, 1 / problem.n_var)
+        return get(prob_var, **kwargs)

pymoo/core/operator.py

@@ -0,0 +1,46 @@
+import abc
+
+import numpy as np
+
+from pymoo.util import default_random_state
+
+
+class Operator:
+
+    def __init__(self,
+                 name=None,
+                 vtype=None,
+                 repair=None) -> None:
+
+        super().__init__()
+
+        if name is None:
+            name = self.__class__.__name__
+
+        self.name = name
+        self.vtype = vtype
+        self.repair = repair
+
+    @default_random_state
+    def do(self, problem, elem, *args, random_state, **kwargs):
+        return self._do(problem, elem, *args, random_state=random_state, **kwargs)
+
+    @abc.abstractmethod
+    def _do(self, problem, elem, *args, random_state, **kwargs):
+        pass
+
+    def __call__(self, problem, elem, *args, to_numpy=False, **kwargs):
+        out = self.do(problem, elem, *args, **kwargs)
+
+        if self.vtype is not None:
+            for ind in out:
+                ind.X = ind.X.astype(self.vtype)
+
+        # allow to have a built-in repair (can be useful to customize standard crossover)
+        if self.repair is not None:
+            self.repair.do(problem, out)
+
+        if to_numpy:
+            out = np.array([ind.X for ind in out])
+
+        return out

pymoo/core/parameters.py

@@ -0,0 +1,134 @@
+from pymoo.core.variable import Variable
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Functions
+# ---------------------------------------------------------------------------------------------------------
+
+def get_data(obj):
+    if not isinstance(obj, dict):
+        if hasattr(obj, "__dict__"):
+            return obj.__dict__
+        else:
+            return {}
+    else:
+        return obj
+
+
+def get_params(obj, flag="default", only_active=True):
+    return get_params_bfs(obj, flag, only_active)
+
+
+def get_params_bfs(obj, flag, only_active):
+    ret = {}
+
+    q = [(None, obj)]
+
+    visited = set()
+
+    while len(q) > 0:
+
+        prefix, obj = q.pop()
+
+        if isinstance(obj, Variable):
+
+            if obj not in visited and obj.flag == flag and (not only_active or obj.active):
+
+                # find the right spot in the ret dictionary
+                e = ret
+
+                for name in prefix[:-1]:
+                    if name not in e:
+                        e[name] = {}
+                    e = e[name]
+
+                # set it so the value
+                e[prefix[-1]] = obj
+
+            # add it to have been visited
+            visited.add(obj)
+
+        else:
+            data = get_data(obj)
+            for key in data:
+                new_prefix = [key] if prefix is None else prefix + [key]
+                entry = (new_prefix, data[key])
+                q.append(entry)
+
+    return ret
+
+
+def get_params_rec(obj, visited, flag, only_active):
+    data = get_data(obj)
+
+    ret = {}
+    for k, v in data.items():
+        if isinstance(v, Variable):
+
+            if v not in visited and v.flag == flag and (not only_active or v.active):
+                ret[k] = v
+
+            visited.add(v)
+
+        else:
+            entry = get_params_rec(v, visited, flag, only_active)
+            if entry is not None and len(entry) > 0:
+                ret[k] = entry
+    return ret
+
+
+def apply_to_params(obj, func_apply):
+    for _, v in flatten_rec(get_params(obj)):
+        func_apply(v)
+
+
+def deactivate_params(obj):
+    def func(param):
+        param.active = False
+
+    apply_to_params(obj, func)
+
+
+def set_params(obj, params, as_value=True):
+    data = get_data(obj)
+
+    for k, v in params.items():
+        if isinstance(v, dict):
+            set_params(data[k], v)
+        else:
+            if as_value:
+                data[k].set(v)
+            else:
+                data[k] = v
+
+
+def flatten(params):
+    return {k: v for k, v in flatten_rec(params)}
+
+
+def flatten_rec(params, prefix=None):
+    if hasattr(params, "items"):
+        for k, v in params.items():
+            yield from flatten_rec(v, prefix=f"{prefix}.{k}" if prefix is not None else k)
+    else:
+        yield prefix, params
+
+
+def hierarchical(data):
+    ret = {}
+
+    groups = {}
+    for k, v in data.items():
+        a = k.split(".")
+        if len(a) > 1:
+            prefix = a[0]
+            if prefix not in groups:
+                groups[prefix] = {}
+            groups[prefix][".".join(a[1:])] = v
+        else:
+            ret[k] = v
+
+    for name, group in groups.items():
+        ret[name] = hierarchical(group)
+
+    return ret