Continuous Time Modeling for Event Sequences

17 concepts15 papers

When we attempt to model real-world events—whether they are financial transactions, social media interactions, neural spikes, or medical emergency calls—we face a fundamental design choice: how should we represent time?

The most common approach is to chop time into discrete buckets, such as hours, days, or fixed-step intervals. While this simplifies computation, it introduces temporal discretization bias. By forcing continuous reality into rigid digital containers, we inadvertently destroy the fine-grained temporal resolution required to understand true system dynamics.

To overcome these limitations, a growing body of research shifts the paradigm from discrete-time approximations to native continuous-time modeling. By treating time as a fluid continuum, these frameworks preserve the exact ordering, spacing, and causal relationships inherent in sequential data.

The Hidden Costs of the Time Bin

To understand why continuous-time modeling works, we must first look at how discrete binning fails. Suppose two events occur just two minutes apart, but one happens at 11:59 AM and the other at 12:01 PM. If we aggregate our data into hourly bins, these events are split across an arbitrary boundary. Conversely, two events occurring at 12:01 PM and 12:59 PM are lumped into the same bucket, despite being nearly an hour apart.

As Christian Braune demonstrates in Prototype Construction for Clustering of Point Processes based on Imprecise Synchrony, fixed-window binning creates artificial boundary errors that distort patterns of synchrony. When we group actions into the same discrete time slice, we also erase their internal sequence. As Chaokun Wang et al. point out in Learning Temporal Dynamics of Behavior Propagation in Social Networks, preserving the total order of events is essential for mapping how influence spreads; without it, we lose the ability to determine which event actually triggered the next.

This loss of resolution severely degrades causal discovery. When data is aggregated, distinguishing between a true cause-and-effect relationship and a mere co-occurrence becomes incredibly difficult. Authors such as Debarun Bhattacharjya et al. in Cause-Effect Association between Event Pairs in Event Datasets and Tsuyoshi Ide et al. in Cardinality-Regularized Hawkes-Granger Model emphasize that maintaining exact timestamps is the only reliable way to isolate precise lead-lag relationships and separate independent background noise from self-exciting triggers.

Modeling Intensity Instead of Buckets

If we abandon discrete bins, how do we mathematically represent the likelihood of an event occurring? The solution lies in modeling the conditional intensity function—a continuous measure of the instantaneous rate at which events happen over time.

A foundational tool for this is the Hawkes process, a self-exciting point process where past events cause a temporary spike in the probability of future events, which then decays smoothly over time. This approach naturally mirrors real-world phenomena like viral social media threads or corporate behavior. For instance, Junchi Yan et al. apply this intuition in Modeling Contagious Merger and Acquisition via Point Processes with a Profile Regression Prior to capture the temporal "waves" of corporate acquisitions, demonstrating how one market action triggers a continuous cascade of subsequent deals.

Discrete Binning (Information Loss):
[ Event A, Event B ] -> [ Bin 1: Count=2 ]
[                  ] -> [ Bin 2: Count=0 ]

Continuous Intensity (Information Preserved):
Event A -------> Event B 
   |                ^
   |-- (Exact dt) --|  --> Instantaneous Intensity Spike & Smooth Decay

To capture fast-moving online discussions or complex relational networks, the intensity function must be highly flexible. Yeon Seonwoo et al. show in Hierarchical Dirichlet Gaussian Marked Hawkes Process for Narrative Reconstruction in Continuous Time Domain that discrete intervals like hours or days completely miss the rapid-fire dynamics of online threads, whereas continuous-time Hawkes models can trace exact narrative trajectories. To model these smooth intensity functions without relying on rigid parametric assumptions, Gabriel Loaiza-Ganem et al. developed Deep Random Splines for Point Process Intensity Estimation, which maps neural network outputs directly to spline parameters to achieve flexible, non-negative rate estimations.

Continuous Trajectories in Multiway Data

Real-world data is rarely isolated; it often involves multiway interactions between users, items, and features over time. Traditional tensor factorization methods handle this by slicing a data tensor into static, discrete time blocks. However, this treats latent entities as if they change in sudden, jerky steps.

Continuous-time frameworks resolve this by modeling the latent factors themselves as continuous, time-varying trajectories. Hongteng Xu et al. pioneer this in Online Continuous-Time Tensor Factorization Based on Pairwise Interactive Point Processes, combining point processes with tensor decomposition to track fluid multiway interactions. By replacing discrete steps with non-parametric functions like Gaussian Processes, models can capture highly non-linear, rapid fluctuations.

As explored by Shandian Zhe et al. in Stochastic Nonparametric Event-Tensor Decomposition, this integration prevents the destruction of fine-grained multiway patterns. Building on this concept, Zheng Wang et al. in Nonparametric Factor Trajectory Learning for Dynamic Tensor Decomposition and Shikai Fang et al. in Bayesian Continuous-Time Tucker Decomposition demonstrate that linking Gaussian Processes with Stochastic Differential Equations allows models to track subtle, rapid shifts in multiway data with highly efficient, linear-time inference ($O(N)$).

Integrating Differential Equations into Deep Learning

The push toward continuous time has also transformed deep sequence models, which historically relied on discrete recurrent steps or fixed positional encodings. When dealing with irregular or missing data, traditional architectures struggle because they assume uniform spacing between tokens.

Modern continuous-time architectures solve this by embedding differential equations directly into deep learning components:

Why It Works: The Power of Inter-Event Intervals

Ultimately, continuous-time modeling works because it treats the inter-event interval ($\Delta t$) as a first-class informational feature rather than a nuisance variable. As Kevin Heins et al. articulate in A Statistical Model for Event Sequence Data, the specific duration between actions carries deep behavioral meaning. A gap of two seconds implies a completely different relationship than a gap of two days.

By modeling these intervals explicitly on a continuous scale, these frameworks eliminate the arbitrary trade-off between interval granularity and data density. Models no longer have to guess what occurred inside a blank bucket or struggle with sparse, empty intervals. Instead, they calculate exact mathematical gradients of influence decay, maintain strict causal paths, and naturally accommodate the irregular, spiky rhythms of the real world.

Key Foundational Work

A Statistical Model for Event Sequence Data (2014) — contributed 2 concept elements to this direction.
Learning Temporal Dynamics of Behavior Propagation in Social Networks (2014) — contributed 1 concept elements to this direction.
Prototype Construction for Clustering of Point Processes based on Imprecise Synchrony (2013) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_continuous_time_event_modeling_2a4e68df,
  title = {continuous-time event modeling},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/continuous-time-event-modeling/rdr_2a4e68dfbd2740dd92cf7901e269e3ba},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_continuous_time_event_modeling_2a4e68df_v1,
  title = {continuous-time event modeling},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/continuous-time-event-modeling/rdr_2a4e68dfbd2740dd92cf7901e269e3ba/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}

See something wrong? Report a mistake