Imaging-based spatial transcriptomics records the position of every individual RNA molecule in a tissue slice, and each molecule carries a gene label. The best current way to turn these molecule clouds into cells treats every molecule as a node in a spatial graph and runs a graph neural network over it. A graph neural network is a model in which each node repeatedly updates itself from messages sent by its neighbors. Bering does exactly this. The graphs are huge, with millions of molecules per slice, and dense floating-point graph networks over them assume GPU infrastructure that many wet labs lack. The file is explicit that compute and memory budgets are among the barriers keeping such tools away from bench scientists (InstantDL; environment fragility; Secure Encapsulation and Publication of Biological Services in the Cloud Computing Environment).
This proposal starts from one observation. A molecule-level transcript graph already has the shape of a spiking system. Spiking neural networks are models whose units communicate with discrete all-or-nothing pulses, so that computation happens only when a pulse arrives. Each detected molecule is a discrete event with a single gene identity. Its "feature vector" is one index, not a dense 20,000-gene profile. Passing that index to a neighbor requires no multiplication at all: the receiver adds one row of a weight table to its internal state. We propose an asynchronous, event-driven spiking graph network in which molecules emit gene-index events, receivers accumulate them in a leaky internal state, and a node forwards a new event only when its state has changed enough to matter. The target is to match Bering's segmentation quality on a laptop-class CPU, with far fewer operations. Because work is local, the model should also update incrementally as new tissue regions are added, instead of recomputing the whole slice.
Core Claim
On molecule-level spatial transcriptomics graphs, graph message passing can be implemented as asynchronous, accumulate-only spike events with no encoding loss at the input. Two conditions follow if this is right. First, segmentation and cell-type accuracy should stay within a small margin of Bering. Second, the number of arithmetic operations, energy, and peak memory should drop by at least an order of magnitude on commodity hardware. Asynchrony, meaning no global round-by-round lockstep, should contribute beyond spiking alone, because activity in a tissue graph is spatially concentrated near cell boundaries.
The claim is new at a specific point in the literature. Existing spiking graph networks, SpikingGCN, DRSGNN, GSG and COS-GNN, all run synchronous global rounds. All four are evaluated only on citation, co-authorship, web or image graphs. They must also invent a spike code for continuous inputs; SpikingGCN, for example, uses random Bernoulli sampling. The asynchronous graph network GwAC processes messages one at a time as they arrive. It uses dense continuous vectors, however, and reports overfitting on wide-feature graphs such as Cora. No work in the file combines these ideas on biological data, where inputs are natively discrete.
Why this domain fits, and what prior work constrains
Three prior results shape the design, each in a different role.
Bering supplies the task, the data and the target. It builds a spatial graph over transcripts and computes Neighborhood Gene Components, which are counts of gene identities in each molecule's neighborhood. It then classifies nodes by cell type and edges as within-cell or between-cell, and clusters the result into cells. A neighborhood count is a sum of one-hot vectors, which is already an accumulate-only computation. Bering computes these counts and then hands them to a dense graph network. We keep them in event form throughout the model.
GwAC constrains the design. Its overfitting on high-dimensional features is a known failure mode of one-message-at-a-time models. Our input messages are single gene indices, so the effective input width per message is one embedding row, not thousands of dense features. Whether this avoids the failure is a question our experiments test directly. GwAC's other limitation is a "GPU gap": asynchronous queues run badly on GPUs. That cost does not apply here, because our deployment target is a CPU event runtime and not a GPU.
Two lines of work supply the propagation mechanism. Maiter showed that sending only changes in state, instead of polling full states every round, restricts communication to vertices that are actually changing. PushNet brought local push propagation into neural message passing. Our firing rule is a learned version of Maiter's delta threshold.
The energy motivation comes from hardware reports, which we treat as upper-bound evidence and not as expected outcomes. SpikingGCN reports roughly 100× less energy on the ROLLS neuromorphic chip than a GCN on a TITAN RTX GPU. GSG reports 0.051 mJ against 18.444 mJ for a standard GCN on Co-author CS. The file itself notes a gap between theoretical operation counts and real silicon, so we measure energy on hardware we actually have.
Research Program
Each node $i$ holds a membrane vector $v_i$, a running internal state. It also keeps a copy $\hat v_i$ of the state it last broadcast. When an event from neighbor $j$ with gene or hidden-unit index $k$ arrives, the node updates
$$v_i \leftarrow \lambda\, v_i + W_{k} ,$$
where $\lambda \in (0,1)$ is a leak factor and $W_k$ is row $k$ of a learned weight table. Node $i$ then emits new events only when
$$\lVert v_i - \hat v_i \rVert_1 > \theta_i ,$$
where $\theta_i$ is a threshold. It emits one event for each hidden unit whose change crosses a per-unit level, and then resets $\hat v_i$.
The threshold $\theta_i$ is learned per node group, following DRSGNN's neuron-level thresholds. It trades accuracy against event count, and we add an explicit penalty on the total number of events. Edge classification uses the accumulated states of the two endpoints, as in Bering, and cells are then formed by Leiden clustering, again as in Bering.
Training uses surrogate gradients on a synchronous simulation of the same model with a fixed number of steps. We then check that asynchronous execution, with randomized arrival order, reproduces the trained model's predictions. GwAC's analysis suggests arrival order can carry information. We therefore report accuracy under several random orderings to show robustness, and we do not claim an expressiveness gain.
We will build a single-threaded and multi-threaded CPU event runtime and release it as a pip-installable tool with no CUDA dependency. The same model will also be exposed as a callable tool, so agents such as CellAgent can invoke it. The agent handles the language interface; we supply a backend that fits on the machine at hand.
A secondary program transfers the idea to spot-level data such as 10x Visium. Here each spot holds gene counts, and a count of $c$ can be emitted exactly as $c$ events. This tests whether the approach holds beyond molecule graphs.
Baselines
The naive reference points are the classical segmenters Watershed, Cellpose and Baysor. These are the comparators against which Bering reports an average AMI improvement of 0.1 to 0.5 (AMI, adjusted mutual information, measures agreement between predicted and reference labels, corrected for chance). We run them with default settings on the same slices. Beating them is necessary but not interesting.
The strongest competitor is Bering itself, because it is the only method in the file that performs molecule-level joint segmentation and annotation with transfer across platforms. For per-platform 2D AMI, no reported per-dataset result was found on Lacuna. The only absolute figure in the file is an AMI of 0.795 for 3D segmentation of 100-µm tissue, and we will also report its 20% to 70% gain in transcripts captured per cell. Fairness means rerunning Bering's released models and training recipe on identical tiles, with equal hyperparameter-search budgets for both methods, and measuring it on both a GPU and the same CPU our model uses. Beating Bering means one of two outcomes. The strong form is AMI within 0.02 of Bering together with at least a 10× reduction in CPU energy and in peak memory. The weak form is a clear accuracy loss that is still smaller than Bering's margin over Cellpose, reported as such.
A second strong competitor is Bering quantized to INT8 on CPU, since quantization is the standard cheap answer to "make it run on a laptop."
Three ablations isolate the key ingredients. A synchronous spiking variant, identical except that all nodes update in global rounds in the style of SpikingGCN and DRSGNN, isolates asynchrony. A variant with $\theta_i = 0$, where every event is forwarded, isolates delta-thresholding. A dense-input variant that feeds full neighborhood count vectors instead of gene-index events isolates the native-discrete input and tests GwAC's overfitting concern.
Why not just…?
Why not just quantize Bering and run it on a CPU? This is a live threat, and it is the main competitor our energy claim must beat. Quantized graph networks still multiply for every edge on every layer. AMPLE also documents that skewed-degree graphs leave batched hardware idle; its event-driven design was 7.2× faster than an RTX A6000 on average. Molecule graphs have strongly uneven local density, so the same skew should appear. The INT8 comparison on identical hardware settles this directly. If INT8 Bering matches our energy within 2×, the spiking design is not worth its complexity and we will say so.
Why not just precompute Neighborhood Gene Components and classify each molecule with a small MLP? This alternative follows the precompute-then-classify approach that PushNet's precomputed variant exploits, and it may be the most dangerous. Bering's features already summarize the neighborhood, so learned message passing may add little. We run this model as a baseline. If it matches Bering's AMI, then the energy question reduces to computing counts cheaply, and our contribution narrows to incremental, event-driven count maintenance. The streaming experiment below would then be the result that matters.
Why not just use an existing synchronous spiking graph network? SpikingGCN and DRSGNN would give accumulate-only arithmetic without an asynchronous runtime. They still update every node at every step, however, including cell interiors that have stopped changing. They also inherit an input-encoding step that molecule data does not need. The synchronous ablation measures exactly this gap in events and energy at equal accuracy.
Why not just wrap existing tools in an LLM agent? CellAgent orchestrates Scanpy-style pipelines but does not change the compute beneath them. An agent cannot make a GPU-bound model fit on a workstation. The two approaches are complementary, and we expose our model as an agent tool rather than competing with agents.
Proposed Experiments
The main benchmark is Bering's suite: CosMx, MERFISH, Xenium and seqFISH slices from cortex, ileum and breast cancer. We report AMI, transcripts per cell, cell-type accuracy, and the operation count in accumulates versus multiply-accumulates. We also report measured CPU energy from hardware counters, wall-clock time and peak memory on a single laptop, plus event-count distributions across the slice.
The first decisive check is the Pareto curve of AMI against energy, traced by sweeping the event penalty, for our model, INT8 Bering, NGC+MLP and the synchronous spiking ablation. The claim holds only if our curve dominates at the accuracy levels of practical interest.
The second decisive check is streaming. Tiles are added to a slice one at a time, and we measure the work per added tile against a full recompute, together with the prediction difference from a batch run. Delta propagation predicts that work scales with the number of boundary molecules, not with slice size.
The third check applies the dense-input ablation to 3D data. Its purpose is to confirm that native gene-index events are what prevent the GwAC-style overfitting.
The secondary benchmark is DLPFC domain identification, scored by ARI (adjusted Rand index, a chance-corrected measure of clustering agreement). We compare against PREST, which reports ARI 0.75 on slice 151507, and stMFG, which reports ARI 0.89 on 151671. Here we expect a larger accuracy gap, because both methods use heavier fusion. The experiment reports how far the event representation carries beyond molecule graphs, not a claim to beat either method.
References
- Bering: joint cell segmentation and annotation for spatial transcriptomics with transferred graph embeddings
- InstantDL: an easy-to-use deep learning pipeline for image segmentation and classification
- Secure Encapsulation and Publication of Biological Services in the Cloud Computing Environment
- Spiking Graph Convolutional Networks
- Dynamic Reactive Spiking Graph Neural Network
- Geometry-Aware Spiking Graph Neural Network
- Continuous Spiking Graph Neural Networks
- GwAC: GNNs with Asynchronous Communication
- Maiter: An Asynchronous Graph Processing Framework for Delta-Based Accumulative Iterative Computation
- PushNet: Efficient and Adaptive Neural Message Passing
- CellAgent: LLM-Driven Multi-Agent Framework for Natural Language-Based Single-Cell Analysis
- AMPLE: Event-Driven Accelerator for Mixed-Precision Inference of Graph Neural Networks
- Evidence-aware Integration and Domain Identification of Spatial Transcriptomics Data
- A Multi-scale Fused Graph Neural Network with Inter-view Contrastive Learning for Spatial Transcriptomics Data Clustering