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)