def _get_n_connections(self, pre_vertex_slice, post_vertex_slice): # do the work from self._cset in here # get the values for this slice pre_lo = pre_vertex_slice.lo_atom pre_hi = pre_vertex_slice.hi_atom post_lo = post_vertex_slice.lo_atom post_hi = post_vertex_slice.hi_atom # this is where the magic needs to happen somehow if self._full_cset is None: self._full_cset = [ x for x in csa.cross(range(self._n_pre_neurons), range(self._n_post_neurons)) * self._cset ] # use CSA to cross the range of this vertex's neurons with the cset pair_list = csa.cross(range(pre_lo, pre_hi + 1), range(post_lo, post_hi + 1)) * self._full_cset if self._verbose: print('full cset: ', self._full_cset) print('this vertex pair_list: ', pair_list) print('this vertex pre_neurons: ', [x[0] for x in pair_list]) print('this vertex post_neurons: ', [x[1] for x in pair_list]) n_connections = len(pair_list) # size of the array created return n_connections, pair_list
def _get_n_connections( self, pre_vertex_slice, post_vertex_slice, synapse_info): """ :param ~pacman.model.graphs.common.Slice pre_vertex_slice: :param ~pacman.model.graphs.common.Slice post_vertex_slice: :param SynapseInformation synapse_info: :rtype: tuple(int, cset.connset.CSet) """ # do the work from self._cset in here # this is where the magic needs to happen somehow if self.__full_cset is None: self.__full_cset = [x for x in csa.cross( range(synapse_info.n_pre_neurons), range(synapse_info.n_post_neurons)) * self.__cset] # use CSA to cross the range of this vertex's neurons with the cset pair_list = csa.cross( range(pre_vertex_slice.lo_atom, pre_vertex_slice.hi_atom+1), range(post_vertex_slice.lo_atom, post_vertex_slice.hi_atom+1)) \ * self.__full_cset if self.verbose: print('full cset: ', self.__full_cset) print('this vertex pair_list: ', pair_list) print('this vertex pre_neurons: ', [x[0] for x in pair_list]) print('this vertex post_neurons: ', [x[1] for x in pair_list]) n_connections = len(pair_list) # size of the array created return n_connections, pair_list
def _get_n_connections(self, pre_vertex_slice, post_vertex_slice): # do the work from self._cset in here # get the values for this slice pre_lo = pre_vertex_slice.lo_atom pre_hi = pre_vertex_slice.hi_atom post_lo = post_vertex_slice.lo_atom post_hi = post_vertex_slice.hi_atom # this is where the magic needs to happen somehow if self._full_cset is None: self._full_cset = [x for x in csa.cross( range(self._n_pre_neurons), range(self._n_post_neurons)) * self._cset] # use CSA to cross the range of this vertex's neurons with the cset pair_list = csa.cross( range(pre_lo, pre_hi+1), range(post_lo, post_hi+1)) * self._full_cset if self._verbose: print('full cset: ', self._full_cset) print('this vertex pair_list: ', pair_list) print('this vertex pre_neurons: ', [x[0] for x in pair_list]) print('this vertex post_neurons: ', [x[1] for x in pair_list]) n_connections = len(pair_list) # size of the array created return n_connections, pair_list
def connect(self, projection): """Connect-up a Projection.""" # Cut out finite part c = csa.cross((0, projection.pre.size - 1), (0, projection.post.size - 1)) * self.cset if csa.arity(self.cset) == 2: # Connection-set with arity 2 for (i, j, weight, delay) in c: projection.connection_manager.connect(projection.pre[i], [projection.post[j]], weight, delay) elif CSAConnector.isConstant (self.weights) \ and CSAConnector.isConstant (self.delays): # Mask with constant weights and delays for (i, j) in c: projection.connection_manager.connect(projection.pre[i], [projection.post[j]], self.weights, self.delays) else: # Mask with weights and/or delays iterable weights = self.weights if CSAConnector.isConstant(weights): weights = CSAConnector.constantIterator(weights) delays = self.delays if CSAConnector.isConstant(delays): delays = CSAConnector.constantIterator(delays) for (i, j), weight, delay in zip(c, weights, delays): projection.connection_manager.connect(projection.pre[i], [projection.post[j]], weight, delay)
def connect(self, projection): """Connect-up a Projection.""" if self.delays is None: self.delays = projection._simulator.state.min_delay # Cut out finite part c = csa.cross( (0, projection.pre.size - 1), (0, projection.post.size - 1)) * self.cset # can't we cut out just the columns we want? if csa.arity(self.cset) == 2: # Connection-set with arity 2 for (i, j, weight, delay) in c: projection._convergent_connect([projection.pre[i]], projection.post[j], weight, delay) elif CSAConnector.isConstant (self.weights) \ and CSAConnector.isConstant (self.delays): # Mask with constant weights and delays for (i, j) in c: projection._convergent_connect([projection.pre[i]], projection.post[j], self.weights, self.delays) else: # Mask with weights and/or delays iterable weights = self.weights if CSAConnector.isConstant(weights): weights = repeat(weights) delays = self.delays if CSAConnector.isConstant(delays): delays = repeat(delays) for (i, j), weight, delay in zip(c, weights, delays): projection._convergent_connect([projection.pre[i]], projection.post[j], weight, delay)
def connect(self, projection): """Connect-up a Projection.""" if self.delays is None: self.delays = projection._simulator.state.min_delay # Cut out finite part c = csa.cross((0, projection.pre.size-1), (0, projection.post.size-1)) * self.cset # can't we cut out just the columns we want? if csa.arity(self.cset) == 2: # Connection-set with arity 2 for (i, j, weight, delay) in c: projection._convergent_connect([projection.pre[i]], projection.post[j], weight, delay) elif CSAConnector.isConstant (self.weights) \ and CSAConnector.isConstant (self.delays): # Mask with constant weights and delays for (i, j) in c: projection._convergent_connect([projection.pre[i]], projection.post[j], self.weights, self.delays) else: # Mask with weights and/or delays iterable weights = self.weights if CSAConnector.isConstant(weights): weights = repeat(weights) delays = self.delays if CSAConnector.isConstant(delays): delays = repeat(delays) for (i, j), weight, delay in zip (c, weights, delays): projection._convergent_connect([projection.pre[i]], projection.post[j], weight, delay)
def _connect(self): '''Connect populations.''' finite_set = csa.cross(xrange(self._N_s), xrange(self._N_t)) if self._fan == 'in': self._cs = csa.cset(csa.random(fanIn=self._C) * finite_set) else: self._cs = csa.cset(csa.random(fanOut=self._C) * finite_set)
def _connect(self): '''Connect populations.''' sigma = self._params['sigma'] cutoff = self._max_dist self._cs = csa.cset( csa.cross([0], xrange(self._N - 1)) * (csa.random * (csa.gaussian(sigma, cutoff) * self._d)), 1.0, 1.0)
def _connect(self): '''Connect populations.''' finite_set = csa.cross(xrange(self._N_s), xrange(self._N_t)) if self._fan == 'in': cs = csa.cset(csa.random(fanIn=self._C) * finite_set) else: cs = csa.cset(csa.random(fanOut=self._C) * finite_set) nest.CGConnect(self._source_pop, self._target_pop, csa.cset(cs))
def connect(self, projection): """Connect-up a Projection.""" # Cut out finite part c = csa.cross((0, projection.pre.size - 1), (0, projection.post.size - 1)) * self.cset # can't we cut out just the columns we want? if csa.arity(self.cset) == 2: # Connection-set with arity 2 for (i, j, weight, delay) in c: projection._convergent_connect([projection.pre[i]], projection.post[j], weight, delay) elif csa.arity(self.cset) == 0: # inefficient implementation as a starting point connection_map = numpy.zeros((projection.pre.size, projection.post.size), dtype=bool) for addr in c: connection_map[addr] = True self._connect_with_map(projection, LazyArray(connection_map)) else: raise NotImplementedError
def _connect(self): '''Connect populations.''' g1 = self._geometryFunction(self._ls) g2 = self._geometryFunction(self._lt) d = csa.euclidMetric2d(g1, g2) sigma = self._params['sigma'] cutoff = self._max_dist cs = csa.cset( csa.cross([0], xrange(self._N - 1)) * (csa.random * (csa.gaussian(sigma, cutoff) * d)), 1.0, 1.0) nest.CGConnect( nest.GetLeaves(self._ls)[0], nest.GetLeaves(self._lt)[0], cs, { 'weight': 0, 'delay': 1 })
def _connect(self): '''Connect populations.''' finite_set = csa.cross(xrange(self._N_s), xrange(self._N_t)) cs = csa.cset(csa.random(p=self._p) * finite_set) nest.CGConnect(self._source_pop, self._target_pop, csa.cset(cs))
def _connect(self): '''Connect populations.''' finite_set = csa.cross(xrange(self._N_s), xrange(self._N_t)) self._cs = csa.cset(csa.random(p=self._p) * finite_set)