def test_simu_hawkes_multi_time_func(self): """...Test that hawkes multi works correctly with HawkesKernelTimeFunc """ run_time = 100 t_values1 = np.array([0, 1, 1.5], dtype=float) y_values1 = np.array([0, .2, 0], dtype=float) tf1 = TimeFunction([t_values1, y_values1], inter_mode=TimeFunction.InterConstRight, dt=0.1) kernel1 = HawkesKernelTimeFunc(tf1) t_values2 = np.array([0, 2, 2.5], dtype=float) y_values2 = np.array([0, .6, 0], dtype=float) tf2 = TimeFunction([t_values2, y_values2], inter_mode=TimeFunction.InterConstRight, dt=0.1) 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, kernel1) hawkes.set_kernel(1, 0, kernel2) hawkes.set_kernel(1, 1, kernel2) hawkes_multi = SimuHawkesMulti(hawkes, n_simulations=5, n_threads=4) hawkes_multi.simulate()
def test_hawkes_set_kernel(self): """...Test Hawkes process kernels can be set after initialization """ hawkes = SimuHawkes(n_nodes=2) for i, j in product(range(2), range(2)): hawkes.set_kernel(i, j, self.kernels[i, j]) for i, j in product(range(2), range(2)): self.assertEqual(hawkes.kernels[i, j], self.kernels[i, j]) hawkes.set_kernel(1, 1, self.time_func_kernel) self.assertEqual(hawkes.kernels[1, 1], self.time_func_kernel)
def test_hawkes_negative_intensity_fail(self): """...Test simulation with negative kernel without threshold_negative_intensity """ run_time = 40 hawkes = SimuHawkes(n_nodes=1, end_time=run_time, verbose=False, seed=1398) kernel = HawkesKernelExp(-1.3, .8) hawkes.set_kernel(0, 0, kernel) hawkes.set_baseline(0, 0.3) msg = 'Simulation stopped because intensity went negative ' \ '\(you could call ``threshold_negative_intensity`` to allow it\)' with self.assertRaisesRegex(RuntimeError, msg): hawkes.simulate()
def test_simu_hawkes_no_seed(self): """...Test hawkes multi can be simulated even if no seed is given """ T1 = np.array([0, 2, 2.5], dtype=float) Y1 = np.array([0, .6, 0], dtype=float) tf = TimeFunction([T1, Y1], inter_mode=TimeFunction.InterConstRight, dt=0.1) kernel = HawkesKernelTimeFunc(tf) hawkes = SimuHawkes(baseline=[.1], end_time=100, verbose=False) hawkes.set_kernel(0, 0, kernel) multi_hawkes_1 = SimuHawkesMulti(hawkes, n_simulations=5) multi_hawkes_1.simulate() multi_hawkes_2 = SimuHawkesMulti(hawkes, n_simulations=5) multi_hawkes_2.simulate() # If no seed are given, realizations must be different self.assertNotEqual(multi_hawkes_1.timestamps[0][0][0], multi_hawkes_2.timestamps[0][0][0])
def test_hawkes_negative_intensity(self): """...Test simulation with negative kernel """ run_time = 40 hawkes = SimuHawkes(n_nodes=1, end_time=run_time, verbose=False, seed=1398) kernel = HawkesKernelExp(-1.3, .8) hawkes.set_kernel(0, 0, kernel) hawkes.set_baseline(0, 0.3) hawkes.threshold_negative_intensity() dt = 0.1 hawkes.track_intensity(dt) hawkes.simulate() self.assertAlmostEqual(hawkes.tracked_intensity[0].min(), 0) self.assertAlmostEqual(hawkes.tracked_intensity[0].max(), hawkes.baseline[0]) self.assertGreater(hawkes.n_total_jumps, 1)
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 g2(t): return np.cos(np.pi * (t / 10 + 1)) + 1.1 t_values = np.linspace(0, 20, 1000) u_values = [(0.007061, 0.001711), (0.005445, 0.003645), (0.003645, 0.005445), (0.001790, 0.007390)] hawkes = SimuHawkes(baseline=[1e-5, 1e-5], seed=1093, verbose=False) for i, j in itertools.product(range(2), repeat=2): u1, u2 = u_values[2 * i + j] y_values = g1(t_values) * u1 + g2(t_values) * u2 kernel = HawkesKernelTimeFunc(t_values=t_values, y_values=y_values) hawkes.set_kernel(i, j, kernel) hawkes.end_time = end_time hawkes.simulate() ticks = hawkes.timestamps # And then perform estimation with two basis kernels kernel_support = 20 n_basis = 2 em = HawkesBasisKernels(kernel_support, n_basis=n_basis, kernel_size=kernel_size, C=C, n_threads=4, max_iter=max_iter,
""" 1 dimensional Hawkes process simulation ======================================= """ from tick.plot import plot_point_process from tick.simulation import SimuHawkes, HawkesKernelSumExp import matplotlib.pyplot as plt run_time = 40 hawkes = SimuHawkes(n_nodes=1, end_time=run_time, verbose=False, seed=1398) kernel = HawkesKernelSumExp([.1, .2, .1], [1., 3., 7.]) hawkes.set_kernel(0, 0, kernel) hawkes.set_baseline(0, 1.) dt = 0.01 hawkes.track_intensity(dt) hawkes.simulate() timestamps = hawkes.timestamps intensity = hawkes.tracked_intensity intensity_times = hawkes.intensity_tracked_times _, ax = plt.subplots(1, 2, figsize=(16, 4)) plot_point_process(hawkes, n_points=50000, t_min=2, max_jumps=10, ax=ax[0]) plot_point_process(hawkes, n_points=50000, t_min=2, t_max=20, ax=ax[1]) plt.show()