def test_should_execute_work_properly_with_a_two_crossover_operators(self): operator = CompositeCrossover( [SBXCrossover(0.9, 20.0), IntegerSBXCrossover(0.1, 20.0)]) float_solution1 = FloatSolution([2.0], [3.9], 3) float_solution1.variables = [3.0] float_solution2 = FloatSolution([2.0], [3.9], 3) float_solution2.variables = [4.0] integer_solution1 = IntegerSolution([2], [4], 3) integer_solution1.variables = [3.0] integer_solution2 = IntegerSolution([2], [7], 3) integer_solution2.variables = [4.0] composite_solution1 = CompositeSolution( [float_solution1, integer_solution1]) composite_solution2 = CompositeSolution( [float_solution2, integer_solution2]) children = operator.execute([composite_solution1, composite_solution2]) self.assertIsNotNone(children) self.assertEqual(2, len(children)) self.assertEqual(2, children[0].number_of_variables) self.assertEqual(2, children[1].number_of_variables)
def create_solution(self) -> CompositeSolution: # INICIALIZAÇÂO DO PROBLEMA attributes_solution = IntegerSolution(self.int_lower_bound_attribute, self.int_upper_bound_attribute, self.number_of_objectives, self.number_of_constraints) labels_solution = IntegerSolution(self.int_lower_bound_label, self.int_upper_bound_label, self.number_of_objectives, self.number_of_constraints) points_solution = FloatSolution(self.lower_centroids, self.upper_centroids, self.number_of_objectives, self.number_of_constraints) if self.isSeed: attributes_solution.variables = self.antecedentes labels_solution.variables = self.consequentes points_solution.variables = self.centroids self.isSeed = False else: attributes_solution.variables = \ [random.randint(self.int_lower_bound_attribute[i], self.int_upper_bound_attribute[i]) for i in range(len(self.int_lower_bound_attribute))] labels_solution.variables = \ [random.randint(self.int_lower_bound_label[i], self.int_upper_bound_label[i]) for i in range(len(self.int_lower_bound_label))] points_solution.variables = \ [random.uniform(self.lower_centroids[i], self.upper_centroids[i]) for i in range(len(self.lower_centroids))] return CompositeSolution([attributes_solution, labels_solution, points_solution])
def test_should_execute_raise_and_exception_if_the_types_of_the_solutions_do_not_match_the_operators(self): operator = CompositeCrossover([SBXCrossover(1.0, 5.0), SPXCrossover(0.9)]) float_solution1 = FloatSolution([2.0], [3.9], 3) float_solution1.variables = [3.0] float_solution2 = FloatSolution([2.0], [3.9], 3) float_solution2.variables = [4.0] composite_solution1 = CompositeSolution([float_solution1, float_solution2]) composite_solution2 = CompositeSolution([float_solution1, float_solution2]) with self.assertRaises(InvalidConditionException): operator.execute([composite_solution1, composite_solution2])
def test_should_execute_return_the_parents_if_the_crossover_probability_is_zero(self): crossover: SBXCrossover = SBXCrossover(0.0, 20.0) solution1 = FloatSolution([1, 2], [2, 4], 2, 2) solution2 = FloatSolution([1, 2], [2, 4], 2, 2) solution1.variables = [1.5, 2.7] solution2.variables = [1.7, 3.6] offspring = crossover.execute([solution1, solution2]) self.assertEqual(2, len(offspring)) self.assertEqual(solution1.variables, offspring[0].variables) self.assertEqual(solution2.variables, offspring[1].variables)
def test_should_the_solution_change_if_the_probability_is_one(self): operator = SimpleRandomMutation(1.0) solution = FloatSolution([-5, -5, -5], [5, 5, 5], 1) solution.variables = [1.0, 2.0, 3.0] mutated_solution = operator.execute(solution) self.assertNotEqual([1.0, 2.0, 3.0], mutated_solution.variables)
def test_should_the_solution_remain_unchanged_if_the_probability_is_zero(self): operator = Polynomial(0.0) solution = FloatSolution(2, 1, 0, [-5, -5, -5], [5, 5, 5]) solution.variables = [1.0, 2.0, 3.0] mutated_solution = operator.execute(solution) self.assertEqual([1.0, 2.0, 3.0], mutated_solution.variables)
def create_initial_solutions(self) -> List[S]: if self.problem.config.iteration_round == 0: # print(self.problem.config.iteration_round, self.population_size) return [ self.population_generator.new(self.problem) for _ in range(self.population_size) ] # return [self.problem.create_solution() for _ in range(self.population_size)] ## random generator else: population = [ self.population_generator.new(self.problem) for _ in range(int(0.5 * self.population_size)) ] # existing_population = [] for i in range(self.population_size - int(0.5 * self.population_size)): new_solution = FloatSolution( self.problem.lower_bound, self.problem.upper_bound, self.problem.number_of_objectives, self.problem.number_of_constraints) new_solution.variables = self.initial_population[ self.problem.config.goal_selection_index][i] # print(i, self.initial_population[self.problem.config.goal_selection_index][i]) population.append(new_solution) return population
def create_solution(self) -> FloatSolution: new_solution = FloatSolution(self.number_of_variables, self.number_of_objectives, self.number_of_constraints, self.lower_bound, self.upper_bound) new_solution.variables = \ [random.uniform(self.lower_bound[i]*1.0, self.upper_bound[i]*1.0) for i in range(self.number_of_variables)] return new_solution
def lorenz_map(swarm_size, number_of_variables, number_of_objectives, number_of_constraints, lower_bound, upper_bound): #lorenz map initialization chaos_limits = { "x_high": 22.0, "x_low": -22.0, "y_high": 30.0, "y_low": -30.0, "z_high": 55.0, "z_low": 0.0 } lorenz_sets = number_of_variables // 3 + 1 chaos_set = {} for it in range(lorenz_sets): chaos_set["xs_list_" + str(it + 1)] = [] chaos_set["ys_list_" + str(it + 1)] = [] chaos_set["zs_list_" + str(it + 1)] = [] dt = 0.02 xs = np.empty((swarm_size + 1)) ys = np.empty((swarm_size + 1)) zs = np.empty((swarm_size + 1)) xs[0], ys[0], zs[0] = (np.random.rand(), np.random.rand(), np.random.rand()) for i in range(swarm_size): # Derivatives of the X, Y, Z state x_dot, y_dot, z_dot = lorenz(xs[i], ys[i], zs[i]) xs[i + 1] = xs[i] + (x_dot * dt) ys[i + 1] = ys[i] + (y_dot * dt) zs[i + 1] = zs[i] + (z_dot * dt) chaos_set["xs_list_" + str(it + 1)].extend(xs) chaos_set["ys_list_" + str(it + 1)].extend(ys) chaos_set["zs_list_" + str(it + 1)].extend(zs) choices = list(chaos_set.keys()) #print(chaos_set) random.shuffle(choices) result = [] for i in range(swarm_size): temp = [] for i_1 in range(number_of_variables): temp.append(((chaos_set[choices[i_1]][i] - chaos_limits[choices[i_1][0] + "_low"]) / (chaos_limits[choices[i_1][0] + "_high"] - chaos_limits[choices[i_1][0] + "_low"])) * (upper_bound[i_1] - lower_bound[i_1]) + lower_bound[i_1]) #print(chaos_set[choices[i_1]][i],chaos_limits[choices[i_1][0]+"_low"],(chaos_limits[choices[i_1][0]+"_high"],upper_bound[i_1],lower_bound[i_1]),((chaos_set[choices[i_1]][i] - chaos_limits[choices[i_1][0]+"_low"])/(chaos_limits[choices[i_1][0]+"_high"] - chaos_limits[choices[i_1][0]+"_low"])) * (upper_bound[i_1] - lower_bound[i_1]) + lower_bound[i_1]) #input() #print(chaos_set[sel_list[i_1][0]+ "s_list_" + str(sel_list[i_1][1])][i_1]) new_solution = FloatSolution(number_of_variables, number_of_objectives, number_of_constraints, lower_bound, upper_bound) #print(temp) #input() new_solution.variables = temp result.append(new_solution) #print(temp) #print(result) return result
def test_should_the_solution_change_between_max_and_min_value(self): operator = SimpleRandom(1.0) solution = FloatSolution(4, 1, 0, [-1, 12, -3, -5], [1, 17, 3, -2]) solution.variables = [-7.0, 3.0, 12.0, 13.4] mutated_solution = operator.execute(solution) for i in range(solution.number_of_variables): self.assertGreaterEqual(mutated_solution.variables[i], solution.lower_bound[i]) self.assertLessEqual(mutated_solution.variables[i], solution.upper_bound[i])
def create_solution(self): """ Creates a new solution based on the bounds and variables. """ new_solution = FloatSolution(self.lower_bound, self.upper_bound, self.number_of_objectives, self.number_of_constraints) new_solution.variables = np.random.uniform( self.lower_bound, self.upper_bound, self.number_of_variables ).tolist( ) if not self._initial_solutions else self._initial_solutions.pop() return new_solution
def test_should_the_solution_change__if_the_probability_is_one(self): operator = PolynomialMutation(1.0) solution = FloatSolution([-5, -5, -5], [5, 5, 5], 2) solution.variables = [1.0, 2.0, 3.0] FloatSolution.lower_bound = [-5, -5, -5] FloatSolution.upper_bound = [5, 5, 5] mutated_solution = operator.execute(solution) self.assertNotEqual([1.0, 2.0, 3.0], mutated_solution.variables)
def generate_solution(self) -> FloatSolution: new_solution = FloatSolution(self.lower_bound, self.upper_bound, self.number_of_objectives, self.number_of_constraints) new_solution.variables = [] for _ in range(self.number_of_objectives - 1): new_solution.variables.append(random.uniform(0, 1)) for _ in range(self.number_of_objectives - 1, self.number_of_variables): new_solution.variables.append(0.5) self.evaluate(new_solution) return new_solution
def create_solution(self, swarm_size=1) -> FloatSolution: if swarm_size > 1: #if not default swarm size, use lorenz map initalization return lorenz_map(swarm_size, self.number_of_variables, self.number_of_objectives, self.number_of_constraints, self.lower_bound, self.upper_bound) else: new_solution = FloatSolution(self.number_of_variables, self.number_of_objectives, self.number_of_constraints, self.lower_bound, self.upper_bound) #### Chaos initialization start new_solution.variables = \ [random.uniform(self.lower_bound[i]*1.0, self.upper_bound[i]*1.0) for i in range(self.number_of_variables)] #lorenz_map(self.lower_bound,self.upper_bound,self.number_of_variables)#[random.uniform(self.lower_bound[i]*1.0, self.upper_bound[i]*1.0) for i in range(self.number_of_variables)] return new_solution
def test_should_execute_raise_and_exception_if_the_types_of_the_solutions_do_not_match_the_operators( self): operator = CompositeMutation( [PolynomialMutation(1.0, 5.0), PolynomialMutation(0.9, 25.0)]) float_solution = FloatSolution([2.0], [3.9], 3) binary_solution = BinarySolution(1, 3, 0) float_solution.variables = [3.0] composite_solution = CompositeSolution( [float_solution, binary_solution]) with self.assertRaises(InvalidConditionException): operator.execute(composite_solution)
def create_initial_solutions(self) -> List[S]: if self.continue_flag == 1: population = [] for i in range(self.population_size): new_solution = FloatSolution( self.problem.lower_bound, self.problem.upper_bound, self.problem.number_of_objectives, self.problem.number_of_constraints) new_solution.variables = self.initial_population[i] population.append(new_solution) return population else: return [ self.population_generator.new(self.problem) for _ in range(self.population_size) ]
def test_should_copy_work_properly(self) -> None: solution = FloatSolution(2, 3, [0.0, 0.5], [1.0, 2.0]) solution.variables = [1.24, 2.66] solution.objectives = [0.16, -2.34, 9.25] solution.attributes["attr"] = "value" new_solution = copy.copy(solution) self.assertEqual(solution.number_of_variables, new_solution.number_of_variables) self.assertEqual(solution.number_of_objectives, new_solution.number_of_objectives) self.assertEqual(solution.variables, new_solution.variables) self.assertEqual(solution.objectives, new_solution.objectives) self.assertEqual(solution.lower_bound, new_solution.lower_bound) self.assertEqual(solution.upper_bound, new_solution.upper_bound) self.assertIs(solution.lower_bound, solution.lower_bound) self.assertIs(solution.upper_bound, solution.upper_bound) self.assertEqual(solution.attributes, new_solution.attributes)
def test_should_copy_work_properly(self) -> None: solution = FloatSolution(2, 3, 2, [0.0, 0.5], [1.0, 2.0]) solution.variables = [1.24, 2.66] solution.objectives = [0.16, -2.34, 9.25] solution.attributes["attr"] = "value" new_solution = copy.copy(solution) self.assertEqual(solution.number_of_variables, new_solution.number_of_variables) self.assertEqual(solution.number_of_objectives, new_solution.number_of_objectives) self.assertEqual(solution.number_of_constraints, new_solution.number_of_constraints) self.assertEqual(solution.variables, new_solution.variables) self.assertEqual(solution.objectives, new_solution.objectives) self.assertEqual(solution.lower_bound, new_solution.lower_bound) self.assertEqual(solution.upper_bound, new_solution.upper_bound) self.assertIs(solution.lower_bound, solution.lower_bound) self.assertIs(solution.upper_bound, solution.upper_bound) self.assertEqual({}, new_solution.attributes)
def create_solution(self) -> CompositeSolution: integer_solution = IntegerSolution(self.int_lower_bound, self.int_upper_bound, self.number_of_objectives, self.number_of_constraints) float_solution = FloatSolution(self.float_lower_bound, self.float_upper_bound, self.number_of_objectives, self.number_of_constraints) float_solution.variables = \ [random.uniform(self.float_lower_bound[i] * 1.0, self.float_upper_bound[i] * .01) for i in range(len(self.int_lower_bound))] integer_solution.variables = \ [random.uniform(self.float_lower_bound[i], self.float_upper_bound[i]) for i in range(len(self.float_lower_bound))] return CompositeSolution([integer_solution, float_solution])
def generate_existing_solution( self, variables: List[float], is_objectives: bool = False) -> FloatSolution: new_solution = FloatSolution(self.lower_bound, self.upper_bound, self.number_of_objectives, self.number_of_constraints) if not is_objectives: new_solution.variables = [ variables[index_var] for index_var in range(self.number_of_variables) ] self.evaluate(new_solution) else: new_solution.objectives = [ variables[index_var] for index_var in range(self.number_of_objectives) ] return new_solution
def create_solution(self) -> FloatSolution: new_solution = FloatSolution( lower_bound=self.lower_bound, upper_bound=self.upper_bound, number_of_objectives=self.number_of_objectives, number_of_constraints=self.number_of_constraints) new_solution.number_of_variables = self.number_of_variables new_solution.attributes = { "fitness": 0, "weights": np.zeros(self.number_of_objectives), "confort": 0, "temperatura": 0, "vt": 0 } new_solution.variables = [ np.random.uniform(self.lower_bound[i], self.upper_bound[i]) for i in range(self.datos_externos.intervalos * 5) ] return new_solution
def read_(self, absolute_path: str) -> DTLZInstance: with open(absolute_path) as f: content = f.readlines() # you may also want to remove whitespace characters like `\n` at the end of each line content = [x.strip() for x in content] index = 0 self.n_obj = int(content[index].split()[0]) index += 1 self.n_var = int(content[index].split()[0]) index += 1 self.n_constraints = 0 self.dms = int(content[index].split()[0]) self.upper_bound = self.n_var * [0.0] self.lower_bound = self.n_var * [1.0] weight = [] for dm in range(self.dms): index += 1 line_split = clean_line(content[index]) idx = 0 w = [] while idx < self.n_obj * 2: lower = float(line_split[idx]) idx += 1 upper = float(line_split[idx].replace(',', '')) idx += 1 w.append(Interval(lower, upper)) weight.append(w) veto = [] for dm in range(self.dms): index += 1 line_split = clean_line(content[index]) idx = 0 v = [] while idx < self.n_obj * 2: lower = float(line_split[idx]) idx += 1 upper = float(line_split[idx].replace(',', '')) idx += 1 v.append(Interval(lower, upper)) veto.append(v) beta = [] for i in range(self.dms): index += 1 line_split = content[index].split() beta.append( Interval(float(line_split[0]), float(line_split[1].replace(',', '')))) lambdas = [] for i in range(self.dms): index += 1 line_split = content[index].split() lambdas.append( Interval(float(line_split[0]), float(line_split[1].replace(',', '')))) index += 1 line = clean_line(content[index]) if line[0] == 'TRUE': read_objectives = False if len(line) >= 2: read_objectives = line[1] == "TRUE" index += 1 n = int(content[index].split()[0]) best_compromise = [] for i in range(n): index += 1 line_split = content[index].split() if read_objectives: best_compromise.append([ float(line_split[i].replace(',', '')) for i in range(0, self.n_obj) ]) else: best_compromise.append([ float(line_split[i].replace(',', '')) for i in range(0, self.n_var) ]) self.attributes['best_compromise'] = best_compromise index += 1 line = clean_line(content[index]) if line[0] == "TRUE": is_interval = True if len(line) >= 2 and line[1] == "FALSE": is_interval = False r2_set = [] r1_set = [] frontiers = [] for dm in range(self.dms): index += 1 line = clean_line(content[index]) n_size = int(int(line[0]) / 2) r2 = [] r1 = [] for n_row in range(n_size): r2_ = [] index += 1 line = clean_line(content[index]) idx = 0 while idx < self.n_obj * (2 if is_interval else 1): if is_interval: r2_.append(Interval(line[idx], line[idx + 1])) idx += 2 else: r2_.append(Interval(line[idx], line[idx])) idx += 1 r2.append(r2_) for n_row in range(n_size): r1_ = [] index += 1 line = clean_line(content[index]) idx = 0 while idx < self.n_obj * (2 if is_interval else 1): if is_interval: r1_.append(Interval(line[idx], line[idx + 1])) idx += 2 else: r1_.append(Interval(line[idx], line[idx])) idx += 1 r1.append(r1_) r2_set.append(r2) r1_set.append(r1) frontiers.append(r2 + r1) self.attributes['frontiers'] = frontiers self.attributes['r2'] = r2_set self.attributes['r1'] = r1_set index += 1 if content[index].split()[0] == 'TRUE': index += 1 n = int(content[index].split()[0]) self.initial_solutions = [] for i in range(n): index += 1 line_split = content[index].split() solution = FloatSolution(lower_bound=self.lower_bound, upper_bound=self.upper_bound, number_of_objectives=self.n_obj) solution.variables = [ float(line_split[i].replace(',', '')) for i in range(0, self.n_var) ] self.initial_solutions.append(solution) self.attributes['dms'] = self.dms models = [] for dm in range(self.dms): model = OutrankingModel(weight[dm], veto[dm], 1.0, beta[dm], lambdas[dm], 1) models.append(model) self.attributes['models'] = models return self