def test_forward_new():
reg = Registry(2, 2)
# 3 hidden nodes
for _ in range(3):
reg.create_node()
nodes = reg.nodes
connections = [
reg.get_connection(n1, n2)
for n1, n2 in [(nodes[0], nodes[5]), (
nodes[5], nodes[6]), (nodes[6], nodes[3]), (
nodes[1],
nodes[7]), (nodes[7],
nodes[5]), (nodes[6],
nodes[7]), (nodes[7], nodes[4])]
]
# connections = [Connection(nodes[0], nodes[5]), Connection(nodes[5], nodes[6]), Connection(nodes[6], nodes[3]),
# Connection(nodes[1], nodes[7]), Connection(nodes[7], nodes[5]), Connection(nodes[6], nodes[7]),
# Connection(nodes[7], nodes[4])]
g1 = Genom(reg, connections)
for c in g1.connections:
c.weight = 1
print('recurrent network, output should be different')
out = g1.forward_rec(np.array([1, 0]))
print(out)
out = g1.forward_rec(np.array([1, 0]))
print(out)
def __init__(self, initial_value={}, refresh_callback=None, server_uri=None):
if server_uri:
self.server_uri = server_uri
else:
self.server_uri = SERVER_URI
self.__registry = Registry(initial_value)
self.__refresh_callback = refresh_callback
self.socket = ServerSocket(self.server_uri)
self._start_msg_thread()
class Persister(object):
def __init__(self, load_files=[], output_file=None):
self.__registry = Registry()
self.load_files = load_files
self.output_file = output_file
for file in self.load_files:
self.load_file(file)
def load_file(self, file_path):
try:
f = open(file_path)
json_content = f.read()
f.close()
data = json.loads(json_content)
self.__registry.merge(data)
except Exception, err:
# print err
pass
def test_add_category(self):
r = Registry()
r.clear()
cat_name = 'category_1'
r.add(cat_name)
self.assertEqual(cat_name, r.categories[cat_name].name)
print(r)
def __init__(self, input_size: int, output_size: int, population_size: int, fitness_fn, max_hidden: int = None):
self.registry = Registry(input_size, output_size, max_hidden)
self.fitness_fn = fitness_fn
self.population_size = population_size
self.population = []
self.scores = []
self.best_all = 0
self.species = []
self.new_size = []
self.generation = 0
for _ in range(self.population_size):
self.population.append(Genom(self.registry))
def test_forward():
x = np.random.random(25)
reg = Registry(25, 5)
g1 = Genom(reg)
for _ in range(1):
g1.mutate_link()
g1.mutate_add_node()
g1.mutate_weight_shift()
g1.mutate_enable_disable_connection()
out = None
for _ in range(10):
out = g1.forward(x, )
out = g1.forward_rec(x, )
print(out)
def test_genom():
reg = Registry(25, 5)
g1 = Genom(reg)
g2 = Genom(reg)
g1.mutate_link()
g2.mutate_add_node()
g1.mutate_weight_shift()
g2.mutate_enable_disable_connection()
g1.fitness = 0
g2.fitness = 1
delta = distance(g1, g2)
g3 = crossover_genes(g1, g2)
class RegistryServer(object, IRegistryServer):
def __init__(self, initial_value={}, refresh_callback=None, server_uri=None):
if server_uri:
self.server_uri = server_uri
else:
self.server_uri = SERVER_URI
self.__registry = Registry(initial_value)
self.__refresh_callback = refresh_callback
self.socket = ServerSocket(self.server_uri)
self._start_msg_thread()
def _start_msg_thread(self):
self.msg_thread = MsgThread(self, self.socket)
self.msg_thread.daemon = True
self.msg_thread.start()
def _stop_msg_thread(self):
self.msg_thread.exit()
def get(self, key):
return self.__registry.get(key)
def set(self, key, value):
resp = self.__registry.set(key, value)
self.call_callback()
return resp
def remove(self, key):
resp = self.__registry.remove(key)
self.call_callback()
return resp
def commit(self, values):
self.__registry.set_values(values)
self.call_callback()
def get_values(self):
return self.__registry.get_values()
def get_version(self):
return self.__registry.get_version()
def call_callback(self):
if self.__refresh_callback:
self.__refresh_callback(self)
def test_add_class(self):
class myclass():
def __call__(self):
pass
class myclass2():
def __call__(self):
pass
r = Registry()
r.clear()
cat_name = 'category_1'
r.add(cat_name, myclass)
self.assertEqual(cat_name, r.categories[cat_name].name)
r.add(cat_name, myclass2)
self.assertEqual(len(r.categories), 1)
self.assertEqual(len(r.categories[cat_name].class_dict), 2)
self.assertIn(myclass.__name__, r.categories[cat_name].class_dict.keys())
self.assertIn(myclass2.__name__, r.categories[cat_name].class_dict.keys())
def test_build_from_config(self):
class myclass():
def __init__(self, a, b):
self.a = a
self.b = b
def __call__(self):
pass
r = Registry()
r.clear()
cat_name = 'category_1'
r.add(cat_name, myclass)
config = {
'name': 'myclass',
'params': {'a': 1, 'b':'string'}
}
myobj = r.build_from_config(cat_name, config)
self.assertEqual(myobj.a, 1)
self.assertEqual(myobj.b, config['params']['b'])
print(r)
def setUp(self):
self.r = Registry({"key0": "value0", "key_nasted0": {"key1": "value1"}})
class TestRegistry:
def setUp(self):
self.r = Registry({"key0": "value0", "key_nasted0": {"key1": "value1"}})
def test_get(self):
value = self.r.get("key0")
eq_(value, "value0")
value = self.r.get("key_nasted0")
eq_(value, {"key1": "value1"})
# must get copy of value
value["key1"] = "other value"
value = self.r.get("key_nasted0")
eq_(value, {"key1": "value1"})
def test_get_nasted(self):
value = self.r.get("key_nasted0.key1")
eq_(value, "value1")
def test_key_is_nasted(self):
assert self.r.is_nasted("a.b")
assert not self.r.is_nasted("a")
assert not self.r.is_nasted(None)
def test_extract_key(self):
assert self.r.extract_key("a.b") == ["a", "b"]
assert self.r.extract_key("a") == ["a"]
assert self.r.extract_key(None) == []
def test_set(self):
self.r.set("key", "setted")
value = self.r.get("key")
eq_(value, "setted")
def test_set_nasted(self):
self.r.set("a.b", "c")
value = self.r.get("a.b")
eq_(value, "c")
self.r.set("x.y", "z")
value = self.r.get("x.y")
eq_(value, "z")
def test_remove(self):
self.r.set("a", "b")
self.r.remove("a")
value = self.r.get("a")
assert not value
self.r.set("a.a", "c")
self.r.set("a.b", "d")
self.r.remove("a.b")
assert not self.r.get("a.b")
assert self.r.get("a.a") == "c"
def test_get_values(self):
(version, values) = self.r.get_values()
assert values["key0"] == "value0"
def test_set_values(self):
self.r.set_values({"a": "b"})
(version, values) = self.r.get_values()
assert values == {"a": "b"}
def test_set_values_with_version(self):
self.r.set_values({"a": "b"}, 1)
(version, values) = self.r.get_values()
assert version == 1
def test_get_version(self):
assert self.r.get_version()
def test_update_version_when_set(self):
old_version = self.r.get_version()
self.r.set("a", "b")
new_version = self.r.get_version()
assert old_version != new_version
def test_version_not_update_when_nothing_change(self):
self.r.set("a", "b")
old_version = self.r.get_version()
self.r.set("a", "b")
new_version = self.r.get_version()
assert old_version == new_version
self.r.set("x.y", "z")
old_version = self.r.get_version()
self.r.set("x.y", "z")
new_version = self.r.get_version()
assert old_version == new_version
def test_update_version_when_set_values(self):
old_version = self.r.get_version()
self.r.set_values({"a": "b"})
new_version = self.r.get_version()
assert old_version != new_version
def test_update_version_when_remove(self):
self.r.set("a", "b")
old_version = self.r.get_version()
self.r.remove("a")
new_version = self.r.get_version()
assert old_version != new_version
def test_merge(self):
self.r.set("a", {"k0": "v0", "k3": "v3"})
b = {"a": {"k1": "v1", "k3": "v33"}, "c": "d"}
self.r.merge(b)
assert self.r.get("a.k0") == "v0"
assert self.r.get("a.k1") == "v1"
assert self.r.get("a.k3") == "v33"
assert self.r.get("c") == "d"
def test_ignode_when_key_not_found(self):
self.r.remove("notexist")
def test_singleton(self):
r1 = Registry()
r2 = Registry()
self.assertEqual(r1, r2)
def __init__(self, load_files=[], output_file=None):
self.__registry = Registry()
self.load_files = load_files
self.output_file = output_file
for file in self.load_files:
self.load_file(file)
