dense_edge (conv) vs dense_edge_gru: a smoke-scale comparison

2026-08-24 · architecture ablation

The model has always had two ways to summarize a coherence edge's behavior over time into a single vector: a small convolutional block, or a per-edge GRU. Only the GRU path had actually been wired into the real pipeline's command-line interface; this session finished wiring up the convolutional alternative and ran the same smoke-scale six-fold comparison against it, alongside turning on validation-based early stopping for the first time.

Not an isolated ablation

Worth being upfront about before the numbers: this is not a clean head-to-head. The GRU numbers being compared against were trained for a fixed 10 epochs on the full training set with no validation split; the conv run added a validation split and early stopping in the same pass, so most folds trained on 80% of the data and restored an earlier checkpoint instead of running the full schedule. Any difference below reflects both the temporal-block choice and this protocol change together, not the temporal block in isolation.

Results, on the folds without known smoke-scale artifacts

Two of the six folds in this smoke-scale run are known artifacts of the reduced interictal sample used here (one is a persistent outlier under both architectures, one has a degenerate all-positive test set from the sampling scheme) — excluded from this comparison to avoid reading noise as signal:

metric	GRU (10 epochs, no val)	conv (early-stopped)
accuracy	0.828	0.862
F1	0.608	0.697
average precision	0.586	0.674
ROC-AUC	0.902	0.919
k-of-n hits	3/4	4/4

The convolutional block came out ahead on every metric here, including catching a seizure the GRU run missed after smoothing. On the one fold where a closer protocol match was possible — the GRU also run with the same validation split and full epoch schedule, no early stopping — the two architectures landed close together (F1 0.697 GRU vs. 0.754 conv on that fold), a smaller gap than the headline numbers suggest. Both architectures agreed on which fold is a genuine problem: the outlier fold stayed a false-alarm disaster under either temporal block, around 100 false alarms per hour that smoothing couldn't meaningfully fix, though the convolutional block's ranking score on that fold was noticeably better even while still being unusable as an actual predictor there.

What would make this a real ablation

The same six folds, same live-edge channel subset, same validation split and early-stopping patience, with only the temporal block itself changed between runs — that head-to-head hasn't been run yet. This session's comparison is suggestive that the convolutional block isn't behind the GRU and plausibly ahead of it, but the protocol confound needs to be removed before treating that as a real finding rather than a training-schedule artifact.

Open items

A matched-protocol conv-vs-GRU rerun is the direct next step. Neither architecture was tested with the bf16 speedup flags in this session — both ran on Apple Silicon, where those CUDA-specific flags are no-ops. Results here used a smoke-scale interictal cap, not the real uncapped dataset.