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:
where
\(D\) is the number of nodes
\(\mu_i\) are the baseline intensities
\(\phi_{ij}\) are the kernels
The basis kernel hypothesis translates to:
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.
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 ton_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 ofprint_every
record_every : int
, default=10
Record history information when
n_iter
(iteration number) is a multiple ofrecord_every
n_threads : int
, default=1
Number of threads used for parallel computation.
if
int <= 0
: the number of physical cores available on the CPUotherwise the desired number of threads
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.
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-dimensionalnumpy.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
key : str
, default=None
If
None
all history is returned as adict
If
str
, name of the history element to retrieve
output : list
or dict
If
key
is None orkey
is not in history then output is a dict containing history of all keysIf
key
is the name of an element in the history, output is alist
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
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
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
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)
output : float
Value of the objective at given
coeffs
tick.hawkes.HawkesBasisKernels
¶