Event cameras do not take pictures. Each pixel independently reports a timestamped "brighter" or "darker" signal the instant its brightness changes, which yields microsecond timing, no motion blur, and a sparse cloud of points in space and time instead of a frame. A natural way to process this cloud without destroying its timing is a graph neural network, a model in which each event is a node that repeatedly exchanges information with nearby events. Existing event graph networks share one quiet limitation: they are very shallow, one or two rounds of exchange. To see more of the scene, they fall back on dense, frame-like pooling branches, and those branches bring back the latency the sensor was meant to remove. The best low-latency flow estimator in the file, HUGNet2+PA, needs a periodic grid-and-recurrent branch to cut its error by up to 59% relative to its own standalone event graph.
We propose that event graphs stay shallow because of over-smoothing, the tendency of repeated neighbor averaging to make node features indistinguishable. We further propose that the event stream itself contains the label-free signal needed to stop it. Two events that lie on the same moving contour should agree. Two events that are spatially close but kinematically inconsistent, such as different motions, a motion boundary, or noise, should push apart. We turn this local motion consistency into signed edges: attractive edges along a trajectory, repulsive edges across it. We combine this with strictly past-to-future message direction, so that a deep network can still be updated one event at a time. The claim is that a deep, fully asynchronous event graph built this way can match or beat hybrid frame-assisted models on dense per-event tasks without any periodic frame branch.
Core Claim
Over-smoothing in event graphs is not mainly a global collapse at extreme depth. Event neighborhood graphs are geometric and have large diameter, so the receptive field grows only about linearly with depth. Long before global context arrives, plain averaging erases the high-frequency contrast at motion boundaries, which is exactly the information that flow, segmentation and tracking need. A Signed Graph Approach to Understanding and Mitigating Oversmoothing supplies the mechanism we reuse. It proves that preventing collapse requires negative edges, shows that normalization and residual tricks act as uncontrolled implicit negative edges, and keeps about 80% accuracy on Cora at 300 layers where plain GCN falls below 30%. It also constrains us twice. First, its best variant builds repulsive edges from class labels, which event data mostly lacks; its feature-based variant is weaker. Second, it proves a critical negative-edge weight above which propagation explodes. Our contribution is to replace label-derived or feature-derived signs with a physical, label-free sign, and to place it in a causal streaming graph. Neither SBP nor any event graph method in the file does this.
Research Program
The graph is built online. When an event $e_i=(x_i,y_i,t_i,p_i)$ arrives, we gather its $k$ nearest predecessors in a spatio-temporal ball. Edges point only from earlier to later events, so once a node's features are computed they never change. A new event therefore costs $O(Lk)$ feature computations for an $L$-layer network. This differs from the incremental rule in LSNet/ALSNet, which must refresh the cached activations of every node the new event influences.
For each neighbor $j$, we fit a local plane to the timestamps of $i$'s neighborhood. This is the standard time-surface fit, whose slope gives the local normal flow. We then measure the residual $r_{ij}$ of $j$'s timestamp against that plane, in units of the fit's noise scale. The edge weight is
$$w_{ij} = \exp(-r_{ij}^2/\tau^2) - \beta\,\mathbb{1}[r_{ij} > \rho],$$
where $\tau$ sets the attraction width, $\rho$ is the residual beyond which a neighbor counts as kinematically inconsistent, and $\beta$ is the repulsion strength. We clip $\beta$ below a critical value estimated per dataset by sweeping it on a held-out split, following the SBP stability result.
Each layer combines signed aggregation with a residual path. We vary depth from 2 to 32 layers. A drift variant asks whether the directional transport in the Bakry-Émery advection-diffusion Laplacian adds anything beyond causal edge direction. That paper modulates mixing speed on static graphs through a learned node potential. In our variant, the node potential is predicted from the local plane fit, and we test whether this adds anything over sign alone.
Following Are we measuring oversmoothing in graph neural networks correctly?, which shows that Dirichlet energy and cosine similarity confuse useful consensus with collapse, we also introduce a motion-aware diagnostic. It is the ratio of mean feature distance across ground-truth motion boundaries to mean distance within a single motion segment, tracked per layer.
Baselines
The naive reference is a frame representation fed to a standard network. We use the learned voxel grid of EST with a 2D encoder, run at the same event budget. It sets the accuracy a latency-insensitive method reaches.
The strongest competitor on our question is HUGNet2+PA. It is the only method in the file that targets per-event low-latency flow with an event graph, and it gets its context from the frame branch we aim to remove. We will retrain it with the authors' configuration on identical splits and give it an equal tuning budget. We report EPE, latency, and operations per second. The file reports a relative EPE reduction of up to 59% over its standalone GNN on Rock Scenes and about 50 µs latency. No absolute EPE was found on Lacuna for Rock Scenes or MVSEC, so we will establish absolute numbers ourselves. Beating it means equal or lower EPE on Rock Scenes and MVSEC at no worse per-event latency, using only the event graph.
For classification sanity checks, LSNet reports 74.86% on CIFAR10-DVS and 96.10% on N-Cars. MEM reports 98.55% on N-Cars with pretraining. For label-free eye tracking, EyeGraph reports 91.45% p10 on 3ET+.
Three ablations isolate the key ingredient. The first is the same deep causal network with all-positive weights and residuals plus normalization. The second is the same network with a learned high-pass channel in the style of FB-GNN. The third uses SBP's feature-similarity signs in place of motion-residual signs. A polarity-sign variant is included because polarity is the obvious free signed signal. We expect it to fail, since leading and trailing edges of a single contour fire opposite polarities. All variants share architecture width, depth, data, and a fixed hyperparameter search budget.
Why not just…?
Why not just keep the graph shallow and add a pooled context branch, as HUGNet2+PA does? This works, and it is our main competitor. Its cost is that context is two cycles stale and computed on dense pooled grids, so it reintroduces frame-rate behavior. The decisive comparison is Rock Scenes, where objects reverse direction at up to 500 Hz. If our fully asynchronous deep graph does not match HUGNet2+PA's EPE there, the proposal fails on its central claim, and we will report that.
Why not just add residual connections and normalization to a deep event GNN? Residual connections provably mitigate oversmoothing in graph neural networks shows that residuals preserve feature rank. This is a real threat because rank preservation may be enough. However, rank preservation does not require boundary contrast to survive. The all-positive residual ablation, scored with the boundary-ratio diagnostic and EPE at boundary pixels, settles the question. If the ablation matches us, the sign prior is unnecessary.
Why not just learn the high-pass component, or derive signs from features? FB-GNN and Feature-SBP need no physics. They are run as ablations under identical budgets. Our hypothesis is that learned or feature-based signs are unreliable early in training and in sparse, noisy regions, where the motion residual is already informative. If they match motion signs, the contribution narrows to the causal deep-graph design.
Why not just treat events as a token sequence with linear attention? EVA does this, reaching 0.477 mAP on Gen1 and 96.9% on DVS128 Gesture at 541k to 611k events per second. Its authors note a higher per-event cost than local filters, and patch tokenization blurs sub-patch boundaries. We will compare throughput and boundary EPE where EVA's code supports flow. We acknowledge it may win on detection.
Proposed Experiments
The first check comes before any method claim and is a diagnosis. We train plain causal event GNNs at depths 2 through 32 on Rock Scenes and MVSEC. We test whether EPE stops improving or degrades with depth, and whether the boundary-ratio diagnostic collapses before depth-related degradation appears. If deep plain graphs do not degrade, over-smoothing is not the bottleneck, and the proposal should be redirected toward receptive-field efficiency.
The second check is the depth-scaling curve for signed versus all-positive, high-pass, feature-signed, and polarity-signed variants. It includes a sweep of $\beta$ to locate the explosion threshold that SBP predicts. The third is the head-to-head against HUGNet2+PA on flow, measuring EPE, per-event latency and operations. The fourth asks whether the same signed graph transfers to label-free settings: 3ET+ eye tracking against EyeGraph's 91.45%, and CIFAR10-DVS against LSNet's 74.86%. On the latter, accuracy has headroom, unlike DVS128 Gesture, where LSNet's 99.62% leaves none. The result that would most convince us is a monotone improvement in boundary EPE with depth for the motion-signed graph only, together with parity with HUGNet2+PA without its frame branch.
References
- Graph Neural Network Combining Event Stream and Periodic Aggregation for Low-Latency Event-based Vision
- A Signed Graph Approach to Understanding and Mitigating Oversmoothing
- Asynchronous Event Processing with Local-Shift Graph Convolutional Network
- Advection-Diffusion on Graphs: A Bakry-Emery Laplacian for Spectral Graph Neural Networks
- Are we measuring oversmoothing in graph neural networks correctly?
- End-to-End Learning of Representations for Asynchronous Event-Based Data
- EyeGraph: Modularity-aware Spatio Temporal Graph Clustering for Continuous Event-based Eye Tracking
- Complete the Missing Half: Augmenting Aggregation Filtering with Diversification for Graph Convolutional Networks
- Residual connections provably mitigate oversmoothing in graph neural networks
- Maximizing Asynchronicity in Event-based Neural Networks