def __init__(self,
kernel_support=None,
kernel_size=10,
kernel_discretization=None,
tol=1e-5,
max_iter=100,
print_every=10,
record_every=10,
verbose=False,
n_threads=1):
LearnerHawkesNoParam.__init__(self,
n_threads=n_threads,
verbose=verbose,
tol=tol,
max_iter=max_iter,
print_every=print_every,
record_every=record_every)
if kernel_discretization is not None:
self._learner = _HawkesEM(kernel_discretization, n_threads)
elif kernel_support is not None:
self._learner = _HawkesEM(kernel_support, kernel_size, n_threads)
else:
raise ValueError('Either kernel support or kernel discretization '
'must be provided')
self.baseline = None
self.kernel = None
self.history.print_order = ["n_iter", "rel_baseline", "rel_kernel"]
def fit(self,
events,
end_times=None,
baseline_start=None,
kernel_start=None):
"""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), default=None
Used to force start values for baseline parameter
If `None` starts with uniform 1 values
kernel_start : `None` or `np.ndarray`, shape=(n_nodes, n_nodes, kernel_size), default=None
Used to force start values for kernel parameter
If `None` starts with random values
"""
LearnerHawkesNoParam.fit(self, events, end_times=end_times)
self.solve(baseline_start=baseline_start, kernel_start=kernel_start)
return self
def __init__(self, max_mean_gaussian, n_gaussians=5, step_size=1e-7,
C=1e3, lasso_grouplasso_ratio=0.5, max_iter=50,
tol=1e-5, n_threads=1, verbose=False, print_every=10,
record_every=10, approx=0, em_max_iter=30,
em_tol=None):
LearnerHawkesNoParam.__init__(self, verbose=verbose, max_iter=max_iter,
print_every=print_every, tol=tol,
n_threads=n_threads,
record_every=record_every)
self.baseline = None
self.amplitudes = None
self.n_gaussians = n_gaussians
self.max_mean_gaussian = max_mean_gaussian
self.step_size = step_size
strength_lasso = lasso_grouplasso_ratio / C
strength_grouplasso = (1. - lasso_grouplasso_ratio) / C
self.em_max_iter = em_max_iter
self.em_tol = em_tol
self._learner = _HawkesSumGaussians(
n_gaussians, max_mean_gaussian, step_size, strength_lasso,
strength_grouplasso, em_max_iter, n_threads, approx)
self.verbose = verbose
self.history.print_order += ["rel_baseline", "rel_amplitudes"]
def __init__(self, decay, C=1e3, lasso_nuclear_ratio=0.5, max_iter=50,
tol=1e-5, n_threads=1, verbose=False, print_every=10,
record_every=10, rho=.1, approx=0, em_max_iter=30,
em_tol=None):
LearnerHawkesNoParam.__init__(self, verbose=verbose, max_iter=max_iter,
print_every=print_every, tol=tol,
n_threads=n_threads,
record_every=record_every)
self.baseline = None
self.adjacency = None
self._C = 0
self._lasso_nuclear_ratio = 0
self.decay = decay
self.rho = rho
self._prox_l1 = ProxL1(1.)
self._prox_nuclear = ProxNuclear(1.)
self.C = C
self.lasso_nuclear_ratio = lasso_nuclear_ratio
self.verbose = verbose
self.em_max_iter = em_max_iter
self.em_tol = em_tol
self._learner = _HawkesADM4(decay, rho, n_threads, approx)
# TODO add approx to model
self._model = ModelHawkesFixedExpKernLogLik(self.decay,
n_threads=self.n_threads)
self.history.print_order += ["rel_baseline", "rel_adjacency"]
def _set_data(self, events: list):
"""Set the corresponding realization(s) of the process.
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
"""
LearnerHawkesNoParam._set_data(self, events)
events, end_times = self._clean_events_and_endtimes(events)
self._model.fit(events, end_times=end_times)
self._prox_nuclear.n_rows = self.n_nodes
def __init__(self, kernel_support, n_basis=None, kernel_size=10, tol=1e-5,
C=1e-1, max_iter=100, verbose=False, print_every=10,
record_every=10, n_threads=1, ode_max_iter=100, ode_tol=1e-5):
LearnerHawkesNoParam.__init__(self, max_iter=max_iter, verbose=verbose,
tol=tol, print_every=print_every,
record_every=record_every,
n_threads=n_threads)
self.ode_max_iter = ode_max_iter
self.ode_tol = ode_tol
alpha = 1. / C
if n_basis is None:
n_basis = 0
self._learner = _HawkesBasisKernels(kernel_support, kernel_size,
n_basis, alpha, n_threads)
self._amplitudes_2d = None
self.history.print_order = ["n_iter", "rel_baseline", "rel_amplitudes",
"rel_basis_kernels"]