def set_weights_and_delays(self, weights, delays):
""" allows setting of the weights and delays at seperate times to the
init, also sets the dtypes correctly.....
:param weights:
:param delays:
:return:
"""
# set the data if not already set (supports none overriding via
# synapse data)
if self._weights is None:
self._weights = utility_calls.convert_param_to_numpy(
weights, len(self._conn_list))
if self._delays is None:
self._delays = utility_calls.convert_param_to_numpy(
delays, len(self._conn_list))
# if got data, build connlist with correct dtypes
if (self._weights is not None and self._delays is not None
and not self._converted_weights_and_delays):
# add weights and delays to the conn list
temp_conn_list = numpy.dstack(
(self._conn_list[:, 0], self._conn_list[:, 1], self._weights,
self._delays))[0]
self._conn_list = list()
for element in temp_conn_list:
self._conn_list.append(
(element[0], element[1], element[2], element[3]))
# set dtypes (cant we just set them within the array?)
self._conn_list = numpy.asarray(self._conn_list,
dtype=self.CONN_LIST_DTYPE)
self._converted_weights_and_delays = True
def __init__(
self, n_neurons,
# TODO: update parameters
threshold_value, prob_fire, seed, rng=None):
AbstractThresholdType.__init__(self)
self._n_neurons = n_neurons
# TODO: Store any parameters
self._threshold_value = utility_calls.convert_param_to_numpy(
threshold_value, n_neurons)
# Convert prob_fire to uint32 from [0,1]
self._prob_fire = int(utility_calls.convert_param_to_numpy(
prob_fire, n_neurons) * 0xFFFFFFFF)
print prob_fire
print self._prob_fire
# Get rng (if it hasn't been defined yet) using NumpyRNG
if rng is None:
rng = NumpyRNG(seed=seed)
# now get seed from rng
seed = [rng.randint(0xFFFFFFFF) for _ in range(4)]
print seed
# Validate the random seed here
utility_calls.validate_mars_kiss_64_seed(seed)
self._seed = utility_calls.convert_param_to_numpy(
seed, n_neurons*4)
def set_weights_and_delays(self, weights, delays):
# set the data if not already set (supports none overriding via
# synapse data)
if self._weights is None:
self._weights = convert_param_to_numpy(weights,
len(self._conn_list))
if self._delays is None:
self._delays = convert_param_to_numpy(delays, len(self._conn_list))
# if got data, build connlist with correct dtypes
if (self._weights is not None and self._delays is not None
and not self._converted_weights_and_delays):
# add weights and delays to the conn list
temp_conn_list = numpy.dstack(
(self._conn_list[:, 0], self._conn_list[:, 1], self._weights,
self._delays))[0]
self._conn_list = list()
for element in temp_conn_list:
self._conn_list.append(
(element[0], element[1], element[2], element[3]))
# set dtypes (cant we just set them within the array?)
self._conn_list = numpy.asarray(self._conn_list,
dtype=self.CONN_LIST_DTYPE)
self._converted_weights_and_delays = True
def __init__(
self,
n_neurons,
# TODO: update the parameters
i_offset,
my_neuron_parameter,
# TODO: update the state variables if required
v_init=-70.0):
AbstractNeuronModel.__init__(self)
AbstractContainsUnits.__init__(self)
self._units = {
'v_init': 'mV',
'my_neuron_parameter': 'mV',
'i_offset': 'nA'
}
self._n_neurons = n_neurons
# TODO: Store any parameters
self._i_offset = utility_calls.convert_param_to_numpy(
i_offset, n_neurons)
self._my_neuron_parameter = utility_calls.convert_param_to_numpy(
my_neuron_parameter, n_neurons)
# TODO: Store any state variables
self._v_init = utility_calls.convert_param_to_numpy(v_init, n_neurons)
def __init__(self, n_neurons, e_rev_E, e_rev_I):
AbstractInputType.__init__(self)
self._n_neurons = n_neurons
self._e_rev_E = utility_calls.convert_param_to_numpy(
e_rev_E, n_neurons)
self._e_rev_I = utility_calls.convert_param_to_numpy(
e_rev_I, n_neurons)
def __init__(self,
n_neurons,
tau_syn_E,
tau_syn_I,
initial_input_exc=0.0,
initial_input_inh=0.0):
AbstractSynapseType.__init__(self)
AbstractContainsUnits.__init__(self)
self._units = {
'tau_syn_E': "mV",
'tau_syn_I': 'mV',
'gsyn_exc': "uS",
'gsyn_inh': "uS"
}
self._n_neurons = n_neurons
self._tau_syn_E = utility_calls.convert_param_to_numpy(
tau_syn_E, n_neurons)
self._tau_syn_I = utility_calls.convert_param_to_numpy(
tau_syn_I, n_neurons)
self._initial_input_exc = utility_calls.convert_param_to_numpy(
initial_input_exc, n_neurons)
self._initial_input_inh = utility_calls.convert_param_to_numpy(
initial_input_inh, n_neurons)
def __init__(
self,
n_neurons,
# TODO: update the parameters
my_ex_synapse_parameter=0.1,
my_in_synapse_parameter=0.1,
my_exc_init=0.0,
my_inh_init=0.0):
AbstractSynapseType.__init__(self)
AbstractContainsUnits.__init__(self)
self._units = {
'my_ex_synapse_parameter': "mV",
'my_in_synapse_parameter': 'mV',
'my_exc_init': "uS",
'my_inh_init': "uS"
}
self._n_neurons = n_neurons
# TODO: Store the parameters
self._my_ex_synapse_parameter = utility_calls.convert_param_to_numpy(
my_ex_synapse_parameter, n_neurons)
self._my_in_synapse_parameter = utility_calls.convert_param_to_numpy(
my_in_synapse_parameter, n_neurons)
self._my_exc_init = utility_calls.convert_param_to_numpy(
my_exc_init, n_neurons)
self._my_inh_init = utility_calls.convert_param_to_numpy(
my_inh_init, n_neurons)
def __init__(self, n_neurons, machine_time_step, tau_syn_E, tau_syn_I):
AbstractSynapseType.__init__(self)
self._n_neurons = n_neurons
self._machine_time_step = machine_time_step
self._tau_syn_E = utility_calls.convert_param_to_numpy(
tau_syn_E, n_neurons)
self._tau_syn_I = utility_calls.convert_param_to_numpy(
tau_syn_I, n_neurons)
def __init__(self, n_neurons, machine_time_step,
tau_syn_E=5.0, tau_syn_I=5.0):
self._tau_syn_E = utility_calls.convert_param_to_numpy(tau_syn_E,
n_neurons)
self._tau_syn_I = utility_calls.convert_param_to_numpy(tau_syn_I,
n_neurons)
self._machine_time_step = machine_time_step
def __init__(self, n_neurons, machine_time_step, v_init, v_rest, tau_m, cm,
i_offset, v_reset, tau_refrac):
NeuronModelLeakyIntegrate.__init__(self, n_neurons, machine_time_step,
v_init, v_rest, tau_m, cm, i_offset)
self._v_reset = utility_calls.convert_param_to_numpy(
v_reset, n_neurons)
self._tau_refrac = utility_calls.convert_param_to_numpy(
tau_refrac, n_neurons)
def __init__(self, n_neurons, du_th, tau_th, v_thresh):
AbstractThresholdType.__init__(self)
self._n_neurons = n_neurons
self._du_th = utility_calls.convert_param_to_numpy(du_th, n_neurons)
self._tau_th = utility_calls.convert_param_to_numpy(tau_th, n_neurons)
self._v_thresh = utility_calls.convert_param_to_numpy(
v_thresh, n_neurons)
def __init__(self,
n_neurons,
constraints=none_pynn_default_parameters['constraints'],
label=none_pynn_default_parameters['label'],
rate=default_parameters['rate'],
start=default_parameters['start'],
duration=default_parameters['duration'],
seed=none_pynn_default_parameters['seed']):
ApplicationVertex.__init__(self, label, constraints,
self._model_based_max_atoms_per_core)
AbstractSpikeRecordable.__init__(self)
AbstractProvidesOutgoingPartitionConstraints.__init__(self)
AbstractChangableAfterRun.__init__(self)
SimplePopulationSettable.__init__(self)
ProvidesKeyToAtomMappingImpl.__init__(self)
config = globals_variables.get_simulator().config
# atoms params
self._n_atoms = n_neurons
self._seed = None
# check for changes parameters
self._change_requires_mapping = True
self._change_requires_neuron_parameters_reload = False
# Store the parameters
self._rate = utility_calls.convert_param_to_numpy(rate, n_neurons)
self._start = utility_calls.convert_param_to_numpy(start, n_neurons)
self._duration = utility_calls.convert_param_to_numpy(
duration, n_neurons)
self._time_to_spike = utility_calls.convert_param_to_numpy(
0, n_neurons)
self._rng = numpy.random.RandomState(seed)
self._machine_time_step = None
# Prepare for recording, and to get spikes
self._spike_recorder = MultiSpikeRecorder()
self._time_between_requests = config.getint("Buffers",
"time_between_requests")
self._receive_buffer_host = config.get("Buffers",
"receive_buffer_host")
self._receive_buffer_port = helpful_functions.read_config_int(
config, "Buffers", "receive_buffer_port")
self._minimum_buffer_sdram = config.getint("Buffers",
"minimum_buffer_sdram")
self._using_auto_pause_and_resume = config.getboolean(
"Buffers", "use_auto_pause_and_resume")
spike_buffer_max_size = 0
self._buffer_size_before_receive = None
if config.getboolean("Buffers", "enable_buffered_recording"):
spike_buffer_max_size = config.getint("Buffers",
"spike_buffer_size")
self._buffer_size_before_receive = config.getint(
"Buffers", "buffer_size_before_receive")
self._maximum_sdram_for_buffering = [spike_buffer_max_size]
def __init__(self, n_neurons, machine_time_step, primary, v_init=-70.0):
AbstractNeuronModel.__init__(self)
self._n_neurons = n_neurons
self._machine_time_step = machine_time_step
self._primary = utility_calls.convert_param_to_numpy(
primary, n_neurons)
self._v_init = utility_calls.convert_param_to_numpy(v_init, n_neurons)
def __init__(self, v_init, tau_m, cm, i_offset, atoms, v_rest, v_reset,
v_thresh, tau_refrac):
super(AbstractIntegrateAndFireProperties,
self).__init__(v_init, tau_m, cm, i_offset, atoms, v_rest)
self._v_reset = utility_calls.convert_param_to_numpy(v_reset, atoms)
self._v_thresh = utility_calls.convert_param_to_numpy(v_thresh, atoms)
self._tau_refrac = utility_calls.convert_param_to_numpy(
tau_refrac, atoms)
def __init__(self, n_neurons, machine_time_step, v_init, v_rest, tau_m, cm,
i_offset, v_reset, tau_refrac):
NeuronModelLeakyIntegrate.__init__(
self, n_neurons, machine_time_step, v_init, v_rest, tau_m, cm,
i_offset)
self._v_reset = utility_calls.convert_param_to_numpy(
v_reset, n_neurons)
self._tau_refrac = utility_calls.convert_param_to_numpy(
tau_refrac, n_neurons)
def test_convert_param_to_numpy_random_distribution(self):
random = RandomDistribution("uniform", [0, 1])
single_value = utility_calls.convert_param_to_numpy(random, 1)
multi_value = utility_calls.convert_param_to_numpy(random, 10)
self.assertTrue(hasattr(single_value, "__iter__"))
self.assertEqual(len(single_value), 1)
self.assertTrue(hasattr(multi_value, "__iter__"))
self.assertEqual(len(multi_value), 10)
def test_convert_param_to_numpy_random_distribution(self):
globals_variables.set_simulator(Spinnaker(timestep=1.0))
random = RandomDistribution("uniform", [0, 1])
single_value = utility_calls.convert_param_to_numpy(random, 1)
multi_value = utility_calls.convert_param_to_numpy(random, 10)
self.assertTrue(hasattr(single_value, "__iter__"))
self.assertEqual(len(single_value), 1)
self.assertTrue(hasattr(multi_value, "__iter__"))
self.assertEqual(len(multi_value), 10)
def __init__(self,
n_neurons,
constraints=non_pynn_default_parameters['constraints'],
label=non_pynn_default_parameters['label'],
rate=default_parameters['rate'],
start=default_parameters['start'],
duration=default_parameters['duration'],
seed=non_pynn_default_parameters['seed']):
# pylint: disable=too-many-arguments
super(SpikeSourcePoisson,
self).__init__(label, constraints,
self._model_based_max_atoms_per_core)
config = globals_variables.get_simulator().config
# atoms params
self._n_atoms = n_neurons
self._model_name = "SpikeSourcePoisson"
self._seed = None
# check for changes parameters
self._change_requires_mapping = True
self._change_requires_neuron_parameters_reload = False
# Store the parameters
self._rate = utility_calls.convert_param_to_numpy(rate, n_neurons)
self._start = utility_calls.convert_param_to_numpy(start, n_neurons)
self._duration = utility_calls.convert_param_to_numpy(
duration, n_neurons)
self._time_to_spike = utility_calls.convert_param_to_numpy(
0, n_neurons)
self._rng = numpy.random.RandomState(seed)
self._machine_time_step = None
# Prepare for recording, and to get spikes
self._spike_recorder = MultiSpikeRecorder()
self._time_between_requests = config.getint("Buffers",
"time_between_requests")
self._receive_buffer_host = config.get("Buffers",
"receive_buffer_host")
self._receive_buffer_port = helpful_functions.read_config_int(
config, "Buffers", "receive_buffer_port")
self._minimum_buffer_sdram = config.getint("Buffers",
"minimum_buffer_sdram")
self._using_auto_pause_and_resume = config.getboolean(
"Buffers", "use_auto_pause_and_resume")
spike_buffer_max_size = 0
self._buffer_size_before_receive = None
if config.getboolean("Buffers", "enable_buffered_recording"):
spike_buffer_max_size = config.getint("Buffers",
"spike_buffer_size")
self._buffer_size_before_receive = config.getint(
"Buffers", "buffer_size_before_receive")
self._maximum_sdram_for_buffering = [spike_buffer_max_size]
def __init__(self, n_neurons, machine_time_step, tau_syn_E, tau_syn_E2,
tau_syn_I):
AbstractSynapseType.__init__(self)
self._n_neurons = n_neurons
self._machine_time_step = machine_time_step
self._tau_syn_E = utility_calls.convert_param_to_numpy(
tau_syn_E, n_neurons)
self._tau_syn_E2 = utility_calls.convert_param_to_numpy(
tau_syn_E2, n_neurons)
self._tau_syn_I = utility_calls.convert_param_to_numpy(
tau_syn_I, n_neurons)
def __init__(self, n_neurons, machine_time_step, tau_ca2, i_ca2, i_alpha):
AbstractAdditionalInput.__init__(self)
self._n_neurons = n_neurons
self._machine_time_step = machine_time_step
self._tau_ca2 = utility_calls.convert_param_to_numpy(
tau_ca2, n_neurons)
self._i_ca2 = utility_calls.convert_param_to_numpy(i_ca2, n_neurons)
self._i_alpha = utility_calls.convert_param_to_numpy(
i_alpha, n_neurons)
def __init__(self, n_neurons, e_rev_E, e_rev_I):
AbstractInputType.__init__(self)
AbstractContainsUnits.__init__(self)
self._units = {"e_rev_I": "mV", "e_rev_E": "mV"}
self._n_neurons = n_neurons
self._e_rev_E = utility_calls.convert_param_to_numpy(
e_rev_E, n_neurons)
self._e_rev_I = utility_calls.convert_param_to_numpy(
e_rev_I, n_neurons)
def __init__(self,
n_neurons,
machine_time_step,
tau_syn_E=5.0,
tau_syn_I=5.0):
self._tau_syn_E = utility_calls.convert_param_to_numpy(
tau_syn_E, n_neurons)
self._tau_syn_I = utility_calls.convert_param_to_numpy(
tau_syn_I, n_neurons)
self._machine_time_step = machine_time_step
def __init__(self, n_neurons, constraints, label, rate, start, duration,
seed, max_atoms_per_core, model):
# pylint: disable=too-many-arguments
super(SpikeSourcePoissonVertex, self).__init__(label, constraints,
max_atoms_per_core)
config = globals_variables.get_simulator().config
# atoms params
self._n_atoms = n_neurons
self._model_name = "SpikeSourcePoisson"
self._model = model
self._seed = seed
self._kiss_seed = dict()
self._rng = None
self._n_subvertices = 0
self._n_data_specs = 0
# check for changes parameters
self._change_requires_mapping = True
self._change_requires_neuron_parameters_reload = False
# Store the parameters
self._rate = utility_calls.convert_param_to_numpy(rate, n_neurons)
self._rate_change = numpy.zeros(self._rate.size)
self._start = utility_calls.convert_param_to_numpy(start, n_neurons)
self._duration = utility_calls.convert_param_to_numpy(
duration, n_neurons)
self._time_to_spike = utility_calls.convert_param_to_numpy(
0, n_neurons)
self._machine_time_step = None
# Prepare for recording, and to get spikes
self._spike_recorder = MultiSpikeRecorder()
self._time_between_requests = config.getint("Buffers",
"time_between_requests")
self._receive_buffer_host = config.get("Buffers",
"receive_buffer_host")
self._receive_buffer_port = helpful_functions.read_config_int(
config, "Buffers", "receive_buffer_port")
self._minimum_buffer_sdram = config.getint("Buffers",
"minimum_buffer_sdram")
self._using_auto_pause_and_resume = config.getboolean(
"Buffers", "use_auto_pause_and_resume")
spike_buffer_max_size = 0
self._buffer_size_before_receive = None
if config.getboolean("Buffers", "enable_buffered_recording"):
spike_buffer_max_size = config.getint("Buffers",
"spike_buffer_size")
self._buffer_size_before_receive = config.getint(
"Buffers", "buffer_size_before_receive")
self._maximum_sdram_for_buffering = [spike_buffer_max_size]
def __init__(self, n_neurons, v_init, v_rest, tau_m, cm, i_offset, v_reset,
tau_refrac):
NeuronModelLeakyIntegrate.__init__(self, n_neurons, v_init, v_rest,
tau_m, cm, i_offset)
self._v_reset = utility_calls.convert_param_to_numpy(
v_reset, n_neurons)
self._tau_refrac = utility_calls.convert_param_to_numpy(
tau_refrac, n_neurons)
self._countdown_to_refactory_period = \
utility_calls.convert_param_to_numpy(0, n_neurons)
self._my_units = {'v_reset': 'mV', 'tau_refac': 'ms'}
def __init__(self, v_init, tau_m, cm, i_offset, atoms, v_rest):
self._tau_m = utility_calls.convert_param_to_numpy(tau_m, atoms)
self._cm = utility_calls.convert_param_to_numpy(cm, atoms)
self._i_offset = utility_calls.convert_param_to_numpy(i_offset, atoms)
self._atoms = atoms
self._v_rest = utility_calls.convert_param_to_numpy(v_rest, atoms)
# if v_init is not set to v_rest then set to v_init
self._v_init = v_rest
if v_init is not None:
self._v_init = \
utility_calls.convert_param_to_numpy(v_init, atoms)
def __init__(self, n_neurons, machine_time_step, tau_ca2, i_ca2, i_alpha):
AbstractAdditionalInput.__init__(self)
self._n_neurons = n_neurons
self._machine_time_step = machine_time_step
self._tau_ca2 = utility_calls.convert_param_to_numpy(
tau_ca2, n_neurons)
self._i_ca2 = utility_calls.convert_param_to_numpy(
i_ca2, n_neurons)
self._i_alpha = utility_calls.convert_param_to_numpy(
i_alpha, n_neurons)
def __init__(
self, n_neurons,
# TODO: update parameters
threshold_value, my_threshold_parameter):
AbstractThresholdType.__init__(self)
self._n_neurons = n_neurons
# TODO: Store any parameters
self._threshold_value = utility_calls.convert_param_to_numpy(
threshold_value, n_neurons)
self._my_threshold_parameter = utility_calls.convert_param_to_numpy(
my_threshold_parameter, n_neurons)
def __init__(self, n_neurons, machine_time_step, v_init, v_rest, tau_m, cm,
i_offset):
AbstractNeuronModel.__init__(self)
self._n_neurons = n_neurons
self._machine_time_step = machine_time_step
self._v_init = utility_calls.convert_param_to_numpy(v_init, n_neurons)
self._v_rest = utility_calls.convert_param_to_numpy(v_rest, n_neurons)
self._tau_m = utility_calls.convert_param_to_numpy(tau_m, n_neurons)
self._cm = utility_calls.convert_param_to_numpy(cm, n_neurons)
self._i_offset = utility_calls.convert_param_to_numpy(
i_offset, n_neurons)
if v_init is None:
self._v_init = v_rest
def __init__(self, n_neurons,
# TODO: update the parameters
my_ex_synapse_parameter=0.1,
my_in_synapse_parameter=0.1):
AbstractSynapseType.__init__(self)
self._n_neurons = n_neurons
# TODO: Store the parameters
self._my_ex_synapse_parameter = utility_calls.convert_param_to_numpy(
my_ex_synapse_parameter, n_neurons)
self._my_in_synapse_parameter = utility_calls.convert_param_to_numpy(
my_in_synapse_parameter, n_neurons)
def __init__(self, n_neurons, machine_time_step, v_init, v_rest, tau_m, cm,
i_offset):
AbstractNeuronModel.__init__(self)
self._n_neurons = n_neurons
self._machine_time_step = machine_time_step
self._v_init = utility_calls.convert_param_to_numpy(v_init, n_neurons)
self._v_rest = utility_calls.convert_param_to_numpy(v_rest, n_neurons)
self._tau_m = utility_calls.convert_param_to_numpy(tau_m, n_neurons)
self._cm = utility_calls.convert_param_to_numpy(cm, n_neurons)
self._i_offset = utility_calls.convert_param_to_numpy(
i_offset, n_neurons)
if v_init is None:
self._v_init = v_rest
def __init__(
self,
n_neurons,
# TODO: update parameters
threshold_value,
my_threshold_parameter):
AbstractThresholdType.__init__(self)
self._n_neurons = n_neurons
# TODO: Store any parameters
self._threshold_value = utility_calls.convert_param_to_numpy(
threshold_value, n_neurons)
self._my_threshold_parameter = utility_calls.convert_param_to_numpy(
my_threshold_parameter, n_neurons)
def initialize(self, variable, value):
"""
Set the initial value of one of the state variables of the neurons in
this population.
"""
self._vertex.initialize(variable, utility_calls.convert_param_to_numpy(
value, self._vertex.n_atoms))
def __setitem__(self, key, value):
# See if the object we're acting as surrogate for has this parameter
if not hasattr(self.vertex, key):
raise Exception("Object '%s' does not have parameter '%s'." %
(self.vertex, key))
value = utility_calls.convert_param_to_numpy(value,
self.vertex.n_atoms)
setattr(self.vertex, key, value)
def __init__(self, n_neurons, v_thresh):
AbstractThresholdType.__init__(self)
AbstractContainsUnits.__init__(self)
self._units = {'v_thresh': "mV"}
self._n_neurons = n_neurons
self._v_thresh = utility_calls.convert_param_to_numpy(
v_thresh, n_neurons)
def __init__(
self, n_neurons,
# TODO: update the parameters
i_offset, my_neuron_parameter,
# TODO: update the state variables if required
v_init=-70.0):
AbstractNeuronModel.__init__(self)
self._n_neurons = n_neurons
# TODO: Store any parameters
self._i_offset = utility_calls.convert_param_to_numpy(
i_offset, n_neurons)
self._my_neuron_parameter = utility_calls.convert_param_to_numpy(
my_neuron_parameter, n_neurons)
# TODO: Store any state variables
self._v_init = utility_calls.convert_param_to_numpy(v_init, n_neurons)
def initialize(self, variable, value):
""" Set the initial value of one of the state variables of the neurons\
in this population.
"""
if not isinstance(self._vertex, AbstractPopulationInitializable):
raise KeyError(
"Population does not support the initialisation of {}".format(
variable))
self._vertex.initialize(variable, utility_calls.convert_param_to_numpy(
value, self._vertex.n_atoms))
self._change_requires_mapping = True
def __init__(self, n_neurons, constraints, label, rate, max_rate, start,
duration, seed, max_atoms_per_core, model):
# pylint: disable=too-many-arguments
super(SpikeSourcePoissonVertex, self).__init__(label, constraints,
max_atoms_per_core)
# atoms params
self.__n_atoms = n_neurons
self.__model_name = "SpikeSourcePoisson"
self.__model = model
self.__seed = seed
self.__kiss_seed = dict()
self.__rng = None
self.__n_subvertices = 0
self.__n_data_specs = 0
# check for changes parameters
self.__change_requires_mapping = True
self.__change_requires_neuron_parameters_reload = False
self.__spike_recorder = MultiSpikeRecorder()
# Store the parameters
self.__max_rate = max_rate
self.__rate = self.convert_rate(rate)
self.__rate_change = numpy.zeros(self.__rate.size)
self.__start = utility_calls.convert_param_to_numpy(start, n_neurons)
self.__duration = utility_calls.convert_param_to_numpy(
duration, n_neurons)
self.__time_to_spike = utility_calls.convert_param_to_numpy(
0, n_neurons)
self.__machine_time_step = None
# get config from simulator
config = globals_variables.get_simulator().config
self.__n_profile_samples = helpful_functions.read_config_int(
config, "Reports", "n_profile_samples")
# Prepare for recording, and to get spikes
self.__spike_recorder = MultiSpikeRecorder()
def initialize(self, variable, value):
""" Set the initial value of one of the state variables of the neurons\
in this population.
"""
if not isinstance(self._vertex, AbstractPopulationInitializable):
raise KeyError(
"Population does not support the initialisation of {}".format(
variable))
self._vertex.initialize(
variable,
utility_calls.convert_param_to_numpy(value, self._vertex.n_atoms))
self._change_requires_mapping = True
def __init__(
self, n_neurons, machine_time_step, timescale_factor,
constraints=None, label="SpikeSourcePoisson", rate=1.0, start=0.0,
duration=None, seed=None):
AbstractPartitionableVertex.__init__(
self, n_neurons, label, self._model_based_max_atoms_per_core,
constraints)
AbstractDataSpecableVertex.__init__(
self, machine_time_step=machine_time_step,
timescale_factor=timescale_factor)
AbstractSpikeRecordable.__init__(self)
AbstractProvidesOutgoingPartitionConstraints.__init__(self)
PopulationSettableChangeRequiresMapping.__init__(self)
# Store the parameters
self._rate = utility_calls.convert_param_to_numpy(rate, n_neurons)
self._start = utility_calls.convert_param_to_numpy(start, n_neurons)
self._duration = utility_calls.convert_param_to_numpy(
duration, n_neurons)
self._rng = numpy.random.RandomState(seed)
# Prepare for recording, and to get spikes
self._spike_recorder = MultiSpikeRecorder(machine_time_step)
self._spike_buffer_max_size = config.getint(
"Buffers", "spike_buffer_size")
self._buffer_size_before_receive = config.getint(
"Buffers", "buffer_size_before_receive")
self._time_between_requests = config.getint(
"Buffers", "time_between_requests")
self._enable_buffered_recording = config.getboolean(
"Buffers", "enable_buffered_recording")
self._receive_buffer_host = config.get(
"Buffers", "receive_buffer_host")
self._receive_buffer_port = config.getint(
"Buffers", "receive_buffer_port")
self._minimum_buffer_sdram = config.getint(
"Buffers", "minimum_buffer_sdram")
self._using_auto_pause_and_resume = config.getboolean(
"Buffers", "use_auto_pause_and_resume")
def __init__(self, n_neurons, v_init, v_rest, tau_m, cm, i_offset):
AbstractNeuronModel.__init__(self)
AbstractContainsUnits.__init__(self)
self._units = {
'v_init': 'mV',
'v_rest': 'mV',
'tau_m': 'ms',
'cm': 'nF',
'i_offset': 'nA'
}
self._n_neurons = n_neurons
self._v_init = utility_calls.convert_param_to_numpy(v_init, n_neurons)
self._v_rest = utility_calls.convert_param_to_numpy(v_rest, n_neurons)
self._tau_m = utility_calls.convert_param_to_numpy(tau_m, n_neurons)
self._cm = utility_calls.convert_param_to_numpy(cm, n_neurons)
self._i_offset = utility_calls.convert_param_to_numpy(
i_offset, n_neurons)
if v_init is None:
self._v_init = self._v_rest
def convert_rate(self, rate):
new_rates = utility_calls.convert_param_to_numpy(rate, self._n_atoms)
new_max = max(new_rates)
if self._max_rate is None:
self._max_rate = new_max
# Setting record forces reset so ok to go over if not recording
elif self._spike_recorder.record and new_max > self._max_rate:
logger.info('Increasing spike rate while recording requires a '
'"reset unless additional_parameters "max_rate" is '
'set')
self._change_requires_mapping = True
self._max_rate = new_max
return new_rates
def __init__(
self, n_neurons, constraints, label, rate, max_rate, start,
duration, seed, max_atoms_per_core, model):
# pylint: disable=too-many-arguments
super(SpikeSourcePoissonVertex, self).__init__(
label, constraints, max_atoms_per_core)
# atoms params
self._n_atoms = n_neurons
self._model_name = "SpikeSourcePoisson"
self._model = model
self._seed = seed
self._kiss_seed = dict()
self._rng = None
self._n_subvertices = 0
self._n_data_specs = 0
# check for changes parameters
self._change_requires_mapping = True
self._change_requires_neuron_parameters_reload = False
# Prepare for recording, and to get spikes
self._spike_recorder = MultiSpikeRecorder()
# Store the parameters
self._max_rate = max_rate
self._rate = self.convert_rate(rate)
self._rate_change = numpy.zeros(self._rate.size)
self._start = utility_calls.convert_param_to_numpy(start, n_neurons)
self._duration = utility_calls.convert_param_to_numpy(
duration, n_neurons)
self._time_to_spike = utility_calls.convert_param_to_numpy(
0, n_neurons)
self._machine_time_step = None
# Prepare for recording, and to get spikes
self._spike_recorder = MultiSpikeRecorder()
def __init__(self, n_neurons, machine_time_step, a, b, c, d, v_init,
u_init, i_offset):
AbstractNeuronModel.__init__(self)
self._n_neurons = n_neurons
self._machine_time_step = machine_time_step
self._a = utility_calls.convert_param_to_numpy(a, n_neurons)
self._b = utility_calls.convert_param_to_numpy(b, n_neurons)
self._c = utility_calls.convert_param_to_numpy(c, n_neurons)
self._d = utility_calls.convert_param_to_numpy(d, n_neurons)
self._v_init = utility_calls.convert_param_to_numpy(v_init, n_neurons)
self._u_init = utility_calls.convert_param_to_numpy(u_init, n_neurons)
self._i_offset = utility_calls.convert_param_to_numpy(
i_offset, n_neurons)
def __init__(self, n_neurons, a=0.02, c=-65.0, b=0.2, d=2.0, i_offset=0,
u_init=-14.0, v_init=-70.0):
self._a = utility_calls.convert_param_to_numpy(a, n_neurons)
self._b = utility_calls.convert_param_to_numpy(b, n_neurons)
self._c = utility_calls.convert_param_to_numpy(c, n_neurons)
self._d = utility_calls.convert_param_to_numpy(d, n_neurons)
self._i_offset = utility_calls.convert_param_to_numpy(i_offset,
n_neurons)
self._u_init = utility_calls.convert_param_to_numpy(u_init,
n_neurons)
self._v_init = utility_calls.convert_param_to_numpy(v_init,
n_neurons)
self._atoms = n_neurons
def initialize_u(self, u_init):
self._u_init = utility_calls.convert_param_to_numpy(
u_init, self._n_neurons)
def duration(self, duration):
self._duration = utility_calls.convert_param_to_numpy(
duration, self._n_atoms)
def start(self, start):
self._start = utility_calls.convert_param_to_numpy(
start, self._n_atoms)
def e_rev_I(self, e_rev_I):
self._e_rev_I = utility_calls.convert_param_to_numpy(
e_rev_I, self._n_neurons)
def threshold_value(self, threshold_value):
self._threshold_value = utility_calls.convert_param_to_numpy(
threshold_value, self._n_neurons)
def a(self, a):
self._a = utility_calls.convert_param_to_numpy(a, self._n_neurons)
def b(self, b):
self._b = utility_calls.convert_param_to_numpy(b, self._n_neurons)
def c(self, c):
self._c = utility_calls.convert_param_to_numpy(c, self._n_neurons)
def initialize_u(self, value):
self._u_init = utility_calls.convert_param_to_numpy(value, self._atoms)
def e_rev_E(self, e_rev_E):
self._e_rev_E = utility_calls.convert_param_to_numpy(
e_rev_E, self._n_neurons)
def d(self, d):
self._d = utility_calls.convert_param_to_numpy(d, self._n_neurons)
def initialize_v(self, v_init):
self._v_init = utility_calls.convert_param_to_numpy(
v_init, self._n_neurons)
def my_threshold_parameter(self, my_threshold_parameter):
self._my_threshold_parameter = utility_calls.convert_param_to_numpy(
my_threshold_parameter, self._n_neurons)
def i_offset(self, i_offset):
self._i_offset = utility_calls.convert_param_to_numpy(
i_offset, self._n_neurons)
