Event Based Features: Asynchronous Representations

• Event Based Features are defined as representations computed directly from asynchronous event streams or temporal sequences, preserving native event structure and causality.
• They include a diverse range of methods such as suffix tree subsequences, synaptic-kernel responses, adaptive thresholds on time surfaces, and tensor-based descriptors.
• EBFs improve robustness and efficiency in tasks like prediction, tracking, and segmentation by leveraging precise timing and spatial event information.

Searching arXiv for the cited works to ground the article in current paper records. arXiv Search Results for: (Andrew et al., 2023) Event based Prediction Suffix Tree

1. (Andrew et al., 2023) - An Event based Prediction Suffix Tree Authors: Fred Leibrock, Simon Stringer, Tony Lewis Published: 2023-10-20 URL: http://arxiv.org/abs/([2310.14944](/papers/2310.14944))v1

arXiv Search Results for: (Afshar et al., 2019) event-based feature extraction adaptive selection thresholds

2. (Afshar et al., 2019) - Event-based Feature Extraction Using Adaptive Selection Thresholds Authors: Paul Kirkland, Mehrtash Harandi, Greg Cohen, Niko Piatkowski, Cedric Scheerlinck Published: 2019-07-18 URL: http://arxiv.org/abs/([1907.07853](/papers/1907.07853))v1

arXiv Search Results for: (Hamann et al., 2024) ETAP Event-based Tracking of Any Point

3. (Hamann et al., 2024) - ETAP: Event-based Tracking of Any Point Authors: Timo Stoffregen, Yosif Welde, Guillermo Gallego Published: 2024-11-28 URL: http://arxiv.org/abs/([2412.00133](/papers/2412.00133))v1

arXiv Search Results for: (Guan et al., 2022) PL-EVIO Robust Monocular Event-based Visual Inertial Odometry with Point and Line Features

4. (Guan et al., 2022) - PL-EVIO: Robust Monocular Event-based Visual Inertial Odometry with Point and Line Features Authors: Senyang Cao, Xingyu Zhu, Xiaohao Xu, Jianping Xi, Yuxin Zou, Lihua Xie, Jiaqi Yang անուն, Jiahao Zeng, Xin Wu Published: 2022-09-25 URL: http://arxiv.org/abs/([2209.12160](/papers/2209.12160))v1

arXiv Search Results for: (Sakhno et al., 16 Mar 2026) Embedding-Aware Feature Discovery

5. (Sakhno et al., 16 Mar 2026) - Embedding-Aware Feature Discovery: Bridging Latent Representations and Interpretable Features in Event Sequences Authors: Nikita Paliutin, Oleg Rogov, Vladimir Ponomarev, Dmitrii Bychkov, Artem Belyaev, Timofey Arkhangelskii Published: 2026-03-16 URL: http://arxiv.org/abs/([2603.15713](/papers/2603.15713))v1

arXiv Search Results for: (Li et al., 4 Jul 2025) Efficient Event-Based Semantic Segmentation via Exploiting Frame-Event Fusion

6. (Li et al., 4 Jul 2025) - Efficient Event-Based Semantic Segmentation via Exploiting Frame-Event Fusion: A Hybrid Neural Network Approach Authors: Wei Luo, Tiange Qiu, Yuchen Lu, Liwei Wang, Hao Tang, Yansong Tang Published: 2025-07-04 URL: http://arxiv.org/abs/([2507.03765](/papers/2507.03765))v1

Event-Based Features (EBFs) are feature representations computed directly from asynchronous event streams or temporal event sequences. In event-camera and spike-processing settings, they encode where and when brightness changes or spikes occur, often with polarity or channel identity; in sequence analytics and process mining, they are deterministic statistics or structural measurements extracted from time-stamped events. The literature therefore uses the same term for several non-equivalent constructions: delay-annotated subsequences in the Event based Prediction Suffix Tree (EPST), synaptic-kernel responses in modified Extreme Learning Machines, adaptive-threshold prototypes on time surfaces, slow-feature projections of spatiotemporal voxel grids, learned descriptors on event stacks, object-centric execution features, and interpretable statistics over transactional sequences (Andrew et al., 2023, Tapson et al., 2014, Afshar et al., 2019, Ghosh et al., 2019, Hamann et al., 2024, Adams et al., 2022, Sakhno et al., 16 Mar 2026).

1. Formal scope and event models

A common starting point is the event tuple. In event-camera vision, an event is typically written as $e_i = (x_i, y_i, t_i, p_i)$, where $(x_i,y_i)$ are pixel coordinates, $t_i$ is the timestamp, and $p_i \in \{-1,+1\}$ is the polarity. The associated event stream is an ordered set or sequence of such tuples. Closely related spike-processing formulations use point processes such as $s_c(t) = \sum_k \delta(t-t_{c,k})$ for channel $c$, while EPST models an event stream as $f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$ with $t_j \in \mathbb{R}$ and $c_j \in \{0,\dots,C\}$ (Li et al., 4 Jul 2025, Liu et al., 2024, Ren et al., 2024, Hamann et al., 2024, Tapson et al., 2014, Andrew et al., 2023).

In industrial and process-oriented settings, the same abstraction broadens from sensor events to attribute-rich temporal records. EAFD models a dataset of event sequences as $\mathcal{S}=\{s_i\}_{i=1}^N$, where each sequence contains temporal events with attributes such as timestamps, merchant category codes, amounts, currencies, and transaction types. Object-centric process mining defines an event log $(x_i,y_i)$0, where events may reference multiple objects and directly-follows relations are defined per object trace rather than by flattening into a single sequence (Sakhno et al., 16 Mar 2026, Adams et al., 2022).

This diversity of formalisms indicates that EBFs are not a single canonical representation. A plausible implication is that the term denotes a design principle: preserve event-native structure rather than first converting the stream into conventional frame-like or uniformly sampled signals.

2. Symbolic, statistical, and prototype-based EBFs

One major lineage treats EBFs as explicit templates, subsequences, or statistics. EPST defines its Event-Based Features as “a portion of the power set of event subsequences within a short context window.” At event time $(x_i,y_i)$1, it constructs a history window $(x_i,y_i)$2 and matches learned subsequences $(x_i,y_i)$3 using either time-bin matching or interval matching. Learned subsequences are stored in a suffix-tree-like structure with delay-annotated edges, each node maintaining numerator and denominator counts for local frequentist estimation of $(x_i,y_i)$4. Prediction selects the matched subsequence with minimum entropy, and optional inhibitory subsequences resolve XOR-like cases (Andrew et al., 2023).

A second lineage uses continuous synaptic responses as features. In the modified ELM architecture sometimes referred to as SKIM, EBFs are continuous-valued feature signals produced by convolving Dirac impulse trains with causal synaptic kernels and optionally applying a compressive nonlinearity:

$(x_i,y_i)$5

The resulting feature vector $(x_i,y_i)$6 provides fading memory and spatiotemporal selectivity without recurrent connectivity. Exponential, alpha, difference-of-exponentials, damped oscillatory, delayed, and Gaussian-with-delay kernels are all explicitly described (Tapson et al., 2014).

FEAST, by contrast, learns prototype filters on event-derived time surfaces. Given the last-event map $(x_i,y_i)$7 and polarity map $(x_i,y_i)$8, it defines a fixed-window surface $(x_i,y_i)$9 and an exponentially decaying surface $t_i$0, extracts a local $t_i$1 region of interest, vectorizes it as $t_i$2, normalizes $t_i$3, and compares it to feature weights $t_i$4 using cosine distance $t_i$5. Each feature has an adaptive threshold $t_i$6; if some $t_i$7, the winner is updated, otherwise the event is missed and all thresholds expand. This yields unsupervised competitive clustering, a small steady-state miss rate of about $t_i$8, and convergence proxies derived from thresholds and activation statistics rather than direct weight inspection (Afshar et al., 2019).

In non-sensory sequence domains, EBFs are deterministic and interpretable mappings. EAFD defines candidate features as $t_i$9 and evaluates them by alignment,

$p_i \in \{-1,+1\}$0

and complementarity,

$p_i \in \{-1,+1\}$1

The discovered features include counts in windows, recency, span, inter-arrival statistics, amount statistics, $p_i \in \{-1,+1\}$2-scores, EWMA, HHI, autocorrelation, rolling aggregates, RFM-like features, and conditional sequence-pattern features (Sakhno et al., 16 Mar 2026).

Object-centric process mining similarly defines native event-based features as partial functions $p_i \in \{-1,+1\}$3 over executions. Representative examples are the synchronization time

$p_i \in \{-1,+1\}$4

the pooling time

$p_i \in \{-1,+1\}$5

object counts, directly-follows degrees, transition probabilities, and graph centrality measures. These are defined natively on multi-object logs to avoid the loss induced by flattening (Adams et al., 2022).

3. Voxel, cloud, stack, and geometric-neural EBFs

A second major family represents events as dense or semi-dense tensors and learns feature hierarchies over them. In hybrid frame-event semantic segmentation, EBFs include voxel grids $p_i \in \{-1,+1\}$6 formed by temporal binning with linear interpolation, spiking feature tensors $p_i \in \{-1,+1\}$7, temporal weighting vectors $p_i \in \{-1,+1\}$8, event-guided sparse reference points $p_i \in \{-1,+1\}$9, and directional offsets $s_c(t) = \sum_k \delta(t-t_{c,k})$0. These are fused with frame features through the Adaptive Temporal Weighting Injector, the Event-Driven Sparse Injector, and the Channel Selection Fusion module, then decoded by Mask2Former (Li et al., 4 Jul 2025).

Event-based video frame interpolation uses a related voxel-grid representation, but emphasizes edges and motion boundaries. EGMR converts events into $s_c(t) = \sum_k \delta(t-t_{c,k})$1 with $s_c(t) = \sum_k \delta(t-t_{c,k})$2, splits the interval into $s_c(t) = \sum_k \delta(t-t_{c,k})$3 and $s_c(t) = \sum_k \delta(t-t_{c,k})$4, and derives event optical flow $s_c(t) = \sum_k \delta(t-t_{c,k})$5 and event visibility maps $s_c(t) = \sum_k \delta(t-t_{c,k})$6. The Edge Guided Attentive module combines Cross-modal Local Attention and Cross-OF Attention so that event-derived edge structure rectifies frame flow locally, while learned event visibility guides warping near occlusions (Liu et al., 2024).

FECNet moves away from voxelization and preserves events as an ordered Event Cloud,

$s_c(t) = \sum_k \delta(t-t_{c,k})$7

described as “2S-1T-1P.” Local neighborhoods are built with Differentiation Farthest Point Sampling, Event Feature-based KNN, and Coordinates Evolution Strategy. Feature extraction then shifts to the frequency domain: Spatial-FA applies FFT-based filtering along the channel axis, and Temporal-FA applies FFT-based filtering along time, reducing convolutional complexity from $s_c(t) = \sum_k \delta(t-t_{c,k})$8 to $s_c(t) = \sum_k \delta(t-t_{c,k})$9 (Ren et al., 2024).

Tracking-oriented EBFs take yet another form. ETAP converts asynchronous windows into mixed-density event stacks $c$0 with $c$1, processes a temporal sequence $c$2 with $c$3, extracts multi-scale descriptors

$c$4

and augments them with patch-wise correlation features. Because event appearance varies with motion, ETAP introduces a feature-alignment loss that maximizes cosine similarity between descriptors from original and time-inverted, rotated event sequences (Hamann et al., 2024).

PL-EVIO uses event corners and line-based event features rather than generic tensor embeddings. It defines a polarity-aware time surface

$c$5

tracks Arc* corners by two-way Lucas–Kanade flow on $c$6, and detects line segments by running LSD on IMU-motion-compensated event images. Matched lines are represented in Plücker coordinates and then in an orthonormal four-parameter form for sliding-window optimization (Guan et al., 2022).

Slow-feature learning supplies a further variant. Around each event $c$7, the method builds a cuboid neighborhood $c$8, histograms events into a spike-count matrix $c$9, smooths with a separable 3D Gaussian, compresses by PCA, and learns linear projections ordered by a slowness criterion over matched pairs. The final EBFs are spatiotemporal receptive fields $f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$0 acting directly on voxelized counts (Ghosh et al., 2019).

4. Learning rules, inference mechanisms, and explainability

Across these constructions, the update rules vary from pure counting to deep optimization. EPST is strictly online: denominator counts are incremented when any event arrives, numerator counts are incremented only when the preferred channel $f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$1 spikes, and branch extension occurs when a numerator exceeds $f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$2. No smoothing or back-off is used beyond the minimum frequency threshold $f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$3; prediction relies on local node statistics and entropy-based selection of the representative subsequence (Andrew et al., 2023).

FEAST is also online but uses competitive homeostasis rather than counts. The winning prototype is updated by

$f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$4

its threshold contracts by $f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$5, and all thresholds expand by $f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$6 on a miss. This makes homeostasis observable through threshold stability, per-feature firing-rate variance, and missed-spike rate. The paper further uses the Gini coefficient of feature counts as a predictor of downstream classification accuracy (Afshar et al., 2019).

Kernel-based ELM solutions decouple feature synthesis from output optimization. Synaptic-kernel parameters are chosen a priori, often randomly, and the linear output layer is solved by ridge regression, the pseudoinverse, RLS, OPIUM, or OS-ELM. Because the hidden representation already contains fading memory, the output layer can remain linear while still producing event decisions by thresholding $f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$7 (Tapson et al., 2014).

Several recent systems treat EBFs as trainable latent variables in end-to-end models. The segmentation framework uses Leaky Integrate-and-Fire neurons with $f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$8, $f := [(t_0,c_0), (t_1,c_1), \dots, (t_j,c_j)]$9, $t_j \in \mathbb{R}$0, and sigmoid surrogate gradients, then fuses event and frame features by cross-attention and sparse deformable attention. ETAP refines point tracks autoregressively with a transformer over tokens containing geometry, visibility, descriptors, correlation features, and positional encodings. PL-EVIO instead embeds event features inside a nonlinear least-squares objective over IMU states, inverse depths, line parameters, and extrinsics, combining event, line, image, IMU, marginalization, and re-localization residuals (Li et al., 4 Jul 2025, Hamann et al., 2024, Guan et al., 2022).

In sequential analytics, EAFD makes feature generation itself part of the learning loop. A frozen encoder $t_j \in \mathbb{R}$1 produces embeddings $t_j \in \mathbb{R}$2, a LLM proposes executable feature code, failed code enters self-correction, and successfully executed features are ranked by alignment and utility before reflective feedback seeds the next iteration. This makes explainability an explicit objective rather than a by-product (Sakhno et al., 16 Mar 2026).

A recurring theme is explicit interpretability. EPST can report the matched subsequence that drove prediction; SKIM exposes receptive fields through kernel choices; FEAST uses directly inspectable prototype weights and threshold dynamics; object-centric process mining retains directly-follows and synchronization structure; EAFD selects interpretable statistics; and PL-EVIO uses geometric primitives whose residuals are analytically defined (Andrew et al., 2023, Tapson et al., 2014, Afshar et al., 2019, Adams et al., 2022, Sakhno et al., 16 Mar 2026, Guan et al., 2022).

5. Robustness, complexity, and hardware constraints

A central argument for EBFs is that event-native structure can improve robustness. EPST explicitly attributes fault tolerance and dropout robustness to storing a portion of the power set of subsequences, so that shorter or alternative routes to the preferred channel remain available when events are missing. Interval matching gives jitter tolerance; additive noise has limited effect because random events do not alter delay relations among signal events; and $t_j \in \mathbb{R}$3, $t_j \in \mathbb{R}$4 yields one-shot learning, albeit with rapid tree growth that must be controlled by pruning (Andrew et al., 2023).

FEAST reaches similar conclusions from a different mechanism. By discarding events outside all adaptive thresholds, it trades a small amount of information loss for simpler homeostasis. The learned activation patterns provide useful convergence signals, and the appearance of “noise features” becomes a heuristic for network-size selection. This suggests that selective event rejection is not necessarily a defect; in these models it can be part of the intended operating regime (Afshar et al., 2019).

The cost of EBFs depends strongly on representation. EPST has worst-case combinatorics

$t_j \in \mathbb{R}$5

and worst-case matching cost

$t_j \in \mathbb{R}$6

so it relies on $t_j \in \mathbb{R}$7, $t_j \in \mathbb{R}$8, $t_j \in \mathbb{R}$9, $c_j \in \{0,\dots,C\}$0, pruning, early stopping, and pre-prediction sampling. FECNet addresses an analogous scaling problem by moving feature extraction to the frequency domain; at $c_j \in \{0,\dots,C\}$1 channels, the per-position reduction from $c_j \in \{0,\dots,C\}$2 to $c_j \in \{0,\dots,C\}$3 is reported as approximately $c_j \in \{0,\dots,C\}$4, and the overall network-level MAC reduction as up to approximately $c_j \in \{0,\dots,C\}$5 (Andrew et al., 2023, Ren et al., 2024).

Efficiency claims in event-frame fusion are likewise tied to feature design. The hybrid segmentation model reports number of parameters, ANN GFLOPs, SNN GFLOPs, and total energy $c_j \in \{0,\dots,C\}$6; on DSEC-Semantic it reports $c_j \in \{0,\dots,C\}$7 versus HALSIE $c_j \in \{0,\dots,C\}$8, described as about $c_j \in \{0,\dots,C\}$9 reduction, while also increasing mIoU from $\mathcal{S}=\{s_i\}_{i=1}^N$0 to $\mathcal{S}=\{s_i\}_{i=1}^N$1. On DDD17-Seg it reports $\mathcal{S}=\{s_i\}_{i=1}^N$2 and $\mathcal{S}=\{s_i\}_{i=1}^N$3 mIoU (Li et al., 4 Jul 2025).

The acronym requires care in hardware literature. In the intracortical BMI paper, EBF denotes Event-Based Frontends rather than Event-Based Features. There, delta modulation produces asynchronous up/down events according to

$\mathcal{S}=\{s_i\}_{i=1}^N$4

with reconstruction

$\mathcal{S}=\{s_i\}_{i=1}^N$5

Those frontends are paired with an event-domain spike detector, Ev-SPD, whose fabricated 1024-channel macro reports $\mathcal{S}=\{s_i\}_{i=1}^N$6 spike detection accuracy on a synthetic dataset, $\mathcal{S}=\{s_i\}_{i=1}^N$7 similarity and $\mathcal{S}=\{s_i\}_{i=1}^N$8 firing pattern MAE on Neuropixel recordings, $\mathcal{S}=\{s_i\}_{i=1}^N$9 per channel, and $(x_i,y_i)$00 per channel (Ke et al., 9 Dec 2025).

6. Applications, empirical record, and contested boundaries of the term

EBFs appear in prediction, recognition, tracking, interpolation, odometry, spike detection, and sequence analytics. EPST is evaluated on synthetic structured interference, additive noise, jitter, and jitter-plus-dropout tasks; FEAST on N-MNIST and airplane dropping; slow-feature descriptors on traffic, rotation, MNIST motion variants, and intermittent motion; ETAP on TAP benchmarks and classical feature tracking; PL-EVIO on DAVIS, DVXplorer, UZH-FPV, VICON, and outdoor experiments; FECNet on object classification, action recognition, and human pose estimation; EAFD on Age Prediction, Gender Prediction, Rosbank, DataFusion, and a proprietary multi-target dataset (Andrew et al., 2023, Afshar et al., 2019, Ghosh et al., 2019, Hamann et al., 2024, Guan et al., 2022, Ren et al., 2024, Sakhno et al., 16 Mar 2026).

Quantitative outcomes differ sharply by task, but several representative results illustrate the breadth of the concept. EGMR reports $(x_i,y_i)$01 on Vimeo90k-Triplet and $(x_i,y_i)$02 on SNU-FILM Extreme, exceeding the cited TimeLens baselines. FECNet reports $(x_i,y_i)$03 on DVS128 Gesture, $(x_i,y_i)$04 on Daily DVS, $(x_i,y_i)$05 on UCF101-DVS, and MPJPE3D $(x_i,y_i)$06 on DHP19. ETAP reports AJ $(x_i,y_i)$07 on EventKubric versus $(x_i,y_i)$08 for E2Vid+CoTracker, FA $(x_i,y_i)$09 on EDS, and FA $(x_i,y_i)$10 on EC. FEAST with ELM reaches $(x_i,y_i)$11 on N-MNIST with 8000 hidden units, and $(x_i,y_i)$12 per-drop accuracy on Plane Dropping with FEAST features plus ELM 30k. EAFD reports gains up to $(x_i,y_i)$13 on DataFusion for CoLES and $(x_i,y_i)$14 for NTP (Liu et al., 2024, Ren et al., 2024, Hamann et al., 2024, Afshar et al., 2019, Sakhno et al., 16 Mar 2026).

Several misconceptions are directly contradicted by this record. EBFs are not limited to voxel grids, because the literature also uses suffix-tree subsequences, time-surface prototypes, continuous synaptic-kernel responses, event clouds, graph-native execution features, and explicit point-line geometry. They are not always learned end-to-end, because some methods rely on local counts, random kernel banks, or hand-defined statistics. Nor are they always purely visual: transaction logs and object-centric process executions use the same term for interpretable event-sequence features (Andrew et al., 2023, Tapson et al., 2014, Adams et al., 2022, Sakhno et al., 16 Mar 2026).

The principal limitations are likewise heterogeneous. EPST faces combinatorial growth and sensitivity to large jitter without interval matching. Event-frame fusion loses leverage in static scenes or low-texture areas where few events occur. EGMR identifies textureless regions, extreme occlusions, and event noise as persistent problems. ETAP notes descriptor initialization when there is no motion. FEAST depends on suitable $(x_i,y_i)$15 and network size. SKIM’s fixed kernel bank may degrade under drift. Object-centric features depend on accurate event-object links and time semantics. FECNet depends on downsampling choices and robust early embeddings for grouping (Andrew et al., 2023, Li et al., 4 Jul 2025, Liu et al., 2024, Hamann et al., 2024, Afshar et al., 2019, Tapson et al., 2014, Adams et al., 2022, Ren et al., 2024).

Future directions named in the cited work include uncertainty-aware fusion, adaptive binning, better event denoising, encoder refinement guided by embedding-aware feature discovery, graph-attention or heterogeneous graph models for object-centric data, adaptive kernels or selective recurrence for long temporal dependencies, and stronger privacy-aware feature selection through HSIC-based decorrelation (Liu et al., 2024, Sakhno et al., 16 Mar 2026, Tapson et al., 2014, Adams et al., 2022).

Taken together, the literature portrays Event-Based Features as a broad methodological category: representations that remain faithful to the asynchronous, sparse, and temporally structured nature of event data. The exact mathematical object may be a counted subsequence, a synaptic response, a prototype on a time surface, a learned tensor descriptor, a geometric primitive, or an interpretable statistic; what unifies them is that they attempt to preserve event-native causality, timing, and structure rather than erase those properties through premature rate conversion or flattening (Andrew et al., 2023, Afshar et al., 2019, Li et al., 4 Jul 2025, Hamann et al., 2024, Adams et al., 2022, Sakhno et al., 16 Mar 2026).