from tick.inference import HawkesSumExpKern
from tick.plot import plot_point_process
from tick.simulation import SimuHawkesSumExpKernels
end_time = 1000
decays = [0.1, 0.5, 1.]
baseline = [0.12, 0.07]
adjacency = [[[0, .1, .4], [.2, 0., .2]],
[[0, 0, 0], [.6, .3, 0]]]
hawkes_exp_kernels = SimuHawkesSumExpKernels(
adjacency=adjacency, decays=decays, baseline=baseline,
end_time=end_time, verbose=False, seed=1039)
hawkes_exp_kernels.track_intensity(0.1)
hawkes_exp_kernels.simulate()
learner = HawkesSumExpKern(decays, penalty='elasticnet',
elastic_net_ratio=0.8)
learner.fit(hawkes_exp_kernels.timestamps)
t_min = 100
t_max = 200
fig, ax_list = plt.subplots(2, 1, figsize=(10, 6))
learner.plot_estimated_intensity(hawkes_exp_kernels.timestamps,
t_min=t_min, t_max=t_max,
ax=ax_list)
plot_point_process(hawkes_exp_kernels, plot_intensity=True,
t_min=t_min, t_max=t_max, ax=ax_list)
class Test(unittest.TestCase):
def setUp(self):
np.random.seed(23982)
self.n_nodes = 3
self.n_decays = 4
self.baseline = np.random.rand(self.n_nodes)
self.adjacency = np.random.rand(self.n_nodes, self.n_nodes,
self.n_decays) / 10
self.decays = np.random.rand(self.n_decays)
self.adjacency[0, 0, :] = 0
self.adjacency[-1, -1, :] = 0
self.hawkes = SimuHawkesSumExpKernels(self.adjacency,
self.decays,
baseline=self.baseline,
seed=203,
verbose=False)
def test_hawkes_exponential_kernels(self):
"""...Test creation of a Hawkes Process with exponential kernels
"""
kernel_0 = None
for i, j in product(range(self.n_nodes), range(self.n_nodes)):
kernel_ij = self.hawkes.kernels[i, j]
if np.linalg.norm(self.adjacency[i, j, :]) == 0:
self.assertEqual(kernel_ij.__class__, HawkesKernel0)
# We check that all 0 adjacency share the same kernel 0
# This might save lots of memory with very large,
# very sparse adjacency matrices
if kernel_0 is None:
kernel_0 = kernel_ij
else:
self.assertEqual(kernel_0, kernel_ij)
else:
self.assertEqual(kernel_ij.__class__, HawkesKernelSumExp)
np.testing.assert_array_equal(kernel_ij.decays, self.decays)
np.testing.assert_array_equal(kernel_ij.intensities,
self.adjacency[i, j, :])
np.testing.assert_array_equal(self.baseline, self.hawkes.baseline)
def test_hawkes_spectral_radius_exp_kernel(self):
"""...Hawkes Process spectral radius and adjust spectral radius
methods
"""
self.assertAlmostEqual(self.hawkes.spectral_radius(),
0.5202743505580953)
self.hawkes.adjust_spectral_radius(0.6)
self.assertAlmostEqual(self.hawkes.spectral_radius(), 0.6)
def test_hawkes_mean_intensity(self):
"""...Test that Hawkes obtained mean intensity is consistent
"""
self.assertLess(self.hawkes.spectral_radius(), 1)
self.hawkes.end_time = 1000
self.hawkes.track_intensity(0.01)
self.hawkes.simulate()
mean_intensity = self.hawkes.mean_intensity()
for i in range(self.hawkes.n_nodes):
self.assertAlmostEqual(np.mean(self.hawkes.tracked_intensity[i]),
mean_intensity[i],
delta=0.1)
def test_hawkes_sumexp_constructor_errors(self):
bad_adjacency = np.random.rand(self.n_nodes, self.n_nodes,
self.n_decays + 1)
msg = "^adjacency matrix shape should be \(3, 3, 4\) but its shape " \
"is \(3, 3, 5\)$"
with self.assertRaisesRegex(ValueError, msg):
SimuHawkesSumExpKernels(bad_adjacency,
self.decays,
baseline=self.baseline)