def test_constructor(self): """ Tests BrkgaParams constructor. """ ######################## # Test regular/correct building. ####################### param_values = deepcopy(self.default_param_values) brkga = BrkgaMpIpr(**param_values) self.assertEqual(brkga.elite_size, 3) self.assertEqual(brkga.num_mutants, 1) brkga_params = param_values["params"] self.assertEqual(len(brkga._parents_ordered), brkga_params.total_parents) local_rng = Random(param_values["seed"]) # Same warm up that the one in the constructor. for _ in range(1000): local_rng.random() self.assertEqual(brkga._rng.getstate(), local_rng.getstate()) self.assertEqual(brkga._ChromosomeType, BaseChromosome) ######################## # Test multi-start building. ######################## param_values["evolutionary_mechanism_on"] = False param_values["params"].population_size = 10 brkga = BrkgaMpIpr(**param_values) self.assertEqual(brkga.elite_size, 1) self.assertEqual(brkga.num_mutants, 9) ######################## # Test bias functions. ######################## param_values = deepcopy(self.default_param_values) param_values["params"].bias_type = BiasFunctionType.LOGINVERSE brkga = BrkgaMpIpr(**param_values) self.assertEqual(brkga.params.bias_type, BiasFunctionType.LOGINVERSE) self.assertAlmostEqual(brkga._bias_function(1), 1.4426950408889634) self.assertAlmostEqual(brkga._bias_function(2), 0.9102392266268375) self.assertAlmostEqual(brkga._bias_function(3), 0.721347520444481) param_values["params"].bias_type = BiasFunctionType.LINEAR brkga = BrkgaMpIpr(**param_values) self.assertEqual(brkga.params.bias_type, BiasFunctionType.LINEAR) self.assertAlmostEqual(brkga._bias_function(1), 1.0) self.assertAlmostEqual(brkga._bias_function(2), 0.5) self.assertAlmostEqual(brkga._bias_function(3), 0.333333333333) param_values["params"].bias_type = BiasFunctionType.QUADRATIC brkga = BrkgaMpIpr(**param_values) self.assertEqual(brkga.params.bias_type, BiasFunctionType.QUADRATIC) self.assertAlmostEqual(brkga._bias_function(1), 1.0) self.assertAlmostEqual(brkga._bias_function(2), 0.25) self.assertAlmostEqual(brkga._bias_function(3), 0.111111111111) param_values["params"].bias_type = BiasFunctionType.CUBIC brkga = BrkgaMpIpr(**param_values) self.assertEqual(brkga.params.bias_type, BiasFunctionType.CUBIC) self.assertAlmostEqual(brkga._bias_function(1), 1.0) self.assertAlmostEqual(brkga._bias_function(2), 0.125) self.assertAlmostEqual(brkga._bias_function(3), 0.037037037037037035) param_values["params"].bias_type = BiasFunctionType.EXPONENTIAL brkga = BrkgaMpIpr(**param_values) self.assertEqual(brkga.params.bias_type, BiasFunctionType.EXPONENTIAL) self.assertAlmostEqual(brkga._bias_function(1), 0.36787944117144233) self.assertAlmostEqual(brkga._bias_function(2), 0.1353352832366127) self.assertAlmostEqual(brkga._bias_function(3), 0.049787068367863944) param_values["params"].bias_type = BiasFunctionType.CONSTANT brkga = BrkgaMpIpr(**param_values) self.assertEqual(brkga.params.bias_type, BiasFunctionType.CONSTANT) self.assertAlmostEqual(brkga._bias_function(1), 0.5) self.assertAlmostEqual(brkga._bias_function(2), 0.5) self.assertAlmostEqual(brkga._bias_function(3), 0.5) ######################## # Test exceptions. ######################## # Chromosome size param_values = deepcopy(self.default_param_values) param_values["chromosome_size"] = 0 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Chromosome size must be larger than zero: 0") param_values["chromosome_size"] = -10 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Chromosome size must be larger than zero: -10") # Population size param_values = deepcopy(self.default_param_values) param_values["params"].population_size = 0 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Population size size must be larger than zero: 0") param_values["params"].population_size = -10 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Population size size must be larger than zero: -10") # Elite size param_values = deepcopy(self.default_param_values) param_values["params"].elite_percentage = 0.0 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Elite set size less then one: 0") param_values["params"].elite_percentage = -1.0 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Elite set size less then one: -10") param_values["params"].elite_percentage = 0.3 param_values["params"].population_size = 2 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Elite set size less then one: 0") param_values["params"].elite_percentage = 1.1 param_values["params"].population_size = 10 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Elite set size (11) greater than population size (10)") # Mutant size param_values = deepcopy(self.default_param_values) param_values["params"].mutants_percentage = 0.0 brkga = BrkgaMpIpr(**param_values) self.assertEqual(brkga.num_mutants, 0) param_values["params"].mutants_percentage = -1.0 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Mutant set size less then zero: -10") param_values["params"].mutants_percentage = 1.1 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Mutant set size (11) greater than population size (10)") # Elite + Mutant size. param_values = deepcopy(self.default_param_values) param_values["params"].elite_percentage = 0.6 param_values["params"].mutants_percentage = 0.6 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Elite set size (6) + mutant set size (6) greater " "than population size (10)") # Elite parents for mating. param_values = deepcopy(self.default_param_values) param_values["params"].num_elite_parents = 0 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Number of elite parents must be at least 1: 0") param_values["params"].num_elite_parents = 1 param_values["params"].total_parents = 1 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Total parents must be at least 2: 1") param_values["params"].num_elite_parents = 2 param_values["params"].total_parents = 2 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Number of elite parents (2) is greater than or " "equal to total_parents (2)") param_values["params"].num_elite_parents = 3 param_values["params"].total_parents = 2 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Number of elite parents (3) is greater than or " "equal to total_parents (2)") brkga_params = param_values["params"] brkga_params.num_elite_parents = \ 1 + int(brkga_params.population_size * brkga_params.elite_percentage) brkga_params.total_parents = 1 + brkga_params.num_elite_parents with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Number of elite parents (4) is greater than elite set (3)") # Number of independent populations. param_values = deepcopy(self.default_param_values) param_values["params"].num_independent_populations = 0 with self.assertRaises(ValueError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "Number of parallel populations must be larger than zero: 0") # TODO: enable the following when IPR methods be implemented. # # alpha_block_size. # param_values = deepcopy(self.default_param_values) # param_values["params"].alpha_block_size = 0 # with self.assertRaises(ValueError) as context: # brkga = BrkgaMpIpr(**param_values) # self.assertEqual(str(context.exception).strip(), # "Alpha block size must be larger than zero: 0") # # Percentage / path size. # param_values = deepcopy(self.default_param_values) # param_values["params"].pr_percentage = 0.0 # with self.assertRaises(ValueError) as context: # brkga = BrkgaMpIpr(**param_values) # self.assertEqual(str(context.exception).strip(), # "Percentage / path size must be in (0, 1]: 0.0") # param_values["params"].pr_percentage = 1.001 # with self.assertRaises(ValueError) as context: # brkga = BrkgaMpIpr(**param_values) # self.assertEqual(str(context.exception).strip(), # "Percentage / path size must be in (0, 1]: 1.001") # Invalid decoder object. param_values = deepcopy(self.default_param_values) param_values["decoder"] = None with self.assertRaises(TypeError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "The given decoder (<class 'NoneType'>) has no 'decode()' method") param_values["decoder"] = lambda x: sum(x) with self.assertRaises(TypeError) as context: brkga = BrkgaMpIpr(**param_values) self.assertEqual( str(context.exception).strip(), "The given decoder (<class 'function'>) has no 'decode()' method")
def test_set_bias_custom_function(self): """ Tests set_bias_custom_function() method. """ param_values = deepcopy(self.default_param_values) param_values["params"].population_size = 100 param_values["params"].total_parents = 10 brkga = BrkgaMpIpr(**param_values) # After build, brkga_params function is never CUSTOM self.assertNotEqual(brkga.params.bias_type, BiasFunctionType.CUSTOM) with self.assertRaises(ValueError) as context: brkga.set_bias_custom_function(lambda x: -x) self.assertEqual( str(context.exception).strip(), "Bias function must be positive non-increasing") with self.assertRaises(ValueError) as context: brkga.set_bias_custom_function(lambda x: x) self.assertEqual( str(context.exception).strip(), "Bias function is not a non-increasing function") with self.assertRaises(ValueError) as context: brkga.set_bias_custom_function(lambda x: x + 1) self.assertEqual( str(context.exception).strip(), "Bias function is not a non-increasing function") with self.assertRaises(ValueError) as context: brkga.set_bias_custom_function(lambda x: math.log1p(x)) self.assertEqual( str(context.exception).strip(), "Bias function is not a non-increasing function") brkga.set_bias_custom_function(lambda x: 1.0 / math.log1p(x)) self.assertAlmostEqual(brkga._total_bias_weight, 6.554970525044798) # After 2nd call to set_bias_custom_function, brkga_params function # is always CUSTOM self.assertEqual(brkga.params.bias_type, BiasFunctionType.CUSTOM) brkga.set_bias_custom_function(lambda x: 1.0 / x) self.assertAlmostEqual(brkga._total_bias_weight, 2.9289682539682538) self.assertEqual(brkga.params.bias_type, BiasFunctionType.CUSTOM) brkga.set_bias_custom_function(lambda x: x**-2.0) self.assertAlmostEqual(brkga._total_bias_weight, 1.5497677311665408) self.assertEqual(brkga.params.bias_type, BiasFunctionType.CUSTOM) brkga.set_bias_custom_function(lambda x: x**-3.0) self.assertAlmostEqual(brkga._total_bias_weight, 1.197531985674193) self.assertEqual(brkga.params.bias_type, BiasFunctionType.CUSTOM) brkga.set_bias_custom_function(lambda x: math.exp(-x)) self.assertAlmostEqual(brkga._total_bias_weight, 0.5819502851677112) self.assertEqual(brkga.params.bias_type, BiasFunctionType.CUSTOM) # This is a constance function. brkga.set_bias_custom_function( lambda _: 1.0 / brkga.params.total_parents) self.assertAlmostEqual(brkga._total_bias_weight, 0.9999999999999999) self.assertEqual(brkga.params.bias_type, BiasFunctionType.CUSTOM) brkga.set_bias_custom_function(lambda x: 0.6325 / math.sqrt(x)) self.assertAlmostEqual(brkga._total_bias_weight, 3.175781171302612) self.assertEqual(brkga.params.bias_type, BiasFunctionType.CUSTOM) ############################################# # Constant functions test for standard BRKGA ############################################# param_values = deepcopy(self.default_param_values) param_values["params"].num_elite_parents = 1 param_values["params"].total_parents = 2 brkga = BrkgaMpIpr(**param_values) rho = 0.5 brkga.set_bias_custom_function(lambda x: rho if x == 1 else 1.0 - rho) self.assertAlmostEqual(brkga._total_bias_weight, 1.0) self.assertAlmostEqual(brkga._bias_function(1), 0.5) self.assertAlmostEqual(brkga._bias_function(2), 0.5) rho = 0.75 brkga.set_bias_custom_function(lambda x: rho if x == 1 else 1.0 - rho) self.assertAlmostEqual(brkga._total_bias_weight, 1.0) self.assertAlmostEqual(brkga._bias_function(1), 0.75) self.assertAlmostEqual(brkga._bias_function(2), 0.25) rho = 0.9 brkga.set_bias_custom_function(lambda x: rho if x == 1 else 1.0 - rho) self.assertAlmostEqual(brkga._total_bias_weight, 1.0) self.assertAlmostEqual(brkga._bias_function(1), 0.9) self.assertAlmostEqual(brkga._bias_function(2), 0.1)