def setUp(self):
np.random.seed(28374)
self.kernels = np.array([
[HawkesKernel0(), HawkesKernelExp(0.1, 3)],
[HawkesKernelPowerLaw(0.2, 4, 2),
HawkesKernelSumExp([0.1, 0.4], [3, 4])]
])
self.baseline = np.random.rand(2)
def setUp(self):
np.random.seed(28374)
self.kernels = np.array([
[HawkesKernel0(), HawkesKernelExp(0.1, 3)],
[HawkesKernelPowerLaw(0.2, 4, 2),
HawkesKernelSumExp([0.1, 0.4], [3, 4])]
])
t_values = np.linspace(0, 10, 10)
y_values = np.maximum(0.5 + np.sin(t_values), 0)
self.time_func_kernel = HawkesKernelTimeFunc(t_values=t_values,
y_values=y_values)
self.baseline = np.random.rand(2)
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_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 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()
import numpy as np
import matplotlib.pyplot as plt
from tick.simulation import HawkesKernel0, HawkesKernelExp, \
HawkesKernelPowerLaw, HawkesKernelTimeFunc
kernel_0 = HawkesKernel0()
kernel_exp = HawkesKernelExp(.7, 1.3)
kernel_pl = HawkesKernelPowerLaw(.1, .2, 0.7)
t_values = np.array([0, 1, 1.5, 1.8, 2.7])
y_values = np.array([0, .6, .34, .2, .1])
kernel_tf = HawkesKernelTimeFunc(t_values=t_values, y_values=y_values)
kernels = [[kernel_0, kernel_exp], [kernel_pl, kernel_tf]]
fig, ax = plt.subplots(2, 2, sharex=True, sharey=True, figsize=(10, 4))
t_values = np.linspace(0, 3, 100)
for i in range(2):
for j in range(2):
ax[i, j].plot(t_values,
kernels[i][j].get_values(t_values),
label=kernels[i][j])
ax[i, j].legend()
plt.show()
from tick.simulation import (SimuHawkes, SimuHawkesMulti, HawkesKernelExp,
HawkesKernelTimeFunc, HawkesKernelPowerLaw,
HawkesKernel0)
from tick.inference import 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)
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()