Event Slice Sequencing Module

• Event Slice Sequencing Module (ESSM) is a component that transforms unordered event data from text, vision, and sensor streams into temporally ordered slices.
• It employs methods like DAG construction, time-binned slicing, and spiking neural triggers to enforce temporal order across diverse data modalities.
• ESSM improves downstream task performance as evidenced by increased F1 scores in textual sequencing and AUC gains in event-driven vision tasks.

An Event Slice Sequencing Module (ESSM) is a functional component in event-centric pipelines—textual, sensor, or vision-based—responsible for transforming unordered or raw event data into structured, temporally coherent sequences or slices for downstream processing. This module spans implementations from graph-based decoding in discourse to point-cloud sub-sampling for event-driven vision, as well as generative paradigms for narrative schema construction. ESSM’s primary contribution is enforcing temporal order (via sorting, slicing, or DAG construction) in settings where events are detected asynchronously or lack inherent chronological organization.

1. Mathematical Formulations Across Domains

Event Slice Sequencing modules adopt domain-specific approaches for encoding temporal structure:

• Textual/NLP (DAG Construction): Given a set of typed event mentions $M = \{m_1, m_2, \dots, m_n\}$, ESSM outputs a directed acyclic graph (DAG) with “After” arcs, representing minimal temporal scripts after transitive reduction. The decoding objective optimizes $score(z) = w \cdot \Phi(z)$, where $z$ denotes the binary inclusion of arcs and $\Phi(z)$ aggregates arc-wise features (Liu et al., 2018).
• Point Cloud Vision (Time-Binned Slicing): For each batch $b$ of $N$ events, each point is labeled with a normalized timestamp $t_{b,n} \in [0, 1]$ and assigned to a slice $s_{b,n} = \left\lfloor K t_{b,n} \right\rfloor$, yielding $K$ bins. Slice tokens $\mathbf{t}_{b,s}$ are formed via max-pooling over assigned events and stacked into $\mathbf{T}_b \in \mathbb{R}^{K\times C}$ (Zhou et al., 6 Dec 2025).
• Spiking Neural Network-Based Slicing: Event streams are partitioned into cells $\mathcal{C}[n]$ over time intervals, processed by an SNN that triggers a slice whenever LIF neuron membrane potential $U[n]$ exceeds a threshold $V_{th}$ (Cao et al., 3 Oct 2024).
• Conditional Generation over Narratives: The ESSM encoder takes shuffled, corrupted event sequences as input $x$ and is trained (via denoising autoencoding) to reconstruct the original ordered sequence $y$, optimizing $-\sum_{(y,x)} \log P_\theta(y|x)$ (Lin et al., 2020).

2. Event and Slice Representation

ESSM design depends on precise event encoding:

• Textual Pipelines: Nodes are event mentions $m_j$, collapsed into clusters per coreference analysis. Edges encode strict temporal precedence, subject to acyclicity and minimality (Liu et al., 2018).
• Vision Pipelines: Events become multi-feature vectors post rasterization and edge-enhanced sampling $(x, y, t_{avg}, p_{acc}, e_{cnt})$, processed via MLP/point-cloud backbone (Zhou et al., 6 Dec 2025).
• SNN Slicing: Each event cell is transformed into a fixed-size tensor for SNN input, with slices emitted on spike trigger (Cao et al., 3 Oct 2024).
• Narrative Generation: Event representations combine predicate verbs and structured argument spans, using special marker tokens ([E], [Ei]) to preserve event boundaries for autoencoding and infilling (Lin et al., 2020).

3. Inference, Decoding, and Training Algorithms

ESSMs utilize both deterministic and generative training and inference workflows:

Domain/Module	Inference Method	Training Approach
Graph-based Text	Greedy Best-First Decoding over O($n^2$) arcs; acyclicity and transitive reduction enforced	Passive–Aggressive online learning, arc-level feature updates (Liu et al., 2018)
Point-Cloud Vision	Synchronous slice assignment via timestamp binning, followed by max-pooling and ETSC	Backbone (MLP) trained end-to-end; slice construction via deterministic binning (Zhou et al., 6 Dec 2025)
SNN-Based Slicing	Spike when $U[n] \geq V_{th}$; triggers slice boundary	Two-stage feedback loop with Spiking Position-aware Loss (SPA-Loss); downstream ANN feedback (Cao et al., 3 Oct 2024)
Conditional Generation	Beam search for event ordering; nucleus sampling for infilling	Denoising autoencoder objective on corrupted event sequences (Lin et al., 2020)

Graph-Based Decoding

• Inputs: document event mentions $M$, candidate antecedents per mention; outputs: minimal “After”-arc DAG.
• Greedy left-to-right decoding: for mention $m_j$, score possible arcs $(m_i\to m_j)$ (for $i<j$), choose highest non-redundant arc per cycle/transitivity constraints, return transitive reduction (Liu et al., 2018).

SNN Event Slicing

• LIF neuron integrates spatio-temporal event grids; spike triggers slicing.
• Training with SPA-Loss ensures spikes align with ground-truth salient temporal boundaries, augmented by feedback from downstream ANN's task loss (Cao et al., 3 Oct 2024).

Conditional Generators

• BART-based encoder reconstructs temporally ordered sequences after event shuffling/deletion.
• Decoding employs beam search (ordering) and nucleus sampling (infilling), ensuring output sequence recovers both event order and plausible missing events (Lin et al., 2020).

4. Feature Spaces and Compatibility Functions

ESSM performance relies on effective event–event relation scoring:

Graph-Based Text Features (Liu et al., 2018)

• Surface compatibility: headword lemma pairs, event-type compatibility, script-database membership (e.g., Chambers schema), shared semantic argument frames.
• Discourse compatibility: dependency-path, function-word bag, intervening event types, sentence distance, presence of temporal expressions.
• Ordering signals: discourse ordering (forward/backward), external temporal relations (CAEVO labels).

Point-Cloud Vision Features (Zhou et al., 6 Dec 2025)

• Sobel-edge enhancement augments per-event features.
• Max-pooling across time-bins yields slice-level tokens, supporting local motion dependency extraction via ETSC.

SNN Slicing Features (Cao et al., 3 Oct 2024)

• Cell-based voxel encoding, low-energy convolutional transform, feedback-tuned spike timing.

Generation Model Features (Lin et al., 2020)

• Input tokenization preserves predicate/argument structure for event slices; ordering inferred via learned positional/segment embeddings.

5. Evaluation Metrics and Empirical Results

ESSMs are assessed by domain-specified metrics:

• Textual Event Sequencing: TempEval closure-based metric (precision/recall/F1 on transitive reduction/closure of DAGs), e.g., P=18.28, R=16.91, F1=17.57 for graph-based decoding (Liu et al., 2018).
• Event-Driven Vision: Recognition and tracking accuracy post-ESS slicing—SpikeSlicer yields 11.4% absolute AUC improvement for tracking and up to +6.46% for event recognition with negligible energy overhead (Cao et al., 3 Oct 2024); point-cloud backbone fusion yields consistent performance gains across PointNet, DGCNN, Point Transformer (Zhou et al., 6 Dec 2025).
• Narrative Generation: Pairwise ordering accuracy, macro F1, exact match/top-2 metrics for event ordering; human-rated coherence/temporality for infilled events (e.g., TemporalBART-indexed 79.7% vs. BERT pairwise 65.7%) (Lin et al., 2020).

6. Modular Deployment and Extensions

Implementation blueprints emphasize modular, pipeline-based integration:

Textual Pipeline (Minimal-DAG) (Liu et al., 2018)

• Event detection/typing $\rightarrow$ (optionally) coreference clustering $\rightarrow$ candidate pair feature extraction $\rightarrow$ graph-based decoding/training $\rightarrow$ post-processing/visualization.
• Adaptations: joint coref+sequencing, ILP/MST-style global inference, neural encoding augmentation.

Vision Pipeline (Zhou et al., 6 Dec 2025)

• Edge-enhanced rasterization and MLP extraction $\rightarrow$ ESS assignment (binning/max-pooling) $\rightarrow$ short-term sequence processing (ETSC) $\rightarrow$ global descriptor fusion $\rightarrow$ backbone feature addition $\rightarrow$ downstream keypoint/pose estimation.

SNN/ANN Event Slice Trigger (Cao et al., 3 Oct 2024)

• SNN spike-based slicing upstream of any event representation block; integrates seamlessly with time-surface/voxel representations; compatible with neuromorphic hardware for low-power, real-time adaptive slicing.

Generative Pipeline (Lin et al., 2020)

• SRL-based event extraction $\rightarrow$ sequence corruption (shuffling, deletion) $\rightarrow$ BART encoder-decoder for ordering/infilling $\rightarrow$ application to timeline completion, story generation, QA.

Potential extensions include multi-task decode over coref/sequencing arcs, streaming deployment (Distil-BART), neural breadcrumbs features, and multi-event infilling.

7. Limitations, Domain Bias, and Adaptation Strategies

Notable constraints:

• Textual ESSMs exhibit domain bias, particularly in highly technical or conversational corpora; lack context grounding for coreference/anaphora (Lin et al., 2020).
• SNN slice triggers generalize across motion density regimes; minimal energy cost but require annotated downstream feedback (Cao et al., 3 Oct 2024).
• Vision ESSMs rely on chosen $K$-bin granularity and backbone compatibility; practical applicability confirmed for DHP19 benchmark (Zhou et al., 6 Dec 2025).

Adaptation strategies involve coreference–sequencing integration, domain-specific fine-tuning (MATRES/CaTeRS), multi-slot event infilling, and integration of neural context encodings in feature extraction or scoring.

---

Event Slice Sequencing Modules thus constitute foundational infrastructure for temporally structured event modeling, spanning symbolic, neural, and spiking paradigms across text, vision, and narrative domains (Liu et al., 2018, Zhou et al., 6 Dec 2025, Cao et al., 3 Oct 2024, Lin et al., 2020). Their algorithmic flexibility and modular integration enable robust temporal inference, adaptive slicing, and streamlined downstream task performance in heterogeneous event-centric applications.