add gene type RNN

examples/config_test.py

@@ -1,4 +0,0 @@
-from algorithm.config import Configer
-
-config = Configer.load_config()
-print(config)

examples/rnn_forward_test.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+
+vals = np.array([1, 2])
+weights = np.array([[0, 4], [5, 0]])
+
+ins1 = vals * weights[:, 0]
+ins2 = vals * weights[:, 1]
+ins_all = vals * weights.T
+
+print(ins1)
+print(ins2)
+print(ins_all)

examples/xor.ini

@@ -1,5 +1,7 @@
 [basic]
 forward_way = "common"
+network_type = "recurrent"
+activate_times = 5
 
 [population]
 fitness_threshold = 4

examples/xor.py

@@ -2,7 +2,7 @@ import jax
 import numpy as np
 
 from algorithm import Configer, NEAT
-from algorithm.neat import NormalGene, Pipeline
+from algorithm.neat import NormalGene, RecurrentGene, Pipeline
 
 xor_inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=np.float32)
 xor_outputs = np.array([[0], [1], [1], [0]], dtype=np.float32)
@@ -15,16 +15,17 @@ def evaluate(forward_func):
     """
     outs = forward_func(xor_inputs)
     outs = jax.device_get(outs)
-    # print(outs)
     fitnesses = 4 - np.sum((outs - xor_outputs) ** 2, axis=(1, 2))
     return fitnesses
 
 
 def main():
     config = Configer.load_config("xor.ini")
-    algorithm = NEAT(config, NormalGene)
+    # algorithm = NEAT(config, NormalGene)
+    algorithm = NEAT(config, RecurrentGene)
     pipeline = Pipeline(config, algorithm)
-    pipeline.auto_run(evaluate)
+    best = pipeline.auto_run(evaluate)
+    print(best)
 
 
 if __name__ == '__main__':

examples/xor_test.py

@@ -2,31 +2,49 @@ import jax
 import numpy as np
 
 from algorithm.config import Configer
-from algorithm.neat import NEAT, NormalGene, Pipeline
+from algorithm.neat import NEAT, NormalGene, RecurrentGene, Pipeline
 from algorithm.neat.genome import create_mutate
 
 xor_inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=np.float32)
 
+
 def single_genome(func, nodes, conns):
-    t = NormalGene.forward_transform(nodes, conns)
+    t = RecurrentGene.forward_transform(nodes, conns)
     out1 = func(xor_inputs[0], t)
     out2 = func(xor_inputs[1], t)
     out3 = func(xor_inputs[2], t)
     out4 = func(xor_inputs[3], t)
     print(out1, out2, out3, out4)
 
+
+def batch_genome(func, nodes, conns):
+    t = NormalGene.forward_transform(nodes, conns)
+    out = jax.vmap(func, in_axes=(0, None))(xor_inputs, t)
+    print(out)
+
+
+def pop_batch_genome(func, pop_nodes, pop_conns):
+    t = jax.vmap(NormalGene.forward_transform)(pop_nodes, pop_conns)
+    func = jax.vmap(jax.vmap(func, in_axes=(0, None)), in_axes=(None, 0))
+    out = func(xor_inputs, t)
+    print(out)
+
+
 if __name__ == '__main__':
-    config = Configer.load_config()
-    neat = NEAT(config, NormalGene)
+    config = Configer.load_config("xor.ini")
+    # neat = NEAT(config, NormalGene)
+    neat = NEAT(config, RecurrentGene)
     randkey = jax.random.PRNGKey(42)
     state = neat.setup(randkey)
-    forward_func = NormalGene.create_forward(config)
-    mutate_func =  create_mutate(config, NormalGene)
-
+    forward_func = RecurrentGene.create_forward(config)
+    mutate_func = create_mutate(config, RecurrentGene)
 
     nodes, conns = state.pop_nodes[0], state.pop_conns[0]
     single_genome(forward_func, nodes, conns)
+    # batch_genome(forward_func, nodes, conns)
+
     nodes, conns = mutate_func(state, randkey, nodes, conns, 10000)
     single_genome(forward_func, nodes, conns)
 
-
+    # batch_genome(forward_func, nodes, conns)
+    #