def to_matrix(self, multiple_synapses='last'):
'''
Returns the wanted state as a matrix of shape (# presynaptic neurons, # postsynaptic neurons) for visualization purposes.
The returned array value at [i,j] is the value of the wanted synaptic variable for the synapse between (i, j). If not synapse exists between those two neurons, then the value is ``np.nan``.
* Dealing with multiple synapses between two neurons
Outputting a 2D matrix is not generally possible, because multiple synapses can exist for a given pair or pre- and post-synaptic neurons.
In this case, the state values for all the synapses between neurons i and j are aggregated in the (i, j) position of the matrix. This is done according to the ``multiple_synapses`` keyword argument which can be changed:
``mutiple_synapses = 'last'`` (default) takes the last value
``mutiple_synapses = 'first'`` takes the first value
``mutiple_synapses = 'min'`` takes the min of the values
``mutiple_synapses = 'max'`` takes the max of the values
``mutiple_synapses = 'sum'`` takes the sum of the values
Please note that this function should be used for visualization, and should not be used to store or reload synaptic variable values.
If you want to do so, refer to the documentation at :meth:`Synapses.save_connectivity`.
'''
Nsource = len(self.synapses.source)
Ntarget = len(self.synapses.target)
Nsynapses = len(self.synapses)
output = np.ones((Nsource, Ntarget)) * np.nan
for isyn in xrange(Nsynapses):
# this is the couple index of the presynaptic and postsynaptic neurons.
curidx = (self.synapses.presynaptic[isyn],
self.synapses.postsynaptic[isyn])
if multiple_synapses == 'last' or np.isnan(output[curidx]):
# no previously found synapse, or we want the last one
output[curidx] = self.data[isyn]
elif multiple_synapses == 'first':
# if we want the first one, it's already set
pass
else:
# in this case, we try to use the numpy function as named by the multiple_synapses keyword
# it's a trick to make this code impossible to understand.
try:
# there already was a synapse, we aggregate data
exec('output[curidx] = np.' + multiple_synapses +
'([output[curidx], self.data[isyn]])')
except AttributeError:
log_debug(
'brian.synapticvariable',
'Couldn\'t figure out how to handle multiple synapses when creating matrix'
)
raise
return output
def to_matrix(self, multiple_synapses='last'):
'''
Returns the wanted state as a matrix of shape (# presynaptic neurons, # postsynaptic neurons) for visualization purposes.
The returned array value at [i,j] is the value of the wanted synaptic variable for the synapse between (i, j). If not synapse exists between those two neurons, then the value is ``np.nan``.
* Dealing with multiple synapses between two neurons
Outputting a 2D matrix is not generally possible, because multiple synapses can exist for a given pair or pre- and post-synaptic neurons.
In this case, the state values for all the synapses between neurons i and j are aggregated in the (i, j) position of the matrix. This is done according to the ``multiple_synapses`` keyword argument which can be changed:
``mutiple_synapses = 'last'`` (default) takes the last value
``mutiple_synapses = 'first'`` takes the first value
``mutiple_synapses = 'min'`` takes the min of the values
``mutiple_synapses = 'max'`` takes the max of the values
``mutiple_synapses = 'sum'`` takes the sum of the values
Please note that this function should be used for visualization, and should not be used to store or reload synaptic variable values.
If you want to do so, refer to the documentation at :meth:`Synapses.save_connectivity`.
'''
Nsource = len(self.synapses.source)
Ntarget = len(self.synapses.target)
Nsynapses = len(self.synapses)
output = np.ones((Nsource, Ntarget)) * np.nan
for isyn in xrange(Nsynapses):
# this is the couple index of the presynaptic and postsynaptic neurons.
curidx = (self.synapses.presynaptic[isyn], self.synapses.postsynaptic[isyn])
if multiple_synapses == 'last' or np.isnan(output[curidx]):
# no previously found synapse, or we want the last one
output[curidx] = self.data[isyn]
elif multiple_synapses == 'first':
# if we want the first one, it's already set
pass
else:
# in this case, we try to use the numpy function as named by the multiple_synapses keyword
# it's a trick to make this code impossible to understand.
try:
# there already was a synapse, we aggregate data
exec('output[curidx] = np.'+multiple_synapses+'([output[curidx], self.data[isyn]])')
except AttributeError:
log_debug('brian.synapticvariable', 'Couldn\'t figure out how to handle multiple synapses when creating matrix')
raise
return output
def generate_code(self,code,level,direct=False,code_namespace=None):
'''
Generates pre and post code.
``code''
The code as a string.
``level''
The namespace level in which the code is executed.
``direct=False''
If True, the code is generated assuming that
postsynaptic variables are not modified. This makes the
code faster.
``code_namespace''
Additional namespace (highest priority)
TODO:
* include static variables (substitution)
* have a list of variable names
'''
# Handle multi-line pre, post equations and multi-statement equations separated by ;
# (this should probably be factored)
if '\n' in code:
code = flattened_docstring(code)
elif ';' in code:
code = '\n'.join([line.strip() for line in code.split(';')])
# Create namespaces
_namespace = namespace(code, level = level + 1)
if code_namespace is not None:
_namespace.update(code_namespace)
_namespace['target'] = self.target # maybe we could save one indirection here
_namespace['unique'] = np.unique
_namespace['nonzero'] = np.nonzero
_namespace['empty'] = np.empty
_namespace['logical_not'] = np.logical_not
_namespace['not_equal'] = np.not_equal
_namespace['take'] = np.take
_namespace['extract'] = np.extract
_namespace['add'] = np.add
_namespace['hstack'] = np.hstack
code = re.sub(r'\b' + 'rand\(\)', 'rand(n)', code)
code = re.sub(r'\b' + 'randn\(\)', 'randn(n)', code)
# Generate the code
def update_code(code, indices, postinds):
res = code
# given the synapse indices, write the update code,
# this is here because in the code we generate we need to write this twice (because of the multiple presyn spikes for the same postsyn neuron problem)
# Replace synaptic variables by their value
for var in self.var_index: # static variables are not included here
if isinstance(var, str):
res = re.sub(r'\b' + var + r'\b', var + '['+indices+']', res) # synaptic variable, indexed by the synapse number
# Replace postsynaptic variables by their value
for postsyn_var in self.target.var_index: # static variables are not included here
if isinstance(postsyn_var, str):
#res = re.sub(r'\b' + postsyn_var + r'_post\b', 'target.' + postsyn_var + '['+postinds+']', res)# postsyn variable, indexed by post syn neuron numbers
#res = re.sub(r'\b' + postsyn_var + r'\b', 'target.' + postsyn_var + '['+postinds+']', res)# postsyn variable, indexed by post syn neuron numbers
res = re.sub(r'\b' + postsyn_var + r'_post\b', '_target_' + postsyn_var + '['+postinds+']', res)# postsyn variable, indexed by post syn neuron numbers
res = re.sub(r'\b' + postsyn_var + r'\b', '_target_' + postsyn_var + '['+postinds+']', res)# postsyn variable, indexed by post syn neuron numbers
_namespace['_target_' + postsyn_var] = self.target.state_(postsyn_var)
# Replace presynaptic variables by their value
for presyn_var in self.source.var_index: # static variables are not included here
if isinstance(presyn_var, str):
#res = re.sub(r'\b' + presyn_var + r'_pre\b', 'source.' + presyn_var + '[_pre['+indices+']]', res)# postsyn variable, indexed by post syn neuron numbers
res = re.sub(r'\b' + presyn_var + r'_pre\b', '_source_' + presyn_var + '[_pre['+indices+']]', res)# postsyn variable, indexed by post syn neuron numbers
_namespace['_source_' + presyn_var] = self.source.state_(presyn_var)
# Replace n by number of synapses being updated
res = re.sub(r'\bn\b','len('+indices+')', res)
return res
if direct: # direct update code, not caring about multiple accesses to postsynaptic variables
code_str = '_post_neurons = _post[_synapses]\n'+update_code(code, '_synapses', '_post_neurons') + "\n"
else:
algo = 3
if algo==0:
## Old version using numpy's unique()
code_str = "_post_neurons = _post[_synapses]\n" # not necessary to do a copy because _synapses is not a slice
code_str += "_u, _i = unique(_post_neurons, return_index = True)\n"
#code_str += update_code(code, '_synapses[_i]', '_u') + "\n"
code_str += update_code(code, '_synapses[_i]', '_post[_synapses[_i]]') + "\n"
code_str += "if len(_u) < len(_post_neurons):\n"
code_str += " _post_neurons[_i] = -1\n"
code_str += " while (len(_u) < len(_post_neurons)) & (_post_neurons>-1).any():\n" # !! the any() is time consuming (len(u)>=1??)
#code_str += " while (len(_u) < len(_post_neurons)) & (len(_u)>1):\n" # !! the any() is time consuming (len(u)>=1??)
code_str += " _u, _i = unique(_post_neurons, return_index = True)\n"
code_str += indent(update_code(code, '_synapses[_i[1:]]', '_post[_synapses[_i[1:]]]'),2) + "\n"
code_str += " _post_neurons[_i[1:]] = -1 \n"
elif algo==1:
code_str = "_post_neurons = _post[_synapses]\n" # not necessary to do a copy because _synapses is not a slice
code_str += "_perm = _post_neurons.argsort()\n"
code_str += "_aux = _post_neurons[_perm]\n"
code_str += "_flag = empty(len(_aux) + 1, dtype = bool)\n"
code_str += "_flag[0] = _flag[-1] = True\n"
code_str += "not_equal(_aux[1:], _aux[:-1], _flag[1:-1])\n"
code_str += "_F = _flag.nonzero()[0][:-1]\n"
code_str += "logical_not(_flag, _flag)\n"
code_str += "while len(_F):\n"
code_str += " _u = _aux[_F]\n"
code_str += " _i = _perm[_F]\n"
code_str += indent(update_code(code, '_synapses[_i]', '_u'), 1) + "\n"
code_str += " _F += 1\n"
code_str += " _F = _F[_flag[_F]]\n"
elif algo==2:
code_str = '''
_post_neurons = _post.data.take(_synapses)
_perm = _post_neurons.argsort()
_aux = _post_neurons.take(_perm)
_flag = empty(len(_aux)+1, dtype=bool)
_flag[0] = _flag[-1] = 1
not_equal(_aux[1:], _aux[:-1], _flag[1:-1])
if 0:#_flag.sum()==len(_aux)+1:
%(code1)s
else:
_F = _flag.nonzero()[0][:-1]
logical_not(_flag, _flag)
while len(_F):
_u = _aux.take(_F)
_i = _perm.take(_F)
%(code2)s
_F += 1
_F = extract(_flag.take(_F), _F)
'''
code_str = flattened_docstring(code_str) % {'code1': indent(update_code(code, '_synapses','_post_neurons'), 1),
'code2': indent(update_code(code, '_synapses[_i]', '_u'), 2)}
elif algo==3:
code_str = '''
_post_neurons = _post.data.take(_synapses)
_perm = _post_neurons.argsort()
_aux = _post_neurons.take(_perm)
_flag = empty(len(_aux)+1, dtype=bool)
_flag[0] = _flag[-1] = 1
not_equal(_aux[1:], _aux[:-1], _flag[1:-1])
_F = _flag.nonzero()[0][:-1]
logical_not(_flag, _flag)
while len(_F):
_u = _aux.take(_F)
_i = _perm.take(_F)
%(code)s
_F += 1
_F = extract(_flag.take(_F), _F)
'''
code_str = flattened_docstring(code_str) % {'code': indent(update_code(code, '_synapses[_i]', '_u'), 1)}
elif algo==4:
code_str = '''
_post_neurons = _post[_synapses]
_perm = _post_neurons.argsort()
_aux = _post_neurons[_perm]
_flag = empty(len(_aux)+1, dtype=bool)
_flag[0] = _flag[-1] = 1
not_equal(_aux[1:], _aux[:-1], _flag[1:-1])
_F = _flag.nonzero()[0][:-1]
logical_not(_flag, _flag)
while len(_F):
_u = _aux[_F]
_i = _perm[_F]
%(code)s
_F += 1
_F = _F[_flag[_F]]
'''
code_str = flattened_docstring(code_str) % {'code': indent(update_code(code, '_synapses[_i]', '_u'), 1)}
# print code_str
log_debug('brian.synapses', '\nCODE:\n'+code_str)
# Compile
compiled_code = compile(code_str, "Synaptic code", "exec")
_namespace['_original_code_string'] = code_str
return compiled_code,_namespace
