def range_list_as_list(spec):
value = SpynnakerRangedList(size=10, value=_generator(10), key="test")
param = NeuronParameter(value, DataType.S1615)
iterator = param.iterator_by_slice(0, 5, spec)
values = _iterate_parameter_values(iterator, DataType.S1615)
assert list(value[0:5]) == values
assert isinstance(iterator, _Range_Iterator)
def get_neural_parameters(self, machine_time_step):
# pylint: disable=arguments-differ
return [
# membrane voltage [mV]
# REAL V_membrane;
NeuronParameter(self._data[V_INIT], _IF_TYPES.V_INIT.data_type),
# membrane resting voltage [mV]
# REAL V_rest;
NeuronParameter(self._data[V_REST], _IF_TYPES.V_REST.data_type),
# membrane resistance [MOhm]
# REAL R_membrane;
NeuronParameter(self._data[R_MEMBRANE],
_IF_TYPES.R_MEMBRANE.data_type),
# 'fixed' computation parameter - time constant multiplier for
# closed-form solution
# exp( -(machine time step in ms)/(R * C) ) [.]
# REAL exp_TC;
NeuronParameter(self._exp_tc(machine_time_step),
_IF_TYPES.EXP_TC.data_type),
# offset current [nA]
# REAL I_offset;
NeuronParameter(self._data[I_OFFSET], _IF_TYPES.I_OFFSET.data_type)
]
def single_value(spec):
value = 1.0
param = NeuronParameter(value, DataType.S1615)
iterator = param.iterator_by_slice(0, 5, spec)
values = _iterate_parameter_values(iterator, DataType.S1615)
assert [value] * 5 == values
assert isinstance(iterator, _SingleValue_Iterator)
def get_input_type_parameters(self):
return [
NeuronParameter(self._data[E_REV_E],
_CONDUCTANTCE_TYPES.E_REV_E.data_type),
NeuronParameter(self._data[E_REV_I],
_CONDUCTANTCE_TYPES.E_REV_I.data_type)
]
def get_neural_parameters(self):
# TODO: update to match the parameters and state variables
# Note: this must match the order of the parameters in the neuron_t
# data structure in the C code
return [
# REAL V;
NeuronParameter(self._v_init,
_MY_NEURON_MODEL_TYPES.V_INIT.data_type),
# REAL I_offset;
NeuronParameter(self._i_offset,
_MY_NEURON_MODEL_TYPES.I_OFFSET.data_type),
# REAL my_parameter;
NeuronParameter(self._my_neuron_parameter,
_MY_NEURON_MODEL_TYPES.
MY_NEURON_PARAMETER.data_type),
# REAL V_rest;
NeuronParameter(self._v_rest,
_MY_NEURON_MODEL_TYPES.V_REST.data_type),
# REAL decay;
NeuronParameter(self._decay,
_MY_NEURON_MODEL_TYPES.DECAY.data_type)
]
def real_list(spec):
value = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
param = NeuronParameter(value, DataType.S1615)
iterator = param.iterator_by_slice(0, 5, spec)
values = _iterate_parameter_values(iterator, DataType.S1615)
assert list(value[0:5]) == values
assert isinstance(iterator, _Get_Iterator)
def get_parameters(self, machine_time_step):
# pylint: disable=arguments-differ
return [
NeuronParameter(
self._exp_tau_ca2(machine_time_step),
_CA2_TYPES.EXP_TAU_CA2.data_type),
NeuronParameter(self._data[I_CA2], _CA2_TYPES.I_CA2.data_type),
NeuronParameter(self._data[I_ALPHA], _CA2_TYPES.I_ALPHA.data_type)]
def get_threshold_parameters(self):
return [
NeuronParameter(self._data[DU_TH_INV],
_MAASS_TYPES.DU_TH.data_type),
NeuronParameter(self._data[TAU_TH_INV],
_MAASS_TYPES.TAU_TH.data_type),
NeuronParameter(self._data[V_THRESH],
_MAASS_TYPES.V_THRESH.data_type)
]
def get_global_parameters(self, vertex_slice):
params = []
for variable in self._sampling_rates:
params.append(NeuronParameter(
self._sampling_rates[variable], DataType.UINT32))
for variable in self._sampling_rates:
n_recording = self._count_recording_per_slice(
variable, vertex_slice)
params.append(NeuronParameter(n_recording, DataType.UINT8))
return params
def get_synapse_type_parameters(self, machine_time_step):
# pylint: disable=arguments-differ
e_decay, e_init = get_exponential_decay_and_init(
self._data[TAU_SYN_E], machine_time_step)
e_decay2, e_init2 = get_exponential_decay_and_init(
self._data[TAU_SYN_E2], machine_time_step)
i_decay, i_init = get_exponential_decay_and_init(
self._data[TAU_SYN_I], machine_time_step)
return [
NeuronParameter(e_decay, _DUAL_EXP_TYPES.E_DECAY.data_type),
NeuronParameter(e_init, _DUAL_EXP_TYPES.E_INIT.data_type),
NeuronParameter(e_decay2, _DUAL_EXP_TYPES.E2_DECAY.data_type),
NeuronParameter(e_init2, _DUAL_EXP_TYPES.E2_INIT.data_type),
NeuronParameter(i_decay, _DUAL_EXP_TYPES.I_DECAY.data_type),
NeuronParameter(i_init, _DUAL_EXP_TYPES.I_INIT.data_type),
NeuronParameter(
self._data[INITIAL_INPUT_EXC],
_DUAL_EXP_TYPES.INITIAL_EXC.data_type),
NeuronParameter(
self._data[INITIAL_INPUT_EXC2],
_DUAL_EXP_TYPES.INITIAL_EXC2.data_type),
NeuronParameter(
self._data[INITIAL_INPUT_INH],
_DUAL_EXP_TYPES.INITIAL_INH.data_type)
]
def get_threshold_parameters(self):
# TODO: update to return the parameters
# Note: The order of the parameters must match the order in the
# threshold_type_t data structure in the C code
return [
NeuronParameter(self._threshold_value,
_MY_THRESHOLD_TYPES.THRESHOLD_VALUE.data_type),
NeuronParameter(
self._my_threshold_parameter,
_MY_THRESHOLD_TYPES.MY_THRESHOLD_PARAMETER.data_type)
]
def get_threshold_parameters(self):
# TODO: update to return the parameters
# Note: The order of the parameters must match the order in the
# threshold_type_t data structure in the C code
return [
NeuronParameter(self._threshold_value,
_MY_THRESHOLD_TYPES.THRESHOLD_VALUE.data_type),
NeuronParameter(self._prob_fire,
_MY_THRESHOLD_TYPES.PROB_FIRE.data_type),
NeuronParameter(self._seed,
_MY_THRESHOLD_TYPES.SEED.data_type)
]
def get_neural_parameters(self, machine_time_step):
# pylint: disable=arguments-differ
return [
# REAL A
NeuronParameter(self._data[A], _IZH_TYPES.A.data_type),
# REAL B
NeuronParameter(self._data[B], _IZH_TYPES.B.data_type),
# REAL C
NeuronParameter(self._data[C], _IZH_TYPES.C.data_type),
# REAL D
NeuronParameter(self._data[D], _IZH_TYPES.D.data_type),
# REAL V
NeuronParameter(self._data[V_INIT], _IZH_TYPES.V_INIT.data_type),
# REAL U
NeuronParameter(self._data[U_INIT], _IZH_TYPES.U_INIT.data_type),
# offset current [nA]
# REAL I_offset;
NeuronParameter(self._data[I_OFFSET],
_IZH_TYPES.I_OFFSET.data_type),
# current timestep - simple correction for threshold
# REAL this_h;
NeuronParameter(machine_time_step / 1000.0,
_IZH_TYPES.THIS_H.data_type)
]
def test_single_value():
MockSimulator.setup()
spec_writer = FileDataWriter("test.dat")
spec = DataSpecificationGenerator(spec_writer, None)
try:
value = 1.0
param = NeuronParameter(value, DataType.S1615)
iterator = param.iterator_by_slice(0, 5, spec)
values = _iterate_parameter_values(iterator, DataType.S1615)
assert [value] * 5 == values
assert isinstance(iterator, _SingleValue_Iterator)
finally:
spec.end_specification()
os.remove("test.dat")
def test_real_list():
MockSimulator.setup()
spec_writer = FileDataWriter("test.dat")
spec = DataSpecificationGenerator(spec_writer, None)
try:
value = range(10)
param = NeuronParameter(value, DataType.S1615)
iterator = param.iterator_by_slice(0, 5, spec)
values = _iterate_parameter_values(iterator, DataType.S1615)
assert list(value[0:5]) == values
assert isinstance(iterator, _Get_Iterator)
finally:
spec.end_specification()
os.remove("test.dat")
def test_range_list_as_list():
MockSimulator.setup()
spec_writer = FileDataWriter("test.dat")
spec = DataSpecificationGenerator(spec_writer, None)
try:
value = SpynnakerRangedList(size=10, value=_generator(10), key="test")
param = NeuronParameter(value, DataType.S1615)
iterator = param.iterator_by_slice(0, 5, spec)
values = _iterate_parameter_values(iterator, DataType.S1615)
assert list(value[0:5]) == values
assert isinstance(iterator, _Range_Iterator)
finally:
spec.end_specification()
os.remove("test.dat")
def test_single_value():
MockSimulator.setup()
spec_writer = FileDataWriter("test.dat")
spec = DataSpecificationGenerator(spec_writer, None)
try:
value = 1.0
param = NeuronParameter(value, DataType.S1615)
iterator = param.iterator_by_slice(0, 5, spec)
values = _iterate_parameter_values(iterator, DataType.S1615)
assert [value] * 5 == values
assert isinstance(iterator, _SingleValue_Iterator)
finally:
spec.end_specification()
os.remove("test.dat")
def test_real_list():
MockSimulator.setup()
spec_writer = FileDataWriter("test.dat")
spec = DataSpecificationGenerator(spec_writer, None)
try:
value = range(10)
param = NeuronParameter(value, DataType.S1615)
iterator = param.iterator_by_slice(0, 5, spec)
values = _iterate_parameter_values(iterator, DataType.S1615)
assert list(value[0:5]) == values
assert isinstance(iterator, _Get_Iterator)
finally:
spec.end_specification()
os.remove("test.dat")
def test_range_list_as_list():
MockSimulator.setup()
spec_writer = FileDataWriter("test.dat")
spec = DataSpecificationGenerator(spec_writer, None)
try:
value = SpynnakerRangedList(size=10, value=_generator(10), key="test")
param = NeuronParameter(value, DataType.S1615)
iterator = param.iterator_by_slice(0, 5, spec)
values = _iterate_parameter_values(iterator, DataType.S1615)
assert list(value[0:5]) == values
assert isinstance(iterator, _Range_Iterator)
finally:
spec.end_specification()
os.remove("test.dat")
def get_index_parameters(self, vertex_slice):
params = []
for variable in self._sampling_rates:
if self._sampling_rates[variable] > 0:
if self._indexes[variable] is None:
local_indexes = IndexIsValue()
else:
local_indexes = []
n_recording = sum((index >= vertex_slice.lo_atom
and index <= vertex_slice.hi_atom)
for index in self._indexes[variable])
indexes = self._indexes[variable]
local_index = 0
for index in xrange(vertex_slice.lo_atom,
vertex_slice.hi_atom + 1):
if index in indexes:
local_indexes.append(local_index)
local_index += 1
else:
# write to one beyond recording range
local_indexes.append(n_recording)
else:
local_indexes = 0
params.append(NeuronParameter(local_indexes, DataType.UINT8))
return params
def get_parameters(self):
""" Get the parameters for the additional input
:return: An array of parameters
:rtype: array of\
:py:class:`spynnaker.pyNN.models.neural_properties.neural_parameter.NeuronParameter`
"""
# TODO: update the parameters
# Note: must match the order of the additional_input_t structure in
# the C code
return [
NeuronParameter(0, DataType.S1615),
NeuronParameter(
self._my_additional_input_parameter,
_MY_ADDITIONAL_INPUT_TYPES.MY_ADDITIONAL_INPUT_PARAMETER.
data_type)
]
def get_neural_parameters(self):
def _get_var(item):
return getattr(self, '_' + item.name.lower())
# Note: must match the order of parameters in `neuron_t' in C
return [
NeuronParameter(_get_var(item), item.data_type)
for item in _NeuralParameters
]
def get_global_parameters(self, machine_time_step):
# TODO: update to match the global parameters
# Note: This must match the order of the parameters in the
# global_neuron_t data structure in the C code
return [
# uint32_t machine_time_step
NeuronParameter(machine_time_step, DataType.UINT32)
]
def get_neural_parameters(self, machine_time_step):
params = super(NeuronModelLeakyIntegrateAndFire,
self).get_neural_parameters()
params.extend([
# count down to end of next refractory period [timesteps]
# int32_t refract_timer;
NeuronParameter(self._data[COUNTDOWN_TO_REFRACTORY_PERIOD],
_LIF_TYPES.REFRACT_COUNT.data_type),
# post-spike reset membrane voltage [mV]
# REAL V_reset;
NeuronParameter(self._data[V_RESET], _LIF_TYPES.V_RESET.data_type),
# refractory time of neuron [timesteps]
# int32_t T_refract;
NeuronParameter(self._tau_refrac_timesteps(machine_time_step),
_LIF_TYPES.TAU_REFRACT.data_type)
])
return params
def get_global_parameters(self, machine_time_step):
def _get_var(item):
name = item.name.lower()
if name == 'machine_time_step':
return machine_time_step
return getattr(self, '_' + name)
# Note: must match the order of the parameters in the `global_neuron_t' in the C code
return [
NeuronParameter(_get_var(item), item.data_type)
for item in _GLOBAL_PARAMETERS
]
def get_threshold_parameters(self):
timings = [device.device_control_timesteps_between_sending
for device in self._devices]
max_time = max(timings)
time_between_send = int(max_time) // len(self._devices)
return [
NeuronParameter(
[device.device_control_key for device in self._devices],
_THRESHOLD_TYPE_MULTICAST.DEVICE_CONTROL_KEY.data_type),
NeuronParameter(
[1 if device.device_control_uses_payload else 0
for device in self._devices],
_THRESHOLD_TYPE_MULTICAST.DEVICE_CONTROLS_USES_PAYLOAD
.data_type),
NeuronParameter(
[device.device_control_min_value for device in self._devices],
_THRESHOLD_TYPE_MULTICAST.DEVICE_CONTROL_MIN_VALUE.data_type),
NeuronParameter(
[device.device_control_max_value for device in self._devices],
_THRESHOLD_TYPE_MULTICAST.DEVICE_CONTROL_MAX_VALUE.data_type),
NeuronParameter(
timings,
_THRESHOLD_TYPE_MULTICAST
.DEVICE_CONTROL_TIMESTEPS_BETWEEN_SENDING.data_type),
# This is the "state" variable that keeps track of how many
# timesteps to go before a send is done
# Initially set this to a different number for each device, to
# avoid them being in step with each other
NeuronParameter(
[i * time_between_send for i, _ in enumerate(self._devices)],
_THRESHOLD_TYPE_MULTICAST.DEVICE_STATE.data_type)
]
def get_synapse_type_parameters(self, machine_time_step):
e_decay, e_init = get_exponential_decay_and_init(
self._tau_syn_E, machine_time_step)
i_decay, i_init = get_exponential_decay_and_init(
self._tau_syn_I, machine_time_step)
return [
NeuronParameter(e_decay, _EXP_TYPES.E_DECAY.data_type),
NeuronParameter(e_init, _EXP_TYPES.E_INIT.data_type),
NeuronParameter(i_decay, _EXP_TYPES.I_DECAY.data_type),
NeuronParameter(i_init, _EXP_TYPES.I_INIT.data_type),
NeuronParameter(
self._initial_input_exc, _EXP_TYPES.INITIAL_EXC.data_type),
NeuronParameter(
self._initial_input_inh, _EXP_TYPES.INITIAL_INH.data_type)
]
def get_synapse_type_parameters(self, machine_time_step):
e_decay, e_init = get_exponential_decay_and_init(
self._my_ex_synapse_parameter, machine_time_step)
i_decay, i_init = get_exponential_decay_and_init(
self._my_in_synapse_parameter, machine_time_step)
# TODO: update to return the parameters
# Note: The order of the parameters must match the order in the
# synapse_param_t data structure in the C code
return [
NeuronParameter(e_decay, _MY_SYNAPSE_TYPES.E_DECAY.data_type),
NeuronParameter(e_init, _MY_SYNAPSE_TYPES.E_INIT.data_type),
NeuronParameter(i_decay, _MY_SYNAPSE_TYPES.I_DECAY.data_type),
NeuronParameter(i_init, _MY_SYNAPSE_TYPES.I_INIT.data_type),
NeuronParameter(self._my_exc_init,
_MY_SYNAPSE_TYPES.INITIAL_EXC.data_type),
NeuronParameter(self._my_inh_init,
_MY_SYNAPSE_TYPES.INITIAL_INH.data_type),
]
def get_synapse_type_parameters(self):
return [
NeuronParameter(self._data[INITIAL_INPUT_EXC], DataType.S1615),
NeuronParameter(self._data[INITIAL_INPUT_INH], DataType.S1615)
]
def get_global_parameters(self, machine_time_step):
# pylint: disable=arguments-differ
return [
NeuronParameter(machine_time_step / 1000.0,
_IZH_GLOBAL_TYPES.TIMESTEP.data_type)
]
def get_threshold_parameters(self):
return [
NeuronParameter(self._data[V_THRESH],
_STATIC_TYPES.V_THRESH.data_type)
]
def get_neural_parameters(self):
# Note: must match the order of the parameters in the `neuron_t' in the C code
return [
NeuronParameter(getattr(self, '_' + item.name.lower()),
item.data_type) for item in _NEURAL_PARAMETERS
]
