示例#1
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()
示例#2
0
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
示例#3
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)
# 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()

# %% Get attributes from Multi
示例#5
0
"""
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()