def set_weights(self, weight=None, elist=None, distribution=None, parameters=None, noise_scale=None): ''' Set the synaptic weights. ..todo :: take elist into account in Connections.weights Parameters ---------- weight : float or class:`numpy.array`, optional (default: None) Value or list of the weights (for user defined weights). elist : class:`numpy.array`, optional (default: None) List of the edges (for user defined weights). distribution : class:`string`, optional (default: None) Type of distribution (choose among "constant", "uniform", "gaussian", "lognormal", "lin_corr", "log_corr"). parameters : dict, optional (default: {}) Dictionary containing the properties of the weight distribution. noise_scale : class:`int`, optional (default: None) Scale of the multiplicative Gaussian noise that should be applied on the weights. ''' if isinstance(weight, float): size = self.edge_nb() if elist is None else len(elist) weight = np.repeat(weight, size) elif not hasattr(weight, "__len__") and weight is not None: raise AttributeError('''Invalid `weight` value: must be either float, array-like or None.''') if distribution is None: distribution = self._w["distribution"] if parameters is None: parameters = self._w Connections.weights(self, elist=elist, wlist=weight, distribution=distribution, parameters=parameters, noise_scale=noise_scale)
def set_weights(self, elist=None, wlist=None, distrib=None, distrib_prop=None, correl=None, noise_scale=None): ''' Set the synaptic weights. @todo: take elist into account in Connections.weights Parameters ---------- elist : class:`numpy.array`, optional (default: None) List of the edges (for user defined weights). wlist : class:`numpy.array`, optional (default: None) List of the weights (for user defined weights). distrib : class:`string`, optional (default: None) Type of distribution (choose among "constant", "uniform", "gaussian", "lognormal", "lin_corr", "log_corr"). distrib_prop : dict, optional (default: {}) Dictoinary containing the properties of the weight distribution. correl : class:`string`, optional (default: None) Property to which the weights should be correlated. noise_scale : class:`int`, optional (default: None) Scale of the multiplicative Gaussian noise that should be applied on the weights. ''' if distrib is None: distrib = self._w["distrib"] if distrib_prop is None: distrib_prop = (self._w["distrib_prop"] if "distrib_prop" in self._w.keys() else {}) if correl is None: correl = self._w["correl"] if "correl" in self._w.keys() else None Connections.weights(self, elist=elist, wlist=wlist, distrib=distrib, correl=correl, distrib_prop=distrib_prop, noise_scale=noise_scale)
def _init_bioproperties(self, population): ''' Set the population attribute and link each neuron to its group. ''' if issubclass(population.__class__, NeuralPop): if population.is_valid: self._population = population nodes = population.size # create the delay attribute Connections.delays(self) else: raise AttributeError("NeuralPop is not valid (not all \ neurons are associated to a group).") else: raise AttributeError("Expected NeuralPop but received \ {}".format(pop.__class__.__name__))
def _init_spatial_properties(self, shape, positions=None, **kwargs): ''' Create the positions of the neurons from the graph `shape` attribute and computes the connections distances. ''' if shape is not None: shape.set_parent(self) self._shape = shape else: self._shape = Shape.rectangle(self,1,1) if positions is not None and positions.shape[1] != self.node_nb(): raise InvalidArgument("Wrong number of neurons in `positions`.") b_rnd_pos = True if not self.node_nb() or positions is None else False self._pos = self._shape.rnd_distrib() if b_rnd_pos else positions Connections.distances(self)
def set_delays(self, delay=None, elist=None, distribution=None, parameters=None, noise_scale=None): ''' Set the delay for spike propagation between neurons. ..todo :: take elist into account in Connections.delays Parameters ---------- delay : float or class:`numpy.array`, optional (default: None) Value or list of delays (for user defined delays). elist : class:`numpy.array`, optional (default: None) List of the edges (for user defined delays). distribution : class:`string`, optional (default: None) Type of distribution (choose among "constant", "uniform", "gaussian", "lognormal", "lin_corr", "log_corr"). parameters : dict, optional (default: {}) Dictionary containing the properties of the delay distribution. noise_scale : class:`int`, optional (default: None) Scale of the multiplicative Gaussian noise that should be applied on the delays. ''' if isinstance(delay, float): size = self.edge_nb() if elist is None else len(elist) delay = np.repeat(delay, size) elif not hasattr(delay, "__len__") and delay is not None: raise AttributeError('''Invalid `delay` value: must be either float, array-like or None.''') if distribution is None: distribution = self._w["distribution"] if parameters is None: parameters = self._w return Connections.delays(self, elist=elist, dlist=delay, distribution=distribution, parameters=parameters, noise_scale=noise_scale)
def make_network(graph, neural_pop): ''' Turn a :class:`~nngt.Graph` object into a :class:`~nngt.Network`, or a :class:`~nngt.SpatialGraph` into a :class:`~nngt.SpatialNetwork`. Parameters ---------- graph : :class:`~nngt.Graph` or :class:`~nngt.SpatialGraph` Graph to convert neural_pop : :class:`~nngt.NeuralPop` Population to associate to the new :class:`~nngt.Network` Notes ----- In-place operation that directly converts the original graph. ''' if isinstance(graph, SpatialGraph): graph.__class__ = SpatialNetwork else: graph.__class__ = Network graph.population = neural_pop Connections.delays(graph)
def set_types(self, syn_type, nodes=None, fraction=None): ''' Set the synaptic/connection types. .. warning :: The special "type" attribute cannot be modified when using graphs that inherit from the :class:`~nngt.Network` class. This is because for biological networks, neurons make only one kind of synapse, which is determined by the :class:`nngt.core.NeuralGroup` they belong to. Parameters ---------- syn_type : int or string Type of the connection among 'excitatory' (also `1`) or 'inhibitory' (also `-1`). nodes : int, float or list, optional (default: `None`) If `nodes` is an int, number of nodes of the required type that will be created in the graph (all connections from inhibitory nodes are inhibitory); if it is a float, ratio of `syn_type` nodes in the graph; if it is a list, ids of the `syn_type` nodes. fraction : float, optional (default: `None`) Fraction of the selected edges that will be set as `syn_type` (if `nodes` is not `None`, it is the fraction of the specified nodes' edges, otherwise it is the fraction of all edges in the graph). Returns ------- t_list : :class:`numpy.ndarray` List of the types in an order that matches the `edges` attribute of the graph. ''' inhib_nodes = nodes if syn_type == 'excitatory' or syn_type == 1: if issubclass(nodes.__class__, int): inhib_nodes = graph.node_nb() - nodes elif issubclass(nodes.__class__, float): inhib_nodes = 1./nodes elif hasattr(nodes, '__iter__'): inhib_nodes = list(range(graph.node_nb())) nodes.sort() for node in nodes[::-1]: del inhib_nodes[node] return Connections.types(self, inhib_nodes, fraction)