tick.hawkes.HawkesBasisKernels

class tick.hawkes.HawkesBasisKernels(kernel_support, n_basis=None, kernel_size=10, tol=1e-05, C=0.1, max_iter=100, verbose=False, print_every=10, record_every=10, n_threads=1, ode_max_iter=100, ode_tol=1e-05)[source]

This class is used for performing non parametric estimation of multi-dimensional Hawkes processes based on expectation maximization algorithm and the hypothesis that kernels are linear combinations of some basis kernels.

Hawkes processes are point processes defined by the intensity:

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

where

  • \(D\) is the number of nodes

  • \(\mu_i\) are the baseline intensities

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

The basis kernel hypothesis translates to:

\[\phi_{ij}(t) = \sum_{u}^U a_{ij}^u g^u(t)\]

where

  • \(U\) is the number of basis kernels.

  • \(g^u\) is a basis kernel

  • \(a_{ij}^u\) is the amplitude of basis kernel \(u\) in kernel \(\phi_{ij}\)

Finally we also suppose that basis kernels \(g^u\) are piecewise constant on a given support and number of intervals.

Parameters

kernel_support : float

The support size common to all the kernels.

n_basis : int, default=`None`

Number of non parametric basis kernels to be used. If None or 0, it will be set to n_nodes

kernel_size : int, default=10

Number of discretizations of the kernel

C : float, default=1e-1

The penalization parameter. It penalizes both the amplitudes squared values and the basis kernels smoothness through the integral of their squared derivative.

tol : float, default=1e-5

The tolerance of the solver (iterations stop when the stopping criterion is below it). If not reached the solver does max_iter iterations

max_iter : int, default=100

Maximum number of iterations of the solver

verbose : bool, default=False

If True, we verbose things, otherwise the solver does not print anything (but records information in history anyway)

print_every : int, default=10

Print history information when n_iter (iteration number) is a multiple of print_every

record_every : int, default=10

Record history information when n_iter (iteration number) is a multiple of record_every

n_threads : int, default=1

Number of threads used for parallel computation.

  • if int <= 0: the number of physical cores available on the CPU

  • otherwise the desired number of threads

Attributes

n_nodes : int

Number of nodes of the estimated Hawkes process

n_realizations : int

Number of given realizations`

baseline : np.array shape=(n_nodes)

The estimated baseline

amplitudes : np.array shape=(n_nodes, n_nodes, n_basis)

Amplitudes of all basis kernels for all kernels.

basis_kernels : np.array shape=(n_basis, kernel_size)

Estimated basis kernels

kernel_dt : float

Kernel discretization step. It is equal to kernel_support / kernel_size

kernel_discretization : np.ndarray, shape=(kernel_size + 1, )

Kernel discretizations points, denotes the interval on which basis kernels are piecewise constant.

References

Zhou, K., Zha, H. and Song, L., 2013, June. Learning Triggering Kernels for Multi-dimensional Hawkes Processes. In ICML (3) (pp. 1301-1309).

Some rewriting notes for implementing the algorithm can be found in the doc/tex directory.

__init__(kernel_support, n_basis=None, kernel_size=10, tol=1e-05, C=0.1, max_iter=100, verbose=False, print_every=10, record_every=10, n_threads=1, ode_max_iter=100, ode_tol=1e-05)[source]

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

fit(events, end_times=None, baseline_start=None, amplitudes_start=None, basis_kernels_start=None)[source]

Fit the model according to the given training data.

Parameters

events : list of list of np.ndarray

List of Hawkes processes realizations. Each realization of the Hawkes process is a list of n_node for each component of the Hawkes. Namely events[i][j] contains a one-dimensional numpy.array of the events’ timestamps of component j of realization i. If only one realization is given, it will be wrapped into a list

end_times : np.ndarray or float, default = None

List of end time of all hawkes processes that will be given to the model. If None, it will be set to each realization’s latest time. If only one realization is provided, then a float can be given.

baseline_start : None or np.ndarray, shape=(n_nodes)

Used to force start values for baseline attribute If None starts with uniform 1 values

amplitudes_start : None or np.ndarray, shape=(n_nodes,n_nodes,D)

Used to force start values for amplitude parameter If None starts with random values uniformly sampled between 0.5 and 0.9

basis_kernels_start : None or np.darray, shape=(D,kernel_size)

Used to force start values for the basis kernels If None starts with random values uniformly sampled between 0 and 0.1

get_history(key=None)

Returns history of the solver

Parameters

key : str, default=None

  • If None all history is returned as a dict

  • If str, name of the history element to retrieve

Returns

output : list or dict

  • If key is None or key is not in history then output is a dict containing history of all keys

  • If key is the name of an element in the history, output is a list containing the history of this element

get_kernel_values(i, j, abscissa_array)[source]

Computes value of the specified kernel on given time values. This makes our learner compliant with tick.plot.plot_hawkes_kernels API

Parameters

i : int

First index of the kernel

j : int

Second index of the kernel

abscissa_array : np.ndarray, shape=(n_points, )

1d array containing all the times at which this kernel will computes it value

Returns

output : np.ndarray, shape=(n_points, )

1d array containing the values of the specified kernels at the given times.

objective(coeffs, loss: float = None)[source]

Compute the objective minimized by the solver at coeffs

Parameters

coeffs : numpy.ndarray, shape=(n_coeffs,)

The objective is computed at this point

loss : float, default=`None`

Gives the value of the loss if already known (allows to avoid its computation in some cases)

Returns

output : float

Value of the objective at given coeffs

Examples using tick.hawkes.HawkesBasisKernels