---
kind: concept
slug: temporal-point-process
title: Temporal point process
summary: >-
  Modelling when timestamped events happen, through a conditional intensity that depends on past events (Hawkes-style kernels). Covers the kernel parametrisation, the likelihood and positivity choices, and graph-aware variants. One card so far (GraDK); all reported results are author-reported.
tags: [point-process, hawkes-process, intensity-model, graph]
papers: ["2306.11313"]
related: [graph-neural-network, graph-structure-learning, survival-analysis]
status: draft
updated_at: 2026-11-06
---

## Overview

A temporal point process models when events happen. Its central object is the
conditional intensity λ(t): the rate at which the next event is expected at
time t, given the events before t. In the Hawkes-style family, a base rate μ
is raised or lowered by one term per past event, and each term is an influence
kernel that depends on how long ago that event was [arxiv:2306.11313 §2]
[eq. 2]. The likelihood of an observed sequence combines the intensity at each
event time with the intensity integrated over the observation window
[arxiv:2306.11313 §3.4].

Two points hold for every variant. First, the intensity must stay positive. A
kernel that can go negative (to model inhibition) makes this a real
constraint, and the card enforces it with a log-barrier evaluated on a grid of
times and nodes [arxiv:2306.11313 §3.4]. Second, when events sit at nodes of a
graph, the kernel also depends on which node caused the event and which node it
affects [arxiv:2306.11313 §3.3].

## Variants

### Low-rank graph kernel (GraDK)

The kernel is a low-rank sum over pairs of temporal basis functions and graph
filter bases. Each temporal basis is a sum of products of a function of the
past event time and a function of the lag t − t' [arxiv:2306.11313 §3.2]. The
graph basis is a set of localised filters on the graph [arxiv:2306.11313 §3.3].
The paper's own runs use two filter families: L3Net, where the filter reaches
neighbours up to a set order, and GAT, where the filter is learned
[arxiv:2306.11313 app. B] [arxiv:2306.11313 app. C]. Card:
[Deep graph kernel point processes over networks](/papers/2306.11313).

Its loss is either the negative log-likelihood (NLL) or a least-squares (LS)
objective, and the paper reports both [arxiv:2306.11313 §3.4]. The two losses
give close results on most sets (see the contradictions below).

### Non-graph and Euclidean baselines (named, no card here)

The paper compares against neural point processes (RMTPP, FullyNN, DNSK-mtpp,
THP-S, SAHP-G) on graph data [arxiv:2306.11313 §4], and against classical or
spatio-temporal models (MHP, ETAS, DNSK-stpp) on wildfire and theft data using
Euclidean distances [arxiv:2306.11313 tab. 2]. None of these has a card in this
wiki, so this page reports only the paper's numbers for them and does not
describe their methods.

## When to use which

Only one card supports this page, so the table reflects that paper's reported
results. Every number is author-reported and comes from its own experiments.

| Situation | Use | Why |
|---|---|---|
| Events on a known network, where influence may spread over several hops | GraDK with L3Net filters | The paper uses L3Net when the graph is known [arxiv:2306.11313 §3.3]. With NLL on the 16-node synthetic set it gives Time MAE 0.028, against 0.085 for DNSK-mtpp [arxiv:2306.11313 tab. 1]. |
| Network structure is unknown and must be learned | GraDK with GAT, or check the paper's numbers first | GAT is the paper's choice when the graph must be learned [arxiv:2306.11313 §3.3]. On the 16-node set its Time MAE is 0.148 against 0.028 for L3Net with NLL [arxiv:2306.11313 tab. 1]. |
| Tight parameter budget on a larger graph | GraDK | On wildfire it has 411 parameters against 4742 for DNSK-stpp, with lower Time MAE (0.580 against 0.861) [arxiv:2306.11313 tab. 2]. |
| Best likelihood on Sepsis or Theft | Consider SAHP-G | On both sets SAHP-G has a higher testing log-likelihood than any GraDK row [arxiv:2306.11313 tab. 3]. The authors argue that prediction error matters more there [arxiv:2306.11313 app. H]. |
| Need for the exact shipped results | Not supported by the paper alone | Several constants are not stated in the paper (see Hyperparameters on the card), and the code differs from the paper (see Contradictions). |

The paper's wildfire ablation supports keeping the displacement form of the
temporal basis: using the raw time t instead of the lag t − t' gives worse Time
MAE on the 16-node set (0.107 against 0.028) [arxiv:2306.11313 app. H.5].

## Implementation sketch

The sketch uses the paper's intensity form and likelihood. It is not the
authors' code. Basis functions are small networks; the constants are the
paper's own choices or are left open.

```pseudocode
# Conditional intensity at node v and time t  [arxiv:2306.11313 eq. 2]
# history: list of (t_j, v_j) with t_j < t
def intensity(t, v, history, mu):
    # Start from the base rate, then add one kernel term per past event
    rate = mu
    for t_j, v_j in history:
        rate += kernel(t_j, t - t_j, v_j, v)
    return rate
```

```pseudocode
# Low-rank kernel: sum over temporal and graph basis pairs  [arxiv:2306.11313 eq. 4]
# lag is t - t_j; B[r] is a graph filter matrix over nodes
def kernel(t_j, lag, v_j, v):
    total = 0.0
    for r in range(R):
        for l in range(L):
            # Weight alpha[r, l] times the past-time basis psi_l, the lag
            # basis phi_l, and the graph basis B_r for the node pair
            total += alpha[r, l] * psi[l](t_j) * phi[l](lag) * B[r][v_j, v]
    return total
```

```pseudocode
# Negative log-likelihood of one sequence on [0, T]  [arxiv:2306.11313 §3.4]
# events: list of (t_i, v_i); grid: sampled (t, v) pairs for the integral
def nll(events, T, grid):
    # Log term: intensity at each observed event, with its own history
    log_sum = 0.0
    for t_i, v_i in events:
        log_sum += log(intensity(t_i, v_i, history_before(t_i)))
    # Compensator: intensity integrated over time and nodes (grid approx.)
    integral = 0.0
    for t, v, weight in grid:
        integral += intensity(t, v, history_before(t)) * weight
    return integral - log_sum
```

The paper adds a log-barrier term to keep the intensity above a bound on a
grid, and it lowers the bound and the barrier weight over epochs
[arxiv:2306.11313 §3.4] [arxiv:2306.11313 app. F]. The paper leaves the grid
sizes, the barrier constants and the maximum lag unstated [arxiv:2306.11313
app. E].

## Contradictions

- **Optimiser.** The paper states Adam with learning rate 1e-2 [arxiv:2306.11313
  app. H], and its Algorithm 1 is plain SGD [arxiv:2306.11313 app. F]. The
  authors' repository uses Adadelta with the configured learning rate
  [code: src/utils.py#L230].
- **Loss normalisation.** The paper averages the NLL and LS over M sequences
  [arxiv:2306.11313 §3.4] [arxiv:2306.11313 app. D]. The repository sums over
  the mini-batch [code: src/model.py#L1237-L1242]. The relative weight of the
  barrier therefore depends on batch size.
- **Penalty term.** The repository adds a regulariser on the temporal basis at
  long lags, which the paper's loss does not contain [code: src/model.py#L1106-L1125].
- **Time MAE.** The paper describes it as a mean absolute error of predicted
  event frequency [arxiv:2306.11313 §4.1]. The evaluation code takes the signed
  difference of two mean counts, without an absolute value or per-sequence
  error [code: src/evaluation.py#L209-L211].
- **Barrier schedule.** The paper sets the bound from the smallest grid
  intensity minus a small offset [arxiv:2306.11313 app. F]. The repository
  keeps a fixed bound unless a violation occurs, then resets the weight
  [code: src/utils.py#L345-L355].
- **Sign in Algorithm 1.** Algorithm 1 writes the objective as minus the
  likelihood plus the barrier, while the text defines the NLL as a positive
  quantity. Read literally, the two disagree [arxiv:2306.11313 alg. 1]
  [arxiv:2306.11313 §3.4].
- **Loss choice.** The paper reports LS with the higher testing log-likelihood
  on the 16-node set (−2.993 against −2.995 for NLL) and on traffic, but NLL
  with the higher one on wildfire (−3.625 against −3.628 for LS) [arxiv:2306.11313
  tab. 1] [arxiv:2306.11313 tab. H4]. The paper itself calls LS slightly more
  numerically stable [arxiv:2306.11313 §4.1].

## Papers

- [Deep graph kernel point processes over networks](/papers/2306.11313): a
  low-rank graph kernel for Hawkes-style intensities, trained by NLL or LS
  with a log-barrier that keeps the intensity positive.