pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/core/algorithm.py

@@ -0,0 +1,408 @@
+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)

pymoo/core/callback.py

@@ -0,0 +1,38 @@
+class Callback:
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.data = {}
+        self.is_initialized = False
+
+    def initialize(self, algorithm):
+        pass
+
+    def notify(self, algorithm):
+        pass
+
+    def update(self, algorithm):
+        return self._update(algorithm)
+
+    def _update(self, algorithm):
+        pass
+
+    def __call__(self, algorithm):
+
+        if not self.is_initialized:
+            self.initialize(algorithm)
+            self.is_initialized = True
+
+        self.notify(algorithm)
+        self.update(algorithm)
+
+
+class CallbackCollection(Callback):
+
+    def __init__(self, *args) -> None:
+        super().__init__()
+        self.callbacks = args
+
+    def update(self, algorithm):
+        [callback.update(algorithm) for callback in self.callbacks]
+

pymoo/core/crossover.py

@@ -0,0 +1,79 @@
+import numpy as np
+
+from pymoo.core.operator import Operator
+from pymoo.core.population import Population
+from pymoo.core.variable import Real, get
+from pymoo.util import default_random_state
+
+
+class Crossover(Operator):
+
+    def __init__(self,
+                 n_parents,
+                 n_offsprings,
+                 prob=0.9,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.n_parents = n_parents
+        self.n_offsprings = n_offsprings
+        self.prob = Real(prob, bounds=(0.5, 1.0), strict=(0.0, 1.0))
+
+    @default_random_state
+    def do(self, problem, pop, parents=None, *args, random_state=None, **kwargs):
+
+        # if a parents with array with mating indices is provided -> transform the input first
+        if parents is not None:
+            pop = [pop[mating] for mating in parents]
+
+        # get the dimensions necessary to create in and output
+        n_parents, n_offsprings = self.n_parents, self.n_offsprings
+        n_matings, n_var = len(pop), problem.n_var
+
+        # get the actual values from each of the parents
+        X = np.swapaxes(np.array([[parent.get("X") for parent in mating] for mating in pop]), 0, 1)
+        if self.vtype is not None:
+            X = X.astype(self.vtype)
+
+        # the array where the offsprings will be stored to
+        Xp = np.empty(shape=(n_offsprings, n_matings, n_var), dtype=X.dtype)
+
+        # the probability of executing the crossover
+        prob = get(self.prob, size=n_matings)
+
+        # a boolean mask when crossover is actually executed
+        cross = random_state.random(n_matings) < prob
+
+        # the design space from the parents used for the crossover
+        if np.any(cross):
+
+            # we can not prefilter for cross first, because there might be other variables using the same shape as X
+            Q = self._do(problem, X, *args, random_state=random_state, **kwargs)
+            assert Q.shape == (n_offsprings, n_matings, problem.n_var), "Shape is incorrect of crossover impl."
+            Xp[:, cross] = Q[:, cross]
+
+        # now set the parents whenever NO crossover has been applied
+        for k in np.flatnonzero(~cross):
+            if n_offsprings < n_parents:
+                s = random_state.choice(np.arange(self.n_parents), size=n_offsprings, replace=False)
+            elif n_offsprings == n_parents:
+                s = np.arange(n_parents)
+            else:
+                s = []
+                while len(s) < n_offsprings:
+                    s.extend(random_state.permutation(n_parents))
+                s = s[:n_offsprings]
+
+            Xp[:, k] = np.copy(X[s, k])
+
+        # flatten the array to become a 2d-array
+        Xp = Xp.reshape(-1, X.shape[-1])
+
+        # create a population object
+        off = Population.new("X", Xp)
+
+        return off
+
+    def _do(self, problem, X, *args, random_state=None, **kwargs):
+        pass
+
+

pymoo/core/decision_making.py

@@ -0,0 +1,102 @@
+import numpy as np
+from scipy.spatial.ckdtree import cKDTree
+
+from pymoo.core.indicator import Indicator
+
+
+class DecisionMaking(Indicator):
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.default_if_empty = None
+
+    def _do(self, F, *args, **kwargs):
+        pass
+
+
+class NeighborFinder:
+
+    def __init__(self, N,
+                 epsilon=0.125,
+                 n_neighbors=None,
+                 n_min_neigbors=None,
+                 consider_2d=True):
+
+        super().__init__()
+        self.N = N
+        self.consider_2d = consider_2d
+
+        _, n_dim = N.shape
+
+        # at least find min(dimensionality times two neighbors, number PO solutions - 1) - if enabled
+        if n_min_neigbors == "auto":
+            self.n_min_neigbors = min(2 * n_dim, _ - 1)
+
+        # disable the minimum neighbor variable
+        else:
+            self.n_min_neigbors = np.inf
+
+        # either choose epsilon
+        self.epsilon = epsilon
+
+        # if none choose the number of neighbors
+        self.n_neighbors = n_neighbors
+
+        if self.N.shape[1] == 1:
+            raise Exception("At least 2 objectives must be provided.")
+
+        elif self.consider_2d and self.N.shape[1] == 2:
+            self.min, self.max = N.min(), N.max()
+            self.rank = np.argsort(N[:, 0])
+            self.pos_in_rank = np.argsort(self.rank)
+
+        else:
+            self.tree = cKDTree(N)
+
+    def find(self, i):
+
+        if self.consider_2d and self.N.shape[1] == 2:
+            neighbours = []
+
+            pos = self.pos_in_rank[i]
+            if pos > 0:
+                neighbours.append(self.rank[pos - 1])
+            if pos < len(self.N) - 1:
+                neighbours.append(self.rank[pos + 1])
+
+        else:
+
+            # for each neighbour in a specific radius of that solution
+            if self.epsilon is not None:
+                neighbours = self.tree.query_ball_point([self.N[i]], self.epsilon).tolist()[0]
+            elif self.n_neighbors is not None:
+                neighbours = self.tree.query([self.N[i]], k=self.n_neighbors + 1)[1].tolist()[0]
+            else:
+                raise Exception("Either define epsilon or number of neighbors.")
+
+            # in case n_min_neigbors is enabled
+            if len(neighbours) < self.n_min_neigbors:
+                neighbours = self.tree.query([self.N[i]], k=self.n_min_neigbors + 1)[1].tolist()[0]
+
+        return neighbours
+
+
+def find_outliers_upper_tail(mu):
+
+    # remove values that are nan
+    I = np.where(np.logical_and(np.logical_not(np.isnan(mu)), np.logical_not(np.isinf(mu))))[0]
+    mu = mu[I]
+
+    # calculate mean and sigma
+    mean, sigma = mu.mean(), mu.std()
+
+    # calculate the deviation in terms of sigma
+    deviation = (mu - mean) / sigma
+
+    # 2 * sigma is considered as an outlier
+    S = I[np.where(deviation >= 2)[0]]
+
+    if len(S) == 0 and deviation.max() > 1:
+        S = I[[np.argmax(mu)]]
+
+    return S if len(S) > 0 else None

pymoo/core/decomposition.py

@@ -0,0 +1,76 @@
+import numpy as np
+
+from pymoo.util.misc import at_least_2d_array, to_1d_array_if_possible
+
+
+class Decomposition:
+
+    def __init__(self, eps=0.0, _type="auto", **kwargs) -> None:
+        super().__init__()
+        self.eps = eps
+        self._type = _type
+        self.ideal_point, self.utopian_point, self.nadir_point = None, None, None
+
+    def __call__(self, *args, **kwargs):
+        return self.do(*args, **kwargs)
+
+    def do(self,
+           F,
+           weights,
+           _type="auto",
+           ideal_point=None,
+           utopian_point=None,
+           nadir_point=None,
+           **kwargs):
+
+        _F, _weights = to_1d_array_if_possible(F), to_1d_array_if_possible(weights)
+
+        if _type == "auto":
+            if _F.ndim == 1 and _weights.ndim > 1:
+                _type = "one_to_many"
+            elif _F.ndim > 1 and _weights.ndim == 1:
+                _type = "many_to_one"
+            elif _F.ndim == 2 and _weights.ndim == 2 and _F.shape[0] == _weights.shape[0]:
+                _type = "one_to_one"
+            else:
+                _type = "many_to_many"
+
+        # make both at least 2d arrays
+        F, weights = at_least_2d_array(F), at_least_2d_array(weights)
+
+        # get the number of points and weights
+        n_points, n_weights = F.shape[0], weights.shape[0]
+
+        self.ideal_point = ideal_point
+        if self.ideal_point is None:
+            self.ideal_point = np.zeros(F.shape[1])
+
+        self.utopian_point = utopian_point
+        if self.utopian_point is None:
+            self.utopian_point = self.ideal_point - self.eps
+
+        # set the nadir point by default to value or default
+        self.nadir_point = nadir_point
+        if self.nadir_point is None:
+            self.nadir_point = self.utopian_point + np.ones(F.shape[1])
+
+        if _type == "one_to_one":
+            D = self._do(F, weights=weights, **kwargs).flatten()
+
+        elif _type == "one_to_many":
+            F = np.repeat(F, n_weights, axis=0)
+            D = self._do(F, weights=weights, **kwargs).flatten()
+
+        elif _type == "many_to_one":
+            weights = np.repeat(weights, n_points, axis=0)
+            D = self._do(F, weights=weights, **kwargs).flatten()
+
+        elif _type == "many_to_many":
+            F = np.repeat(F, n_weights, axis=0)
+            weights = np.tile(weights, (n_points, 1))
+            D = self._do(F, weights=weights, **kwargs).reshape(n_points, n_weights)
+
+        else:
+            raise Exception("Unknown type for decomposition: %s" % _type)
+
+        return D