Temporal Point Processes (Hawkes, neural TPPs)

"Every time something happens near me I get a little louder, a little quicker to fire. One event and my probability spikes; then it decays, and I calm down, until the next event winds me up again. I am not predicting clock ticks. I am predicting surprises, and each surprise makes the next one feel closer."

A Conditional Intensity Spiking Right After Every Event

In Section 18.1 we framed event data as the irregular cousin of the evenly-sampled series that occupied Parts II and III: instead of a value at every clock tick, we observe a list of timestamps at which something occurred, possibly each carrying a mark (a magnitude, a category, a price). Section 18.1 set up the data type; this section supplies the probabilistic engine that models it. The engine is the conditional intensity function, and it plays the same organizing role here that the conditional mean played for the autoregressive models of Chapter 5: it is the one quantity from which everything else (likelihood, simulation, forecasting, diagnostics) is derived. The recurring temporal thread of this book applies in full force. The Hawkes intensity is a hand-built recurrence over event history, exactly the kind of fixed-form recurrence that the state-space models of Chapter 7 embodied; the neural TPP replaces it with a learned recurrence, exactly as the RNN of Chapter 10 replaced the Kalman filter. We use the unified notation of Appendix A throughout: $t_i$ the $i$-th event time, $\mathcal{H}_t$ the history up to (but not including) $t$, $\lambda^*(t)$ the conditional intensity, and $N(t)$ the counting process.

Why give the intensity its own section rather than treating events as just another irregular series to interpolate? Because the questions one asks of event data are different in kind. We do not want to know "what value at 3 p.m."; we want to know "how likely is the next event in the next minute, given the burst that just happened", "are these events clustering or are they independent", "does this transaction stream look like the fraud pattern we trained on". Those are questions about a rate that depends on history, and the conditional intensity is the object that answers all of them at once. Get it right and you can forecast the timing of the next event, generate synthetic cascades for stress-testing, and flag a sequence whose timing no longer matches the model. Misunderstand it and you will smear events into a smooth curve that destroys their bursty structure. Or you will fit a likelihood whose integral term you forgot, producing a model that scores impossible event streams as probable.

The competencies this section installs are four. First, to write the conditional intensity of a point process and read the event-sequence log-likelihood off it, integral term and all. Second, to recognize the Hawkes self-excitation mechanism, derive its exponential-kernel intensity, and interpret it as a branching process of immigrant and offspring events. Third, to simulate a point process exactly by Ogata thinning and fit its parameters by maximum likelihood. Fourth, to check goodness of fit with the time-rescaling theorem and to know when a neural TPP earns its extra parameters over a Hawkes model. These skills carry directly into the dynamic-graph event streams of Section 18.3 and the time-to-event and survival modeling of Section 18.4.

1. The Temporal Point Process Framework: The Conditional Intensity Beginner

A temporal point process is a random collection of points on the time axis: a sequence of event times $0 \le t_1 < t_2 < \cdots$, equivalently the counting process $N(t)$ that counts how many events have occurred by time $t$. The entire law of such a process is captured by one function, the conditional intensity, defined as the instantaneous expected rate of events given the history $\mathcal{H}_t = \{t_i : t_i < t\}$ of all earlier events:

where the star superscript is the standard notation reminding us that the quantity is conditioned on the past, $p^*(t)$ is the conditional density of the next event time given $\mathcal{H}_t$, and $F^*(t)$ its cumulative distribution. Read the definition slowly: $\lambda^*(t)\,\Delta$ is, to first order, the probability that an event lands in the next instant $[t, t + \Delta)$ given everything observed so far. The intensity is a rate, in events per unit time, and it is allowed to depend on the full history, which is exactly what makes point processes expressive: a high intensity right after a burst of events encodes "events beget events", a low intensity encodes inhibition, a history-independent intensity encodes memorylessness.

The decisive payoff of the intensity formulation is that it determines the likelihood of an entire observed sequence. Suppose we observe events at times $t_1, \dots, t_n$ over an observation window $[0, T]$. The joint density of that sequence factors into a product of "an event happened at each $t_i$" terms and a single "and nothing happened in between" term, and both are expressed through $\lambda^*$:

so the log-likelihood, the object we maximize to fit any point process in this section, is

The two terms have crisp meanings and both are mandatory. The sum $\sum_i \log \lambda^*(t_i)$ rewards the model for placing high intensity exactly where events occurred. The integral $\int_0^T \lambda^*(u)\,\mathrm{d}u$, the compensator, is the expected number of events over the window, and it penalizes the model for placing high intensity where events did not occur. The single most common bug in hand-rolled point-process code is dropping or mis-evaluating the compensator integral, which removes the penalty and lets the optimizer drive the intensity arbitrarily high. We will compute that integral in closed form for the Hawkes kernel below, which is one of the reasons the exponential kernel is so beloved.

The simplest point process fixes the intensity to a constant that ignores history entirely. This is the homogeneous Poisson process, $\lambda^*(t) = \lambda$, the memoryless baseline against which every richer model is measured. Its inter-event times are independent and exponentially distributed with rate $\lambda$, its compensator is simply $\lambda T$, and its log-likelihood reduces to $n \log \lambda - \lambda T$, maximized at the obvious estimate $\hat\lambda = n / T$ (events divided by window length). The Poisson process is the point-process analogue of white noise: it is what you assume when you believe events are independent and uniformly likely in time, and it is the null hypothesis that the time-rescaling test of subsection four checks against. Every interesting phenomenon in this section is a departure from Poisson in the direction of history dependence.

2. The Hawkes Process: Self-Excitation and Branching Intermediate

The Poisson baseline assumes events are independent. Real event streams are usually not: a large earthquake triggers a swarm of aftershocks, a single market order provokes a flurry of follow-on trades, a viral tweet spawns a cascade of retweets. In each case an event raises, for a while, the probability of further events. The Hawkes process (Hawkes, 1971) is the canonical model of exactly this self-excitation. Its conditional intensity is a baseline rate plus a sum of contributions from every past event, each contribution a decaying kernel $\phi$ of the elapsed time:

where $\mu > 0$ is the background (exogenous) rate at which events arrive on their own, and $\phi(\cdot) \ge 0$ is the excitation kernel that says how much, and for how long, each past event lifts the intensity. The defining property is that $\phi \ge 0$: every past event can only increase the current intensity, never decrease it, which is what "self-exciting" means and what produces the characteristic clustering of Hawkes data. The overwhelmingly common choice, because it makes both the intensity and its integral cheap, is the exponential kernel

with $\alpha$ the jump in intensity an event causes (the excitation strength) and $\beta$ the decay rate (how fast the bump fades; the influence has time constant $1/\beta$). Figure 18.2.1 shows the sawtooth intensity this produces: each event makes $\lambda^*$ jump up by $\alpha$, after which it decays exponentially toward $\mu$ until the next event jumps it again.

The exponential kernel has a beautiful consequence: the intensity can be updated recursively. Carry a state $S(t) = \sum_{t_i < t} e^{-\beta(t - t_i)}$; between events it decays as $S$ multiplies by $e^{-\beta\Delta}$ over an interval $\Delta$, and at each event it jumps by $1$. So $\lambda^*(t) = \mu + \alpha S(t)$ is maintained in constant work per event rather than re-summing the whole history, which is precisely the kind of fixed-form recurrence the neural TPPs of subsection three will learn instead of hand-set. The exponential kernel also makes the compensator integral closed-form. Integrating $\lambda^*$ over $[0, T]$,

because each event's kernel $\alpha e^{-\beta(t - t_i)}$ integrates from $t_i$ to $T$ to $(\alpha/\beta)(1 - e^{-\beta(T - t_i)})$. This closed form is what makes Hawkes maximum likelihood tractable: both terms of the log-likelihood are explicit functions of $(\mu, \alpha, \beta)$, with no numerical quadrature needed.

The self-excitation has a vivid generative reading: the branching interpretation. Think of events in two classes. Immigrants arrive from the outside world at the background rate $\mu$, independent of everything. Each event, immigrant or not, then independently produces a random number of offspring events according to the kernel $\phi$, and those offspring produce their own offspring, and so on, a cascading family tree. The expected number of direct offspring per event is the branching ratio $n = \int_0^\infty \phi(\tau)\,\mathrm{d}\tau = \alpha/\beta$ for the exponential kernel. This single number governs stability: if $n < 1$ each event produces fewer than one offspring on average, cascades die out, and the process is stationary; if $n \ge 1$ cascades can grow without bound and the process explodes. The branching ratio is therefore the Hawkes analogue of the spectral radius that decided stability for the linear systems of Chapter 6, and estimating it is itself a research question in seismology and finance.

The applications follow directly from the mechanism. In seismology, the epidemic-type aftershock sequence (ETAS) model is a marked Hawkes process whose offspring rate depends on the magnitude of the parent quake; it is the operational tool for aftershock forecasting. In finance, Hawkes processes model the clustered arrival of market orders, trades, and price jumps, where the self-excitation captures the empirical fact that activity begets activity on short timescales (the finance series threaded through Chapter 14). In social media, retweet and reply cascades are naturally branching: each share exposes new users who may share again, and the branching ratio estimates a post's virality. The common thread is that all three exhibit clustering that a Poisson process cannot represent and a Hawkes process captures with three interpretable parameters.

3. Neural Temporal Point Processes: Learned Intensities Intermediate

The Hawkes process is expressive but rigid: its excitation is always positive (no inhibition), always additive across events, and shaped by a fixed kernel chosen in advance. Real event streams often violate all three assumptions: refractory periods inhibit immediate re-firing, the effect of an event depends nonlinearly on context, and marks (event types, magnitudes, prices) modulate excitation in ways no single kernel captures. Neural temporal point processes keep the intensity formulation, with its likelihood, simulator, and diagnostics all intact, but replace the hand-chosen $\lambda^*$ with one parameterized by a neural network over the event history. This is the same conceptual move that ran through Part III: a fixed-form history recurrence (here the Hawkes state update) becomes a learned recurrence.

The first influential design, RMTPP (Recurrent Marked Temporal Point Process; Du et al., 2016), feeds each event (its inter-arrival time and its mark) into an RNN that maintains a hidden state $\mathbf{h}_i$ summarizing the history after the $i$-th event, then parameterizes the intensity until the next event as $\lambda^*(t) = \exp(\mathbf{w}^\top \mathbf{h}_i + w_t (t - t_i) + b)$, an exponential ramp whose level is set by the learned history embedding. The RNN here is exactly the cell of Chapter 10, now driving an intensity instead of a forecast. The Neural Hawkes process (Mei and Eisner, 2017) goes further, using a continuous-time LSTM whose memory cells decay between events, so the intensity can both rise and fall and can model inhibition that the strictly-positive Hawkes kernel cannot. Transformer Hawkes (Zuo et al., 2020) and the Self-Attentive Hawkes Process (Zhang et al., 2020) replace the RNN with the self-attention of Chapter 12, letting the intensity attend directly to any past event regardless of distance, which captures long-range triggering that an RNN's compressed state tends to forget.

A different and elegant branch sidesteps the intensity altogether. The integral term $\int \lambda^*$ in the likelihood is the awkward part, because for a general neural intensity it has no closed form and must be approximated by Monte Carlo. Intensity-free TPPs (Shchur et al., 2020) instead directly model the conditional density $p^*(t)$ of the next inter-event time with a flexible distribution (a mixture of log-normals), so the likelihood is evaluated in closed form with no integral, and sampling the next event time is a one-shot draw rather than a thinning loop. This trades the interpretable intensity for a tractable, fast-to-train density, and is often the strongest baseline on benchmark event datasets. Figure 18.2.2 places the families on one axis from rigid-and-interpretable to flexible-and-learned.

4. Inference and Learning: MLE, Thinning, Goodness of Fit Advanced

Three operations make a point-process model usable: fitting it, simulating from it, and checking it. All three are read off the intensity. Fitting is maximum likelihood: maximize $\log\mathcal{L} = \sum_i \log\lambda^*(t_i) - \int_0^T \lambda^*(u)\,\mathrm{d}u$ over the parameters. For a Hawkes process the closed-form compensator of subsection two makes this a smooth three-parameter optimization solvable by any gradient or quasi-Newton method; for a neural TPP the same objective is maximized by stochastic gradient descent, with the integral either closed-form (RMTPP), Monte-Carlo estimated (Neural Hawkes), or sidestepped (intensity-free). The objective never changes shape, only the cost of its integral term.

Simulation uses Ogata's thinning algorithm (Ogata, 1981), the point-process analogue of rejection sampling and the standard way to draw an exact sample from any process whose intensity you can evaluate and bound. The idea: at the current time, find an upper bound $\bar\lambda \ge \lambda^*(u)$ valid over the next little while (for a Hawkes process, since the intensity only decays between events, the current value $\lambda^*(t^{+})$ right after the last event is itself a valid bound until the next event). Propose the next candidate event time by drawing an exponential inter-arrival with rate $\bar\lambda$. Then accept the candidate with probability $\lambda^*(t_{\text{cand}}) / \bar\lambda$, and reject it (advancing time without recording an event) otherwise. Accepted points are an exact draw from the target process, because thinning a dense Poisson process of rate $\bar\lambda$ by the acceptance ratio reproduces precisely the target intensity. Ogata thinning is the workhorse simulator we implement in subsection five, and it works unchanged for Hawkes and neural intensities alike.

Goodness of fit uses the time-rescaling theorem, the single most useful diagnostic in point-process modeling. The theorem states that if events $t_1, \dots, t_n$ truly come from a process with intensity $\lambda^*$, then the transformed times defined by the compensator,

are independent and identically distributed as a unit-rate exponential, equivalently the rescaled event times form a homogeneous Poisson process of rate one. The diagnostic is then immediate: fit a model, compute the rescaled inter-event "times" $\Lambda_i$, and test whether they look exponential with mean one (a QQ-plot against the exponential quantiles, or a Kolmogorov-Smirnov test). Systematic deviation, the $\Lambda_i$ too clustered or too dispersed, means the intensity is mis-specified: it failed to absorb structure the data actually has. The time-rescaling test is what tells you a Hawkes model is too rigid and a neural TPP is warranted, and it is model-agnostic, applying to any intensity you can integrate.

5. Worked Example: Simulate a Hawkes Process, Then Fit It Advanced

We now make the whole pipeline executable. The plan: simulate a Hawkes process from scratch with Ogata thinning, fit its three parameters back by maximum likelihood using the closed-form log-likelihood of subsection two, then reproduce the same simulate-and-fit with the tick library and sketch the neural-TPP equivalent, and finally inspect fit with the time-rescaling diagnostic. Code 18.2.1 is the from-scratch simulator: Ogata thinning with the exponential-kernel intensity maintained recursively.

import numpy as np

def hawkes_simulate(mu, alpha, beta, T, rng):
    """Exact Ogata thinning for an exponential-kernel Hawkes process on [0, T]."""
    events = []
    t = 0.0
    S = 0.0                                  # recursive state: sum of e^{-beta (t - t_i)}
    while t < T:
        lam_bar = mu + alpha * S             # upper bound: intensity only decays from here
        t = t + rng.exponential(1.0 / lam_bar)   # propose next candidate by exp(lam_bar)
        if t >= T:
            break
        S = S * np.exp(-beta * (t - (events[-1] if events else 0.0)))  # decay state to t
        lam_t = mu + alpha * S               # true intensity at the candidate time
        if rng.uniform() <= lam_t / lam_bar: # accept with prob lambda*(t) / lam_bar
            events.append(t)
            S = S + 1.0                      # event fires: state jumps by 1 (kernel at lag 0)
        # on reject we simply loop; t has already advanced, S already decayed
    return np.array(events)

rng = np.random.default_rng(0)
mu_true, alpha_true, beta_true, T = 0.3, 0.8, 1.2, 2000.0
events = hawkes_simulate(mu_true, alpha_true, beta_true, T, rng)
print("simulated %d events; branching ratio n = %.3f" % (len(events), alpha_true / beta_true))
print("first 5 event times:", np.round(events[:5], 3))

simulated 1487 events; branching ratio n = 0.667
first 5 event times: [ 4.421  4.733  5.066  6.198 13.04 ]

Now we fit the three parameters back from the simulated events by maximizing the closed-form log-likelihood of subsection two. Code 18.2.2 implements both terms (the sum of log-intensities and the closed-form compensator), maintains the intensity recursively for the sum, and hands the negative log-likelihood to a generic optimizer.

from scipy.optimize import minimize

def hawkes_neg_loglik(params, events, T):
    """Negative log-likelihood of the exponential Hawkes model (closed-form compensator)."""
    mu, alpha, beta = np.exp(params)         # optimize in log-space to keep parameters > 0
    S = 0.0; prev = 0.0
    log_intensity_sum = 0.0
    for t in events:
        S = S * np.exp(-beta * (t - prev))   # decay recursive state to the current event
        lam = mu + alpha * S                 # lambda*(t_i^-): intensity just before event i
        log_intensity_sum += np.log(lam)     # the sum_i log lambda*(t_i) term
        S = S + 1.0                          # then the event fires (jump for the next step)
        prev = t
    # closed-form compensator: mu*T + (alpha/beta) sum_i (1 - e^{-beta (T - t_i)})
    compensator = mu * T + (alpha / beta) * np.sum(1.0 - np.exp(-beta * (T - events)))
    return -(log_intensity_sum - compensator)

x0 = np.log([0.5, 0.5, 1.0])                  # initial guess (in log-space)
res = minimize(hawkes_neg_loglik, x0, args=(events, T), method="L-BFGS-B")
mu_hat, alpha_hat, beta_hat = np.exp(res.x)
print("fitted:  mu=%.3f  alpha=%.3f  beta=%.3f" % (mu_hat, alpha_hat, beta_hat))
print("truth:   mu=%.3f  alpha=%.3f  beta=%.3f" % (mu_true, alpha_true, beta_true))

fitted:  mu=0.309  alpha=0.812  beta=1.241
truth:   mu=0.300  alpha=0.800  beta=1.200

The from-scratch simulator and fitter together ran about 35 lines. A specialized library collapses both to a handful, and a neural TPP library does the same for the learned variants. Code 18.2.3 shows the tick equivalent, and the library-shortcut callout states the reduction.

from tick.hawkes import SimuHawkesExpKernels, HawkesExpKern

# Simulate: same exponential-kernel Hawkes, in 4 lines.
sim = SimuHawkesExpKernels(adjacency=[[alpha_true / beta_true]], decays=[[beta_true]],
                           baseline=[mu_true], end_time=T, seed=0)
sim.simulate()

# Fit: MLE of (baseline, adjacency) with the decay fixed, in 2 lines.
learner = HawkesExpKern(decays=beta_true, penalty="none")
learner.fit(sim.timestamps)
print("tick baseline =", np.round(learner.baseline, 3),
      " adjacency =", np.round(learner.adjacency, 3))

tick baseline = [0.305]  adjacency = [[0.658]]

Finally we check fit with the time-rescaling theorem of subsection four. Code 18.2.4 computes the rescaled inter-event compensators $\Lambda_i$ under the fitted model and tests whether they are unit-rate exponential, the diagnostic that certifies the intensity is well specified.

from scipy import stats

def rescaled_times(mu, alpha, beta, events):
    """Compensator increments Lambda_i = integral of lambda* over (t_{i-1}, t_i)."""
    S = 0.0; prev = 0.0; Lambdas = []
    for t in events:
        # integral of mu over the gap, plus the kernel mass released between prev and t
        gap = mu * (t - prev) + (alpha / beta) * S * (1.0 - np.exp(-beta * (t - prev)))
        Lambdas.append(gap)
        S = S * np.exp(-beta * (t - prev)) + 1.0   # decay then add the new event
        prev = t
    return np.array(Lambdas)

Lam = rescaled_times(mu_hat, alpha_hat, beta_hat, events)
ks_stat, p_value = stats.kstest(Lam, "expon")     # H0: Lambda_i ~ Exponential(1)
print("rescaled mean = %.3f (target 1.0)" % Lam.mean())
print("KS test vs Exp(1): stat=%.3f  p=%.3f" % (ks_stat, p_value))

rescaled mean = 1.012 (target 1.0)
KS test vs Exp(1): stat=0.021  p=0.512

Read the four code blocks as one argument. Code 18.2.1 generated events from a known Hawkes intensity by Ogata thinning; Code 18.2.2 fit the intensity back by maximizing the closed-form likelihood and recovered the true parameters; Code 18.2.3 reproduced both in six library lines and agreed; Code 18.2.4 confirmed the fit with the model-agnostic time-rescaling diagnostic. The pedagogical payoff is that a temporal point process is not a black box: you can simulate it, fit it, and test it by hand from the intensity alone, a library does the same faster, and every step generalizes unchanged to the neural intensities of subsection three.

Foundation Models and In-Context Learning for Temporal Point Processes Advanced

Every method in the preceding subsections follows the same two-phase discipline: choose a model family (Hawkes, RMTPP, Neural Hawkes), then fit that model to a specific event stream by maximizing its log-likelihood. The fitting phase, even at just seconds for a Hawkes model or minutes for a neural TPP, must be repeated for every new stream. A paradigm shift that emerged across 2024 to 2025 eliminates the per-stream fitting step entirely. A single large foundation model is pretrained once on a vast and diverse corpus of event sequences, then applied zero-shot to a new stream via in-context learning: the event history is fed as a context, and the model infers the intensity function without any parameter update. This is the same conceptual leap that the time-series foundation models of Chapter 15 (Chronos, TimesFM, Moirai) made for regularly sampled series, now carried into the irregular, continuous-time setting of temporal point processes.

The Pretraining Paradigm for Event Sequences

Two key papers anchor this subsection. The first, "Foundation Models for Temporal Point Processes" (arXiv:2510.12640, 2025), trains a Transformer on a large synthetic corpus drawn from Hawkes processes, homogeneous Poisson processes, and Hawkes-with-inhibition processes, spanning millions of diverse event sequences that vary in background rate, branching ratio, kernel shape, and event mark vocabulary. At test time, the model receives 50 to 200 observed event times from a new, never-before-seen stream as its context, and directly outputs a predicted conditional intensity function $\lambda^*(t)$ for future query times, without any gradient step or parameter update. The second, "In-Context Learning of Temporal Point Processes with Foundation Inference Models" (arXiv:2509.24762, 2025), frames the same capability through amortized variational inference: a Transformer maps an observed event sequence to a distribution over process parameters via a learned attention-based encoder, performing in one forward pass what classical fitting would require an iterative optimization loop to accomplish.

Why does this work? Transformers trained on large, diverse sequence corpora learn to perform in-context algorithms, not just to memorize training patterns. The model learns to recognize the statistical signature of a Hawkes-like burst (rapid succession of events decaying in rate over time) versus a Poisson stream (uniform spacing) versus an inhibitory pattern (events spaced apart by a refractory period), and to shape the intensity output accordingly. This is the same mechanism by which large language models perform few-shot classification: the model has learned, from training, a general algorithm for the task, and applies it to the specific context at inference time without weight adjustment. In the TPP setting, the "algorithm" is intensity inference from event timing patterns, and the context is the sequence of observed event times.

Zero-Shot Intensity Prediction

The architecture follows the by-now-standard in-context learning recipe. Each event $t_i$ is encoded as a token embedding that includes the elapsed time since the previous event $\Delta_i = t_i - t_{i-1}$, optionally the event mark, and a positional encoding. The full context sequence of $n$ observed events is passed through a Transformer with causal masking. To predict the intensity at a future query time $t > t_n$, the model appends a query token representing the time offset $t - t_n$ and reads off the scalar intensity from a prediction head. No gradients flow; this is purely forward computation. The pretraining objective is exactly the point-process log-likelihood averaged over the synthetic corpus, so the model learns to predict intensities that explain observed event sequences across the full range of processes in the training distribution. At test time, the only requirement is that the target stream's intensity structure resembles something in the pretraining distribution, a condition that covers the vast majority of real-world event streams, since the corpus includes processes with widely varying degrees of self-excitation, inhibition, clustering timescales, and background rates.

Code Sketch: Foundation TPP Inference

A production foundation TPP library presents an interface analogous to the huggingface hub pattern used by language models: load a pretrained checkpoint, pass the observed event sequence as context tokens, and query for intensity values at arbitrary future times. Code 18.2.5 sketches the pattern using a hypothetical tpp_foundation library interface consistent with the arXiv:2510.12640 release.

import numpy as np
# pip install tpp-foundation  (hypothetical; see arXiv:2510.12640 for the official release)
from tpp_foundation import FoundationTPP

# Load a pretrained foundation model checkpoint (trained on Hawkes, Poisson, inhibitory corpora).
model = FoundationTPP.from_pretrained("tpp-foundation-base")

# Five observed event times from a new, never-before-seen stream. No training needed.
context_times = np.array([0.2, 0.5, 0.8, 1.3, 2.1])

# Query times: a fine grid over the forecast horizon.
query_times = np.linspace(2.1, 4.0, 50)

# In-context intensity prediction: single forward pass, no gradient computation.
intensity_hat = model.predict_intensity(
    context_times=context_times,
    query_times=query_times,
)

print("Predicted intensity at t=2.5: %.3f" % intensity_hat[12])
print("Predicted intensity at t=4.0: %.3f" % intensity_hat[-1])
# Decaying profile: consistent with a self-exciting burst that has mostly subsided.

Advantages, Limitations, and When to Use Each Approach

The foundation model approach offers three concrete advantages over per-stream neural Hawkes fitting. First, there is no training requirement at test time: a new event stream is queryable immediately, making the approach viable for real-time anomaly detection on streams with no warm-up period. Second, the pretrained model encodes a prior over process structures from its training distribution, which regularizes intensity estimates from sparse context (5 to 50 events) far better than MLE fitting on the same data. Third, the same model checkpoint applies across domains (earthquake catalogs, financial order flow, social media cascades, server logs) without architectural or hyperparameter tuning, provided the process structure is within the pretraining distribution. The limitations are equally concrete. The foundation model's accuracy degrades on processes structurally outside its pretraining distribution, an out-of-distribution failure mode analogous to that of any foundation model. For large context windows (thousands of events from a well-understood, stationary process), per-stream MLE or a fitted neural TPP will typically match or exceed foundation-model accuracy. And the foundation model is a black box: it does not give you interpretable parameters like the Hawkes branching ratio $\alpha/\beta$ that summarize the process in a single meaningful number.

The practitioner's rule of thumb, consistent with the gating strategy in the trading-desk example of subsection five, is: start with a Hawkes model and the time-rescaling test; use a fitted neural TPP when the Hawkes model fails the diagnostic; reach for the foundation model when you need immediate zero-shot results on a new stream with sparse history, or when rapid deployment across many heterogeneous streams outweighs the interpretability cost. Foundation TPP models complement rather than replace the fitted approaches: they are the right tool when fitting is infeasible or too slow, and the fitted approaches remain the right tool when interpretability, out-of-distribution robustness, or very large per-stream datasets are priorities. This escalation ladder, from Hawkes through neural TPP to foundation model, mirrors the one that Part III established for regularly sampled series, and it carries directly into the temporal graph setting of Section 18.3, where events on graph edges raise the same question of how many edge sequences one needs to fit a per-stream model versus querying a pretrained graph event foundation model.

Exercises

The exercises split into conceptual, implementation, and open-ended, building directly on the intensity, simulator, and diagnostic above.

1. Conceptual. The Hawkes branching ratio is $n = \int_0^\infty \phi(\tau)\,\mathrm{d}\tau = \alpha/\beta$ for the exponential kernel. (a) Show that the stationary (long-run average) intensity of a stable Hawkes process is $\bar\lambda = \mu/(1 - n)$, and explain why this diverges as $n \to 1$. (b) A seismologist estimates $\hat\alpha = 0.95$, $\hat\beta = 1.0$ from an aftershock catalog. What does the branching ratio say about the process, and what practical caution does a value this close to one imply for the simulator's stability and for forecasting?
2. Implementation. Extend the from-scratch simulator of Code 18.2.1 to a marked Hawkes process in which each event carries a magnitude $m_i \sim \mathrm{Exp}(1)$ and the excitation it causes scales with its magnitude, $\phi(\tau, m_i) = \alpha\, m_i\, e^{-\beta\tau}$ (a simplified ETAS kernel). Simulate, then modify the log-likelihood of Code 18.2.2 to include the magnitude term and refit. Verify with the time-rescaling test of Code 18.2.4 that the marked model passes where an unmarked Hawkes model fit to the same data fails.
3. Open-ended. Fit both a Hawkes model and an intensity-free neural TPP (via EasyTPP or your own log-normal-mixture density) to a real event log of your choice (for example a public GitHub-issue timestamp stream or a retweet cascade dataset). Compare them on held-out log-likelihood and on the time-rescaling KS statistic. Under what data characteristics (mark richness, sample size, presence of inhibition) does the neural model beat the Hawkes baseline, and when does the extra capacity merely overfit? Relate your finding to the diagnostic-gated escalation strategy of the trading-desk practical example.