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 SimEM(smodel, time=600):
sim_em = SimuHawkes(kernels=smodel.time_kernel,
baseline=smodel.baseline,
verbose=False,
end_time=time)
sim_em.simulate()
return sim_em.timestamps
def test_simu_hawkes_multi_attrs(self):
"""...Test multiple simulations via SimuHawkesMulti vs. single Hawkes
See that multiple simulations has same attributes as a single Hawkes
simulation, but different results
"""
hawkes = SimuHawkes(kernels=self.kernels,
baseline=self.baseline,
end_time=10,
verbose=False,
seed=504)
multi = SimuHawkesMulti(hawkes, n_threads=4, n_simulations=10)
multi.simulate()
hawkes.simulate()
np.testing.assert_array_equal(hawkes.simulation_time,
multi.simulation_time)
np.testing.assert_array_equal(hawkes.n_nodes, multi.n_nodes)
np.testing.assert_array_equal(hawkes.end_time, multi.end_time)
np.testing.assert_array_equal(hawkes.max_jumps, multi.max_jumps)
np.testing.assert_array_equal(hawkes.spectral_radius(),
multi.spectral_radius)
self.assertTrue(
all(
np.array_equal(hawkes.mean_intensity(), np.array(x))
for x in multi.mean_intensity))
self.assertFalse(
np.array_equal(hawkes.n_total_jumps, multi.n_total_jumps))
def test_simu_hawkes_multi_seed(self):
"""...Test seeded Hawkes simu is re-seeded under multiple simulations
"""
seed = 504
hawkes = SimuHawkes(kernels=self.kernels,
baseline=self.baseline,
end_time=10,
verbose=False)
seeded_hawkes = SimuHawkes(kernels=self.kernels,
baseline=self.baseline,
end_time=10,
verbose=False,
seed=seed)
multi_1 = SimuHawkesMulti(seeded_hawkes, n_threads=4, n_simulations=1)
multi_2 = SimuHawkesMulti(hawkes, n_threads=4, n_simulations=1)
multi_2.seed = seed
hawkes.seed = seed
multi_3 = SimuHawkesMulti(hawkes, n_threads=4, n_simulations=1)
multi_1.simulate()
multi_2.simulate()
multi_3.simulate()
np.testing.assert_array_equal(multi_1.n_total_jumps,
multi_2.n_total_jumps)
np.testing.assert_array_equal(multi_1.n_total_jumps,
multi_3.n_total_jumps)
timestamps_1 = multi_1.timestamps
timestamps_2 = multi_2.timestamps
timestamps_3 = multi_3.timestamps
self.assertEqual(len(timestamps_1), len(timestamps_2))
self.assertEqual(len(timestamps_1), len(timestamps_3))
for (t1, t2, t3) in zip(timestamps_1, timestamps_2, timestamps_3):
np.testing.assert_array_equal(t1[0], t2[0])
np.testing.assert_array_equal(t1[1], t2[1])
np.testing.assert_array_equal(t1[0], t3[0])
np.testing.assert_array_equal(t1[1], t3[1])
def test_hawkes_set_baseline_piecewiseconstant(self):
"""...Test Hawkes process baseline set with time and value arrays
"""
baselines = [[1., 2., 1.5, 4.],
[2., 1.5, 4., 1.]]
hawkes = SimuHawkes(baseline=baselines, period_length=3.5,
kernels=self.kernels, verbose=False)
hawkes.end_time = 10
hawkes.simulate()
self.assertGreater(hawkes.n_total_jumps, 1)
def simulate_hawkes(self, model_name):
self.model_name = model_name
def y_func_pos(t_values):
y_values = 0.02 * np.exp(-t_values)
return y_values
def y_func_neg(t_values):
y_values = -0.1 * np.exp(-t_values)
return y_values
if model_name == 'hawkes_neg':
y_func = y_func_neg
elif model_name == 'hawkes_pos':
y_func = y_func_pos
t_values = np.linspace(0, 101, 100)
y_values = y_func(t_values)
tf = TimeFunction([t_values, y_values],
inter_mode=TimeFunction.InterLinear,
dt=0.1)
tf_kernel = HawkesKernelTimeFunc(tf)
N_enodes = self.G_e2n.number_of_nodes() # regarded as 'N_enodes' types
base_int = 0.2
baselines = [base_int for i in range(N_enodes)]
kernels = [[] for i in range(N_enodes)]
for i in range(N_enodes):
for j in range(N_enodes):
if i == j:
# kernels[i].append(HawkesKernel0())
kernels[i].append(HawkesKernelExp(.1, 4)) # self influence
else:
if self.G_e2n.has_edge(self.idx_elabel_map[i],
self.idx_elabel_map[j]):
kernels[i].append(tf_kernel)
else:
kernels[i].append(HawkesKernel0())
hawkes = SimuHawkes(kernels=kernels,
baseline=baselines,
verbose=False,
seed=self.seed)
hawkes.threshold_negative_intensity(allow=True)
run_time = 100
hawkes.end_time = run_time
hawkes.simulate()
timestamps = hawkes.timestamps
self.save(timestamps, self.model_name)
def test_simu_hawkes_constructor_errors(self):
"""...Test error messages raised by SimuHawkes constructor
"""
bad_baseline = np.random.rand(4)
bad_kernels = self.kernels[:, 0:1]
msg = '^kernels and baseline have different length. kernels has ' \
'length 2, whereas baseline has length 4\.$'
with self.assertRaisesRegex(ValueError, msg):
SimuHawkes(kernels=self.kernels, baseline=bad_baseline)
msg = "^n_nodes will be automatically calculated if baseline or " \
"kernels is set$"
with self.assertRaisesRegex(ValueError, msg):
SimuHawkes(kernels=self.kernels, n_nodes=2)
with self.assertRaisesRegex(ValueError, msg):
SimuHawkes(baseline=self.baseline, n_nodes=2)
msg = "^n_nodes must be given if neither kernels, nor baseline are " \
"given$"
with self.assertRaisesRegex(ValueError, msg):
SimuHawkes()
msg = '^kernels shape should be \(2, 2\) instead of \(2, 1\)$'
with self.assertRaisesRegex(ValueError, msg):
SimuHawkes(kernels=bad_kernels)
msg = '^n_nodes must be positive but equals -1$'
with self.assertRaisesRegex(ValueError, msg):
SimuHawkes(n_nodes=-1)
def test_hawkes_set_baseline_timefunction(self):
"""...Test Hawkes process baseline set with TimeFunction
"""
t_values = [0.5, 1., 2., 3.5]
y_values_1 = [1., 2., 1.5, 4.]
y_values_2 = [2., 1.5, 4., 1.]
timefunction1 = TimeFunction((t_values, y_values_1))
timefunction2 = TimeFunction((t_values, y_values_2))
hawkes = SimuHawkes(baseline=[timefunction1, timefunction2],
kernels=self.kernels, verbose=False)
hawkes.end_time = 10
hawkes.simulate()
self.assertGreater(hawkes.n_total_jumps, 1)
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_simu_hawkes_constructor(self):
"""...Test SimuHawkes constructor
"""
hawkes = SimuHawkes(kernels=self.kernels)
self.assertEqual(hawkes.n_nodes, 2)
np.testing.assert_array_equal(hawkes.baseline, np.zeros(2))
for i, j in product(range(2), range(2)):
self.assertEqual(hawkes.kernels[i, j], self.kernels[i, j])
hawkes = SimuHawkes(baseline=self.baseline)
self.assertEqual(hawkes.n_nodes, 2)
np.testing.assert_array_equal(hawkes.baseline, self.baseline)
for i, j in product(range(2), range(2)):
self.assertEqual(hawkes.kernels[i, j].__class__, HawkesKernel0)
self.assertEqual(hawkes.kernels[i, j], hawkes._kernel_0)
hawkes = SimuHawkes(n_nodes=2)
self.assertEqual(hawkes.n_nodes, 2)
np.testing.assert_array_equal(hawkes.baseline, np.zeros(2))
for i, j in product(range(2), range(2)):
self.assertEqual(hawkes.kernels[i, j].__class__, HawkesKernel0)
self.assertEqual(hawkes.kernels[i, j], hawkes._kernel_0)
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_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 test_simu_hawkes_force_simulation(self):
"""...Test force_simulation parameter of SimuHawkes
"""
diverging_kernel = [[HawkesKernelExp(2, 3)]]
hawkes = SimuHawkes(kernels=diverging_kernel, baseline=[1],
verbose=False)
hawkes.end_time = 10
msg = '^Simulation not launched as this Hawkes process is not ' \
'stable \(spectral radius of 2\). You can use ' \
'force_simulation parameter if you really want to simulate it$'
with self.assertRaisesRegex(ValueError, msg):
hawkes.simulate()
msg = "^This process has already be simulated until time 0.000000$"
with self.assertWarnsRegex(UserWarning, msg):
hawkes.end_time = 0
hawkes.force_simulation = True
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 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)
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 _corresponding_simu(self):
"""Create simulation object corresponding to the obtained coefficients
"""
return SimuHawkes()
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)
""" 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()
# We first simulate a similar Hawkes process
def g1(t):
return np.cos(np.pi * t / 10) + 1.1
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,
HawkesKernel0, HawkesSumGaussians)
end_time = 1000
n_nodes = 2
n_realizations = 10
n_gaussians = 5
timestamps_list = []
kernel_timefunction = HawkesKernelTimeFunc(
t_values=np.array([0., .7, 2.5, 3., 4.]),
y_values=np.array([.3, .03, .03, .2, 0.]))
kernels = [[HawkesKernelExp(.2, 2.),
HawkesKernelPowerLaw(.2, .5, 1.3)],
[HawkesKernel0(), kernel_timefunction]]
hawkes = SimuHawkes(baseline=[.5, .2],
kernels=kernels,
end_time=end_time,
verbose=False,
seed=1039)
multi = SimuHawkesMulti(hawkes, n_simulations=n_realizations)
multi.simulate()
learner = HawkesSumGaussians(n_gaussians, max_iter=10)
learner.fit(multi.timestamps)
plot_hawkes_kernels(learner, hawkes=hawkes, support=4)
from tick.hawkes import SimuHawkes, HawkesKernelPowerLaw, HawkesConditionalLaw
from tick.plot import plot_hawkes_kernels
multiplier = np.array([0.012, 0.008, 0.004, 0.005])
cutoff = 0.0005
exponent = 1.3
support = 2000
hawkes = SimuHawkes(kernels=[[
HawkesKernelPowerLaw(multiplier[0], cutoff, exponent, support),
HawkesKernelPowerLaw(multiplier[1], cutoff, exponent, support)
],
[
HawkesKernelPowerLaw(multiplier[2], cutoff,
exponent, support),
HawkesKernelPowerLaw(multiplier[3], cutoff,
exponent, support)
]],
baseline=[0.05, 0.05],
seed=382,
verbose=False)
hawkes.end_time = 50000
hawkes.simulate()
e = HawkesConditionalLaw(claw_method="log",
delta_lag=0.1,
min_lag=0.002,
max_lag=100,
quad_method="log",
n_quad=50,
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()
# intensity = hawkes.tracked_intensity # intensity_times = hawkes.intensity_tracked_times # mean_intensity = hawkes.mean_intensity() # %% Plot jumps # pd.Series(np.arange(1, len(timestamps[0])+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()
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])
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])