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")
