def test_overflow(self):
pynn.setup(neuronPermutation=self.permutation)
pynn.Population(len(self.permutation), pynn.cells.HXNeuron())
with self.assertRaises(ValueError):
pynn.Population(1, pynn.cells.HXNeuron())
pynn.end()
def test_number_of_spike_trains(self):
"""
Here we test that only spikes are recorded for the neurons we set in
the spike recording mode.
"""
runtime = 0.5 # ms
pop_size = 4
pops = []
pops.append(pynn.Population(pop_size, pynn.cells.HXNeuron()))
pops.append(pynn.Population(pop_size, pynn.cells.HXNeuron()))
pops.append(pynn.Population(pop_size, pynn.cells.HXNeuron()))
# Once record whole population, once subset and once no neurons
pops[0].record(['spikes'])
pynn.PopulationView(pops[1], [0]).record(['spikes'])
# Spike input
input_pop = pynn.Population(1, pynn.cells.SpikeSourceArray(
spike_times=np.arange(0.1, runtime, runtime / 10)))
for pop in pops:
pynn.Projection(input_pop, pop, pynn.AllToAllConnector(),
synapse_type=StaticSynapse(weight=63))
pynn.run(runtime)
# Assert correct number of recorded spike trains
self.assertEqual(len(pops[0].get_data().segments[0].spiketrains),
pop_size)
self.assertEqual(len(pops[1].get_data().segments[0].spiketrains), 1)
self.assertEqual(len(pops[2].get_data().segments[0].spiketrains), 0)
def main(params: dict):
pynn.setup()
nrn = pynn.Population(1, pynn.cells.HXNeuron(**params))
nrn.record(["spikes", "v"])
spike_times = [0.01, 0.03, 0.05, 0.07, 0.09, 0.11, 0.13, 0.15, 0.17, 0.19]
pop_input = pynn.Population(20,
pynn.cells.SpikeSourceArray,
cellparams={"spike_times": spike_times})
synapse = pynn.standardmodels.synapses.StaticSynapse(weight=63)
pynn.Projection(pop_input,
nrn,
pynn.AllToAllConnector(),
synapse_type=synapse)
pynn.run(0.2)
spiketrain = nrn.get_data("spikes").segments[0].spiketrains[0]
mem_v = nrn.get_data("v").segments[0]
membrane_times, membrane_voltage = zip(*mem_v.filter(name="v")[0])
pynn.end()
# Plot data
plt.figure()
plt.xlabel("Time [ms]")
plt.ylabel("Membrane Potential [LSB]")
plt.plot(membrane_times, membrane_voltage)
plt.savefig("plot_external_input.pdf")
plt.close()
return spiketrain
def test_bypass(self):
# Create network with single SpikeSourceArray which projects on a
# single HX neuron
spikes_in = self.poisson_spike_train(self.rate)
input_pop = pynn.Population(1,
pynn.cells.SpikeSourceArray,
cellparams={"spike_times": spikes_in})
output_pop = pynn.Population(1, pynn.cells.HXNeuron())
output_pop.record(["spikes"])
synapse = pynn.standardmodels.synapses.StaticSynapse(weight=63)
pynn.Projection(input_pop,
output_pop,
pynn.AllToAllConnector(),
synapse_type=synapse)
# Run experiment on chip
pynn.run(self.runtime)
# Make sure that at least 98% (estimate considering typical spike
# loss) of the spikes are read back and that the time difference
# between them is less than 0.01ms
spikes_out = output_pop.get_data().segments[0].spiketrains[0].magnitude
# Add a small number such that timestamps with a '5' the third decimal
# place are rounded up to the next higher (and not to the next even)
# number
input_set = set(np.round(spikes_in + 1e-9, 2))
output_set = set(np.round(spikes_out + 1e-9, 2))
assert len(input_set - output_set) / len(input_set) < 0.02
def test_renewed_setup(self):
pynn.setup(neuronPermutation=self.permutation)
pynn.Population(1, pynn.cells.HXNeuron())
self.assertEqual(
pynn.simulator.state.neuron_placement.id2hwenum(0),
self.permutation[0])
pynn.end()
pynn.setup()
pynn.Population(1, pynn.cells.HXNeuron())
self.assertEqual(
pynn.simulator.state.neuron_placement.id2hwenum(0), 0)
pynn.end()
def test_timing_of_spikes(self):
"""
Test whether the output spikes have approximately the same timing as
the input spikes.
"""
runtime = 100 # ms
n_spikes = 1000
pop_1 = pynn.Population(1, pynn.cells.HXNeuron())
pop_1.record('spikes')
pop_2 = pynn.Population(1, pynn.cells.HXNeuron())
pop_2.record('spikes')
# Inject spikes
spikes_1 = np.arange(0.1, runtime, runtime / n_spikes)
input_pop_1 = pynn.Population(1, pynn.cells.SpikeSourceArray(
spike_times=spikes_1))
pynn.Projection(input_pop_1, pop_1, pynn.AllToAllConnector(),
synapse_type=StaticSynapse(weight=63))
# Take midpoints of spikes_1 to have some variation in timing and
spikes_2 = (spikes_1[:-1] + spikes_1[1:]) / 2
input_pop_2 = pynn.Population(1, pynn.cells.SpikeSourceArray(
spike_times=spikes_2))
pynn.Projection(input_pop_2, pop_2, pynn.AllToAllConnector(),
synapse_type=StaticSynapse(weight=63))
pynn.run(runtime)
# Make sure that at least 98% (estimate considering typical spike
# loss) of the spikes are read back and that the time difference
# between them is less than 0.01ms.
# To accomplish that we round the spike times to two decimal places
# and then compare the sets of the input and output spike times.
# By default numpy does not round '5' to the next higher number but
# to the next even number, e.g. np.round(2.5) == 2. Therefore, we
# add a small number such that timestamps with a '5' at the third
# decimal place are rounded up to the next higher (and not even) number
input_set_1 = set(np.round(spikes_1 + 1e-9, 2))
output_set_1 = set(np.round(
pop_1.get_data().segments[0].spiketrains[0].magnitude + 1e-9, 2))
self.assertLess(len(input_set_1 - output_set_1) / len(input_set_1),
0.02)
input_set_2 = set(np.round(spikes_2 + 1e-9, 2))
output_set_2 = set(np.round(
pop_2.get_data().segments[0].spiketrains[0].magnitude + 1e-9, 2))
self.assertLess(len(input_set_2 - output_set_2) / len(input_set_2),
0.02)
def test_default(self):
pynn.setup()
pop = pynn.Population(2, pynn.cells.HXNeuron(self.coco))
self.assertTrue(np.array_equal(pop.get("leak_i_bias"), [555, 0]))
self.assertTrue(
np.array_equal(pop.get("threshold_v_threshold"), [0, 123]))
pynn.end()
def test_permutation(self):
coord = halco.AtomicNeuronOnDLS(halco.common.Enum(8))
neuron = lola.AtomicNeuron()
neuron.leak.i_bias = 666
pynn.setup(neuronPermutation=[8])
pop = pynn.Population(1, pynn.cells.HXNeuron({coord: neuron}))
self.assertEqual(pop.get("leak_i_bias"), 666)
pynn.end()
def test_number_of_neurons(self):
# TODO: grenade routing backend does not support 512 neurons?
for n_neurons in [1, 16, 32, 64, 128, 256]:
with self.subTest(n_neurons=n_neurons):
pynn.setup()
pynn.Population(n_neurons, pynn.cells.HXNeuron())
pynn.run(None)
pynn.end()
def get_neuron_population(size: int) -> pynn.Population:
"""
Minimal helper function:
Construct a neuron population to be used within this experiment.
:param size: Population size
:return: Neuron population
"""
return pynn.Population(size, pynn.cells.HXNeuron)
def setUp(self):
self.bg_props = dict(
start=1, # ms
rate=20e3, # Hz
duration=100 # ms
)
# Emulate the network 1ms longer than Poisson stimulation, in order to
# convince oneself that the stimulation ends properly.
self.runtime = self.bg_props["start"] + self.bg_props["duration"] + 1
# The refractory time was found to must be set slightly larger 0 (DAC
# value) to achieve a short time on hardware (cf. #3741).
neuron_params = {"refractory_period_refractory_time": 5}
# By enabling the bypass mode, the neuron should spike at the income of
# each event.
pynn.setup(enable_neuron_bypass=True)
pop1 = pynn.Population(1, pynn.cells.HXNeuron(**neuron_params))
pop2 = pynn.Population(1, pynn.cells.HXNeuron(**neuron_params))
pop1.record(["spikes"])
pop2.record(["spikes"])
src = pynn.Population(1,
pynn.cells.SpikeSourcePoisson(**self.bg_props))
pynn.Projection(src,
pop1,
pynn.AllToAllConnector(),
synapse_type=StaticSynapse(weight=63))
pynn.Projection(src,
pop2,
pynn.AllToAllConnector(),
synapse_type=StaticSynapse(weight=63))
pynn.run(self.runtime)
self.spiketrain1 = pop1.get_data("spikes").segments[0].spiketrains[0]
self.spiketrain2 = pop2.get_data("spikes").segments[0].spiketrains[0]
pynn.reset()
self.rate3 = 10e3
src.set(rate=self.rate3)
pynn.run(self.runtime)
self.spiketrain3 = pop1.get_data("spikes").segments[1].spiketrains[0]
pynn.end()
def setUp(self):
pynn.setup()
self.pop = pynn.Population(2, pynn.cells.HXNeuron(
threshold_v_threshold=200, threshold_enable=200))
self.neurons = [None] * self.pop.size
for idx, item in enumerate(self.pop.celltype.parameter_space):
neuron = pynn.cells.HXNeuron.create_hw_entity(item)
self.neurons[idx] = neuron
def test_mixed_celltypes(self):
pynn.setup(neuronPermutation=self.permutation)
pynn.Population(1, pynn.cells.SpikeSourceArray(spike_times=[0]))
pynn.Population(2, pynn.cells.HXNeuron())
pynn.Population(1, pynn.cells.SpikeSourceArray(spike_times=[0]))
pynn.Population(1, pynn.cells.HXNeuron())
self.assertEqual(
pynn.simulator.state.neuron_placement.id2hwenum(1),
self.permutation[0])
self.assertEqual(
pynn.simulator.state.neuron_placement.id2hwenum(2),
self.permutation[1])
self.assertEqual(
pynn.simulator.state.neuron_placement.id2hwenum(4),
self.permutation[2])
pynn.end()
def main(params: dict):
pynn.setup()
nrn = pynn.Population(1, pynn.cells.HXNeuron(**params))
nrn.record(["spikes", "v"])
spike_times = [0.01, 0.03, 0.05, 0.07, 0.09, 0.11, 0.13, 0.15, 0.17, 0.19]
pop_input = pynn.Population(20, pynn.cells.SpikeSourceArray,
cellparams={"spike_times": spike_times})
synapse = pynn.standardmodels.synapses.StaticSynapse(weight=63)
pynn.Projection(pop_input, nrn, pynn.AllToAllConnector(),
synapse_type=synapse)
pynn.run(0.2)
spiketrain = nrn.get_data("spikes").segments[0].spiketrains[0]
mem_v = nrn.get_data("v").segments[0]
membrane_times, membrane_voltage = zip(*mem_v.filter(name="v")[0])
pynn.end()
return spiketrain, membrane_times, membrane_voltage
def main(params: dict):
log = pynn.logger.get("leak_over_threshold")
pynn.setup()
pop2 = pynn.Population(2, pynn.cells.HXNeuron(**params))
pop1 = pynn.Population(1, pynn.cells.HXNeuron(**params))
pop1.record(["spikes", "v"])
pop2.record("spikes")
pynn.run(0.2)
spikes1 = pop1.get_data("spikes").segments[0]
spikes2 = pop2.get_data("spikes").segments[0]
# TODO: Find out how to extract neuron ids.
for i, spiketrain in enumerate(spikes2.spiketrains):
log.INFO("Number of Spikes of Neuron {}: ".format(i + 1),
len(spiketrain))
log.INFO("Spiketimes of Neuron {}: ".format(i + 1), spiketrain)
spiketimes = spikes1.spiketrains[0]
log.INFO("Number of spikes of single recorded neuron: ", len(spiketimes))
log.INFO("Spiketimes of recorded neuron: ", spiketimes)
mem_v = pop1.get_data("v").segments[0]
times, membrane = zip(*mem_v.filter(name="v")[0])
log.INFO("Number of MADC Samples: ", len(times))
plt.figure()
plt.xlabel("Time [ms]")
plt.ylabel("Membrane Potential [LSB]")
plt.plot(times, membrane)
plt.savefig("plot_leak_over_threshold.pdf")
plt.close()
pynn.end()
def test_accessors(self):
self.assertEqual(self.hxpop2.get("threshold_v_threshold"), 200)
self.assertEqual(
self.hxpop3.get(["threshold_v_threshold", "leak_i_bias"]),
[300, 100])
self.assertTrue(self.hxpop3.get("exponential_enable"), True)
self.assertTrue(np.array_equal(
self.hxpop4.get("leak_i_bias"), [100, 150]))
self.assertEqual(self.hxpop4[0:1].get("leak_i_bias"), 100)
self.assertEqual(self.hxpop4[0].leak_i_bias, 100)
self.assertEqual(self.hxpop4[1:2].get("leak_i_bias"), 150)
self.assertEqual(self.hxpop4[1].leak_i_bias, 150)
self.assertTrue(np.array_equal(
self.hxpop5.get("leak_i_bias"), [100, 200]))
self.assertEqual(
self.sapop1.get("spike_times"), parameters.Sequence([0, 1, 2]))
self.assertEqual(
self.sapop1[0].spike_times, parameters.Sequence([0, 1, 2]))
self.assertTrue(np.array_equal(
self.sapop2.get("spike_times"),
[parameters.ArrayParameter([0, 1, 2]),
parameters.ArrayParameter([3, 4, 5])]))
self.assertEqual(
self.sapop2[0].spike_times, parameters.Sequence([0, 1, 2]))
self.assertEqual(
self.sapop2[1].spike_times, parameters.Sequence([3, 4, 5]))
mypop = pynn.Population(3, pynn.cells.HXNeuron())
mypop.set(leak_i_bias=400)
mypop[0:2].set(leak_i_bias=150)
self.assertTrue(
np.array_equal(mypop.get("leak_i_bias"), [150, 150, 400]))
mypop.set(leak_i_bias=[100, 200, 300])
self.assertTrue(
np.array_equal(mypop.get("leak_i_bias"), [100, 200, 300]))
mypop[1].leak_i_bias = 350
self.assertTrue(
np.array_equal(mypop.get("leak_i_bias"), [100, 350, 300]))
mypop.set(exponential_enable=True)
mypop[1, 2].set(exponential_enable=False)
self.assertTrue(np.array_equal(
mypop.get("exponential_enable"),
[True, False, False]))
mypop.set(leak_i_bias=123)
mypop[0, 2].set(exponential_enable=True, leak_i_bias=100)
self.assertTrue(np.array_equal(
mypop.get(["leak_i_bias", "exponential_enable"]),
[[100, 123, 100], [True, False, True]]))
def get_isi(tau_ref: int):
pynn.setup()
cell_params.update({"refractory_period_refractory_time": tau_ref})
pop = pynn.Population(1, pynn.cells.HXNeuron(**cell_params))
pop.record("spikes")
pynn.run(0.2)
spikes = pop.get_data("spikes").segments[0].spiketrains[0]
if len(spikes) == 0:
return 0
isi = np.zeros(len(spikes) - 1)
for i in range(len(spikes) - 1):
isi[i] = spikes[i + 1] - spikes[i]
pynn.end()
return np.mean(isi)
def setUp(self):
pynn.setup()
self.hxpop1 = pynn.Population(1, pynn.cells.HXNeuron())
self.hxpop2 = pynn.Population(
5, pynn.cells.HXNeuron(threshold_v_threshold=200))
self.hxpop3 = pynn.Population(
3, pynn.cells.HXNeuron(
threshold_v_threshold=300,
leak_i_bias=100,
exponential_enable=True))
self.hxpop4 = pynn.Population(
2, pynn.cells.HXNeuron(leak_i_bias=[100, 150]))
# test old API support
self.hxpop5 = pynn.Population(
2, pynn.cells.HXNeuron, cellparams={'leak_i_bias': [100, 200]})
self.sapop1 = pynn.Population(
1, pynn.cells.SpikeSourceArray(spike_times=[0, 1, 2]))
self.sapop2 = pynn.Population(
2, pynn.cells.SpikeSourceArray(spike_times=[[0, 1, 2], [3, 4, 5]]))
def test_coco_extraction(self):
builder = sta.PlaybackProgramBuilderDumper()
an_coord0 = halco.AtomicNeuronOnDLS(halco.common.Enum(0))
an_coord1 = halco.AtomicNeuronOnDLS(halco.common.Enum(1))
neuron0 = lola.AtomicNeuron()
neuron0.leak.i_bias = 666
neuron1 = lola.AtomicNeuron()
neuron1.leak.i_bias = 420
builder.write(an_coord0, neuron0)
builder.write(an_coord1, neuron1)
common_config = hal.CommonNeuronBackendConfig()
common_config.clock_scale_fast = 3
common_coord = halco.CommonNeuronBackendConfigOnDLS()
builder.write(common_coord, common_config)
full_coco = {}
with tempfile.TemporaryDirectory() as tempdir:
filename = os.path.join(tempdir, "dump")
with open(filename, "wb") as fd:
fd.write(sta.to_binary(builder.done()))
full_coco = pynn.helper.coco_from_file(filename)
self.assertTrue(an_coord0 in full_coco)
self.assertTrue(an_coord1 in full_coco)
hx_coco = pynn.helper.filter_atomic_neuron(full_coco)
self.assertTrue(an_coord0 in hx_coco)
self.assertTrue(an_coord1 in hx_coco)
self.assertFalse(common_coord in hx_coco)
remainder_coco = pynn.helper.filter_non_atomic_neuron(full_coco)
self.assertFalse(an_coord0 in remainder_coco)
self.assertTrue(common_coord in remainder_coco)
self.assertEqual(remainder_coco[common_coord].clock_scale_fast, 3)
pynn.setup()
pop = pynn.Population(2, pynn.cells.HXNeuron(hx_coco))
self.assertTrue(numpy.array_equal(pop.get("leak_i_bias"), [666, 420]))
pynn.run(None)
pynn.end()
def test_not_configurable(self):
with self.assertRaises(errors.NonExistentParameterError):
pynn.Population(
1, pynn.cells.HXNeuron(event_routing_analog_output=0))
with self.assertRaises(errors.NonExistentParameterError):
pynn.Population(
1, pynn.cells.HXNeuron(event_routing_enable_digital=False))
with self.assertRaises(errors.NonExistentParameterError):
pynn.Population(
1, pynn.cells.HXNeuron(leak_reset_i_bias_source_follower=0))
with self.assertRaises(errors.NonExistentParameterError):
pynn.Population(
1, pynn.cells.HXNeuron(readout_enable_amplifier=True))
with self.assertRaises(errors.NonExistentParameterError):
pynn.Population(
1, pynn.cells.HXNeuron(readout_source="something"))
with self.assertRaises(errors.NonExistentParameterError):
pynn.Population(
1, pynn.cells.HXNeuron(readout_enable_buffered_access=True))
with self.assertRaises(errors.NonExistentParameterError):
pynn.Population(
1, pynn.cells.HXNeuron(readout_i_bias=1000))
def test_missing_coco_entries(self):
pynn.setup()
pynn.Population(2, pynn.cells.HXNeuron(self.coco))
with self.assertRaises(KeyError):
pynn.Population(1, pynn.cells.HXNeuron(self.coco))
pynn.end()
stimulated_p = pynn.Population(
1,
pynn.cells.HXNeuron(
# Leak potential, range: 300-1000
leak_v_leak=800,
# Leak conductance, range: 0-1022 increase -> time constant decrease
leak_i_bias=cond,
# Threshold potential, range: 0-600
threshold_v_threshold=400,
# Reset potential, range: 300-1000
reset_v_reset=600,
# Membrane capacitance, range: 0-63 increase->increase time constant 63-->2.4pF
membrane_capacitance_capacitance=63,
# Refractory time, range: 0-255
refractory_period_refractory_time=120,
# Enable reset on threshold crossing
threshold_enable=True,
# Reset conductance, range: 0-1022
reset_i_bias=1022,
# Enable strengthening of reset conductance
reset_enable_multiplication=True,
# -- Parameters for synaptic inputs -- #
# Enable synaptic stimulation
excitatory_input_enable=False,
inhibitory_input_enable=False,
# Strength of synaptic inputs
excitatory_input_i_bias_gm=1022,
inhibitory_input_i_bias_gm=1022,
# Synaptic time constants
excitatory_input_i_bias_tau=200,
inhibitory_input_i_bias_tau=200,
# Technical parameters
excitatory_input_i_drop_input=300,
inhibitory_input_i_drop_input=300,
excitatory_input_i_shift_reference=300,
inhibitory_input_i_shift_reference=300))
def test_permutation_mismatch(self):
pynn.setup(neuronPermutation=[8, 14])
with self.assertRaises(KeyError):
pynn.Population(2, pynn.cells.HXNeuron(self.coco))
pynn.end()
def main():
main_log = pynn.logger.get("internal_projections_main")
pynn.setup()
lot_values = {
"threshold_v_threshold": 400,
"leak_v_leak": 1022,
"leak_i_bias": 420,
"leak_enable_division": True,
"reset_v_reset": 50,
"reset_i_bias": 950,
"reset_enable_multiplication": True,
"threshold_enable": True,
"membrane_capacitance_capacitance": 10,
"refractory_period_refractory_time": 95
}
cell_params = deepcopy(lot_values)
cell_params.update({
"leak_v_leak": 650,
"reset_v_reset": 650,
"excitatory_input_enable": True,
"excitatory_input_i_bias_tau": 150,
"excitatory_input_i_bias_gm": 200,
# FIXME: replace by i_drop_input and i_shift_reference
# "excitatory_input_v_syn": 700})
})
# not leak over threshold
pop1 = pynn.Population(1,
pynn.standardmodels.cells.HXNeuron(**cell_params))
# leak over threshold
pop2 = pynn.Population(100,
pynn.standardmodels.cells.HXNeuron(**lot_values))
pop1.record(["spikes", "v"])
pop2.record("spikes")
synapse = pynn.standardmodels.synapses.StaticSynapse(weight=63)
pynn.Projection(pop2, pop1, pynn.AllToAllConnector(), synapse_type=synapse)
pynn.run(0.2)
spiketimes1 = pop1.get_data("spikes").segments[0].spiketrains[0]
main_log.INFO("Spiketimes of first neuron: ", spiketimes1)
spikes2 = pop2.get_data("spikes").segments[0]
spikenumber2 = 0
for i in range(len(pop2)):
spikes = len(spikes2.spiketrains[i])
spikenumber2 += spikes
main_log.INFO("Number of spikes from pop2: ", spikenumber2)
mem_v = pop1.get_data("v").segments[0]
membrane_times, membrane_voltage = zip(*mem_v.filter(name="v")[0])
pynn.end()
# Plot data
plt.figure()
plt.xlabel("Time [ms]")
plt.ylabel("Membrane Potential [LSB]")
plt.plot(membrane_times, membrane_voltage)
plt.savefig("plot_internal_projections.pdf")
plt.close()
return len(spiketimes1)
def test_user_overwrite(self):
pynn.setup()
pop = pynn.Population(
2, pynn.cells.HXNeuron(self.coco, leak_i_bias=[100, 150]))
self.assertTrue(np.array_equal(pop.get("leak_i_bias"), [100, 150]))
pynn.end()
def setUp(self):
pynn.setup()
self.pop1 = pynn.Population(1, pynn.cells.HXNeuron())
self.pop2 = pynn.Population(1, pynn.cells.HXNeuron())
self.pop3 = pynn.Population(2, pynn.cells.HXNeuron())
self.pop4 = pynn.Population(3, pynn.cells.HXNeuron())
def setUp(self):
pynn.setup()
self.pops_in = dict()
# SpikeSourceArray
self.spike_times = [0.01, 0.03, 0.05, 0.07, 0.09]
self.spike_times2 = [0.01, 0.03, 0.05, 0.07, 0.09, 0.1]
self.pops_in['in1'] = pynn.Population(
1,
pynn.cells.SpikeSourceArray(spike_times=self.spike_times)
)
self.pops_in['npin1'] = pynn.Population(
1,
pynn.cells.SpikeSourceArray(spike_times=np.array(self.spike_times))
)
self.pops_in['sein1'] = pynn.Population(
1,
pynn.cells.SpikeSourceArray(
spike_times=parameters.Sequence(self.spike_times))
)
self.pops_in['in2'] = pynn.Population(
2,
pynn.cells.SpikeSourceArray(spike_times=self.spike_times)
)
self.pops_in['npin2'] = pynn.Population(
2,
pynn.cells.SpikeSourceArray(spike_times=np.array(self.spike_times))
)
self.pops_in['sein2'] = pynn.Population(
2,
pynn.cells.SpikeSourceArray(
spike_times=parameters.Sequence(self.spike_times))
)
self.pops_in['in2var'] = pynn.Population(
2,
pynn.cells.SpikeSourceArray(
spike_times=[self.spike_times, self.spike_times2])
)
self.pops_in['npin2var'] = pynn.Population(
2,
pynn.cells.SpikeSourceArray(
spike_times=[np.array(self.spike_times),
np.array(self.spike_times2)])
)
self.pops_in['sein2var'] = pynn.Population(
2,
pynn.cells.SpikeSourceArray(
spike_times=[parameters.Sequence(self.spike_times),
parameters.Sequence(self.spike_times2)])
)
self.pops_in['in2equal'] = pynn.Population(
2,
pynn.cells.SpikeSourceArray(spike_times=[self.spike_times] * 2)
)
self.pops_in['npin2equal'] = pynn.Population(
2,
pynn.cells.SpikeSourceArray(
spike_times=[np.array(self.spike_times)] * 2)
)
self.pops_in['sein2equal'] = pynn.Population(
2,
pynn.cells.SpikeSourceArray(
spike_times=[parameters.Sequence(self.spike_times)] * 2)
)
self.pops_in['mixedtypein3equal'] = pynn.Population(
3,
pynn.cells.SpikeSourceArray(
spike_times=[
self.spike_times,
parameters.Sequence(self.spike_times),
np.array(self.spike_times)
])
)
self.pops_in['mixedtypein3var'] = pynn.Population(
3,
pynn.cells.SpikeSourceArray(
spike_times=[
self.spike_times,
parameters.Sequence(self.spike_times2),
np.array(self.spike_times)])
)
# SpikeSourcePoisson
poisson_properties = dict(rate=1e4, start=0, duration=10)
self.pops_in['poisson1'] = pynn.Population(
1,
pynn.cells.SpikeSourcePoisson(**poisson_properties)
)
self.pops_in['poisson2'] = pynn.Population(
2,
pynn.cells.SpikeSourcePoisson(**poisson_properties)
)
# Target Populations
self.pops = []
self.pops.append(pynn.Population(1, pynn.cells.HXNeuron()))
self.pops.append(pynn.Population(2, pynn.cells.HXNeuron()))
pynn.setup()
# In the current state, we only expose the neuron type 'HXNeuron',
# which allows low-level access to all circuit parameters. It can be
# configured by passing initial values to the respective Population.
# Each Population may consist of multiple neurons (in this case: one),
# all sharing the same parameters.
# Circuit parameters control the dynamic behavior of the neuron as well as
# static configuration. Most of them are either boolean or given in units of
# 'LSB' for chip-internal Digital-to-Analog converters - they have no direct
# biological translation.
# For this first example, you may alter the leak potential and observe
# the response of the analog neuron's resting potential.
pop = pynn.Population(1, pynn.cells.HXNeuron(
# Leak potential, range: 300-1000
leak_v_leak=700,
# Leak conductance, range: 0-1022
leak_i_bias=1022))
# The chip contains a fast Analog-to-Digital converter. It can be used to
# record different observables of a single analog neuron - most importantly
# the membrane potential.
#
# The chip additionally includes slower, parallel ADCs which will allow for
# parallel access to analog signals in multiple neurons. Support for this
# ADC will be integrated in future versions of our pyNN-Api.
pop.record(["v"])
# Calling pynn.run(time_in_ms) will as a first step apply the static
# configuration to the neuromorphic substrate. As a second step, the network
# is evolved for a given amount of time and neurons are stimulated by any
