class TreeGeneratorTests(unittest.TestCase): def setUp(self): self.config = { "max_population": 10, "tree_generation": { "tree_type": "SYMBOLIC_REGRESSION", "method": "RAMPED_HALF_AND_HALF_METHOD", "initial_max_depth": 3 }, "function_nodes": [{ "type": "FUNCTION", "arity": 2, "name": "ADD" }, { "type": "FUNCTION", "arity": 2, "name": "SUB" }, { "type": "FUNCTION", "arity": 2, "name": "MUL" }, { "type": "FUNCTION", "arity": 2, "name": "DIV" }, { "type": "FUNCTION", "arity": 1, "name": "COS" }, { "type": "FUNCTION", "arity": 1, "name": "SIN" }], "terminal_nodes": [{ "type": "CONSTANT", "value": 1.0 }, { "type": "INPUT", "name": "x" }, { "type": "INPUT", "name": "y" }, { "type": "RANDOM_CONSTANT", "data_range": { "upper_bound": 10.0, "lower_bound": -10.0, "decimal_places": 1 } }], "input_variables": [{ "name": "x" }, { "name": "y" }] } self.functions = GPFunctionRegistry("SYMBOLIC_REGRESSION") self.generator = TreeGenerator(self.config) self.parser = TreeParser() def tearDown(self): del self.config del self.generator del self.parser def test_generate_func_node(self): # SYMBOLIC REGRESSION TREES for i in range(100): node = self.generator.generate_func_node() self.assertEquals(node.node_type, NodeType.FUNCTION) # CLASSIFICATION TREES self.config["tree_generation"]["tree_type"] = "CLASSIFICATION_TREE" self.config["function_nodes"] = [{ "type": "CLASS_FUNCTION", "name": "GREATER_THAN", "arity": 2, "data_range": { "lower_bound": 0.0, "upper_bound": 10.0, "decimal_places": 1 } }] self.config["class_attributes"] = [ "attrubte_1", "attrubte_2", "attrubte_3" ] generator = TreeGenerator(self.config) for i in range(100): node = generator.generate_func_node() class_attribute = node.class_attribute self.assertEquals(node.node_type, NodeType.CLASS_FUNCTION) self.assertTrue(class_attribute in self.config["class_attributes"]) def test_resolve_random_constant(self): upper_bound = 10.0 lower_bound = -10.0 decimal_places = 0 for i in range(100): n_details = { "type": "RANDOM_CONSTANT", "data_range": { "lower_bound": lower_bound, "upper_bound": upper_bound, "decimal_places": decimal_places } } new_n_details = self.generator.resolve_random_constant(n_details) node_type = new_n_details["type"] node_value = new_n_details["value"] self.assertEquals(node_type, "CONSTANT") self.assertTrue(upper_bound >= node_value) self.assertTrue(lower_bound <= node_value) self.assertEquals(node_value, int(node_value)) upper_bound = 100.0 lower_bound = -100.0 decimal_places = 1 for i in range(100): n_details = { "type": "RANDOM_CONSTANT", "data_range": { "lower_bound": lower_bound, "upper_bound": upper_bound, "decimal_places": decimal_places } } new_n_details = self.generator.resolve_random_constant(n_details) node_type = new_n_details["type"] node_value = new_n_details["value"] self.assertEquals(node_type, "CONSTANT") self.assertTrue(upper_bound >= node_value) self.assertTrue(lower_bound <= node_value) node_value = decimal.Decimal(str(node_value)) node_decimal_places = abs(node_value.as_tuple().exponent) self.assertEquals(decimal_places, node_decimal_places) def test_generate_term_node(self): for i in range(100): node = self.generator.generate_term_node() self.assertTrue(node.node_type == NodeType.CONSTANT or NodeType.INPUT) def test_full_method(self): tests = 1 for i in xrange(tests): tree = self.generator.full_method() # asserts init_max = self.config["tree_generation"]["initial_max_depth"] self.assertEquals(tree.depth, init_max) self.assertTrue(tree.size > init_max) def test_grow_method(self): tests = 1000 for i in xrange(tests): tree = self.generator.grow_method() # asserts init_max = self.config["tree_generation"]["initial_max_depth"] self.assertEquals(tree.depth, init_max) self.assertTrue(tree.size > init_max) def test_generate_tree_from_dict(self): population = self.generator.init() tree = population.individuals[0] tree_dict = self.parser.tree_to_dict(tree, tree.root) tree_generated = self.generator.generate_tree_from_dict(tree_dict) program_str = "" for i in tree.program: if i.name is not None: program_str += i.name else: program_str += str(i.value) generated_str = "" for i in tree_generated.program: if i.name is not None: generated_str += i.name else: generated_str += str(i.value) self.assertEquals(program_str, generated_str) def test_init(self): population = self.generator.init() self.assertEquals(len(population.individuals), 10)
def test_evaluate(self): random.seed(10) # solution = { # "results": # [ # {"score": 15726642.002161335}, # {"score": 359.25843589015597}, # {"score": 92155571.22132382}, # {"score": 26186.46142920347}, # {"score": 15649304.847552022}, # {"score": 188.86069156360125}, # {"score": 23439.33097274221}, # ] # } # setup config = { "max_population" : 10, "max_generation" : 5, "tree_generation" : { "method" : "GROW_METHOD", "initial_max_depth" : 3 }, "evaluator": { "use_cache" : True }, "selection" : { "method" : "TOURNAMENT_SELECTION", "tournament_size": 5 }, "crossover" : { "method" : "POINT_CROSSOVER", "probability" : 0.8 }, "mutation" : { "methods": [ "POINT_MUTATION", "HOIST_MUTATION", "SUBTREE_MUTATION", "SHRINK_MUTATION", "EXPAND_MUTATION" ], "probability" : 0.9 }, "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} ], "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} ], "data_file" : "tests/data/sine.dat", "input_variables" : [{"type": "INPUT", "name": "x"}], "response_variables" : [{"name": "y"}] } parser = TreeParser() population = TreeGenerator(config).init() # create a dictionary of trees data = {"config": config, "individuals": []} for individual in population.individuals: tree_json = parser.tree_to_dict(individual, individual.root) data["individuals"].append(tree_json) # make sure population size is equals to number of trees population_size = len(population.individuals) individuals = len(data["individuals"]) self.assertEquals(population_size, individuals) # evaluating individuals data = json.dumps(data) host = "localhost" port = 8080 req_type = "POST" path = "evaluate" response = self.transmit(host, port, req_type, path, data) response = json.loads(response) print response
class TreeGeneratorTests(unittest.TestCase): def setUp(self): self.config = { "max_population": 10, "tree_generation": { "tree_type": "SYMBOLIC_REGRESSION", "method": "RAMPED_HALF_AND_HALF_METHOD", "initial_max_depth": 3 }, "function_nodes": [ {"type": "FUNCTION", "arity": 2, "name": "ADD"}, {"type": "FUNCTION", "arity": 2, "name": "SUB"}, {"type": "FUNCTION", "arity": 2, "name": "MUL"}, {"type": "FUNCTION", "arity": 2, "name": "DIV"}, {"type": "FUNCTION", "arity": 1, "name": "COS"}, {"type": "FUNCTION", "arity": 1, "name": "SIN"} ], "terminal_nodes": [ {"type": "CONSTANT", "value": 1.0}, {"type": "INPUT", "name": "x"}, {"type": "INPUT", "name": "y"}, { "type": "RANDOM_CONSTANT", "data_range": { "upper_bound": 10.0, "lower_bound": -10.0, "decimal_places": 1 } } ], "input_variables": [ {"name": "x"}, {"name": "y"} ] } self.functions = GPFunctionRegistry("SYMBOLIC_REGRESSION") self.generator = TreeGenerator(self.config) self.parser = TreeParser() def tearDown(self): del self.config del self.generator del self.parser def test_generate_func_node(self): # SYMBOLIC REGRESSION TREES for i in range(100): node = self.generator.generate_func_node() self.assertEquals(node.node_type, NodeType.FUNCTION) # CLASSIFICATION TREES self.config["tree_generation"]["tree_type"] = "CLASSIFICATION_TREE" self.config["function_nodes"] = [ { "type": "CLASS_FUNCTION", "name": "GREATER_THAN", "arity": 2, "data_range": { "lower_bound": 0.0, "upper_bound": 10.0, "decimal_places": 1 } } ] self.config["class_attributes"] = [ "attrubte_1", "attrubte_2", "attrubte_3" ] generator = TreeGenerator(self.config) for i in range(100): node = generator.generate_func_node() class_attribute = node.class_attribute self.assertEquals(node.node_type, NodeType.CLASS_FUNCTION) self.assertTrue(class_attribute in self.config["class_attributes"]) def test_resolve_random_constant(self): upper_bound = 10.0 lower_bound = -10.0 decimal_places = 0 for i in range(100): n_details = { "type": "RANDOM_CONSTANT", "data_range": { "lower_bound": lower_bound, "upper_bound": upper_bound, "decimal_places": decimal_places } } new_n_details = self.generator.resolve_random_constant(n_details) node_type = new_n_details["type"] node_value = new_n_details["value"] self.assertEquals(node_type, "CONSTANT") self.assertTrue(upper_bound >= node_value) self.assertTrue(lower_bound <= node_value) self.assertEquals(node_value, int(node_value)) upper_bound = 100.0 lower_bound = -100.0 decimal_places = 1 for i in range(100): n_details = { "type": "RANDOM_CONSTANT", "data_range": { "lower_bound": lower_bound, "upper_bound": upper_bound, "decimal_places": decimal_places } } new_n_details = self.generator.resolve_random_constant(n_details) node_type = new_n_details["type"] node_value = new_n_details["value"] self.assertEquals(node_type, "CONSTANT") self.assertTrue(upper_bound >= node_value) self.assertTrue(lower_bound <= node_value) node_value = decimal.Decimal(str(node_value)) node_decimal_places = abs(node_value.as_tuple().exponent) self.assertEquals(decimal_places, node_decimal_places) def test_generate_term_node(self): for i in range(100): node = self.generator.generate_term_node() self.assertTrue( node.node_type == NodeType.CONSTANT or NodeType.INPUT ) def test_full_method(self): tests = 1 for i in xrange(tests): tree = self.generator.full_method() # asserts init_max = self.config["tree_generation"]["initial_max_depth"] self.assertEquals(tree.depth, init_max) self.assertTrue(tree.size > init_max) def test_grow_method(self): tests = 1000 for i in xrange(tests): tree = self.generator.grow_method() # asserts init_max = self.config["tree_generation"]["initial_max_depth"] self.assertEquals(tree.depth, init_max) self.assertTrue(tree.size > init_max) def test_generate_tree_from_dict(self): population = self.generator.init() tree = population.individuals[0] tree_dict = self.parser.tree_to_dict(tree, tree.root) tree_generated = self.generator.generate_tree_from_dict(tree_dict) program_str = "" for i in tree.program: if i.name is not None: program_str += i.name else: program_str += str(i.value) generated_str = "" for i in tree_generated.program: if i.name is not None: generated_str += i.name else: generated_str += str(i.value) self.assertEquals(program_str, generated_str) def test_init(self): population = self.generator.init() self.assertEquals(len(population.individuals), 10)
class TreeParserTests(unittest.TestCase): def setUp(self): random.seed(10) self.config = { "max_population": 10, "tree_generation": { "method": "FULL_METHOD", "initial_max_depth": 4 }, "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} ], "terminal_nodes": [ {"type": "CONSTANT", "value": 1.0}, {"type": "INPUT", "name": "x"}, {"type": "INPUT", "name": "y"}, {"type": "INPUT", "name": "z"} ], "input_variables": [ {"name": "x"}, {"name": "y"}, {"name": "z"} ] } self.functions = GPFunctionRegistry("SYMBOLIC_REGRESSION") self.generator = TreeGenerator(self.config) self.parser = TreeParser() # create nodes left_node = Node(NodeType.CONSTANT, value=1.0) right_node = Node(NodeType.CONSTANT, value=2.0) cos_func = Node( NodeType.FUNCTION, name="COS", arity=1, branches=[left_node] ) sin_func = Node( NodeType.FUNCTION, name="SIN", arity=1, branches=[right_node] ) add_func = Node( NodeType.FUNCTION, name="ADD", arity=2, branches=[cos_func, sin_func] ) # create tree self.tree = Tree() self.tree.root = add_func self.tree.update_program() self.tree.update_func_nodes() self.tree.update_term_nodes() def tearDown(self): del self.config del self.generator del self.parser def test_parse_tree(self): # self.parser.print_tree(tree.root) program = self.parser.parse_tree(self.tree, self.tree.root) for i in program: if i.name is not None: print i.name else: print i.value self.assertEquals(self.tree.size, 5) self.assertEquals(self.tree.depth, 2) self.assertEquals(len(self.tree.func_nodes), 2) self.assertEquals(len(self.tree.term_nodes), 2) self.assertEquals(len(self.tree.input_nodes), 0) def test_parse_equation(self): # self.parser.print_tree(tree.root) equation = self.parser.parse_equation(self.tree.root) self.assertEquals(equation, "((COS(1.0)) ADD (SIN(2.0)))") def test_tree_to_dict(self): solution = { 'program': [ {'type': 'CONSTANT', 'value': 1.0}, {'arity': 1, 'type': 'FUNCTION', 'name': 'COS'}, {'type': 'CONSTANT', 'value': 2.0}, {'arity': 1, 'type': 'FUNCTION', 'name': 'SIN'}, {'arity': 2, 'type': 'FUNCTION', 'root': True, 'name': 'ADD'} ] } results = self.parser.tree_to_dict(self.tree, self.tree.root) self.assertEquals(results["program"], solution["program"])