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