flysim-malecns / flysim /tests /test_engine.py
DevNexon's picture
flysim-malecns: connectome-v1 release
aecbd27 verified
Raw History Blame Contribute Delete
18 kB
"""Engine tests on tiny networks: exact dynamics, Brian2 step order, and equality with a
naive implementation written independently of the kernel."""
import math
import numpy as np
import pytest
from flysim.engine import (
CpuEngine,
InputSchedule,
ModelParams,
SynapseMatrix,
poisson_schedule,
trial_rng,
)
from flysim.engine.inputs import merge
P = ModelParams()
# First draw of trial 0 of one condition, pinned so a change to the seeding scheme
# cannot pass silently.
PINNED_DRAW = 1489115183
def _matrix(edges: list[tuple[int, int, int]], n: int) -> SynapseMatrix:
pre, post, w = zip(*edges, strict=True) if edges else ((), (), ())
return SynapseMatrix.from_edges(np.array(pre), np.array(post), np.array(w), n)
def _inputs(at: dict[int, list[int]]) -> InputSchedule:
"""{neuron: [steps]} -> schedule."""
pairs = sorted((s, n) for n, steps in at.items() for s in steps)
return InputSchedule(
targets=np.array(sorted(at), dtype=np.int32),
steps=np.array([s for s, _ in pairs], dtype=np.int64),
neurons=np.array([n for _, n in pairs], dtype=np.int32),
)
KERNELS = ("plain", "skip_rest", "vec")
def _run(matrix, schedule, steps, dtype=np.float32, params=P, skip_rest=False, kernel=None):
eng = CpuEngine(dtype, skip_rest=skip_rest, kernel=kernel)
eng.load(matrix, params)
eng.schedule_inputs(schedule)
eng.advance_to(steps)
return eng
def _spike_steps(eng, neuron):
s, n = eng.spikes_since(0)
return s[n == neuron].tolist()
def test_params_match_the_preregistration():
assert P.rfc_steps == 22
assert P.delay_steps == 18
assert P.w_input == pytest.approx(68.75)
def test_input_spike_fires_next_step_and_reset_discards_same_step_input():
# Input at every step 0..9: an input fires the neuron in the next step, and the
# input arriving in the spiking step is wiped by the reset (Brian2 order).
eng = _run(_matrix([], 1), _inputs({0: list(range(10))}), 12)
assert _spike_steps(eng, 0) == [1, 3, 5, 7, 9]
def test_delay_and_exact_propagator():
# 0 spikes at step 1, so its synapse onto 1 lands at step 1 + 18 = 19.
w = 100
eng = _run(_matrix([(0, 1, w)], 2), _inputs({0: [0]}), 19, dtype=np.float64)
assert eng.g[1] == 0 and eng.v[1] == P.v_0
eng.advance_to(20)
g0 = P.w_syn * w
assert eng.g[1] == pytest.approx(g0)
# From the end of step 19, neuron 1 follows the closed-form solution.
for k in range(1, 200):
eng.advance_to(20 + k)
t = k * P.dt
u = g0 * P.tau / (P.tau - P.t_mbr) * (math.exp(-t / P.tau) - math.exp(-t / P.t_mbr))
assert eng.v[1] - P.v_0 == pytest.approx(u, rel=1e-9, abs=1e-12)
assert eng.g[1] == pytest.approx(g0 * math.exp(-t / P.tau), rel=1e-9)
assert _spike_steps(eng, 1) == []
def test_refractory_period_is_22_steps_and_drops_input():
# 0 spikes at every odd step; each spike gives 1 a huge kick 18 steps later, at
# odd steps from 19. 1 spikes at 20 and is refractory for steps 21-41; the kicks
# in that window are dropped (Brian2's conditional write), so it is at rest at
# step 42 and only the kick at 43 fires it, at 44. Period: 24 steps.
eng = _run(_matrix([(0, 1, 20000)], 2), _inputs({0: list(range(0, 400, 2))}), 120)
assert _spike_steps(eng, 1) == [20, 44, 68, 92, 116]
def test_input_to_refractory_neuron_is_dropped_not_deferred():
# 1 spikes at 20 (kick from 0's spike at 1). A second, smaller kick lands at 25,
# inside the refractory window: Brian2 drops it, so 1 stays exactly at rest.
m = _matrix([(0, 1, 20000), (2, 1, 20000)], 3)
eng = _run(m, _inputs({0: [0], 2: [5]}), 60, dtype=np.float64)
assert _spike_steps(eng, 1) == [20]
assert eng.v[1] == P.v_0 and eng.g[1] == 0
def test_inhibition_and_stimulated_neurons_have_no_refractory_period():
m = _matrix([(0, 2, 30000), (1, 2, -30000)], 3)
both = _run(m, _inputs({0: [0], 1: [0]}), 100)
only_exc = _run(m, _inputs({0: [0]}), 100)
assert _spike_steps(only_exc, 2) == [20]
assert _spike_steps(both, 2) == []
# 0 Hz targets still lose their refractory period (Brian2's poi() sets rfc = 0).
eng = _run(m, InputSchedule(np.array([0, 1], np.int32), np.zeros(0, np.int64),
np.zeros(0, np.int32)), 1)
assert eng.rfc.tolist() == [0, 0, P.rfc_steps]
def _naive(matrix: SynapseMatrix, schedule: InputSchedule, steps: int, dtype) -> list[tuple]:
"""Straightforward per-step implementation of the same schedule, no shortcuts."""
f = np.dtype(dtype).type
n = matrix.n
a, b, c = (f(x) for x in P.coefficients())
v = np.full(n, P.v_0, dtype)
g = np.zeros(n, dtype)
last = np.full(n, -(10**9))
rfc = np.full(n, P.rfc_steps)
rfc[schedule.targets] = 0
history: list[np.ndarray] = []
out = []
for s in range(steps):
active = (s - last) >= rfc
v_new = f(P.v_0) + (v - f(P.v_0)) * a + g * b
v = np.where(active, v_new, v).astype(dtype)
g = np.where(active, g * c, g).astype(dtype)
spk = np.flatnonzero(active & (v > f(P.v_th)))
last[spk] = s
history.append(spk)
# Brian2's not_refractory after the thresholder: writes to v and g are
# conditional on it.
writable = active.copy()
writable[spk] = False
if s >= P.delay_steps:
for j in history[s - P.delay_steps]:
lo, hi = matrix.indptr[j], matrix.indptr[j + 1]
for post, w in zip(matrix.indices[lo:hi], matrix.weights[lo:hi], strict=True):
if writable[post]:
g[post] += f(P.w_syn) * f(w)
for k in np.flatnonzero(schedule.steps == s):
if writable[schedule.neurons[k]]:
v[schedule.neurons[k]] += f(P.w_input)
v[spk] = f(P.v_rst)
g[spk] = 0
out += [(s, int(i)) for i in spk]
return out
@pytest.mark.parametrize("kernel", KERNELS)
@pytest.mark.parametrize("dtype", [np.float32, np.float64])
def test_kernel_matches_naive_implementation(dtype, kernel):
rng = np.random.default_rng(1)
n, n_edges = 300, 6000
pre = rng.integers(0, n, n_edges)
post = rng.integers(0, n, n_edges)
w = rng.integers(1, 40, n_edges) * np.where(rng.random(n_edges) < 0.25, -1, 1)
m = SynapseMatrix.from_edges(pre, post, w, n)
sched = poisson_schedule(rng, np.arange(20), 150.0, 0, 1500, P.dt)
eng = _run(m, sched, 1500, dtype=dtype, kernel=kernel)
s, i = eng.spikes_since(0)
ours = list(zip(s.tolist(), i.tolist(), strict=True))
assert len(ours) > 1000 # the network is actually active
assert ours == _naive(m, sched, 1500, dtype)
@pytest.mark.parametrize("kernel", KERNELS)
def test_chunked_advance_and_log_growth_change_nothing(kernel):
rng = np.random.default_rng(2)
n = 200
m = SynapseMatrix.from_edges(rng.integers(0, n, 4000), rng.integers(0, n, 4000),
rng.integers(1, 30, 4000), n)
sched = poisson_schedule(rng, np.arange(15), 200.0, 0, 3000, P.dt)
whole = _run(m, sched, 3000) # plain kernel, in one go
chunked = CpuEngine(kernel=kernel)
chunked.load(m, P)
chunked._log = np.empty(n + 1, np.int32) # force repeated growth
chunked.schedule_inputs(sched)
seen_s, seen_n = [], []
for stop in range(100, 3001, 100): # 10 ms chunks, as the live runs step
before = chunked.step
chunked.advance_to(stop)
s, i = chunked.spikes_since(before)
seen_s.append(s)
seen_n.append(i)
ws, wn = whole.spikes_since(0)
np.testing.assert_array_equal(np.concatenate(seen_s), ws)
np.testing.assert_array_equal(np.concatenate(seen_n), wn)
np.testing.assert_array_equal(chunked.snapshot().v, whole.snapshot().v)
def test_reset_restores_rest_and_inputs_cannot_go_back_in_time():
eng = _run(_matrix([(0, 1, 5)], 2), _inputs({0: [0, 5]}), 50)
with pytest.raises(ValueError):
eng.schedule_inputs(_inputs({0: [10]}))
eng.reset()
assert eng.step == 0 and np.all(eng.v == P.v_0) and np.all(eng.g == 0)
assert eng.spikes_since(0)[0].size == 0
assert eng.rfc.tolist() == [P.rfc_steps] * 2
def test_seeding_is_stable_and_keyed():
a = trial_rng("E1", "E1/sugar/100Hz", 3).random(4)
b = trial_rng("E1", "E1/sugar/100Hz", 3).random(4)
np.testing.assert_array_equal(a, b)
assert not np.array_equal(a, trial_rng("E1", "E1/sugar/100Hz", 4).random(4))
assert not np.array_equal(a, trial_rng("E1", "E1/sugar/50Hz", 3).random(4))
assert trial_rng("E1", "E1/sugar/100Hz", 0).integers(0, 2**31) == PINNED_DRAW
def test_named_seed_namespaces_keep_the_recorded_seeds():
"""The public names of the chain tests and the live worker map to the namespace
strings the recorded runs were seeded with (draws pinned before the renaming)."""
assert trial_rng("chain-tests", "LC9/100Hz", 0).integers(0, 2**31) == 1436011335
assert trial_rng("chain-tests", "control-55/03", 7).integers(0, 2**31) == 707105761
assert trial_rng("live", "LC4/35Hz", 12).integers(0, 2**31) == 249271961
def test_poisson_rate_and_schedule_merge():
rng = trial_rng("test", "rate", 0)
s = poisson_schedule(rng, np.arange(50), 100.0, 0, 10000, P.dt)
rate = len(s.steps) / 50 / 1.0
assert 90 < rate < 110
s2 = poisson_schedule(rng, np.array([60, 61]), 0.0, 0, 10000, P.dt)
assert len(s2.steps) == 0
merged = merge(s, s2)
assert set(merged.targets.tolist()) == set(range(50)) | {60, 61}
assert np.all(np.diff(merged.steps) >= 0)
def _sparse_net(seed: int, n: int = 3000, n_edges: int = 30000) -> SynapseMatrix:
"""Mostly quiet network: activity spreads from a few stimulated neurons, as in the
connectome, so neurons leave rest, return to it and leave it again."""
rng = np.random.default_rng(seed)
pre, post = rng.integers(0, n, n_edges), rng.integers(0, n, n_edges)
w = rng.integers(1, 60, n_edges) * np.where(rng.random(n_edges) < 0.3, -1, 1)
return SynapseMatrix.from_edges(pre, post, w, n)
@pytest.mark.parametrize("seed", [3, 4, 5])
def test_skip_rest_is_bit_identical_to_the_plain_kernel(seed):
m = _sparse_net(seed)
rng = np.random.default_rng(seed)
sched = poisson_schedule(rng, rng.choice(m.n, 40, replace=False), 120.0, 0, 3000, P.dt)
plain = _run(m, sched, 6000)
fast = CpuEngine(kernel="skip_rest")
fast.dense_div = 1 # stay sparse: this test checks the list path
fast.load(m, P)
fast.schedule_inputs(sched)
for stop in (1, 17, 18, 100, 2999, 3000, 3001, 4500, 6000): # odd chunk edges
fast.advance_to(stop)
ps, pn = plain.spikes_since(0)
fs, fn = fast.spikes_since(0)
assert len(ps) > 1000
np.testing.assert_array_equal(fs, ps)
np.testing.assert_array_equal(fn, pn)
# the whole state, bit for bit (v and g compared as raw bits, NaN-proof)
a, b = plain.snapshot(), fast.snapshot()
np.testing.assert_array_equal(a.v.view(np.int32), b.v.view(np.int32))
np.testing.assert_array_equal(a.g.view(np.int32), b.g.view(np.int32))
np.testing.assert_array_equal(a.last_spike, b.last_spike)
# list invariant (sparse mode): every neuron off rest is listed, the list is sorted
assert not fast._dense
off = np.flatnonzero((fast.v != np.float32(P.v_0)) | (fast.g != 0))
listed = np.union1d(fast._act[fast._cur, : fast._n_act], fast._new[: fast._n_new])
assert np.isin(off, listed).all()
cur = fast._act[fast._cur, : fast._n_act]
assert np.all(np.diff(cur) > 0)
assert 0 < fast._n_act < m.n # it actually skips neurons
def test_skip_rest_survives_reset():
m = _sparse_net(6)
rng = np.random.default_rng(6)
sched = poisson_schedule(rng, np.arange(30), 150.0, 0, 1000, P.dt)
eng = CpuEngine(kernel="skip_rest")
eng.load(m, P)
eng.schedule_inputs(sched)
eng.advance_to(1500)
first = eng.spikes_since(0)
eng.reset()
assert eng._n_act == 0 and eng._n_new == 0 and not eng._flag.any()
eng.schedule_inputs(sched)
eng.advance_to(1500)
for x, y in zip(first, eng.spikes_since(0), strict=True):
np.testing.assert_array_equal(x, y)
@pytest.mark.parametrize("dense_div", [1, 2, 50, 10**6])
def test_skip_rest_dense_switch_is_bit_identical(dense_div):
m = _sparse_net(7)
rng = np.random.default_rng(7)
sched = poisson_schedule(rng, rng.choice(m.n, 60, replace=False), 150.0, 0, 3000, P.dt)
plain = _run(m, sched, 6000)
fast = CpuEngine(kernel="skip_rest")
fast.dense_div = dense_div
fast.load(m, P)
fast.schedule_inputs(sched)
for stop in (250, 2000, 6000):
fast.advance_to(stop)
for x, y in zip(plain.spikes_since(0), fast.spikes_since(0), strict=True):
np.testing.assert_array_equal(x, y)
np.testing.assert_array_equal(plain.v.view(np.int32), fast.v.view(np.int32))
np.testing.assert_array_equal(plain.g.view(np.int32), fast.g.view(np.int32))
if dense_div in (1, 10**6): # 1 never switches; 10**6 switches at the first input
assert fast._dense == (dense_div == 10**6)
def _bits_equal(a: CpuEngine, b: CpuEngine) -> None:
"""Spikes and the whole state, bit for bit (v and g as raw bits, NaN-proof)."""
for x, y in zip(a.spikes_since(0), b.spikes_since(0), strict=True):
np.testing.assert_array_equal(x, y)
bits = np.int32 if a.dtype == np.float32 else np.int64
np.testing.assert_array_equal(a.v.view(bits), b.v.view(bits))
np.testing.assert_array_equal(a.g.view(bits), b.g.view(bits))
np.testing.assert_array_equal(a.last, b.last)
def _until_matches(eng: CpuEngine) -> None:
"""vec's refractory state is last + max(rfc, 1) for every neuron that has spiked."""
spiked = eng.last > -(2**40)
np.testing.assert_array_equal(eng._until[spiked],
eng.last[spiked] + np.maximum(eng.rfc[spiked], 1))
assert np.all(eng._until[~spiked] < -(2**29))
def test_kernel_choice():
assert CpuEngine().kernel == "vec" and CpuEngine(skip_rest=True).kernel == "vec"
assert CpuEngine(kernel="skip_rest").kernel == "skip_rest"
assert CpuEngine(skip_rest=False).kernel == "plain"
assert CpuEngine(kernel="vec").kernel == "vec"
with pytest.raises(ValueError):
CpuEngine(kernel="fast")
@pytest.mark.parametrize("dtype", [np.float32, np.float64])
@pytest.mark.parametrize("dense_div", [1, 2, 50, 10**6])
@pytest.mark.parametrize("seed", [3, 7])
def test_vec_is_bit_identical_to_the_plain_kernel(seed, dense_div, dtype):
# dense_div 1 never leaves the list path; 10**6 sweeps densely from the first input
m = _sparse_net(seed)
rng = np.random.default_rng(seed)
sched = poisson_schedule(rng, rng.choice(m.n, 60, replace=False), 150.0, 0, 3000, P.dt)
plain = _run(m, sched, 6000, dtype=dtype)
fast = CpuEngine(dtype, kernel="vec")
fast.dense_div = dense_div
fast.load(m, P)
fast._log = np.empty(m.n + 1, np.int32) # force repeated log growth
fast.schedule_inputs(sched)
for stop in (1, 17, 18, 100, 511, 2999, 3000, 3001, 4500, 6000): # odd chunk edges
fast.advance_to(stop)
assert len(plain.spikes_since(0)[0]) > 1000
_bits_equal(plain, fast)
_until_matches(fast)
if dense_div in (1, 10**6):
assert fast._dense == (dense_div == 10**6)
def test_vec_dense_sweep_with_blocks_and_ragged_tail():
# more neurons than one block, not a multiple of it, dense from the start; a long
# quiet tail lets g decay into the subnormal range, where it gets stuck: m * c
# rounds back to m for subnormal mantissas m <= 25, so g never reaches 0
from flysim.engine.kernel import VEC_BLOCK
n = 3 * VEC_BLOCK + 77
m = _sparse_net(8, n=n, n_edges=12 * n)
rng = np.random.default_rng(8)
sched = poisson_schedule(rng, rng.choice(n, 40, replace=False), 150.0, 0, 1500, P.dt)
plain = CpuEngine(kernel="plain")
fast = CpuEngine(kernel="vec")
fast.dense_div = 10**6
subnormal = 0
for eng in (plain, fast):
eng.load(m, P)
eng.schedule_inputs(sched)
for stop in range(500, 12001, 500):
plain.advance_to(stop)
fast.advance_to(stop)
_bits_equal(plain, fast)
gb = plain.g.view(np.int32) & 0x7FFFFFFF
subnormal += int(np.sum((gb > 0) & (gb < 0x00800000)))
assert fast._dense and subnormal > 0
gb = plain.g.view(np.int32) & 0x7FFFFFFF
assert np.all(gb < 0x00800000) and np.any(gb > 0) # every g is 0 or subnormal
@pytest.mark.parametrize("kernel", ["skip_rest", "vec"])
def test_rfc_change_after_a_spike_is_honoured(kernel):
# 1 spikes at 20 (kick from 0's spike at 1), so it is refractory for 22 steps. At
# step 22 it becomes a stimulus target, so rfc drops to 0 and the inputs at 25 and
# later count at once, as in the plain kernel (rfc is read when it is used).
m = _matrix([(0, 1, 20000)], 2)
for k in ("plain", kernel):
eng = CpuEngine(np.float64, kernel=k)
eng.load(m, P)
eng.schedule_inputs(_inputs({0: [0]}))
eng.advance_to(22)
eng.schedule_inputs(_inputs({1: [25, 26, 30]}))
eng.advance_to(60)
if k == "plain":
plain = eng
assert _spike_steps(plain, 1) == [20, 26, 31]
_bits_equal(plain, eng)
if kernel == "vec":
_until_matches(eng)
def test_vec_survives_reset():
m = _sparse_net(6)
rng = np.random.default_rng(6)
sched = poisson_schedule(rng, np.arange(30), 150.0, 0, 1000, P.dt)
eng = CpuEngine(kernel="vec")
eng.dense_div = 10**6
eng.load(m, P)
eng.schedule_inputs(sched)
eng.advance_to(1500)
first = eng.spikes_since(0)
assert eng._dense
eng.reset()
assert not eng._dense and eng._n_act == 0 and not eng._flag.any()
assert np.all(eng._until < -(2**29)) and eng.rfc.tolist() == [P.rfc_steps] * m.n
eng.schedule_inputs(sched)
eng.advance_to(1500)
for x, y in zip(first, eng.spikes_since(0), strict=True):
np.testing.assert_array_equal(x, y)