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 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)
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)
"name": "sepal_width"
}, {
"name": "petal_length"
}, {
"name": "petal_width"
}],
"response_variables": [{
"name": "species"
}]
}
load_data(config, script_path)
functions = GPFunctionRegistry("CLASSIFICATION")
generator = TreeGenerator(config)
# genetic operators
selection = Selection(config)
crossover = TreeCrossover(config)
mutation = TreeMutation(config)
# run symbolic regression
population = generator.init()
start_time = time.time()
details = play.play_details(
population=population,
evaluate=evaluate,
functions=functions,
selection=selection,
crossover=crossover,
mutation=mutation,
print_func=print_func,
"ADD": "+",
"SUB": "-",
"MUL": "*",
"DIV": "/",
"POW": "**",
"SIN": "math.sin",
"COS": "math.cos",
"RAD": "math.radians",
"LN": "math.ln",
"EXP": "math.exp",
"LOG": "math.log"
}
generator = TreeGenerator(config)
# genetic operators
selection = Selection(config, recorder=json_store)
crossover = TreeCrossover(config, recorder=json_store)
mutation = TreeMutation(config, recorder=json_store)
# run symbolic regression
population = generator.init()
start_time = time.time()
details = play.play_details(population=population,
evaluate=evaluate,
functions=functions,
selection=selection,
crossover=crossover,
mutation=mutation,
print_func=print_func,
plot_func=plot_func,
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)
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)
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)
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)
def gp_benchmark_loop(config):
try:
# setup
random.seed(config["random_seed"]) # VERY IMPORTANT!
load_data(config, config["call_path"])
json_store = JSONStore(config)
# functions = GPFunctionRegistry("SYMBOLIC_REGRESSION")
generator = TreeGenerator(config)
# genetic operators
selection = Selection(config, recorder=json_store)
crossover = TreeCrossover(config, recorder=json_store)
mutation = TreeMutation(config, recorder=json_store)
# setup the initial random population
population = generator.init()
# create play details
details = play.play_details(
population=population,
functions=config["functions"],
evaluate=evaluate,
selection=selection,
crossover=crossover,
mutation=mutation,
editor=edit_trees,
stop_func=default_stop_func,
# print_func=print_func,
config=config,
recorder=json_store)
# run symbolic regression
start_time = time.time()
play.play(details)
end_time = time.time()
time_taken = end_time - start_time
# print msg
print("DONE -> pop: {0} cross: {1} mut: {2} seed: {3} [{4}s]".format(
config["max_population"], config["crossover"]["probability"],
config["mutation"]["probability"], config["random_seed"],
round(time_taken, 2)))
# log on completion
if config.get("log_path", False):
config.pop("data")
msg = {
"timestamp": time.mktime(datetime.now().timetuple()),
"status": "DONE",
"config": config,
"runtime": time_taken,
"best_score": population.find_best_individuals()[0].score,
"best": str(population.find_best_individuals()[0])
}
log_path = os.path.expandvars(config["log_path"])
log_file = open(log_path, "a+")
log_file.write(json.dumps(msg) + "\n")
log_file.close()
except Exception as err_msg:
import traceback
traceback.print_exc()
# log exception
if config.get("log_path", False):
msg = {
"timestamp": time.mktime(datetime.now().timetuple()),
"status": "ERROR",
"config": config,
"error": err_msg
}
log_path = os.path.expandvars(config["log_path"])
log_file = open(log_path, "a+")
log_file.write(json.dumps(msg) + "\n")
log_file.close()
raise # raise the exception
return config
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)
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)
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)
def gp_predict(train_data, test_data, train_cat, xx, yy):
# setup
config = {
"max_population":
800,
"max_generation":
30,
"stale_limit":
10,
"tree_generation": {
"tree_type": "CLASSIFICATION_TREE",
"method": "RAMPED_HALF_AND_HALF_METHOD",
"depth_ranges": [{
"size": 1,
"percentage": 1.0
}]
},
"evaluator": {
"use_cache": True
},
"selection": {
"method": "TOURNAMENT_SELECTION",
"tournament_size": 100
},
"crossover": {
"method": "POINT_CROSSOVER",
"probability": 0.8
},
"mutation": {
"methods": ["SUBTREE_MUTATION"],
"probability": 0.8
},
"function_nodes": [{
"type": "CLASS_FUNCTION",
"name": "GREATER_THAN",
"arity": 2,
"data_range": {
"lower_bound": -1.0,
"upper_bound": 1.0,
"decimal_places": 2,
}
}, {
"type": "CLASS_FUNCTION",
"name": "LESS_THAN",
"arity": 2,
"data_range": {
"lower_bound": -1.0,
"upper_bound": 1.0,
"decimal_places": 2,
}
}, {
"type": "CLASS_FUNCTION",
"name": "EQUALS",
"arity": 2,
"data_range": {
"lower_bound": -1.0,
"upper_bound": 1.0,
"decimal_places": 2
}
}],
"terminal_nodes": [
{
"type": "RANDOM_CONSTANT",
"name": "category",
"range": [0.0, 1.0]
},
],
"class_attributes": ["x", "y"],
"input_variables": [{
"name": "x"
}, {
"name": "y"
}],
"response_variables": [{
"name": "category"
}]
}
# load data
config["data"] = {}
config["data"]["rows"] = len(train_data)
config["data"]["x"] = []
config["data"]["y"] = []
config["data"]["category"] = train_cat
for row in train_data:
config["data"]["x"].append(row[0])
config["data"]["y"].append(row[1])
functions = GPFunctionRegistry("CLASSIFICATION")
generator = TreeGenerator(config)
# genetic operators
selection = Selection(config)
crossover = TreeCrossover(config)
mutation = TreeMutation(config)
# run symbolic regression
population = generator.init()
details = play.play_details(
population=population,
evaluate=evaluate,
functions=functions,
selection=selection,
crossover=crossover,
mutation=mutation,
print_func=print_func,
stop_func=default_stop_func,
config=config,
editor=edit_trees,
)
play.play(details)
best_tree = population.best_individuals[0]
# gp_plot_dt(best_tree, True)
# load test data
config["data"] = {}
config["data"]["rows"] = len(test_data)
config["data"]["x"] = []
config["data"]["y"] = []
for row in test_data:
config["data"]["x"].append(row[0])
config["data"]["y"].append(row[1])
# predict
predicted = gp_eval.predict_tree(best_tree, functions, config)
# load test data
config["data"] = {}
config["data"]["rows"] = xx.shape[0] * xx.shape[1]
config["data"]["x"] = np.reshape(xx, xx.shape[0] * xx.shape[1])
config["data"]["y"] = np.reshape(yy, yy.shape[0] * yy.shape[1])
contour = gp_eval.predict_tree(best_tree, functions, config)
contour = np.array(contour)
contour = contour.reshape(xx.shape)
return predicted, contour
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)
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)