tick.hawkes.SimuHawkes

class tick.hawkes.SimuHawkes(kernels=None, baseline=None, n_nodes=None, end_time=None, period_length=None, max_jumps=None, seed=None, verbose=True, force_simulation=False)[source]

Hawkes process simulation

They are defined by the intensity:

\[\forall i \in [1 \dots D], \quad \lambda_i(t) = \mu_i(t) + \sum_{j=1}^D \int \phi_{ij}(t - s) dN_j(s)\]

where

  • \(D\) is the number of nodes

  • \(\mu_i(t)\) are the baseline intensities

  • \(\phi_{ij}\) are the kernels

  • \(dN_j\) are the processes differentiates

Parameters

kernels : np.ndarray, shape=(n_nodes, n_nodes)

A 2-dimensional arrays of kernels, also noted \(\phi_{ij}\)

baseline : np.ndarray or list

The baseline of all intensities, also noted \(\mu(t)\). It might be three different types:

  • np.ndarray, shape=(n_nodes,) : One baseline per node is given. Hence baseline is assumed to be constant, ie. \(\mu_i(t) = \mu_i\)

  • np.ndarray, shape=(n_nodes, n_intervals) : n_intervals baselines are given per node. This assumes parameter period_length is also given. In this case baseline is piecewise constant on intervals of size period_length / n_intervals and periodic.

  • list of tick.base.TimeFunction, shape=(n_nodes,) : One function is given per node, ie. \(\mu_i(t)\) is explicitely given.

n_nodes : int

The number of nodes of the Hawkes process. If kernels and baseline are None this will create a Hawkes process with n_nodes nodes of zero kernels and with zero baseline

end_time : float, default=None

Time until which this point process will be simulated

period_length : float, default=None

Period of baseline in piecewise constant case.

max_jumps : int, default=None

Simulation will stop if this number of jumps in reached

seed : int, default = None

The seed of the random sampling. If it is None then a random seed (different at each run) will be chosen.

force_simulation : bool, default = False

If force is not set to True, simulation won’t be run if the matrix of the L1 norm of kernels has a spectral radius greater or equal to 1 as it would be unstable

Attributes

timestamps : list of np.ndarray, size=n_nodes

A list of n_nodes timestamps arrays, each array containing the timestamps of all the jumps for this node

simulation_time : float

Time until which this point process has been simulated

n_total_jumps : int

Total number of jumps simulated

tracked_intensity : list[np.ndarray], size=n_nodes

A record of the intensity with which this point process has been simulated. Note: you must call track_intensity before simulation to record it

intensity_tracked_times : np.ndarray

The times at which intensity has been recorded. Note: you must call track_intensity before simulation to record it

intensity_track_step : float

Step with which the intensity has been recorded

__init__(kernels=None, baseline=None, n_nodes=None, end_time=None, period_length=None, max_jumps=None, seed=None, verbose=True, force_simulation=False)[source]

Initialize self. See help(type(self)) for accurate signature.

get_baseline_values(i, t_values)[source]

Outputs value of baseline depending on time

Parameters

i : int

Selected dimension

t_values : np.ndarray

Values baseline will be computed at

Returns

output : np.ndarray

Value of baseline i at t_values

is_intensity_tracked()

Is intensity tracked thanks to track_intensity or not

mean_intensity()[source]

Compute the mean intensity vector

reset()

Reset the process, so that is is ready for a brand new simulation

simulate()

Launch the simulation of data

spectral_radius()[source]

Compute the spectral radius of the matrix of l1 norm of Hawkes kernels.

Notes

If the spectral radius is greater that 1, the hawkes process is not stable

threshold_negative_intensity(allow=True)

Threshold intensity to 0 if it becomes negative. This allows simulation with negative kernels

Parameters

allow : bool

Flag to allow negative intensity thresholding

track_intensity(intensity_track_step=-1)

Activate the tracking of the intensity

Parameters

intensity_track_step : float

If positive then the step the intensity vector is recorded every, otherwise, it is deactivated.

Notes

This method must be called before simulation