A Hawkes process is a self-exciting temporal point process where the occurrence of an event increases the conditional intensity function, thereby elevating the probability of future events in the near term. This positive feedback loop captures bursty behavior and clustering phenomena, making it distinct from memoryless Poisson processes. The intensity at any time t is modeled as a baseline rate plus a weighted sum of the influence of all past events, where influence decays over time via a kernel function.
Glossary
Hawkes Process

What is a Hawkes Process?
A Hawkes process is a mathematical model for events that cluster in time, where each occurrence temporarily raises the probability of subsequent events.
In financial fraud detection, Hawkes processes model the inter-arrival times of transactions to identify anomalous bursts of activity characteristic of account takeover or coordinated attacks. The self-exciting property naturally captures the rapid, repeated attempts seen in credential stuffing or high-velocity transfer schemes. By fitting a Hawkes model to normal user behavior, deviations in the branching ratio—the expected number of events triggered by a single event—serve as a robust sequence anomaly score, flagging sessions where one suspicious action cascades into many.
Key Characteristics of Hawkes Processes
A Hawkes process is a temporal point process where each event triggers a temporary increase in the probability of subsequent events. This self-exciting property makes it uniquely suited for modeling bursty, clustered behaviors in financial transaction streams.
Self-Exciting Mechanism
The defining property of a Hawkes process is that the occurrence of an event elevates the conditional intensity function for a finite period afterward. In fraud detection, a rapid series of small-amount transactions (card testing) excites the model, making it anticipate further fraudulent attempts. The intensity λ(t) is modeled as:
λ(t) = μ + Σ α · g(t - tᵢ)
- μ: Baseline intensity (normal activity rate)
- α: Excitation strength (how much one event triggers others)
- g(t - tᵢ): Decay kernel (how quickly the excitation fades)
This captures the intuitive reality that fraud events are rarely isolated—they cluster in time.
Branching Structure Interpretation
Hawkes processes can be understood through a branching process metaphor, where each event is either an immigrant (arriving independently via the baseline rate μ) or an offspring (triggered by a prior event). This creates a causal, tree-like structure:
- Immigrant events: Represent the background noise of normal, uncorrelated activity
- Offspring events: Represent triggered, correlated activity—the hallmark of coordinated fraud
The branching ratio (n = ∫ g(t) dt) determines whether the process is subcritical (n < 1, dies out), critical (n = 1), or supercritical (n > 1, explodes). Most financial fraud models operate in the subcritical regime, where bursts are self-limiting.
Exponential Decay Kernel
The most common excitation kernel is the exponential decay function: g(t) = α · e^(-βt), where β controls the decay rate. This choice is computationally advantageous because it renders the intensity process Markovian—the future depends only on the current intensity, not the full history.
Key implications for transaction modeling:
- High β: Excitation decays rapidly; only very recent events matter (e.g., velocity checks over seconds)
- Low β: Excitation persists longer; captures slower-burn fraud patterns (e.g., credential stuffing over hours)
- The half-life of excitation is ln(2)/β, providing an interpretable timescale for risk windows
Multivariate Hawkes for Cross-Channel Fraud
A multivariate Hawkes process extends the framework to multiple interacting event types, where events of type j can excite events of type i through a mutually exciting matrix αᵢⱼ. This is critical for detecting cross-channel fraud:
- A password reset (type A) may excite a beneficiary change (type B)
- A login from a new device (type C) may excite a wire transfer (type D)
- The excitation matrix α captures these causal dependencies between event types
This allows the model to learn that certain sequences of seemingly benign actions are precursors to fraud, even when each action individually appears normal.
Parameter Estimation via Maximum Likelihood
Hawkes process parameters (μ, α, β) are typically estimated using maximum likelihood estimation (MLE). The log-likelihood for a Hawkes process over interval [0, T] with events at times t₁, t₂, ..., tₙ is:
L = Σ log λ(tᵢ) - ∫₀ᵀ λ(t) dt
- The first term rewards high intensity at actual event times
- The second term penalizes high intensity everywhere else (preventing trivial solutions)
- Optimization is performed via gradient descent or expectation-maximization
For streaming fraud applications, online Bayesian updating can adapt parameters as new transactions arrive, enabling the model to track evolving fraudster behavior without full retraining.
Goodness-of-Fit: Residual Analysis
Validating a fitted Hawkes process relies on the random time change theorem: if the model is correct, transforming event times by the cumulative intensity τᵢ = ∫₀ᵗⁱ λ(s) ds yields a unit-rate Poisson process. The transformed inter-arrival times should be i.i.d. Exponential(1).
Diagnostic checks include:
- QQ-plots of transformed residuals against the exponential distribution
- Kolmogorov-Smirnov tests for uniformity
- Inspection of the compensator for deviations from linearity
These tests ensure the model adequately captures the temporal clustering structure and is not missing systematic patterns in the transaction stream.
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.
Frequently Asked Questions
Clear, technical answers to the most common questions about self-exciting point processes and their application in financial fraud detection and high-frequency event modeling.
A Hawkes Process is a self-exciting temporal point process where the occurrence of an event instantaneously increases the conditional intensity—the probability of observing another event in the immediate future. Unlike a homogeneous Poisson process where events occur independently at a constant rate, the Hawkes process models events that cluster or burst together in time.
Mathematically, the conditional intensity function λ(t) is defined as:
codeλ(t) = μ + Σ α · exp(-β(t - t_i))
Where:
μ(mu) is the baseline intensity—the background rate of events occurring spontaneously.α(alpha) is the excitation factor—the magnitude of the instantaneous jump in intensity after each event.β(beta) is the decay rate—how quickly the self-exciting effect diminishes back toward baseline.- The summation runs over all past events
t_ioccurring before timet.
Each event triggers an exponentially decaying boost to the intensity, and these boosts stack additively. This creates realistic clustering behavior: a rapid succession of transactions in a short window drives the intensity higher, making further events more probable, until the excitation decays and the process returns to its baseline rate. The branching ratio n = α/β determines whether the process is subcritical (n < 1, eventually dies out) or supercritical (n > 1, explodes).
Related Terms
The Hawkes process is a foundational self-exciting model. Understanding its ecosystem requires familiarity with the broader family of temporal point processes, their neural extensions, and the sequence modeling architectures that compete with or complement them.
Temporal Point Process (TPP)
The probabilistic framework for modeling event sequences in continuous time. A TPP is defined by its conditional intensity function λ(t), which represents the instantaneous rate of events given the history. The Hawkes process is a specific TPP where λ(t) depends on past events. Key components include:
- Inter-arrival time: The duration between consecutive events
- Counting process N(t): The number of events up to time t
- Marked TPPs: Each event carries auxiliary information (e.g., transaction amount)
Poisson Process
The simplest temporal point process and the baseline against which self-exciting behavior is measured. In a homogeneous Poisson process, events occur independently with a constant intensity λ. The inter-arrival times are exponentially distributed. When fraud detection models assume transaction arrivals are memoryless, they miss the bursty clustering that Hawkes processes explicitly capture. The inhomogeneous Poisson process allows λ(t) to vary with time but still lacks self-excitation.
Neural Hawkes Process
A modern extension where the intensity function is parameterized by a neural network rather than a fixed parametric form. This allows the model to learn complex, non-linear excitation dynamics from data. Architectures include:
- Recurrent Neural Hawkes: Uses an LSTM or GRU to summarize the event history into a hidden state that drives λ(t)
- Transformer Hawkes: Employs self-attention to capture long-range triggering dependencies
- Neural Jump SDEs: Models intensity as a stochastic differential equation with jumps at event times
Self-Attention for Sequences
The core mechanism behind Transformer architectures that computes a weighted representation of each event by attending to all other events in the sequence. For fraud detection, self-attention allows a model to directly connect a current suspicious transaction to a distantly related past event without the gradual information decay of recurrent models. The attention weights can be visualized to explain which historical transactions most influenced a fraud alert.
Marked Temporal Point Process
A TPP where each event carries a mark — additional data beyond the timestamp. In financial fraud, marks include transaction amount, merchant category, device ID, and location. A marked Hawkes process models how the magnitude and type of an event influence future excitation. A large wire transfer may trigger a higher intensity spike than a small purchase, and the mark distribution itself can be anomalous even if the timing is normal.
Change Point Detection
Algorithms that identify abrupt shifts in the statistical properties of a time series. While Hawkes processes model smooth self-excitation, change point detection flags moments when the entire data-generating process changes — such as an account takeover where the user's transaction rhythm fundamentally shifts. Combining both approaches provides a layered defense: Hawkes for burst detection, change point for regime shifts.

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