def generate_synapse_list(
self, presynaptic_population, postsynaptic_population, delay_scale,
weight_scale, synapse_type):
prevertex = presynaptic_population._get_vertex
postvertex = postsynaptic_population._get_vertex
n_post_atoms = postvertex.n_atoms
n_pre_atoms = prevertex.n_atoms
id_lists = list()
weight_lists = list()
delay_lists = list()
type_lists = list()
for _ in range(0, n_pre_atoms):
id_lists.append(list())
weight_lists.append(list())
delay_lists.append(list())
type_lists.append(list())
if not 0 <= self._n_pre <= n_pre_atoms:
raise exceptions.ConfigurationException(
"Sample size has to be a number less than the size of the "
"population but greater than zero")
for post_atom in range(n_post_atoms):
pre_synaptic_neurons = random.sample(range(0, n_pre_atoms),
self._n_pre)
if (not self._allow_self_connections and
presynaptic_population == postsynaptic_population and
post_atom in pre_synaptic_neurons):
pre_synaptic_neurons.remove(post_atom)
#~ print("Connections going to POST neuron %s (%s)"%(post_atom, len(pre_synaptic_neurons)))
#~ print(pre_synaptic_neurons)
#~ print("----------------------------------------------------")
for pre_atom in pre_synaptic_atoms:
id_lists[pre_atom].append(post_atom)
for pre_atom in range(n_pre_atoms):
present = id_lists[pre_atom]
n_present = len(id_lists[pre_atom])
weight_lists[pre_atom] = (generate_parameter_array(
self._weights, n_present, present) * weight_scale)
delay_lists[pre_atom] = (generate_parameter_array(
self._delays, n_present, present) * delay_scale)
type_lists[pre_atom] = generate_parameter_array(
synapse_type, n_present, present)
connection_list = [SynapseRowInfo(id_lists[i], weight_lists[i],
delay_lists[i], type_lists[i])
for i in range(0, n_pre_atoms)]
return SynapticList(connection_list)
def generate_synapse_list(self, presynaptic_population,
postsynaptic_population, delay_scale,
weight_scale, synapse_type):
prevertex = presynaptic_population._get_vertex
postvertex = postsynaptic_population._get_vertex
connection_list = list()
for pre_atom in range(0, prevertex.n_atoms):
present = numpy.ones(postvertex.n_atoms, dtype=numpy.uint32)
if (not self._allow_self_connections
and presynaptic_population == postsynaptic_population):
present[pre_atom] = 0
n_present = postvertex.n_atoms - 1
else:
n_present = postvertex.n_atoms
ids = numpy.where(present)[0]
delays = (
generate_parameter_array(self._delays, n_present, present) *
delay_scale)
weights = (
generate_parameter_array(self._weights, n_present, present) *
weight_scale)
synapse_types = (numpy.ones(len(ids), dtype='uint32') *
synapse_type)
connection_list.append(
SynapseRowInfo(ids, weights, delays, synapse_types))
return SynapticList(connection_list)
def generate_synapse_list(
self, presynaptic_population, postsynaptic_population, delay_scale,
weight_scale, synapse_type):
prevertex = presynaptic_population._get_vertex
postvertex = postsynaptic_population._get_vertex
connection_list = list()
for pre_atom in range(0, prevertex.n_atoms):
present = numpy.ones(postvertex.n_atoms, dtype=numpy.uint32)
if (not self._allow_self_connections and
presynaptic_population == postsynaptic_population):
present[pre_atom] = 0
n_present = postvertex.n_atoms - 1
else:
n_present = postvertex.n_atoms
ids = numpy.where(present)[0]
delays = (generate_parameter_array(
self._delays, n_present, present) * delay_scale)
weights = (generate_parameter_array(
self._weights, n_present, present) * weight_scale)
synapse_types = (numpy.ones(len(ids), dtype='uint32') *
synapse_type)
connection_list.append(SynapseRowInfo(ids, weights, delays,
synapse_types))
return SynapticList(connection_list)
def generate_synapse_list(self, presynaptic_population,
postsynaptic_population, delay_scale,
weight_scale, synapse_type):
prevertex = presynaptic_population._get_vertex
postvertex = postsynaptic_population._get_vertex
id_lists = list()
weight_lists = list()
delay_lists = list()
type_lists = list()
for _ in range(0, prevertex.n_atoms):
id_lists.append(list())
weight_lists.append(list())
delay_lists.append(list())
type_lists.append(list())
if not 0 <= self._n_pre <= prevertex.n_atoms:
raise exceptions.ConfigurationException(
"Sample size has to be a number less than the size of the "
"population but greater than zero")
pre_synaptic_neurons = random.sample(range(0, prevertex.n_atoms),
self._n_pre)
for pre_atom in pre_synaptic_neurons:
present = numpy.ones(postvertex.n_atoms, dtype=numpy.uint32)
if (not self._allow_self_connections
and presynaptic_population == postsynaptic_population):
present[pre_atom] = 0
n_present = postvertex.n_atoms - 1
else:
n_present = postvertex.n_atoms
id_lists[pre_atom] = numpy.where(present)[0]
weight_lists[pre_atom] = (
generate_parameter_array(self._weights, n_present, present) *
weight_scale)
delay_lists[pre_atom] = (
generate_parameter_array(self._delays, n_present, present) *
delay_scale)
type_lists[pre_atom] = generate_parameter_array(
synapse_type, n_present, present)
connection_list = [
SynapseRowInfo(id_lists[i], weight_lists[i], delay_lists[i],
type_lists[i]) for i in range(0, prevertex.n_atoms)
]
return SynapticList(connection_list)
def generate_synapse_list(
self, presynaptic_population, postsynaptic_population, delay_scale,
weight_scale, synapse_type):
prevertex = presynaptic_population._get_vertex
postvertex = postsynaptic_population._get_vertex
id_lists = list()
weight_lists = list()
delay_lists = list()
type_lists = list()
for _ in range(0, prevertex.n_atoms):
id_lists.append(list())
weight_lists.append(list())
delay_lists.append(list())
type_lists.append(list())
if not 0 <= self._n_pre <= prevertex.n_atoms:
raise exceptions.ConfigurationException(
"Sample size has to be a number less than the size of the "
"population but greater than zero")
pre_synaptic_neurons = random.sample(range(0, prevertex.n_atoms),
self._n_pre)
for pre_atom in pre_synaptic_neurons:
present = numpy.ones(postvertex.n_atoms, dtype=numpy.uint32)
if (not self._allow_self_connections and
presynaptic_population == postsynaptic_population):
present[pre_atom] = 0
n_present = postvertex.n_atoms - 1
else:
n_present = postvertex.n_atoms
id_lists[pre_atom] = numpy.where(present)[0]
weight_lists[pre_atom] = (generate_parameter_array(
self._weights, n_present, present) * weight_scale)
delay_lists[pre_atom] = (generate_parameter_array(
self._delays, n_present, present) * delay_scale)
type_lists[pre_atom] = generate_parameter_array(
synapse_type, n_present, present)
connection_list = [SynapseRowInfo(id_lists[i], weight_lists[i],
delay_lists[i], type_lists[i])
for i in range(0, prevertex.n_atoms)]
return SynapticList(connection_list)
def generate_synapse_list(
self, presynaptic_population, postsynaptic_population, delay_scale,
weight_scale, synapse_type):
prevertex = presynaptic_population._get_vertex
postvertex = postsynaptic_population._get_vertex
present = (numpy.random.rand(postvertex.n_atoms * prevertex.n_atoms) <=
self._p_connect)
ids = numpy.where(present)[0]
n_present = numpy.sum(present)
source_ids = ids / postvertex.n_atoms
source_ids.sort()
target_ids = ids % postvertex.n_atoms
delays = generate_parameter_array(
self._delays, n_present, present) * delay_scale
weights = generate_parameter_array(
self._weights, n_present, present) * weight_scale
pre_counts = numpy.histogram(source_ids,
numpy.arange(prevertex.n_atoms + 1))[0]
pre_end_idxs = numpy.cumsum(pre_counts)
pre_start_idxs = numpy.append(0, pre_end_idxs[:-1])
synaptic_rows = []
n_synapses = 0
for _, (start, end) in enumerate(zip(pre_start_idxs, pre_end_idxs)):
this_target_ids = target_ids[start:end]
this_weights = weights[start:end]
this_delays = delays[start:end]
this_synapes_types = numpy.ones(
len(this_target_ids), dtype="uint32") * synapse_type
n_synapses += len(this_target_ids)
synaptic_rows.append(SynapseRowInfo(
this_target_ids, this_weights, this_delays,
this_synapes_types))
return SynapticList(synaptic_rows)
def generate_synapse_list(self, presynaptic_population,
postsynaptic_population, delay_scale,
weight_scale, synapse_type):
prevertex = presynaptic_population._get_vertex
postvertex = postsynaptic_population._get_vertex
present = (numpy.random.rand(postvertex.n_atoms * prevertex.n_atoms) <=
self._p_connect)
ids = numpy.where(present)[0]
n_present = numpy.sum(present)
source_ids = ids / postvertex.n_atoms
source_ids.sort()
target_ids = ids % postvertex.n_atoms
delays = generate_parameter_array(self._delays, n_present,
present) * delay_scale
weights = generate_parameter_array(self._weights, n_present,
present) * weight_scale
pre_counts = numpy.histogram(source_ids,
numpy.arange(prevertex.n_atoms + 1))[0]
pre_end_idxs = numpy.cumsum(pre_counts)
pre_start_idxs = numpy.append(0, pre_end_idxs[:-1])
synaptic_rows = []
n_synapses = 0
for _, (start, end) in enumerate(zip(pre_start_idxs, pre_end_idxs)):
this_target_ids = target_ids[start:end]
this_weights = weights[start:end]
this_delays = delays[start:end]
this_synapes_types = numpy.ones(len(this_target_ids),
dtype="uint32") * synapse_type
n_synapses += len(this_target_ids)
synaptic_rows.append(
SynapseRowInfo(this_target_ids, this_weights, this_delays,
this_synapes_types))
return SynapticList(synaptic_rows)
def generate_synapse_list(self, presynaptic_population,
postsynaptic_population, delay_scale,
weight_scale, synapse_type):
prevertex = presynaptic_population._get_vertex
postvertex = postsynaptic_population._get_vertex
source_ids = numpy.random.choice(prevertex.n_atoms,
size=self._num_synapses,
replace=True)
source_ids.sort()
target_ids = numpy.random.choice(postvertex.n_atoms,
size=self._num_synapses,
replace=True)
weights = generate_parameter_array(self._weights, self._num_synapses,
target_ids) * weight_scale
delays = generate_parameter_array(self._delays, self._num_synapses,
target_ids) * delay_scale
pre_counts = numpy.histogram(source_ids,
numpy.arange(prevertex.n_atoms + 1))[0]
pre_end_idxs = numpy.cumsum(pre_counts)
pre_start_idxs = numpy.append(0, pre_end_idxs[:-1])
synaptic_rows = []
n_synapses = 0
for _, (start, end) in enumerate(zip(pre_start_idxs, pre_end_idxs)):
this_target_ids = target_ids[start:end]
this_weights = weights[start:end]
this_delays = delays[start:end]
this_synapes_types = numpy.ones(len(this_target_ids),
dtype="uint32") * synapse_type
n_synapses += len(this_target_ids)
synaptic_rows.append(
SynapseRowInfo(this_target_ids, this_weights, this_delays,
this_synapes_types))
return SynapticList(synaptic_rows)
def generate_synapse_list(
self, presynaptic_population, postsynaptic_population, delay_scale,
weight_scale, synapse_type):
prevertex = presynaptic_population._get_vertex
postvertex = postsynaptic_population._get_vertex
source_ids = numpy.random.choice(
prevertex.n_atoms, size=self._num_synapses, replace=True)
source_ids.sort()
target_ids = numpy.random.choice(
postvertex.n_atoms, size=self._num_synapses, replace=True)
weights = generate_parameter_array(
self._weights, self._num_synapses, target_ids) * weight_scale
delays = generate_parameter_array(
self._delays, self._num_synapses, target_ids) * delay_scale
pre_counts = numpy.histogram(source_ids,
numpy.arange(prevertex.n_atoms + 1))[0]
pre_end_idxs = numpy.cumsum(pre_counts)
pre_start_idxs = numpy.append(0, pre_end_idxs[:-1])
synaptic_rows = []
n_synapses = 0
for _, (start, end) in enumerate(zip(pre_start_idxs, pre_end_idxs)):
this_target_ids = target_ids[start:end]
this_weights = weights[start:end]
this_delays = delays[start:end]
this_synapes_types = numpy.ones(
len(this_target_ids), dtype="uint32") * synapse_type
n_synapses += len(this_target_ids)
synaptic_rows.append(SynapseRowInfo(
this_target_ids, this_weights, this_delays,
this_synapes_types))
return SynapticList(synaptic_rows)
def generate_synapse_list(self, presynaptic_population,
postsynaptic_population, delay_scale,
weight_scale, synapse_type):
prevertex = presynaptic_population._get_vertex
postvertex = postsynaptic_population._get_vertex
n_post_atoms = postvertex.n_atoms
n_pre_atoms = prevertex.n_atoms
if not 0 <= self._n_post <= n_post_atoms:
raise exceptions.ConfigurationException(
"Sample size has to be a number less than the size of the "
"population but greater than zero")
id_lists = list()
weight_lists = list()
delay_lists = list()
type_lists = list()
for _ in range(0, n_pre_atoms):
id_lists.append(list())
weight_lists.append(list())
delay_lists.append(list())
type_lists.append(list())
for pre_atom in range(n_pre_atoms):
post_synaptic_neurons = random.sample(range(0, n_post_atoms),
self._n_post)
if (not self._allow_self_connections
and presynaptic_population == postsynaptic_population
and pre_atom in post_synaptic_neurons):
post_synaptic_neurons.remove(pre_atom)
n_present = len(post_synaptic_neurons)
id_lists[pre_atom] = post_synaptic_neurons
weight_lists[pre_atom] = (generate_parameter_array(
self._weights, n_present, post_synaptic_neurons) *
weight_scale)
delay_lists[pre_atom] = (generate_parameter_array(
self._delays, n_present, post_synaptic_neurons) * delay_scale)
type_lists[pre_atom] = generate_parameter_array(
synapse_type, n_present, post_synaptic_neurons)
if self._debug:
print("Connections going from PRE neuron %s (%s)" %
(pre_atom, n_present))
print("Index, Weight, Delay, Type")
print("[")
for i in range(n_present):
print("[%s, %s, %s, %s]," %
(id_lists[pre_atom][i], weight_lists[pre_atom][i],
delay_lists[pre_atom][i], type_lists[pre_atom][i]))
print("]")
print("----------------------------------------------------")
print("----------------------------------------------------")
print("----------------------------------------------------")
connection_list = [
SynapseRowInfo(id_lists[i], weight_lists[i], delay_lists[i],
type_lists[i]) for i in range(0, n_pre_atoms)
]
return SynapticList(connection_list)
