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 goodness_of_fit_nonpar(nplearner, arrivals, timestep, method): # setup simulation object hp = SimuHawkes(baseline=nplearner.baseline) # set kernels support = np.arange(0, np.max(nplearner.get_kernel_supports()), timestep) for i, j in itertools.product(range(nplearner.n_nodes), repeat=2): print('Kernel {} set.'.format([i, j])) y = nplearner.get_kernel_values(i, j, support) kernel = HawkesKernelTimeFunc(t_values=support, y_values=y) hp.set_kernel(i, j, kernel) hp.track_intensity(timestep) hp.set_timestamps(timestamps=arrivals) dimension = hp.n_nodes intensities = hp.tracked_intensity x = hp.intensity_tracked_times residuals = [resid(x, intensities, arrivals, dim, method) for dim in range(dimension)] return residuals
def generate_points(n_processes, mu, alpha, decay, window, seed, dt=0.01): """ Generates points of an marked Hawkes processes using the tick library """ hawkes = SimuHawkes(n_nodes=n_processes, end_time=window, verbose=False, seed=seed) for i in range(n_processes): for j in range(n_processes): hawkes.set_kernel(i=i, j=j, kernel=HawkesKernelExp(intensity=alpha[i][j] / decay[i][j], decay=decay[i][j])) hawkes.set_baseline(i, mu[i]) hawkes.track_intensity(dt) hawkes.simulate() return hawkes.timestamps
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)
# index=timestamps[0]).plot(drawstyle='steps-post') # %% Plot point express # plot_point_process(hawkes) # %% [markdown] # ### SimuHawkesMulti # %% Simulate with Multi hawkes_m1 = SimuHawkes(n_nodes=1, end_time=10000) hawkes_m1.set_baseline(0, 1.) hawkes_m2 = SimuHawkes(n_nodes=1, end_time=10000) hawkes_m2.set_baseline(0, 1.) hawkes_m1.set_kernel(0, 0, kernel_1) hawkes_m2.set_kernel(0, 0, kernel_2) # %% Run Multi multi_1 = SimuHawkesMulti(hawkes_m1, n_simulations=100) multi_1.simulate() multi_2 = SimuHawkesMulti(hawkes_m2, n_simulations=100) multi_2.simulate() # %% Get attributes from Multi multi_1_timestamps = multi_1.timestamps # multi_1_mean_intensity = multi_1.mean_intensity multi_2_timestamps = multi_2.timestamps # multi_2_mean_intensity = multi_2.mean_intensity
""" 1 dimensional Hawkes process simulation ======================================= """ from tick.plot import plot_point_process from tick.hawkes 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, .4, .1, .3], [3., 3., 7., 31]) 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, figsize=(8, 4)) plot_point_process(hawkes, n_points=50000, t_min=2, max_jumps=10, ax=ax) 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,
def test_HawkesEM(): print('\n##############################') print('\nstarting: test_HawkesEM()\n') run_time = 30000 t_values1 = np.array([0, 1, 1.5, 2., 3.5], dtype=float) y_values1 = np.array([0, 0.2, 0, 0.1, 0.], dtype=float) tf1 = TimeFunction( [t_values1, y_values1], 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]) ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### realizations = list() for i in range(0,1000): print( '' ) temp_seed = int(1000 + 1000 * random.random()) print('i = ' + str(i) + ', temp_seed = ' + str(temp_seed)); hawkes = SimuHawkes( baseline = baseline, end_time = run_time, verbose = False, seed = temp_seed ) hawkes.set_kernel(0, 0, kernel1) hawkes.set_kernel(0, 1, HawkesKernelExp(.5, .7)) hawkes.set_kernel(1, 1, kernel2) hawkes.simulate() temp_realization = hawkes.timestamps; print( 'i = ' + str(i) + ', ' + 'event counts = (' + str(len(temp_realization[0])) + ',' + str(len(temp_realization[1])) + ')' ); print( temp_realization ) realizations.append( temp_realization ); ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### em = HawkesEM(4, kernel_size=16, n_threads=8, verbose=False, tol=1e-3) em.fit(events = realizations) fig = plot_hawkes_kernels(em, hawkes=hawkes, show=False) outputFILE = 'test-HawkesEM.png' for ax in fig.axes: ax.set_ylim([0, 1]) plt.savefig(fname = outputFILE, bbox_inches='tight', pad_inches=0.2) ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### print('\nexitng: test_HawkesEM()') print('\n##############################') return( None )
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_HawkesEM(): print('\n##############################') print('\nstarting: test_HawkesEM()\n') run_time = 30000 t_values1 = np.array([0, 1, 1.5, 2., 3.5], dtype=float) y_values1 = np.array([0, 0.2, 0, 0.1, 0.], dtype=float) tf1 = TimeFunction([t_values1, y_values1], 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]) ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### realizations = list() for i in range(0, 1000): print('') temp_seed = int(1000 + 1000 * random.random()) print('i = ' + str(i) + ', temp_seed = ' + str(temp_seed)) hawkes = SimuHawkes(baseline=baseline, end_time=run_time, verbose=False, seed=temp_seed) hawkes.set_kernel(0, 0, kernel1) hawkes.set_kernel(0, 1, HawkesKernelExp(.5, .7)) hawkes.set_kernel(1, 1, kernel2) hawkes.simulate() temp_realization = hawkes.timestamps print('i = ' + str(i) + ', ' + 'event counts = (' + str(len(temp_realization[0])) + ',' + str(len(temp_realization[1])) + ')') print(temp_realization) realizations.append(temp_realization) ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### em = HawkesEM(4, kernel_size=16, n_threads=8, verbose=False, tol=1e-3) em.fit(events=realizations) fig = plot_hawkes_kernels(em, hawkes=hawkes, show=False) outputFILE = 'test-HawkesEM.png' for ax in fig.axes: ax.set_ylim([0, 1]) plt.savefig(fname=outputFILE, bbox_inches='tight', pad_inches=0.2) ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### print('\nexitng: test_HawkesEM()') print('\n##############################') return (None)