A Temporal Point Process (TPP) is a stochastic process that models a sequence of discrete events as random points in continuous time, fully characterized by its conditional intensity function λ(t|H_t). This function defines the instantaneous rate of event occurrence at time t given the complete history H_t of all preceding events, capturing self-exciting or self-correcting temporal dynamics.
Glossary
Temporal Point Process

What is Temporal Point Process?
A mathematical framework for modeling the timing of discrete events occurring in continuous time, characterized by a conditional intensity function that governs event likelihood.
Key variants include the Poisson process (constant intensity), Hawkes process (self-exciting with decaying influence from past events), and self-correcting processes (diminishing intensity after events). In sequential user behavior modeling, TPPs predict next-event timing and type, enabling real-time personalization engines to anticipate purchase likelihood, session abandonment, or optimal intervention moments.
Key Characteristics
The core mathematical and structural properties that define a Temporal Point Process and distinguish it from discrete-time sequence models.
Conditional Intensity Function
The fundamental building block of a TPP. This function, often denoted as λ(t|H_t), defines the instantaneous rate of event occurrence at time t given the entire history of past events H_t. Unlike a static Poisson rate, the intensity dynamically evolves after every observed event, capturing self-exciting or self-correcting behavior. It is the continuous-time analog of a hazard rate in survival analysis.
Continuous-Time Modeling
TPPs operate in continuous time, meaning events can occur at any instant on the real line. This is a critical distinction from discrete-time sequence models like RNNs, which operate on fixed time steps. The inter-event times are modeled as random variables drawn from a distribution, allowing the model to naturally handle irregularly sampled data without binning or imputation.
Marked Point Processes
A standard TPP can be extended to a Marked Point Process by associating a mark (e.g., item ID, event type, price) with each event time. The joint distribution of times and marks is modeled, often by factorizing the intensity into a ground intensity and a conditional mark distribution. This is essential for next-item recommendation where the mark is the product clicked.
Self-Exciting Processes (Hawkes)
A Hawkes process is a specific class of TPP where past events temporarily increase the conditional intensity, creating clustered event patterns. The influence decays over time via a triggering kernel. This is mathematically expressed as: λ(t) = μ + Σ α * exp(-β(t - t_i)). It models phenomena like viral social media cascades or bursts of trading activity.
Neural TPPs
Modern approaches replace fixed parametric forms of the intensity function with neural networks. Architectures like recurrent neural networks or transformers encode the event history H_t into a hidden state, which is then decoded into the intensity function parameters. This allows the model to learn complex, non-linear temporal dependencies directly from raw event sequences.
Likelihood-Based Learning
TPPs are typically trained by maximizing the log-likelihood of observing a sequence of event times. The log-likelihood decomposes into two terms: the sum of the log-intensity at event times, minus the integral of the intensity over the observation window. This integral, often called the compensator, acts as a normalizing constant and can be computationally challenging to approximate.
Frequently Asked Questions
Clear, technically precise answers to the most common questions about modeling event timing with stochastic point processes.
A temporal point process is a stochastic model for a sequence of discrete events occurring at random points in continuous time. It is fully characterized by its conditional intensity function λ*(t), which represents the instantaneous rate of event occurrence at time t given the complete history of all prior events. Unlike discrete-time sequence models that operate on fixed time steps, a point process models time as a continuous variable, making it ideal for irregularly spaced events like user clicks, purchases, or machine failures. The process works by defining this intensity function, which can depend on past events (self-exciting), external covariates (modulated), or baseline rates. Given the intensity, the likelihood of an observed event sequence can be computed exactly, enabling principled parameter estimation via maximum likelihood. Modern neural point processes parameterize λ*(t) using recurrent neural networks or transformers to capture complex, non-linear temporal dependencies in user behavior.
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Related Terms
Understanding temporal point processes requires familiarity with the mathematical and modeling frameworks that describe event timing, intensity, and sequential dependencies.
Conditional Intensity Function
The core mathematical object defining a temporal point process. It represents the instantaneous rate of event occurrence at time t given the entire history of past events up to that moment.
- Notation: λ*(t) = λ(t | H_t)
- Interpretation: λ*(t)dt is the probability of an event in [t, t+dt)
- Self-exciting processes: Past events increase λ*(t)
- Self-correcting processes: Past events decrease λ*(t)
This function fully characterizes the process and is the target of estimation in most modeling tasks.
Poisson Process
The simplest and most fundamental temporal point process, where events occur independently at a constant average rate.
- Homogeneous Poisson: Constant intensity λ, events are memoryless
- Non-homogeneous Poisson: Intensity λ(t) varies with time but not with event history
- Key property: The number of events in disjoint intervals are independent
- Limitation: Cannot capture clustering or inhibitory effects
Serves as the null model against which more complex self-exciting or self-correcting processes are compared.
Hawkes Process
A self-exciting temporal point process where each event increases the probability of future events in the near term, creating clustered event patterns.
- Intensity form: λ*(t) = μ + Σ α · exp(-β(t - t_i))
- μ: Baseline intensity
- α: Jump size (excitation strength)
- β: Decay rate of excitation
- Applications: Earthquake aftershock modeling, social media cascades, high-frequency trading, neural spike trains
Captures the 'rich-get-richer' temporal dynamics observed in many real-world phenomena.
Marked Temporal Point Process
An extension where each event carries an associated mark (category, value, or vector) alongside its timestamp, enabling joint modeling of when and what.
- Mark space: Can be discrete (user action type) or continuous (purchase amount)
- Conditional intensity: λ*(t, k) for mark type k
- Decomposition: λ*(t, k) = λ*(t) · p*(k | t)
- Use case: Modeling sequences of heterogeneous user actions (clicks, adds-to-cart, purchases) as a single unified process
Essential for next-event prediction tasks where both timing and event type matter.
Neural Temporal Point Process
Modern approaches that parameterize the conditional intensity function using deep neural networks instead of hand-crafted parametric forms.
- RNN-based: Use recurrent networks to encode event history H_t into a hidden state, then decode into λ*(t)
- Transformer-based: Apply self-attention over the event sequence for parallelized history encoding
- Advantage: Learn complex, non-linear dependencies from data without strong parametric assumptions
- Training: Maximum likelihood estimation over observed event sequences
Enables modeling of intricate user behavior patterns that classical parametric processes cannot capture.
Inter-Event Time Distribution
An alternative characterization of a temporal point process through the probability distribution of waiting times between consecutive events.
- Relationship to intensity: f(τ) = λ*(τ) · exp(-∫ λ*(s)ds)
- Exponential distribution: Implied by constant intensity (memoryless)
- Weibull distribution: Captures increasing or decreasing hazard rates
- Log-normal distribution: Common in human activity modeling
Useful for simulation, goodness-of-fit testing, and understanding the rhythm of user behavior patterns.

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us