def test_hawkes_mean_intensity(self):
"""...Test that Hawkes obtained mean intensity is consistent
"""
hawkes = SimuHawkes(kernels=self.kernels, baseline=self.baseline,
seed=308, end_time=300, verbose=False)
self.assertLess(hawkes.spectral_radius(), 1)
hawkes.track_intensity(0.01)
hawkes.simulate()
mean_intensity = hawkes.mean_intensity()
for i in range(hawkes.n_nodes):
self.assertAlmostEqual(np.mean(hawkes.tracked_intensity[i]),
mean_intensity[i], delta=0.3)
def SimulateBasis(kernel, baseline, time=600):
sim_em = SimuHawkes(kernels=kernel,
baseline=baseline,
verbose=False,
end_time=time)
dt = 0.001 #millisecond granularity
sim_em.track_intensity(dt)
sim_em.simulate()
timestamps = sim_em.timestamps
l = 0
for series in timestamps:
l += len(series)
print(f"Simulated {l} points")
return sim_em.timestamps
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_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)
t_values = np.array([0, 1, 1.5], dtype=float)
y_values = np.array([0, .2, 0], dtype=float)
tf1 = TimeFunction([t_values, y_values],
inter_mode=TimeFunction.InterConstRight,
dt=0.1)
kernel_1 = HawkesKernelTimeFunc(tf1)
t_values = np.array([0, .1, 2], dtype=float)
y_values = np.array([0, .4, -0.2], dtype=float)
tf2 = TimeFunction([t_values, y_values],
inter_mode=TimeFunction.InterLinear,
dt=0.1)
kernel_2 = HawkesKernelTimeFunc(tf2)
hawkes = SimuHawkes(kernels=[[kernel_1, kernel_1],
[HawkesKernelExp(.07, 4), kernel_2]],
baseline=[1.5, 1.5],
verbose=False,
seed=23983)
run_time = 40
dt = 0.01
hawkes.track_intensity(dt)
hawkes.end_time = run_time
hawkes.simulate()
fig, ax = plt.subplots(hawkes.n_nodes, 1, figsize=(14, 8))
plot_point_process(hawkes, t_max=20, ax=ax)
plt.show()