def create_row_info_from_elements(self, p_p_entries, f_f_entries,
f_p_entries, bits_reserved_for_type,
weight_scale):
'''
takes a collection of entries for both fixed fixed, plastic plasitic and
fixed plastic and returns a synaptic row object for them
p_p_entries and f_p_entries are ignored due to this model dealing with
fixed synapses
'''
target_indices = list()
weights = list()
delays_in_ticks = list()
synapse_types = list()
#read in each element
for element in f_f_entries:
weights.append(float(element >> 16) /
float(weight_scale)) # drops delay, type and id
target_indices.append(element & 0xFF) # masks by 8 bits
# gets the size of the synapse type parameter
synaptic_type_mask = (1 << bits_reserved_for_type) - 1
synapse_types.append((element >> 8) & synaptic_type_mask)
delay_mask = (1 << (8 - bits_reserved_for_type)) - 1
delays_in_ticks.append((element >> 8 + bits_reserved_for_type)
& delay_mask)
return SynapseRowInfo(target_indices, weights, delays_in_ticks,
synapse_types)
def generate_synapse_list(self, prevertex, postvertex, delay_scale,
synapse_type):
id_lists = list()
weight_lists = list()
delay_lists = list()
type_lists = list()
for _ in range(0, prevertex.atoms):
id_lists.append(list())
weight_lists.append(list())
delay_lists.append(list())
type_lists.append(list())
pre_synaptic_neurons = random.sample(range(0, prevertex.atoms),
self.n_pre)
for pre_atom in pre_synaptic_neurons:
present = numpy.ones(postvertex.atoms, dtype=numpy.uint32)
n_present = postvertex.atoms
id_lists[pre_atom] = numpy.where(present)[0]
weight_lists[pre_atom] = generateParameterArray(
self.weights, n_present, present)
delay_lists[pre_atom] = (
generateParameterArray(self.delays, n_present, present) *
delay_scale)
type_lists[pre_atom] = synapse_type
connection_list = [
SynapseRowInfo(id_lists[i], weight_lists[i], delay_lists[i],
type_lists[i]) for i in range(0, prevertex.atoms)
]
return SynapticList(connection_list)
def generate_synapse_list(self, prevertex, postvertex, delay_scale,
synapse_type):
id_lists = list()
weight_lists = list()
delay_lists = list()
type_lists = list()
for _ in range(0, prevertex.atoms):
id_lists.append(list())
weight_lists.append(list())
delay_lists.append(list())
type_lists.append(list())
numIncomingAxons = prevertex.atoms
numTargetNeurons = postvertex.atoms
for _ in range(0, self.numSynapses):
source = int(random() * numIncomingAxons)
target = int(random() * numTargetNeurons)
weight = generateParameter(self.weights, target)
delay = generateParameter(self.weights, target) * delay_scale
id_lists[source].append(target)
weight_lists[source].append(weight)
delay_lists[source].append(delay)
type_lists[source].append(synapse_type)
connection_list = [SynapseRowInfo(id_lists[i], weight_lists[i],
delay_lists[i], type_lists[i])
for i in range(0, prevertex.atoms)]
return SynapticList(connection_list)
def get_synaptic_data(self, controller, min_delay):
'''
Get synaptic data for all connections in this Projection.
'''
logger.info("Reading synapse data for edge between {} and {}".format(
self.prevertex.label, self.postvertex.label))
sorted_subedges = sorted(
self.subedges,
key=lambda subedge:
(subedge.presubvertex.lo_atom, subedge.postsubvertex.lo_atom))
synaptic_list = list()
last_pre_lo_atom = None
for subedge in sorted_subedges:
rows = None
if subedge.pruneable:
rows = [
SynapseRowInfo([], [], [], [])
for _ in range(subedge.presubvertex.n_atoms)
]
else:
rows = subedge.get_synaptic_data(controller,
min_delay).get_rows()
if (last_pre_lo_atom is None) or (last_pre_lo_atom !=
subedge.presubvertex.lo_atom):
synaptic_list.extend(rows)
last_pre_lo_atom = subedge.presubvertex.lo_atom
else:
for i in range(len(rows)):
row = rows[i]
synaptic_list[i + last_pre_lo_atom].append(
row, lo_atom=subedge.postsubvertex.lo_atom)
return SynapticList(synaptic_list)
def generate_synapse_list(self, prevertex, postvertex, delay_scale,
synapse_type):
id_lists = list()
weight_lists = list()
delay_lists = list()
type_lists = list()
for _ in range(0, prevertex.atoms):
id_lists.append(list())
weight_lists.append(list())
delay_lists.append(list())
type_lists.append(list())
for i in range(0, len(self.conn_list)):
conn = self.conn_list[i]
pre_atom = generateParameter(conn[0], i)
post_atom = generateParameter(conn[1], i)
weight = generateParameter(conn[2], i)
delay = generateParameter(conn[3], i) * delay_scale
id_lists[pre_atom].append(post_atom)
weight_lists[pre_atom].append(weight)
delay_lists[pre_atom].append(delay)
type_lists[pre_atom].append(synapse_type)
connection_list = [
SynapseRowInfo(id_lists[i], weight_lists[i], delay_lists[i],
type_lists[i]) for i in range(0, prevertex.atoms)
]
return SynapticList(connection_list)
def generate_synapse_list(self, prevertex, postvertex, delay_scale,
synapse_type):
connection_list = list()
for pre_atom in range(0, prevertex.atoms):
delay = generateParameter(self.delays, pre_atom) * delay_scale
weight = generateParameter(self.weights, pre_atom)
connection_list.append(SynapseRowInfo([pre_atom], [weight],
[delay], [synapse_type]))
return SynapticList(connection_list)
def get_synaptic_data(self, controller, delay_offset):
delay_list = self.postsubvertex.vertex.get_synaptic_data(controller,
self.presubvertex, self.synapse_delay_rows, self.postsubvertex,
self.edge.synapse_row_io).get_rows()
rows = list()
for pre_atom in range(0, self.presubvertex.n_atoms):
rows.append(SynapseRowInfo([], [], [], []))
for i in range(0, self.edge.num_delay_stages):
min_delay = (i * self.edge.max_delay_per_neuron) + delay_offset
list_offset = i * 256
for pre_atom in range(0, self.presubvertex.n_atoms):
row = delay_list[list_offset + pre_atom]
rows[pre_atom].append(row, min_delay=min_delay)
return SynapticList(rows)
def generate_synapse_list(self, prevertex, postvertex, delay_scale,
synapse_type):
rows = list()
for _ in range(0, prevertex.atoms):
present = numpy.random.rand(postvertex.atoms) <= self.p_connect
n_present = numpy.sum(present)
ids = numpy.where(present)[0]
delays = (generateParameterArray(self.delays, n_present, present)
* delay_scale)
weights = generateParameterArray(self.weights, n_present, present)
synapse_types = (numpy.ones(len(ids), dtype='uint32')
* synapse_type)
rows.append(SynapseRowInfo(ids, weights, delays, synapse_types))
return SynapticList(rows)
def generate_synapse_list(self, prevertex, postvertex, delay_scale,
synapse_type):
connection_list = list()
for _ in range(0, prevertex.atoms):
present = numpy.ones(postvertex.atoms, dtype=numpy.uint32)
n_present = postvertex.atoms
ids = numpy.where(present)[0]
delays = (generateParameterArray(self.delays, n_present, present) *
delay_scale)
weights = generateParameterArray(self.weights, n_present, present)
synapse_types = (numpy.ones(len(ids), dtype='uint32') *
synapse_type)
connection_list.append(
SynapseRowInfo(ids, weights, delays, synapse_types))
return SynapticList(connection_list)
def get_synapse_sublist(self):
"""
Gets the synapse list for this subedge
"""
if self.synapse_sublist is None:
synapse_sublist = self.edge.synapse_list.create_atom_sublist(
self.presubvertex.lo_atom, self.presubvertex.hi_atom,
self.postsubvertex.lo_atom, self.postsubvertex.hi_atom)
# if logger.isEnabledFor("debug"):
# logger.debug("Original Synapse List rows:")
# orig_list = synapse_sublist.get_rows()
# for i in range(len(orig_list)):
# logger.debug("{}: {}".format(i, orig_list[i]))
if synapse_sublist.get_n_rows() > 256:
raise Exception(
"Delay sub-vertices can only support up to"
+ " 256 incoming neurons!")
full_delay_list = list()
for i in range(0, self.edge.num_delay_stages):
min_delay = (i * self.edge.max_delay_per_neuron)
max_delay = min_delay + self.edge.max_delay_per_neuron
delay_list = synapse_sublist.get_delay_sublist(min_delay,
max_delay)
# if logger.isEnabledFor("debug"):
# logger.debug(" Rows for delays {} - {}:".format(
# min_delay, max_delay))
# for i in range(len(delay_list)):
# logger.debug("{}: {}".format(i, delay_list[i]))
full_delay_list.extend(delay_list)
# Add extra rows for the "missing" items, up to 256
if (i + 1) < self.edge.num_delay_stages:
for _ in range(0, 256 - len(delay_list)):
full_delay_list.append(SynapseRowInfo([], [], [], []))
self.synapse_sublist = SynapticList(full_delay_list)
self.synapse_delay_rows = len(full_delay_list)
return self.synapse_sublist
def create_row_info_from_elements(self, p_p_entries, f_f_entries,
f_p_entries, bits_reserved_for_type,
weight_scale):
'''
takes a collection of entries for both fixed fixed, plastic plasitic and
fixed plastic and returns a synaptic row object for them
f_f_entries are ignored due to this model dealing with plastic synapses
'''
target_indices = list()
weights = list()
delays_in_ticks = list()
synapse_types = list()
#read in each element
#the fact that the fixed plastic are shorts, means that its number is an
#exact number for entries in the plastic plastic region. Because of the
# pp elements are in shorts but read as ints, the for loop has to
# selectively decide each section of the int to read given the shorts
#counter/index ABS and AGR
for index in range(len(f_p_entries)):
if index % 2 == 0:
weights.append(
(p_p_entries[self.num_header_words + int(index / 2)]
& 0xFFFF) / weight_scale) # drops delay, type and id
else:
weights.append(
(p_p_entries[self.num_header_words + int(index / 2)] >> 16)
/ weight_scale)
#read in each element
for element in f_p_entries:
target_indices.append(element & 0xFF) # masks by 8 bits
synaptic_type_mask = (1 << bits_reserved_for_type) - 1
synapse_types.append((element >> 8) & synaptic_type_mask)
delay_mask = (1 << (8 - bits_reserved_for_type)) - 1
delays_in_ticks.append((element >> 8 + bits_reserved_for_type)
& delay_mask)
return SynapseRowInfo(target_indices, weights, delays_in_ticks,
synapse_types)