pydmoo 0.0.18__py3-none-any.whl → 0.1.0__py3-none-any.whl

pydmoo/algorithms/base/__init__.py

@@ -0,0 +1,20 @@
+__all__ = [
+    "DMOEADA",
+    "DMOEADB",
+    "DMOEADDEA",
+    "DMOEADDEB",
+    "DNSGA2A",
+    "DNSGA2B",
+    "MOEAD",
+    "MOEADDE",
+    "NSGA2",
+    "Algorithm"
+]
+
+from .core.algorithm import Algorithm
+from .dmoo.dmoead import DMOEADA, DMOEADB
+from .dmoo.dmoeadde import DMOEADDEA, DMOEADDEB
+from .dmoo.dnsga2 import DNSGA2A, DNSGA2B
+from .moo.moead import MOEAD
+from .moo.moeadde import MOEADDE
+from .moo.nsga2 import NSGA2

pydmoo/algorithms/base/core/algorithm.py

@@ -0,0 +1,416 @@
+"""
+Includes modified code from [pymoo](https://github.com/anyoptimization/pymoo).
+
+Sources:
+    - [algorithm.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/core/algorithm.py).
+
+Licensed under the Apache License, Version 2.0. Original copyright and license terms are preserved.
+"""
+
+import copy
+import time
+
+import numpy as np
+from pymoo.core.callback import Callback
+from pymoo.core.evaluator import Evaluator
+from pymoo.core.meta import Meta
+from pymoo.core.population import Population
+from pymoo.core.result import Result
+from pymoo.functions import FunctionLoader
+from pymoo.termination.default import DefaultMultiObjectiveTermination, DefaultSingleObjectiveTermination
+from pymoo.util.display.display import Display
+from pymoo.util.misc import termination_from_tuple
+from pymoo.util.optimum import filter_optimum
+
+
+class Algorithm:
+
+    def __init__(self,
+                 termination=None,
+                 output=None,
+                 display=None,
+                 callback=None,
+                 archive=None,
+                 return_least_infeasible=False,
+                 save_history=False,
+                 verbose=False,
+                 seed=None,
+                 evaluator=None,
+                 **kwargs):
+
+        super().__init__()
+
+        # prints the compile warning if enabled
+        FunctionLoader.get_instance()
+
+        # the problem to be solved (will be set later on)
+        self.problem = None
+
+        # the termination criterion to be used by the algorithm - might be specific for an algorithm
+        self.termination = termination
+
+        # the text that should be printed during the algorithm run
+        self.output = output
+
+        # an archive kept during algorithm execution (not always the same as optimum)
+        self.archive = archive
+
+        # the form of display shown during algorithm execution
+        self.display = display
+
+        # callback to be executed each generation
+        if callback is None:
+            callback = Callback()
+        self.callback = callback
+
+        # whether the algorithm should finally return the least infeasible solution if no feasible found
+        self.return_least_infeasible = return_least_infeasible
+
+        # whether the history should be saved or not
+        self.save_history = save_history
+
+        # whether the algorithm should print output in this run or not
+        self.verbose = verbose
+
+        # the random seed that was used
+        self.seed = seed
+        self.random_state = None
+
+        # the function evaluator object (can be used to inject code)
+        if evaluator is None:
+            evaluator = Evaluator()
+        self.evaluator = evaluator
+
+        # the history object which contains the list
+        self.history = list()
+
+        # the current solutions stored - here considered as population
+        self.pop = None
+
+        # a placeholder object for implementation to store solutions in each iteration
+        self.off = None
+
+        # the optimum found by the algorithm
+        self.opt = None
+
+        # the current number of generation or iteration
+        self.n_iter = None
+
+        # can be used to store additional data in submodules
+        self.data = {}
+
+        # if the initialized method has been called before or not
+        self.is_initialized = False
+
+        # the time when the algorithm has been setup for the first time
+        self.start_time = None
+
+    def setup(self, problem, verbose=False, progress=False, **kwargs):
+
+        # the problem to be solved by the algorithm
+        self.problem = problem
+
+        # clone the output object if it exists to avoid state pollution between runs
+        if self.output is not None:
+            self.output = copy.deepcopy(self.output)
+
+        # set all the provided options to this method
+        for key, value in kwargs.items():
+            self.__dict__[key] = value
+
+        # set random state
+        self.random_state = np.random.default_rng(self.seed)
+
+        # make sure that some type of termination criterion is set
+        if self.termination is None:
+            self.termination = default_termination(problem)
+        else:
+            self.termination = termination_from_tuple(self.termination)
+
+        # set up the display during the algorithm execution
+        if self.display is None:
+            self.display = Display(self.output, verbose=verbose, progress=progress)
+
+        # finally call the function that can be overwritten by the actual algorithm
+        self._setup(problem, **kwargs)
+
+        return self
+
+    def run(self):
+        while self.has_next():
+            self.next()
+        return self.result()
+
+    def has_next(self):
+        return not self.termination.has_terminated()
+
+    def finalize(self):
+
+        # finalize the display output in the end of the run
+        self.display.finalize()
+
+        return self._finalize()
+
+    def next(self):
+
+        # get the infill solutions
+        infills = self.infill()
+
+        # call the advance with them after evaluation
+        if infills is not None:
+            self.evaluator.eval(self.problem, infills, algorithm=self)
+            self.advance(infills=infills)
+
+        # if the algorithm does not follow the infill-advance scheme just call advance
+        else:
+            self.advance()
+
+    def _initialize(self):
+
+        # the time starts whenever this method is called
+        self.start_time = time.time()
+
+        # set the attribute for the optimization method to start
+        self.n_iter = 1
+        self.pop = Population.empty()
+        self.opt = None
+
+    def infill(self):
+        if self.problem is None:
+            raise Exception("Please call `setup(problem)` before calling next().")
+
+        # the first time next is called simply initial the algorithm - makes the interface cleaner
+        if not self.is_initialized:
+
+            # hook mostly used by the class to happen before even to initialize
+            self._initialize()
+
+            # execute the initialization infill of the algorithm
+            infills = self._initialize_infill()
+
+        else:
+            # request the infill solutions if the algorithm has implemented it
+            infills = self._infill()
+
+        # set the current generation to the offsprings
+        if infills is not None:
+            infills.set("n_gen", self.n_iter)
+            infills.set("n_iter", self.n_iter)
+
+        return infills
+
+    def advance(self, infills=None, **kwargs):
+
+        # if infills have been provided set them as offsprings and feed them into advance
+        self.off = infills
+
+        # if the algorithm has not been already initialized
+        if not self.is_initialized:
+
+            # set the generation counter to 1
+            self.n_iter = 1
+
+            # assign the population to the algorithm
+            self.pop = infills
+
+            # do what is necessary after the initialization
+            self._initialize_advance(infills=infills, **kwargs)
+
+            # set this algorithm to be initialized
+            self.is_initialized = True
+
+            # always advance to the next iteration after initialization
+            self._post_advance()
+
+        else:
+
+            # call the implementation of the advance method - if the infill is not None
+            val = self._advance(infills=infills, **kwargs)
+
+            # always advance to the next iteration - except if the algorithm returns False
+            if val is None or val:
+                self._post_advance()
+
+        # if the algorithm has terminated, then do the finalization steps and return the result
+        if self.termination.has_terminated():
+            self.finalize()
+            ret = self.result()
+
+        # otherwise just increase the iteration counter for the next step and return the current optimum
+        else:
+            ret = self.opt
+
+        # add the infill solutions to an archive
+        if self.archive is not None and infills is not None:
+            self.archive = self.archive.add(infills)
+
+        return ret
+
+    def result(self):
+        res = Result()
+
+        # store the time when the algorithm as finished
+        res.start_time = self.start_time
+        res.end_time = time.time()
+        res.exec_time = res.end_time - res.start_time
+
+        res.pop = self.pop
+        res.archive = self.archive
+        res.data = self.data
+
+        # get the optimal solution found
+        opt = self.opt
+        if opt is None or len(opt) == 0:
+            opt = None
+
+        # if no feasible solution has been found
+        elif not np.any(opt.get("FEAS")):
+            if self.return_least_infeasible:
+                opt = filter_optimum(opt, least_infeasible=True)
+            else:
+                opt = None
+        res.opt = opt
+
+        # if optimum is set to none to not report anything
+        if res.opt is None:
+            X, F, CV, G, H = None, None, None, None, None
+
+        # otherwise get the values from the population
+        else:
+            X, F, CV, G, H = self.opt.get("X", "F", "CV", "G", "H")
+
+            # if single-objective problem and only one solution was found - create a 1d array
+            if self.problem.n_obj == 1 and len(X) == 1:
+                X, F, CV, G, H = X[0], F[0], CV[0], G[0], H[0]
+
+        # set all the individual values
+        res.X, res.F, res.CV, res.G, res.H = X, F, CV, G, H
+
+        # create the result object
+        res.problem = self.problem
+        res.history = self.history
+
+        return res
+
+    def ask(self):
+        return self.infill()
+
+    def tell(self, *args, **kwargs):
+        return self.advance(*args, **kwargs)
+
+    def _set_optimum(self):
+        self.opt = filter_optimum(self.pop, least_infeasible=True)
+
+    def _post_advance(self):
+
+        # update the current optimum of the algorithm
+        self._set_optimum()
+
+        # update the current termination condition of the algorithm
+        self.termination.update(self)
+
+        # display the output if defined by the algorithm
+        self.display(self)
+
+        if self.save_history:
+            _hist, _callback, _display = self.history, self.callback, self.display
+
+            self.history, self.callback, self.display = None, None, None
+            obj = copy.deepcopy(self)
+
+            self.history, self.callback, self.display = _hist, _callback, _display
+            self.history.append(obj)
+
+        # if a callback function is provided it is called after each iteration
+        self.callback(self)
+
+        self.n_iter += 1
+
+    # =========================================================================================================
+    # TO BE OVERWRITTEN
+    # =========================================================================================================
+
+    def _setup(self, problem, **kwargs):
+        pass
+
+    def _initialize_infill(self):
+        pass
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        pass
+
+    def _infill(self):
+        pass
+
+    def _advance(self, infills=None, **kwargs):
+        pass
+
+    def _finalize(self):
+        pass
+
+    # =========================================================================================================
+    # CONVENIENCE
+    # =========================================================================================================
+
+    @property
+    def n_gen(self):
+        return self.n_iter
+
+    @n_gen.setter
+    def n_gen(self, value):
+        self.n_iter = value
+
+
+class LoopwiseAlgorithm(Algorithm):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.generator = None
+        self.state = None
+
+    def _next(self):
+        pass
+
+    def _infill(self):
+        if self.state is None:
+            self._advance()
+        return self.state
+
+    def _advance(self, infills=None, **kwargs):
+        if self.generator is None:
+            self.generator = self._next()
+        try:
+            self.state = self.generator.send(infills)
+        except StopIteration:
+            self.generator = None
+            self.state = None
+            return True
+
+        return False
+
+
+def default_termination(problem):
+    if problem.n_obj > 1:
+        termination = DefaultMultiObjectiveTermination()
+    else:
+        termination = DefaultSingleObjectiveTermination()
+    return termination
+
+
+class MetaAlgorithm(Meta):
+    """
+    An algorithm wrapper that combines Algorithm's functionality with Meta's delegation behavior.
+    Uses Meta to provide transparent proxying with the ability to override specific methods.
+    """
+
+    def __init__(self, algorithm, copy=True, **kwargs):
+        # If the algorithm is already a Meta object, don't copy to avoid deepcopy issues with nested proxies
+        if isinstance(algorithm, Meta):
+            copy = False
+
+        # Initialize Meta
+        super().__init__(algorithm, copy=copy)
+
+        # Pass any additional kwargs to the wrapped algorithm if needed
+        for key, value in kwargs.items():
+            setattr(self, key, value)

pydmoo/algorithms/base/core/genetic.py

@@ -0,0 +1,129 @@
+"""
+Includes modified code from [pymoo](https://github.com/anyoptimization/pymoo).
+
+Sources:
+    - [genetic.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/algorithms/base/genetic.py).
+
+Licensed under the Apache License, Version 2.0. Original copyright and license terms are preserved.
+
+Add a method `_infill_static_dynamic` for dynamic multi-objective optimization.
+"""
+from pymoo.core.duplicate import DefaultDuplicateElimination, NoDuplicateElimination
+from pymoo.core.initialization import Initialization
+from pymoo.core.mating import Mating
+from pymoo.core.population import Population
+from pymoo.core.repair import NoRepair
+
+from pydmoo.algorithms.base.core.algorithm import Algorithm
+
+
+class GeneticAlgorithm(Algorithm):
+
+    def __init__(self,
+                 pop_size=None,
+                 sampling=None,
+                 selection=None,
+                 crossover=None,
+                 mutation=None,
+                 survival=None,
+                 n_offsprings=None,
+                 eliminate_duplicates=DefaultDuplicateElimination(),
+                 repair=None,
+                 mating=None,
+                 advance_after_initial_infill=False,
+                 **kwargs
+                 ):
+
+        super().__init__(**kwargs)
+
+        # the population size used
+        self.pop_size = pop_size
+
+        # whether the algorithm should be advanced after initialization of not
+        self.advance_after_initial_infill = advance_after_initial_infill
+
+        # the survival for the genetic algorithm
+        self.survival = survival
+
+        # number of offsprings to generate through recombination
+        self.n_offsprings = n_offsprings
+
+        # if the number of offspring is not set - equal to population size
+        if self.n_offsprings is None:
+            self.n_offsprings = pop_size
+
+        # set the duplicate detection class - a boolean value chooses the default duplicate detection
+        if isinstance(eliminate_duplicates, bool):
+            if eliminate_duplicates:
+                self.eliminate_duplicates = DefaultDuplicateElimination()
+            else:
+                self.eliminate_duplicates = NoDuplicateElimination()
+        else:
+            self.eliminate_duplicates = eliminate_duplicates
+
+        # simply set the no repair object if it is None
+        self.repair = repair if repair is not None else NoRepair()
+
+        self.initialization = Initialization(sampling,
+                                             repair=self.repair,
+                                             eliminate_duplicates=self.eliminate_duplicates)
+
+        if mating is None:
+            mating = Mating(selection,
+                            crossover,
+                            mutation,
+                            repair=self.repair,
+                            eliminate_duplicates=self.eliminate_duplicates,
+                            n_max_iterations=100)
+        self.mating = mating
+
+        # other run specific data updated whenever solve is called - to share them in all algorithms
+        self.n_gen = None
+        self.pop = None
+        self.off = None
+
+    def _initialize_infill(self):
+        pop = self.initialization.do(self.problem, self.pop_size, algorithm=self, random_state=self.random_state)
+        return pop
+
+    def _initialize_advance(self, infills=None, **kwargs):
+        if self.advance_after_initial_infill:
+            self.pop = self.survival.do(self.problem, infills, n_survive=len(infills),
+                                        random_state=self.random_state, algorithm=self, **kwargs)
+
+    def _infill(self):
+        # Added by DynOpt on Dec 21, 2025
+        pop = self._infill_static_dynamic()
+
+        # do the mating using the current population
+        off = self.mating.do(self.problem, pop, self.n_offsprings, algorithm=self, random_state=self.random_state)
+
+        # if the mating could not generate any new offspring (duplicate elimination might make that happen)
+        if len(off) == 0:
+            self.termination.force_termination = True
+            return
+
+        # if not the desired number of offspring could be created
+        elif len(off) < self.n_offsprings:
+            if self.verbose:
+                print("WARNING: Mating could not produce the required number of (unique) offsprings!")
+
+        return off
+
+    # Added by DynOpt on Dec 21, 2025
+    def _infill_static_dynamic(self):
+        pop = self.pop
+
+        return pop
+
+    def _advance(self, infills=None, **kwargs):
+
+        # the current population
+        pop = self.pop
+
+        # merge the offsprings with the current population
+        if infills is not None:
+            pop = Population.merge(self.pop, infills)
+
+        # execute the survival to find the fittest solutions
+        self.pop = self.survival.do(self.problem, pop, n_survive=self.pop_size, algorithm=self, random_state=self.random_state, **kwargs)

pydmoo/algorithms/base/dmoo/dmoead.py

@@ -0,0 +1,131 @@
+import time
+
+import numpy as np
+from pymoo.core.population import Population
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+
+from pydmoo.algorithms.base.moo.moead import MOEAD
+
+
+class DMOEAD(MOEAD):
+
+    def __init__(self,
+                 perc_detect_change=0.1,
+                 eps=0.0,
+                 **kwargs):
+
+        super().__init__(**kwargs)
+        self.perc_detect_change = perc_detect_change
+        self.eps = eps
+
+    def setup(self, problem, **kwargs):
+        assert not problem.has_constraints(), f"{self.__class__.__name__} only works for unconstrained problems."
+        return super().setup(problem, **kwargs)
+
+    def _detect_change_sample_part_population(self):
+        pop = self.pop
+        X, F = pop.get("X", "F")
+
+        # the number of solutions to sample from the population to detect the change
+        n_samples = int(np.ceil(len(pop) * self.perc_detect_change))
+
+        # choose randomly some individuals of the current population to test if there was a change
+        I = self.random_state.choice(np.arange(len(pop)), size=n_samples)
+        samples = self.evaluator.eval(self.problem, Population.new(X=X[I]))
+
+        # calculate the differences between the old and newly evaluated pop
+        delta = ((samples.get("F") - F[I]) ** 2).mean()
+
+        # if there is an average deviation bigger than eps -> we have a change detected
+        change_detected = delta > self.eps
+        return change_detected
+
+    def _next_static_dynamic(self):
+        # for dynamic environment
+        pop = self.pop
+
+        if self.state is None:
+
+            change_detected = self._detect_change_sample_part_population()
+
+            if change_detected:
+
+                start_time = time.time()
+
+                pop = self._response_change()
+
+                # reevaluate because we know there was a change
+                self.evaluator.eval(self.problem, pop)
+
+                if len(pop) > self.pop_size:
+                    # do a survival to recreate rank and crowding of all individuals
+                    # Modified by DynOpt on Dec 21, 2025
+                    # n_survive=len(pop) -> n_survive=self.pop_size
+                    pop = RankAndCrowding().do(self.problem, pop, n_survive=self.pop_size, random_state=self.random_state)
+
+                self.pop = pop
+
+                self.data["response_duration"] = time.time() - start_time
+
+        return pop
+
+    def _response_change(self):
+        pass
+
+
+class DMOEADA(DMOEAD):
+
+    def __init__(self,
+                 perc_detect_change=0.1,
+                 eps=0.0,
+                 perc_diversity=0.3,
+                 **kwargs):
+        super().__init__(perc_detect_change=perc_detect_change,
+                         eps=eps,
+                         **kwargs)
+
+        self.perc_diversity = perc_diversity
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # find indices to be replaced (introduce diversity)
+        I = np.where(self.random_state.random(len(pop)) < self.perc_diversity)[0]
+
+        # replace with randomly sampled individuals
+        pop[I] = self.initialization.sampling(self.problem, len(I), random_state=self.random_state)
+
+        return pop
+
+
+class DMOEADB(DMOEAD):
+
+    def __init__(self,
+                 perc_detect_change=0.1,
+                 eps=0.0,
+                 perc_diversity=0.3,
+                 **kwargs):
+        super().__init__(perc_detect_change=perc_detect_change,
+                         eps=eps,
+                         **kwargs)
+
+        self.perc_diversity = perc_diversity
+
+    def _response_change(self):
+        pop = self.pop
+        X = pop.get("X")
+
+        # recreate the current population without being evaluated
+        pop = Population.new(X=X)
+
+        # find indices to be replaced (introduce diversity)
+        I = np.where(self.random_state.random(len(pop)) < self.perc_diversity)[0]
+
+        # replace by mutations of existing solutions (this occurs inplace)
+        self.mating.mutation(self.problem, pop[I])
+
+        return pop