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)