def do_all_constraint(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], placement_constraint=placement_constraint, record=True, record_7=True, record_v=True, record_v_7=True, record_gsyn_exc=True, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEqual(n_neurons * runtime, len(gsyn_exc)) read_gsyn = numpy.loadtxt(gysn_file, delimiter=',') self.assertTrue(numpy.allclose(read_gsyn, gsyn_exc, rtol=1e-04), "gsyn neo method mismatch") self.assertEqual(n_neurons * runtime, len(v)) read_v = numpy.loadtxt(v_file, delimiter=',') self.assertTrue(numpy.allclose(read_v, v, rtol=1e-03), "v neo method mismatch") self.assertEqual(expected_spikes, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) read_spikes = numpy.loadtxt(spike_file, delimiter=',') self.assertTrue(numpy.allclose(read_spikes, spikes), "spikes neo method mismatch")
def do_v_no_constraint(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=False, record_v=True, record_gsyn_exc_7=False, record_gsyn_inh=False) v = synfire_run.get_output_pop_voltage_numpy() self.assertEqual(n_neurons * runtime, len(v)) read_v = numpy.loadtxt(v_file, delimiter=',') self.assertTrue(numpy.allclose(read_v, v, rtol=1e-03), "v neo method mismatch")
def do_gsyn_no_constraint(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=False, record_v=False, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() self.assertEqual(n_neurons * runtime, len(gsyn_exc)) read_gsyn = numpy.loadtxt(gysn_file, delimiter=',') self.assertTrue(numpy.allclose(read_gsyn, gsyn_exc, rtol=1e-04), "gsyn neo method mismatch")
def do_spikes_no_constraint(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=True, record_v=False, record_gsyn_exc_7=False, record_gsyn_inh=False) spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEqual(expected_spikes, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) read_spikes = numpy.loadtxt(spike_file, delimiter=',') self.assertTrue(numpy.allclose(read_spikes, spikes), "spikes neo method mismatch")
def get_before_and_after(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, weight_to_spike=weight_to_spike, delay=delay, placement_constraint=placement_constraint, run_times=runtimes, get_weights=get_weights, get_delays=get_delays) weights = synfire_run.get_weights() self.assertEqual(n_neurons, len(weights[0])) self.assertEqual(n_neurons, len(weights[1])) self.assertTrue(numpy.allclose(weights[0][0][2], weights[1][0][2])) delays = synfire_run.get_delay() self.assertEqual(n_neurons, len(delays[0])) self.assertEqual(n_neurons, len(delays[1])) self.assertTrue(numpy.allclose(delays[0][0][2], delays[1][0][2]))
def test_all_no_constarint(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=True, record_7=True, record_v=True, record_v_7=True, record_gsyn_exc=True, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc_7 = synfire_run.get_output_pop_gsyn_exc_7() v_7 = synfire_run.get_output_pop_voltage_7() spikes_7 = synfire_run.get_output_pop_spikes_7() gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEquals(n_neurons * runtime, len(gsyn_exc)) read_gsyn = numpy.loadtxt(gysn_file, delimiter=',') if not numpy.allclose(read_gsyn, gsyn_exc_7): for g1, g2 in zip(read_gsyn, gsyn_exc_7): if not numpy.allclose(g1, g2, rtol=1e-04): print(g1, g2, g1[2] - g2[2], (g1[2] - g2[2]) / g1[2]) self.assertTrue(numpy.allclose(read_gsyn, gsyn_exc_7, rtol=1e-04), "gsyn synakker method mismatch") self.assertTrue(numpy.allclose(read_gsyn, gsyn_exc, rtol=1e-04), "gsyn neo method mismatch") self.assertEquals(n_neurons * runtime, len(v)) read_v = numpy.loadtxt(v_file, delimiter=',') self.assertTrue(numpy.allclose(read_v, v_7, rtol=1e-03), "v synakker method mismatch") self.assertTrue(numpy.allclose(read_v, v, rtol=1e-03), "v neo method mismatch") self.assertEquals(expected_spikes, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) read_spikes = numpy.loadtxt(spike_file, delimiter=',') self.assertTrue(numpy.allclose(read_spikes, spikes_7), "spikes synakker method mismatch") self.assertTrue(numpy.allclose(read_spikes, spikes), "spikes neo method mismatch")
def do_run(seed=None): # Simulate using both simulators synfire_run = SynfireRunner() synfire_run.do_run( n_neurons=1, input_class=SpikeSourcePoisson, rate=noise_rate, start_time=0, duration=simtime, seed=seed, use_spike_connections=False, cell_params=cell_params, run_times=[simtime], record=True, record_v=True, randomise_v_init=True, record_input_spikes=True, weight_to_spike=0.4) s_pop_voltages = synfire_run.get_output_pop_voltage_numpy() s_pop_spikes = synfire_run.get_output_pop_spikes_numpy() noise_spike_times = synfire_run.get_spike_source_spikes_numpy() return noise_spike_times, s_pop_spikes, s_pop_voltages
def do_sampling_rate(self): synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=True, record_7=True, record_v=True, record_v_7=True, v_sampling_rate=2, gsyn_exc_sampling_rate=3, record_gsyn_exc=True, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc_7 = synfire_run.get_output_pop_gsyn_exc_7() v_7 = synfire_run.get_output_pop_voltage_7() spikes_7 = synfire_run.get_output_pop_spikes_7() gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_numpy() read_gsyn = numpy.loadtxt(gysn_file, delimiter=',') small_gsyn = read_gsyn[read_gsyn[:, 1] % 3 == 0] self.assertEqual(len(small_gsyn), len(gsyn_exc_7)) self.assertTrue(numpy.allclose(small_gsyn, gsyn_exc_7, rtol=1e-04), "gsyn synakker method mismatch") self.assertTrue(numpy.allclose(small_gsyn, gsyn_exc, rtol=1e-04), "gsyn neo method mismatch") self.assertEqual(n_neurons*(runtime/2), len(v)) read_v = numpy.loadtxt(v_file, delimiter=',') small_v = read_v[read_v[:, 1] % 2 == 0] self.assertTrue(numpy.allclose(small_v, v_7, rtol=1e-03), "v synakker method mismatch") self.assertTrue(numpy.allclose(small_v, v, rtol=1e-03), "v neo method mismatch") self.assertEqual(expected_spikes, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) read_spikes = numpy.loadtxt(spike_file, delimiter=',') self.assertTrue(numpy.allclose(read_spikes, spikes_7), "spikes synakker method mismatch") self.assertTrue(numpy.allclose(read_spikes, spikes), "spikes neo method mismatch")
delays = synfire_run.get_delay() self.assertEqual(n_neurons, len(delays[0])) self.assertEqual(n_neurons, len(delays[1])) self.assertTrue(numpy.allclose(delays[0][0][2], delays[1][0][2])) def test_get_before_and_after(self): self.runsafe(self.get_before_and_after) if __name__ == '__main__': synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, weight_to_spike=weight_to_spike, delay=delay, placement_constraint=placement_constraint, run_times=runtimes, get_weights=get_weights, get_delays=get_delays) weights = synfire_run.get_weights() delays = synfire_run.get_delay() print("weights[0]") print(weights[0]) print(weights[0].shape) print("weights[1]") print(weights[1]) print(weights[1].shape) print("delays[0]") print(delays[0]) print(delays[0].shape) print("delays[1]")
Synfirechain-like example """ from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner n_neurons = 200 # number of neurons in each population runtime = 5000 neurons_per_core = n_neurons / 2 synfire_run = SynfireRunner() class SynfireIfCurrExp(BaseTestCase): def test_run(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=[runtime], record=False, record_v=False, record_gsyn_exc=False, record_gsyn_inh=False) if __name__ == '__main__': synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=[runtime], record=False, record_v=False, record_gsyn_exc=False, record_gsyn_inh=False)
from p8_integration_tests.base_test_case import BaseTestCase from p8_integration_tests.scripts.synfire_run import SynfireRunner nNeurons = 200 # number of neurons in each population spike_times = [[0, 1050]] run_times = [1000, 1000] reset = False new_pop = True synfire_run = SynfireRunner() class Synfire2RunNewPopIfCurrExpLower(BaseTestCase): def test_run(self): try: synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, reset=reset, new_pop=new_pop) except NotImplementedError: # This is the current behaviour but would not be wrong if changed. print("Adding populations without reset not yet supported") if __name__ == '__main__': synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, reset=reset, new_pop=new_pop)
class Synfire2RunExtractionIfCurrExpLowerSecondRun(BaseTestCase): def test_run(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, spike_times=spike_times, run_times=runtimes, reset=reset) spikes = synfire_run.get_output_pop_spikes_list_numpy() self.assertEquals(53, len(spikes[0])) self.assertEquals(103, len(spikes[1])) spike_checker.synfire_spike_checker(spikes[0], n_neurons) spike_checker.synfire_multiple_lines_spike_checker(spikes[1], n_neurons, 2) if __name__ == '__main__': results = synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, spike_times=spike_times, run_times=runtimes, reset=reset)\ gsyn = synfire_run.get_output_pop_gsyn_exc_list_numpy() v = synfire_run.get_output_pop_voltage_list_numpy() spikes = synfire_run.get_output_pop_spikes_list_numpy() print(len(spikes[0])) print(len(spikes[1])) plot_utils.plot_spikes(spikes[0], spikes[1]) plot_utils.heat_plot(v[0], title="v1") plot_utils.heat_plot(gsyn[0], title="gysn1") plot_utils.heat_plot(v[1], title="v2") plot_utils.heat_plot(gsyn[1], title="gysn2")
gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() self.assertEqual(n_neurons * runtime, len(gsyn_exc)) read_gsyn = numpy.loadtxt(gysn_file, delimiter=',') self.assertTrue(numpy.allclose(read_gsyn, gsyn_exc, rtol=1e-04), "gsyn neo method mismatch") def test_gsyn_no_constraint(self): self.runsafe(self.do_gsyn_no_constraint) if __name__ == '__main__': synfire_run = SynfireRunner() synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], placement_constraint=placement_constraint, record=True, record_7=True, record_v=True, record_v_7=True, record_gsyn_exc=True, record_gsyn_exc_7=True, record_gsyn_inh=False) gsyn_exc = synfire_run.get_output_pop_gsyn_exc_numpy() gsyn_exc_neo = synfire_run.get_output_pop_gsyn_exc_neo() v = synfire_run.get_output_pop_voltage_numpy() v_neo = synfire_run.get_output_pop_voltage_neo() spikes = synfire_run.get_output_pop_spikes_numpy() spikes_neo = synfire_run.get_output_pop_spikes_neo() numpy.savetxt(spike_file, spikes, delimiter=',') numpy.savetxt(v_file, v, delimiter=',') numpy.savetxt(gysn_file, gsyn_exc, delimiter=',') Figure(SpynnakerPanel(spikes_neo, yticks=True, xticks=True, markersize=4,
spike_checker.synfire_multiple_lines_spike_checker(spikes, n_neurons, len(input), wrap_around=False) def test_second_none(self): self.runsafe(self.second_none) if __name__ == '__main__': synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=run_times, use_wrap_around_connections=wrap_around, input_class=input_class, start_time=start_time, duration=duration, rate=rate, extract_between_runs=extract_between_runs, set_between_runs=set_between_runs, record_input_spikes=record_input_spikes) gsyn = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() input = synfire_run.get_spike_source_spikes_numpy() hist = numpy.histogram(input[:, 1], bins=[0, 5000, 10000]) print(hist[0][0], hist[0][1]) spikes = synfire_run.get_output_pop_spikes_numpy() plot_utils.plot_spikes(input, spikes2=spikes) plot_utils.heat_plot(v) plot_utils.heat_plot(gsyn)
runtime = 5000 neurons_per_core = n_neurons / 2 synfire_run = SynfireRunner() class SynfireIfCurrExp(BaseTestCase): def test_run(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=[runtime], seed=self._test_seed) spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEquals(263, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) synfire_run.get_output_pop_gsyn_exc_numpy() synfire_run.get_output_pop_voltage_numpy() if __name__ == '__main__': synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=[runtime]) gsyn = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_numpy() plot_utils.plot_spikes(spikes) plot_utils.line_plot(v, title="v") plot_utils.heat_plot(gsyn, title="gsyn")
tests the printing of get gsyn given a simulation """ def test_get_gsyn(self): synfire_run.do_run(n_neurons, max_delay=max_delay, time_step=timestep, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime]) spikes = synfire_run.get_output_pop_spikes_numpy() gsyn = synfire_run.get_output_pop_gsyn_exc_numpy() self.assertEquals(12, len(spikes)) spike_checker.synfire_spike_checker(spikes, n_neurons) gsyn_tools.check_sister_gysn(__file__, n_neurons, runtime, gsyn) if __name__ == '__main__': 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 = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_numpy() plot_utils.plot_spikes(spikes) plot_utils.heat_plot(v) plot_utils.heat_plot(gsyn) gsyn_tools.check_sister_gysn(__file__, n_neurons, runtime, gsyn)
""" tests the printing of get gsyn given a simulation """ def test_get_gsyn(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=runtimes, extract_between_runs=extract_between_runs, set_between_runs=set_between_runs) spikes = synfire_run.get_output_pop_spikes_numpy() # Check spikes increase in second half by at least a factor of ten hist = numpy.histogram(spikes[:, 1], bins=[0, 5000, 10000]) self.assertEquals(263, hist[0][0]) self.assertEquals(333400, hist[0][1]) if __name__ == '__main__': synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=runtimes, extract_between_runs=extract_between_runs, set_between_runs=set_between_runs) gsyn = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_numpy() hist = numpy.histogram(spikes[:, 1], bins=[0, 5000, 10000]) print(hist[0][0], hist[0][1]) plot_utils.plot_spikes(spikes) plot_utils.heat_plot(v) plot_utils.heat_plot(gsyn)
record_v = False record_gsyn = False synfire_run = SynfireRunner() class Synfire1600n10pc10chipsWithNoDelaysSpikeRecording(BaseTestCase): def test_run(self): self.assert_not_spin_three() synfire_run.do_run(nNeurons, run_times=run_times, record_v=record_v, record_gsyn_exc=record_gsyn, record_gsyn_inh=record_gsyn) spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEquals(263, len(spikes)) spike_checker.synfire_spike_checker(spikes, nNeurons) if __name__ == '__main__': synfire_run.do_run(nNeurons, run_times=run_times, record_v=record_v, record_gsyn_exc=record_gsyn, record_gsyn_inh=record_gsyn) spikes = synfire_run.get_output_pop_spikes_numpy() print(len(spikes)) plot_utils.plot_spikes(spikes) # v and gysn are None
class TestSynfirePoissonIfCurrExpParameter(BaseTestCase): def synfire_poisson_if_curr_exp_parameter(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=run_times, input_class=input_class, start_time=start_time, duration=duration, rate=rate, extract_between_runs=extract_between_runs, set_between_runs=set_between_runs, seed=12345) spikes = synfire_run.get_output_pop_spikes_numpy() # Check spikes increase in second half by at least a factor of ten hist = numpy.histogram(spikes[:, 1], bins=[0, 5000, 10000]) self.assertLess(hist[0][0] * 10, hist[0][1]) def test_synfire_poisson_if_curr_exp_parameter(self): self.runsafe(self.synfire_poisson_if_curr_exp_parameter) if __name__ == '__main__': synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=run_times, input_class=input_class, start_time=start_time, duration=duration, rate=rate, extract_between_runs=extract_between_runs, set_between_runs=set_between_runs) spikes = synfire_run.get_output_pop_spikes_numpy() hist = numpy.histogram(spikes[:, 1], bins=[0, 5000, 10000]) print(hist[0][0] * 10, hist[0][1]) plot_utils.plot_spikes(spikes)
synfire_run = SynfireRunner() class Synfire3Rrun1ExitNoExtractionIfCurrExp(BaseTestCase): def test_run(self): synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, reset=reset, extract_between_runs=extract_between_runs) spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEquals(303, len(spikes)) spike_checker.synfire_multiple_lines_spike_checker(spikes, nNeurons, 3) if __name__ == '__main__': synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, reset=reset, extract_between_runs=extract_between_runs) gsyn = synfire_run.get_output_pop_gsyn_exc_numpy() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_numpy() print(len(spikes)) plot_utils.plot_spikes(spikes) plot_utils.heat_plot(v, title="v") plot_utils.heat_plot(gsyn, title="gysn")
len4 = reduce(lambda x, y: x + y, map(len, spikes_neos[4].segments[0].spiketrains)) self.assertEquals(53, len0) self.assertEquals(106, len1) self.assertEquals(158, len2) self.assertEquals(211, len3) self.assertEquals(263, len4) spikes = map(neo_convertor.convert_spikes, spikes_neos) spike_checker.synfire_spike_checker(spikes, n_neurons) if __name__ == '__main__': results = synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=runtimes, record=True, record_v=True, record_gsyn_exc=True, record_gsyn_inh=False) # TODO plotting if required # gsyn = synfire_run.get_output_pop_gsyn() # v = synfire_run.get_output_pop_voltage() spikes_neos = synfire_run.get_output_pop_spikes_list() len0 = reduce(lambda x, y: x + y, map(len, spikes_neos[0].segments[0].spiketrains)) len1 = reduce(lambda x, y: x + y, map(len, spikes_neos[1].segments[0].spiketrains)) len2 = reduce(lambda x, y: x + y, map(len, spikes_neos[2].segments[0].spiketrains)) len3 = reduce(lambda x, y: x + y, map(len, spikes_neos[3].segments[0].spiketrains))
v_1_1 = neo_convertor.convert_data(neos[1], "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[1], "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[1], "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)) if __name__ == '__main__': synfire_run.do_run(nNeurons, run_times=run_times, reset=reset, 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")
delay = 17 run_times = [5000] get_weights = True synfire_run = SynfireRunner() class SynfireIfCurr_exp(BaseTestCase): def test_run(self): synfire_run.do_run(nNeurons, neurons_per_core=neurons_per_core, delay=delay, run_times=run_times, get_weights=get_weights) spikes = synfire_run.get_output_pop_spikes_numpy() weights = synfire_run.get_weights() self.assertEqual(263, len(spikes)) self.assertEqual(200, len(weights)) spike_checker.synfire_spike_checker(spikes, nNeurons) if __name__ == '__main__': synfire_run.do_run(nNeurons, neurons_per_core=neurons_per_core, delay=delay, run_times=run_times, get_weights=get_weights) spikes = synfire_run.get_output_pop_spikes_numpy() weights = synfire_run.get_weights() print(len(spikes)) print(len(weights)) plot_utils.plot_spikes(spikes)
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)) 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")
spike_checker.synfire_spike_checker(spikes, n_neurons) # no check of gsyn as the system overloads # System intentional overload so may error except SpinnmanTimeoutException as ex: raise SkipTest(ex) if __name__ == '__main__': # plotting stuff delay import so unittestsz do not need them import matplotlib.pyplot as plt from pyNN.utility.plotting import Figure from spynnaker8.spynnaker_plotting import SpynnakerPanel synfire_run.do_run(n_neurons, max_delay=14.4, time_step=0.1, neurons_per_core=5, delay=1.7, run_times=[runtime]) gsyn_exc_neo = synfire_run.get_output_pop_gsyn_exc_neo() v_neo = synfire_run.get_output_pop_voltage_neo() spikes_neo = synfire_run.get_output_pop_spikes_neo() Figure(SpynnakerPanel(spikes_neo, yticks=True, xticks=True, markersize=4, xlim=(0, runtime)), SpynnakerPanel(v_neo, yticks=True, xticks=True), SpynnakerPanel(gsyn_exc_neo, yticks=True), title="TestGsyn", annotations="generated by {}".format(__file__))
delay = 1 neurons_per_core = 20 record_v = False record_gsyn = False synfire_run = SynfireRunner() class Synfire200n20pc10cWithNoDelaysSpikeRecording(BaseTestCase): def test_run(self): synfire_run.do_run(nNeurons, delay=delay, neurons_per_core=neurons_per_core, record_v=record_v, record_gsyn_exc=record_gsyn, record_gsyn_inh=record_gsyn) spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEqual(333, len(spikes)) spike_checker.synfire_spike_checker(spikes, nNeurons) if __name__ == '__main__': synfire_run.do_run(nNeurons, delay=delay, neurons_per_core=neurons_per_core, record_v=record_v, record_gsyn_exc=record_gsyn, record_gsyn_inh=record_gsyn) spikes = synfire_run.get_output_pop_spikes_numpy() print(len(spikes)) plot_utils.plot_spikes(spikes) # v and gysn are None
get_gsyn_inh = False class ExtractingSpikesWhenVOnlySetToRecord(BaseTestCase): """ tests the printing of get gsyn given a simulation """ def test_cause_error(self): with self.assertRaises(ConfigurationException): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=record, get_spikes=get_spikes, record_v=record_v, get_gsyn_exc=get_gsyn_exc, get_gsyn_inh=get_gsyn_inh) if __name__ == '__main__': synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, delay=delay, run_times=[runtime], record=record, get_spikes=get_spikes, record_v=record_v, get_gsyn_exc=get_gsyn_exc, get_gsyn_inh=get_gsyn_inh)
def test_run(self): synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, reset=reset) spikes = synfire_run.get_output_pop_spikes_list_numpy() self.assertEquals(53, len(spikes[0])) self.assertEquals(103, len(spikes[1])) spike_checker.synfire_spike_checker(spikes[0], nNeurons) spike_checker.synfire_multiple_lines_spike_checker( spikes[1], nNeurons, 2) if __name__ == '__main__': synfire_run.do_run(nNeurons, spike_times=spike_times, run_times=run_times, reset=reset) gsyn = synfire_run.get_output_pop_gsyn_exc_list_numpy() v = synfire_run.get_output_pop_voltage_list_numpy() spikes = synfire_run.get_output_pop_spikes_list_numpy() print(len(spikes[0])) print(len(spikes[1])) plot_utils.plot_spikes(spikes[0], spikes[1]) plot_utils.heat_plot(v[0], title="v1") plot_utils.heat_plot(gsyn[0], title="gysn1") plot_utils.heat_plot(v[1], title="v2") plot_utils.heat_plot(gsyn[1], title="gysn2")
record_v = False record_gsyn = False synfire_run = SynfireRunner() class Synfire200n10pc2chipsWithNoDelaysSpikeRecording(BaseTestCase): def test_run(self): self.assert_not_spin_three() synfire_run.do_run(nNeurons, delay=delay, record_v=record_v, record_gsyn_exc=record_gsyn, record_gsyn_inh=record_gsyn) spikes = synfire_run.get_output_pop_spikes_numpy() self.assertEqual(333, len(spikes)) spike_checker.synfire_spike_checker(spikes, nNeurons) if __name__ == '__main__': synfire_run.do_run(nNeurons, delay=delay, record_v=record_v, record_gsyn_exc=record_gsyn, record_gsyn_inh=record_gsyn) spikes = synfire_run.get_output_pop_spikes_numpy() print(len(spikes)) plot_utils.plot_spikes(spikes) # v and gysn are None
record = False record_v = True record_gsyn = False synfire_run = SynfireRunner() class SynfireIfCurrExp(BaseTestCase): def test_run(self): synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=[runtime], record=record, record_v=record_v, record_gsyn_exc=record_gsyn) gsyn = synfire_run.get_output_pop_gsyn_exc_list() v = synfire_run.get_output_pop_voltage_list() spikes = synfire_run.get_output_pop_spikes_list() self.assertEqual(1, len(v)) self.assertEqual(0, len(gsyn)) self.assertEqual(0, len(spikes)) if __name__ == '__main__': synfire_run.do_run(n_neurons, neurons_per_core=neurons_per_core, run_times=[runtime], record=record, record_v=record_v, record_gsyn=record_gsyn) gsyn = synfire_run.get_output_pop_gsyn_exc_list() v = synfire_run.get_output_pop_voltage_numpy() spikes = synfire_run.get_output_pop_spikes_list() plot_utils.line_plot(v, title="v")