def build_node(model, node):
if isinstance(node, ChipReceiveNode):
spike_input = SpikeInput(node.raw_dimensions, label=node.label)
model.add_input(spike_input)
model.objs[node]["out"] = spike_input
node.spike_target = spike_input
else:
raise NotImplementedError()
def build_dvs_file_chip_process(model, process, node=None):
e_t, e_idx = process._read_events()
label = node.label if node is not None else "DVSFileChipProcess"
spike_input = SpikeInput(process.size, label=label)
dt_us = model.dt * 1e6
t = process.t_start * 1e6 # time in us
image_idx = 0
event_idx = 0
while t <= e_t[-1]:
t += dt_us
image_idx += 1
new_event_idx = event_idx + np.searchsorted(e_t[event_idx:], t)
spike_input.add_spikes(image_idx,
e_idx[event_idx:new_event_idx],
permanent=True)
event_idx = new_event_idx
model.add_input(spike_input)
return spike_input
def test_negative_cxbase(request, seed):
n_axons = 3
model = Model()
input = SpikeInput(n_axons)
input.add_spikes(1, list(range(n_axons)))
model.add_input(input)
axon = Axon(n_axons)
input.add_axon(axon)
block = LoihiBlock(3)
block.compartment.configure_relu()
model.add_block(block)
synapse = Synapse(n_axons)
weights = [0.1, 0.1, 0.1]
indices = [0, 1, 2]
axon_to_weight_map = list(range(n_axons))
cx_bases = [0, 1, -1]
synapse.set_population_weights(weights,
indices,
axon_to_weight_map,
cx_bases,
pop_type=32)
axon.target = synapse
block.add_synapse(synapse)
probe = Probe(target=block, key='voltage')
block.add_probe(probe)
discretize_model(model)
n_steps = 2
if request.config.getoption("--target") == 'loihi':
with HardwareInterface(model, use_snips=False, seed=seed) as sim:
sim.run_steps(n_steps)
y = sim.get_probe_output(probe)
else:
with EmulatorInterface(model, seed=seed) as sim:
sim.run_steps(n_steps)
y = sim.get_probe_output(probe)
# Compartments 0 and 2 should change from axons 0 and 1.
# Axon 2 should have no effect, and not change compartment 1 (the sum of
# its cx_base and index), or other compartments (e.g. 2 if cx_base ignored)
assert np.allclose(y[1, 1], 0), "Third axon not ignored"
assert np.allclose(y[1, 0], y[1, 2]), "Third axon targeting another"
assert not np.allclose(y[1], y[0]), "Voltage not changing"
def test_multiple_get_probe_output():
n_steps = 15
n_axons = 3
model = Model()
# n_axons controls number of input spikes and thus amount of overflow
input = SpikeInput(n_axons)
for t in np.arange(1, n_steps + 1):
input.add_spikes(t, np.arange(n_axons)) # send spikes to all axons
model.add_input(input)
block = LoihiBlock(1)
block.compartment.configure_relu()
block.compartment.configure_filter(0.1)
model.add_block(block)
synapse = Synapse(n_axons)
synapse.set_weights(np.ones((n_axons, 1)))
block.add_synapse(synapse)
axon = Axon(n_axons)
axon.target = synapse
input.add_axon(axon)
probe_u = LoihiProbe(target=block, key="current", synapse=Lowpass(0.005))
model.add_probe(probe_u)
probe_v = LoihiProbe(target=block, key="voltage", synapse=Lowpass(0.005))
model.add_probe(probe_v)
probe_s = LoihiProbe(target=block, key="spiked", synapse=Lowpass(0.005))
model.add_probe(probe_s)
discretize_model(model)
# must set these after `discretize` to specify discretized values
block.compartment.vmin = -(2**22) + 1
block.compartment.vth[:] = VTH_MAX
with EmulatorInterface(model) as emu:
emu.run_steps(n_steps)
first_u = emu.get_probe_output(probe_u)
first_v = emu.get_probe_output(probe_v)
first_s = emu.get_probe_output(probe_s)
second_u = emu.get_probe_output(probe_u)
second_v = emu.get_probe_output(probe_v)
second_s = emu.get_probe_output(probe_s)
assert np.all(first_u == second_u)
assert np.all(first_v == second_v)
assert np.all(first_s == second_s)
def build_chip_receive_node(model, node):
spike_input = SpikeInput(node.raw_dimensions, label=node.label)
model.add_input(spike_input)
model.objs[node]["out"] = spike_input
model.spike_targets[node] = spike_input
def test_uv_overflow(n_axons, plt, allclose, monkeypatch):
# TODO: Currently this is not testing the V overflow, since it is higher
# and I haven't been able to figure out a way to make it overflow.
nt = 15
model = Model()
# n_axons controls number of input spikes and thus amount of overflow
input = SpikeInput(n_axons)
for t in np.arange(1, nt + 1):
# send spikes to all axons
input.add_spikes(t, np.arange(n_axons), permanent=True)
model.add_input(input)
block = LoihiBlock(1)
block.compartment.configure_relu()
block.compartment.configure_filter(0.1)
model.add_block(block)
synapse = Synapse(n_axons)
synapse.set_weights(np.ones((n_axons, 1)))
block.add_synapse(synapse)
axon = Axon(n_axons)
axon.target = synapse
input.add_axon(axon)
probe_u = LoihiProbe(target=block, key="current")
model.add_probe(probe_u)
probe_v = LoihiProbe(target=block, key="voltage")
model.add_probe(probe_v)
probe_s = LoihiProbe(target=block, key="spiked")
model.add_probe(probe_s)
discretize_model(model)
# must set these after `discretize` to specify discretized values
block.compartment.vmin = -(2**22) + 1
block.compartment.vth[:] = VTH_MAX
assert EmulatorInterface.strict # Tests should be run in strict mode
monkeypatch.setattr(EmulatorInterface, "strict", False)
overflow_var = "q0" if n_axons == 1000 else "current"
with EmulatorInterface(model) as emu:
with pytest.warns(UserWarning, match=f"Overflow in {overflow_var}"):
emu.run_steps(nt)
emu_u = emu.collect_probe_output(probe_u)
emu_v = emu.collect_probe_output(probe_v)
emu_s = emu.collect_probe_output(probe_s)
with HardwareInterface(model, use_snips=False) as sim:
sim.run_steps(nt)
sim_u = sim.collect_probe_output(probe_u)
sim_v = sim.collect_probe_output(probe_v)
sim_s = sim.collect_probe_output(probe_s)
sim_v[sim_s > 0] = 0 # since Loihi has placeholder voltage after spike
plt.subplot(311)
plt.plot(emu_u)
plt.plot(sim_u)
plt.subplot(312)
plt.plot(emu_v)
plt.plot(sim_v)
plt.subplot(313)
plt.plot(emu_s)
plt.plot(sim_s)
assert allclose(emu_u, sim_u)
assert allclose(emu_v, sim_v)
def test_population_input(request, allclose):
target = request.config.getoption("--target")
dt = 0.001
n_inputs = 3
n_axons = 1
n_cx = 2
steps = 6
spike_times_inds = [(1, [0]), (3, [1]), (5, [2])]
model = Model()
input = SpikeInput(n_inputs)
model.add_input(input)
spikes = [(input, ti, inds) for ti, inds in spike_times_inds]
input_axon = Axon(n_axons)
axon_map = np.zeros(n_inputs, dtype=int)
atoms = np.arange(n_inputs)
input_axon.set_axon_map(axon_map, atoms)
input.add_axon(input_axon)
block = LoihiBlock(n_cx)
block.compartment.configure_lif(tau_rc=0., tau_ref=0., dt=dt)
block.compartment.configure_filter(0, dt=dt)
model.add_block(block)
synapse = Synapse(n_axons)
weights = 0.1 * np.array([[[1, 2], [2, 3], [4, 5]]], dtype=float)
indices = np.array([[[0, 1], [0, 1], [0, 1]]], dtype=int)
axon_to_weight_map = np.zeros(n_axons, dtype=int)
cx_bases = np.zeros(n_axons, dtype=int)
synapse.set_population_weights(weights,
indices,
axon_to_weight_map,
cx_bases,
pop_type=32)
block.add_synapse(synapse)
input_axon.target = synapse
probe = Probe(target=block, key='voltage')
block.add_probe(probe)
discretize_model(model)
if target == 'loihi':
with HardwareInterface(model, use_snips=True) as sim:
sim.run_steps(steps, blocking=False)
for ti in range(1, steps + 1):
spikes_i = [spike for spike in spikes if spike[1] == ti]
sim.host2chip(spikes=spikes_i, errors=[])
sim.chip2host(probes_receivers={})
y = sim.get_probe_output(probe)
else:
for inp, ti, inds in spikes:
inp.add_spikes(ti, inds)
with EmulatorInterface(model) as sim:
sim.run_steps(steps)
y = sim.get_probe_output(probe)
vth = block.compartment.vth[0]
assert (block.compartment.vth == vth).all()
z = y / vth
assert allclose(z[[1, 3, 5]], weights[0], atol=4e-2, rtol=0)