def build(self, time_offs=0, topology_params={}, input_params={},
meta_data={}, seed=None):
"""
Builds a network with the given topology and input data that is ready
to be handed of to PyNNLess.
"""
old_state = utils.initialize_seed(seed, 1)
try:
topology = self.build_topology(topology_params=topology_params)
finally:
utils.finalize_seed(old_state)
old_state = utils.initialize_seed(seed, 2)
try:
input_times, input_indices, input_split = self.build_input(
time_offs=time_offs,
topology_params=topology_params,
input_params=input_params)
finally:
utils.finalize_seed(old_state)
return NetworkInstance(
self.inject_input(topology, input_times),
input_times=input_times,
input_indices=input_indices,
input_split=input_split,
input_params=input_params,
data_params=self.data_params,
topology_params=topology_params,
meta_data=meta_data,
mat_in=self.mat_in,
mat_out=self.mat_out)
def build(self, time_offs=0, topology_params={}, input_params={}, meta_data={}, seed=None):
"""
Builds a network with the given topology and input data that is ready
to be handed of to PyNNLess.
"""
old_state = utils.initialize_seed(seed, 1)
try:
topology = self.build_topology(topology_params=topology_params)
finally:
utils.finalize_seed(old_state)
old_state = utils.initialize_seed(seed, 2)
try:
input_times, input_indices, input_split = self.build_input(
time_offs=time_offs, topology_params=topology_params, input_params=input_params
)
finally:
utils.finalize_seed(old_state)
return NetworkInstance(
self.inject_input(topology, input_times),
input_times=input_times,
input_indices=input_indices,
input_split=input_split,
input_params=input_params,
data_params=self.data_params,
topology_params=topology_params,
meta_data=meta_data,
mat_in=self.mat_in,
mat_out=self.mat_out,
)
def _finalize_generate(old_random_state):
utils.finalize_seed(old_random_state)
def build(self, simulator_info, simulator="", seed=None):
"""
Builds all NetworkPool instances required to conduct the specified
experiments.
:param simulator_info: Information about the used simulator as returned
from PyNNLess.get_simulator_info() -- contains the maximum number of
neurons and the supported software concurrency.
:param seed: seed to be used to spawn the seeds for the data generation.
"""
# Spawn more random seeds
old_state = utils.initialize_seed(seed)
try:
data_seed = np.random.randint(1 << 30)
build_seed = np.random.randint(1 << 30)
finally:
utils.finalize_seed(old_state)
# Add a dummy experiment if there are no experiments specified
if len(self["experiments"]) == 0:
self["experiments"] = [ExperimentDescriptor(name="eval")]
# "Count sources" flag
cs = simulator_info["sources_are_neurons"]
# Create all NetworkPool instances
pools = []
for i, experiment in enumerate(self["experiments"]):
# Gather the input and topology parameters for this experiment
input_params_list, topology_params_list = \
self.build_parameters(experiment)
# Generate an experiment name
# TODO: Make sure the name is unique
if experiment["name"] == "":
experiment["name"] = "experiment_" + str(i)
# Generate new pools for this experiment
min_pool = len(pools)
pidx = simulator_info["concurrency"]
# Assemble a name for this repetition
pools = pools + [NetworkPool(name=experiment["name"] + "." + str(c))
for c in xrange(simulator_info["concurrency"])]
# Metadata to store along with the networks
meta_data = {
"experiment_idx": i,
"experiment_name": experiment["name"],
"experiment_size": (experiment["repeat"] *
(len(input_params_list) * len(topology_params_list))),
"keys": experiment.get_keys(),
"output_params": self["output"],
"simulator": simulator
}
# Repeat the experiment as many times as specified in the "repeat"
# parameter
local_build_seed = build_seed
net_idx = 0
for j in xrange(experiment["repeat"]):
# Create a random permutation of the topology parameters list
perm = range(0, len(topology_params_list))
random.shuffle(perm)
for k in xrange(len(topology_params_list)):
# Print the current network number
net_idx = net_idx + 1
if (net_idx % 100 == 0):
n_nets = len(topology_params_list) * experiment["repeat"]
print("Generating network " + str(net_idx) + "/" +
str(n_nets))
# Create a build instance coupled with the topology
# parameters
topology_params = topology_params_list[perm[k]]
builder = NetworkBuilder(
data_params=topology_params["data"],
seed=data_seed)
# Build a network instance and add it to the network pool
net = builder.build(
topology_params=topology_params["topology"],
input_params=input_params_list,
meta_data=meta_data,
seed=local_build_seed)
# Search for a pool to which the network should be added.
# Use the pool with the fewest neurons which still has
# space for this experiment.
target_pool_idx = -1
for l in xrange(min_pool, len(pools)):
if ((target_pool_idx == -1 or pools[l].neuron_count(cs)
< pools[target_pool_idx].neuron_count(cs)) and
pools[l].neuron_count(cs)
+ net.neuron_count(cs)
<= simulator_info["max_neuron_count"]):
# If uniform parameter are required (Spikey), check
# whether the target network parameters are the same
# as the current network parameters
if pools[l].neuron_count(cs) > 0:
if self._check_shared_parameters_equal(
simulator_info["shared_parameters"],
pools[l]["topology_params"][0]["params"],
topology_params["topology"]["params"]):
target_pool_idx = l
else:
target_pool_idx = l
# No free pool has been found, add a new one
if target_pool_idx == -1:
pool_name = experiment["name"] + "." + str(pidx)
pools.append(NetworkPool(name=pool_name))
pidx = pidx + 1
target_pool_idx = len(pools) - 1
# Add the network to the pool
pools[target_pool_idx].add_network(net)
# Advance the build_seed -- the input and topology
# parameters should still vary between trials,
# but reproducibly
local_build_seed = local_build_seed * 2
# Return non-empty pool instances
return filter(lambda x: x.neuron_count(cs) > 0, pools)
