class SelectionTests(unittest.TestCase): def setUp(self): self.config = { "max_population": 10, "tree_generation": { "method": "FULL_METHOD", "initial_max_depth": 3 }, "selection": { "method": "ROULETTE_SELECTION" }, "function_nodes": [{ "type": "FUNCTION", "name": "ADD", "arity": 2 }, { "type": "FUNCTION", "name": "SUB", "arity": 2 }, { "type": "FUNCTION", "name": "MUL", "arity": 2 }, { "type": "FUNCTION", "name": "DIV", "arity": 2 }, { "type": "FUNCTION", "name": "COS", "arity": 1 }, { "type": "FUNCTION", "name": "SIN", "arity": 1 }, { "type": "FUNCTION", "name": "RAD", "arity": 1 }], "terminal_nodes": [{ "type": "CONSTANT", "value": 1.0 }, { "type": "CONSTANT", "value": 2.0 }, { "type": "CONSTANT", "value": 2.0 }, { "type": "CONSTANT", "value": 3.0 }, { "type": "CONSTANT", "value": 4.0 }, { "type": "CONSTANT", "value": 5.0 }, { "type": "CONSTANT", "value": 6.0 }, { "type": "CONSTANT", "value": 7.0 }, { "type": "CONSTANT", "value": 8.0 }, { "type": "CONSTANT", "value": 9.0 }, { "type": "CONSTANT", "value": 10.0 }], "input_variables": [{ "type": "INPUT", "name": "x" }] } self.functions = GPFunctionRegistry("SYMBOLIC_REGRESSION") self.generator = TreeGenerator(self.config) self.selection = Selection(self.config) self.population = self.generator.init() # give population random scores for inidividual in self.population.individuals: inidividual.score = random.triangular(1, 100) def print_population(self, phase, population): print "{0}[{1}]:".format(phase, len(population.individuals)) for individual in population.individuals: print individual, individual.score print '\n\n' return len(population.individuals) def test_normalize_scores(self): self.selection._normalize_scores(self.population) total_sum = 0 for individual in self.population.individuals: total_sum += individual.score self.assertEquals(round(total_sum, 2), 1.0) def test_roulette_selection(self): print "ROULETTE SELECTION" old_pop_size = len(self.population.individuals) self.selection.roulette_wheel_selection(self.population) new_pop_size = len(self.population.individuals) # assert # check for object uniqueness individual_ids = [] for i in self.population.individuals: self.assertFalse(id(i) in individual_ids) individual_ids.append(id(i)) self.assertEquals(new_pop_size, old_pop_size) def test_tournament_selection(self): print "TOURNAMENT SELECTION" # tournament selection old_pop_size = self.print_population("OLD", self.population) self.selection.tournament_selection(self.population) new_pop_size = self.print_population("NEW", self.population) # assert # check for object uniqueness individual_ids = [] for i in self.population.individuals: self.assertFalse(id(i) in individual_ids) individual_ids.append(id(i)) self.assertEqual(old_pop_size, new_pop_size) def test_elitest_selection(self): print "ELITEST SELECTION" # elitest selection old_pop_size = self.print_population("OLD", self.population) self.selection.elitest_selection(self.population) new_pop_size = self.print_population("NEW", self.population) self.assertEquals(old_pop_size, new_pop_size) def test_greedy_over_selection(self): print "GREEDY-OVER SELECTION" # create population of size 1000 self.config["max_population"] = 1000 generator = TreeGenerator(self.config) population = generator.init() # greedy over selection old_pop_size = self.print_population("OLD", population) self.selection.greedy_over_selection(population) new_pop_size = self.print_population("NEW", population) self.assertEquals(old_pop_size, new_pop_size) def test_select(self): old_pop_size = len(self.population.individuals) self.selection.select(self.population) new_pop_size = len(self.population.individuals) # assert # check for object uniqueness individual_ids = [] for i in self.population.individuals: self.assertFalse(id(i) in individual_ids) individual_ids.append(id(i)) self.assertEquals(old_pop_size, new_pop_size)
class JSONStoreTests(unittest.TestCase): def setUp(self): self.config = { "max_population": 10, "tree_generation": { "method": "FULL_METHOD", "initial_max_depth": 4 }, "evaluator": { "use_cache": True }, "selection": { "method": "TOURNAMENT_SELECTION", "tournament_size": 2 }, "crossover": { "method": "POINT_CROSSOVER", "probability": 0.6 }, "mutation": { "methods": ["POINT_MUTATION"], "probability": 0.8 }, "function_nodes": [{ "type": "FUNCTION", "name": "ADD", "arity": 2 }, { "type": "FUNCTION", "name": "SUB", "arity": 2 }], "terminal_nodes": [ { "type": "CONSTANT", "value": 1.0 }, ], "input_variables": [{ "type": "INPUT", "name": "x" }], "data_file": "tests/data/sine.dat", "response_variables": [{ "name": "y" }], "recorder": { "store_file": "json_store_test.json", "compress": True } } config.load_data(self.config) self.functions = GPFunctionRegistry("SYMBOLIC_REGRESSION") self.generator = TreeGenerator(self.config) self.json_store = JSONStore(self.config) self.json_store.setup_store() self.population = self.generator.init() results = [] cache = {} evaluate(self.population.individuals, self.functions, self.config, results, cache, self.json_store) self.population.sort_individuals() self.selection = Selection(self.config, recorder=self.json_store) self.crossover = TreeCrossover(self.config, recorder=self.json_store) self.mutation = TreeMutation(self.config, recorder=self.json_store) def tearDown(self): self.json_store.delete_store() del self.config del self.functions del self.generator del self.population del self.json_store def test_setup_store(self): # assert file_exists = os.path.exists(self.config["recorder"]["store_file"]) self.assertEquals(file_exists, True) def test_purge_store(self): # write something to store file self.json_store.store_file.write("Hello World\n") self.json_store.store_file.close() # purge store file self.json_store.purge_store() # assert store_file = open(self.config["recorder"]["store_file"], "r").read() self.assertEquals(len(store_file), 0) def test_delete_store(self): # delete store self.json_store.delete_store() # assert file_exists = os.path.exists(self.config["recorder"]["store_file"]) self.assertEquals(file_exists, False) def test_record_population(self): self.json_store.record_population(self.population) record = self.json_store.generation_record self.assertNotEquals(record, {}) self.assertEquals(record["population"]["generation"], 0) def test_record_selection(self): # record selection self.selection.select(self.population) # assert record = self.json_store.generation_record # import pprint # pprint.pprint(record) self.assertNotEquals(record, {}) self.assertEquals(record["selection"]["selected"], 10) def test_record_crossover(self): # record crossover tree_1 = self.population.individuals[0] tree_2 = self.population.individuals[1] self.crossover.crossover(tree_1, tree_2) # assert record = self.json_store.generation_record self.assertNotEquals(record, {}) def test_record_mutation(self): # record mutation tree = self.population.individuals[0] self.mutation.mutate(tree) # assert record = self.json_store.generation_record # pprint.pprint(record) self.assertNotEquals(record, {}) def test_record_evaulation(self): # record evaluation results = [] evaluate(self.population.individuals, self.functions, self.config, results, recorder=self.json_store) # assert record = self.json_store.generation_record # import pprint # pprint.pprint(record) self.assertEquals(record["evaluation"]["cache_size"], 10) self.assertEquals(record["evaluation"]["match_cached"], 0) def test_record_to_file(self): # write record to file and close self.json_store.record_population(self.population) self.json_store.record_to_file() self.json_store.store_file.close() # open up the file and restore json to dict store_file = open(self.config["recorder"]["store_file"], "r").read() data = json.loads(store_file) # assert tests self.assertNotEquals(data, {}) self.assertEquals(data["population"]["generation"], 0) def test_summarize_store(self): # write record to file and close self.json_store.setup_store() self.json_store.record_population(self.population) for i in range(5): tree_1 = self.population.individuals[0] tree_2 = self.population.individuals[1] self.crossover.crossover(tree_1, tree_2) for i in range(10): tree = self.population.individuals[0] self.mutation.mutate(tree) self.json_store.record_to_file() self.json_store.store_file.close() # summarize self.json_store.summarize_store() # assert store_file = open(self.config["recorder"]["store_file"], "r") line = json.loads(store_file.read()) store_file.close() self.assertIsNotNone(line) def test_finalize(self): # write record to file and close self.json_store.setup_store() self.json_store.record_population(self.population) self.json_store.record_to_file() self.json_store.store_file.close() # zip the store file self.json_store.finalize() # assert store_fp = self.config["recorder"]["store_file"] store_fp = list(os.path.splitext(store_fp)) # split ext store_fp[1] = ".zip" # change ext to zip store_fp = "".join(store_fp) file_exists = os.path.exists(store_fp) self.assertEquals(file_exists, True)
class SelectionTests(unittest.TestCase): def setUp(self): self.config = { "max_population" : 10, "tree_generation" : { "method" : "FULL_METHOD", "initial_max_depth" : 3 }, "selection" : { "method" : "ROULETTE_SELECTION" }, "function_nodes" : [ {"type": "FUNCTION", "name": "ADD", "arity": 2}, {"type": "FUNCTION", "name": "SUB", "arity": 2}, {"type": "FUNCTION", "name": "MUL", "arity": 2}, {"type": "FUNCTION", "name": "DIV", "arity": 2}, {"type": "FUNCTION", "name": "COS", "arity": 1}, {"type": "FUNCTION", "name": "SIN", "arity": 1}, {"type": "FUNCTION", "name": "RAD", "arity": 1} ], "terminal_nodes" : [ {"type": "CONSTANT", "value": 1.0}, {"type": "CONSTANT", "value": 2.0}, {"type": "CONSTANT", "value": 2.0}, {"type": "CONSTANT", "value": 3.0}, {"type": "CONSTANT", "value": 4.0}, {"type": "CONSTANT", "value": 5.0}, {"type": "CONSTANT", "value": 6.0}, {"type": "CONSTANT", "value": 7.0}, {"type": "CONSTANT", "value": 8.0}, {"type": "CONSTANT", "value": 9.0}, {"type": "CONSTANT", "value": 10.0} ], "input_variables" : [ {"type": "INPUT", "name": "x"} ] } self.functions = GPFunctionRegistry("SYMBOLIC_REGRESSION") self.generator = TreeGenerator(self.config) self.selection = Selection(self.config) self.population = self.generator.init() # give population random scores for inidividual in self.population.individuals: inidividual.score = random.triangular(1, 100) def print_population(self, phase, population): print "{0}[{1}]:".format(phase, len(population.individuals)) for individual in population.individuals: print individual, individual.score print '\n\n' return len(population.individuals) def test_normalize_scores(self): self.selection._normalize_scores(self.population) total_sum = 0 for individual in self.population.individuals: total_sum += individual.score self.assertEquals(round(total_sum, 2), 1.0) def test_roulette_selection(self): print "ROULETTE SELECTION" old_pop_size = len(self.population.individuals) self.selection.roulette_wheel_selection(self.population) new_pop_size = len(self.population.individuals) # assert # check for object uniqueness individual_ids = [] for i in self.population.individuals: self.assertFalse(id(i) in individual_ids) individual_ids.append(id(i)) self.assertEquals(new_pop_size, old_pop_size) def test_tournament_selection(self): print "TOURNAMENT SELECTION" # tournament selection old_pop_size = self.print_population("OLD", self.population) self.selection.tournament_selection(self.population) new_pop_size = self.print_population("NEW", self.population) # assert # check for object uniqueness individual_ids = [] for i in self.population.individuals: self.assertFalse(id(i) in individual_ids) individual_ids.append(id(i)) self.assertEqual(old_pop_size, new_pop_size) def test_elitest_selection(self): print "ELITEST SELECTION" # elitest selection old_pop_size = self.print_population("OLD", self.population) self.selection.elitest_selection(self.population) new_pop_size = self.print_population("NEW", self.population) self.assertEquals(old_pop_size, new_pop_size) def test_greedy_over_selection(self): print "GREEDY-OVER SELECTION" # create population of size 1000 self.config["max_population"] = 1000 generator = TreeGenerator(self.config) population = generator.init() # greedy over selection old_pop_size = self.print_population("OLD", population) self.selection.greedy_over_selection(population) new_pop_size = self.print_population("NEW", population) self.assertEquals(old_pop_size, new_pop_size) def test_select(self): old_pop_size = len(self.population.individuals) self.selection.select(self.population) new_pop_size = len(self.population.individuals) # assert # check for object uniqueness individual_ids = [] for i in self.population.individuals: self.assertFalse(id(i) in individual_ids) individual_ids.append(id(i)) self.assertEquals(old_pop_size, new_pop_size)
class JSONStoreTests(unittest.TestCase): def setUp(self): self.config = { "max_population" : 10, "tree_generation" : { "method" : "FULL_METHOD", "initial_max_depth" : 4 }, "evaluator" : { "use_cache": True }, "selection" : { "method" : "TOURNAMENT_SELECTION", "tournament_size": 2 }, "crossover" : { "method" : "POINT_CROSSOVER", "probability" : 0.6 }, "mutation" : { "methods": ["POINT_MUTATION"], "probability" : 0.8 }, "function_nodes" : [ {"type": "FUNCTION", "name": "ADD", "arity": 2}, {"type": "FUNCTION", "name": "SUB", "arity": 2} ], "terminal_nodes" : [ {"type": "CONSTANT", "value": 1.0}, ], "input_variables" : [ {"type": "INPUT", "name": "x"} ], "data_file" : "tests/data/sine.dat", "response_variables" : [{"name": "y"}], "recorder" : { "store_file": "json_store_test.json", "compress": True } } config.load_data(self.config) self.functions = GPFunctionRegistry("SYMBOLIC_REGRESSION") self.generator = TreeGenerator(self.config) self.json_store = JSONStore(self.config) self.json_store.setup_store() self.population = self.generator.init() results = [] cache = {} evaluate( self.population.individuals, self.functions, self.config, results, cache, self.json_store ) self.population.sort_individuals() self.selection = Selection(self.config, recorder=self.json_store) self.crossover = TreeCrossover(self.config, recorder=self.json_store) self.mutation = TreeMutation(self.config, recorder=self.json_store) def tearDown(self): self.json_store.delete_store() del self.config del self.functions del self.generator del self.population del self.json_store def test_setup_store(self): # assert file_exists = os.path.exists(self.config["recorder"]["store_file"]) self.assertEquals(file_exists, True) def test_purge_store(self): # write something to store file self.json_store.store_file.write("Hello World\n") self.json_store.store_file.close() # purge store file self.json_store.purge_store() # assert store_file = open(self.config["recorder"]["store_file"], "r").read() self.assertEquals(len(store_file), 0) def test_delete_store(self): # delete store self.json_store.delete_store() # assert file_exists = os.path.exists(self.config["recorder"]["store_file"]) self.assertEquals(file_exists, False) def test_record_population(self): self.json_store.record_population(self.population) record = self.json_store.generation_record self.assertNotEquals(record, {}) self.assertEquals(record["population"]["generation"], 0) def test_record_selection(self): # record selection self.selection.select(self.population) # assert record = self.json_store.generation_record # import pprint # pprint.pprint(record) self.assertNotEquals(record, {}) self.assertEquals(record["selection"]["selected"], 10) def test_record_crossover(self): # record crossover tree_1 = self.population.individuals[0] tree_2 = self.population.individuals[1] self.crossover.crossover(tree_1, tree_2) # assert record = self.json_store.generation_record self.assertNotEquals(record, {}) def test_record_mutation(self): # record mutation tree = self.population.individuals[0] self.mutation.mutate(tree) # assert record = self.json_store.generation_record # pprint.pprint(record) self.assertNotEquals(record, {}) def test_record_evaulation(self): # record evaluation results = [] evaluate( self.population.individuals, self.functions, self.config, results, recorder=self.json_store ) # assert record = self.json_store.generation_record # import pprint # pprint.pprint(record) self.assertEquals(record["evaluation"]["cache_size"], 10) self.assertEquals(record["evaluation"]["match_cached"], 0) def test_record_to_file(self): # write record to file and close self.json_store.record_population(self.population) self.json_store.record_to_file() self.json_store.store_file.close() # open up the file and restore json to dict store_file = open(self.config["recorder"]["store_file"], "r").read() data = json.loads(store_file) # assert tests self.assertNotEquals(data, {}) self.assertEquals(data["population"]["generation"], 0) def test_summarize_store(self): # write record to file and close self.json_store.setup_store() self.json_store.record_population(self.population) for i in range(5): tree_1 = self.population.individuals[0] tree_2 = self.population.individuals[1] self.crossover.crossover(tree_1, tree_2) for i in range(10): tree = self.population.individuals[0] self.mutation.mutate(tree) self.json_store.record_to_file() self.json_store.store_file.close() # summarize self.json_store.summarize_store() # assert store_file = open(self.config["recorder"]["store_file"], "r") line = json.loads(store_file.read()) store_file.close() self.assertIsNotNone(line) def test_finalize(self): # write record to file and close self.json_store.setup_store() self.json_store.record_population(self.population) self.json_store.record_to_file() self.json_store.store_file.close() # zip the store file self.json_store.finalize() # assert store_fp = self.config["recorder"]["store_file"] store_fp = list(os.path.splitext(store_fp)) # split ext store_fp[1] = ".zip" # change ext to zip store_fp = "".join(store_fp) file_exists = os.path.exists(store_fp) self.assertEquals(file_exists, True)
class PlayTests(unittest.TestCase): def setUp(self): random.seed(0) self.config = { "max_population": 20, "max_generation": 5, "tree_generation": { "method": "GROW_METHOD", "initial_max_depth": 4 }, "evaluator": { "use_cache": True }, "selection": { "method": "TOURNAMENT_SELECTION", "tournament_size": 2 }, "crossover": { "method": "POINT_CROSSOVER", "probability": 0.8 }, "mutation": { "methods": [ "POINT_MUTATION", "HOIST_MUTATION", "SUBTREE_MUTATION", "SHRINK_MUTATION", "EXPAND_MUTATION" ], "probability": 1.0 }, "function_nodes": [{ "type": "FUNCTION", "name": "ADD", "arity": 2 }, { "type": "FUNCTION", "name": "SUB", "arity": 2 }, { "type": "FUNCTION", "name": "MUL", "arity": 2 }, { "type": "FUNCTION", "name": "DIV", "arity": 2 }, { "type": "FUNCTION", "name": "COS", "arity": 1 }, { "type": "FUNCTION", "name": "SIN", "arity": 1 }, { "type": "FUNCTION", "name": "RAD", "arity": 1 }], "terminal_nodes": [{ "type": "CONSTANT", "value": 1.0 }, { "type": "CONSTANT", "value": 2.0 }, { "type": "CONSTANT", "value": 2.0 }, { "type": "CONSTANT", "value": 3.0 }, { "type": "CONSTANT", "value": 4.0 }, { "type": "CONSTANT", "value": 5.0 }, { "type": "CONSTANT", "value": 6.0 }, { "type": "CONSTANT", "value": 7.0 }, { "type": "CONSTANT", "value": 8.0 }, { "type": "CONSTANT", "value": 9.0 }, { "type": "CONSTANT", "value": 10.0 }], "input_variables": [{ "type": "INPUT", "name": "x" }], "data_file": "tests/data/sine.dat", "response_variables": [{ "name": "y" }] } config.load_data(self.config) self.functions = GPFunctionRegistry("SYMBOLIC_REGRESSION") self.generator = TreeGenerator(self.config) self.selection = Selection(self.config, recorder=None) self.crossover = TreeCrossover(self.config, recorder=None) self.mutation = TreeMutation(self.config, recorder=None) def tearDown(self): del self.config del self.generator del self.selection del self.crossover del self.mutation def test_reproduce(self): tests = 1 for i in range(tests): population = self.generator.init() res = [] evaluate(population.individuals, self.functions, self.config, res) population.individuals = res # print "POPULATION" # for i in population.individuals: # print i, i.score # print "\n" self.selection.select(population) # print "SELECTION" # for i in population.individuals: # print i, i.score # print "\n" # reproduce play_details = play.play_details(population=population, selection=self.selection, crossover=self.crossover, mutation=self.mutation, evaluate=None, config=self.config) play.play_ga_reproduce(play_details) # print "REPRODUCE" # for i in population.individuals: # print i, i.score # assert max_pop = self.config["max_population"] self.assertEquals(len(population.individuals), max_pop) self.assertTrue(population.config is self.config)
class PlayTests(unittest.TestCase): def setUp(self): random.seed(0) self.config = { "max_population" : 20, "max_generation" : 5, "tree_generation" : { "method" : "GROW_METHOD", "initial_max_depth" : 4 }, "evaluator": { "use_cache" : True }, "selection" : { "method" : "TOURNAMENT_SELECTION", "tournament_size": 2 }, "crossover" : { "method" : "POINT_CROSSOVER", "probability" : 0.8 }, "mutation" : { "methods": [ "POINT_MUTATION", "HOIST_MUTATION", "SUBTREE_MUTATION", "SHRINK_MUTATION", "EXPAND_MUTATION" ], "probability" : 1.0 }, "function_nodes" : [ {"type": "FUNCTION", "name": "ADD", "arity": 2}, {"type": "FUNCTION", "name": "SUB", "arity": 2}, {"type": "FUNCTION", "name": "MUL", "arity": 2}, {"type": "FUNCTION", "name": "DIV", "arity": 2}, {"type": "FUNCTION", "name": "COS", "arity": 1}, {"type": "FUNCTION", "name": "SIN", "arity": 1}, {"type": "FUNCTION", "name": "RAD", "arity": 1} ], "terminal_nodes" : [ {"type": "CONSTANT", "value": 1.0}, {"type": "CONSTANT", "value": 2.0}, {"type": "CONSTANT", "value": 2.0}, {"type": "CONSTANT", "value": 3.0}, {"type": "CONSTANT", "value": 4.0}, {"type": "CONSTANT", "value": 5.0}, {"type": "CONSTANT", "value": 6.0}, {"type": "CONSTANT", "value": 7.0}, {"type": "CONSTANT", "value": 8.0}, {"type": "CONSTANT", "value": 9.0}, {"type": "CONSTANT", "value": 10.0} ], "input_variables" : [ {"type": "INPUT", "name": "x"} ], "data_file" : "tests/data/sine.dat", "response_variables" : [{"name": "y"}] } config.load_data(self.config) self.functions = GPFunctionRegistry("SYMBOLIC_REGRESSION") self.generator = TreeGenerator(self.config) self.selection = Selection(self.config, recorder=None) self.crossover = TreeCrossover(self.config, recorder=None) self.mutation = TreeMutation(self.config, recorder=None) def tearDown(self): del self.config del self.generator del self.selection del self.crossover del self.mutation def test_reproduce(self): tests = 1 for i in range(tests): population = self.generator.init() res = [] evaluate(population.individuals, self.functions, self.config, res) population.individuals = res # print "POPULATION" # for i in population.individuals: # print i, i.score # print "\n" self.selection.select(population) # print "SELECTION" # for i in population.individuals: # print i, i.score # print "\n" # reproduce play_details = play.play_details( population=population, selection=self.selection, crossover=self.crossover, mutation=self.mutation, evaluate=None, config=self.config ) play.play_ga_reproduce(play_details) # print "REPRODUCE" # for i in population.individuals: # print i, i.score # assert max_pop = self.config["max_population"] self.assertEquals(len(population.individuals), max_pop) self.assertTrue(population.config is self.config)