def do_run(nNeurons): p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0) p.set_number_of_neurons_per_core(p.IF_curr_exp, 100) cell_params_lif = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 10.0, 'tau_refrac': 2.0, 'tau_syn_E': 0.5, 'tau_syn_I': 0.5, 'v_reset': -65.0, 'v_rest': -65.0, 'v_thresh': -64.4 } populations = list() projections = list() weight_to_spike = 2 injection_delay = 2 delay = 10 spikeArray = {'spike_times': [[0]]} populations.append( p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1')) populations.append( p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1')) synapse_type = p.StaticSynapse(weight=weight_to_spike, delay=delay) connector = p.AllToAllConnector() projections.append( p.Projection(populations[0], populations[0], connector, synapse_type=synapse_type)) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector([(0, 0, 4, injection_delay)]))) populations[0].record("v") populations[0].record("gsyn_exc") populations[0].record("spikes") p.run(90) neo = populations[0].get_data(["v", "spikes", "gsyn_exc"]) v = neo_convertor.convert_data(neo, name="v") gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") spikes = neo_convertor.convert_spikes(neo) p.end() return (v, gsyn, spikes)
def do_run(nNeurons): p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0) p.set_number_of_neurons_per_core(p.Izhikevich, 100) cell_params_izk = { 'a': 0.02, 'b': 0.2, 'c': -65, 'd': 8, 'v': -75, 'u': 0, 'tau_syn_E': 2, 'tau_syn_I': 2, 'i_offset': 0 } populations = list() projections = list() weight_to_spike = 40 delay = 1 connections = list() for i in range(0, nNeurons): singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay) connections.append(singleConnection) injectionConnection = [(0, 0, weight_to_spike, delay)] spikeArray = {'spike_times': [[50]]} populations.append( p.Population(nNeurons, p.Izhikevich, cell_params_izk, label='pop_1')) populations.append( p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1')) projections.append( p.Projection(populations[0], populations[0], p.FromListConnector(connections))) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection))) populations[0].record("v") populations[0].record("gsyn_exc") populations[0].record("spikes") p.run(500) neo = populations[0].get_data(["v", "spikes", "gsyn_exc"]) v = neo_convertor.convert_data(neo, name="v") gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") spikes = neo_convertor.convert_spikes(neo) p.end() return (v, gsyn, spikes)
def check_run(self): all1, all2 = do_run() spikes1 = neo_convertor.convert_spiketrains( all1.segments[0].spiketrains) spikes2 = neo_convertor.convert_spiketrains( all2.segments[1].spiketrains) self.assertEqual(spikes1.all(), spikes2.all()) v1 = neo_convertor.convert_data(all1, name="v", run=0) v2 = neo_convertor.convert_data(all2, name="v", run=1) self.assertEqual(v1.all(), v2.all())
def a_run(self): v, spikes, weights = do_run(plot=False) # any checks go here v_test = neo_convertor.convert_data(v, name='v') spikes_test = neo_convertor.convert_data(spikes, name='spikes') self.assertEqual(25000, len(v_test)) # Not sure checking spike len is telling us much self.assertLess(7750, len(spikes_test)) self.assertGreater(8250, len(spikes_test)) self.check_weights(weights)
def do_run(): p.setup(timestep=1.0, min_delay=1.0, max_delay=10.0, db_name='if_cond.sqlite') cell_params = { 'i_offset': .1, 'tau_refrac': 3.0, 'v_rest': -65.0, 'v_thresh': -51.0, 'tau_syn_E': 2.0, 'tau_syn_I': 5.0, 'v_reset': -70.0 } ifcell = p.Population(1, p.IF_curr_exp, cell_params, label='IF_curr_exp') spike_sourceE = p.Population( 1, p.SpikeSourceArray, {'spike_times': [ [i for i in range(5, 105, 10)], ]}, label='spike_sourceE') p.Projection(spike_sourceE, ifcell, p.OneToOneConnector(), synapse_type=p.StaticSynapse(weight=1, delay=2), receptor_type="excitatory") breakMe = True if breakMe: p.Projection(spike_sourceE, ifcell, p.OneToOneConnector(), synapse_type=p.StaticSynapse(weight=1, delay=2), receptor_type="excitatory") ifcell.record("v") ifcell.record("gsyn_exc") p.run(200.0) neo = ifcell.get_data(["v", "gsyn_exc"]) recorded_v = neo_convertor.convert_data(neo, name="v") recorded_gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") p.end() return (recorded_v, recorded_gsyn)
def test_get_gsyn(self): try: synfire_run.do_run(n_neurons, max_delay=max_delay, time_step=timestep, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], gsyn_path_exc=gsyn_path) spikes = synfire_run.get_output_pop_spikes_numpy() g_syn = synfire_run.get_output_pop_gsyn_exc_numpy() spike_checker.synfire_spike_checker(spikes, n_neurons) try: with open(gsyn_path, "r") as gsyn_file: gsyn2_neo = pickle.load(gsyn_file) gsyn2_numpy = neo_convertor.convert_data(gsyn2_neo, run=0, name="gsyn_exc") self.assertTrue(numpy.allclose(g_syn, gsyn2_numpy)) except UnicodeDecodeError: raise SkipTest( "https://github.com/NeuralEnsemble/python-neo/issues/529") finally: os.remove(gsyn_path) except SpinnmanTimeoutException as ex: # System intentional overload so may error raise SkipTest(ex)
def do_run(self): p.setup(timestep=1.0, min_delay=1.0, max_delay=1.0) cell_params = { 'i_offset': .1, 'tau_refrac': 3.0, 'v_rest': -65.0, 'v_thresh': -51.0, 'tau_syn_E': 2.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'e_rev_E': 0., 'e_rev_I': -80. } # setup test population if_pop = p.Population(1, p.IF_cond_exp, cell_params) # setup spike sources spike_times = [20., 40., 60.] exc_pop = p.Population(1, p.SpikeSourceArray, {'spike_times': spike_times}) inh_pop = p.Population(1, p.SpikeSourceArray, {'spike_times': [120, 140, 160]}) # setup excitatory and inhibitory connections listcon = p.FromListConnector([(0, 0, 0.05, 1.0)]) p.Projection(exc_pop, if_pop, listcon, receptor_type='excitatory') p.Projection(inh_pop, if_pop, listcon, receptor_type='inhibitory') # setup recorder if_pop.record(["v"]) p.run(100) p.reset() if_pop.initialize(v=-65) exc_pop.set(spike_times=[]) inh_pop.set(spike_times=spike_times) p.run(100) # read out voltage and plot neo = if_pop.get_data("all") p.end() v = neo_convertor.convert_data(neo, "v", run=0) v2 = neo_convertor.convert_data(neo, "v", run=1) self.assertGreater(v[22][2], v[21][2]) self.assertGreater(v[42][2], v[41][2]) self.assertGreater(v[62][2], v[61][2]) self.assertLess(v2[22][2], v2[21][2]) self.assertLess(v2[42][2], v2[41][2]) self.assertLess(v2[62][2], v2[61][2])
def test_run(self): synfire_run.do_run(nNeurons, spike_times=spike_times, reset=reset, run_times=runtimes, neurons_per_core=neurons_per_core, get_all=True) neos = synfire_run.get_output_pop_all_list() spikes_0_0 = neo_convertor.convert_spikes(neos[0], 0) spikes_1_1 = neo_convertor.convert_spikes(neos[1], 1) self.assertEquals(53, len(spikes_0_0)) self.assertEquals(156, len(spikes_1_1)) spike_checker.synfire_spike_checker(spikes_0_0, nNeurons) spike_checker.synfire_multiple_lines_spike_checker( spikes_1_1, nNeurons, 2) # v + gsyn_exc + gsyn_ihn = 3 (spikes not in analogsignalarrays if pynn8_syntax: self.assertEquals(3, len(neos[0].segments[0].analogsignalarrays)) self.assertEquals(3, len(neos[1].segments[0].analogsignalarrays)) self.assertEquals(3, len(neos[1].segments[1].analogsignalarrays)) else: self.assertEquals(3, len(neos[0].segments[0].analogsignals)) self.assertEquals(3, len(neos[1].segments[0].analogsignals)) self.assertEquals(3, len(neos[1].segments[1].analogsignals)) neo_compare.compare_segments(neos[0].segments[0], neos[1].segments[0]) # neo compare does all the compares so just some safety come once spikes_1_0 = neo_convertor.convert_spikes(neos[1], 0) for s1, s2 in zip(spikes_0_0, spikes_1_0): for (a1, a2) in zip(s1, s2): self.assertEquals(a1, a2) v_0_0 = neo_convertor.convert_data(neos[0], "v", 0) v_1_0 = neo_convertor.convert_data(neos[1], "v", 0) v_1_1 = neo_convertor.convert_data(neos[1], "v", 1) self.assertEquals(nNeurons * runtimes[0], len(v_0_0)) self.assertEquals(nNeurons * runtimes[0], len(v_1_0)) self.assertEquals(nNeurons * runtimes[1], len(v_1_1)) gsyn_exc_0_0 = neo_convertor.convert_data(neos[0], "gsyn_exc", 0) gsyn_exc_1_0 = neo_convertor.convert_data(neos[1], "gsyn_exc", 0) gsyn_exc_1_1 = neo_convertor.convert_data(neos[1], "gsyn_exc", 1) self.assertEquals(nNeurons * runtimes[0], len(gsyn_exc_0_0)) self.assertEquals(nNeurons * runtimes[0], len(gsyn_exc_1_0)) self.assertEquals(nNeurons * runtimes[1], len(gsyn_exc_1_1)) gsyn_inh_0_0 = neo_convertor.convert_data(neos[0], "gsyn_inh", 0) gsyn_inh_1_0 = neo_convertor.convert_data(neos[1], "gsyn_inh", 0) gsyn_inh_1_1 = neo_convertor.convert_data(neos[1], "gsyn_inh", 1) self.assertEquals(nNeurons * runtimes[0], len(gsyn_inh_0_0)) self.assertEquals(nNeurons * runtimes[0], len(gsyn_inh_1_0)) self.assertEquals(nNeurons * runtimes[1], len(gsyn_inh_1_1))
def check_results(self, neo, expected_spikes): spikes = neo_convertor.convert_spikes(neo) v = neo_convertor.convert_data(neo, name="v") print(spikes) for i, spike in enumerate(expected_spikes): self.assertEqual(spikes[i][1], spike) self.assertEqual(spikes.shape, (len(spikes), 2)) for spike in expected_spikes: print(spike, v[spike][2], v[spike + 1][2]) self.assertTrue(v[spike][2] > v[spike + 1][2])
def do_run(nNeurons): p.setup(timestep=1.0, min_delay=1.0, max_delay=8.0) cell_params_lif_in = { 'tau_m': 333.33, 'cm': 208.33, 'v': [0.0, 0.0146789550781, 0.029296875, 0.0438842773438, 0.0584106445312], 'v_rest': 0.1, 'v_reset': 0.0, 'v_thresh': 1.0, 'tau_syn_E': 1, 'tau_syn_I': 2, 'tau_refrac': 2.5, 'i_offset': 3.0 } pop1 = p.Population(nNeurons, p.IF_curr_exp, cell_params_lif_in, label='pop_0') pop1.record("v") pop1.record("gsyn_exc") pop1.record("spikes") p.run(100) neo = pop1.get_data(["v", "spikes", "gsyn_exc"]) v = neo_convertor.convert_data(neo, name="v") gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") spikes = neo_convertor.convert_spikes(neo) p.end() return (v, gsyn, spikes)
def do_run(nNeurons): p.setup(timestep=0.1, min_delay=1.0, max_delay=7.5) p.set_number_of_neurons_per_core(p.IF_curr_exp, 100) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 6, 'tau_syn_I': 6, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -55.4} populations = list() projections = list() weight_to_spike = 12 injection_delay = 1 delay = 1 spikeArray = {'spike_times': [[0, 10, 20, 30]]} populations.append(p.Population(1, p.SpikeSourceArray, spikeArray, label='pop_0')) populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1')) populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_2')) connector = p.AllToAllConnector() synapse_type = p.StaticSynapse(weight=weight_to_spike, delay=injection_delay) projections.append(p.Projection(populations[0], populations[1], connector, synapse_type=synapse_type)) connector = p.OneToOneConnector() synapse_type = p.StaticSynapse(weight=weight_to_spike, delay=delay) projections.append(p.Projection(populations[1], populations[2], connector, synapse_type=synapse_type)) populations[1].record("v") populations[1].record("spikes") p.run(100) neo = populations[1].get_data(["v", "spikes"]) v = neo_convertor.convert_data(neo, name="v") spikes = neo_convertor.convert_spikes(neo) p.end() return (v, spikes)
def test_get_gsyn(self): try: synfire_run.do_run(n_neurons, max_delay=max_delay, time_step=timestep, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], gsyn_path_exc=gsyn_path) spikes = synfire_run.get_output_pop_spikes_numpy() g_syn = synfire_run.get_output_pop_gsyn_exc_numpy() spike_checker.synfire_spike_checker(spikes, n_neurons) io = PickleIO(filename=gsyn_path) gsyn2_neo = io.read()[0] gsyn2_numpy = neo_convertor.convert_data( gsyn2_neo, run=0, name="gsyn_exc") self.assertTrue(numpy.allclose(g_syn, gsyn2_numpy)) os.remove(gsyn_path) except SpinnmanTimeoutException as ex: # System intentional overload so may error raise SkipTest(ex)
def test_run(self): synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, extract_between_runs=extract_between_runs, reset=reset, new_pop=new_pop, get_all=True) # Note this is a list of length 1 # as no get data is done after first run neos = synfire_run.get_output_pop_all_list() spikes_0_0 = neo_convertor.convert_spikes(neos[0], 0) spikes_1_1 = neo_convertor.convert_spikes(neos[0], 1) self.assertEquals(53, len(spikes_0_0)) self.assertEquals(53, len(spikes_1_1)) spike_checker.synfire_spike_checker(spikes_0_0, nNeurons) spike_checker.synfire_spike_checker(spikes_1_1, nNeurons) # v + gsyn_exc + gsyn_ihn = 3 (spikes not in analogsignalarrays if pynn8_syntax: self.assertEquals(3, len(neos[0].segments[0].analogsignalarrays)) self.assertEquals(3, len(neos[0].segments[0].analogsignalarrays)) else: self.assertEquals(3, len(neos[0].segments[0].analogsignals)) self.assertEquals(3, len(neos[0].segments[0].analogsignals)) neo_compare.compare_segments(neos[0].segments[0], neos[0].segments[1]) # neo compare does all the compares so just some safety come once v_0_0 = neo_convertor.convert_data(neos[0], "v", 0) v_1_1 = neo_convertor.convert_data(neos[0], "v", 1) self.assertEquals(nNeurons * run_times[0], len(v_0_0)) self.assertEquals(nNeurons * run_times[1], len(v_1_1)) gsyn_exc_0_0 = neo_convertor.convert_data(neos[0], "gsyn_exc", 0) gsyn_exc_1_1 = neo_convertor.convert_data(neos[0], "gsyn_exc", 1) self.assertEquals(nNeurons * run_times[0], len(gsyn_exc_0_0)) self.assertEquals(nNeurons * run_times[1], len(gsyn_exc_1_1)) gsyn_inh_0_0 = neo_convertor.convert_data(neos[0], "gsyn_inh", 0) gsyn_inh_1_1 = neo_convertor.convert_data(neos[0], "gsyn_inh", 1) self.assertEquals(nNeurons * run_times[0], len(gsyn_inh_0_0)) self.assertEquals(nNeurons * run_times[1], len(gsyn_inh_1_1))
def do_run(nNeurons): p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0) p.set_number_of_neurons_per_core(p.IF_curr_exp, 250) cell_params_lif = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 5.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } populations = list() projections = list() weight_to_spike = 1.5 delay = 1 connections = list() for i in range(0, nNeurons): singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay) connections.append(singleConnection) injectionConnection = [(0, 0, weight_to_spike, delay)] spikeArray = {'spike_times': [[0]]} populations.append( p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1')) populations.append( p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1')) projections.append( p.Projection(populations[0], populations[0], p.FromListConnector(connections))) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection))) populations[0].record("v") populations[0].record("gsyn_exc") populations[0].record("spikes") p.run(1000) '''' weights = projections[0].getWeights() delays = projections[0].getDelays() ''' neo = populations[0].get_data(["v", "spikes", "gsyn_exc"]) v = neo_convertor.convert_data(neo, name="v") gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") spikes = neo_convertor.convert_spikes(neo) p.end() return (v, gsyn, spikes)
def do_run(nNeurons): p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0) p.set_number_of_neurons_per_core(p.IF_curr_exp, 100) cm = list() i_off = list() tau_m = list() tau_re = list() tau_syn_e = list() tau_syn_i = list() v_reset = list() v_rest = list() v_thresh = list() cell_params_lif = { 'cm': cm, 'i_offset': i_off, 'tau_m': tau_m, 'tau_refrac': tau_re, 'tau_syn_E': tau_syn_e, 'tau_syn_I': tau_syn_i, 'v_reset': v_reset, 'v_rest': v_rest, 'v_thresh': v_thresh } for atom in range(0, nNeurons): cm.append(0.25) i_off.append(0.0) tau_m.append(10.0) tau_re.append(2.0) tau_syn_e.append(0.5) tau_syn_i.append(0.5) v_reset.append(-65.0) v_rest.append(-65.0) v_thresh.append(-64.4) gbar_na_distr = RandomDistribution('normal', (20.0, 2.0), rng=NumpyRNG(seed=85524)) cell_params_lif = { 'cm': cm, 'i_offset': i_off, 'tau_m': tau_m, 'tau_refrac': tau_re, 'tau_syn_E': tau_syn_e, 'tau_syn_I': tau_syn_i, 'v_reset': v_reset, 'v_rest': v_rest, 'v_thresh': v_thresh } populations = list() projections = list() weight_to_spike = 2 delay = 1 connections = list() for i in range(0, nNeurons): singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay) connections.append(singleConnection) injectionConnection = [(0, 0, weight_to_spike, delay)] spikeArray = {'spike_times': [[0]]} populations.append( p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1')) populations.append( p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1')) populations[0].set(cm=0.25) populations[0].set(cm=cm) populations[0].set(tau_m=tau_m, v_thresh=v_thresh) populations[0].set(i_offset=gbar_na_distr) populations[0].set(i_offset=i_off) projections.append( p.Projection(populations[0], populations[0], p.FromListConnector(connections))) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection))) populations[0].record("v") populations[0].record("gsyn_exc") populations[0].record("spikes") p.run(100) neo = populations[0].get_data(["v", "spikes", "gsyn_exc"]) v = neo_convertor.convert_data(neo, name="v") gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") spikes = neo_convertor.convert_spikes(neo) p.end() return (v, gsyn, spikes)
exc_pop = p.Population(1, p.SpikeSourceArray, {'spike_times': [20., 40., 60.]}) inh_pop = p.Population(1, p.SpikeSourceArray, {'spike_times': [120., 140., 160.]}) # setup excitatory and inhibitory connections listcon = p.FromListConnector([(0, 0, 0.01, 1.0)]) p.Projection(exc_pop, if_pop, listcon, receptor_type='excitatory') p.Projection(inh_pop, if_pop, listcon, receptor_type='inhibitory') # setup recorder if_pop.record("v") p.run(200.) # read out voltage and plot neo = if_pop.get_data("v") p.end() return neo class TestSynapsesExcitVsInhib(BaseTestCase): def test_run(self): do_run() if __name__ == '__main__': neo = do_run() V = neo_convertor.convert_data(neo, "v") import pylab # deferred so unittest are not dependent on it pylab.plot(V[:, 1], V[:, 2], '.', label=p.__name__) pylab.legend() pylab.show()
def do_run(nNeurons, neurons_per_core): p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0) p.set_number_of_neurons_per_core(p.IF_curr_exp, neurons_per_core) nPopulations = 62 cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0} populations = list() projections = list() weight_to_spike = 1.5 delay = 5 for i in range(0, nPopulations): populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_' + str(i))) # print("++++++++++++++++") # print("Added population %s" % (i)) # print("o-o-o-o-o-o-o-o-") synapse_type = p.StaticSynapse(weight=weight_to_spike, delay=delay) for i in range(0, nPopulations): projections.append(p.Projection(populations[i], populations[(i + 1) % nPopulations], p.OneToOneConnector(), synapse_type=synapse_type, label="Projection from pop {} to pop " "{}".format(i, (i + 1) % nPopulations))) # print("++++++++++++++++++++++++++++++++++++++++++++++++++++") # print("Added projection from population %s to population %s" \ # % (i, (i + 1) % nPopulations)) # print("----------------------------------------------------") # from pprint import pprint as pp # pp(projections) spikeArray = {'spike_times': [[0]]} populations.append(p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1')) projections.append(p.Projection(populations[-1], populations[0], p.AllToAllConnector(), synapse_type=synapse_type)) for i in range(0, nPopulations): populations[i].record("v") populations[i].record("gsyn_exc") populations[i].record("spikes") p.run(1500) '''' weights = projections[0].getWeights() delays = projections[0].getDelays() ''' neo = populations[0].get_data(["v", "spikes", "gsyn_exc"]) v = neo_convertor.convert_data(neo, name="v") gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") spikes = neo_convertor.convert_spikes(neo) p.end() return (v, gsyn, spikes)
def do_run(nNeurons): p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) p.set_number_of_neurons_per_core(p.IF_curr_exp, nNeurons / 2) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } p.set_number_of_neurons_per_core(p.IF_cond_exp, nNeurons / 2) cell_params_cond = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0, 'e_rev_E': 0., 'e_rev_I': -80. } p.set_number_of_neurons_per_core(p.Izhikevich, 100) cell_params_izk = {'a': 0.02, 'b': 0.2, 'c': -65, 'd': 8, 'v_init': -75, 'u_init': 0, 'tau_syn_E': 2, 'tau_syn_I': 2, 'i_offset': 0 } populations = list() projections = list() current_weight_to_spike = 2.0 cond_weight_to_spike = 0.035 delay = 17 # different strangths of connection curr_injection_connection = [(0, 0, current_weight_to_spike, delay)] cond_injection_connection = [(0, 0, cond_weight_to_spike, delay)] izk_injection_connection = [(0, 0, current_weight_to_spike, delay)] sinkConnection = [(0, 0, 0, 1)] # spike time spikeArray = {'spike_times': [[0]]} # curr set up populations.append(p.Population(nNeurons, p.IF_cond_exp, cell_params_cond, label='pop_cond')) # cond setup populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_curr')) # izk setup populations.append(p.Population(nNeurons, p.Izhikevich, cell_params_izk, label='izk pop')) # sink pop for spikes to go to (otherwise they are not recorded as firing) populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='sink_pop')) populations.append(p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpike')) pop = p.Projection(populations[4], populations[0], p.FromListConnector(cond_injection_connection)) projections.append(pop) pop = p.Projection(populations[4], populations[1], p.FromListConnector(curr_injection_connection)) projections.append(pop) pop = p.Projection(populations[4], populations[2], p.FromListConnector(izk_injection_connection)) projections.append(pop) projections.append(p.Projection(populations[2], populations[3], p.FromListConnector(sinkConnection))) projections.append(p.Projection(populations[1], populations[3], p.FromListConnector(sinkConnection))) projections.append(p.Projection(populations[0], populations[3], p.FromListConnector(sinkConnection))) # record stuff for cond populations[0].record("v") populations[0].record("gsyn_exc") populations[0].record("spikes") # record stuff for curr populations[1].record("v") populations[1].record("gsyn_exc") populations[1].record("spikes") # record stuff for izk populations[2].record("v") populations[2].record("gsyn_exc") populations[2].record("spikes") p.run(500) # get cond neo = populations[0].get_data(["v", "spikes", "gsyn_exc"]) cond_v = neo_convertor.convert_data(neo, name="v") cond_gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") cond_spikes = neo_convertor.convert_spikes(neo) # get curr neo = populations[1].get_data(["v", "spikes", "gsyn_exc"]) curr_v = neo_convertor.convert_data(neo, name="v") curr_gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") curr_spikes = neo_convertor.convert_spikes(neo) # get izk neo = populations[1].get_data(["v", "spikes", "gsyn_exc"]) izk_v = neo_convertor.convert_data(neo, name="v") izk_gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") izk_spikes = neo_convertor.convert_spikes(neo) p.end() return (cond_v, cond_gsyn, cond_spikes, curr_v, curr_gsyn, curr_spikes, izk_v, izk_gsyn, izk_spikes)
n_cores = 1 neo = do_run(n_neurons, n_cores, 0.1875) spiketrains = neo.segments[0].spiketrains for spiketrain in spiketrains: self.assertEquals(0, len(spiketrain)) def test_three_cores(self): n_neurons = 40 n_cores = 3 neo = do_run(n_neurons, n_cores, 0.1875) spiketrains = neo.segments[0].spiketrains for spiketrain in spiketrains: self.assertEquals(0, len(spiketrain)) if __name__ == '__main__': n_neurons = 40 n_cores = 3 neo = do_run(n_neurons, n_cores, 0.1875) spikes = neo_convertor.convert_spikes(neo) v = neo_convertor.convert_data(neo, "v") gsyn = neo_convertor.convert_data(neo, "gsyn_exc") print(spikes) plot_utils.plot_spikes(spikes) plot_utils.heat_plot(v) plot_utils.heat_plot(gsyn) times = set(spikes[:, 1]) print(n_neurons * len(times), len(spikes))
def do_run(nNeurons): p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) max_delay = 50 p.set_number_of_neurons_per_core(p.IF_curr_exp, nNeurons / 2) cell_params_lif = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } populations = list() projections = list() weight_to_spike = 2.0 delay = numpy.random.RandomState() delays = list() connections = list() for i in range(0, nNeurons): d_value = int(delay.uniform(low=1, high=max_delay)) delays.append(float(d_value)) singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, d_value) connections.append(singleConnection) injectionConnection = [(0, 0, weight_to_spike, 1)] spikeArray = {'spike_times': [[0]]} populations.append( p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1')) populations.append( p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1')) projections.append( p.Projection(populations[0], populations[0], p.FromListConnector(connections))) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection))) populations[0].record("v") populations[0].record("gsyn_exc") populations[0].record("spikes") run_time = (max_delay * nNeurons) print("Running for {} ms".format(run_time)) p.run(run_time) neo = populations[0].get_data(["v", "spikes", "gsyn_exc"]) v = neo_convertor.convert_data(neo, name="v") gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") spikes = neo_convertor.convert_spikes(neo) p.end() return (v, gsyn, spikes)
def do_run(nNeurons): p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) p.set_number_of_neurons_per_core(p.IF_curr_exp, nNeurons / 2) cell_params_lif = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } p.set_number_of_neurons_per_core(p.IF_cond_exp, nNeurons / 2) cell_params_cond = { 'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0, 'e_rev_E': 0., 'e_rev_I': -80. } populations = list() projections = list() weight_to_spike = 0.035 delay = 17 injectionConnection = [(0, 0, weight_to_spike, delay)] sinkConnection = [(0, 0, weight_to_spike, 1)] spikeArray = {'spike_times': [[0]]} populations.append( p.Population(nNeurons, p.IF_cond_exp, cell_params_cond, label='pop_cond')) populations.append( p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1')) populations.append( p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_curr')) populations.append( p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_2')) populations.append( p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='sink_pop')) projections.append( p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection))) projections.append( p.Projection(populations[3], populations[2], p.FromListConnector(injectionConnection))) projections.append( p.Projection(populations[0], populations[4], p.FromListConnector(sinkConnection))) projections.append( p.Projection(populations[2], populations[4], p.FromListConnector(sinkConnection))) populations[0].record("v") populations[0].record("gsyn_exc") populations[0].record("spikes") populations[2].record("v") populations[2].record("gsyn_exc") populations[2].record("spikes") p.run(500) neo = populations[0].get_data(["v", "spikes", "gsyn_exc"]) cond_v = neo_convertor.convert_data(neo, name="v") cond_gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") cond_spikes = neo_convertor.convert_spikes(neo) neo = populations[2].get_data(["v", "spikes", "gsyn_exc"]) curr_v = neo_convertor.convert_data(neo, name="v") curr_gsyn = neo_convertor.convert_data(neo, name="gsyn_exc") curr_spikes = neo_convertor.convert_spikes(neo) p.end() return (cond_v, cond_gsyn, cond_spikes, curr_v, curr_gsyn, curr_spikes)
def get_output_pop_voltage_numpy(self): v_neo = self._recorded_v_list[0] return neo_convertor.convert_data(v_neo, "v")
def get_output_pop_gsyn_inh_numpy(self): gsyn_inh_neo = self._recorded_gsyn_inh_list[0] return neo_convertor.convert_data(gsyn_inh_neo, "gsyn_exc")
return (all1, all2) class TinyTest(BaseTestCase): def check_run(self): all1, all2 = do_run() spikes1 = neo_convertor.convert_spiketrains( all1.segments[0].spiketrains) spikes2 = neo_convertor.convert_spiketrains( all2.segments[1].spiketrains) self.assertEqual(spikes1.all(), spikes2.all()) v1 = neo_convertor.convert_data(all1, name="v", run=0) v2 = neo_convertor.convert_data(all2, name="v", run=1) self.assertEqual(v1.all(), v2.all()) def test_run(self): self.runsafe(self.check_run) if __name__ == '__main__': all1, all2 = do_run() spikes1 = neo_convertor.convert_spiketrains(all1.segments[0].spiketrains) print(spikes1) spikes2 = neo_convertor.convert_spiketrains(all2.segments[1].spiketrains) print(spikes2) v1 = neo_convertor.convert_data(all1, name="v", run=0) print(v1) v2 = neo_convertor.convert_data(all2, name="v", run=1) print(v2)
if __name__ == '__main__': # Delayed imports so unit tests do not need them from pyNN.utility.plotting import Figure import matplotlib.pyplot as plt synfire_run.do_run(n_neurons, max_delay=max_delay, time_step=timestep, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], gsyn_path_exc=gsyn_path) spikes = synfire_run.get_output_pop_spikes_numpy() g_syn = synfire_run.get_output_pop_gsyn_exc_numpy() spike_checker.synfire_spike_checker(spikes, n_neurons) with open(gsyn_path, "r") as gsyn_file: gsyn2_neo = pickle.load(gsyn_file) gsyn2_numpy = neo_convertor.convert_data(gsyn2_neo, run=0, name="gsyn_exc") print(len(spikes)) Figure(SpynnakerPanel(spikes, yticks=True, xticks=True, markersize=4, xlim=(0, runtime)), SpynnakerPanel(gsyn2_neo, yticks=True), title="TestPrintGsyn".format(delay), annotations="generated by {}".format(__file__)) plt.show() os.remove(gsyn_path)
gsyn_inh_0_0 = neo_convertor.convert_data(neos[0], "gsyn_inh", 0) gsyn_inh_1_0 = neo_convertor.convert_data(neos[1], "gsyn_inh", 0) gsyn_inh_1_1 = neo_convertor.convert_data(neos[1], "gsyn_inh", 1) self.assertEquals(nNeurons * runtimes[0], len(gsyn_inh_0_0)) self.assertEquals(nNeurons * runtimes[0], len(gsyn_inh_1_0)) self.assertEquals(nNeurons * runtimes[1], len(gsyn_inh_1_1)) if __name__ == '__main__': synfire_run.do_run(nNeurons, spike_times=spike_times, reset=reset, run_times=runtimes, neurons_per_core=neurons_per_core, get_all=True) neos = synfire_run.get_output_pop_all_list() spikes = [1, 1] spikes[0] = neo_convertor.convert_spikes(neos[1], 0) spikes[1] = neo_convertor.convert_spikes(neos[1], 1) v_1_0 = neo_convertor.convert_data(neos[1], "v", 0) v_1_1 = neo_convertor.convert_data(neos[1], "v", 1) gsyn_exc_1_0 = neo_convertor.convert_data(neos[1], "gsyn_exc", 0) gsyn_exc_1_1 = neo_convertor.convert_data(neos[1], "gsyn_exc", 1) print(len(spikes[0])) print(len(spikes[1])) plot_utils.plot_spikes(spikes) plot_utils.heat_plot(v_1_0, title="v1") plot_utils.heat_plot(gsyn_exc_1_0, title="gysn1") plot_utils.heat_plot(v_1_1, title="v2") plot_utils.heat_plot(gsyn_exc_1_1, title="gysn2")
self.assertEqual(self.S_COUNTS, s_counts) single_connected = self.directly_connected(weights) two_step_connected = self.next_connected( single_connected, single_connected) three_step_connected = self.next_connected( two_step_connected, single_connected) # There is a minor chance this fails so if it ever does add a skip for i in range(25): self.assertEqual(25, len(three_step_connected[i])) def a_run(self): v, spikes, weights = do_run(plot=False) # any checks go here v_test = neo_convertor.convert_data(v, name='v') spikes_test = neo_convertor.convert_data(spikes, name='spikes') self.assertEqual(25000, len(v_test)) # Not sure checking spike len is telling us much self.assertLess(7750, len(spikes_test)) self.assertGreater(8250, len(spikes_test)) self.check_weights(weights) def test_a_run(self): self.runsafe(self.a_run) if __name__ == '__main__': v, spikes = do_run(plot=True) print(len(neo_convertor.convert_data(v, name='v'))) print(len(neo_convertor.convert_data(spikes, name='spikes')))