def setUp(self):
self.config = config.load_config(config_fp)
self.functions = FunctionRegistry()
self.tree_generator = TreeGenerator(self.config)
self.json_store = JSONStore(self.config)
self.json_store.setup_store()
self.population = self.tree_generator.init()
results = []
evaluate(
self.population.individuals,
self.functions,
self.config,
results,
self.json_store
)
self.population.sort_individuals()
self.selection = Selection(self.config, recorder=self.json_store)
self.crossover = GPTreeCrossover(self.config, recorder=self.json_store)
self.mutation = GPTreeMutation(self.config, recorder=self.json_store)
from playground.gp.tree.mutation import TreeMutation
from playground.recorder.json_store import JSONStore
# SETTINGS
record_exception = False
script_path = os.path.dirname(os.path.realpath(sys.argv[0]))
# config_fp = os.path.join(script_path, "sine_config.json")
# config_fp = os.path.join(script_path, "simple_test_func_5-config.json")
config_fp = os.path.join(script_path, sys.argv[1])
if __name__ == "__main__":
try:
# setup
random.seed(10) # seed random so results can be reproduced
config = config.load_config(config_fp, script_path)
json_store = JSONStore(config)
functions = {
"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)
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 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 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 = config.load_config(config_fp)
self.functions = FunctionRegistry()
self.tree_generator = TreeGenerator(self.config)
self.json_store = JSONStore(self.config)
self.json_store.setup_store()
self.population = self.tree_generator.init()
results = []
evaluate(
self.population.individuals,
self.functions,
self.config,
results,
self.json_store
)
self.population.sort_individuals()
self.selection = Selection(self.config, recorder=self.json_store)
self.crossover = GPTreeCrossover(self.config, recorder=self.json_store)
self.mutation = GPTreeMutation(self.config, recorder=self.json_store)
def tearDown(self):
self.json_store.delete_store()
del self.config
del self.functions
del self.tree_generator
del self.population
del self.json_store
def test_setup_store(self):
# assert
file_exists = os.path.exists(self.config["json_store"]["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["json_store"]["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["json_store"]["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
# pprint.pprint(record)
self.assertNotEquals(record, {})
self.assertEquals(record["selection"]["selected"], 5)
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
# pprint.pprint(record)
self.assertNotEquals(record, {})
self.assertEquals(record["crossover"][0]["crossovered"], True)
self.assertEquals(record["crossover"][0]["index"], 1)
self.assertEquals(record["crossover"][0]["method"], "POINT_CROSSOVER")
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, {})
self.assertEquals(record["mutation"][0]["method"], "SHRINK_MUTATION")
self.assertEquals(record["mutation"][0]["mutation_probability"], 0.8)
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
pprint.pprint(record)
self.assertEquals(record["evaluation"][0]["cache_size"], 10)
self.assertEquals(record["evaluation"][0]["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["json_store"]["store_file"], "r").read()
data = json.loads(store_file)
# assert tests
self.assertNotEquals(data, {})
self.assertEquals(data["population"]["generation"], 0)
