def simulate_NHP(run_time, T, Y, dt_, track):
#run_time = 30
#T = np.arange((run_time * 0.9) * 5, dtype=float) / 5
#Y = np.maximum(
# 15 * np.sin(T) * (np.divide(np.ones_like(T),
# np.sqrt(T + 1) + 0.1 * T)), 0.001)
tf = TimeFunction((T, Y), dt=dt_)
# We define a 1 dimensional inhomogeneous Poisson process with the
# intensity function seen above
in_poi = SimuInhomogeneousPoisson([tf],
end_time=run_time,
verbose=True,
seed=3) #, max_jumps=sum(Y))
# We activate intensity tracking and launch simulation
in_poi.track_intensity(track)
in_poi.threshold_negative_intensity(allow=True)
in_poi.simulate()
# We plot the resulting inhomogeneous Poisson process with its
# intensity and its ticks over time
plot_point_process(in_poi)
return list(in_poi.tracked_intensity[0]), list(
in_poi.intensity_tracked_times)
def generate_times_opt(max_t, delta, vreme_c, c_var, vreme, Lambda):
time = np.arange(delta,max_t, delta)
c_value_t = C_value(time,vreme_c,c_var)
lamb_val_t = Lambda_value(time,vreme,Lambda)/c_value_t
tf = TimeFunction((time, lamb_val_t), dt=delta)
Psim = SimuInhomogeneousPoisson([tf], end_time = max_t, verbose = False)
Psim.simulate()
simulacija = Psim.timestamps
plot_point_process(Psim)
return simulacija
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()
hawkes_exp_kernels.track_intensity(0.1)
hawkes_exp_kernels.simulate()
learner = HawkesSumExpKern(decays, penalty='elasticnet',
elastic_net_ratio=0.8)
learner.fit(hawkes_exp_kernels.timestamps)
t_min = 100
t_max = 200
fig, ax_list = plt.subplots(2, 1, figsize=(10, 6))
learner.plot_estimated_intensity(hawkes_exp_kernels.timestamps,
t_min=t_min, t_max=t_max,
ax=ax_list)
plot_point_process(hawkes_exp_kernels, plot_intensity=True,
t_min=t_min, t_max=t_max, ax=ax_list)
# Enhance plot
for ax in ax_list:
# Set labels to both plots
ax.lines[0].set_label('estimated')
ax.lines[1].set_label('original')
# Change original intensity style
ax.lines[1].set_linestyle('--')
ax.lines[1].set_alpha(0.8)
# avoid duplication of scatter plots of events
ax.collections[1].set_alpha(0)
ax.legend()
def plot_estimated_intensity(self,
events,
n_points=10000,
plot_nodes=None,
t_min=None,
t_max=None,
intensity_track_step=None,
max_jumps=None,
show=True,
ax=None):
"""Plot value of intensity for a given realization with the fitted
parameters
events : `list` of `np.ndarray`, default = None
One Hawkes processes realization, a list of n_node for
each component of the Hawkes. Namely `events[i]` contains a
one-dimensional `numpy.array` of the events' timestamps of
component i.
n_points : `int`, default=10000
Number of points used for intensity plot.
plot_nodes : `list` of `int`, default=`None`
List of nodes that will be plotted. If `None`, all nodes are
considered
t_min : `float`, default=`None`
If not `None`, time at which plot will start
t_max : `float`, default=`None`
If not `None`, time at which plot will stop
intensity_track_step : `float`, default=`None`
Defines how often intensity will be computed. If this is too low,
computations might be long. By default, a value will be
extrapolated from (t_max - t_min) / n_points.
max_jumps : `int`, default=`None`
If not `None`, maximum of jumps per coordinate that will be plotted.
This is useful when plotting big point processes to ensure a only
readable part of them will be plotted
show : `bool`, default=`True`
if `True`, show the plot. Otherwise an explicit call to the show
function is necessary. Useful when superposing several plots.
ax : `list` of `matplotlib.axes`, default=None
If not None, the figure will be plot on this axis and show will be
set to False.
"""
simu = self._corresponding_simu()
end_time = max(map(max, events))
if t_max is not None:
end_time = max(end_time, t_max)
if intensity_track_step is None:
display_start_time = 0
if t_min is not None:
display_start_time = t_min
display_end_time = end_time
if t_min is not None:
display_start_time = t_min
intensity_track_step = (display_end_time - display_start_time) \
/ n_points
simu.track_intensity(intensity_track_step)
simu.set_timestamps(events, end_time)
plot_point_process(simu,
plot_intensity=True,
n_points=n_points,
plot_nodes=plot_nodes,
t_min=t_min,
t_max=t_max,
max_jumps=max_jumps,
show=show,
ax=ax)
decay = 0.1
adjacency = np.array([[0.5]])
hawkes = SimuHawkesExpKernels(adjacency,
decay,
baseline=baselines,
seed=2093,
verbose=False)
hawkes.track_intensity(0.1)
hawkes.end_time = 6 * period_length
hawkes.simulate()
fig, ax = plt.subplots(1, 1, figsize=(10, 4))
plot_point_process(hawkes, ax=ax)
t_values = np.linspace(0, hawkes.end_time, 1000)
ax.plot(t_values,
hawkes.get_baseline_values(0, t_values),
label='baseline',
ls='--',
lw=1)
ax.set_ylabel("$\lambda(t)$", fontsize=18)
ax.legend()
plt.title("Intensity Hawkes process with exponential kernel and varying "
"baseline")
fig.tight_layout()
plt.show()
""" 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()
This example show how to simulate any inhomogeneous Poisson process. Its
intensity is modeled through `tick.base.TimeFunction`
"""
import numpy as np
from tick.base import TimeFunction
from tick.plot import plot_point_process
from tick.simulation.inhomogeneous_poisson import SimuInhomogeneousPoisson
run_time = 30
T = np.arange((run_time * 0.9) * 5, dtype=float) / 5
Y = np.maximum(15 * np.sin(T) * (np.divide(np.ones_like(T),
np.sqrt(T + 1) + 0.1 * T)), 0.001)
tf = TimeFunction((T, Y), dt=0.01)
# We define a 1 dimensional inhomogeneous Poisson process with the
# intensity function seen above
in_poi = SimuInhomogeneousPoisson([tf], end_time=run_time, verbose=False)
# We activate intensity tracking and launch simulation
in_poi.track_intensity(0.1)
in_poi.simulate()
# We plot the resulting inhomogeneous Poisson process with its
# intensity and its ticks over time
plot_point_process(in_poi)
from tick.hawkes import SimuPoissonProcess from tick.plot import plot_point_process run_time = 10 intensity = 5 poi = SimuPoissonProcess(intensity, end_time=run_time, verbose=False) poi.simulate() plot_point_process(poi)