def setUp(self): neuron.Population.nPop = 0 self.net1 = neuron.Population((10,), neuron.IF_curr_alpha) self.net2 = neuron.Population((2,4,3), neuron.IF_curr_exp) self.net3 = neuron.Population((2,2,1), neuron.SpikeSourceArray) self.net4 = neuron.Population((1,2,1), neuron.SpikeSourceArray) self.net5 = neuron.Population((3,3), neuron.IF_cond_alpha)
def setUp(self): neuron.Population.nPop = 0 neuron.Projection.nProj = 0 self.target33 = neuron.Population((3,3), neuron.IF_curr_alpha) self.target6 = neuron.Population((6,), neuron.IF_cond_exp) self.source5 = neuron.Population((5,), neuron.IF_curr_exp) self.source22 = neuron.Population((2,2), neuron.SpikeSourcePoisson)
def setUp(self): sim.setup() self.p1 = sim.Population(7, sim.IF_cond_exp()) self.p2 = sim.Population(4, sim.IF_cond_exp()) self.p3 = sim.Population(5, sim.IF_curr_alpha()) self.syn1 = sim.StaticSynapse(weight=0.123, delay=0.5) self.syn2 = sim.StaticSynapse(weight=0.456, delay=0.4) self.random_connect = sim.FixedNumberPostConnector(n=2) self.all2all = sim.AllToAllConnector()
def model_network(param_dict): """ This model network consists of a spike source and a neuron (IF_curr_alpha). The spike rate of the source and the weight can be specified in the param_dict. Returns the number of spikes fired during 1000 ms of simulation. Parameters: param_dict - dictionary with keys rate - the rate of the spike source (spikes/second) weight - weight of the connection source -> neuron Returns: dictionary with keys: source_rate - the rate of the spike source weight - weight of the connection source -> neuron neuron_rate - spike rate of the neuron """ #set up the network import pyNN.neuron as sim sim.setup(dt=0.01, min_delay=1., max_delay=1., debug=False, quit_on_end=False) weight = param_dict['weight'] import NeuroTools.stgen as stgen stgen = stgen.StGen() spiketrain = stgen.poisson_generator(param_dict['rate'], t_stop=1000.) source = sim.Population(1, sim.SpikeSourceArray, {'spike_times': spiketrain.spike_times}) neuron = sim.Population(1, sim.IF_cond_alpha) sim.Projection(source, neuron, method=sim.OneToOneConnector(weights=param_dict['weight'], delays=1.)) #set recorder neuron.record() neuron.record_v() #run the simulation sim.run(1001.) sim.end() # count the number of spikes spikes = neuron.getSpikes() numspikes = len(spikes) # return everything, including the input parameters return { 'source_rate': param_dict['rate'], 'weight': param_dict['weight'], 'neuron_rate': numspikes }
def build_network(sim, order=1000, epsilon=0.1, delay=1.5, J=0.1, theta=20.0, tau=20.0, tau_syn=0.1, tau_refrac=2.0, v_reset=10.0, R=1.5, g=5, eta=2, seed=None): NE = 4 * order NI = 1 * order CE = int(epsilon * NE) # number of excitatory synapses per neuron CI = int(epsilon * NI) # number of inhibitory synapses per neuron CMem = tau/R J_unit = psp_height(tau, R, tau_syn) J_ex = J / J_unit J_in = -g * J_ex nu_th = theta / (J_ex * CE * R * tau_syn) nu_ex = eta * nu_th p_rate = 1000.0 * nu_ex * CE assert seed is not None rng = NumpyRNG(seed) neuron_params = { "nrn_tau": tau, "nrn_v_threshold": theta, "nrn_refractory_period": tau_refrac, "nrn_v_reset": v_reset, "nrn_R": R, "syn_tau": tau_syn } celltype = Dynamics(name='iaf', subnodes={'nrn': read("sources/BrunelIaF.xml")['BrunelIaF'], 'syn': read("sources/AlphaPSR.xml")['AlphaPSR']}) celltype.connect_ports('syn.i_synaptic', 'nrn.i_synaptic') exc = sim.Population(NE, nineml_cell_type('BrunelIaF', celltype, {'syn': 'syn_weight'})(**neuron_params)) inh = sim.Population(NI, nineml_cell_type('BrunelIaF', celltype, {'syn': 'syn_weight'})(**neuron_params)) all = exc + inh all.initialize(v=RandomDistribution('uniform', (0.0, theta), rng=rng)) stim = sim.Population(NE + NI, nineml_cell_type('Poisson', read("sources/Poisson.xml")['Poisson'], {})(rate=p_rate)) print("Connecting network") exc_synapse = sim.StaticSynapse(weight=J_ex, delay=delay) inh_synapse = sim.StaticSynapse(weight=J_in, delay=delay) input_connections = sim.Projection(stim, all, sim.OneToOneConnector(), exc_synapse, receptor_type="syn") exc_connections = sim.Projection(exc, all, sim.FixedNumberPreConnector(n=CE), exc_synapse, receptor_type="syn") # check is Pre not Post inh_connections = sim.Projection(inh, all, sim.FixedNumberPreConnector(n=CI), inh_synapse, receptor_type="syn") return stim, exc, inh
def run_sim(ncell): print "Cells: ", ncell setup0 = time.time() sim.setup(timestep=0.1) hh_cell_type = sim.HH_cond_exp() hh = sim.Population(ncell, hh_cell_type) pulse = sim.DCSource(amplitude=0.5, start=20.0, stop=80.0) pulse.inject_into(hh) hh.record('v') setup1 = time.time() t0 = time.time() sim.run(100.0) v = hh.get_data() sim.end() t1 = time.time() setup_total = setup1 - setup0 run_total = t1 - t0 print "Setup: ", setup_total print "Run: ", run_total print "Total sim time: ", setup_total + run_total return run_total
def testInitWithParams(self): """Population.__init__(): Parameters set on creation should be the same as retrieved with the top-level HocObject""" net = neuron.Population((3,3), neuron.IF_curr_alpha, {'tau_syn_E':3.141592654}) for cell in net: tau_syn = cell._cell.esyn.tau self.assertAlmostEqual(tau_syn, 3.141592654, places=5)
def testInitWithNonStandardModel(self): """Population.__init__(): the cell list in hoc should have the same length as the population size.""" net = neuron.Population((3,3), neuron.StandardIF, {'syn_type':'current', 'syn_shape':'exp'}) self.assertEqual(net.size, 9) n_cells_local = len([id for id in net]) min = 9/neuron.num_processes() max = min+1 assert min <= n_cells_local <= max, "%d not between %d and %d" % (n_cells_local, min, max)
def testSimpleInit(self): """Population.__init__(): the cell list in hoc should have the same length as the population size.""" net = neuron.Population((3,3), neuron.IF_curr_alpha) self.assertEqual(net.size, 9) n_cells_local = len([id for id in net]) # round-robin distribution min = 9/neuron.num_processes() max = min+1 assert min <= n_cells_local <= max, "%d not between %d and %d" % (n_cells_local, min, max)
def setUp(self): sim.setup() self.p = sim.Population( 4, sim.IF_cond_exp( **{ 'tau_m': 12.3, 'cm': lambda i: 0.987 + 0.01 * i, 'i_offset': numpy.array([-0.21, -0.20, -0.19, -0.18]) }))
def testRecordWithSpikeTimesGreaterThanSimTime(self): """ If a `SpikeSourceArray` is initialized with spike times greater than the simulation time, only those spikes that actually occurred should be written to file or returned by getSpikes(). """ spike_times = numpy.arange(10.0, 200.0, 10.0) spike_source = neuron.Population(1, neuron.SpikeSourceArray, {'spike_times': spike_times}) spike_source.record() neuron.run(100.0) spikes = spike_source.getSpikes() spikes = spikes[:,1] if neuron.rank() == 0: self.assert_( max(spikes) == 100.0, str(spikes) )
def sim_runner(wgf): wg = wgf import pyNN.neuron as sim nproc = sim.num_processes() node = sim.rank() print(nproc) import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt import matplotlib as mpl mpl.rcParams.update({'font.size':16}) #import mpi4py #threads = sim.rank() threads = 1 rngseed = 98765 parallel_safe = False #extra = {'threads' : threads} import os import pandas as pd import sys import numpy as np from pyNN.neuron import STDPMechanism import copy from pyNN.random import RandomDistribution, NumpyRNG import pyNN.neuron as neuron from pyNN.neuron import h from pyNN.neuron import StandardCellType, ParameterSpace from pyNN.random import RandomDistribution, NumpyRNG from pyNN.neuron import STDPMechanism, SpikePairRule, AdditiveWeightDependence, FromListConnector, TsodyksMarkramSynapse from pyNN.neuron import Projection, OneToOneConnector from numpy import arange import pyNN from pyNN.utility import get_simulator, init_logging, normalized_filename import random import socket #from neuronunit.optimization import get_neab import networkx as nx sim = pyNN.neuron # Get some hippocampus connectivity data, based on a conversation with # academic researchers on GH: # https://github.com/Hippocampome-Org/GraphTheory/issues?q=is%3Aissue+is%3Aclosed # scrape hippocamome connectivity data, that I intend to use to program neuromorphic hardware. # conditionally get files if they don't exist. path_xl = '_hybrid_connectivity_matrix_20171103_092033.xlsx' if not os.path.exists(path_xl): os.system('wget https://github.com/Hippocampome-Org/GraphTheory/files/1657258/_hybrid_connectivity_matrix_20171103_092033.xlsx') xl = pd.ExcelFile(path_xl) dfEE = xl.parse() dfEE.loc[0].keys() dfm = dfEE.as_matrix() rcls = dfm[:,:1] # real cell labels. rcls = rcls[1:] rcls = { k:v for k,v in enumerate(rcls) } # real cell labels, cast to dictionary import pickle with open('cell_names.p','wb') as f: pickle.dump(rcls,f) import pandas as pd pd.DataFrame(rcls).to_csv('cell_names.csv', index=False) filtered = dfm[:,3:] filtered = filtered[1:] rng = NumpyRNG(seed=64754) delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng) weight_distr = RandomDistribution('normal', [45, 1e-1], rng=rng) sanity_e = [] sanity_i = [] EElist = [] IIlist = [] EIlist = [] IElist = [] for i,j in enumerate(filtered): for k,xaxis in enumerate(j): if xaxis == 1 or xaxis == 2: source = i sanity_e.append(i) target = k if xaxis ==-1 or xaxis == -2: sanity_i.append(i) source = i target = k index_exc = list(set(sanity_e)) index_inh = list(set(sanity_i)) import pickle with open('cell_indexs.p','wb') as f: returned_list = [index_exc, index_inh] pickle.dump(returned_list,f) import numpy a = numpy.asarray(index_exc) numpy.savetxt('pickles/'+str(k)+'excitatory_nunber_labels.csv', a, delimiter=",") import numpy a = numpy.asarray(index_inh) numpy.savetxt('pickles/'+str(k)+'inhibitory_nunber_labels.csv', a, delimiter=",") for i,j in enumerate(filtered): for k,xaxis in enumerate(j): if xaxis==1 or xaxis == 2: source = i sanity_e.append(i) target = k delay = delay_distr.next() weight = 1.0 if target in index_inh: EIlist.append((source,target,delay,weight)) else: EElist.append((source,target,delay,weight)) if xaxis==-1 or xaxis == -2: sanity_i.append(i) source = i target = k delay = delay_distr.next() weight = 1.0 if target in index_exc: IElist.append((source,target,delay,weight)) else: IIlist.append((source,target,delay,weight)) internal_conn_ee = sim.FromListConnector(EElist) ee = internal_conn_ee.conn_list ee_srcs = ee[:,0] ee_tgs = ee[:,1] internal_conn_ie = sim.FromListConnector(IElist) ie = internal_conn_ie.conn_list ie_srcs = set([ int(e[0]) for e in ie ]) ie_tgs = set([ int(e[1]) for e in ie ]) internal_conn_ei = sim.FromListConnector(EIlist) ei = internal_conn_ei.conn_list ei_srcs = set([ int(e[0]) for e in ei ]) ei_tgs = set([ int(e[1]) for e in ei ]) internal_conn_ii = sim.FromListConnector(IIlist) ii = internal_conn_ii.conn_list ii_srcs = set([ int(e[0]) for e in ii ]) ii_tgs = set([ int(e[1]) for e in ii ]) for e in internal_conn_ee.conn_list: assert e[0] in ee_srcs assert e[1] in ee_tgs for i in internal_conn_ii.conn_list: assert i[0] in ii_srcs assert i[1] in ii_tgs ml = len(filtered[1])+1 pre_exc = [] post_exc = [] pre_inh = [] post_inh = [] rng = NumpyRNG(seed=64754) delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng) plot_EE = np.zeros(shape=(ml,ml), dtype=bool) plot_II = np.zeros(shape=(ml,ml), dtype=bool) plot_EI = np.zeros(shape=(ml,ml), dtype=bool) plot_IE = np.zeros(shape=(ml,ml), dtype=bool) for i in EElist: plot_EE[i[0],i[1]] = int(0) #plot_ss[i[0],i[1]] = int(1) if i[0]!=i[1]: # exclude self connections plot_EE[i[0],i[1]] = int(1) pre_exc.append(i[0]) post_exc.append(i[1]) assert len(pre_exc) == len(post_exc) for i in IIlist: plot_II[i[0],i[1]] = int(0) if i[0]!=i[1]: plot_II[i[0],i[1]] = int(1) pre_inh.append(i[0]) post_inh.append(i[1]) for i in IElist: plot_IE[i[0],i[1]] = int(0) if i[0]!=i[1]: # exclude self connections plot_IE[i[0],i[1]] = int(1) pre_inh.append(i[0]) post_inh.append(i[1]) for i in EIlist: plot_EI[i[0],i[1]] = int(0) if i[0]!=i[1]: plot_EI[i[0],i[1]] = int(1) pre_exc.append(i[0]) post_exc.append(i[1]) plot_excit = plot_EI + plot_EE plot_inhib = plot_IE + plot_II assert len(pre_inh) == len(post_inh) num_exc = [ i for i,e in enumerate(plot_excit) if sum(e) > 0 ] num_inh = [ y for y,i in enumerate(plot_inhib) if sum(i) > 0 ] # the network is dominated by inhibitory neurons, which is unusual for modellers. assert num_inh > num_exc assert np.sum(plot_inhib) > np.sum(plot_excit) assert len(num_exc) < ml assert len(num_inh) < ml # # Plot all the Projection pairs as a connection matrix (Excitatory and Inhibitory Connections) import pickle with open('graph_inhib.p','wb') as f: pickle.dump(plot_inhib,f, protocol=2) import pickle with open('graph_excit.p','wb') as f: pickle.dump(plot_excit,f, protocol=2) #with open('cell_names.p','wb') as f: # pickle.dump(rcls,f) import pandas as pd pd.DataFrame(plot_EE).to_csv('ee.csv', index=False) import pandas as pd pd.DataFrame(plot_IE).to_csv('ie.csv', index=False) import pandas as pd pd.DataFrame(plot_II).to_csv('ii.csv', index=False) import pandas as pd pd.DataFrame(plot_EI).to_csv('ei.csv', index=False) from scipy.sparse import coo_matrix m = np.matrix(filtered[1:]) bool_matrix = np.add(plot_excit,plot_inhib) with open('bool_matrix.p','wb') as f: pickle.dump(bool_matrix,f, protocol=2) if not isinstance(m, coo_matrix): m = coo_matrix(m) Gexc_ud = nx.Graph(plot_excit) avg_clustering = nx.average_clustering(Gexc_ud)#, nodes=None, weight=None, count_zeros=True)[source] rc = nx.rich_club_coefficient(Gexc_ud,normalized=False) print('This graph structure as rich as: ',rc[0]) gexc = nx.DiGraph(plot_excit) gexcc = nx.betweenness_centrality(gexc) top_exc = sorted(([ (v,k) for k, v in dict(gexcc).items() ]), reverse=True) in_degree = gexc.in_degree() top_in = sorted(([ (v,k) for k, v in in_degree.items() ])) in_hub = top_in[-1][1] out_degree = gexc.out_degree() top_out = sorted(([ (v,k) for k, v in out_degree.items() ])) out_hub = top_out[-1][1] mean_out = np.mean(list(out_degree.values())) mean_in = np.mean(list(in_degree.values())) mean_conns = int(mean_in + mean_out/2) k = 2 # number of neighbouig nodes to wire. p = 0.25 # probability of instead wiring to a random long range destination. ne = len(plot_excit)# size of small world network small_world_ring_excit = nx.watts_strogatz_graph(ne,mean_conns,0.25) k = 2 # number of neighbouring nodes to wire. p = 0.25 # probability of instead wiring to a random long range destination. ni = len(plot_inhib)# size of small world network small_world_ring_inhib = nx.watts_strogatz_graph(ni,mean_conns,0.25) nproc = sim.num_processes() nproc = 8 host_name = socket.gethostname() node_id = sim.setup(timestep=0.01, min_delay=1.0)#, **extra) print("Host #%d is on %s" % (node_id + 1, host_name)) rng = NumpyRNG(seed=64754) #pop_size = len(num_exc)+len(num_inh) #num_exc = [ i for i,e in enumerate(plot_excit) if sum(e) > 0 ] #num_inh = [ y for y,i in enumerate(plot_inhib) if sum(i) > 0 ] #pop_exc = sim.Population(len(num_exc), sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0)) #pop_inh = sim.Population(len(num_inh), sim.Izhikevich(a=0.02, b=0.25, c=-65, d=2, i_offset=0)) #index_exc = list(set(sanity_e)) #index_inh = list(set(sanity_i)) all_cells = sim.Population(len(index_exc)+len(index_inh), sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0)) #all_cells = None #all_cells = pop_exc + pop_inh pop_exc = sim.PopulationView(all_cells,index_exc) pop_inh = sim.PopulationView(all_cells,index_inh) #print(pop_exc) #print(dir(pop_exc)) for pe in pop_exc: print(pe) #import pdb pe = all_cells[pe] #pdb.set_trace() #pe = all_cells[i] r = random.uniform(0.0, 1.0) pe.set_parameters(a=0.02, b=0.2, c=-65+15*r, d=8-r**2, i_offset=0) #pop_exc.append(pe) #pop_exc = sim.Population(pop_exc) for pi in index_inh: pi = all_cells[pi] #print(pi) #pi = all_cells[i] r = random.uniform(0.0, 1.0) pi.set_parameters(a=0.02+0.08*r, b=0.25-0.05*r, c=-65, d= 2, i_offset=0) #pop_inh.append(pi) #pop_inh = sim.Population(pop_inh) ''' for pe in pop_exc: r = random.uniform(0.0, 1.0) pe.set_parameters(a=0.02, b=0.2, c=-65+15*r, d=8-r**2, i_offset=0) for pi in pop_inh: r = random.uniform(0.0, 1.0) pi.set_parameters(a=0.02+0.08*r, b=0.25-0.05*r, c=-65, d= 2, i_offset=0) ''' NEXC = len(num_exc) NINH = len(num_inh) exc_syn = sim.StaticSynapse(weight = wg, delay=delay_distr) assert np.any(internal_conn_ee.conn_list[:,0]) < ee_srcs.size prj_exc_exc = sim.Projection(all_cells, all_cells, internal_conn_ee, exc_syn, receptor_type='excitatory') prj_exc_inh = sim.Projection(all_cells, all_cells, internal_conn_ei, exc_syn, receptor_type='excitatory') inh_syn = sim.StaticSynapse(weight = wg, delay=delay_distr) delay_distr = RandomDistribution('normal', [1, 100e-3], rng=rng) prj_inh_inh = sim.Projection(all_cells, all_cells, internal_conn_ii, inh_syn, receptor_type='inhibitory') prj_inh_exc = sim.Projection(all_cells, all_cells, internal_conn_ie, inh_syn, receptor_type='inhibitory') inh_distr = RandomDistribution('normal', [1, 2.1e-3], rng=rng) def prj_change(prj,wg): prj.setWeights(wg) prj_change(prj_exc_exc,wg) prj_change(prj_exc_inh,wg) prj_change(prj_inh_exc,wg) prj_change(prj_inh_inh,wg) def prj_check(prj): for w in prj.weightHistogram(): for i in w: print(i) prj_check(prj_exc_exc) prj_check(prj_exc_inh) prj_check(prj_inh_exc) prj_check(prj_inh_inh) #print(rheobase['value']) #print(float(rheobase['value']),1.25/1000.0) '''Old values that worked noise = sim.NoisyCurrentSource(mean=0.85/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0) pop_exc.inject(noise) #1000.0 pA noise = sim.NoisyCurrentSource(mean=1.740/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0) pop_inh.inject(noise) #1750.0 pA ''' noise = sim.NoisyCurrentSource(mean=0.74/1000.0, stdev=4.00/1000.0, start=0.0, stop=2000.0, dt=1.0) pop_exc.inject(noise) #1000.0 pA noise = sim.NoisyCurrentSource(mean=1.440/1000.0, stdev=4.00/1000.0, start=0.0, stop=2000.0, dt=1.0) pop_inh.inject(noise) ## # Setup and run a simulation. Note there is no current injection into the neuron. # All cells in the network are in a quiescent state, so its not a surprise that xthere are no spikes ## sim = pyNN.neuron arange = np.arange import re all_cells.record(['v','spikes']) # , 'u']) all_cells.initialize(v=-65.0, u=-14.0) # === Run the simulation ===================================================== tstop = 2000.0 sim.run(tstop) data = None data = all_cells.get_data().segments[0] #print(len(data.analogsignals[0].times)) with open('pickles/qi'+str(wg)+'.p', 'wb') as f: pickle.dump(data,f) # make data none or else it will grow in a loop all_cells = None data = None noise = None
'cm': cm, 'v_rest': v_rest, 'v_thresh': v_thresh, 'tau_syn_E': tau_syn_E, 'tau_syn_I': tau_syn_I, 'e_rev_E': e_rev_E, 'e_rev_I': e_rev_I, 'v_reset': v_reset, 'tau_refrac': tau_refrac, 'i_offset': i_offset } cell_type = sim.IF_cond_exp(**neuronParameters) input = sim.Population(20, sim.SpikeSourcePoisson(rate=50.0)) output = sim.Population(25, cell_type) rand_distr = RandomDistribution('uniform', (v_reset, v_thresh), rng=NumpyRNG(seed=85524)) output.initialize(v=rand_distr) stdp = sim.STDPMechanism(weight_dependence=sim.AdditiveWeightDependence(w_min=0.0, w_max=0.1), timing_dependence=sim.Vogels2011Rule(eta=0.0, rho=1e-3), weight=0.005, delay=0.5)
def t4(): print 'Loading Forth XML File (iaf-2coba-Model)' print '----------------------------------------' component = readers.XMLReader.read_component(Join(tenml_dir, 'iaf_2coba.10ml'), component_name='iaf') writers.XMLWriter.write( component, '/tmp/nineml_toxml4.xml', ) model = readers.XMLReader.read_component(Join(tenml_dir, 'iaf_2coba.10ml')) from nineml.abstraction_layer.flattening import flatten from nineml.abstraction_layer.dynamics.utils.modifiers import ( DynamicsModifier) flatcomponent = flatten(model, componentname='iaf_2coba') DynamicsModifier.close_analog_port(component=flatcomponent, port_name='iaf_iSyn', value='0') writers.XMLWriter.write(flatcomponent, '/tmp/nineml_out_iaf_2coba.9ml') import pyNN.neuron as sim from pyNN.utility import init_logging init_logging(None, debug=True) sim.setup(timestep=0.1, min_delay=0.1) print 'Attempting to simulate From Model:' print '----------------------------------' celltype_cls = pyNNml.nineml_celltype_from_model( name="iaf_2coba", nineml_model=flatcomponent, synapse_components=[ pyNNml.CoBaSyn(namespace='cobaExcit', weight_connector='q'), pyNNml.CoBaSyn(namespace='cobaInhib', weight_connector='q'), ]) parameters = { 'iaf.cm': 1.0, 'iaf.gl': 50.0, 'iaf.taurefrac': 5.0, 'iaf.vrest': -65.0, 'iaf.vreset': -65.0, 'iaf.vthresh': -50.0, 'cobaExcit.tau': 2.0, 'cobaInhib.tau': 5.0, 'cobaExcit.vrev': 0.0, 'cobaInhib.vrev': -70.0, } parameters = ComponentFlattener.flatten_namespace_dict(parameters) cells = sim.Population(1, celltype_cls, parameters) cells.initialize('iaf_V', parameters['iaf_vrest']) cells.initialize('tspike', -1e99) # neuron not refractory at start cells.initialize('regime', 1002) # temporary hack input = sim.Population(2, sim.SpikeSourcePoisson, {'rate': 100}) connector = sim.OneToOneConnector(weights=1.0, delays=0.5) conn = [ sim.Projection(input[0:1], cells, connector, target='cobaExcit'), sim.Projection(input[1:2], cells, connector, target='cobaInhib') ] cells._record('iaf_V') cells._record('cobaExcit_g') cells._record('cobaInhib_g') cells._record('cobaExcit_I') cells._record('cobaInhib_I') cells.record() sim.run(100.0) cells.recorders['iaf_V'].write("Results/nineml_neuron.V", filter=[cells[0]]) cells.recorders['cobaExcit_g'].write("Results/nineml_neuron.g_exc", filter=[cells[0]]) cells.recorders['cobaInhib_g'].write("Results/nineml_neuron.g_inh", filter=[cells[0]]) cells.recorders['cobaExcit_I'].write("Results/nineml_neuron.g_exc", filter=[cells[0]]) cells.recorders['cobaInhib_I'].write("Results/nineml_neuron.g_inh", filter=[cells[0]]) t = cells.recorders['iaf_V'].get()[:, 1] v = cells.recorders['iaf_V'].get()[:, 2] gInh = cells.recorders['cobaInhib_g'].get()[:, 2] gExc = cells.recorders['cobaExcit_g'].get()[:, 2] IInh = cells.recorders['cobaInhib_I'].get()[:, 2] IExc = cells.recorders['cobaExcit_I'].get()[:, 2] import pylab pylab.subplot(311) pylab.ylabel('Voltage') pylab.plot(t, v) pylab.subplot(312) pylab.ylabel('Conductance') pylab.plot(t, gInh) pylab.plot(t, gExc) pylab.subplot(313) pylab.ylabel('Current') pylab.plot(t, IInh) pylab.plot(t, IExc) pylab.suptitle("From Tree-Model Pathway") pylab.show() sim.end()
w = 0.1 # synaptic weight (dimensionless) cell_params = { 'tau': 20.0, # (ms) 'refrac': 2.0, # (ms) } dt = 0.1 # (ms) syn_delay = 1.0 # (ms) input_rate = 50.0 # (Hz) simtime = 1000.0 # (ms) # === Build the network ======================================================== sim.setup(timestep=dt, max_delay=syn_delay) cells = sim.Population(n, sim.IntFire1(**cell_params), initial_values={'m': rnd('uniform', (0.0, 1.0))}, label="cells") number = int(2 * simtime * input_rate / 1000.0) np.random.seed(26278342) def generate_spike_times(i): gen = lambda: Sequence( np.add.accumulate( np.random.exponential(1000.0 / input_rate, size=number))) if hasattr(i, "__len__"): return [gen() for j in i] else: return gen()
from pyNN.utility.plotting import Figure, Panel t_stop = 100000 dt = 0.1 sim.setup(timestep=dt) cell_parameters = { 'v_reset': 10.0, 'tau_m': 20.0, 'v_rest': 0.0, 'tau_refrac': 2.0, 'v_thresh': 20.0, 'tau_syn_E': 2.0 } p = sim.Population(1, sim.IF_curr_alpha(**cell_parameters)) p.initialize(v=0.0) rate = 20 stim = sim.Population( 1, nineml_cell_type('Poisson', read("../sources/Poisson.xml")['Poisson'], {})(rate=rate)) stim.initialize(t_next=numpy.random.exponential(1000 / rate)) weight = 0.1 delay = 0.5 prj = sim.Projection(stim, p, sim.AllToAllConnector(), sim.StaticSynapse(weight=weight, delay=delay),
import pyNN.neuron as sim # can of course replace `nest` with `neuron`, `brian`, etc. import matplotlib.pyplot as plt from quantities import nA sim.setup() cell = sim.Population(1, sim.HH_cond_exp()) step_current = sim.DCSource(start=20.0, stop=80.0) step_current.inject_into(cell) cell.record('v') for amp in (-0.2, -0.1, 0.0, 0.1, 0.2): step_current.amplitude = amp sim.run(100.0) sim.reset(annotations={"amplitude": amp * nA}) data = cell.get_data() sim.end() for segment in data.segments: vm = segment.analogsignals[0] plt.plot(vm.times, vm, label=str(segment.annotations["amplitude"])) plt.legend(loc="upper left") plt.xlabel("Time (%s)" % vm.times.units._dimensionality) plt.ylabel("Membrane potential (%s)" % vm.units._dimensionality) plt.show()
def setUp(self): self.p = sim.Population(2, sim.IF_cond_exp()) self.rec = recording.Recorder(self.p) self.cells = self.p.all_cells # [MockID(22), MockID(29)]
import pyNN.neuron as sim # can of course replace `nest` with `neuron`, `brian`, etc. import matplotlib.pyplot as plt from quantities import nA from pyNN.random import RandomDistribution, NumpyRNG refractory_period=RandomDistribution('uniform', [2.0, 3.0], rng=NumpyRNG(seed=4242)) sim.setup() pyr_parameters= {'cm': 0.25, 'tau_m': 20.0, 'v_rest': -60, 'v_thresh': -50, 'tau_refrac': refractory_period, 'v_reset': -60, 'v_spike': -50.0, 'a': 1.0, 'b': 0.005, 'tau_w': 600, 'delta_T': 2.5, 'tau_syn_E': 5.0, 'e_rev_E': 0.0, 'tau_syn_I': 10.0, 'e_rev_I': -80 } pyrcell = sim.Population(1, sim.EIF_cond_exp_isfa_ista(**pyr_parameters)) step_current = sim.DCSource(start=20.0, stop=80.0) step_current.inject_into(pyrcell) pyrcell.record('v') print(pyrcell.celltype.recordable) for amp in (-0.2, -0.1, 0.0, 0.1, 0.2,0.3,0.4,0.5): step_current.amplitude = amp sim.run(150.0) sim.reset(annotations={"amplitude": amp * nA}) data = pyrcell.get_data() sim.end() for segment in data.segments: vm = segment.analogsignals[0] plt.plot(vm.times, vm,
def setUp(self): neuron.Population.nPop = 0 self.pop1 = neuron.Population((5,), neuron.IF_curr_alpha,{'tau_m':10.0}) self.pop2 = neuron.Population((5,4), neuron.IF_curr_exp,{'v_reset':-60.0})
def setUp(self): self.target = neuron.Population((3,3), neuron.IF_curr_alpha) self.source = neuron.Population((3,3), neuron.SpikeSourcePoisson,{'rate': 200}) self.distrib_Numpy = random.RandomDistribution(rng=random.NumpyRNG(12345), distribution='uniform', parameters=(0.2,1)) self.distrib_Native= random.RandomDistribution(rng=random.NativeRNG(12345), distribution='uniform', parameters=(0.2,1))
""" """ from plot_helper import plot_current_source import pyNN.neuron as sim sim.setup() population = sim.Population(30, sim.IF_cond_exp(tau_m=10.0)) population[0:1].record_v() noise = sim.NoisyCurrentSource(mean=1.5, stdev=1.0, start=50.0, stop=450.0, dt=1.0) population.inject(noise) noise._record() sim.run(500.0) t, i_inj = noise._get_data() v = population.get_data().segments[0].analogsignals[0] plot_current_source(t, i_inj, v, v_range=(-66, -48), v_ticks=(-65, -60, -55, -50), i_range=(-3, 5), i_ticks=range(-2, 6, 2), t_range=(0, 500))
import pyNN.neuron as sim # can of course replace `neuron` with `nest`, `brian`, etc. import matplotlib.pyplot as plt import numpy as np sim.setup(timestep=0.01) p_in = sim.Population(10, sim.SpikeSourcePoisson(rate=10.0), label="input") p_out = sim.Population(10, sim.EIF_cond_exp_isfa_ista(), label="AdExp neurons") syn = sim.StaticSynapse(weight=0.05) random = sim.FixedProbabilityConnector(p_connect=0.5) connections = sim.Projection(p_in, p_out, random, syn, receptor_type='excitatory') p_in.record('spikes') p_out.record('spikes') # record spikes from all neurons p_out[0:2].record(['v', 'w', 'gsyn_exc']) # record other variables from first two neurons sim.run(500.0) spikes_in = p_in.get_data() data_out = p_out.get_data() fig_settings = { 'lines.linewidth': 0.5, 'axes.linewidth': 0.5, 'axes.labelsize': 'small', 'legend.fontsize': 'small', 'font.size': 8 } plt.rcParams.update(fig_settings) plt.figure(1, figsize=(6, 8))
def run(plot_and_show=True): import sys from os.path import abspath, realpath, join import numpy import nineml root = abspath(join(realpath(nineml.__path__[0]), "../../..")) sys.path.append(join(root, "lib9ml/python/examples/AL")) sys.path.append(join(root, "code_generation/nmodl")) sys.path.append(join(root, "code_generation/nest2")) #from nineml.abstraction_layer.example_models import get_hierachical_iaf_3coba from nineml.abstraction_layer.testing_utils import TestableComponent from nineml.abstraction_layer.flattening import ComponentFlattener import pyNN.neuron as sim import pyNN.neuron.nineml as pyNNml from pyNN.utility import init_logging init_logging(None, debug=True) sim.setup(timestep=0.1, min_delay=0.1) #test_component = get_hierachical_iaf_3coba() test_component = TestableComponent('hierachical_iaf_3coba')() from nineml.abstraction_layer.writers import DotWriter DotWriter.write(test_component, 'test1.dot') from nineml.abstraction_layer.writers import XMLWriter XMLWriter.write(test_component, 'iaf_3coba.xml') celltype_cls = pyNNml.nineml_celltype_from_model( name="iaf_3coba", nineml_model=test_component, synapse_components=[ pyNNml.CoBaSyn(namespace='AMPA', weight_connector='q'), pyNNml.CoBaSyn(namespace='GABAa', weight_connector='q'), pyNNml.CoBaSyn(namespace='GABAb', weight_connector='q'), ]) parameters = { 'iaf.cm': 1.0, 'iaf.gl': 50.0, 'iaf.taurefrac': 5.0, 'iaf.vrest': -65.0, 'iaf.vreset': -65.0, 'iaf.vthresh': -50.0, 'AMPA.tau': 2.0, 'GABAa.tau': 5.0, 'GABAb.tau': 50.0, 'AMPA.vrev': 0.0, 'GABAa.vrev': -70.0, 'GABAb.vrev': -95.0, } parameters = ComponentFlattener.flatten_namespace_dict(parameters) cells = sim.Population(1, celltype_cls, parameters) cells.initialize('iaf_V', parameters['iaf_vrest']) cells.initialize('tspike', -1e99) # neuron not refractory at start cells.initialize('regime', 1002) # temporary hack input = sim.Population(3, sim.SpikeSourceArray) numpy.random.seed(12345) input[0].spike_times = numpy.add.accumulate( numpy.random.exponential(1000.0 / 100.0, size=1000)) input[1].spike_times = numpy.add.accumulate( numpy.random.exponential(1000.0 / 20.0, size=1000)) input[2].spike_times = numpy.add.accumulate( numpy.random.exponential(1000.0 / 50.0, size=1000)) connector = sim.OneToOneConnector(weights=1.0, delays=0.5) conn = [ sim.Projection(input[0:1], cells, connector, target='AMPA'), sim.Projection(input[1:2], cells, connector, target='GABAa'), sim.Projection(input[2:3], cells, connector, target='GABAb') ] cells._record('iaf_V') cells._record('AMPA_g') cells._record('GABAa_g') cells._record('GABAb_g') cells.record() sim.run(100.0) cells.recorders['iaf_V'].write("Results/nineml_neuron.V", filter=[cells[0]]) cells.recorders['AMPA_g'].write("Results/nineml_neuron.g_exc", filter=[cells[0]]) cells.recorders['GABAa_g'].write("Results/nineml_neuron.g_gabaA", filter=[cells[0]]) cells.recorders['GABAb_g'].write("Results/nineml_neuron.g_gagaB", filter=[cells[0]]) t = cells.recorders['iaf_V'].get()[:, 1] v = cells.recorders['iaf_V'].get()[:, 2] gInhA = cells.recorders['GABAa_g'].get()[:, 2] gInhB = cells.recorders['GABAb_g'].get()[:, 2] gExc = cells.recorders['AMPA_g'].get()[:, 2] if plot_and_show: import pylab pylab.subplot(211) pylab.plot(t, v) pylab.ylabel('voltage [mV]') pylab.suptitle("AMPA, GABA_A, GABA_B") pylab.subplot(212) pylab.plot(t, gInhA, label='GABA_A') pylab.plot(t, gInhB, label='GABA_B') pylab.plot(t, gExc, label='AMPA') pylab.ylabel('conductance [nS]') pylab.xlabel('t [ms]') pylab.legend() pylab.show() sim.end()
def std_pynn_simulation(test_component, parameters, initial_values, synapse_components, records, plot=True, sim_time=100., synapse_weights=1.0, syn_input_rate=100): from nineml.abstraction_layer.flattening import ComponentFlattener import pyNN.neuron as sim import pyNN.neuron.nineml as pyNNml from pyNN.neuron.nineml import CoBaSyn from pyNN.utility import init_logging init_logging(None, debug=True) sim.setup(timestep=0.01, min_delay=0.1) synapse_components_ML = [CoBaSyn(namespace=ns, weight_connector=wc) for (ns, wc) in synapse_components] celltype_cls = pyNNml.nineml_celltype_from_model( name=test_component.name, nineml_model=test_component, synapse_components=synapse_components_ML, ) parameters = ComponentFlattener.flatten_namespace_dict(parameters) initial_values = ComponentFlattener.flatten_namespace_dict(initial_values) cells = sim.Population(1, celltype_cls, parameters) # Set Initial Values: for state, state_initial_value in initial_values.iteritems(): cells.initialize(state, state_initial_value) # For each synapse type, create a spike source: if synapse_components: input = sim.Population( len(synapse_components), sim.SpikeSourcePoisson, {'rate': syn_input_rate}) connector = sim.OneToOneConnector(weights=synapse_weights, delays=0.5) conn = [] for i, (ns, weight_connector) in enumerate(synapse_components): proj = sim.Projection(input[i:i + 1], cells, connector, target=ns), conn.append(proj) # Setup the Records: for record in records: cells.record(record.what) cells.record('spikes') # Run the simulation: sim.run(sim_time) if len(records) == 0: assert False # Write the Results to a file: cells.write_data("Results/nineml.pkl") # Plot the values: results = cells.get_data().segments[0] # Create a list of the tags: tags = [] for record in records: if not record.tag in tags: tags.append(record.tag) # Plot the graphs: if plot: import pylab nGraphs = len(tags) # Plot the Records: for graphIndex, tag in enumerate(tags): pylab.subplot(nGraphs, 1, graphIndex + 1) for r in records: if r.tag != tag: continue trace = results.filter(name=r.what)[0] pylab.plot(trace.times, trace, label=r.label) pylab.ylabel(tag) pylab.legend() # Plot the spikes: # pylab.subplot(nGraphs,1, len(tags)+1) # t_spikes = cells[0:1].getSpikes()[:1] # pylab.plot( [1,3],[1,3],'x' ) # print t_spikes # if t_spikes: # pylab.scatter( t_spikes, t_spikes ) # Add the X axis to the last plot: pylab.xlabel('t [ms]') # pylab.suptitle("From Tree-Model Pathway") pylab.show() sim.end() return results
w_eff = weight/scale_factor delay = 0.5 print("\nEffective weight = {} nA\n".format(w_eff)) # PyNN/NineML simulation sim.setup(timestep=dt) celltype = Dynamics(name='iaf', subnodes={'nrn': read("../sources/BrunelIaF.xml")['BrunelIaF'], 'syn': read("../sources/AlphaPSR.xml")['AlphaPSR']}) celltype.connect_ports('syn.i_synaptic', 'nrn.i_synaptic') p = sim.Population(2, nineml_cell_type('BrunelIaF', celltype, {'syn': 'syn_weight'})(**cell_parameters)) stim = sim.Population(1, sim.SpikeSourceArray(spike_times=spike_times)) prj = sim.Projection(stim, p, sim.AllToAllConnector(), sim.StaticSynapse(weight=w_eff, delay=delay), receptor_type='syn') p.record(['nrn_v', 'syn_a', 'syn_b']) sim.run(t_stop) nrn_data = p.get_data().segments[0] expected = np.zeros((1 + int(round(t_stop/dt)),)) tau_syn = cell_parameters["syn_tau"]
'iaf.vthresh': -50.0, # NMDA parameters from Gertner's book, pg 53. 'nmda.taur': 3.0, # ms 'nmda.taud': 40.0, # ms 'nmda.gmax': 1.2, # nS 'nmda.E': 0.0, 'nmda.gamma': 0.062, # 1/mV 'nmda.mgconc': 1.2, # mM 'nmda.beta': 3.57 # mM } parameters = ComponentFlattener.flatten_namespace_dict(parameters) cells = sim.Population(1, celltype_cls, parameters) cells.initialize('iaf_V', parameters['iaf_vrest']) cells.initialize('tspike', -1e99) # neuron not refractory at start cells.initialize('regime', 1002) # temporary hack input = sim.Population(1, sim.SpikeSourcePoisson, {'rate': 100}) connector = sim.OneToOneConnector(weights=1.0, delays=0.5) conn = [ sim.Projection(input[0:1], cells, connector, target='nmda'), sim.Projection(input[0:1], cells, connector, target='cobaExcit'), ]
rec.record(self.spike_times) cell_params = { "c_m": 1.0, "i_offset": 0.0, "v_init": -65.0, "tau_e": 2.0, "tau_i": 2.0, "e_e": 0.0, "e_i": -75.0, } sim.setup() p0 = sim.Population(1, sim.SpikeSourcePoisson, {'rate': 100.0}) p1 = sim.Population(10, TestCell, cell_params) p2 = sim.Population(10, sim.IF_cond_exp) p1.record_v(1) p1.record() p2.record_v(1) #curr = sim.DCSource() #curr.inject_into(p1) prj01 = sim.Projection(p0, p1, sim.AllToAllConnector()) prj12 = sim.Projection(p1, p2, sim.FixedProbabilityConnector(0.5)) prj01.setWeights(0.1) prj12.setWeights(0.1)
nproc = sim.num_processes() nproc = 8 host_name = socket.gethostname() node_id = sim.setup(timestep=0.01, min_delay=1.0, **extra) print("Host #%d is on %s" % (node_id + 1, host_name)) print("%s Initialising the simulator with %d thread(s)..." % (node_id, extra['threads'])) #assert len(num_exc) < ml #assert len(num_inh) < ml pop_size = len(num_exc) + len(num_inh) num_exc = [i for i, e in enumerate(plot_excit) if sum(e) > 0] num_inh = [y for y, i in enumerate(plot_inhib) if sum(i) > 0] pop_exc = sim.Population(len(num_exc), sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0)) pop_inh = sim.Population( len(num_inh), sim.Izhikevich(a=0.02, b=0.25, c=-65, d=2, i_offset=0)) all_cells = pop_exc + pop_inh #pop_pre_exc = all_cells[list(set(pre_exc))] #pop_post_exc = all_cells[list(set(post_exc))] #pop_pre_inh = all_cells[list(set(pre_inh))] #pop_post_inh = all_cells[list(set(post_inh))] for pe in pop_exc: r = random.uniform(0.0, 1.0) pe.set_parameters(a=0.02, b=0.2, c=-65 + 15 * r, d=8 - r**2, i_offset=0) for pe in pop_inh:
## Chose the neuron type ## # Works only in NEST and NEURON # Warning: don't try to use sim.cells.IF_cond_exp_gsfa_grr myModel = sim.IF_cond_exp_gsfa_grr ## Simulation creation ## # Creates a file that never closes sim.setup(timestep=dt, min_delay=dt, max_delay=30.0, default_maxstep=distanceFactor, debug=True, quit_on_end=False) ## Define popultation ## myLabelE = "Simulated excitatory adapting neurons" myLabelI = "Simulated inhibitory adapting neurons" numberOfNeuronsI = int(latticeSize**3 * propOfI) numberOfNeuronsE = int(latticeSize**3 - numberOfNeuronsI) popE = sim.Population((numberOfNeuronsE,), myModel, params.excitatory, label=myLabelE) popI = sim.Population((numberOfNeuronsI,), myModel, params.inhibitory, label=myLabelI) #all_cells = Assembly("All cells", popE, popI) # excitatory Poisson poissonE_Eparams = {'rate': rateE_E * connectionsE_E, 'start': 0.0, 'duration': tsim} poissonE_Iparams = {'rate': rateE_I * connectionsE_I, 'start': 0.0, 'duration': tsim} poissonE_E = sim.Population((numberOfNeuronsE,), cellclass=sim.SpikeSourcePoisson, cellparams=poissonE_Eparams, label='poissonE_E') poissonE_I = sim.Population((numberOfNeuronsI,), cellclass=sim.SpikeSourcePoisson, cellparams=poissonE_Iparams, label='poissonE_I') # inhibitory Poisson poissonI_Eparams = {'rate': rateI_E * connectionsI_E, 'start': 0.0,