def __init__(self, **parameters):
super(StaticSynapse, self).__init__(**parameters)
# we have to define the translations on a per-instance basis because
# they depend on whether the synapses are current-, conductance- or voltage-based.
self.translations = build_translations(
('weight', 'weight', "weight*weight_units", "weight/weight_units"),
('delay', 'delay', ms))
def test_describe():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3, 'c': 44.4}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 1000.0),
('c', 'C', 'c + a', 'C - A'),
)
assert isinstance(M().describe(), basestring)
def test_computed_parameters():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3, 'c': 44.4}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 1000.0),
('c', 'C', 'c + a', 'C - A'),
)
assert_equal(M().computed_parameters(), ['c'])
def test_translate_with_divide_by_zero_error():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 'b/0', 'B*0'),
)
assert_raises(ZeroDivisionError,
M.translate, {'a': 23.4, 'b': 34.5})
def test_reverse_translate():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3, 'c': 44.4}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 1000.0),
('c', 'C', 'c + a', 'C - A'),
)
assert_equal(_parameter_space_to_dict(M().reverse_translate(ParameterSpace({'A': 23.4, 'B': 34500.0, 'C': 69.0})), 88),
{'a': 23.4, 'b': 34.5, 'c': 45.6})
def test_translate():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3, 'c': 44.4}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 1000.0),
('c', 'C', 'c + a', 'C - A'),
)
assert_equal(M.translate({'a': 23.4, 'b': 34.5, 'c': 45.6}),
{'A': 23.4, 'B': 34500.0, 'C': 69.0})
def test_reverse_translate_with_invalid_transformation():
M = StandardModelType
M.translations = build_translations(
('a', 'A'),
('b', 'B', 'b + z', 'B-Z'),
)
M.default_parameters = {'a': 22.2, 'b': 33.3}
#really we should trap such errors in build_translations(), not in reverse_translate()
assert_raises(NameError,
M().reverse_translate,
{'A': 23.4, 'B': 34.5})
def test_translate_with_invalid_transformation():
M = StandardModelType
M.translations = build_translations(
('a', 'A'),
('b', 'B', 'b + z', 'B-Z'),
)
M.default_parameters = {'a': 22.2, 'b': 33.3}
#really we should trap such errors in build_translations(), not in translate()
m = M()
assert_raises(NameError,
m.translate,
ParameterSpace({'a': 23.4, 'b': 34.5}, m.get_schema(), None))
def test_translate():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3, 'c': 44.4}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 1000.0),
('c', 'C', 'c + a', 'C - A'),
)
m = M()
native_parameters = m.translate(ParameterSpace({'a': 23.4, 'b': 34.5, 'c': 45.6}, m.get_schema(), None))
assert_equal(_parameter_space_to_dict(native_parameters, 77),
{'A': 23.4, 'B': 34500.0, 'C': 69.0})
def test_translate_with_divide_by_zero_error():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 'b/0', 'B*0'),
)
m = M()
native_parameters = m.translate(ParameterSpace({'a': 23.4, 'b': 34.5}, m.get_schema(), 77))
assert_raises(ZeroDivisionError,
native_parameters.evaluate,
simplify=True)
class IF_cond_exp_gsfa_grr(cells.IF_cond_exp_gsfa_grr):
eqs = adapt_iaf + conductance_based_alpha_synapses
translations = deepcopy(adapt_iaf_translations)
translations.update(conductance_based_synapse_translations)
state_variable_translations = build_translations(
('v', 'v', lambda p: p * mV, lambda p: p / mV),
('g_s', 'g_s', lambda p: p * uS,
lambda p: p / uS), # should be uS - needs changed for all back-ends
('g_r', 'g_r', lambda p: p * uS, lambda p: p / uS),
('gsyn_exc', 'ge', lambda p: p * uS, lambda p: p / uS),
('gsyn_inh', 'gi', lambda p: p * uS, lambda p: p / uS))
post_synaptic_variables = {'excitatory': 'ge', 'inhibitory': 'gi'}
brian2_model = AdaptiveNeuronGroup2
def test_translate():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3, 'c': 44.4}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 1000.0),
('c', 'C', 'c + a', 'C - A'),
)
m = M()
native_parameters = m.translate(ParameterSpace(
{'a': 23.4, 'b': 34.5, 'c': 45.6}, m.get_schema(), None))
assert_equal(_parameter_space_to_dict(native_parameters, 77),
{'A': 23.4, 'B': 34500.0, 'C': 69.0})
class SpikeSourcePoisson(cells.SpikeSourcePoisson):
__doc__ = cells.SpikeSourcePoisson.__doc__
translations = build_translations(
('rate', 'rate', 0.001),
('start', 'start'),
('duration', 'duration')
)
nemo_name = "PoissonSource"
indices = {'rate' : 0}
class SpikeSourcePoisson(cells.SpikeSourcePoisson):
__doc__ = cells.SpikeSourcePoisson.__doc__
translations = build_translations(
('rate', 'firing_rate', lambda **p: p["rate"] * Hz,
lambda **p: p["firing_rate"] / Hz),
('start', 'start_time', lambda **p: p["start"] * ms,
lambda **p: p["start_time"] / ms),
('duration', 'duration', lambda **p: p["duration"] * ms,
lambda **p: p["duration"] / ms),
)
eqs = None
brian2_model = PoissonGroup
class HH_cond_exp(cells.HH_cond_exp, IF_base):
""" Single-compartment Hodgkin-Huxley model."""
n = 0
translations = standardmodels.build_translations(
*[(name, name) for name in cells.HH_cond_exp.default_parameters])
def __init__(self, parameters):
cells.HH_cond_exp.__init__(self, parameters)
self.label = '%s%d' % (self.__class__.__name__, self.__class__.n)
self.synapse_type = "exp_syn"
self.__class__.n += 1
logger.debug("HH_cond_exp created")
class IF_cond_exp(cells.IF_cond_exp, IF_base):
"""Leaky integrate and fire model with fixed threshold and
decaying-exponential post-synaptic conductance."""
n = 0
translations = standardmodels.build_translations(
*[(name, name) for name in cells.IF_cond_exp.default_parameters])
def __init__(self, parameters):
cells.IF_cond_exp.__init__(self, parameters)
self.label = '%s%d' % (self.__class__.__name__, self.__class__.n)
self.synapse_type = "doub_exp_syn"
self.__class__.n += 1
class SpikeSourceArray(cells.SpikeSourceArray, NotImplementedModel):
"""Spike source generating spikes at the times given in the spike_times array."""
n = 0
translations = standardmodels.build_translations(
*[(name, name)
for name in cells.SpikeSourcePoisson.default_parameters])
def __init__(self, parameters):
NotImplementedModel.__init__(self)
cells.SpikeSourceARRAY.__init__(self, parameters)
self.label = '%s%d' % (self.__class__.__name__, self.__class__.n)
self.__class__.n += 1
class AdditivePotentiationMultiplicativeDepression(synapses.AdditivePotentiationMultiplicativeDepression):
__doc__ = synapses.AdditivePotentiationMultiplicativeDepression.__doc__
translations = build_translations(
('w_max', 'w_max'),
('w_min', 'w_min'),
)
def _set_target_type(self, weight_units):
self.translations["w_max"]["forward_transform"] = lambda **P: P["w_max"] * weight_units
self.translations["w_max"]["reverse_transform"] = lambda **P: P["w_max"] / weight_units
self.translations["w_min"]["forward_transform"] = lambda **P: P["w_min"] * weight_units
self.translations["w_min"]["reverse_transform"] = lambda **P: P["w_min"] / weight_units
class MultiplicativeWeightDependence(synapses.MultiplicativeWeightDependence):
__doc__ = synapses.MultiplicativeWeightDependence.__doc__
translations = build_translations(
('w_max', 'w_max'),
('w_min', 'w_min'),
)
def _set_target_type(self, weight_units):
self.translations["w_max"]["forward_transform"] = lambda **P: P["w_max"] * weight_units
self.translations["w_max"]["reverse_transform"] = lambda **P: P["w_max"] / weight_units
self.translations["w_min"]["forward_transform"] = lambda **P: P["w_min"] * weight_units
self.translations["w_min"]["reverse_transform"] = lambda **P: P["w_min"] / weight_units
def test_build_translations():
t = build_translations(("a", "A"), ("b", "B", 1000.0), ("c", "C", "c + a", "C - A"))
assert_equal(set(t.keys()), set(["a", "b", "c"]))
assert_equal(set(t["a"].keys()), set(["translated_name", "forward_transform", "reverse_transform"]))
assert_equal(t["a"]["translated_name"], "A")
assert_equal(t["a"]["forward_transform"], "a")
assert_equal(t["a"]["reverse_transform"], "A")
assert_equal(t["b"]["translated_name"], "B")
assert_equal(t["b"]["forward_transform"], "float(1000)*b")
assert_equal(t["b"]["reverse_transform"], "B/float(1000)")
assert_equal(t["c"]["translated_name"], "C")
assert_equal(t["c"]["forward_transform"], "c + a")
assert_equal(t["c"]["reverse_transform"], "C - A")
class GutigWeightDependence(synapses.GutigWeightDependence, WeightDependence):
__doc__ = synapses.GutigWeightDependence.__doc__
vars = deepcopy(WeightDependence.vars)
vars.update({"muPlus": "scalar", "muMinus": "scalar"})
depression_update_code = "$(g) -= pow(($(g) - $(Wmin)), $(muMinus)) * update;\n"
potentiation_update_code = "$(g) += pow(($(Wmax) - $(g)), $(muPlus)) * update;\n"
translations = build_translations(("mu_plus", "muPlus"),
("mu_minus", "muMinus"),
*WeightDependence.wd_translations)
class TsodyksMarkramSynapse(synapses.TsodyksMarkramSynapse):
__doc__ = synapses.TsodyksMarkramSynapse.__doc__
translations = build_translations(('weight', 'WEIGHT'), ('delay', 'DELAY'),
('U', 'UU'), ('tau_rec', 'TAU_REC'),
('tau_facil', 'TAU_FACIL'), ('u0', 'U0'),
('x0', 'X'), ('y0', 'Y'))
def _get_minimum_delay(self):
d = state.min_delay
if d == 'auto':
d = state.dt
return d
class SpikeSourcePoisson(cells.SpikeSourcePoisson, NotImplementedModel):
"""Spike source, generating spikes according to a Poisson process."""
n = 0
translations = standardmodels.build_translations(
*[(name, name)
for name in cells.SpikeSourcePoisson.default_parameters])
def __init__(self, parameters):
NotImplementedModel.__init__(self)
cells.SpikeSourcePoisson.__init__(self, parameters)
self.label = '%s%d' % (self.__class__.__name__, self.__class__.n)
self.__class__.n += 1
class IF_cond_exp_gsfa_grr(base_cells.IF_cond_exp_gsfa_grr):
__doc__ = base_cells.IF_cond_exp_gsfa_grr.__doc__
translations = build_translations(
('v_rest', 'v_reset'), ('v_reset', 'v_reset'), ('cm', 'c_m'),
('tau_m', 'tau_m'), ('tau_refrac', 't_refrac'), ('tau_syn_E', 'tau_e'),
('tau_syn_I', 'tau_i'), ('v_thresh', 'v_thresh'),
('i_offset', 'i_offset'), ('e_rev_E', 'e_e'), ('e_rev_I', 'e_i'),
('tau_sfa', 'tau_sfa'), ('e_rev_sfa', 'e_sfa'), ('q_sfa', 'q_sfa'),
('tau_rr', 'tau_rr'), ('e_rev_rr', 'e_rr'), ('q_rr', 'q_rr'))
model = GsfaGrrIF
extra_parameters = {'syn_type': 'conductance', 'syn_shape': 'exp'}
class SpikePairRule(synapses.SpikePairRule):
translations = build_translations(
('tau_plus', 'tau_plus'),
('tau_minus', 'tau_minus'), # defined in post-synaptic neuron
)
possible_models = set(['stdp_synapse']) #,'stdp_synapse_hom'])
def __init__(self, tau_plus=20.0, tau_minus=20.0):
#synapses.SpikePairRule.__init__(self, tau_plus, tau_minus)
parameters = dict(locals())
parameters.pop('self')
self.parameters = self.translate(parameters)
class IF_facets_hardware1(cells.IF_facets_hardware1):
__doc__ = cells.IF_facets_hardware1.__doc__
# in 'iaf_cond_exp', the dimension of C_m is pF,
# while in the pyNN context, cm is given in nF
translations = build_translations(
('v_reset', 'V_reset'), ('v_rest', 'E_L'), ('v_thresh', 'V_th'),
('e_rev_I', 'E_in'), ('tau_syn_E', 'tau_syn_ex'),
('tau_syn_I', 'tau_syn_in'), ('g_leak', 'g_L'))
nest_name = {"on_grid": "iaf_cond_exp", "off_grid": "iaf_cond_exp"}
standard_receptor_type = True
extra_parameters = {'C_m': 200.0, 't_ref': 1.0, 'E_ex': 0.0}
class Izhikevich(cells.Izhikevich):
__doc__ = cells.Izhikevich.__doc__
translations = build_translations(
('a', 'a'),
('b', 'b'),
('c', 'c'),
('d', 'd'),
('i_offset', 'I_e', 1000.0),
)
nest_name = {"on_grid": "izhikevich", "off_grid": "izhikevich"}
standard_receptor_type = True
receptor_scale = 1e-3 # synaptic weight is in mV, so need to undo usual weight scaling
class EIF_cond_exp_isfa_ista(cells.EIF_cond_exp_isfa_ista):
__doc__ = cells.EIF_cond_exp_isfa_ista.__doc__
eqs = adexp_iaf + conductance_based_exponential_synapses
translations = deepcopy(adexp_iaf_translations)
translations.update(conductance_based_synapse_translations)
state_variable_translations = build_translations(
('v', 'v', lambda p: p * mV, lambda p: p / mV),
('w', 'w', lambda p: p * nA, lambda p: p / nA),
('gsyn_exc', 'ge', lambda p: p * uS, lambda p: p / uS),
('gsyn_inh', 'gi', lambda p: p * uS, lambda p: p / uS))
post_synaptic_variables = {'excitatory': 'ge', 'inhibitory': 'gi'}
brian2_model = AdaptiveNeuronGroup
class IF_cond_alpha(cells.IF_cond_alpha, IF_base):
"""Leaky integrate and fire model with fixed threshold and alpha-function-
shaped post-synaptic conductance."""
n = 0
translations = standardmodels.build_translations(
*[(name, name) for name in cells.IF_cond_alpha.default_parameters])
def __init__(self, parameters):
cells.IF_cond_alpha.__init__(self, parameters)
self.label = '%s%d' % (self.__class__.__name__, self.__class__.n)
self.synapse_type = "alpha_syn"
self.__class__.n += 1
class MockStandardCellType(StandardCellType):
default_parameters = {
"foo": 99.9,
"hoo": 100.0,
"woo": 5.0,
}
default_initial_values = {
"v": 0.0,
}
translations = build_translations(
('foo', 'FOO'),
('hoo', 'HOO', 3.0),
('woo', 'WOO', '2*woo + hoo', '(WOO - HOO)/2'),
)
def test_translate_with_invalid_transformation():
M = StandardModelType
M.translations = build_translations(
('a', 'A'),
('b', 'B', 'b + z', 'B-Z'),
)
M.default_parameters = {'a': 22.2, 'b': 33.3}
#really we should trap such errors in build_translations(), not in translate()
m = M()
assert_raises(NameError, m.translate,
ParameterSpace({
'a': 23.4,
'b': 34.5
}, m.get_schema(), None))
class STDPMechanism(synapses.STDPMechanism):
__doc__ = synapses.STDPMechanism.__doc__
base_translations = build_translations(
('weight', 'WEIGHT'),
('delay', 'DELAY'),
('dendritic_delay_fraction', 'dendritic_delay_fraction')
)
def _get_minimum_delay(self):
d = state.min_delay
if d == 'auto':
d = state.dt
return d
class StaticSynapse(synapses.StaticSynapse, GeNNStandardSynapseType):
__doc__ = synapses.StaticSynapse.__doc__
wum_defs = {"sim_code": "$(addToInSyn, $(g));\n", "vars": {"g": "scalar"}}
translations = build_translations(
("weight", "g"),
("delay", "delaySteps", delayMsToSteps, delayStepsToMs))
def _get_minimum_delay(self):
if state._min_delay == "auto":
return state.dt
else:
return state._min_delay
class IF_curr_exp(cells.IF_curr_exp):
__doc__ = cells.IF_curr_exp.__doc__
translations = build_translations( # should add some computed/scaled parameters
('tau_m', 'TAU_M'),
('cm', 'CM'),
('v_rest', 'V_REST'),
('v_thresh', 'V_THRESH'),
('v_reset', 'V_RESET'),
('tau_refrac', 'T_REFRAC'),
('i_offset', 'I_OFFSET'),
('tau_syn_E', 'TAU_SYN_E'),
('tau_syn_I', 'TAU_SYN_I'),
)
class SpikeSourcePoisson(cells.SpikeSourcePoisson):
__doc__ = cells.SpikeSourcePoisson.__doc__
translations = build_translations(('start', 'Tstart', 1e-3),
('rate', 'rate'),
('duration', 'duration', 1e-3))
pcsim_name = 'PoissonInputNeuron'
simObjFactory = None
setterMethods = {}
def __init__(self, parameters):
cells.SpikeSourcePoisson.__init__(self, parameters)
self.simObjFactory = pypcsim.PoissonInputNeuron(**self.parameters)
def test_translate_with_divide_by_zero_error():
M = StandardModelType
M.default_parameters = {'a': 22.2, 'b': 33.3}
M.translations = build_translations(
('a', 'A'),
('b', 'B', 'b/0', 'B*0'),
)
m = M()
native_parameters = m.translate(
ParameterSpace({
'a': 23.4,
'b': 34.5
}, m.get_schema(), 77))
assert_raises(ZeroDivisionError, native_parameters.evaluate, simplify=True)
class SpikePairRule(synapses.SpikePairRule):
__doc__ = synapses.SpikePairRule.__doc__
translations = build_translations(
('tau_plus', 'tauLTP'),
('tau_minus', 'tauLTD'),
)
possible_models = set(['StdwaSA', 'StdwaSoft', 'StdwaGuetig'])
def __init__(self, tau_plus=20.0, tau_minus=20.0):
#synapses.SpikePairRule.__init__(self, tau_plus, tau_minus)
self.parameters = self.translate({'tau_plus': tau_plus,
'tau_minus': tau_minus})
class SpikeSourceArray(cells.SpikeSourceArray):
"""Spike source generating spikes at the times given in the spike_times array."""
translations = build_translations(('spike_times', 'spiketimes', ms), )
@classmethod
def translate(cls, parameters):
if 'spike_times' in parameters:
try:
parameters['spike_times'] = numpy.array(
parameters['spike_times'], float)
except ValueError:
raise errors.InvalidParameterValueError(
"spike times must be floats")
return super(SpikeSourceArray, cls).translate(parameters)
class TsodyksMarkramSynapse(synapses.TsodyksMarkramSynapse, NESTSynapseMixin):
__doc__ = synapses.TsodyksMarkramSynapse.__doc__
translations = build_translations(
('weight', 'weight', 1000.0),
('delay', 'delay'),
('U', 'U'),
('tau_rec', 'tau_rec'),
('tau_facil', 'tau_fac'),
('u0', 'u'), # this could cause problems for reverse translation
('x0', 'x'), # (as for V_m) in cell models, since the initial value
('y0', 'y') # is not stored, only set.
)
nest_name = 'tsodyks_synapse'
class IF_curr_alpha(cells.IF_curr_alpha, NotImplementedModel):
"""Leaky integrate and fire model with fixed threshold and alpha-function-
shaped post-synaptic current."""
n = 0
translations = standardmodels.build_translations(*[(name, name)
for name in cells.IF_curr_alpha.default_parameters])
def __init__(self, parameters):
NotImplementedModel.__init__(self)
cells.IF_curr_exp.__init__(self, parameters)
self.label = '%s%d' % (self.__class__.__name__, self.__class__.n)
self.synapse_type = "doub_exp_syn"
self.__class__.n += 1
class StepCurrentSource(NeuronCurrentSource, electrodes.StepCurrentSource):
__doc__ = electrodes.StepCurrentSource.__doc__
translations = build_translations(
('amplitudes', 'amplitudes'),
('times', 'times')
)
_is_playable = True
_is_computed = False
def _generate(self):
pass
def test_build_translations():
t = build_translations(
('a', 'A'),
('b', 'B', 1000.0),
('c', 'C', 'c + a', 'C - A')
)
assert_equal(set(t.keys()), set(['a', 'b', 'c']))
assert_equal(set(t['a'].keys()),
set(['translated_name', 'forward_transform', 'reverse_transform']))
assert_equal(t['a']['translated_name'], 'A')
assert_equal(t['a']['forward_transform'], 'a')
assert_equal(t['a']['reverse_transform'], 'A')
assert_equal(t['b']['translated_name'], 'B')
assert_equal(t['b']['forward_transform'], 'float(1000)*b')
assert_equal(t['b']['reverse_transform'], 'B/float(1000)')
assert_equal(t['c']['translated_name'], 'C')
assert_equal(t['c']['forward_transform'], 'c + a')
assert_equal(t['c']['reverse_transform'], 'C - A')
from functools import partial
from pyNN.standardmodels import build_translations
from pynn_spinnaker.standardmodels.cells import calc_max_neurons_per_core
# Import globals
from pynn_spinnaker.standardmodels.cells import (if_curr_neuron_translations,
if_curr_neuron_immutable_param_map,
if_curr_neuron_mutable_param_map)
# ----------------------------------------------------------------------------
# Synapse type translations
# ----------------------------------------------------------------------------
# Build translations from PyNN to SpiNNaker synapse model parameters
dual_exp_synapse_translations = build_translations(
("tau_syn_E", "tau_syn_e"),
("tau_syn_E2", "tau_syn_e2"),
("tau_syn_I", "tau_syn_i"),
)
# ----------------------------------------------------------------------------
# Synapse shaping region maps
# ----------------------------------------------------------------------------
dual_exp_synapse_immutable_param_map = [
("tau_syn_e", "u4", lazy_param_map.u032_exp_decay),
("tau_syn_e", "i4", lazy_param_map.s1615_exp_init),
("tau_syn_e2", "u4", lazy_param_map.u032_exp_decay),
("tau_syn_e2", "i4", lazy_param_map.s1615_exp_init),
("tau_syn_i", "u4", lazy_param_map.u032_exp_decay),
("tau_syn_i", "i4", lazy_param_map.s1615_exp_init),
]
''')
current_based_alpha_synapses = brian.Equations('''
die/dt = (2.7182818284590451*ye-ie)/tau_syn_e : nA
dye/dt = -ye/tau_syn_e : nA
dii/dt = (2.7182818284590451*yi-ii)/tau_syn_e : nA
dyi/dt = -yi/tau_syn_e : nA
i_syn = ie + ii : nA
tau_syn_e : ms
tau_syn_i : ms
''')
leaky_iaf_translations = build_translations(
('v_rest', 'v_rest', mV),
('v_reset', 'v_reset', mV),
('cm', 'c_m', nF),
('tau_m', 'tau_m', ms),
('tau_refrac', 'tau_refrac', ms),
('v_thresh', 'v_thresh', mV),
('i_offset', 'i_offset', nA))
adexp_iaf_translations = build_translations(
('v_rest', 'v_rest', mV),
('v_reset', 'v_reset', mV),
('cm', 'c_m', nF),
('tau_m', 'tau_m', ms),
('tau_refrac', 'tau_refrac', ms),
('v_thresh', 'v_thresh', mV),
('i_offset', 'i_offset', nA),
('a', 'a', nA),
('b', 'b', nA),
('delta_T', 'delta_T', mV),
# Import globals
from pynn_spinnaker.standardmodels.cells import (exp_synapse_translations,
exp_synapse_immutable_param_map,
exp_synapse_curr_mutable_param_map)
# ----------------------------------------------------------------------------
# Neuron type translations
# ----------------------------------------------------------------------------
# Build translations from PyNN to SpiNNaker neuron model parameters
if_curr_ca2_adaptive_neuron_translations = build_translations(
("tau_m", "tau_m"),
("cm", "r_membrane", "tau_m / cm", ""),
("v_rest", "v_rest"),
("v_thresh", "v_thresh"),
("v_reset", "v_reset"),
("tau_refrac", "tau_refrac"),
("tau_ca2", "tau_ca2"),
("i_offset", "i_offset"),
("i_alpha", "i_alpha"),
)
# ----------------------------------------------------------------------------
# Neuron region maps
# ----------------------------------------------------------------------------
# Build maps of where and how parameters need to be written into neuron regions
if_curr_ca2_adaptive_neuron_immutable_param_map = [
("v_thresh", "i4", lazy_param_map.s1615),
("v_reset", "i4", lazy_param_map.s1615),
("v_rest", "i4", lazy_param_map.s1615),
("i_offset", "i4", lazy_param_map.s1615),
"tau_z": 5.0, # Time constant of primary trace (ms)
"tau_p": 1000.0, # Time constant of probability trace (ms)
"f_max": 20.0, # Firing frequency representing certainty (Hz)
"phi": 0.05, # Scaling of intrinsic bias current from probability to current domain (nA)
"bias_enabled": True, # Are the learnt biases passed to the neuron
"plasticity_enabled": True # Is plasticity enabled
}
# ----------------------------------------------------------------------------
# Intrinsic plasticity translations
# ----------------------------------------------------------------------------
intrinsic_plasticity_translations = build_translations(
("tau_z", "tau_z"),
("tau_p", "tau_p"),
("f_max", "minus_a", "1000.0 / (f_max * (tau_p - tau_z))", ""),
("phi", "phi"),
("bias_enabled", "epsilon", "1000.0 / (f_max * tau_p)", ""),
("plasticity_enabled", "mode", "bias_enabled + (plasticity_enabled * 2)", "")
)
# ----------------------------------------------------------------------------
# Intrinsic plasticity region map
# ----------------------------------------------------------------------------
intrinsic_plasticity_param_map = [
("minus_a", "i4", s1813),
("phi", "i4", lazy_param_map.s1615),
("epsilon", "i4", s1813),
("tau_z", "i4", s1813_exp_decay),
("tau_p", "i4", s1813_exp_decay),
("mode", "u4", lazy_param_map.integer),
''')
current_based_alpha_synapses = brian.Equations('''
die/dt = (2.7182818284590451*ye-ie)/tau_syn_e : nA
dye/dt = -ye/tau_syn_e : nA
dii/dt = (2.7182818284590451*yi-ii)/tau_syn_e : nA
dyi/dt = -yi/tau_syn_e : nA
i_syn = ie + ii : nA
tau_syn_e : ms
tau_syn_i : ms
''')
leaky_iaf_translations = build_translations(
('v_rest', 'v_rest', mV),
('v_reset', 'v_reset', mV),
('cm', 'c_m', nF),
('tau_m', 'tau_m', ms),
('tau_refrac', 'tau_refrac', ms),
('v_thresh', 'v_thresh', mV),
('i_offset', 'i_offset', nA))
adexp_iaf_translations = build_translations(
('v_rest', 'v_rest', mV),
('v_reset', 'v_reset', mV),
('cm', 'c_m', nF),
('tau_m', 'tau_m', ms),
('tau_refrac', 'tau_refrac', ms),
('v_thresh', 'v_thresh', mV),
('i_offset', 'i_offset', nA),
('a', 'a', nA),
('b', 'b', nA),
('delta_T', 'delta_T', mV),
def test_translate_with_divide_by_zero_error():
M = StandardModelType
M.default_parameters = {"a": 22.2, "b": 33.3}
M.translations = build_translations(("a", "A"), ("b", "B", "b/0", "B*0"))
assert_raises(ZeroDivisionError, M.translate, {"a": 23.4, "b": 34.5})
def test_reverse_translate_with_invalid_transformation():
M = StandardModelType
M.translations = build_translations(("a", "A"), ("b", "B", "b + z", "B-Z"))
M.default_parameters = {"a": 22.2, "b": 33.3}
# really we should trap such errors in build_translations(), not in reverse_translate()
assert_raises(NameError, M.reverse_translate, {"A": 23.4, "B": 34.5})
def test_translate():
M = StandardModelType
M.default_parameters = {"a": 22.2, "b": 33.3, "c": 44.4}
M.translations = build_translations(("a", "A"), ("b", "B", 1000.0), ("c", "C", "c + a", "C - A"))
assert_equal(M.translate({"a": 23.4, "b": 34.5, "c": 45.6}), {"A": 23.4, "B": 34500.0, "C": 69.0})
def test_describe():
M = StandardModelType
M.default_parameters = {"a": 22.2, "b": 33.3, "c": 44.4}
M.translations = build_translations(("a", "A"), ("b", "B", 1000.0), ("c", "C", "c + a", "C - A"))
m = M({})
assert isinstance(m.describe(), basestring)
def test_computed_parameters():
M = StandardModelType
M.default_parameters = {"a": 22.2, "b": 33.3, "c": 44.4}
M.translations = build_translations(("a", "A"), ("b", "B", 1000.0), ("c", "C", "c + a", "C - A"))
assert_equal(M.computed_parameters(), ["c"])