pymoo 0.6.1.2__cp312-cp312-win_amd64.whl → 0.6.1.5.dev0__cp312-cp312-win_amd64.whl

pymoo/algorithms/moo/age.py

@@ -167,7 +167,13 @@ class AGEMOEASurvival(Survival):
         p = self.compute_geometry(front, extreme, n)
 
         nn = np.linalg.norm(front, p, axis=1)
-        distances = self.pairwise_distances(front, p) / (nn[:, None])
+        # Replace very small norms with 1 to prevent division by zero
+        nn[nn < 1e-8] = 1
+
+        distances = self.pairwise_distances(front, p)
+        distances[distances < 1e-8] = 1e-8  # Replace very small entries to prevent division by zero
+
+        distances = distances / (nn[:, None])
 
         neighbors = 2
         remaining = np.arange(m)
@@ -209,7 +215,7 @@ class AGEMOEASurvival(Survival):
         return p
 
     @staticmethod
-    @jit(fastmath=True)
+    #@jit(nopython=True, fastmath=True)
     def pairwise_distances(front, p):
         m = np.shape(front)[0]
         distances = np.zeros((m, m))
@@ -219,14 +225,14 @@ class AGEMOEASurvival(Survival):
         return distances
 
     @staticmethod
-    @jit(fastmath=True)
+    @jit(nopython=True, fastmath=True)
     def minkowski_distances(A, B, p):
         m1 = np.shape(A)[0]
         m2 = np.shape(B)[0]
         distances = np.zeros((m1, m2))
         for i in range(m1):
             for j in range(m2):
-                distances[i][j] = sum(np.abs(A[i] - B[j]) ** p) ** (1 / p)
+                distances[i][j] = np.sum(np.abs(A[i] - B[j]) ** p) ** (1 / p)
 
         return distances
 
@@ -254,15 +260,15 @@ def find_corner_solutions(front):
     return indexes
 
 
-@jit(fastmath=True)
+@jit(nopython=True, fastmath=True)
 def point_2_line_distance(P, A, B):
-    d = np.zeros(P.shape[0])
+    d = np.zeros(P.shape[0], dtype=numba.float64)
 
     for i in range(P.shape[0]):
         pa = P[i] - A
         ba = B - A
         t = np.dot(pa, ba) / np.dot(ba, ba)
-        d[i] = sum((pa - t * ba) ** 2)
+        d[i] = np.sum((pa - t * ba) ** 2)
 
     return d
 

pymoo/algorithms/moo/age2.py

@@ -64,48 +64,78 @@ class AGEMOEA2(GeneticAlgorithm):
         self.tournament_type = 'comp_by_rank_and_crowding'
 
 
-@jit(fastmath=True)
+@jit(nopython=True, fastmath=True)
 def project_on_manifold(point, p):
-    dist = sum(point[point > 0] ** p) ** (1/p)
+    dist = np.sum(point[point > 0] ** p) ** (1/p)
     return np.multiply(point, 1 / dist)
 
 
+import numpy as np
+
+
 def find_zero(point, n, precision):
     x = 1
-
+    epsilon = 1e-10  # Small constant for regularization
     past_value = x
+    max_float = np.finfo(np.float64).max  # Maximum representable float value
+    log_max_float = np.log(max_float)  # Logarithm of the maximum float
+
     for i in range(0, 100):
 
-        # Original function
+        # Original function with regularization
         f = 0.0
         for obj_index in range(0, n):
             if point[obj_index] > 0:
-                f += np.power(point[obj_index], x)
+                log_value = x * np.log(point[obj_index] + epsilon)
+                if log_value < log_max_float:
+                    f += np.exp(log_value)
+                else:
+                    return 1  # Handle overflow by returning a fallback value
 
-        f = np.log(f)
+        f = np.log(f) if f > 0 else 0  # Avoid log of non-positive numbers
 
-        # Derivative
+        # Derivative with regularization
         numerator = 0
         denominator = 0
         for obj_index in range(0, n):
             if point[obj_index] > 0:
-                numerator = numerator + np.power(point[obj_index], x) * np.log(point[obj_index])
-                denominator = denominator + np.power(point[obj_index], x)
-
-        if denominator == 0:
-            return 1
+                log_value = x * np.log(point[obj_index] + epsilon)
+                if log_value < log_max_float:
+                    power_value = np.exp(log_value)
+                    log_term = np.log(point[obj_index] + epsilon)
+
+                    # Use logarithmic comparison to avoid overflow
+                    if log_value + np.log(abs(log_term) + epsilon) < log_max_float:
+                        result = power_value * log_term
+                        numerator += result
+                        denominator += power_value
+                    else:
+                        # Handle extreme cases by capping the result
+                        numerator += max_float
+                        denominator += power_value
+                else:
+                    return 1  # Handle overflow by returning a fallback value
+
+        if denominator == 0 or np.isnan(denominator) or np.isinf(denominator):
+            return 1  # Handle division by zero or NaN
+
+        if np.isnan(numerator) or np.isinf(numerator):
+            return 1  # Handle invalid numerator
 
         ff = numerator / denominator
 
-        # zero of function
+        if ff == 0:  # Check for zero before division
+            return 1  # Handle by returning a fallback value
+
+        # Update x using Newton's method
         x = x - f / ff
 
         if abs(x - past_value) <= precision:
             break
         else:
-            paste_value = x  # update current point
+            past_value = x  # Update current point
 
-    if isinstance(x, complex):
+    if isinstance(x, complex) or np.isinf(x) or np.isnan(x):
         return 1
     else:
         return x
@@ -135,7 +165,7 @@ class AGEMOEA2Survival(AGEMOEASurvival):
         return p
 
     @staticmethod
-    @jit(fastmath=True)
+    @jit(nopython=True, fastmath=True)
     def pairwise_distances(front, p):
         m, n = front.shape
         projected_front = front.copy()
@@ -148,7 +178,7 @@ class AGEMOEA2Survival(AGEMOEASurvival):
         if 0.95 < p < 1.05:
             for row in range(0, m - 1):
                 for column in range(row + 1, m):
-                    distances[row][column] = sum(np.abs(projected_front[row] - projected_front[column]) ** 2) ** 0.5
+                    distances[row][column] = np.sum(np.abs(projected_front[row] - projected_front[column]) ** 2) ** 0.5
 
         else:
             for row in range(0, m-1):
@@ -156,8 +186,8 @@ class AGEMOEA2Survival(AGEMOEASurvival):
                     mid_point = projected_front[row] * 0.5 + projected_front[column] * 0.5
                     mid_point = project_on_manifold(mid_point, p)
 
-                    distances[row][column] = sum(np.abs(projected_front[row] - mid_point) ** 2) ** 0.5 + \
-                                            sum(np.abs(projected_front[column] - mid_point) ** 2) ** 0.5
+                    distances[row][column] = np.sum(np.abs(projected_front[row] - mid_point) ** 2) ** 0.5 + \
+                                            np.sum(np.abs(projected_front[column] - mid_point) ** 2) ** 0.5
 
         return distances + distances.T
 

pymoo/algorithms/moo/ctaea.py

@@ -14,7 +14,7 @@ from pymoo.operators.selection.tournament import TournamentSelection
 from pymoo.util.display.multi import MultiObjectiveOutput
 from pymoo.util.dominator import Dominator
 from pymoo.util.function_loader import load_function
-from pymoo.util.misc import has_feasible, random_permuations
+from pymoo.util.misc import has_feasible, random_permutations
 from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
 
 
@@ -63,7 +63,7 @@ class RestrictedMating(TournamentSelection):
         n_random = n_select * n_parents * self.pressure
         n_perms = math.ceil(n_random / n_pop)
         # get random permutations and reshape them
-        P = random_permuations(n_perms, n_pop)[:n_random]
+        P = random_permutations(n_perms, n_pop)[:n_random]
         P = np.reshape(P, (n_select * n_parents, self.pressure))
         if Pc <= Pd:
             # Choose from DA

pymoo/algorithms/moo/kgb.py

@@ -24,13 +24,13 @@ class KGB(NSGA2):
         c_size=13,
         eps=0.0,
         ps={},
-        pertub_dev=0.1,
+        perturb_dev=0.1,
         save_ps=False,
         **kwargs,
     ):
 
         super().__init__(**kwargs)
-        self.PERTUB_DEV = pertub_dev
+        self.PERTURB_DEV = perturb_dev
         self.PERC_DIVERSITY = perc_diversity
         self.PERC_DETECT_CHANGE = perc_detect_change
         self.EPS = eps
@@ -258,11 +258,11 @@ class KGB(NSGA2):
         :param pop: Population to check and fix boundaries
         :return: Population with corrected boundaries
         """
-        # check wether numpy array or pymoo population is given
+        # check whether numpy array or pymoo population is given
         if isinstance(pop, Population):
             pop = pop.get("X")
 
-        # check if any solution is outside of the bounds
+        # check if any solution is outside the bounds
         for individual in pop:
             for i in range(len(individual)):
                 if individual[i] > self.problem.xu[i]:
@@ -281,7 +281,7 @@ class KGB(NSGA2):
         # TODO: Check boundaries
         random_pop = np.random.random((N_r, self.problem.n_var))
 
-        # check if any solution is outside of the bounds
+        # check if any solution is outside the bounds
         for individual in random_pop:
             for i in range(len(individual)):
                 if individual[i] > self.problem.xu[i]:
@@ -341,16 +341,16 @@ class KGB(NSGA2):
             X_test = self.random_strategy(self.nr_rand_solutions)
 
             # introduce noise to vary previously useful solutions
-            noise = np.random.normal(0, self.PERTUB_DEV, self.problem.n_var)
+            noise = np.random.normal(0, self.PERTURB_DEV, self.problem.n_var)
             noisy_useful_history = np.asarray(pop_useful) + noise
 
-            # check wether solutions are within bounds
+            # check whether solutions are within bounds
             noisy_useful_history = self.check_boundaries(noisy_useful_history)
 
             # add noisy useful history to randomly generated solutions
             X_test = np.vstack((X_test, noisy_useful_history))
 
-            # predict wether random solutions are useful or useless
+            # predict whether random solutions are useful or useless
             Y_test = model.predict(X_test)
 
             # create list of useful predicted solutions
@@ -391,7 +391,7 @@ class KGB(NSGA2):
             # if there are still not enough solutions in init_pop randomly sample previously useful solutions directly without noise to init_pop
             if len(init_pop) < self.pop_size:
 
-                # fill up init_pop with randomly sampled solutions from pop_usefull
+                # fill up init_pop with randomly sampled solutions from pop_useful
                 if len(pop_useful) >= self.pop_size - len(init_pop):
 
                     nr_sampled_pop_useful = self.pop_size - len(init_pop)

pymoo/algorithms/moo/nsga2.py

@@ -70,10 +70,6 @@ def binary_tournament(pop, P, algorithm, **kwargs):
 class RankAndCrowdingSurvival(RankAndCrowding):
     
     def __init__(self, nds=None, crowding_func="cd"):
-        warnings.warn(
-                "RankAndCrowdingSurvival is deprecated and will be removed in version 0.8.*; use RankAndCrowding operator instead, which supports several and custom crowding diversity metrics.",
-                DeprecationWarning, 2
-            )
         super().__init__(nds, crowding_func)
 
 # =========================================================================================================

pymoo/algorithms/moo/nsga3.py

@@ -212,7 +212,7 @@ def niching(pop, n_remaining, niche_count, niche_of_individuals, dist_to_niche):
         # the minimum niche count
         min_niche_count = next_niche_count.min()
 
-        # all niches with the minimum niche count (truncate if randomly if more niches than remaining individuals)
+        # all niches with the minimum niche count (truncate randomly if there are more niches than remaining individuals)
         next_niches = next_niches_list[np.where(next_niche_count == min_niche_count)[0]]
         next_niches = next_niches[np.random.permutation(len(next_niches))[:n_select]]
 
@@ -303,7 +303,7 @@ def get_extreme_points_c(F, ideal_point, extreme_points=None):
     weights = np.eye(F.shape[1])
     weights[weights == 0] = 1e6
 
-    # add the old extreme points to never loose them for normalization
+    # add the old extreme points to never lose them for normalization
     _F = F
     if extreme_points is not None:
         _F = np.concatenate([extreme_points, _F], axis=0)

pymoo/algorithms/moo/pinsga2.py

@@ -0,0 +1,370 @@
+import sys
+from abc import ABC, abstractmethod
+
+import numpy as np
+
+from pymoo.algorithms.base.genetic import GeneticAlgorithm
+from pymoo.algorithms.moo.nsga2 import binary_tournament
+from pymoo.docs import parse_doc_string
+from pymoo.operators.crossover.sbx import SBX
+from pymoo.operators.mutation.pm import PM
+from pymoo.operators.sampling.rnd import FloatRandomSampling
+from pymoo.operators.selection.tournament import TournamentSelection
+from pymoo.operators.survival.rank_and_crowding import RankAndCrowding
+from pymoo.termination.default import DefaultMultiObjectiveTermination
+from pymoo.util import value_functions as mvf
+from pymoo.util.display.multi import MultiObjectiveOutput
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+from pymoo.util.reference_direction import select_points_with_maximum_distance
+from pymoo.util.vf_dominator import VFDominator
+
+
+# =========================================================================================================
+# Implementation
+# =========================================================================================================
+
+
+class AutomatedDM(ABC): 
+    
+    def __init__(self, get_pairwise_ranks_func=None):
+        self.get_pairwise_ranks_func = get_pairwise_ranks_func
+
+    @abstractmethod
+    def makeDecision(self, F):
+        pass
+    
+    def makePairwiseDecision(self, F):
+        
+        dm = lambda F: self.makeDecision(F)
+        ranks = self.get_pairwise_ranks_func(F, 1, dm=dm)
+        
+        return ranks
+        
+
+
+class PINSGA2(GeneticAlgorithm):
+
+    def __init__(self,
+                 pop_size=100,
+                 sampling=FloatRandomSampling(),
+                 selection=TournamentSelection(func_comp=binary_tournament),
+                 crossover=SBX(eta=15, prob=0.9),
+                 mutation=PM(eta=20),
+                 output=MultiObjectiveOutput(),
+                 tau=10,
+                 eta=4,
+                 opt_method="trust-constr",
+                 vf_type="poly",
+                 eps_max=1000,
+                 ranking_type='pairwise',
+                 presi_signs=None,
+                 automated_dm=None,
+                 verbose=False, 
+                 **kwargs):
+       
+        self.survival = RankAndCrowding(nds=NonDominatedSorting(dominator=VFDominator(self)))
+
+        super().__init__(
+            pop_size=pop_size,
+            sampling=sampling,
+            selection=selection,
+            crossover=crossover,
+            mutation=mutation,
+            survival=self.survival,
+            output=output,
+            advance_after_initial_infill=True,
+            **kwargs)
+
+        self.termination = DefaultMultiObjectiveTermination()
+        self.tournament_type = 'comp_by_dom_and_crowding'
+        
+        self.ranking_type=ranking_type
+        self.presi_signs=presi_signs
+
+        self.vf_type = vf_type
+        self.opt_method = opt_method
+        self.tau = tau
+        self.eta = eta
+        self.eta_F = []
+        self.vf_res = None
+        self.v2 = None
+        self.vf_plot_flag = False
+        self.vf_plot = None
+        self.historical_F = None
+        self.prev_pop = None
+        self.fronts = []
+        self.eps_max = eps_max
+
+        self.verbose = verbose
+
+        if automated_dm is not None:
+            automated_dm.get_pairwise_ranks_func = self._get_pairwise_ranks
+        self.automated_dm = automated_dm
+
+    def _warn(self, msg):
+        if self.verbose: 
+            sys.stderr.write(msg)
+
+    @staticmethod
+    def _prompt_for_ranks(F, presi_signs):
+
+        for (e, f) in enumerate(F):
+            print("Solution %d %s" % (e + 1, f * presi_signs))   
+
+        dim = F.shape[0]                                                                                 
+
+        raw_ranks = input(f"Ranks (e.g., \"3, {dim}, ..., 1\" for 3rd best, {dim}th best, ..., 1st best): ")
+
+        if raw_ranks == "":
+            ranks = []
+        else:
+            ranks = [int(raw_rank) for raw_rank in raw_ranks.split()  ] 
+
+        return ranks
+       
+    @staticmethod
+    def _present_ranks(F, dm_ranks, presi_signs):
+
+        print("Solutions are ranked as:")
+
+        for (e, f) in enumerate(F):
+            print("Solution %d %s: Rank %d" % (e + 1, f * presi_signs, dm_ranks[e]))   
+
+
+    @staticmethod
+    def _get_pairwise_ranks(F, presi_signs, dm=None):
+
+        if not dm:
+                                  
+            dm = lambda F: input("\nWhich solution do you like best?\n" + \
+                                    f"[a] {F[0]}\n" +  \
+                                    f"[b] {F[1]}\n" + \
+                                     "[c] These solutions are equivalent.\n--> " )
+
+        # initialize empty ranking
+        _ranks = []
+        for i, f in enumerate( F ):
+            
+            # handle empty case, put first element in first place
+            if not _ranks:
+                _ranks.append( [i] )
+                
+            else:
+                inserted = False
+                
+                # for each remaining elements, compare to all currently ranked elements
+                for j, group in enumerate( _ranks ):
+
+                    # get pairwise preference from user
+                    while True:
+
+                        points_to_compare = np.array( [f*presi_signs, F[ group[0] ]*presi_signs] )
+                        preference_raw = dm( points_to_compare )
+
+                        preference = preference_raw.strip().lower()
+
+                        if preference in ['a', 'b', 'c']:
+                            break
+                        print("Invalid input. Please enter 'a', 'b', or 'c'.")
+                    
+                    # if better than currently ranked element place before that element
+                    if preference == 'a':
+                        _ranks.insert( j, [i] )
+                        inserted = True
+                        break
+                    
+                    # if equal to currently ranked element place with that element
+                    elif preference == 'c':
+                        group.append( i )
+                        inserted = True
+                        break
+                    
+                # if found to be worse than all place at the end
+                if not inserted:
+                    _ranks.append( [i] )
+
+        ranks = np.zeros ( len( F ), dtype=int ) 
+
+        for rank, group in enumerate( _ranks ):
+            for index in group:
+                ranks[index] = rank
+
+        return np.array( ranks ) + 1
+
+
+    @staticmethod
+    def _get_ranks(F, presi_signs):
+
+        ranks_invalid = True
+
+        dim = F.shape[0]                                                                                 
+                                                                                                          
+        print(f"Give each solution a ranking, with 1 being the highest score, and {dim} being the lowest score:")        
+
+        ranks = PINSGA2._prompt_for_ranks(F, presi_signs)
+
+        while ranks_invalid: 
+
+            fc = F.shape[0]
+
+            if len(ranks) > 0 and max(ranks) <= fc and min(ranks) >= 1:
+
+                ranks_invalid = False 
+
+            else: 
+
+                print("Invalid ranks given. Please try again")
+
+                ranks = PINSGA2._prompt_for_ranks(F, presi_signs)
+
+        return np.array(ranks);                         
+
+
+    def _reset_dm_preference(self):
+
+            self._warn("Back-tracking and removing DM preference from search.")
+
+            self.eta_F = []
+            self.vf_res = None
+            self.v2 = None
+            self.vf_plot_flag = False
+            self.vf_plot = None
+            self.pop = self.prev_pop
+
+
+    def _advance(self, infills=None, **kwargs):
+
+        super()._advance(infills=infills, **kwargs)
+
+        rank, F = self.pop.get("rank", "F")
+
+        self.fronts = rank
+
+        F = F[rank == 0]
+
+        if self.historical_F is not None:
+            self.historical_F = np.vstack((self.historical_F, F)) 
+        else: 
+            self.historical_F = F
+
+        to_find = self.eta if F.shape[0] >= self.eta else F.shape[0] 
+
+        if self.presi_signs is None: 
+            self.presi_signs = np.ones(F.shape[1])
+
+        # Eta is the number of solutions displayed to the DM
+        eta_F_indices = select_points_with_maximum_distance(F, to_find)
+
+        self.eta_F = F[eta_F_indices]
+        self.eta_F = self.eta_F[self.eta_F[:,0].argsort()]
+
+        # Remove duplicate rows
+        self.eta_F = np.unique(self.eta_F, axis=0)
+
+        # A frozen view of the optimization each tau generations 
+        self.paused_F = F
+
+        # Record the previous population in case we need to back track 
+        self.prev_pop = self.pop
+
+        dm_time = self.n_gen % self.tau == 0
+
+        # Check whether we have more than one solution
+        if dm_time and len(self.eta_F) < 2: 
+
+            self._warn("Population only contains one non-dominated solution. ")
+
+            self._reset_dm_preference()
+
+        elif dm_time:
+       
+            # Check if the DM is a machine or a human
+            if self.automated_dm is None: 
+
+                # Human DM
+                if self.ranking_type == "absolute": 
+                    dm_ranks = PINSGA2._get_ranks(self.eta_F, self.presi_signs)
+                elif self.ranking_type == "pairwise": 
+                    dm_ranks = PINSGA2._get_pairwise_ranks(self.eta_F, self.presi_signs)
+                    PINSGA2._present_ranks(self.eta_F, dm_ranks, self.presi_signs) 
+                else: 
+                    raise ValueError("Invalid ranking type [%s] given." % self.ranking_type)
+            else:
+
+                # Automated DM
+                if self.ranking_type == "absolute": 
+                    dm_ranks = self.automated_dm.makeDecision(self.eta_F)
+                elif self.ranking_type == "pairwise": 
+                    dm_ranks = self.automated_dm.makePairwiseDecision(self.eta_F)
+                else: 
+                    raise ValueError("Invalid ranking type [%s] given." % self.ranking_type)
+
+            
+
+            if len(set(rank)) == 0: 
+
+                self._warn("No preference between any two points provided.")
+
+                self._reset_dm_preference()
+
+                return 
+
+            eta_F = self.eta_F
+
+            while eta_F.shape[0] > 1:
+
+                if self.vf_type == "linear":
+
+                    vf_res = mvf.create_linear_vf(eta_F * -1, 
+                                                  dm_ranks.tolist(), 
+                                                  eps_max=self.eps_max, 
+                                                  method=self.opt_method)
+
+                elif self.vf_type == "poly":
+
+                    vf_res = mvf.create_poly_vf(eta_F * -1, 
+                                                dm_ranks.tolist(), 
+                                                eps_max=self.eps_max, 
+                                                method=self.opt_method)
+    
+                else:
+                    
+                    raise ValueError("Value function %s not supported" % self.vf_type)
+
+                # check if we were able to model the VF
+                if vf_res.fit:
+
+                    self.vf_res = vf_res
+                    self.vf_plot_flag = True
+                    self.v2 = self.vf_res.vf(eta_F[dm_ranks[1] - 1] * -1).item()
+                    break
+
+                else:
+
+                    # If we didn't the model, try to remove the least preferred point and try to refit
+                    self._warn("Could not fit a function to the DM preference")
+
+                    if eta_F.shape[0] == 2:
+
+                        # If not, reset and use normal domination
+                        self._warn("Removing DM preference")
+                        self._reset_dm_preference()
+                        break
+
+                    else:
+
+                        self._warn("Removing the second best preferred solution from the fit.")
+
+                        # ranks start at 1, not zero
+                        rank_to_remove = dm_ranks[1] 
+                        eta_F = np.delete(eta_F, rank_to_remove - 1, axis=0)
+
+                        dm_ranks = np.concatenate(([dm_ranks[0]], dm_ranks[2:]))
+                        
+                        # update the ranks, since we just removed one
+                        dm_ranks[dm_ranks > rank_to_remove] = dm_ranks[dm_ranks > rank_to_remove] - 1 
+
+
+parse_doc_string(PINSGA2.__init__)
+
+

pymoo/algorithms/moo/rnsga3.py

@@ -176,7 +176,7 @@ def get_ref_dirs_from_points(ref_point, ref_dirs, mu=0.1):
     Das-Dennis points around the projection of user points on the Das-Dennis hyperplane
     :param ref_point: List of user specified reference points
     :param n_obj: Number of objectives to consider
-    :param mu: Shrinkage factor (0-1), Smaller = tigher convergence, Larger= larger convergence
+    :param mu: Shrinkage factor (0-1), Smaller = tighter convergence, Larger= larger convergence
     :return: Set of reference points
     """
 
@@ -232,7 +232,7 @@ def line_plane_intersection(l0, l1, p0, p_no, epsilon=1e-6):
         # if 'fac' is between (0 - 1) the point intersects with the segment.
         # otherwise:
         #  < 0.0: behind p0.
-        #  > 1.0: infront of p1.
+        #  > 1.0: in front of p1.
         w = p0 - l0
         d = np.dot(w, p_no) / dot
         l = l * d