tick.hawkes.HawkesADM4

class tick.hawkes.HawkesADM4(decay, C=1000.0, lasso_nuclear_ratio=0.5, max_iter=50, tol=1e-05, n_threads=1, verbose=False, print_every=10, record_every=10, rho=0.1, approx=0, em_max_iter=30, em_tol=None)[source]

A class that implements parametric inference for Hawkes processes with an exponential parametrisation of the kernels and a mix of Lasso and nuclear regularization

Hawkes processes are point processes defined by the intensity:

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

where

  • \(D\) is the number of nodes

  • \(\mu_i\) are the baseline intensities

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

  • \(t_k^j\) are the timestamps of all events of node \(j\)

and with an exponential parametrisation of the kernels

\[\phi_{ij}(t) = \alpha^{ij} \beta \exp (- \beta t) 1_{t > 0}\]

In our implementation we denote:

  • Integer \(D\) by the attribute n_nodes

  • Vector \(\mu \in \mathbb{R}^{D}\) by the attribute baseline

  • Matrix \(A = (\alpha^{ij})_{ij} \in \mathbb{R}^{D \times D}\) by the attribute adjacency

  • Number \(\beta \in \mathbb{R}\) by the parameter decay. This parameter is given to the model

Parameters

decay : float

The decay used in the exponential kernel

C : float, default=1e3

Level of penalization

lasso_nuclear_ratio : float, default=0.5

Ratio of Lasso-Nuclear regularization mixing parameter with 0 <= ratio <= 1.

  • For ratio = 0 this is nuclear regularization

  • For ratio = 1 this is lasso (L1) regularization

  • For 0 < ratio < 1, the regularization is a linear combination of Lasso and nuclear.

max_iter : int, default=50

Maximum number of iterations of the solving algorithm

tol : float, default=1e-5

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

verbose : bool, default=False

If True, we verbose things

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

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

Attributes

n_nodes : int

Number of nodes / components in the Hawkes model

baseline : np.array, shape=(n_nodes,)

Inferred baseline of each component’s intensity

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

Inferred adjacency matrix

References

Zhou, K., Zha, H., & Song, L. (2013, May). Learning Social Infectivity in Sparse Low-rank Networks Using Multi-dimensional Hawkes Processes. In AISTATS (Vol. 31, pp. 641-649).

__init__(decay, C=1000.0, lasso_nuclear_ratio=0.5, max_iter=50, tol=1e-05, n_threads=1, verbose=False, print_every=10, record_every=10, rho=0.1, approx=0, em_max_iter=30, em_tol=None)[source]

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

fit(events, end_times=None, baseline_start=None, adjacency_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)

Set initial value of baseline parameter If None starts with uniform 1 values

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

Set initial value of adjacency parameter If None starts with random values uniformly sampled between 0.5 and 0.9`

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_norms()[source]

Computes kernel norms. This makes our learner compliant with tick.plot.plot_hawkes_kernel_norms API

Returns

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

2d array in which each entry i, j corresponds to the norm of kernel i, j

get_kernel_supports()[source]

Computes kernel support. This makes our learner compliant with tick.plot.plot_hawkes_kernels API

Returns

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

2d array in which each entry i, j corresponds to the support of kernel i, j

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 learner 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

Notes

Because of the auxiliary variables, the expression of the truly optimized objective is a bit modified. Hence this objective value might not reach its exact minimum especially for high penalization levels.

score(events=None, end_times=None, baseline=None, adjacency=None)[source]

Compute score metric Score metric is log likelihood (the higher the better)

Parameters

events : list of list of np.ndarray, default = None

List of Hawkes processes realizations used to measure score. 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 If None, events given while fitting model will be used

end_times : np.ndarray or float, default = None

List of end time of all hawkes processes used to measure score. 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 : np.ndarray, shape=(n_nodes, ), default = None

Baseline vector for which the score is measured If None baseline obtained during fitting is used

adjacency : np.ndarray, shape=(n_nodes, n_nodes), default = None

Adjacency matrix for which the score is measured If None adjacency obtained during fitting is used

Returns

likelihood : double

Computed log likelihood value