def execute(self, front: List[S]) -> List[S]:
if front is None:
raise Exception('The front is null')
elif len(front) == 0:
raise Exception('The front is empty')
ranking = FastNonDominatedRanking(self.dominance_comparator)
crowding_distance = CrowdingDistance()
ranking.compute_ranking(front)
ranking_index = 0
new_solution_list = []
while len(new_solution_list) < self.max_population_size:
if len(ranking.get_subfront(ranking_index)) < (self.max_population_size - len(new_solution_list)):
new_solution_list = new_solution_list + ranking.get_subfront(ranking_index)
ranking_index += 1
else:
subfront = ranking.get_subfront(ranking_index)
crowding_distance.compute_density_estimator(subfront)
sorted_subfront = sorted(subfront, key=lambda x: x.attributes['crowding_distance'], reverse=True)
for i in range((self.max_population_size - len(new_solution_list))):
new_solution_list.append(sorted_subfront[i])
return new_solution_list
def update_external_archive(self):
feasible_solutions = []
for solution in self.solutions:
if is_feasible(solution):
feasible_solutions.append(copy.deepcopy(solution))
if len(feasible_solutions) > 0:
feasible_solutions = feasible_solutions + self.archive
ranking = FastNonDominatedRanking()
ranking.compute_ranking(feasible_solutions)
first_rank_solutions = ranking.get_subfront(0)
if len(first_rank_solutions) <= self.population_size:
self.archive = []
for solution in first_rank_solutions:
self.archive.append(copy.deepcopy(solution))
else:
crowding_distance = CrowdingDistance()
while len(first_rank_solutions) > self.population_size:
crowding_distance.compute_density_estimator(
first_rank_solutions)
first_rank_solutions = sorted(
first_rank_solutions,
key=lambda x: x.attributes['crowding_distance'],
reverse=True)
first_rank_solutions.pop()
self.archive = []
for solution in first_rank_solutions:
self.archive.append(copy.deepcopy(solution))
class CrowdingDistanceTestCases(unittest.TestCase):
def setUp(self):
self.crowding = CrowdingDistance()
def test_should_the_crowding_distance_of_an_empty_set_do_nothing(self):
solution_list = []
self.crowding.compute_density_estimator(solution_list)
def test_should_the_crowding_distance_of_single_solution_be_infinity(self):
solution = Solution(3, 3)
solution_list = [solution]
self.crowding.compute_density_estimator(solution_list)
value = solution_list[0].attributes["crowding_distance"]
self.assertEqual(float("inf"), value)
def test_should_the_crowding_distance_of_two_solutions_be_infinity(self):
solution1 = Solution(3, 3)
solution2 = Solution(3, 3)
solution_list = [solution1, solution2]
self.crowding.compute_density_estimator(solution_list)
value_from_solution1 = solution_list[0].attributes["crowding_distance"]
value_from_solution2 = solution_list[1].attributes["crowding_distance"]
self.assertEqual(float("inf"), value_from_solution1)
self.assertEqual(float("inf"), value_from_solution2)
def test_should_the_crowding_distance_of_three_solutions_correctly_assigned(self):
solution1 = Solution(2, 2)
solution2 = Solution(2, 2)
solution3 = Solution(2, 2)
solution1.objectives[0] = 0.0
solution1.objectives[1] = 1.0
solution2.objectives[0] = 1.0
solution2.objectives[1] = 0.0
solution3.objectives[0] = 0.5
solution3.objectives[1] = 0.5
solution_list = [solution1, solution2, solution3]
self.crowding.compute_density_estimator(solution_list)
value_from_solution1 = solution_list[0].attributes["crowding_distance"]
value_from_solution2 = solution_list[1].attributes["crowding_distance"]
value_from_solution3 = solution_list[2].attributes["crowding_distance"]
self.assertEqual(float("inf"), value_from_solution1)
self.assertEqual(float("inf"), value_from_solution2)
self.assertEqual(2.0, value_from_solution3)
def test_should_the_crowding_distance_of_four_solutions_correctly_assigned(self):
solution1 = Solution(2, 2)
solution2 = Solution(2, 2)
solution3 = Solution(2, 2)
solution4 = Solution(2, 2)
solution1.objectives[0] = 0.0
solution1.objectives[1] = 1.0
solution2.objectives[0] = 1.0
solution2.objectives[1] = 0.0
solution3.objectives[0] = 0.5
solution3.objectives[1] = 0.5
solution4.objectives[0] = 0.75
solution4.objectives[1] = 0.75
solution_list = [solution1, solution2, solution3, solution4]
self.crowding.compute_density_estimator(solution_list)
value_from_solution1 = solution_list[0].attributes["crowding_distance"]
value_from_solution2 = solution_list[1].attributes["crowding_distance"]
value_from_solution3 = solution_list[2].attributes["crowding_distance"]
value_from_solution4 = solution_list[3].attributes["crowding_distance"]
self.assertEqual(float("inf"), value_from_solution1)
self.assertEqual(float("inf"), value_from_solution2)
self.assertGreater(value_from_solution3, value_from_solution4)