Update crowding distance

Author: ahmedfgad

NSGA-II/non_dominant_sorting_crowding_distance.py

@@ -1,73 +1,139 @@
 import numpy
 
-population = numpy.array([[20, 2.2],
-                          [60, 4.4],
-                          [65, 3.5],
-                          [15, 4.4],
-                          [55, 4.5],
-                          [50, 1.8],
-                          [80, 4.0],
-                          [25, 4.6]])
-
-def non_dominant_sorting(curr_set):
-    # List of the members of the current dominant front/set.
-    dominant_set = []
-    # List of the non-members of the current dominant front/set.
-    non_dominant_set = []
-    for idx1, sol1 in enumerate(curr_set):
-        # Flag indicates whether the solution is a member of the current dominant set.
-        is_dominant = True
-        for idx2, sol2 in enumerate(curr_set):
+population_fitness = numpy.array([[20, 2.2],
+                                  [60, 4.4],
+                                  [65, 3.5],
+                                  [15, 4.4],
+                                  [55, 4.5],
+                                  [50, 1.8],
+                                  [80, 4.0],
+                                  [25, 4.6]])
+
+def get_non_dominated_set(curr_solutions):
+    """
+    Get the set of non-dominated solutions from the current set of solutions.
+
+    Parameters
+    ----------
+    curr_solutions : TYPE
+        The set of solutions to find its non-dominated set.
+
+    Returns
+    -------
+    dominated_set : TYPE
+        A set of the dominated solutions.
+    non_dominated_set : TYPE
+        A set of the non-dominated set.
+
+    """
+    # List of the members of the current dominated pareto front/set.
+    dominated_set = []
+    # List of the non-members of the current dominated pareto front/set.
+    non_dominated_set = []
+    for idx1, sol1 in enumerate(curr_solutions):
+        # Flag indicates whether the solution is a member of the current dominated set.
+        is_dominated = True
+        for idx2, sol2 in enumerate(curr_solutions):
             if idx1 == idx2:
                 continue
             # Zipping the 2 solutions so the corresponding genes are in the same list.
             # The returned array is of size (N, 2) where N is the number of genes.
-            b = numpy.array(list(zip(sol1, sol2)))
-    
+            two_solutions = numpy.array(list(zip(sol1[1], sol2[1])))
+
             #TODO Consider repacing < by > for maximization problems.
             # Checking for if any solution dominates the current solution by applying the 2 conditions.
-            # le_eq: All elements must be True.
-            # le: Only 1 element must be True.
-            le_eq = b[:, 1] <= b[:, 0]
-            le = b[:, 1] < b[:, 0]
+            # le_eq (less than or equal): All elements must be True.
+            # le (less than): Only 1 element must be True.
+            le_eq = two_solutions[:, 1] <= two_solutions[:, 0]
+            le = two_solutions[:, 1] < two_solutions[:, 0]
 
             # If the 2 conditions hold, then a solution dominates the current solution.
-            # The current solution is not considered a member of the dominant set.
+            # The current solution is not considered a member of the dominated set.
             if le_eq.all() and le.any():
-                # print(f"{sol2} dominates {sol1}")
-                # Set the is_dominant flag to False to not insert the current solution in the current dominant set.
-                # Instead, insert it into the non-dominant set.
-                is_dominant = False
-                non_dominant_set.append(sol1)
+                # Set the is_dominated flag to False to NOT insert the current solution in the current dominated set.
+                # Instead, insert it into the non-dominated set.
+                is_dominated = False
+                non_dominated_set.append(sol1)
                 break
             else:
-                # Reaching here means the solution does not dominant the current solution.
-                # print(f"{sol2} does not dominate {sol1}")
+                # Reaching here means the solution does not dominate the current solution.
                 pass
 
         # If the flag is True, then no solution dominates the current solution.
-        if is_dominant:
-            dominant_set.append(sol1)
+        if is_dominated:
+            dominated_set.append(sol1)
+
+    # Return the dominated and non-dominated sets.
+    return dominated_set, non_dominated_set
+
+def non_dominated_sorting(population_fitness):
+    """
+    Apply the non-dominant sorting over the population_fitness to create sets of non-dominaned solutions.
+
+    Parameters
+    ----------
+    population_fitness : TYPE
+        An array of the population fitness across all objective function.
 
-    # Return the dominant and non-dominant sets.
-    return dominant_set, non_dominant_set
+    Returns
+    -------
+    non_dominated_sets : TYPE
+        An array of the non-dominated sets.
 
-dominant_set = []
-non_dominant_set = population.copy()
-while len(non_dominant_set) > 0:
-    d1, non_dominant_set = non_dominant_sorting(non_dominant_set)
-    dominant_set.append(numpy.array(d1))
+    """
+    # A list of all non-dominated sets.
+    non_dominated_sets = []
 
-for i, s in enumerate(dominant_set):
-    print(f'Dominant Front Set {i+1}:\n{s}')
+    # The remaining set to be explored for non-dominance.
+    # Initially it is set to the entire population.
+    # The solutions of each non-dominated set are removed after each iteration.
+    remaining_set = population_fitness.copy()
+
+    # Zipping the solution index with the solution's fitness.
+    # This helps to easily identify the index of each solution.
+    # Each element has:
+        # 1) The index of the solution.
+        # 2) An array of the fitness values of this solution across all objectives.
+    # remaining_set = numpy.array(list(zip(range(0, population_fitness.shape[0]), non_dominated_set)))
+    remaining_set = list(zip(range(0, population_fitness.shape[0]), remaining_set))
+    while len(remaining_set) > 0:
+        # Get the current non-dominated set of solutions.
+        d1, remaining_set = get_non_dominated_set(curr_solutions=remaining_set)
+        non_dominated_sets.append(numpy.array(d1, dtype=object))
+    return non_dominated_sets
+
+def crowding_distance(pareto_front):
+    """
+    Calculate the crowding dstance for all solutions in the current pareto front.
+
+    Parameters
+    ----------
+    pareto_front : TYPE
+        The set of solutions in the current pareto front.
+
+    Returns
+    -------
+    obj_crowding_dist_list : TYPE
+        A nested list of the values for all objectives alongside their crowding distance.
+    crowding_dist_sum : TYPE
+        A list of the sum of crowding distances across all objectives for each solution.
+    """
+
+    # Each solution in the pareto front has 2 elements:
+        # 1) The index of the solution in the population.
+        # 2) A list of the fitness values for all objectives of the solution.
+    # Before proceeding, remove the indices from each solution in the pareto front.
+    pareto_front = numpy.array([pareto_front[idx] for idx in range(pareto_front.shape[0])])
+
+    # If there is only 1 solution, then return empty arrays for the crowding distance.
+    if pareto_front.shape[0] == 1:
+        return numpy.array([]), numpy.array([])
 
-print("\n\n\n--------------------")
-def crowding_distance(front):
     # An empty list holding info about the objectives of each solution. The info includes the objective value and crowding distance.
     obj_crowding_dist_list = []
     # Loop through the objectives to calculate the crowding distance of each solution across all objectives.
-    for obj_idx in range(front.shape[1]):
-        obj = front[:, obj_idx]
+    for obj_idx in range(pareto_front.shape[1]):
+        obj = pareto_front[:, obj_idx]
         # This variable has a nested list where each child list zip the following together:
             # 1) The index of the objective value.
             # 2) The objective value.
@@ -79,8 +145,8 @@ def crowding_distance(front):
         obj_sorted = sorted(obj, key=lambda x: x[1])
 
         # Get the minimum and maximum values for the current objective.
-        obj_min_val = min(population[:, obj_idx])
-        obj_max_val = max(population[:, obj_idx])
+        obj_min_val = min(population_fitness[:, obj_idx])
+        obj_max_val = max(population_fitness[:, obj_idx])
         denominator = obj_max_val - obj_min_val
         # To avoid division by zero, set the denominator to a tiny value.
         if denominator == 0:
@@ -93,7 +159,7 @@ def crowding_distance(front):
         # crowding_distance[-1] = inf_val
         obj_sorted[-1][2] = inf_val
 
-        # If there are only 2 solutions in the current front, then do not proceed.
+        # If there are only 2 solutions in the current pareto front, then do not proceed.
         # The crowding distance for such 2 solutions is infinity.
         if len(obj_sorted) <= 2:
             break
@@ -113,11 +179,24 @@ def crowding_distance(front):
     crowding_dist = numpy.array([obj_crowding_dist_list[idx, :, 2] for idx in range(len(obj_crowding_dist_list))])
     crowding_dist_sum = numpy.sum(crowding_dist, axis=0)
 
+    # An array of the sum of crowding distances across all objectives. 
+    # Each row has 2 elements:
+        # 1) The index of the solution.
+        # 2) The sum of all crowding distances for all objective of the solution.
+    crowding_dist_sum = numpy.array(list(zip(obj_crowding_dist_list[0, :, 0], crowding_dist_sum)))
+    crowding_dist_sum = sorted(crowding_dist_sum, key=lambda x: x[1], reverse=True)
+
     return obj_crowding_dist_list, crowding_dist_sum
 
-# Fetch the current front.
-front = dominant_set[1]
-obj_crowding_distance_list, crowding_distance_sum = crowding_distance(front)
+non_dominated_sets = non_dominated_sorting(population_fitness)
+
+# for i, s in enumerate(non_dominated_sets):
+#     print(f'dominated Pareto Front Set {i+1}:\n{s}')
+# print("\n\n\n--------------------")
+
+# Fetch the current pareto front.
+pareto_front = non_dominated_sets[1][:, 1]
+obj_crowding_distance_list, crowding_distance_sum = crowding_distance(pareto_front)
 
 print(obj_crowding_distance_list)
-print(f'\nSum of Crowd Dists\n{crowding_distance_sum}')
+print(f'\nSorted Sum of Crowd Dists\n{crowding_distance_sum}')