def __init__(self, n_boards, config): self._ip_addresses = config.get("Machine", "machineName") self._bmp_details = config.get("Machine", "bmp_names") self._width = 8 self._height = 8 if n_boards != 1: raise InvalidParameterType("Not enough machine size")
def get_value(self, key): """ Get a property """ if hasattr(self, key): return getattr(self, key) raise InvalidParameterType( "Type {} does not have parameter {}".format(type(self), key))
def _clear_recording(self, variables): for variable in variables: if variable == SPIKES: self._population._vertex.clear_spike_recording( get_simulator().buffer_manager, get_simulator().placements, get_simulator().graph_mapper) elif variable == MEMBRANE_POTENTIAL: self._population._vertex.clear_v_recording( get_simulator().buffer_manager, get_simulator().placements, get_simulator().graph_mapper) elif variable == GSYN_EXCIT: self._population._vertex.clear_gsyn_inhibitory_recording( get_simulator().buffer_manager, get_simulator().placements, get_simulator().graph_mapper) elif variable == GSYN_INHIB: self._population._vertex.clear_gsyn_excitatory_recording( get_simulator().buffer_manager, get_simulator().placements, get_simulator().graph_mapper) else: raise InvalidParameterType( "The variable {} is not a recordable value".format( variable))
def __init__(self, pre_synaptic_population, post_synaptic_population, connector, synapse_type=None, source=None, receptor_type=None, space=None, label=None): # pylint: disable=too-many-arguments if source is not None: raise InvalidParameterType( "sPyNNaker8 {} does not yet support multi-compartmental " "cells.".format(__version__)) self._check_population_param(pre_synaptic_population) self._check_population_param(post_synaptic_population) # set space object if not set if space is None: space = PyNNSpace() # set the simulator object correctly. self._simulator = globals_variables.get_simulator() if synapse_type is None: synapse_type = SynapseDynamicsStatic() # move weights and delays over to the connector to satisfy PyNN 8 # and 7 compatibility connector.set_weights_and_delays(synapse_type.weight, synapse_type.delay) connector.set_space(space) # as a from list connector can have plastic parameters, grab those ( # if any and add them to the synapse dynamics object) if isinstance(connector, FromListConnector): synapse_plastic_parameters = connector.get_extra_parameters() if synapse_plastic_parameters is not None: for parameter in synapse_plastic_parameters.dtype.names: synapse_type.set_value( parameter, synapse_plastic_parameters[:, parameter]) # set rng if needed rng = None if hasattr(connector, "rng"): rng = connector.rng super(Projection, self).__init__( connector=connector, synapse_dynamics_stdp=synapse_type, target=receptor_type, spinnaker_control=self._simulator, pre_synaptic_population=pre_synaptic_population, post_synaptic_population=post_synaptic_population, rng=rng, machine_time_step=self._simulator.machine_time_step, user_max_delay=self._simulator.max_delay, label=label, time_scale_factor=self._simulator.time_scale_factor)
def set_value(self, key, value): for obj in [self.__timing_dependence, self.__weight_dependence, self]: if hasattr(obj, key): setattr(obj, key, value) self.__change_requires_mapping = True return raise InvalidParameterType("Type {} does not have parameter {}".format( type(self), key))
def get_value(self, key): """ Get a property of the overall model. """ if key not in self._parameters: raise InvalidParameterType( "Population {} does not have parameter {}".format( self.__neuron_impl.model_name, key)) return self._parameters[key]
def get_value(self, key): """ Get a property """ for obj in [self.__timing_dependence, self.__weight_dependence, self]: if hasattr(obj, key): return getattr(obj, key) raise InvalidParameterType( "Type {} does not have parameter {}".format(type(self), key))
def set_value(self, key, value): """ Set a property of the overall model. """ if key not in self._parameters: raise InvalidParameterType( "Population {} does not have parameter {}".format( self.__neuron_impl.model_name, key)) self._parameters.set_value(key, value) self.__change_requires_neuron_parameters_reload = True
def set_value(self, key, value): """ Set a property :param key: the name of the parameter to change :param value: the new value of the parameter to assign """ if hasattr(self, key): setattr(self, key, value) self.__change_requires_mapping = True raise InvalidParameterType( "Type {} does not have parameter {}".format(type(self), key))
def set_value(self, key, value): """ Set a property of the overall model """ for obj in [ self._neuron_model, self._input_type, self._threshold_type, self._synapse_manager.synapse_type, self._additional_input ]: if hasattr(obj, key): setattr(obj, key, value) self._change_requires_neuron_parameters_reload = True return raise InvalidParameterType("Type {} does not have parameter {}".format( type(self), key))
def set_value(self, key, value): """ Set a property :param key: the name of the parameter to change :param value: the new value of the parameter to assign """ for obj in [self.__timing_dependence, self.__weight_dependence, self]: if hasattr(obj, key): setattr(obj, key, value) self.__change_requires_mapping = True return raise InvalidParameterType( "Type {} does not have parameter {}".format(type(self), key))
def get_units(self, variable): # search the model components for the variable for obj in [ self._neuron_model, self._input_type, self._threshold_type, self._synapse_manager.synapse_type, self._additional_input ]: if (hasattr(obj, variable) and isinstance(obj, AbstractContainsUnits)): return obj.unit(variable) # if not in the components, must be within myself, so call my own units if variable in self._units: return self._units[variable] else: raise InvalidParameterType( "The parameter {} does not exist in this input " "conductance component".format(variable))
def __init__(self, conn_list, safe=True, verbose=False): """ Creates a new FromListConnector. """ super(FromListConnector, self).__init__(safe, verbose) if conn_list is None or not len(conn_list): raise InvalidParameterType( "The connection list for the FromListConnector must contain" " at least a list of tuples, each of which should contain:" " (pre_idx, post_idx)") self._conn_list = conn_list # supports setting these at different times self._weights = None self._delays = None self._converted_weights_and_delays = False
def _clear_recording(self, variables): sim = get_simulator() for variable in variables: if variable == SPIKES: self.__vertex.clear_spike_recording(sim.buffer_manager, sim.placements) elif variable == MEMBRANE_POTENTIAL: self.__vertex.clear_recording(variable, sim.buffer_manager, sim.placements) elif variable == GSYN_EXCIT: self.__vertex.clear_recording(variable, sim.buffer_manager, sim.placements) elif variable == GSYN_INHIB: self.__vertex.clear_recording(variable, sim.buffer_manager, sim.placements) else: raise InvalidParameterType( "The variable {} is not a recordable value".format( variable))
def __init__(self, conn_list, safe=True, verbose=False): """ :param: conn_list: a list of tuples, one tuple for each connection. Each\ tuple should contain:: (pre_idx, post_idx, weight, delay) where pre_idx is the index (i.e. order in the Population,\ not the ID) of the presynaptic neuron, and post_idx is\ the index of the postsynaptic neuron. """ super(FromListConnector, self).__init__(safe, verbose) if conn_list is None or not len(conn_list): raise InvalidParameterType( "The connection list for the FromListConnector must contain" " at least a list of tuples, each of which should contain:" " (pre_idx, post_idx)") self._conn_list = conn_list # supports setting these at different times self._weights = None self._delays = None self._converted_weights_and_delays = False
def conn_list(self, conn_list): if conn_list is None or not len(conn_list): self.__conn_list = numpy.zeros((0, 2), dtype="uint32") else: self.__conn_list = numpy.array(conn_list) # If the shape of the conn_list is 2D, numpy has been able to create # a 2D array which means every entry has the same number of values. # If this was not possible, raise an exception! if len(self.__conn_list.shape) != 2: raise InvalidParameterType( "Each tuple in the connection list for the" " FromListConnector must have the same number of elements") # This tells us how many columns are in the list n_columns = self.__conn_list.shape[1] if n_columns < 2: raise InvalidParameterType( "Each tuple in the connection list for the" " FromListConnector must have at least 2 elements") if (self.__column_names is not None and n_columns != len(self.__column_names) + _FIRST_PARAM): raise InvalidParameterType( "The number of column names must match the number of" " additional elements in each tuple in the connection list," " not including the pre_idx or post_idx") # Get the column names if not specified column_names = self.__column_names if self.__column_names is None: if n_columns == 4: column_names = ('weight', 'delay') elif n_columns == 2: column_names = () else: raise TypeError( "Need to set 'column_names' for n_columns={}".format( n_columns)) # Set the source and targets self.__sources = self.__conn_list[:, _SOURCE] self.__targets = self.__conn_list[:, _TARGET] # Find any weights self.__weights = None try: weight_column = column_names.index('weight') + _FIRST_PARAM self.__weights = self.__conn_list[:, weight_column] except ValueError: pass # Find any delays self.__delays = None try: delay_column = column_names.index('delay') + _FIRST_PARAM machine_time_step = globals_variables.get_simulator( ).machine_time_step self.__delays = ( numpy.rint( numpy.array(self.__conn_list[:, delay_column]) * (MICRO_TO_MILLISECOND_CONVERSION / machine_time_step)) * (machine_time_step / MICRO_TO_MILLISECOND_CONVERSION)) except ValueError: pass # Find extra columns extra_columns = list() for i, name in enumerate(column_names): if name not in ('weight', 'delay'): extra_columns.append(i + _FIRST_PARAM) # Check any additional parameters have single values over the whole # set of connections (as other things aren't currently supported for i in extra_columns: # numpy.ptp gives the difference between the maximum and # minimum values of an array, so if 0, all values are equal if numpy.ptp(self.__conn_list[:, i]): raise ValueError( "All values in column {} ({}) of a FromListConnector must" " have the same value".format( i, column_names[i - _FIRST_PARAM])) # Store the extra data self.__extra_parameters = None self.__extra_parameter_names = None if extra_columns: self.__extra_parameters = self.__conn_list[:, extra_columns] self.__extra_parameter_names = [ column_names[i - _FIRST_PARAM] for i in extra_columns ]
def __init__(self, pre_synaptic_population, post_synaptic_population, connector, synapse_type=None, source=None, receptor_type=None, space=None, label=None): # pylint: disable=too-many-arguments if source is not None: raise InvalidParameterType( "sPyNNaker8 {} does not yet support multi-compartmental " "cells.".format(__version__)) self._check_population_param(pre_synaptic_population) self._check_population_param(post_synaptic_population) # set space object if not set if space is None: space = PyNNSpace() # set the simulator object correctly. self.__simulator = globals_variables.get_simulator() # set label self.__label = label if label is None: # set the projection's label here, but allow the edge label # to be set lower down if necessary self.__label = "from pre {} to post {} with connector {}".format( pre_synaptic_population.label, post_synaptic_population.label, connector) if synapse_type is None: synapse_type = SynapseDynamicsStatic() # set the space function as required connector.set_space(space) # as a from list connector can have plastic parameters, grab those ( # if any and add them to the synapse dynamics object) if isinstance(connector, FromListConnector): synapse_plastic_parameters = connector.get_extra_parameters() if synapse_plastic_parameters is not None: for i, parameter in enumerate( connector.get_extra_parameter_names()): synapse_type.set_value(parameter, synapse_plastic_parameters[:, i]) # set rng if needed rng = None if hasattr(connector, "rng"): rng = connector.rng super(Projection, self).__init__( connector=connector, synapse_dynamics_stdp=synapse_type, target=receptor_type, spinnaker_control=self.__simulator, pre_synaptic_population=pre_synaptic_population, post_synaptic_population=post_synaptic_population, rng=rng, machine_time_step=self.__simulator.machine_time_step, user_max_delay=self.__simulator.max_delay, label=label, time_scale_factor=self.__simulator.time_scale_factor)
def set_value(self, key, value): if hasattr(self, key): setattr(self, key, value) self.__change_requires_mapping = True raise InvalidParameterType("Type {} does not have parameter {}".format( type(self), key))