def main(plot_torus=True, plot_target=True, num_plot_tagets=3, use_lr_connection_type=NETWORK_DICT["np"]): """ Main function running the test routines :param plot_torus: Flag to plot neural layer :param plot_target: Flag to plot targets to control established connections :param num_plot_tagets: Plot connections of the num_plot_targts-th node :param use_lr_connection_type: Define the type of long range connections :return None """ torus_layer = create_torus_layer_uniform() if plot_torus: fig, _ = plt.subplots() tp.PlotLayer(torus_layer, fig) plt.show() create_local_circular_connections(torus_layer) debug_layer = create_distant_connections( torus_layer, connection_type=use_lr_connection_type) if plot_target: choice = np.random.choice(np.asarray(debug_layer), num_plot_tagets, replace=False) for c in choice: tp.PlotTargets([int(c)], torus_layer) plt.show() adj_mat = create_adjacency_matrix( nest.GetNodes(torus_layer)[0], nest.GetNodes(torus_layer)[0]) eigenvalue_analysis(adj_mat, plot=True)
def get_nest_adjacency(id_converter=None): ''' Get the adjacency matrix describing a NEST network. Parameters ---------- id_converter : dict, optional (default: None) A dictionary which maps NEST gids to the desired neurons ids. Returns ------- mat_adj : :class:`~scipy.sparse.lil_matrix` Adjacency matrix of the network. ''' gids = (nest.GetNodes()[0] if nest_version == 2 else np.asarray(nest.GetNodes())) n = len(gids) mat_adj = ssp.lil_matrix((n,n)) if id_converter is None: id_converter = {idx: i for i, idx in enumerate(gids)} for i in range(n): src = id_converter[gids[i]] connections = nest.GetConnections(source=(gids[i],)) info = nest.GetStatus(connections) for dic in info: mat_adj.rows[src].append(id_converter[dic['target']]) mat_adj.data[src].append(dic[WEIGHT]) return mat_adj
def loadLayers(self, layer_IDs): self.layers_to_record = [] self.area_PSTH_index = [] self.area_recorded_models = [] self.layer_sizes = [] self.layer_sizes_area = [] for layer in self.labels: id_found = False for ll in layer_IDs: if (ll[0] == layer): self.layers_to_record.append((ll[1], ll[2])) self.layer_sizes.append(len(nest.GetNodes(ll[1])[0])) id_found = True if id_found == False: # Assign random layer self.layers_to_record.append((ll[1], ll[2])) print("Warning: layer %s not found!" % layer) for layer in self.area_labels: # Search first for the matching spiking label index = 0 for spiking_label in self.labels: if (layer == spiking_label): self.area_PSTH_index.append(index) index += 1 # Then search for the NEST ID id_found = False for ll in layer_IDs: if (ll[0] == layer): self.area_recorded_models.append((ll[1], ll[2])) self.layer_sizes_area.append(len(nest.GetNodes(ll[1])[0])) id_found = True if id_found == False: # Assign random layer self.area_recorded_models.append((ll[1], ll[2])) print("Warning: layer %s not found!" % layer) # center cell if self.isCenterCell: type = 0 for layer in self.labels: layer_side = int(np.sqrt(self.layer_sizes[type])) center_row = int(layer_side / 2.0) center_col = int(layer_side / 2.0) for cell in np.arange(self.layer_sizes[type]): row = int(cell / layer_side) col = np.remainder(cell, layer_side) if row == center_row and col == center_col: self.selected_cell.append(cell) type += 1
def set_poisson_values(img_dict, poiss_layers): filtered_img_on = img_dict['on'] filtered_img_off = img_dict['off'] fixed_list_on = [k * factor_exc for k in filtered_img_on] fixed_list_off = [k * factor_exc for k in filtered_img_off] poiss_on = list(poiss_layers['poiss_on']) poiss_off = list(poiss_layers['poiss_off']) nest.SetStatus(nest.GetNodes(poiss_on)[0], 'rate', fixed_list_on) nest.SetStatus(nest.GetNodes(poiss_off)[0], 'rate', fixed_list_off)
def create_random_patches( layer, r_loc=0.5, p_loc=0.7, num_patches=3, ): """ Create random long range patchy connections. To every neuron a single link is established instead of taking axonal morphology into account. :param layer: Layer in which the connections should be established :param r_loc: Radius for local connections :param p_loc: Probability for local connections :param num_patches: Number of patches that should be created :return Nodes of the layer for debugging purposes (plotting) """ # Calculate the parameters for the patches r_p = r_loc / 2. min_distance = r_loc + r_p max_distance = R_MAX / 2. - r_loc p_p = get_lr_connection_probability_patches(r_loc, p_loc, r_p, num_patches=num_patches) # Iterate through all neurons, as all neurons have random patches nodes = nest.GetNodes(layer)[0] for neuron in nodes: # Calculate radial distance and the respective coordinates for patches radial_distance = np.random.uniform(min_distance, max_distance, size=num_patches).tolist() radial_angle = np.random.uniform(0., 359., size=num_patches).tolist() # Calculate patch region mask_specs = {"radius": r_p} anchors = [ to_coordinates(distance, angle) for angle, distance in zip(radial_angle, radial_distance) ] patches = tuple() for anchor in anchors: patches += tp.SelectNodesByMask(layer, anchor, mask_obj=tp.CreateMask( "circular", specs=mask_specs)) # Define connection connect_dict = {"rule": "pairwise_bernoulli", "p": p_p} nest.Connect([neuron], patches, connect_dict) # Return nodes of layer for debugging return nest.GetNodes(layer)[0]
def setUp(self): self.num_neurons = 1500 self.neuron_type = "iaf_psc_delta" self.rest_pot = -1. self.threshold_pot = 1e2 self.time_const = 22. self.capacitance = 1e4 self.num_stimulus_discr = 4 self.size_layer = 2. self.input_stimulus = cs.image_with_spatial_correlation(size_img=(20, 20), radius=3, num_circles=80) self.organise_on_grid = True self.torus_layer, self.spike_det, self.multi = nc.create_torus_layer_uniform( num_neurons=self.num_neurons, neuron_type=self.neuron_type, rest_pot=self.rest_pot, threshold_pot=self.threshold_pot, time_const=self.time_const, capacitance=self.capacitance, size_layer=self.size_layer ) self.torus_nodes = nest.GetNodes(self.torus_layer)[0] self.inh_nodes = np.random.choice(np.asarray(self.torus_nodes), self.num_neurons // 5, replace=False) self.min_id_torus = min(self.torus_nodes) self.torus_positions = tp.GetPosition(self.torus_nodes) self.torus_tree = KDTree(self.torus_positions) self.perlin_resolution = (15, 15) self.perlin_spacing = 0.1 (self.tuning_to_neuron_map, self.neuron_to_tuning_map, self.tuning_weight_vector) = nc.create_perlin_stimulus_map( self.torus_layer, self.inh_nodes, num_stimulus_discr=self.num_stimulus_discr, resolution=self.perlin_resolution, spacing=self.perlin_spacing, plot=False, save_plot=False ) self.retina = nc.create_input_current_generator( self.input_stimulus, organise_on_grid=self.organise_on_grid ) self.receptors = nest.GetNodes(self.retina)[0]
def test_GetNodes_with_params(self): """test GetNodes with params""" nodes_Vm = nest.GetNodes({'V_m': -77.}) nodes_Vm_ref = nest.NodeCollection([4, 5, 6, 8]) self.assertEqual(nodes_Vm_ref, nodes_Vm) nodes_Vm_tau = nest.GetNodes({'V_m': -77., 'tau_m': 12.}) nodes_Vm_tau_ref = nest.NodeCollection([8]) self.assertEqual(nodes_Vm_tau_ref, nodes_Vm_tau) nodes_exp = nest.GetNodes({'model': 'iaf_psc_exp'}) nodes_exp_ref = nest.NodeCollection([10, 11, 12, 13]) self.assertEqual(nodes_exp_ref, nodes_exp)
def test_create_torus_layer_with_jitter(self): self.reset() # Must be number that has a square root in N num_neurons = 144 jitter = 0.01 neuron_type = "iaf_psc_delta" layer_size = 3. layer = nc.create_torus_layer_with_jitter( num_neurons=num_neurons, jitter=jitter, neuron_type=neuron_type, layer_size=layer_size ) nodes = nest.GetNodes(layer)[0] self.assertEqual(len(nodes), num_neurons, "Not the right number of nodes") model = nest.GetStatus(nodes, "model") for m in model: self.assertEqual(m, neuron_type, "Wrong neuron type set") mod_size = layer_size - jitter * 2 step_size = mod_size / float(np.sqrt(num_neurons)) coordinate_scale = np.arange(-mod_size / 2., mod_size / 2., step_size) grid = [[x, y] for y in coordinate_scale for x in coordinate_scale] for n in nodes: pos = np.asarray(tp.GetPosition([n])[0]) sorted(grid, key=lambda l: np.linalg.norm(np.asarray(l) - pos)) self.assertLessEqual(pos[0], np.abs(grid[0][0] + jitter), "Distance in x to original position too high") self.assertLessEqual(pos[1], np.abs(grid[0][1] + jitter), "Distance in y to original position too high")
def __len__(self): """Return the number of connections on the local MPI node.""" local_nodes = nest.GetNodes([0], local_only=True)[0] local_connections = nest.GetConnections(target=local_nodes, synapse_model=self.nest_synapse_model, synapse_label=self.nest_synapse_label) return len(local_connections)
def loadLayers(self, layer_IDs): self.layers_to_record = [] self.layer_sizes = [] for layer in self.labels: id_found = False for ll in layer_IDs: if (ll[0] == layer): self.layers_to_record.append((ll[1], ll[2])) self.layer_sizes.append(len(nest.GetNodes(ll[1])[0])) id_found = True if id_found == False: # Assign random layer self.layers_to_record.append((ll[1], ll[2])) print("Warning: layer %s not found!" % layer) # center cell if self.isCenterCell: type = 0 for layer in self.labels: layer_side = int(np.sqrt(self.layer_sizes[type])) center_row = int(layer_side / 2.0) center_col = int(layer_side / 2.0) for cell in np.arange(self.layer_sizes[type]): row = int(cell / layer_side) col = np.remainder(cell, layer_side) if row == center_row and col == center_col: self.selected_cell.append(cell) type += 1
def setUp(self): nest.ResetKernel() nest.SetKernelStatus({"total_num_virtual_procs": 4}) nest.ResetNetwork() self.sim_time = 10000 self.sim_step = 100 nest.SetKernelStatus( {'structural_plasticity_update_interval': self.sim_time + 1}) self.se_integrator = [] self.sim_steps = None self.ca_nest = None self.ca_python = None self.se_nest = None self.se_python = None # build self.pop = nest.Create('iaf_neuron', 10) self.local_nodes = nest.GetNodes([0], {'model': 'iaf_neuron'}, True)[0] self.spike_detector = nest.Create('spike_detector') nest.Connect(self.pop, self.spike_detector, 'all_to_all') noise = nest.Create('poisson_generator') nest.SetStatus(noise, {"rate": 800000.0}) nest.Connect(noise, self.pop, 'all_to_all')
def get_and_save_connections(source_layers_dict, source_layer_key, target_layers_dict, target_layer_key): params = ['source', 'target', 'weight'] source_layer = source_layers_dict[source_layer_key] target_layer = target_layers_dict[target_layer_key] src_nodes = nest.GetNodes(source_layer) tgt_nodes = nest.GetNodes(target_layer) connections = nest.GetConnections(source=src_nodes[0]) data = nest.GetStatus(connections, params) df = pd.DataFrame.from_records(data, columns=params) df = df[df['target'].between(np.min(tgt_nodes), np.max(tgt_nodes))] df.to_csv(connections_path + '/connections_' + str(source_layer_key) + '_to_' + str(target_layer_key) + '.txt', header=None, index=None, sep=' ', mode='a')
def test_GetNodes(self): """GetNodes""" nest.ResetKernel() model = 'iaf_neuron' l = nest.LayoutNetwork(model, [2, 3]) allNodes = range(2, 10) allSubnets = [2, 6] allLeaves = [n for n in allNodes if n not in allSubnets] # test all self.assertEqual(nest.GetNodes(l), [allNodes]) # test all with empty dict self.assertEqual(nest.GetNodes(l, properties={}), [allNodes]) # test iteration over subnets self.assertEqual(nest.GetNodes(l + l), [allNodes, allNodes]) # children of l are nodes self.assertEqual(nest.GetNodes(l, properties={'parent': l[0]}), [allSubnets]) # local id of second intermediate subnet and middle nodes self.assertEqual(nest.GetNodes(l, properties={'local_id': 2}), [[4, 6, 8]]) # selection by model type self.assertEqual(nest.GetNodes(l, properties={'model': 'subnet'}), [allSubnets]) self.assertEqual(nest.GetNodes(l, properties={'model': model}), [allLeaves])
def test_GetNodes(self): """GetNodes""" nest.ResetKernel() model = 'iaf_psc_alpha' l = nest.LayoutNetwork(model, (2, 3)) allNodes = tuple(range(2, 10)) allSubnets = (2, 6) allLeaves = tuple(n for n in allNodes if n not in allSubnets) # test all self.assertEqual(nest.GetNodes(l), (allNodes, )) # test all with empty dict self.assertEqual(nest.GetNodes(l, properties={}), (allNodes, )) # test iteration over subnets self.assertEqual(nest.GetNodes(l + l), (allNodes, allNodes)) # children of l are nodes self.assertEqual(nest.GetNodes( l, properties={'parent': l[0]}), (allSubnets, )) # local id of second intermediate subnet and middle nodes self.assertEqual(nest.GetNodes( l, properties={'local_id': 2}), ((4, 6, 8), )) # selection by model type self.assertEqual(nest.GetNodes( l, properties={'model': 'subnet'}), (allSubnets, )) self.assertEqual(nest.GetNodes( l, properties={'model': model}), (allLeaves, ))
def test_sort_nodes_space(self): self.reset() layer = create_torus_layer_with_jitter(4, jitter=0, layer_size=2.) expected_positions = [[-1., -1.], [-1., 0.], [0., -1.], [0., 0.]] sorted_nodes, positions = tu.sort_nodes_space(nest.GetNodes(layer)[0], axis=0) for sp, esp in zip(positions, expected_positions): self.assertListEqual(list(sp), esp, "Nodes were not correctly sorted")
def main_create_eigenspectra_plots(): """ Compute the eigenvalue spectra and plot them :return: None """ torus_layer, _, _ = create_torus_layer_uniform() create_local_circular_connections_topology(torus_layer) for key in NETWORK_DICT: _ = create_distant_connections(torus_layer, connection_type=NETWORK_DICT[key]) adj_mat = create_adjacency_matrix( nest.GetNodes(torus_layer)[0], nest.GetNodes(torus_layer)[0]) eigenvalue_analysis(adj_mat, plot=True, save_plot=True, fig_name="voges_adj_matrix_%s.png" % key)
def __len__(self): """Return the number of connections on the local MPI node.""" nest_model = self.post.celltype.nest_name[ self._simulator.state.spike_precision] local_nodes = nest.GetNodes({"model": nest_model}, local_only=True) local_connections = nest.GetConnections( target=local_nodes, synapse_model=self.nest_synapse_model, synapse_label=self.nest_synapse_label) return len(local_connections)
def create_populations(self): """ Create all populations of the area. """ self.gids = {} self.num_local_nodes = 0 for pop in self.populations: gid = nest.Create( self.network.params['neuron_params']['neuron_model'], int(self.neuron_numbers[pop])) mask = create_vector_mask(self.network.structure, areas=[self.name], pops=[pop]) I_e = self.network.add_DC_drive[mask][0] if not self.network.params['input_params']['poisson_input']: K_ext = self.external_synapses[pop] W_ext = self.network.W[self.name][pop]['external']['external'] tau_syn = self.network.params['neuron_params'][ 'single_neuron_dict']['tau_syn_ex'] DC = K_ext * W_ext * tau_syn * 1.e-3 * \ self.network.params['rate_ext'] I_e += DC nest.SetStatus(gid, {'I_e': I_e}) # Store first and last GID of each population self.gids[pop] = (gid[0], gid[-1]) # Initialize membrane potentials # This could also be done after creating all areas, which # might yield better performance. Has to be tested. for t in np.arange(nest.GetKernelStatus('local_num_threads')): local_nodes = np.array( nest.GetNodes( [0], { 'model': self.network.params['neuron_params'] ['neuron_model'], 'thread': t }, local_only=True)[0]) local_nodes_pop = local_nodes[(np.logical_and( local_nodes >= gid[0], local_nodes <= gid[-1]))] if len(local_nodes_pop) > 0: vp = nest.GetStatus([local_nodes_pop[0]], 'vp')[0] # vp is the same for all local nodes on the same thread nest.SetStatus( list(local_nodes_pop), 'V_m', self.simulation.pyrngs[vp].normal( self.network.params['neuron_params']['V0_mean'], self.network.params['neuron_params']['V0_sd'], len(local_nodes_pop))) self.num_local_nodes += len(local_nodes_pop)
def print_gdf(f): """ Print network as a graph in GDF format Args: f: file Returns: None """ f.write("nodedef> label\n") for node in nest.GetNodes((0, ))[0]: f.write("%d\n" % node) print_connections(f)
def from_nest_network(cls, gids, resolution=None, monitor_rate=None, mean_field=True, omp=1, ignore_errors=False): ''' Create a Simulator instance from the GIDs of a NEST network and the network parameters. Parameters ---------- gids : tuple NEST GIDs. All the other parameters of the ``__init__`` method except for `num_neurons`. See also -------- :func:`~PyNeurActiv.Simulator2017_SynchroBurst.__init__`, :func:`~PyNeurActiv.Simulator2017_SynchroBurst.from_nngt_network`. ''' # get the neurons neurons = nest.GetNodes([0], properties={'element_type': 'neuron'})[0] num_neurons = len(neurons) di_param = nest.GetStatus((neurons[0], ))[0] edges_info = nest.GetStatus(nest.GetConnections(source=neurons)) weight = 0. delay = 0. num_edges = 0. for di in edges_info: weight += di["weight"] delay += di["delay"] num_edges += 1. if not num_edges: raise RuntimeError("No edges in the network.") di_param["weight"] = weight / num_edges di_param["delay"] = delay / num_edges sim = cls(num_neurons, di_param, resolution=resolution, monitor_rate=monitor_rate, mean_field=mean_field, omp=omp, create_network=False, gids=gids) return sim
def _set_spike_data(data, spike_detector): ''' Data must be [[], []] ''' import nest from ..simulation.nest_utils import _get_nest_gids, spike_rec, nest_version if not len(data[0]): if spike_detector is None: prop = {'model': spike_rec} if nest_version == 3: spike_detector = nest.GetNodes(properties=prop) else: spike_detector = nest.GetNodes((0, ), properties=prop)[0] events = nest.GetStatus(spike_detector, "events") for ev_dict in events: data[0].extend(ev_dict["senders"]) data[1].extend(ev_dict["times"]) sorter = np.argsort(data[1]) return np.array(data)[:, sorter].T
def _set_spike_data(data, spike_detector): ''' Data must be [[], []] ''' import nest if not len(data[0]): if spike_detector is None: spike_detector = nest.GetNodes( (0, ), properties={'model': 'spike_detector'})[0] events = nest.GetStatus(spike_detector, "events") for ev_dict in events: data[0].extend(ev_dict["senders"]) data[1].extend(ev_dict["times"]) sorter = np.argsort(data[1]) return np.array(data)[:, sorter].T
def test_create_input_current_generator(self): self.reset() input_stimulus = cs.image_with_spatial_correlation(size_img=(50, 50), radius=3, num_circles=80) organise_on_grid = True retina = nc.create_input_current_generator( input_stimulus, organise_on_grid=organise_on_grid ) receptors = nest.GetNodes(retina)[0] amplitude = nest.GetStatus(receptors, "amplitude") self.assertTrue( np.all(np.asarray(amplitude) == input_stimulus.reshape(-1)), "The input stimulus and the current in the retina don't match" )
def set_poisson_values(img_dict, poiss_layers, num_orientations): for i in range(0, num_orientations): orientation = i * 180 / num_orientations filtered_img = img_dict["orientation_" + str(orientation)] fixed_list = [ k * factor if k > 10.0 else (11 - k)**0.1 * k * factor for k in filtered_img ] fixed_list = [ fixed_list[k] if filtered_img[k] > poisson_bias else poisson_bias * factor_bias for k in range(0, len(fixed_list)) ] l_poiss = list(poiss_layers['orientation_' + str(orientation)]['l_poiss_' + str(orientation)]) nest.SetStatus(nest.GetNodes(l_poiss)[0], 'rate', fixed_list)
def build_model(): global NEURONS nest.SetDefaults('iaf_psc_exp', iaf_neuronparams) layerNumberZ = 6 neuronID = 2 for layer in Cortex: columns = layer[area][X_area] rows = layer[area][Y_area] NEURONS += rows * columns for y in range(rows): for x in range(columns): dictPosition_NeuronID[(float(x), float(y), float(layerNumberZ))] = neuronID neuronID += 1 layerNumberZ -= 1 logger.debug("{0} {1} neurons".format(layer[Glu][k_name][:2], rows * columns)) logger.debug("X: {0} ({1}neu x {2}col) \n".format( layer[area][X_area], sum(layer[step]), layer[area][X_area] / sum(layer[step])) + " " * 16 + "Y: {0} ({1}neu x {2}col)".format( layer[area][Y_area], 2, layer[area][Y_area] / 2)) model_3D = tp.CreateLayer({ 'positions': dictPosition_NeuronID.keys(), 'elements': 'iaf_psc_exp', 'extent': [1000.0, 1000.0, 100.0], 'edge_wrap': False }) print nest.GetNodes(model_3D) # TODO uncomment if you want to see the 3D model tp.PlotLayer(model_3D) plt.show() # Build another parts for part in IC + MGB: part[k_model] = 'iaf_psc_exp' part[k_IDs] = nest.Create(part[k_model], part[k_NN]) NEURONS += part[k_NN] logger.debug("{0} [{1}, {2}] {3} neurons".format( part[k_name], part[k_IDs][0], part[k_IDs][0] + part[k_NN] - 1, part[k_NN]))
def create_overlapping_patches(layer, r_loc=0.5, p_loc=0.7, distance=2.5, num_patches=3, allow_multapses=False): """ Create long-range patchy connections with overlapping patches such that all neurons share almost the same parameters for these links :param layer: The layer in which the connections should be established :param r_loc: Radius of local connections :param p_loc: Probability of local connections :param distance: Distance of patches :param num_patches: Number of patches :param allow_multapses: Flag to allow multiple links between neurons :return: Neurons of the layer for debugging (plotting) """ # Calculate parameters for pathces r_p = r_loc / 2. p_p = get_lr_connection_probability_patches(r_loc, p_loc, r_p) # Create overlapping patches as every neuron shares the same patch parameter for n in range(1, num_patches + 1): angle = n * 360. / float(num_patches) coordinates = to_coordinates(angle, distance) mask_dict = {"circular": {"radius": r_p, "anchor": coordinates}} connection_dict = { "connection_type": "divergent", "mask": mask_dict, "kernel": p_p, "allow_autapses": False, "allow_multapses": allow_multapses, "synapse_model": "static_synapse" } tp.ConnectLayers(layer, layer, connection_dict) # Return nodes of layer for debugging return nest.GetNodes(layer)[0]
def get_firing_rate(network, spike_detector=None, data=None, nodes=None): ''' Return the average firing rate for the neurons. Parameters ---------- network : :class:`nngt.Network` Network for which the activity was simulated. spike_detector : tuple of ints, optional (default: spike detectors) GID of the "spike_detector" objects recording the network activity. data : array-like of shape (2, N), optionale (default: None) Array containing the spikes data (first line must contain the NEST GID of the neuron that fired, second line must contain the associated spike time). nodes : array-like, optional (default: all nodes) NNGT ids of the nodes for which the B2 should be computed. Returns ------- fr : array-like Firing rate for each neuron in `nodes`. ''' if data is None: data = [[], []] if nodes is None: nodes = network.nest_gid else: nodes = network.nest_gid[nodes] if not len(data[0]): if spike_detector is None: spike_detector = nest.GetNodes( (0,), properties={'model': 'spike_detector'})[0] events = nest.GetStatus(spike_detector, "events") for ev_dict in events: data[0].extend(ev_dict["senders"]) data[1].extend(ev_dict["times"]) data[0] = np.array(data[0]) data[1] = np.array(data[1]) return _fr_from_data(nodes, data)
def create_distant_np_connections(layer, r_loc=0.5, p_loc=0.7, allow_multapses=False): """ Create long distance connections without any patches :param layer: Layer in which the connections should be established :param r_loc: radius for local connections needed to calculate the long range connection probability :param p_loc: probability for local connections needed to calculate the long range connection probability :param allow_multapses: allow multiple connections between neurons :return Neurons of the layer for debugging (plotting) """ # Mask for area to which long-range connections can be established mask_dict = { "doughnut": { "inner_radius": r_loc, "outer_radius": R_MAX / 2. } } # Get possibility to establish a single long-range connection p_lr = get_lr_connection_probability_np(r_loc, p_loc) connection_dict = { "connection_type": "divergent", "mask": mask_dict, "kernel": p_lr, "allow_autapses": False, "allow_multapses": allow_multapses, "allow_oversized_mask": True, } tp.ConnectLayers(layer, layer, connection_dict) # Return nodes of layer for debugging return nest.GetNodes(layer)[0]
def test_get_in_out_degree(self): self.reset() layer = create_torus_layer_with_jitter(4, jitter=0, layer_size=2.) conn_dict = { "connection_type": "divergent", "mask": { "rectangular": { "lower_left": [-1.0, -1.0], "upper_right": [1.0, 1.0] } }, "kernel": 1.0 } expect_in = [9, 6, 6, 4] expect_out = [4, 6, 6, 9] tp.ConnectLayers(layer, layer, conn_dict) in_degree, out_degree, _, _, _, _ = tu.get_in_out_degree( nest.GetNodes(layer)[0]) self.assertListEqual(expect_in, in_degree, "In degree was not computed correctly") self.assertListEqual(expect_out, out_degree, "Out degree was not computed correctly")
def create_populations(self): """ Creates the neuronal populations. The neuronal populations are created and the parameters are assigned to them. The initial membrane potential of the neurons is drawn from a normal distribution. Scaling of the number of neurons and of the synapses is performed. If scaling is performed extra DC input is added to the neuronal populations. """ self.N_full = self.net_dict['N_full'] self.N_scaling = self.net_dict['N_scaling'] self.K_scaling = self.net_dict['K_scaling'] self.synapses = get_total_number_of_synapses(self.net_dict) self.synapses_scaled = self.synapses * self.K_scaling self.nr_neurons = self.N_full * self.N_scaling self.K_ext = self.net_dict['K_ext'] * self.K_scaling self.w_from_PSP = get_weight(self.net_dict['PSP_e'], self.net_dict) self.weight_mat = get_weight( self.net_dict['PSP_mean_matrix'], self.net_dict ) self.weight_mat_std = self.net_dict['PSP_std_matrix'] self.w_ext = self.w_from_PSP if self.net_dict['poisson_input']: self.DC_amp_e = np.zeros(len(self.net_dict['populations'])) else: if nest.Rank() == 0: print( ''' no poisson input provided calculating dc input to compensate ''' ) self.DC_amp_e = compute_DC(self.net_dict, self.w_ext) if nest.Rank() == 0: print( 'The number of neurons is scaled by a factor of: %.2f' % self.N_scaling ) print( 'The number of synapses is scaled by a factor of: %.2f' % self.K_scaling ) # Scaling of the synapses. if self.K_scaling != 1: synapses_indegree = self.synapses / ( self.N_full.reshape(len(self.N_full), 1) * self.N_scaling) self.weight_mat, self.w_ext, self.DC_amp_e = adj_w_ext_to_K( synapses_indegree, self.K_scaling, self.weight_mat, self.w_from_PSP, self.DC_amp_e, self.net_dict, self.stim_dict ) # Create cortical populations. self.pops = [] pop_file = open( os.path.join(self.data_path, 'population_GIDs.dat'), 'w+' ) for i, pop in enumerate(self.net_dict['populations']): population = nest.Create( self.net_dict['neuron_model'], int(self.nr_neurons[i]) ) nest.SetStatus( population, { 'tau_syn_ex': self.net_dict['neuron_params']['tau_syn_ex'], 'tau_syn_in': self.net_dict['neuron_params']['tau_syn_in'], 'E_L': self.net_dict['neuron_params']['E_L'], 'V_th': self.net_dict['neuron_params']['V_th'], 'V_reset': self.net_dict['neuron_params']['V_reset'], 't_ref': self.net_dict['neuron_params']['t_ref'], 'I_e': self.DC_amp_e[i] } ) self.pops.append(population) pop_file.write('%d %d \n' % (population[0], population[-1])) pop_file.close() for thread in np.arange(nest.GetKernelStatus('local_num_threads')): # Using GetNodes is a work-around until NEST 3.0 is released. It # will issue a deprecation warning. local_nodes = nest.GetNodes( [0], { 'model': self.net_dict['neuron_model'], 'thread': thread }, local_only=True )[0] vp = nest.GetStatus(local_nodes)[0]['vp'] # vp is the same for all local nodes on the same thread nest.SetStatus( local_nodes, 'V_m', self.pyrngs[vp].normal( self.net_dict['neuron_params']['V0_mean'], self.net_dict['neuron_params']['V0_sd'], len(local_nodes)) )