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 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 ]