def get_train_data(n_nodes=3, betas=1.):
np.random.seed(130947)
baseline = np.random.rand(n_nodes)
adjacency = np.random.rand(n_nodes, n_nodes)
if isinstance(betas, (int, float)):
betas = np.ones((n_nodes, n_nodes)) * betas
sim = SimuHawkesExpKernels(adjacency=adjacency, decays=betas,
baseline=baseline, verbose=False,
seed=13487, end_time=3000)
sim.adjust_spectral_radius(0.8)
adjacency = sim.adjacency
sim.simulate()
return sim.timestamps, baseline, adjacency
def test_solver_scpg(self):
"""...Check Self-concordant proximal gradient solver for a Hawkes
model with ridge penalization
"""
beta = 3
betas = beta * np.ones((2, 2))
alphas = np.zeros((2, 2))
alphas[0, 0] = 1
alphas[0, 1] = 2
alphas[1, 1] = 3
mus = np.arange(1, 3) / 3
hawkes = SimuHawkesExpKernels(adjacency=alphas,
decays=betas,
baseline=mus,
seed=1231,
end_time=20000,
verbose=False)
hawkes.adjust_spectral_radius(0.8)
alphas = hawkes.adjacency
hawkes.simulate()
timestamps = hawkes.timestamps
model = ModelHawkesExpKernLogLik(beta).fit(timestamps)
prox = ProxL2Sq(1e-7, positive=True)
pg = SCPG(max_iter=2000, tol=1e-10, verbose=False,
step=1e-5).set_model(model).set_prox(prox)
pg.solve(np.ones(model.n_coeffs))
original_coeffs = np.hstack((mus, alphas.reshape(4)))
np.testing.assert_array_almost_equal(pg.solution,
original_coeffs,
decimal=2)
def simulate_sparse_realization(self):
"""Simulate realization in which some nodes are sometimes empty
"""
baseline = np.array([0.3, 0.001])
adjacency = np.array([[0.5, 0.8], [0., 1.3]])
sim = SimuHawkesExpKernels(adjacency=adjacency,
decays=self.decay,
baseline=baseline,
verbose=False,
seed=13487,
end_time=500)
sim.adjust_spectral_radius(0.8)
multi = SimuHawkesMulti(sim, n_simulations=100)
adjacency = sim.adjacency
multi.simulate()
# Check that some but not all realizations are empty
self.assertGreater(max(map(lambda r: len(r[1]), multi.timestamps)), 1)
self.assertEqual(min(map(lambda r: len(r[1]), multi.timestamps)), 0)
return baseline, adjacency, multi.timestamps
adjacency[i, j] = np.random.random()
if args.constant_decay:
decays = np.full((args.n_types, args.n_types), args.exp_decay)
else:
decays = np.random.exponential(args.exp_decay,
(args.n_types, args.n_types))
simu_hawkes = SimuHawkesExpKernels(
baseline=baseline,
adjacency=adjacency,
decays=decays,
verbose=False,
seed=args.rand_seed,
)
simu_hawkes.adjust_spectral_radius(args.adj_spectral_radius)
simu_hawkes.max_jumps = args.max_jumps
print(simu_hawkes.baseline)
print(simu_hawkes.adjacency)
print(simu_hawkes.decays)
with Timer("Simulating events"), Pool(cpu_count() // 2) as p:
timestamps = list(
starmap(
simulate_helper,
zip(
[simu_hawkes] * args.n_seqs,
np.random.poisson(args.max_jumps, args.n_seqs),
),
))
class Test(unittest.TestCase):
def setUp(self):
np.random.seed(23982)
self.n_nodes = 3
self.baseline = np.random.rand(self.n_nodes)
self.adjacency = np.random.rand(self.n_nodes, self.n_nodes) / 2
self.decays = np.random.rand(self.n_nodes, self.n_nodes)
self.adjacency[0, 0] = 0
self.adjacency[-1, -1] = 0
self.hawkes = SimuHawkesExpKernels(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 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__, HawkesKernelExp)
self.assertEqual(kernel_ij.decay, self.decays[i, j])
self.assertEqual(kernel_ij.intensity, 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.6645446549735008)
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)