def test_hidden():
net = RecurrentNet(
n_inputs=1,
n_hidden=1,
n_outputs=1,
input_to_hidden=([(0, 0)], [1.0]),
hidden_to_hidden=([], []),
output_to_hidden=([], []),
input_to_output=([], []),
hidden_to_output=([(0, 0)], [1.0]),
output_to_output=([], []),
hidden_responses=[1.0],
output_responses=[1.0],
hidden_biases=[0],
output_biases=[0],
use_current_activs=True,
)
result = net.activate([[0.2]])
assert result.shape == (1, 1)
assert_almost_equal(net.activs[0, 0], 0.731, 0.001)
assert_almost_equal(net.outputs[0, 0], 0.975, 0.001)
assert result[0, 0] == net.outputs[0, 0]
result = net.activate([[0.4]])
assert result.shape == (1, 1)
assert_almost_equal(net.activs[0, 0], 0.881, 0.001)
assert_almost_equal(net.outputs[0, 0], 0.988, 0.001)
assert result[0, 0] == net.outputs[0, 0]
def test_unconnected():
net = RecurrentNet(
n_inputs=1,
n_hidden=0,
n_outputs=1,
input_to_hidden=([], []),
hidden_to_hidden=([], []),
output_to_hidden=([], []),
input_to_output=([], []),
hidden_to_output=([], []),
output_to_output=([], []),
hidden_responses=[],
output_responses=[1.0],
hidden_biases=[],
output_biases=[0],
)
result = net.activate([[0.2]])
assert result.shape == (1, 1)
assert_almost_equal(net.outputs[0, 0], 0.5, 0.001)
assert result[0, 0] == net.outputs[0, 0]
result = net.activate([[0.4]])
assert result.shape == (1, 1)
assert_almost_equal(net.outputs[0, 0], 0.5, 0.001)
assert result[0, 0] == net.outputs[0, 0]
def create_phenotype_network_nd(self, filename=None):
rnn_params = self.es_hyperneat_nd_tensors()
return RecurrentNet(n_inputs=rnn_params["n_inputs"],
n_outputs=rnn_params["n_outputs"],
n_hidden=rnn_params["n_hidden"],
output_to_hidden=rnn_params["output_to_hidden"],
output_to_output=rnn_params["output_to_output"],
hidden_to_hidden=rnn_params["hidden_to_hidden"],
input_to_hidden=rnn_params["input_to_hidden"],
input_to_output=rnn_params["input_to_output"],
hidden_to_output=rnn_params["hidden_to_output"],
hidden_responses=rnn_params["hidden_responses"],
output_responses=rnn_params["output_responses"],
hidden_biases=rnn_params["hidden_biases"],
output_biases=rnn_params["output_biases"])
def test_match_neat():
with open("tests/test-genome.pkl", "rb") as f:
genome = pickle.load(f)
# use tanh since neat sets output nodes with no inputs to 0
# (sigmoid would output 0.5 for us)
def neat_tanh_activation(z):
return float(torch.tanh(2.5 * torch.tensor(z, dtype=torch.float64)))
for node in genome.nodes.values():
node.response = 0.5
config = neat.Config(
neat.DefaultGenome,
neat.DefaultReproduction,
neat.DefaultSpeciesSet,
neat.DefaultStagnation,
"tests/test-config.cfg",
)
for _ in range(500):
genome.mutate(config.genome_config)
# print(genome)
neat_net = neat.nn.RecurrentNetwork.create(genome, config)
for i, (node, _activation, aggregation, bias, response,
links) in enumerate(neat_net.node_evals):
neat_net.node_evals[i] = (
node,
neat_tanh_activation,
aggregation,
bias,
response,
links,
)
torch_net = RecurrentNet.create(genome,
config,
activation=tanh_activation,
prune_empty=True)
for _ in range(5):
inputs = np.random.randn(12)
# print(inputs)
neat_result = neat_net.activate(inputs)
torch_result = torch_net.activate([inputs])[0].numpy()
assert np.allclose(neat_result, torch_result, atol=1e-8)
def create_phenotype_network_nd(self, filename=None):
input_coordinates = self.substrate.input_coordinates
output_coordinates = self.substrate.output_coordinates
input_nodes = range(len(input_coordinates))
output_nodes = range(len(input_nodes),
len(input_nodes) + len(output_coordinates))
hidden_idx = len(input_coordinates) + len(output_coordinates)
coordinates, indices, draw_connections, node_evals = [], [], [], []
nodes = {}
coordinates.extend(input_coordinates)
coordinates.extend(output_coordinates)
indices.extend(input_nodes)
indices.extend(output_nodes)
# Map input and output coordinates to their IDs.
coords_to_id = dict(zip(coordinates, indices))
# Where the magic happens.
hidden_nodes, connections = self.es_hyperneat_nd()
for cs in hidden_nodes:
coords_to_id[cs] = hidden_idx
hidden_idx += 1
for cs, idx in coords_to_id.items():
for c in connections:
if c.coord2 == cs:
draw_connections.append(c)
if idx in nodes:
initial = nodes[idx]
initial.append((coords_to_id[c.coord1], c.weight))
nodes[idx] = initial
else:
nodes[idx] = [(coords_to_id[c.coord1], c.weight)]
for idx, links in nodes.items():
node_evals.append((idx, self.activation, sum, 0.0, 1.0, links))
# Visualize the network?
# if filename is not None:
# draw_es_nd(coords_to_id, draw_connections, filename)
return RecurrentNet.create_from_es(input_nodes, output_nodes,
node_evals)
def create_phenotype_network_nd(self):
rnn_params = self.es_hyperneat_nd_tensors()
return RecurrentNet(
n_inputs=rnn_params["n_inputs"],
n_outputs=rnn_params["n_outputs"],
n_hidden=rnn_params["n_hidden"],
output_to_hidden=rnn_params["output_to_hidden"],
output_to_output=rnn_params["output_to_output"],
hidden_to_hidden=rnn_params["hidden_to_hidden"],
input_to_hidden=rnn_params["input_to_hidden"],
input_to_output=rnn_params["input_to_output"],
hidden_to_output=rnn_params["hidden_to_output"],
hidden_responses=rnn_params["hidden_responses"],
output_responses=rnn_params["output_responses"],
hidden_biases=rnn_params["hidden_biases"],
output_biases=rnn_params["output_biases"],
activation=str_to_activation[self.activation_string],
)
def make_net(genome, config, bs):
# TODO: get number of agents directly instead of magic number
return RecurrentNet.create(genome, config, bs * 2)
def make_net(genome, config, bs):
return RecurrentNet.create(genome, config, bs)
def __init__(self, genome, config, batch_size=64):
self._batch_size = batch_size
self._net = RecurrentNet.create(genome, config, batch_size)