mixle.stats.processes.multivariate_hawkes module

Multivariate (mutually-exciting) Hawkes process with an exponential kernel.

A D-dimensional Hawkes process over marked events (t, mark) on a fixed window [0, T]. Each mark has a baseline intensity mu_d and an event of mark j excites the intensity of mark d by alpha_{dj} exp(-beta (t - t_k)), so

lambda_d(t) = mu_d + sum_{t_k < t} alpha_{d, mark_k} exp(-beta (t - t_k)),

coupling the dimensions through the D x D excitation matrix alpha (a shared decay beta). The exact log-likelihood sum_n log lambda_{mark_n}(t_n) - sum_d \int_0^T lambda_d is computed in O(n D) by a per-mark excitation recursion, sampling is by multivariate Ogata thinning, and the parameters are fit by the Veen-Schoenberg branching EM (each event is an immigrant of its mark or the offspring of an earlier event, with the excitation kernel as the parent likelihood). The process is stationary when the spectral radius of alpha / beta is below 1.

Reference: Hawkes, ‘Spectra of some self-exciting and mutually exciting point processes’, Biometrika (1971).

class MultivariateHawkesProcessDistribution(mu, alpha, beta, window, name=None, keys=None)

Bases: SequenceEncodableProbabilityDistribution

Multivariate Hawkes process: baselines mu (D), excitation alpha (D, D), decay beta.

Parameters:

• mu (ndarray)

• alpha (ndarray)

• beta (float)

• window (float)

• name (str | None)

• keys (str | None)

intensity(t, times, marks)

Per-mark conditional rate vector (the vector-valued variant of intensity).

Returns lambda(t) of shape (D,) with lambda_k(t) = mu_k + sum_{(t_i, m_i) < t} alpha[k, m_i] exp(-beta (t - t_i)).

Parameters:

• t (float)

• times (Any)

• marks (Any)

Return type:

ndarray

expected_count(t_start, t_end, times, marks)

Per-mark compensator vector (the vector-valued variant of expected_count).

Returns (D,) with the integral of lambda_k over [t_start, t_end] given the history.

Parameters:

• t_start (float)

• t_end (float)

• times (Any)

• marks (Any)

Return type:

ndarray

density(x)

Probability density of one realization (a sequence of (time, mark) events).

Parameters:

x (Any)

Return type:

float

log_density(x)

Exact log-likelihood of one realization of marked events sorted by time.

Parameters:

x (Any)

Return type:

float

seq_log_density(x)

Log-likelihood for a list of realizations.

Parameters:

x (list[Any])

Return type:

ndarray

sampler(seed=None)

Return a sampler (multivariate Ogata thinning).

Parameters:

seed (int | None)

Return type:

MultivariateHawkesProcessSampler

estimator(pseudo_count=None)

Return a branching-EM estimator over the same window and dimension.

Parameters:

pseudo_count (float | None)

Return type:

MultivariateHawkesProcessEstimator

dist_to_encoder()

Return the data encoder (passes realizations through; the likelihood is per-realization).

Return type:

MultivariateHawkesProcessDataEncoder

class MultivariateHawkesProcessSampler(dist, seed=None)

Bases: DistributionSampler

Draw realizations by multivariate Ogata thinning.

Parameters:

• dist (MultivariateHawkesProcessDistribution)

• seed (int | None)

sample(size=None)

Draw observations.

Combinator samplers (mixture/sequence/…) accept batched. With batched=True (the default) each child stream is drawn in one vectorized call instead of a per-draw Python loop – far faster. Because every child sampler owns an independent RandomState, batching consumes each stream in the same order as the loop, so the draws are identical to the legacy path. batched=False forces that legacy per-draw loop as a guaranteed- stable reference. Leaf samplers are already vectorized and ignore the flag.

Parameters:

size (int | None)

class MultivariateHawkesProcessAccumulator(dim, window, name=None, keys=None)

Bases: SequenceEncodableStatisticAccumulator

Accumulate the multivariate branching sufficient statistics.

Parameters:

• dim (int)

• window (float)

• name (str | None)

• keys (str | None)

update(x, weight, estimate)

Parameters:

• x (Any)

• weight (float)

• estimate (MultivariateHawkesProcessDistribution | None)

Return type:

None

initialize(x, weight, rng)

Parameters:

• x (Any)

• weight (float)

• rng (RandomState | None)

Return type:

None

seq_update(x, weights, estimate)

Parameters:

• x (list[Any])

• weights (ndarray)

• estimate (MultivariateHawkesProcessDistribution)

Return type:

None

seq_initialize(x, weights, rng)

Parameters:

• x (list[Any])

• weights (ndarray)

• rng (RandomState | None)

Return type:

None

combine(suff_stat)

Parameters:

suff_stat (tuple)

Return type:

MultivariateHawkesProcessAccumulator

value()

Return type:

tuple

from_value(x)

Parameters:

x (tuple)

Return type:

MultivariateHawkesProcessAccumulator

scale(c)

Scale linear sufficient statistics in-place by c.

The structural default is correct for ordinary weighted sums, nested tuples/lists/dicts, and numeric arrays. Families whose value() payload includes non-linear metadata such as support bounds must override this method and leave that metadata unscaled.

Parameters:

c (float)

Return type:

MultivariateHawkesProcessAccumulator

key_merge(stats_dict)

Pool this accumulator’s statistics into stats_dict under its merge key.

The structural default implements the common single-key pattern: store the accumulator under self.keys the first time the key is seen, else combine into the one already there. Accumulators with several named keys (e.g. an HMM’s init/trans/state keys) or a non-accumulator stats payload override this. A keys of None (the default) is a no-op.

Parameters:

stats_dict (dict[str, Any])

Return type:

None

key_replace(stats_dict)

Replace this accumulator’s statistics from the pooled stats_dict entry (see key_merge).

Parameters:

stats_dict (dict[str, Any])

Return type:

None

acc_to_encoder()

Return type:

MultivariateHawkesProcessDataEncoder

class MultivariateHawkesProcessAccumulatorFactory(dim, window, name=None, keys=None)

Bases: StatisticAccumulatorFactory

Factory for MultivariateHawkesProcessAccumulator.

Parameters:

• dim (int)

• window (float)

• name (str | None)

• keys (str | None)

make()

Return type:

MultivariateHawkesProcessAccumulator

class MultivariateHawkesProcessEstimator(dim, window, name=None, keys=None)

Bases: ParameterEstimator

Veen-Schoenberg branching-EM estimator for the multivariate Hawkes parameters.

Parameters:

• dim (int)

• window (float)

• name (str | None)

• keys (str | None)

accumulator_factory()

Return type:

MultivariateHawkesProcessAccumulatorFactory

estimate(nobs, suff_stat)

Parameters:

• nobs (float | None)

• suff_stat (tuple)

Return type:

MultivariateHawkesProcessDistribution

class MultivariateHawkesProcessDataEncoder(window, dim)

Bases: DataSequenceEncoder

Validate and pass through realizations of marked events.

Parameters:

• window (float)

• dim (int)

seq_encode(x)

Encode the iid observation sequence x for vectorized evaluation.

Parameters:

x (Sequence[Any])

Return type:

list[Any]