Temporal point process

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 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 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 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 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' 2306.11313 §3.2. The graph basis is a set of localised filters on the graph 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 2306.11313 app. B 2306.11313 app. C. Card: Deep graph kernel point processes over networks.

Its loss is either the negative log-likelihood (NLL) or a least-squares (LS) objective, and the paper reports both 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 2306.11313 §4, and against classical or spatio-temporal models (MHP, ETAS, DNSK-stpp) on wildfire and theft data using Euclidean distances 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.

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) 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.

# 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

# 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

# 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 2306.11313 §3.4 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 2306.11313 app. F. The authors' repository uses Adadelta with the configured learning rate utils.py.
• Loss normalisation. The paper averages the NLL and LS over M sequences 2306.11313 §3.4 2306.11313 app. D. The repository sums over the mini-batch model.py. 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 model.py.
• Time MAE. The paper describes it as a mean absolute error of predicted event frequency 2306.11313 §4.1. The evaluation code takes the signed difference of two mean counts, without an absolute value or per-sequence error evaluation.py.
• Barrier schedule. The paper sets the bound from the smallest grid intensity minus a small offset 2306.11313 app. F. The repository keeps a fixed bound unless a violation occurs, then resets the weight utils.py.
• 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 2306.11313 alg. 1 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] 2306.11313 tab. H4. The paper itself calls LS slightly more numerically stable 2306.11313 §4.1.

Papers

• Deep graph kernel point processes over networks: a low-rank graph kernel for Hawkes-style intensities, trained by NLL or LS with a log-barrier that keeps the intensity positive.