acceptodds
Under review as a conference paper at ICLR 2027

Neural Events: Learning Discrete Asynchronous Representations for Event-Based Vision

Abstract

Event cameras capture dynamic scenes with exceptional temporal fidelity by representing them as a continuous stream of microsecond resolution events. Each individual event, however, only carries minimal semantic value, merely signaling a localized brightness change. To derive meaningful signals, downstream algorithms need to quickly integrate cues from a potentially massive torrent of low-information events. Current architectures, however, are easily overwhelmed, struggling to balance capturing fine-grained temporal dynamics and maintaining a manageable data throughput. This paper proposes a framework to re-tokenize event streams into a small set of highly informative neural events, each representing a local spatio-temporal context window with a discrete learnable code. Every time this code flips, a neural event is triggered, yielding a highly compressed data stream. We demonstrate that, across object detection and classification, networks trained on neural events are on par or surpass the performance of state-of-the-art approaches while reducing the event rate by a factor of 2.0.

Primary area:
unsupervised, self-supervised, semi-supervised, and supervised representation learning
Keywords:
Event-based vision, representation learning, discrete autoencoders, asynchronous processing, event tokenization, unsupervised learning, efficient deep learning.

Reviews

Among:
Shape:
1234this paper, Top 32%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.50 over 4 reviews, above 68% of the others.
Reviewer_ff4DOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Neural Events, a discrete asynchronous representation that reduces the rate of an event stream by emitting a new token only when its assigned code changes. A patch-local RWKV-7 encoder processes incoming events and maps its outputs to a learned codebook through straight-through Gumbel-Softmax quantization. The encoder is pretrained using time-surface reconstruction together with rate-alignment and latent-straightening losses that encourage stable code assignments. The authors evaluate the representation with synchronous Swin-based and asynchronous DAGr-based task networks. Experiments cover object detection on DSEC-Detection, Gen1, and N-Caltech101, classification on N-Caltech101, several controlled ablations, and hardware measurements. The results show useful detection gains and competitive classification accuracy, with a reported twofold event-rate reduction.

Critical strengths
  1. The method offers a coherent approach to reducing redundant event updates while retaining a useful learned representation. Patch-local recurrence integrates temporal history, the codebook provides a compact discrete output, and change-triggered emission suppresses repeated code assignments. The reconstruction and temporal regularization objectives are aligned with this goal. This is a meaningful design for the interface between high-rate event sensors and downstream perception networks.
  2. The evaluation contains substantive evidence for the proposed representation and emission rule. The paper tests both real driving data and N-Caltech101, uses synchronous and asynchronous downstream networks, and includes ablations and hardware measurements. The controlled Gen1 comparison is particularly useful. At the same retained-event fraction of 0.5, code-change emission achieves 49.9 mAP, compared with 38.3 for random removal of learned tokens and 43.7 for pairwise feature averaging. Retaining every quantized code reaches 51.1 mAP, so the proposed rule removes half the outputs with a relatively small accuracy loss in this setting. The main detection results also improve over the reported baselines, including DAGr on DSEC and EVA-L on Gen1. Together, these results support the usefulness of the design in the tested pipelines.
Critical weaknesses
  1. The main concern is that the connection between the compressed stream and the downstream input is not specified clearly enough to reproduce the synchronous downstream evaluation from the retained tokens. In Section 3.4, the pretraining feature map is constructed by averaging code vectors according to their frequencies in the full encoded sequence. Section 4.1 then describes the synchronous task network as starting from this feature map. However, the retained neural-event stream keeps only code changes. The manuscript does not state whether the counts of discarded events are maintained internally at the encoder, reconstructed from the retained stream, or omitted when constructing the downstream input. Change timestamps alone do not generally recover those event counts. A different aggregation for downstream evaluation could be valid, but its definition and information requirements need to be explicit. Without this clarification, it is difficult to determine whether the reported synchronous results evaluate the claimed compressed-only deployment. The authors should report the exact online aggregation rule and, if it uses statistics from the full encoded sequence, compare it with an implementation that uses only the retained neural-event stream.
  2. A second concern is that the computational and hardware results do not yet establish the complete efficiency advantage under a consistent operating protocol. The reported seventeen-fold advantage over EVA-L concerns representation construction, using 0.14 versus 2.32 MFLOPs per event. Table 2 also includes full-network costs, with 1,130 MFLOPs per event for TokSwinT-S on Gen1. However, Sections 4 account for synchronous inference by running the full backbone for every incoming event or retained token, whereas Table 6 reports execution on event packets. The paper does not explain how the prediction schedule in the packet measurements relates to the per-event accounting. A comparison at a common output frequency, event window, and hardware configuration is needed to establish practical speed and energy benefits.
Questions for authors
  1. How is the synchronous downstream feature map constructed at deployment? Does it use code frequencies from the full encoded sequence, only the retained neural events, or additional statistics? Please give the exact rule and report the downstream performance when the task network receives only the information carried by the stated neural-event stream.
  2. How do the per-event FLOP and energy figures relate to the prediction schedule used in Table 6? Please compare complete pipelines on the same hardware and at a common output frequency, including encoding, task inference, actual energy, and peak memory. In particular, what does the 281 kilobyte encoder-memory allocation include, and does it cover all persistent patch states?
  3. Can the authors report performance together with the achieved event and byte rates at several compression levels across the evaluated datasets, with repeated-run uncertainty? This would clarify whether the reported twofold reduction and its accuracy cost are stable beyond the single operating point shown in the main ablation.
5 comments

We thank reviewer ff4D for the feedback on our submission. We answer in the following to each of the weaknesses and question raised:

W1/Q1. The main concern is that the connection between the compressed stream and the downstream input is not specified clearly enough to reproduce the synchronous downstream evaluation from the retained tokens.... How is the synchronous downstream feature map constructed at deployment? Does it use code frequencies from the full encoded sequence, only the retained neural events, or additional statistics? Please give the exact rule and report the downstream performance when the task network receives only the information carried by the stated neural-event stream.

We refer the reviewer to our answer to Q2 from reviewer DAx8 and summarize the response here. We build the synchronous feature map from Neural Events, retaining only flips. For example, if one patch generates neural event sequence q1,q1,q1,q2,q2,q3q_1, q_1, q_1, q_2, q_2, q_3, it would only retain flipped events q1,q2,q3q_1, q_2, q_3 (first occurrences). During pretraining of the encoder, we retain all codes, and thus generate feature maps HH with entries at patch jj equal to hj=3q1+2q2+q36h_j=\frac{3q_1+2q_2+q_3}{6}, following the example. This process is repeated for each patch. During training of the downstream task-network and during deployment, we instead generate feature maps H~\tilde H with entries h~j=q1+q2+q33\tilde h_j =\frac{q_1+q_2+q_3}{3} , following the example above. The embedding h~j\tilde h_j can be constructed in a streaming fashion by only transmitting the timestamp, patch index, and code index of the flipped neural event. To do so, we can hold a rolling buffer of neural events and then compute the above per-patch sum in batch. Alternatively, we can compute it event-by-event by maintaining the number of neural events and their rolling buffer sum at each patch. For each new neural event, we then subtract the code of the neural event leaving the buffer, and add the code of the neural event entering the buffer. To compute h~j\tilde h_j, we then divide the sum by the neural event count.

Tab.1-3 all report accuracies in this setting. We study the impact of this dropping mechanism in Tab. 4-c by training a baseline that does not drop neural events. In the example, this baseline would record hjh_j instead of h~j\tilde h_j at that patch. This yields slightly higher mAP (last row, achieving 51.1 mAP) than dropping (code-change emission row, achieving 49.9 mAP). To recover the higher performance, one could cheaply transmit the neural event run length (i.e. number of repeated neural events) in addition to the neural event, allowing reconstruction of the full weighted sum.

Q2. How do the per-event FLOP and energy figures relate to the prediction schedule used in Table 6? Please compare complete pipelines on the same hardware and at a common output frequency, including encoding, task inference, actual energy, and peak memory. In particular, what does the 281 kilobyte encoder-memory allocation include, and does it cover all persistent patch states?:

We refer to our answer to W1, Q3 by reviewer DAx8 and provide a summary here. To complete Tab. 6 and address the reviewer's question, we compare Neural Events, EVA (ICLR 2026), and Event2vec (ICML 2026) models on the same GH200 Nvidia GPU.

We test these methods in two settings: In the event-by-event setting, individual events are inserted into the encoder and then passed through the task network, updating only the affected activations (Tabs. 1 and 2). In the synchronous setting, we perform a complete forward pass with 100,000 events (Tab. 6). Here, the network requires a complete forward pass to produce an updated prediction. Tab. 6-a, in particular, measures execution time under this setting. Tab 6-b reports the memory (281 KB) to store the encoder weights. This convention explains the higher per-event costs of the synchronous baselines. This constitutes the primary computation comparison with other baselines.

Additionally, in the table below, we report the following quantities. (1–2) Memory required to store the encoder and decoder weights.

(3) Memory required for persistent encoder states or retained event history.

(4–5) Encoder steady-state and peak GPU allocations: memory remaining allocated between updates and the maximum allocation reached during processing, respectively.

(6–7) Decoder steady-state and peak GPU allocations: memory remaining allocated between inference calls and the maximum allocation reached during inference, respectively.

(8–9) Full pipeline steady-state allocations and component peaks.

(10) Encoder throughput with sequential, event-by-event processing.

(11) Encoder throughput with batch processing using parallel-scan.

(12–15) Latencies of the encoder, Swin backbone, YOLOX head with postprocessing, and complete pipeline, respectively. Latencies are expressed in milliseconds, with mean ± standard deviation where reported. Decoder inference starts from the complete input representation.

(16) Gen1 detection accuracy, taken from Table 2.

All measurements are performed using FP32 on an NVIDIA GH200 GPU. Memory is reported in decimal MB. All latencies are in milliseconds, with one downstream prediction per packet. Both throughput measurements refer to the encoder. Gen1 detection accuracies are taken from Table 2. The synchronous decoder operates on a fixed-size representation. Its latency is measured per prediction, independently of the number of raw events used to construct that representation.

We see that neural event-based detection has a complete-pipeline latency of 36.70 ms, compared with 282.71 ms for EVA and 79.20 ms for Event2Vec, corresponding to approximately 7.7× and 2.16× speedups. Table 2 separately reports their Gen1 detection accuracies. Tables 1–2 report MAC-based calculated energy estimates using reference operation costs from Jouppi et al. (2021). These provide a comparison under a common energy model; hardware energy consumption was not measured directly.

MetricNeural EventsEVAEvent2Vec
Encoder weights (MB)0.2813.4870.288
Decoder weights (MB)364.29364.29360.32
Persistent state (MB)123.741,345.513.20
Encoder steady-state allocation (MB)158.941,386.0439.28
Encoder allocated peak (MB)158.991,386.62613.78
Decoder steady-state allocation (MB)546.45399.68394.96
Decoder allocated peak (MB)719.51722.16428.59
Full pipeline steady-state allocations (MB)705.391,785.72434.24
Full pipeline peak allocations (MB)878.502,108.781,042.37
—
Encoder throughput with event-by-event processing (events/s)3135524
Encoder throughput with batch-processing (events/s)9.50 x 1e60.39 x 1e61.80 x 1e6
—
Encoder (ms) (mean ± SD)10.53 ± 0.52255.57 ± 2.1255.89 ± 2.47
Swin decoder (ms)16.80 ± 3.3417.17 ± 0.6913.67 ± 3.08
YOLOX head + postprocessing (ms)9.36 ± 0.159.97 ± 0.119.64 ± 1.24
Complete pipeline latency (ms)36.70282.7179.20
—
Detection on Gen1 (mAP)49.947.742.5

Thank you for your detailed rebuttal and additional experiments. I appreciate the effort invested in addressing my concerns. The clarification of the compressed-stream interface and the new hardware measurements substantially improve the paper. In particular, the revised memory accounting and same-hardware comparisons provide useful evidence of computational efficiency. However, some concerns remain. The claimed storage reduction has not been sufficiently validated through actual serialized data, energy consumption is still estimated rather than directly measured, and the accuracy–compression trade-off across different operating points remains insufficiently explored. While the additional results strengthen the practical motivation, I do not find the remaining evidence sufficient to justify increasing my rating. I will therefore maintain my original score of Weak Rejection.

Reviewer_DAx8OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces Neural Events, which re-encodes raw event streams into fewer discrete, learned events. Independent patch-wise RWKV-7 states map incoming events to codebook entries, and a new event is emitted only when the selected code changes. The encoder is pretrained using time-surface reconstruction, rate-dependent smoothing, and latent straightening, then frozen together with the codebook for downstream learning. Evaluation covers detection and classification on Gen1, DSEC, and N-Caltech101, using synchronous Swin-T and asynchronous DAGr backbones. The paper reports approximately twofold event-count reduction, 49.9/52.8 mAP on Gen1, and an 11.0-point improvement over DAGr on DSEC. Ablations include rate-matched dropping, filtering, feature averaging, and unsuppressed quantized outputs. The appendix provides representation-size studies and GH200 and Jetson measurements.

Critical strengths
  1. The method changes the transmission unit from individual brightness changes to changes in learned local states, linking emitted events to accumulated spatiotemporal information. The representation supports both synchronous and asynchronous downstream networks. The improvement over DAGr on DSEC suggests that the frontend can provide useful temporal context in addition to reducing event counts. This is the paper’s most consequential methodological and practical strength.

  2. Table 4(c) provides meaningful rate-matched evidence. At half the original event count, code-change emission achieves 49.9 mAP, compared with 38.3 for random code dropping and 43.7 for feature averaging; unsuppressed quantized outputs achieve 51.1. This supports the claim that the emission rule preserves useful task information under the evaluated setting. The loss, patch-size, and codebook-size studies provide additional support.

Critical weaknesses
  1. Table 2 charges a complete synchronous forward pass for every arriving event or neural event, whereas hardware measurements process packets of 10,000/100,000 events. These operating points are not reconciled at matched detection frequency, input rate, and accuracy, limiting conclusions about practical end-to-end efficiency.

  2. Memory accounting also needs explanation. Table 6 reports only 281 KB for the encoder, despite independent recurrent states for thousands of patches; a conventional implementation would require MB-scale matrix-state storage. Additionally, the bit-count derivation uses EVT 3.0’s 16-bit word width as an event-size assumption, although the format is stateful and its encoding length varies with activity. These issues directly affect the central resource-efficiency claims.

  3. EVA already incorporates patch-wise RWKV encoding, making discretization and change-triggered emission the key contributions to establish here. Table 4(c) supports the emission rule, but its continuous baseline uses raw logits, whereas quantized features pass through a learned codebook. This does not fully isolate hard discretization from normalization and learned projection.

  4. The approximately 17× encoder-FLOPs advantage also compares different depths and widths, as the paper acknowledges. A similarly sized continuous encoder or downsized EVA is needed to establish whether the proposed representation specifically enables effective smaller models. The results support a competitive system combination, but attribution to its distinctive mechanisms remains incomplete.

Questions for authors
  1. The detection and classification comparisons omit several relevant conference methods, including EvRT-DETR (ICCV 2025) and SAST (CVPR 2024) for detection, and EventBind (ECCV 2024) and STP (ICCV 2025) for classification. EventBind, for example, reports 95.29% classification accuracy on N-Caltech101, raising questions about the paper’s broad claim of matching or surpassing state-of-the-art performance. Please include representative strong baselines and specify dataset splits, pretraining data, input modalities, model sizes, and inference frequencies, separately reporting methods benefiting from additional image or image–text pretraining. After these comparisons, does the proposed method remain on the accuracy–computation/bandwidth Pareto frontier? Does its advantage concern overall task performance or a better efficiency trade-off within specific A2S settings?
  2. Section 3.4 constructs HH using code frequencies njkn_j^k before output suppression, while code-change emission removes repeated occurrences. Please specify how HH is constructed during pretraining, downstream training, and testing. Does the downstream network receive only neural-event tuples and the shared codebook? If raw counts, run lengths, or other statistics are needed, how are they transmitted and accounted for? Please verify accuracy and resource costs using strictly the compressed stream.
  3. Please reconcile Table 2’s per-event FLOPs with Table 6’s packet-level measurements, specifying raw and neural events per detection and the actual detector invocation frequency. At matched input rate, detection frequency, and hardware, compare accuracy, end-to-end latency, and throughput against EVA and representative synchronous and asynchronous baselines. Are energy figures measured or converted from FLOPs? Please provide measured energy if retaining the low-power conclusions.
  4. Please provide the state shape and precision per layer, head, and patch, and specify whether 281 KB includes weights, all persistent patch states, previous codes, aggregation buffers, and temporary tensors. Illustratively, eight (8×88\times8) head states across two layers and approximately 3,600 patches require around 7 MiB in FP16 alone. How does the implementation reconcile with the reported figure? Please report steady-state and peak memory during continuous processing after all patches have been visited.
  5. Please specify a decodable neural-event format, including coordinates, timestamps, code indices, headers, and alignment. Clarify bib_i in Equation 16 and reconcile its 4×44\times4 patch assumption with the default 4×54\times5 setting. Please then serialize the same sequences at matched temporal precision and compare actual byte counts. Does approximately twofold event-count reduction consistently translate into comparable storage or transmission savings?
  6. Please specify whether inference uses deterministic argmax or Gumbel sampling, and how states persist or reset across windows. Report accuracy, actual byte rate, and response latency at multiple compression operating points, including first-detection delay and missed detections during motion onset, fast motion, or event bursts. Can code smoothing delay emission of important changes? This evidence would directly inform the claim of preserving fine temporal dynamics.
5 comments

We thank the reviewer for the constructive feedback; in the following, we clarify the expressed doubts:

Q3. Are energy figures measured or converted from FLOPs? Please provide measured energy if retaining the low-power conclusions. We already report computation-induced energy in Tables 1–2, following the same MAC-based energy estimation protocol as DAGr, with the reference operation costs from Jouppi et al. (2021). These values provide an estimated measurement under a common energy model.

W1, Q3. Please reconcile Table 2’s per-event FLOPs with Table 6’s packet-level measurements, specifying the number of raw and neural events per detection and the actual detector invocation frequency. At matched input rate, detection frequency, and hardware, compare accuracy, end-to-end latency, and throughput against EVA and representative synchronous and asynchronous baselines.

As requested, we present a comparison of the related A2S methods EVA (ICLR 2026) and Event2vec (ICML 2026) against Neural Events on the same hardware (GH200 Nvidia GPU), with the same detection frequency and event rate. For this test, we use recurrent matrices and weights stored in FP32, and output vectors in FP64. We report results for the two operating points used in the manuscript: Event-by-event operation (Tabs 1 and 2) used in DAGr (Gehrig, Nature 2024), testing how close we are to a streaming setting where detections are requested at event rate, and the more practical synchronous setting (Tab. 6) where events are accumulated into fixed-size packets before downstream inference.

In both settings, we report (1) the memory required (encoder and decoder weights, recurrent states across patches, and peak allocation), (2) the throughput, i.e., events processed per second (encoding, decoding, and full inference), and (3) the end-to-end latency as well as a breakdown. The results are found in the table below.

In addition to achieving a higher mAP than existing methods, we find that our encoder outperforms them in resource use in both event-by-event and synchronous settings. In the event-by-event setting, it uses (1) less memory for encoder weights, (2) less peak memory than the compared approaches, and (3) has a higher event throughput than the compared approaches. Due to its parallel scan design, in the synchronous setting it achieves a higher event throughput, while reducing encoder and end-to-end latency. The efficiency claims therefore still hold compared to recent state-of-the-art methods without diminishing general performances as reported in Tab 2 with EVA and Event2vec comparison on Gen1.

MetricNeural EventsEVAEvent2Vec
Encoder weights (MB)0.2813.4870.288
Decoder weights (MB)364.29364.29360.32
Persistent state (MB)123.741,345.513.20
Encoder steady-state allocation (MB)158.941,386.0439.28
Encoder allocated peak (MB)158.991,386.62613.78
Decoder steady-state allocation (MB)546.45399.68394.96
Decoder allocated peak (MB)719.51722.16428.59
Full pipeline steady-state allocations (MB)705.391,785.72434.24
Full pipeline peak allocations (MB)878.502,108.781,042.37
—
Encoder throughput with event-by-event processing (events/s)3135524
Encoder throughput with batch-processing (events/s)9.50 x 1e60.39 x 1e61.80 x 1e6
—
Encoder (ms) (mean ± SD)10.53 ± 0.52255.57 ± 2.1255.89 ± 2.47
Swin decoder (ms)16.80 ± 3.3417.17 ± 0.6913.67 ± 3.08
YOLOX head + postprocessing (ms)9.36 ± 0.159.97 ± 0.119.64 ± 1.24
Complete pipeline latency (ms)36.70282.7179.20
—
Complete pipeline latency for one single event (ms)3.38 ± 1.334.17 ± 0.215.39 ± 0.11
Encoder-imposed mean interval between new outputs (ms)6.3918.1841.67
—
Detection on Gen1 (mAP)49.947.742.5

W2 : Memory accounting also needs explanation. Table 6 reports only 281 KB for the encoder, despite independent recurrent states for thousands of patches; a conventional implementation would require MB-scale matrix-state storage.

The 281 KB figure in Tab. 6 only counts encoder weights.

W2: the bit-count derivation uses EVT 3.0’s 16-bit word width as an event-size assumption, although the format is stateful and its encoding length varies with activity.

We address this question in section 7.1 Memory Compression in the appendix, here we summarise the point: Our storage calculation compares explicitly defined fixed-width formats. Both raw events and Neural Events use a 40-bit record: 22 bits for a relative timestamp, followed by either a 17-bit pixel index and one polarity bit, or a 12-bit patch index and six-bit code index. Consequently, the payload reduction equals the event-count reduction, approximately 2× in our evaluated setting. This calculation does not assume that EVT 3.0 requires 16 bits per event or claim equivalent savings against EVT 3.0. We explicitly leave comparison with more stateful compression formats to future work. Block headers are excluded from both payload calculations, and the shared codebook is accounted for separately.

Q4 Please provide the state shape and precision per layer, head, and patch, and specify whether 281 KB includes weights, all persistent patch states, previous codes, aggregation buffers, and temporary tensors … report steady-state and peak memory during continuous processing after all patches have been visited

We additionally profile whole-sensor memory by processing 100,000 random events individually across a 240 × 304 sensor, using 4 × 5-pixel patches. All 3,660 patches are visited prior to the measurement, and their states remain persistent. In this profiling configuration, Neural Events and EVA use 64 × 64 recurrent matrices and weights stored in FP32, and output vectors in FP64. Network parameters are reported in Sec. 4 under "Training details", line 321. We would also like to correct a typo: the number of heads in Section 4 should be 1, not 8. For the small model, each of the two RWKV-7 layers therefore maintains one 64 × 64 recurrent matrix per spatial patch. We will correct the head count in the manuscript and explicitly document the state dimensions, precision, and memory accounting. We provide a summary table of all the parameters below.

Shared encoder weights occupy 0.281 MB, and persistent states occupy 123.741 MB. Total steady-state GPU allocation is 158.939 MB, with a peak of 158.988 MB. Outputs are released after each update, and resident memory remains constant during processing. For comparison, EVA requires 1,386.036 MB of resident allocation and 1,386.617 MB at peak; Event2Vec requires 39.277 MB and 613.781 MB, respectively.

QuantityValue
Number of RWKV layers2
Number of heads1
Patch state shape2 × 1 × 64 × 64 = 8,192
Patch state precisionFP32
State storage (bytes)32,768
Previous activations + metadata (bytes)1,041
Total per patch (MB)0.033809

W4. The approximately 17× encoder-FLOPs advantage also compares different depths and widths, as the paper acknowledges. A similarly sized continuous encoder or downsized EVA is needed to establish whether the proposed representation specifically enables effective smaller models. The results support a competitive system combination, but attribution to its distinctive mechanisms remains incomplete.: The 17× encoder-FLOPs advantage in Table 2 compares TokSwinT-S with EVA-L, and Section 4.1 explicitly acknowledges their different depths and widths. Table 2 also compares TokSwinT-S and TokSwinT-L, varying the depth from 2 to 4 layers while keeping the representation unchanged.

A similarly sized continuous encoder is already evaluated in Table 4(c). With the same encoder architecture and full output retention, continuous logits achieve 39.5 mAP, compared with 51.1 mAP for quantized codebook features. With code-change emission, our model achieves 49.9 mAP while retaining half the outputs. These comparisons support the effectiveness of the learned representation and emission rule within a compact encoder.

We acknowledge that the continuous comparison evaluates the complete codebook mapping, including projection and normalization, rather than hard discretization alone. We will clarify this distinction and explicitly identify the 17× figure as a comparison between the encoder configurations evaluated in Table 2.

Q1. The detection and classification comparisons omitted... including EvRT-DETR (ICCV 2025) and SAST (CVPR 2024) for detection, and EventBind (ECCV 2024) and STP (ICCV 2025) for classification. Please ... specify dataset splits, pretraining data, input modalities, model sizes, and inference frequencies, ... benefiting from additional image or image–text pretraining...

We thank the reviewer for identifying these additional references. We will include their results in our Gen1 and N-Caltech101 benchmarks.

As suggested, we compare our approaches with more recent methods. We find that our large version TokSwinT-L (52.8 mAP) already outperforms SAST and EvRT-DETR-B (52.7 mAP, outperforming SAST). Further, as suggested, we combine Neural Events with EventBind-S (ViT-B/32). We freeze the Neural Events encoder pretrained on Gen1 and adapt EventBind-S to its output using the original EventBind training schedule and the exact evaluation protocol from the official implementation. We limit ourselves to the small version due to limited time to train new models, but a similar procedure can be applied to EventBind-L (ViT-L-14) or any other model.

We report the Top-1 accuracy and FLOPs results for N-Caltech101 below. EventBind-S+NE achieves 95.8% top-1 accuracy on N-Caltech101, compared with 93.7% for EventBind-S, 94.7% for STP, and 95.3% for EventBind-L. We show that EventBind-S+NE outperforms vanilla EventBind-S and our previous model, TokSwin-T.

Object classification results on N-Caltech101.

ModelAsync.AccuracyGFLOPS
STP✗94.7%130.42
EventBind-S (ViT-B-32)✗93.7%59.25
EventBind-L (ViT-L-14)✗95.3%867.17
TokSwinT (Ours)A2S86.5%1.10
EventBind-S+NE (Ours)A2S95.8%59.25
A2S: asynchronous-to-synchronous processing.

Q1. Does its advantage concern overall task performance or a better efficiency trade-off within specific A2S settings?:

Our experiments examine both the representational benefit of Neural Events and its computational benefit with different downstream architectures. Reducing events can reduce downstream computation in event-driven networks such as DAGr. For synchronous networks like EventBind, computation scales only weakly with the number of events; thus, downstream FLOPs remain approximately unchanged, even as performance improves. We observe similar trends for the task of object detection.

Q2. Section 3.4 constructs HH using code frequencies njkn_j^k before output suppression, while code-change emission removes repeated occurrences. Please specify how HH is constructed during pretraining, downstream training, and testing. Does the downstream network receive only neural-event tuples and the shared codebook? If raw counts, run lengths, or other statistics are needed, how are they transmitted and accounted for? Please verify accuracy and resource costs strictly using the compressed stream.:

During encoder pretraining, code-change filtering is not applied. Thus HH is constructed using the full set of neural events. For patch jj, the feature of HH is hj=1Nj∑k=1Knjkqkh_j = \frac{1}{ N_j} \sum_{k=1}^{K} n_j^k q_k, where NjN_j is the number of codes generated in that patch and njkn_j^k counts the frequency of code qkq_k at patch jj. The reconstruction objective in Section 3.4 therefore uses code frequencies computed from the full encoded sequence, as described by njkn_j^k and NjN_j.

During training and testing of the downstream task network (e.g., TokSwinT), code-change filtering is applied before aggregation. We discard an encoded event when its code matches the immediately preceding code within the same patch. Code frequencies are then computed exclusively from retained neural events. Specifically, let n~jk\tilde n_j^k count retained events assigned to code qkq_k in patch j, and let N~j=∑k=1Kn~jk\tilde N_j = \sum_{k=1}^{K} \tilde n_j^k. For a nonempty patch jj in feature map H~\tilde H embedding h~j=1N~j∑k=1Kn~jkqk\tilde h_j = \frac{1}{\tilde N_j} \sum_{k=1}^{K} \tilde n_j^k q_k. We will explicitly distinguish the pretraining and downstream aggregation rules in Section 3.4.

During recurrent encoding, neural events only retain their code, timestamp, and patch, not their run length. Using these quantities alone, we can reconstruct the detector's input H~\tilde H. If we wanted to reconstruct HH, we would need to reserve a small (e.g., 3-bit) portion of each neural event to transmit its run, which may increase data transmission overhead. Table 4(c) already compares task performance of the filtered stream (5th row, CC enabled, 49.9 mAP) with the full encoded sequence without code-change filtering (last row, 51.1 mAP). Table 2 reports accuracy and computational costs for our code-change-filtered model, and Table 6 reports its runtime measurements. Encoder costs include processing all raw input events; downstream processing uses only retained Neural Events. For a full breakdown, please see the answer to W1, Q3.

Reviewer_bEULOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
1
Soundness
3
Read review
Paper summary

This paper proposes generating a scarce yet informative asynchronous scene representation from dense events for competitive performance on downstream event-based applications with less computational cost. The proposed asynchronous representation, termed Neural Events, is generated using a recurrent autoencoder and a flip-then-fire mechanism onto a low-resolution patch. Extensive experiments on both object detection and classification demonstrate the effectiveness, and comprehensive ablation studies help clarify the contribution of each component.

Critical strengths
  1. This paper proposes retokenizing events as a new discrete yet asynchronous scene representation, which is less explored and novel.
  2. This paper extends event-like level-crossing sampling to the more general flip-then-fire mechanism, which may provide further inspiration for spike-like signal processing.
  3. The experiments and ablation studies quite comprehensively cover most concerns about the effectiveness and implementation of the proposed method.
  4. The throughput of Neural Events at the scale of MEvents/s is impressive, implying real-world asynchronous event processing.
Critical weaknesses
  1. The idea of Neural Event still lacks a solid foundation, leading to greater understanding difficulty, harder to extend to other event-based areas, and raising critical concerns about the necessity of event retokenization. In particular, resampling asynchronous event representation with merely a cutoff ratio of 50% seems too complex an innovation compared to in-place event embedding augmentation.
  2. Despite the asynchronous Neural Event design, downstream applications still focus on synchronous object detection and classification. For the proposed recurrent model, it's better to find another streaming application, like online motion field estimation.
Questions for authors
  1. Is the design of Neural Events motivated by any specific principles from computational neuroscience, or is it primarily a computational generalization of the event-generation mechanism used in silicon retinas? Clarifying this connection could provide a stronger conceptual foundation for the proposed representation.
  2. What motivates restricting Neural Event generation to the timestamps of incoming raw events? Could neural events instead be triggered independently, for example, when the latent state crosses a decision boundary between raw event arrivals? How would this design choice affect temporal precision, expressiveness, and computational efficiency?
6 comments

Dear reviewer bEUL, thank you for your constructive feedback and for highlighting the novelty and potential of Neural Events. We address your weaknesses and questions below.

Q1. Is the design of Neural Events motivated by any specific principles from computational neuroscience, or is it primarily a computational generalization of the event-generation mechanism used in silicon retinas?

While our motivation is primarily a computational generalization of event generation in silicon retinas, our design mirrors predictive and redundancy-reducing coding in the retina. Hosoya et al. (Nature, 2005) show that retinal ganglion cells adapt their spatiotemporal receptive fields to suppress predictable sensory information and emphasize informative changes. Likewise, Neural Events arise from spatio-temporal event embeddings that pass through an embedding bottleneck formed by the fixed-size codebook. Neural events thus compress the incoming stream, reducing redundancy, and further reduce redundancy by skipping repeated codes. As described in Sec. 3.1–3.3, this generalizes level-crossing sampling to transitions between regions associated with different learned codes. This also relates conceptually to efficient spiking models that balance representation accuracy against the number of emitted spikes (Boerlin et al., 2013). Furthermore, our latent-straightening regularizer is consistent with evidence that visual cortical representations straighten natural-video trajectories (Hénaff et al., 2021).

W1. Neural Event still lacks a solid foundation, ... raising critical concerns about the necessity of event retokenization. In particular, resampling asynchronous event representation with merely a cutoff ratio of 50% seems too complex an innovation compared to in-place event embedding augmentation.

Whereas embedding augmentation enriches individual events while retaining their number, retokenization additionally suppresses repeated codes. The approximately 50% retained fraction is an empirical outcome, not a predefined parameter. Table 4-c shows that code-change emission halves the outputs while retaining 49.9 mAP, compared with 51.1 without suppression. At the same 50% retained fraction, random code dropping achieves 38.3 mAP, and feature averaging achieves 43.7 mAP, compared with 49.9 for code-change emission. This shows that the emission rule preserves useful task information more effectively than these alternatives at the same output count. Moreover, this data reduction comes with a significant reduction in processing and storage.

W2. ... downstream applications still focus on synchronous object detection and classification. For the proposed recurrent model, it's better to find another streaming application, like online motion field estimation.: We agree that online motion-field estimation would be a valuable further application, and argue that object detection and classification are equally, inherently streaming tasks. Both the exact timing of detection/classification and their accuracy are important algorithmic features. To this end, Table 1 already evaluates Neural Events in this setting using the event-by-event design within the DAGr backbone. TokDAGr improves DSEC detection from 14.0 to 25.0 mAP while reducing computation.

In answer to Q6 by reviewer DAx8, we further study this setting by measuring first-detection delays and missed detections using a 10-second sequence from the Gen1 dataset. Overall, we find that despite code-flipping-based data dropping, neural events maintain high recall (few missed objects) and low detection delay (few events needed to detect a new object), on par with no event dropping and outperforming a rate-matched random-dropping baseline.

Q2. What motivates restricting Neural Event generation to the timestamps of incoming raw events? Could they... be triggered independently, e.g., when the latent state crosses a decision boundary between raw event arrivals? How would this ...affect temporal precision, expressiveness, and computational efficiency?: We agree that continuous-time dynamics could be introduced to evolve memory between event arrivals, thereby prompting neural event generation between consecutive events. Essentially, this is the design adopted by spiking neural networks. This design, however, would require either expensive root-finding operations to regress to the exact level-crossing instance or expensive high-temporal-resolution emulation of the inter-event signal. To maintain computational efficiency, we thus restrict the possible neural event firing times to those of the input events themselves, as these already provide a high temporal resolution, and leave more fine-grained event generation to future work. We presume that allowing more fine-grained spike timings would increase the temporal precision and expressiveness of Neural Events. Future work can investigate how to enable inter-event Neural Event generation while maintaining high computational efficiency.

Reviewer_bEULOpenReview ↗

Need further clarification

Thank the authors for their detailed response and valuable insights into event-based vision. While I appreciate the additional explanations and experiments, I still have some concerns about the conceptual foundation and experimental validation of Neural Events. I would be glad to be proven wrong in further discussion.

Q1: Temporal encoding and event generation.

While retinal ganglion cells efficiently suppress redundant information, I believe the key aspect of event-based sensing lies in encoding the timing of meaningful changes rather than simply detecting transitions between discrete latent states. Unlike classical level-crossing sampling, where event timing and counts reflect signal evolution, code-flipping may lose information about the magnitude and temporal structure of changes. A large latent-state change may trigger only one event, while small fluctuations near decision boundaries may cause repeated emissions. I would appreciate further clarification of how this mechanism preserves meaningful temporal information.

W1: Event-time restriction and compression efficiency.

Restricting Neural Event generation to raw-event timestamps seems primarily motivated by computational convenience rather than representation principles. It remains unclear how this restriction affects temporal precision and expressiveness.

Furthermore, although Table 4(c) demonstrates the effectiveness of code-change emission, I am not convinced that a 50% event reduction sufficiently addresses the scalability bottleneck. Many event-based algorithms already struggle with millions of events per second. I would like to see a more comprehensive rate–accuracy–latency trade-off, particularly at higher reduction ratios (e.g., 80%, 90%, and 99%).

W2: Experimental validation of asynchronous processing.

I acknowledge the asynchronous TokDAGr experiments and the additional first-detection-delay analysis. However, conventional mAP and classification accuracy do not sufficiently characterize asynchronous performance, while the additional evaluation on a single 10-second sequence seems limited.

I would appreciate more systematic evaluations of time-varying prediction accuracy, detection delays, and end-to-end latency. In particular, timestamp perturbation or quantization experiments could help determine whether precise asynchronous timing contributes meaningfully to downstream performance.

Q2: Continuous-time dynamics.

I agree that efficient continuous-time dynamics are challenging. Nevertheless, allowing Neural Events to be generated independently of raw-event arrivals could improve temporal expressiveness. The current design prioritizes computational efficiency, but the implications of this restriction remain insufficiently explored.

Overall assessment.

I remain positive about learning sparse and informative event representations. However, the paper convincingly demonstrates effective learned event compression, but does not yet fully disentangle the contribution of asynchronous temporal encoding from that of recurrent feature learning and discrete quantization.

My main uncertainty is whether the experiments sufficiently establish the necessity and practical advantages of the proposed asynchronous design, rather than primarily demonstrating effective feature compression. Further evidence on temporal sensitivity, aggressive compression, and streaming performance would help clarify the contribution and strengthen my confidence in the paper.

AuthorsOpenReview ↗

Rebuttal to raised concerns

We thank the reviewer for the engaging discussion and point you to our rebuttal below:

Q1: ...I believe the key aspect of event-based sensing lies in encoding the timing of meaningful changes rather than simply detecting transitions between discrete latent states. Unlike classical level-crossing sampling, where event timing and counts reflect signal evolution, code-flipping may lose information about the magnitude and temporal structure of changes...

We would like to clarify that Neural Events use a different coding strategy compared to classical event cameras. In classical event cameras, the magnitude of an intensity change is encoded through the number of events, while their timestamps indicate when the thresholds were crossed. Neural Events instead encode transitions between learned discrete states. Here, the magnitude of a change is not represented by the number of events, but by the previous and new codebook vectors. A large change can therefore be represented by a single event.

Importantly, this does not mean that temporal information is lost. Since we emit an event whenever the code changes, the resulting stream preserves the complete temporal evolution of the quantized representation. Given the code indices and timestamps, we can exactly reconstruct the sequence of discrete states and their durations, without transmitting repeated codes. In this sense, Neural Events generalize the event generation principle from brightness changes to changes in learned features.

Q1. A large latent-state change may trigger only one event, while small fluctuations near decision boundaries may cause repeated emissions. I would appreciate further clarification of how this mechanism preserves meaningful temporal information.

We agree that quantization discards information about changes within individual code regions, and that fluctuations near code boundaries may cause repeated emissions. This is an inherent trade-off of the discrete representation, and we quantify it in our ablation study (see Table 4(c) in the revised manuscript), where we replace hard code assignment with soft code assignment. These results indicate that discrete quantization introduces only a minor performance penalty while enabling a substantial reduction in data redundancy. Our rate-alignment and latent-straightening losses encourage stable code assignments to reduce such fluctuations, although they do not eliminate them entirely. However, we found that we can also enforce this stability at inference by using a probability-ratio filter, which we describe in the next answer to your question.

W1. ... I am not convinced that a 50% event reduction sufficiently addresses the scalability bottleneck. ,,, I would like to see a more comprehensive rate–accuracy–latency trade-off, particularly at higher reduction ratios (e.g., 80%, 90%, and 99%).

To study different compression operating points, we devise a probability-ratio filter that introduces sticky assignment dynamics to reduce the number of code flips. We show results in Fig. 3 of the revised manuscript. Instead of assigning each feature vector to the argmax over logits at each instance, it incorporates hysteresis. Let the last accepted code be k∗k^{\ast}. Then, for each incoming event, the model proposes a code n∗=arg⁡max⁡npi(n)n^{\ast}=\arg\max_n p_i(n) (pip_i is the softmax of the logits). If n∗≠k∗n^{\ast}\neq k^{\ast} then we assign the new code n∗n^{\ast} only if pi(n∗)>τpi(k∗)p_i(n^{\ast}) > \tau p_i(k^{\ast}) where τ\tau is a threshold. Here pi(c∗)p_i(c^{\ast}) is the probability of code c∗c^{\ast} computed from the current encoder logits. Larger values of τ\tau make acceptance more selective. The 00 threshold yields exactly the original behavior. After this code assignment strategy, we retain only the flipped codes. We plot the detection mAP over the test set vs. the proportion of dropped neural events (note this is relative to the 50 percent baseline at x=0, so a drop of 0≤d≤10\leq d\leq 1 retains 0.5∗(1−d)0.5*(1-d) RKWV-7 outputs.)

As transitions become less frequent (τ\tau becomes larger), more neural events are dropped. In this way, we sweep over different neural event-dropping ratios (0 at τ=0\tau=0 to 100100 percent dropping as τ→∞\tau\to\infty) and plot the resulting mAP in Fig. 3 of the revised manuscript. It shows that mAP remains approximately constant under moderate event dropping, up to approximately half the events dropped, corresponding to a retention of 25.625.6 percent on RWKV-7 outputs. More aggressive dropping substantially degrades performance: mAP decreases to 31.231.2 at 85.085.0 percent dropping and to 1.701.70 at 95.895.8 percent. This shows that neural events can compress raw events by up to roughly 4× without significant mAP reductions.

Reviewer_aYaSOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This work presents a framework that re-tokenizes raw event streams into compact, informative neural events. Each neural event corresponds to a local spatiotemporal window encoded by a learnable discrete code; a neural event fires only when this code changes, achieving strong compression. Evaluated on object detection and classification tasks, models using these neural events match or outperform state-of-the-art methods, while cutting the event rate by half. The idea seems reasonable and interesting for the event-based community.

Critical strengths
  1. The idea of compressing the dense event streams into representative neural events is interesting and useful to the community.
  2. The paper is well-written and well-organized, which is readable.
  3. Experiments are conducted on both event-based detection and recognition tasks, which vlidated the effectiveness of the proposed modules.
Critical weaknesses
  1. More experiments on the newly proposed EvDET200K [a] and PokerEvent [b] dataset for event-based object detection are suggested.
    [a]. Object Detection using Event Camera: A MoE Heat Conduction based Detector and A New Benchmark Dataset, CVPR 2025 [b]. SSTFormer: Bridging Spiking Neural Network and Memory Support Transformer for Frame-Event based Recognition, IEEE TCDS 2025

  2. The proportions of Table 2 are unsatisfactory; please adjust the dimensions of this table in the final version.

  3. The source code of this paper can be open-sourced for more in-depth study by future readers.

  4. A limitation analysis is suggested before the section conclusion.

  5. A comparative analysis with other efficient compression methods for event streams is necessary. The authors may consider including more comparable approaches to demonstrate the effectiveness of the proposed method.

Questions for authors
  1. More experiments on the newly proposed EvDET200K [a] and PokerEvent [b] dataset for event-based object detection are suggested.
    [a]. Object Detection using Event Camera: A MoE Heat Conduction based Detector and A New Benchmark Dataset, CVPR 2025 [b]. SSTFormer: Bridging Spiking Neural Network and Memory Support Transformer for Frame-Event based Recognition, IEEE TCDS 2025

  2. The proportions of Table 2 are unsatisfactory; please adjust the dimensions of this table in the final version.

  3. The source code of this paper can be open-sourced for more in-depth study by future readers.

  4. A limitation analysis is suggested before the section conclusion.

  5. A comparative analysis with other efficient compression methods for event streams is necessary. The authors may consider including more comparable approaches to demonstrate the effectiveness of the proposed method.

1 comment

We thank reviewer aYaS for the feedback on our submission.

Q1 Experiments with new baselines

We thank the reviewer for suggesting additional benchmarks. We have now evaluated Neural Events on the requested EvDET200K dataset, integrating our representation with MvHeat-DET, which we term TokMvHeat-DET.

MethodmAP@50:95mAP@50mAP@75Reported FLOPs (G)
vHeat50.372.254.274.5
MvHeat-DET52.980.455.956.4
TokMvHeat-DET (Ours)55.4781.8358.9456.4

TokMvHeat-DET achieves 55.47 mAP@50:95, compared with 52.9 for MvHeat-DET, an improvement of 2.57 points. Improvements are also observed at both individual IoU thresholds: +1.43 points at IoU 0.50 and +3.04 points at IoU 0.75. This extends our evaluation to the additional detection benchmark requested by the reviewer.

We also investigate compatibility with a stronger classification backbone by integrating Neural Events with EventBind-S on N-Caltech101, which we term TokEventBind-S

ModelProcessingAccuracyReported FLOPs (G)
STPSynchronous94.7%130.42
EventBind-S (ViT-B/32)Synchronous93.7%59.25
EventBind-L (ViT-L/14)Synchronous95.3%867.17
TokSwinT (Ours)A2S86.5%1.10
TokEventBind-S (Ours)A2S95.8%59.25

A2S denotes asynchronous-to-synchronous processing.

TokEventBind-S achieves 95.8% accuracy, improving upon EventBind-S by 2.1 percentage points and exceeding the reported accuracy of EventBind-L. This provides further evidence that the usefulness of Neural Events extends beyond the downstream architectures originally evaluated in our paper.

Regarding PokerEvent, we could not locate publicly released SSTFormer checkpoints trained on this dataset in the official repository. Although training code is available, our intended comparison would require first reproducing and validating the SSTFormer baseline before adapting it to Neural Events. We have not completed this comparison during the rebuttal period and have prioritized the requested EvDET200K evaluation and the additional EventBind experiments reported above.

We will include these additional experiments in the revised manuscript.

Q2 Proportions of Table 2:

We will adjust the proportions and spacing of Table 2 to improve readability in the final revision.

Q3 Source code:

We will open-source the code, weights and everything to reproduce results upon acceptance.

Q4 Limitation analysis:

A limitations discussion is provided in Appendix Section 6.8. We will include a concise version before the conclusion to make these limitations more prominent. Our encoder uses fixed, non-overlapping patches with independent recurrent states, leaving the association of information across patch boundaries to the downstream network. Furthermore, tokenization occurs after sensor readout, so raw events must still be transmitted from the sensor to the encoder. Integrating tokenization into sensor hardware is a potential future direction whose implementation costs and energy benefits remain to be evaluated.

Q5 Comparative analysis of efficient event-stream compression methods:

Table 4(c) provides controlled comparisons with alternative event-stream reduction strategies using the same Swin-T backbone and YOLOX head. At the same retaining fraction, random dropping and background-activity filtering of raw events achieve 25.5 and 29.5 mAP, respectively. With the learned codebook representation, random code dropping achieves 38.3 mAP and pairwise feature averaging achieves 43.7 mAP, compared with 49.9 mAP for code-change emission. Retaining every quantized output achieves 51.1 mAP. Thus, code-change emission halves the output count with a 1.2-point mAP reduction, while outperforming the other evaluated reduction strategies at the same retained fraction. We will make the scope and findings of this comparison more explicit in the revised manuscript.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Overview of changes

We would like to thank the reviewers for giving insightful comments and highlighting the novelty and potential of Neural Events. The reviewers’ proposed experiments helped us more clearly demonstrate the resource use of neural events and shed light on the importance of various components of the encoder. Furthermore, exploring additional compression set points allows us to understand the Pareto frontier of our method. We have fixed formatting issues and typos, clarified equations, and will release code upon acceptance.

We have made the following major additions to the manuscript:

  • Following reviewer bEUL, we have included a brief discussion on biological connections to our Neural Event design, beyond its computational motivation (Sec. 1). We have also included a brief discussion of future work targeting algorithms for generating Neural Events between raw events (Sec. 3.3).
  • To answer reviewers DAx8 and ff4D's lack of clarity about the definition of HH and how to compute it online, we have included a paragraph explaining it in more detail (Sec. 3.3, L281).
  • To answer reviewers DAx8d and bEUL's concern about streaming evaluation, we present additional results measuring the detection mAP, time to first detection, and object recall as new events are observed. We present these results in paragraph "Detection Delay" at L 420, Sec. 4.1.
  • Following reviewer DAx8 and ff4D's suggestions, we include real energy measurements and run-time and memory breakdowns across the network, with matched settings across baselines, and exact memory shapes (Sec. 7.4). We present memory and energy measurements on the NVIDIA Jetson Orin (Tab. 6), and runtimes on the Jetson Orin (Tab. 7 a) and an NVIDIA GH200 (Tab. 7 b).
  • Following suggestions by reviewers aYaS and DAx8, we have included more baselines and dataset evaluations. We have included detectors SAST (Peng, 2024), EvRT-DETR-B (Torbunov, 2025), and MvHeat-Det (Wang, 2025) (see Tab. 2 and Tab. 8) and classifiers STP (Liang, 2025) and EventBind (Zhou, 2024) (see Tab. 3). We have included evaluation on EvDET200K (Wang, 2025) in Tab. 8. Further we introduced two new baselines TokEventBind, and TokMvHeat-Det, which augment MvHeat-Det, and EventBind with neural events, setting a new state-of-the-art.
  • Following aYaS, we added a limitation section before the conclusion (Sec. 5), and added an additional ablation, replacing GumbelSoftMax in Eq. 9 with a regular SoftMax, to study the role of hard quantization on the performance (Tab. 4 c, Sec. 4.3).
  • Following comments by DAx8 and bEUL, we have studied in more detail ways to further compress neural events. We have devised a way based on probability ratio-filtering, and report experiments and results in Sec. 7.5 and Fig. 3. We find that we can drop up to 25 percent of RKWV-7 outputs without significant degradation.
  • Following the comments by DAx8, we devised, implemented, and evaluated a data serialization strategy for streaming neural events, which features roughly half the data storage for neural events compared to raw events (Sec. 7.1 )
  • Following reviewer bEUL’s suggestion, we added a controlled timestamp-quantization ablation to assess the contribution of emission-time information beyond the learned codes. These results support the usefulness of emission-time information in the evaluated model, while we retain qualified claims regarding temporal precision.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.