---
title: Event Temporal Slicing Convolution
url: https://www.emergentmind.com/topics/event-temporal-slicing-convolution
type: topic
---

# Event Temporal Slicing Convolution

Event Temporal Slicing Convolution (ETSC) refers broadly to a class of operations in event-based data processing where the temporal dimension is explicitly discretized or segmented (“sliced”) into intervals, and local convolutional operations are applied within or across these slices. This approach is fundamentally motivated by the need to model fine-grained, data-driven temporal patterns in event streams—sequences of occurrences marked by precise timestamps—without losing the sparsity, temporal precision, or causality inherent in such data. ETSC and its variants have become central to a range of modern architectures for temporal point processes, neuromorphic perception, action recognition, pose estimation, and open-vocabulary event-based detection.

## 1. Temporal Slicing and Event Representation

ETSC architectures begin by transforming asynchronous event streams—sequences of tuples $(x_i, y_i, t_i, p_i)$, or higher-order marks—into temporally segmented representations. The key strategies are as follows:

- **Fixed, Uniform Binning:** Segment the time axis into equal-width intervals (bins) and aggregate events within each bin, forming a sequence (\emph{voxel grid} or tensor) suitable for convolutional operations. This is standard in spatiotemporal event filtering for action recognition [1903.07067] and spiking neural networks (SNNs) [2210.05241].  
- **Adaptive Slicing:** Use a data-dependent module (e.g., an SNN with leaky-integrate-and-fire dynamics) to dynamically determine event boundaries, such that slices are created at information-rich moments [2510.00681].
- **Continuous Scanning:** In continuous-time settings, for each target event time $t_i$, aggregate history over a look-back window $[t_i - \eta, t_i]$ (“horizon” slicing), enabling multi-scale contextual encoding [2306.14072].

This step ensures temporal alignment and preserves causality, establishing the foundation for downstream convolutional filtering. 

## 2. Continuous-Time and Discrete-Time Convolutional Operators

ETSC modules use parameterized convolutional kernels to aggregate history within each temporal slice or horizon. The mathematical formalism varies by data modality and task:

- **Continuous-Time Convolution:** For a history of events $(m_j, t_j)$, form
  $$
  c_i^l = \sum_{j:\ 0 \leq t_i - t_j \leq \eta^l} \psi_\theta^l(t_i - t_j) \cdot e_j,
  $$
  where $\psi_\theta^l$ is a trainable, causal kernel (typically SIREN or MLP-parameterized), $e_j$ is the embedding of event $j$, and $\eta^l$ the channel-specific horizon [2306.14072]. COTIC employs linear causal kernels for efficient multi-layer convolution:
  $$
  y_i = \sum_{j=1}^{i-1} k(t_i - t_j) m_j, \quad k(\tau) = \tau W + B, \quad W,B~\text{learned}.
  $$
  This enables direct modeling of irregular, non-uniform event sequences without the necessity of resampling [2302.06247].
- **Discrete-Time Temporal Filtering:** In binned representations, apply 1D (depth-wise) convolution across the temporal axis within each slice, typically immediately prior to spatial processing:
  $$
  C(t, c, h, w) = \sum_{\tau = -P_F}^{+P_F} W^F_{\tau, c} \cdot X(t - \tau, c, h, w),
  $$
  where $K_F$ is filter length, $W^F$ convolution weights, and $X$ the temporally sliced data [2210.05241, 2512.06306].
- **Hybrid Spatiotemporal Filtering:** For event-based action recognition, 3D kernels $F^{(j)} \in \mathbb{R}^{a \times a \times k}$ are applied directly to voxels $V^{(s)} \in \mathbb{N}^{128 \times 128 \times k}$ [1903.07067].

In all cases, kernels are parameterized or learned to match the temporal structure of the data, and dilation, depth, and receptive field hyperparameters are tuned to balance context size with computational efficiency.

## 3. Integration with Downstream Modules and Global Context

Most ETSC architectures are nested within larger pipelines that combine local temporal context with global sequence understanding:

- **Recurrent Fusion:** Local multi-horizon convolutional encodings $c_i$ are concatenated, projected, and fused via residual connections before being fed to a GRU, producing a global hidden state $h_i$ that accumulates both local (convolutional) and global (recurrent) information [2306.14072].
- **Attention and Gating Mechanisms:** Temporal filter outputs are modulated by attention-like gates, computed as temporal convolutions followed by non-linear bottlenecked MLPs and sigmoids, controlling information flow at each time channel [2210.05241].
- **Token-Level Temporal Modeling:** In point cloud architectures for pose estimation, ETSC is applied across slice tokens (after spatial aggregation), with parallel standard and dilated 1D convolutions and residual connections, followed by temporal global pooling and feature concatenation [2512.06306].
- **SNN-CNN Hybrids:** Adaptive slicing (via SNN) is followed by standard 2D convolutional backbones (CNN+FPN), enabling adaptive temporal feature granularity for efficient and semantically rich open-vocabulary detection [2510.00681].

The flexibility in the point at which ETSC is applied—pre-spatial, inter-token, or pre-recurrent—enables reuse across domains.

## 4. Kernel Learning and Temporal Pooling Strategies

The efficacy of ETSC derives from the inductive bias and adaptability of its filters:

- **Trainable Continuous Kernels:** SIREN-style MLPs parameterize continuous temporal kernels, allowing the convolution operator to capture oscillatory and fine-grained temporal dependencies at each scale [2306.14072].
- **Learned Discrete Filters:** In event-based action recognition, 3D filter weights are derived via unsupervised slowness regularization, yielding filters that are robust to missing spikes and focus on salient, invariant motion patterns [1903.07067].
- **Explicit Time-Decay:** Time-Discounting Convolution (TDC) introduces convolutional kernels with eligibility-trace or patch-style parameterizations, imparting exponential memory decay to ensure natural forgetting, robustness to timestamp ambiguity, and time-shift invariance [1812.02395].
- **Dynamic Pooling:** TDC further augments convolution with growing-window pooling over both raw inputs and intermediate activations, increasing resilience to temporal jitter and enhancing time-discounting effects as depth increases [1812.02395].

This kernel engineering directly influences the ability of ETSC modules to handle temporally sparse or ambiguous signals, as well as computational scalability.

## 5. Computational Complexity and Parallelization Properties

A principal motivation for ETSC is efficient, scalable handling of long and non-uniform event sequences:

- **Linear Complexity in Sequence Length:** For windowed or horizon-based ETSC (e.g., [2306.14072]), per-event cost is $O(C W_i d)$—where $C$ is channels, $W_i$ is the number of events in the current window, and $d$ is feature size. If window sizes are chosen judiciously ($W_i \ll i$), computation is nearly linear in total sequence length. Sliding-window indices and minibatch parallelization on GPU further reduce runtime.
- **Full Parallelism over Events/Slices:** Continuous-time convolution architectures (COTIC) in [2302.06247] parallelize over all $T$ events; convolution layer cost is $O(T d^2)$ with batched slicing, compared to $O(T^2 d)$ in transformer-based self-attentive models.
- **Minimal Overhead in SNN-CNN Hybrids:** Slicing is triggered only at points of high membrane potential, limiting computations to informative intervals [2510.00681]; subsequent 2D convolutions are standard and well-optimized.
- **Low Latency:** Ablation studies in event-based pose estimation show runtime of 1.89 ms per ETSC pass on standard hardware, demonstrating suitability for real-time applications [2512.06306].

## 6. Empirical Applications and Benchmark Performance

ETSC and its variants have reported strong performance across a variety of tasks:

- **Temporal Point Process Modeling:** Local horizon slicing plus continuous-time convolutional encoding with global RNN fusion yields improved predictive likelihood and accuracy over RNN/transformer baselines [2306.14072].
- **Event-based Action Recognition:** Spatiotemporal filtering on fine voxelized slices, coupled with unsupervised filter learning, achieves state-of-the-art accuracy and drastically lower latency on DVS Gesture and new action datasets (e.g., 95.6% accuracy, ~56 ms latency for DVS Gesture) [1903.07067].
- **Event-driven Pose Estimation:** ETSC modules operating on sequential token slices yield consistent performance gains (e.g., 3% 2D/3D MPJPE reduction on DHP19), with minimal added runtime [2512.06306].
- **Adaptive Open-vocabulary Detection:** Jointly trained SNN slicers and CNN backbones, optimized for detection and vision-language distillation, match or exceed fixed-slice baselines on object detection with maximal temporal feature retention [2510.00681].
- **Ambiguous-Timestamp Sequences:** TDC’s combination of decay and dynamic pooling provides robustness to time-shift and missing annotations, outperforming TCN, VAR, and RNN baselines in variable-length scenarios [1812.02395].

A plausible implication is that ETSC is foundational for any event-driven modeling context requiring both fine-grained and robust temporal feature extraction.

## 7. Variants, Comparative Architecture, and Future Directions

A comparative summary of ETSC instantiations is provided in the following table:

| Variant / Paper                | Slicing Type         | Kernel Parametrization        |
|-------------------------------|----------------------|------------------------------|
| [2306.14072]                  | Multi-horizon (local)| SIREN-MLP continuous         |
| [2302.06247]                  | Fixed, plus slice pts| Linear, causal continuous    |
| [2512.06306]                  | Equal segment tokens | 1D Conv + dilated Conv       |
| [2210.05241]                  | Frame/binning        | Depthwise 1D Conv + gate     |
| [1903.07067]                  | Fixed bins, segments | Unsupervised 3D conv filters |
| [2510.00681]                  | Adaptive (SNN-cut)   | Standard 2D CNN              |
| [1812.02395]                  | Fixed bins           | Exponential-decay conv + pooling |

Current research is exploring unified models that can learn both slicing granularity and convolutional kernel structure in a task-driven, end-to-end fashion, as well as more adaptive, context- and data-driven methods that blend continuous and discrete slicing.

Future work may investigate tighter integration between event-slicing modules and large pre-trained foundation models, broader integration within spiking or neuromorphic hardware, and theoretical characterizations of information retention and loss in various slicing/convolutional schemes.

Source: https://www.emergentmind.com/topics/event-temporal-slicing-convolution