flysim-malecns / flysim /tests /test_live.py
DevNexon's picture
flysim-malecns: connectome-v1 release
aecbd27 verified
Raw History Blame Contribute Delete
18 kB
"""Live simulation worker on a tiny synthetic network; one check on the real
connectome when it is fetched."""
import asyncio
import json
import math
import os
import threading
from pathlib import Path
import numpy as np
import pytest
from flysim.engine import CpuEngine, SynapseMatrix, poisson_schedule, trial_rng
from flysim.live import (
N_CHUNKS,
STIMULI,
BlockRequest,
BlockSpec,
ConnectomeSource,
InMemorySource,
InvalidRequest,
LiveConfig,
LiveModel,
LiveService,
Recording,
ReplayCache,
WorkerPool,
expected_wait,
make_engine,
model_fingerprint,
round_rate,
run_block,
)
from flysim.live import model as lm
from flysim.validation import chains
CONNECTOME = Path(os.environ.get(
"FLYSIM_CONNECTOME", Path(__file__).parents[2] / "data" / "connectome-v1"))
TRIALS_JSON = Path(__file__).parents[2] / "records" / "results" / "chain-tests-trials.json"
def synthetic() -> InMemorySource:
"""40 neurons: five right-side neurons per stimulus type, one left LC9 (never
stimulated), the 8 readout bodies, and 16 others with random recurrent edges."""
types = (["LC4"] * 5 + ["LC16"] * 5 + ["LC9"] * 6 + ["DNp01"] * 2 + ["MDN"] * 4
+ ["DNp09"] * 2 + ["other"] * 16)
sides = (["R"] * 15 + ["L"] + ["L", "R"] + ["L", "R", "L", "R"] + ["L", "R"]
+ [None] * 16)
n = len(types)
edges = []
for src, dst in (((0, 5), 17), ((5, 10), 19), ((5, 10), 21), ((10, 15), 23)):
edges += [(i, dst, 120) for i in range(*src)]
rng = np.random.default_rng(1)
for i in range(16, n):
for j in rng.choice(np.arange(16, n), 4, replace=False):
edges.append((i, int(j), int(rng.integers(-60, 90))))
edges += [(23, k, 80) for k in range(24, 28)] + [(17, k, 80) for k in range(28, 32)]
pre, post, w = (np.array(x) for x in zip(*edges, strict=True))
neurons = chains.Neurons(
body=np.arange(1000, 1000 + n, dtype=np.int64),
type=np.array(types, dtype=object), side=np.array(sides, dtype=object),
superclass=np.array(["x"] * n, dtype=object), sign=np.ones(n, dtype=np.int8))
return InMemorySource(SynapseMatrix.from_edges(pre, post, w, n), neurons)
@pytest.fixture(scope="module")
def src() -> InMemorySource:
return synthetic()
@pytest.fixture(scope="module")
def model(src: InMemorySource) -> LiveModel:
return LiveModel.build(src.neurons, check_sizes=False)
def test_stimuli_and_statuses_follow_the_chain_tests():
assert {s: STIMULI[s].status for s in STIMULI} == {
"LC4": "not_validated", "LC16": "not_validated", "LC9": "validated"}
assert (STIMULI["LC9"].chain, STIMULI["LC9"].readout) == ("approach", "DNp09")
assert STIMULI["LC4"].readout == "DNp01" and STIMULI["LC16"].readout == "MDN"
assert lm.PARAMS.w_syn == pytest.approx(0.1571, abs=1e-4)
assert (lm.BLOCK_STEPS, lm.STIM_STEPS, lm.CHUNK_STEPS, N_CHUNKS) == (6000, 3000, 100, 60)
def test_model_slots_and_targets(model: LiveModel):
assert model.slots == (("DNp01", "L"), ("DNp01", "R"), ("MDN", "L"), ("MDN", "R"),
("DNp09", "L"), ("DNp09", "R"))
assert model.targets["LC9"].tolist() == [10, 11, 12, 13, 14] # right side only
assert model.slot_of[23] == 5 and model.slot_of[30] == -1
with pytest.raises(ValueError, match="the preregistration says"):
LiveModel.build(synthetic().neurons, check_sizes=True)
def test_validation_and_rounding():
BlockSpec("LC9", 0.0, 0).validate()
BlockSpec("LC9", 200.0, 2**31 - 1).validate()
for bad in (BlockSpec("LC10", 50, 0), BlockSpec("LC9", -1, 0), BlockSpec("LC9", 201, 0),
BlockSpec("LC9", math.nan, 0), BlockSpec("LC9", 50, -1),
BlockSpec("LC9", 50, 2**31)):
with pytest.raises(InvalidRequest):
bad.validate()
assert round_rate(97.6, 5) == 100.0 and round_rate(2.4, 5) == 0.0
assert round_rate(199.0, 5) == 200.0 and round_rate(12.34, 0) == 12.34
assert BlockSpec("LC9", 100.0, 3).condition() == chains.stim_key("LC9", 100.0)
def _reference(src: InMemorySource, model: LiveModel, spec: BlockSpec, experiment: str):
"""The chain-test way: one reset, one schedule, one advance over the whole trial."""
eng = CpuEngine(np.float32, skip_rest=False)
eng.load(src.matrix, lm.PARAMS)
rng = trial_rng(experiment, spec.condition(), spec.seed)
eng.schedule_inputs(poisson_schedule(rng, model.targets[spec.stimulus], spec.rate_hz, 0,
lm.STIM_STEPS, lm.PARAMS.dt))
eng.advance_to(lm.BLOCK_STEPS)
return eng.spikes_since(0)
def test_chunks_equal_one_whole_trial(src: InMemorySource, model: LiveModel):
eng = make_engine(src.matrix)
spec = BlockSpec("LC9", 100.0, 7)
chunks = list(run_block(eng, model, spec, "chain-tests"))
assert [c.index for c in chunks] == list(range(N_CHUNKS))
for c in chunks:
assert c.step1 - c.step0 == 100
assert np.all((c.steps >= c.step0) & (c.steps < c.step1))
slot = model.slot_of[c.neurons]
assert c.counts.tolist() == np.bincount(slot[slot >= 0], minlength=6).tolist()
steps = np.concatenate([c.steps for c in chunks])
neurons = np.concatenate([c.neurons for c in chunks])
ref_s, ref_n = _reference(src, model, spec, "chain-tests")
assert len(ref_s) > 100
assert np.array_equal(steps, ref_s) and np.array_equal(neurons, ref_n)
# the stimulated chain drives its readout: DNp09 right, not left
total = np.sum([c.counts for c in chunks], axis=0)
assert total[5] > 0 and total[4] == 0
# no input after 300 ms
assert not np.any(np.isin(neurons[steps >= lm.STIM_STEPS], model.targets["LC9"]))
def test_every_block_starts_from_rest(src: InMemorySource, model: LiveModel):
eng = make_engine(src.matrix)
a = [c.neurons.tolist() for c in run_block(eng, model, BlockSpec("LC4", 150.0, 1))]
list(run_block(eng, model, BlockSpec("LC16", 200.0, 2)))
b = [c.neurons.tolist() for c in run_block(eng, model, BlockSpec("LC4", 150.0, 1))]
assert a == b
c = [c.neurons.tolist() for c in run_block(eng, model, BlockSpec("LC4", 150.0, 2))]
assert a != c # another seed, other input trains
def _recording(src, model, spec, experiment="live") -> Recording:
eng = make_engine(src.matrix)
return Recording.from_chunks(spec, experiment, model.n, model.slots,
run_block(eng, model, spec, experiment), 1.5)
def test_recording_roundtrip_and_cache(tmp_path: Path, src, model):
spec = BlockSpec("LC9", 100.0, 3)
rec = _recording(src, model, spec)
fp = model_fingerprint(src, "live")
cache = ReplayCache(tmp_path, fp)
assert cache.get(spec) is None and cache.find(spec) is None
path = cache.put(rec)
assert path.parent.name == fp[:16] and path.name == "LC9_100Hz_s3.npz"
back = cache.get(spec)
assert back is not None and back.spec == spec and back.slots == model.slots
for x, y in zip(rec.chunks(), back.chunks(), strict=True):
assert np.array_equal(x.steps, y.steps) and np.array_equal(x.neurons, y.neurons)
assert np.array_equal(x.counts, y.counts)
s = back.summary()
assert s["readouts_block"]["DNp09"]["R"] == int(rec.chunk_counts[:, 5].sum())
assert s["readouts_stimulus"]["DNp09"]["R"] == int(rec.chunk_counts[:30, 5].sum())
# the busy fallback takes another seed of the same stimulus and rate
other = cache.find(BlockSpec("LC9", 100.0, 99))
assert other is not None and other.spec.seed == 3
assert cache.find(BlockSpec("LC9", 50.0, 3)) is None
assert cache.seeds("LC9", 100.0) == [3]
# another model (or experiment) never sees these recordings
assert ReplayCache(tmp_path, model_fingerprint(src, "chain-tests")).find(spec) is None
# a damaged file is a miss
path.write_bytes(b"not an npz")
assert cache.get(spec) is None
def test_cache_evicts_stale_fingerprints_then_least_recently_used(tmp_path: Path, src, model):
import os
recs = [_recording(src, model, BlockSpec("LC9", 100.0, s)) for s in range(3)]
stale = ReplayCache(tmp_path, model_fingerprint(src, "chain-tests"))
old = stale.put(recs[0])
cache = ReplayCache(tmp_path, model_fingerprint(src, "live"))
paths = [cache.put(r) for r in recs]
size = paths[0].stat().st_size
for k, p in enumerate(paths): # put order = age, seed 0 oldest
os.utime(p, (1000 + k, 1000 + k))
assert cache.get(BlockSpec("LC9", 100.0, 0)) is not None # a replay is a use
cache.max_bytes = int(2.5 * size)
assert cache.evict() == 2 # the stale recording, then seed 1 (least recently used)
assert not old.exists()
assert cache.seeds("LC9", 100.0) == [0, 2]
cache.max_bytes = None
assert cache.evict() == 0
def test_fingerprints(tmp_path: Path, src):
assert model_fingerprint(src, "live") == model_fingerprint(synthetic(), "live")
other = synthetic()
w = other.matrix.weights.copy()
w[0] += 1
changed = InMemorySource(SynapseMatrix(other.matrix.indptr, other.matrix.indices, w),
other.neurons)
assert model_fingerprint(changed, "live") != model_fingerprint(src, "live")
d = tmp_path / "c"
d.mkdir()
(d / "SHA256SUMS").write_text("aa matrix-full.tar.zst\nbb neurons.parquet\ncc x\n")
fp1 = ConnectomeSource(d).fingerprint()
(d / "SHA256SUMS").write_text("aa matrix-full.tar.zst\nbb neurons.parquet\ndd x\n")
assert ConnectomeSource(d).fingerprint() == fp1 # other files do not matter
(d / "SHA256SUMS").write_text("ab matrix-full.tar.zst\nbb neurons.parquet\n")
assert ConnectomeSource(d).fingerprint() != fp1
def test_expected_wait():
assert expected_wait(10.0, 0, [], 0, 3.0) == math.inf
assert expected_wait(10.0, 2, [], 0, 3.0) == 0.0
assert expected_wait(10.0, 1, [9.0], 0, 3.0) == pytest.approx(2.0)
assert expected_wait(10.0, 1, [9.0], 2, 3.0) == pytest.approx(8.0)
assert expected_wait(10.0, 2, [9.0], 1, 3.0) == pytest.approx(2.0)
assert expected_wait(10.0, 2, [9.0, 10.0], 2, 3.0) == pytest.approx(5.0)
assert expected_wait(10.0, 1, [1.0], 0, 3.0) == 0.0 # overdue counts as free now
# ----------------------------------------------------------------------------- pool
def _collect(pool: WorkerPool, spec: BlockSpec, timeout: float = 120.0):
done = threading.Event()
events: list = []
def cb(kind, payload):
events.append((kind, payload))
if kind in ("done", "failed"):
done.set()
pool.submit(spec, cb)
assert done.wait(timeout), events
return events
@pytest.fixture(scope="module")
def pool(tmp_path_factory, src):
p = WorkerPool(src, 1, cache_root=tmp_path_factory.mktemp("cache"), compute_ratio_prior=5.0)
p.start()
yield p
p.close()
def test_pool_runs_blocks_in_a_worker_process(pool: WorkerPool, src, model):
spec = BlockSpec("LC9", 100.0, 5)
events = _collect(pool, spec)
kinds = [k for k, _ in events]
assert kinds == ["started"] + ["chunk"] * N_CHUNKS + ["done"]
assert events[0][1] == (model.n, model.slots)
ref = list(run_block(make_engine(src.matrix), model, spec))
for (_, got), want in zip(events[1:-1], ref, strict=True):
assert np.array_equal(got.neurons, want.neurons)
assert np.array_equal(got.counts, want.counts)
compute_s, summary = events[-1][1]
assert compute_s > 0 and summary["spikes"] == sum(len(c.neurons) for c in ref)
assert pool.block_s < 5.0 * lm.BLOCK_S # the estimate moved toward the measurement
assert pool.ready == 1 and pool.queued == 0
assert ReplayCache(pool._cfg.cache_root, pool.fingerprint).get(spec) is not None
assert pool.expected_wait() == 0.0
def test_pool_reports_a_worker_that_cannot_load(tmp_path: Path):
p = WorkerPool(ConnectomeSource(tmp_path / "missing"), 1)
p.start()
try:
events = _collect(p, BlockSpec("LC9", 100.0, 0))
assert events[-1][0] == "failed" and "load" in events[-1][1]
assert p.error is not None and p.expected_wait() == math.inf
finally:
p.close()
# ----------------------------------------------------------------------------- service
def _drain(service: LiveService, req: BlockRequest) -> list[dict]:
async def go():
return [m async for m in service.stream(req)]
return asyncio.run(go())
def test_service_live_then_repeat_replays_the_same_block(tmp_path: Path, src, model):
svc = LiveService(src, LiveConfig(workers=1, cache_dir=tmp_path, rate_step_hz=5.0))
svc.start()
try:
live = _drain(svc, BlockRequest("LC9", 98.0, 4))
again = _drain(svc, BlockRequest("LC9", 101.0, 4))
finally:
svc.close()
assert [m["type"] for m in live] == ["queued", "start"] + ["chunk"] * N_CHUNKS + ["end"]
assert [m["type"] for m in again] == ["start"] + ["chunk"] * N_CHUNKS + ["end"]
for m in live + again: # every message discloses the chain status and the source
assert m["chain_status"] == "validated" and m["chain"] == "approach"
assert {m["source"] for m in live} == {"live"} and {m["source"] for m in again} == {"replay"}
start = live[1]
assert start["rate_hz"] == 100.0 and start["rate_hz_requested"] == 98.0
assert start["block"]["starts_from_rest"] and start["block"]["chunks"] == 60
assert start["readouts"] == {"DNp01": ["L", "R"], "MDN": ["L", "R"], "DNp09": ["L", "R"]}
p = start["pacing"]
min_stretch = LiveConfig().min_stretch
assert p["stretch"] == pytest.approx(max(min_stretch, p["compute_ratio"] * 1.2), abs=1e-3)
assert again[0]["replay_reason"] == "repeat"
assert again[0]["pacing"]["stretch"] == min_stretch
strip = lambda ms: [{k: v for k, v in m.items() if k not in ("run", "source")} # noqa: E731
for m in ms if m["type"] == "chunk"]
assert strip(live) == strip(again)
ref = list(run_block(make_engine(src.matrix), model, BlockSpec("LC9", 100.0, 4)))
assert [m["neurons"] for m in live[2:-1]] == [c.neurons.tolist() for c in ref]
assert live[5]["t0_ms"] == 30.0 and live[5]["t1_ms"] == 40.0
assert all(0 <= s < 100 for m in live[2:-1] for s in m["steps"])
json.dumps(live) # JSON-ready
class BusyPool:
"""Stands in for a saturated pool."""
error = None
queued = 0
compute_ratio = 6.0
def __init__(self, wait: float) -> None:
self.wait = wait
self.submitted: list = []
def expected_wait(self) -> float:
return self.wait
def submit(self, spec, cb):
self.submitted.append(spec)
cb("failed", "stub")
def test_service_busy_falls_back_to_a_replay(tmp_path: Path, src, model):
cfg = LiveConfig(workers=0, cache_dir=tmp_path, serve_repeats=False, max_wait_s=2.0)
busy = BusyPool(5.0)
svc = LiveService(src, cfg, pool=busy) # type: ignore[arg-type]
svc.cache.put(_recording(src, model, BlockSpec("LC4", 50.0, 2))) # type: ignore[union-attr]
out = _drain(svc, BlockRequest("LC4", 50.0, 11))
assert out[0]["type"] == "start" and out[0]["source"] == "replay"
assert out[0]["replay_reason"] == "busy" and out[0]["seed"] == 2
assert out[0]["seed_requested"] == 11 and out[0]["chain_status"] == "not_validated"
assert busy.submitted == []
# no recording for this rate: queued live anyway
out = _drain(svc, BlockRequest("LC4", 100.0, 11))
assert [m["type"] for m in out] == ["queued", "error"] and busy.submitted
# with a short wait, live even though a recording of another seed exists
busy.wait = 0.5
out = _drain(svc, BlockRequest("LC4", 50.0, 11))
assert out[0]["type"] == "queued"
# serve_repeats off: an exact recording is not replayed while workers are free
out = _drain(svc, BlockRequest("LC4", 50.0, 2))
assert out[0]["type"] == "queued"
def test_service_refuses_bad_requests_and_no_workers(tmp_path: Path, src):
svc = LiveService(src, LiveConfig(workers=0, cache_dir=tmp_path))
for req in (BlockRequest("LC10", 50, 0), BlockRequest("LC9", 250, 0),
BlockRequest("LC9", 50, -3), BlockRequest("LC9", 50, 0, min_stretch=0.5)):
(m,) = _drain(svc, req)
assert m["type"] == "error"
(m,) = _drain(svc, BlockRequest("LC9", 50, 0))
assert m["type"] == "error" and "no recording" in m["detail"]
assert m["chain_status"] == "validated"
info = svc.info()
assert info["live"] is False
assert [s["chain_status"] for s in info["stimuli"]] == [
"not_validated", "not_validated", "validated"]
# ----------------------------------------------------------------------------- real data
@pytest.mark.skipif(not CONNECTOME.exists(), reason="connectome-v1 not fetched")
def test_real_connectome_block_is_the_recorded_chain_test_trial(tmp_path: Path):
"""LC9 at 100 Hz, trial 0, under the chain-test seed key: the same readout counts as
the committed chain-test record (live default kernel, chunked stepping, mapped
matrix)."""
src = ConnectomeSource(CONNECTOME, unpack_dir=tmp_path)
matrix, neurons = src.load()
model = LiveModel.build(neurons)
chunks = list(run_block(make_engine(matrix), model, BlockSpec("LC9", 100.0, 0), "chain-tests"))
rec = json.loads(TRIALS_JSON.read_text())["conditions"]["LC9/100Hz"]
k = rec["trials"].index(0)
steps = np.concatenate([c.steps for c in chunks])
neurons_ = np.concatenate([c.neurons for c in chunks])
assert int(np.sum(steps < lm.STIM_STEPS)) == rec["net_stim"][k]
assert int(np.sum((steps >= 4000) & (steps < 6000))) == rec["net_late"][k]
for r, bodies in rec["bodies"].items():
idx = neurons.index_of(bodies)
order = np.argsort(neurons.body[idx])
want = dict(zip(bodies, rec["counts"][r][k], strict=True))
got = {int(neurons.body[i]): int(np.sum((neurons_ == i) & (steps < lm.STIM_STEPS)))
for i in idx[order]}
assert got == want, r