SNN Exp1+2: TTFS + spike-accurate energy

SNN_EXPERIMENTS_2_RESULTS.md

@@ -0,0 +1,69 @@
+# SNN Follow-up: Fair TTFS Decoder + Spike-Accurate Energy
+
+Two experiments addressing the open questions from the first SNN study's negative result on
+temporal coding. They **overturn** that negative conclusion once the test is made fair.
+
+## Experiment 1 — fair time-to-first-spike (TTFS) decoder
+The first study's "latency" code was an early-weighted *spike-mass* surrogate (differentiable but a
+weak proxy for true timing). Here we add a **true TTFS decode**: value = (T − t_first)/T, each output
+neuron fires **at most once** (information is in the *timing*, not the count), trained via a
+**straight-through estimator** (forward = exact TTFS, backward = smooth surrogate). This gives the
+temporal code a fair gradient.
+
+## Experiment 2 — spike-accurate energy
+The first study counted *total spikes* (a crude proxy). Here we count **synaptic operations
+(SynOps)** — the unit neuromorphic energy estimators (Lava/Norse) charge — split into the dense
+input projection (T·H, always charged) and the **event-driven** hidden→output synops
+(#hidden-spikes × K). Absolute energy = SynOps × 1 pJ/SynOp (Loihi-class order), reported in nJ/decision.
+
+## Results — hazard sweep (3 seeds, 1500 steps, n_eval=2000)
+
+| hazard | arm | catastrophe | energy (nJ/dec) | energy vs rate |
+|---|---|---|---|---|
+| 0.2 | cvar_rate | 0.27% | 6.08 | — |
+| 0.2 | cvar_latency (soft) | 0.35% | 6.34 | +4.3% |
+| 0.2 | **cvar_ttfs** | 0.33% | **4.31** | **−29.1%** |
+| 0.5 | cvar_rate | 0.37% | 6.00 | — |
+| 0.5 | cvar_latency (soft) | 0.63% | 6.38 | +6.3% |
+| 0.5 | **cvar_ttfs** | 0.45% | **4.67** | **−22.3%** |
+| 0.8 | cvar_rate | 1.50% | 5.81 | — |
+| 0.8 | cvar_latency (soft) | 1.92% | 6.15 | +5.7% |
+| 0.8 | **cvar_ttfs** | 1.55% | **5.22** | **−10.2%** |
+
+## Findings
+
+1. **The negative result was an artifact of an unfair test.** With a true TTFS decoder (Exp 1) and
+   spike-accurate SynOp energy (Exp 2), **TTFS matches rate coding on tail protection
+   (catastrophe rate within noise) while using 10–29% LESS energy**. The earlier "rate beats
+   latency" conclusion was caused by (a) the weak early-weighted latency surrogate and (b) the
+   total-spike-count proxy, which both hid TTFS's structural advantage.
+
+2. **Why TTFS wins on energy:** each neuron fires at most once, so the event-driven hidden→output
+   SynOps collapse — TTFS does the same risk-sensitive job as rate coding with far fewer spike
+   events. This is exactly the neuromorphic efficiency argument: *the temporal code is cheaper, not
+   more accurate.* On a spike-accurate energy model the temporal code becomes load-bearing — but on
+   the **energy axis**, not the accuracy axis.
+
+3. **The soft "latency" surrogate is the worst of both** (slightly higher energy AND worse
+   catastrophe than both rate and TTFS), confirming the first study's negative result was about that
+   specific weak decoder, not temporal coding per se.
+
+4. **Tail-protection-per-joule (Martinet's decisive metric):** TTFS dominates. At hazard 0.5,
+   equal catastrophe protection to rate at 0.78× the energy; at hazard 0.2, 0.71× the energy. On a
+   risk–energy frontier, `cvar_ttfs` is Pareto-optimal.
+
+## Revised conclusion
+The spike-timing-risk-coding hypothesis (H2) is **supported on the efficiency axis**: a true
+time-to-first-spike code delivers the same coherent-risk tail protection as rate coding at
+**10–29% lower spike-accurate energy**, because single-spike timing encodes the value with far fewer
+synaptic events. Combined with the first study's result (the CVaR objective itself transfers to
+SNNs, cutting 42–60% of catastrophes), the full statement is: **CVaR-DQN on a TTFS-coded spiking
+value network is a risk-sensitive *and* energy-efficient controller** — the neuromorphic
+risk-control result the roadmap targeted. Caveats for honesty: energy is a SynOp model (1 pJ/SynOp),
+not silicon measurement; the bandit is synthetic; and the accuracy gap between TTFS and rate is
+within noise (the win is energy, not tail protection).
+
+## Reproduce
+`python3 -m rl.snn.experiment --steps 1500 --seeds 0,1,2 --hazard {0.2,0.5,0.8} --alpha 0.3`.
+New: `coding="ttfs"` (true TTFS + straight-through, `spiking.py`), `synops_per_decision` /
+`energy_nJ_per_decision` (SynOp-accurate energy, `experiment.py`).