def test_hawkes_em_attributes(self):
"""...Test attributes of HawkesEM are correctly inherited
"""
em = HawkesEM(kernel_support=10)
em.fit(self.events)
self.assertEqual(em.n_nodes, self.n_nodes)
self.assertEqual(em.n_realizations, self.n_realizations)
def test_hawkes_em_fit(self):
"""...Test fit method of HawkesEM
"""
kernel_support = 3
kernel_size = 3
baseline = np.zeros(self.n_nodes) + .2
kernel = np.zeros((self.n_nodes, self.n_nodes, kernel_size)) + .4
em = HawkesEM(kernel_support=kernel_support,
kernel_size=kernel_size,
n_threads=2,
max_iter=10,
verbose=False)
em.fit(self.events, baseline_start=baseline, kernel_start=kernel)
np.testing.assert_array_almost_equal(em.baseline,
[1.2264, 0.2164, 1.6782],
decimal=4)
expected_kernel = [[[2.4569e-02, 2.5128e-06, 0.0000e+00],
[1.8072e-02, 5.4332e-11, 0.0000e+00],
[2.7286e-03, 4.0941e-08, 3.5705e-15]],
[[8.0077e-01, 2.2624e-02, 6.7577e-10],
[2.7503e-02, 3.1840e-05, 0.0000e+00],
[1.4984e-01, 7.8428e-06, 2.8206e-12]],
[[1.2163e-01, 1.0997e-02, 5.4724e-05],
[4.7348e-02, 6.6093e-03, 5.5433e-12],
[1.0662e-03, 5.3920e-05, 1.4930e-08]]]
np.testing.assert_array_almost_equal(em.kernel,
expected_kernel,
decimal=4)
em2 = HawkesEM(kernel_discretization=np.array([0., 1., 2., 3.]),
n_threads=1,
max_iter=10,
verbose=False)
em2.fit(self.events, baseline_start=baseline, kernel_start=kernel)
np.testing.assert_array_almost_equal(em2.kernel,
expected_kernel,
decimal=4)
np.testing.assert_array_almost_equal(
em.get_kernel_values(1, 0, np.linspace(0, 3, 5)),
[0.0000e+00, 8.0077e-01, 2.2624e-02, 6.7577e-10, 0.0000e+00],
decimal=4)
np.testing.assert_array_almost_equal(
em.get_kernel_norms(),
[[0.0246, 0.0181, 0.0027], [0.8234, 0.0275, 0.1499],
[0.1327, 0.054, 0.0011]],
decimal=3)
np.testing.assert_array_equal(
em.get_kernel_supports(),
np.ones((self.n_nodes, self.n_nodes)) * 3)
inter_mode=TimeFunction.InterConstRight,
dt=0.1)
kernel1 = HawkesKernelTimeFunc(tf1)
t_values2 = np.linspace(0, 4, 20)
y_values2 = np.maximum(0., np.sin(t_values2) / 4)
tf2 = TimeFunction([t_values2, y_values2])
kernel2 = HawkesKernelTimeFunc(tf2)
baseline = np.array([0.1, 0.3])
hawkes = SimuHawkes(baseline=baseline,
end_time=run_time,
verbose=False,
seed=2334)
hawkes.set_kernel(0, 0, kernel1)
hawkes.set_kernel(0, 1, HawkesKernelExp(.5, .7))
hawkes.set_kernel(1, 1, kernel2)
hawkes.simulate()
em = HawkesEM(4, kernel_size=16, n_threads=8, verbose=False, tol=1e-3)
em.fit(hawkes.timestamps)
fig = plot_hawkes_kernels(em, hawkes=hawkes, show=False)
for ax in fig.axes:
ax.set_ylim([0, 1])
plt.show()
def test_hawkes_em_score(self):
"""...Test score (ie. likelihood) function of Hawkes EM
"""
def approximate_likelihood(em, events, end_times, precision=2):
n_total_jumps = sum(map(len, events))
kernels_func = [[
lambda t, i=i, j=j: em.get_kernel_values(i, j, np.array([t]))[
0] for j in range(n_nodes)
] for i in range(n_nodes)]
intensities = hawkes_intensities(events, em.baseline, kernels_func)
return hawkes_log_likelihood(
intensities, events, end_times,
precision=precision) / n_total_jumps
# We use only 2 nodes otherwise integral approximation might be very
# slow
n_nodes = 2
kernel_support = 1
kernel_size = 3
baseline = np.random.rand(n_nodes) + .2
kernel = np.random.rand(n_nodes, n_nodes, kernel_size) + .4
train_events = \
[np.cumsum(np.random.rand(2 + i)) for i in range(n_nodes)]
test_events = \
[2 + np.cumsum(np.random.rand(2 + i)) for i in range(n_nodes)]
# Test for 2 kind of discretization
train_kwargs = [{
'kernel_support': 1,
'kernel_size': 3
}, {
'kernel_discretization': np.array([0., 1., 1.5, 3.])
}]
# Test with and without fitting
fits = [True, False]
for kwargs, fit in zip(train_kwargs, fits):
em = HawkesEM(**kwargs)
end_times = max(map(max, train_events)) + 0.2 * kernel_support
msg = '^You must either call `fit` before `score` or provide events'
with self.assertRaisesRegex(ValueError, msg):
em.score()
if fit:
em.fit(train_events,
end_times=end_times,
baseline_start=baseline,
kernel_start=kernel)
else:
em.baseline = baseline
em.kernel = kernel
# Score on em train data
if fit:
em_train_score = em.score()
else:
em_train_score = em.score(train_events, end_times=end_times)
self.assertAlmostEqual(em_train_score,
approximate_likelihood(
em, train_events, end_times, 2),
delta=1e-1,
msg='Failed on train for {}'.format(kwargs))
# Score on test data
em_test_score = em.score(events=test_events)
test_end_times = max(map(max, test_events))
self.assertAlmostEqual(em_test_score,
approximate_likelihood(
em, test_events, test_end_times, 4),
delta=1e-3,
msg='Failed on test for {}'.format(kwargs))