def __init__(self,
model,
mu_0=0.,
lmbda_0=1.,
alpha_0=1.,
beta_0=1.,
delay_0=0.0,
normal_mu=0.1,
normal_sig=0.3):
self.model = model
self.K = model.K
self.dt_max = model.dt_max
self.mu_0 = mu_0
self.lmbda_0 = lmbda_0
self.alpha_0 = alpha_0
self.beta_0 = beta_0
self.delay_0 = delay_0
self.normal_sig = normal_sig
self.normal_mu = normal_mu
self.delay = self.normal_mu * np.ones((self.K, self.K), dtype='double')
from pyhawkes.utils.utils import sample_nig
self.mu, self.tau = \
sample_nig(self.mu_0 * np.ones((self.K, self.K)),
self.lmbda_0 * np.ones((self.K, self.K)),
self.alpha_0 * np.ones((self.K, self.K)),
self.beta_0 * np.ones((self.K, self.K)))
def resample(self, data=[]):
"""
Resample the
:param data: a TxKxKxB array of parents. T time bins, K processes,
K parent processes, and B bases for each parent process.
"""
mu_0, lmbda_0, alpha_0, beta_0 = self.mu_0, self.lmbda_0, self.alpha_0, self.beta_0
assert data is None or isinstance(data, list)
# 0: count, # 1: Sum of scaled dt, #2: Sum of sq scaled dt
ss = np.zeros((3, self.K, self.K))
for d in data:
ss += d.compute_imp_suff_stats()
n = ss[0]
xbar = np.nan_to_num(ss[1] / n)
xvar = ss[2]
alpha_post = alpha_0 + n / 2.
# beta_post = beta_0 + 0.5 * xvar
# beta_post += 0.5 * lmbda_0 * n / (lmbda_0 + n) * (xbar-mu_0)**2
beta_post = beta_0 + 0.5 * xvar + 0.5 * lmbda_0 * n * (xbar-mu_0)**2 / (lmbda_0+n)
lmbda_post = lmbda_0 + n
mu_post = (lmbda_0 * mu_0 + n * xbar) / (lmbda_0 + n)
from pyhawkes.utils.utils import sample_nig
self.mu, self.tau = \
sample_nig(mu_post, lmbda_post, alpha_post, beta_post)
assert np.isfinite(self.mu).all()
assert np.isfinite(self.tau).all()
def test_sample_nig():
mu_0 = 0.0
lmbda_0 = 10.
alpha_0 = 10.
beta_0 = 10.
# Directly sample nig and lookg at marginals
from pyhawkes.utils.utils import sample_nig
mu_samples = \
np.array([sample_nig(mu_0, lmbda_0, alpha_0, beta_0)[0]
for _ in range(10000)])
# Plot the histogram of impulse means
plt.figure()
p_mu = t(df=2*alpha_0,
loc=mu_0,
scale=np.sqrt(beta_0/(alpha_0*lmbda_0)))
_, bins, _ = plt.hist(mu_samples, bins=50, alpha=0.5, normed=True)
bincenters = 0.5*(bins[1:]+bins[:-1])
plt.plot(bincenters, p_mu.pdf(bincenters), 'r--', linewidth=1)
plt.xlabel('mu')
plt.ylabel('p(mu)')
plt.figure()
probplot(mu_samples, dist=p_mu, plot=plt.gca())
plt.show()
def resample(self, data=[]):
"""
Resample the
:param data: a TxKxKxB array of parents. T time bins, K processes,
K parent processes, and B bases for each parent process.
"""
mu_0, lmbda_0, alpha_0, beta_0 = self.mu_0, self.lmbda_0, self.alpha_0, self.beta_0
assert data is None or isinstance(data, list)
# 0: count, # 1: Sum of scaled dt, #2: Sum of sq scaled dt
ss = np.zeros((3, self.K, self.K))
for d in data:
ss += d.compute_imp_suff_stats()
n = ss[0]
xbar = np.nan_to_num(ss[1] / n)
xvar = ss[2]
alpha_post = alpha_0 + n / 2.
# beta_post = beta_0 + 0.5 * xvar
# beta_post += 0.5 * lmbda_0 * n / (lmbda_0 + n) * (xbar-mu_0)**2
beta_post = beta_0 + 0.5 * xvar + 0.5 * lmbda_0 * n * (
xbar - mu_0)**2 / (lmbda_0 + n)
lmbda_post = lmbda_0 + n
mu_post = (lmbda_0 * mu_0 + n * xbar) / (lmbda_0 + n)
from pyhawkes.utils.utils import sample_nig
self.mu, self.tau = \
sample_nig(mu_post, lmbda_post, alpha_post, beta_post)
assert np.isfinite(self.mu).all()
assert np.isfinite(self.tau).all()
def test_sample_nig():
mu_0 = 0.0
lmbda_0 = 10.0
alpha_0 = 10.0
beta_0 = 10.0
# Directly sample nig and lookg at marginals
from pyhawkes.utils.utils import sample_nig
mu_samples = np.array([sample_nig(mu_0, lmbda_0, alpha_0, beta_0)[0] for _ in xrange(10000)])
# Plot the histogram of impulse means
plt.figure()
p_mu = t(df=2 * alpha_0, loc=mu_0, scale=np.sqrt(beta_0 / (alpha_0 * lmbda_0)))
_, bins, _ = plt.hist(mu_samples, bins=50, alpha=0.5, normed=True)
bincenters = 0.5 * (bins[1:] + bins[:-1])
plt.plot(bincenters, p_mu.pdf(bincenters), "r--", linewidth=1)
plt.xlabel("mu")
plt.ylabel("p(mu)")
plt.figure()
probplot(mu_samples, dist=p_mu, plot=plt.gca())
plt.show()
def __init__(self,
model,
mu_0=0.,
lmbda_0=1.,
alpha_0=1.,
beta_0=1.,
support=None):
self.model = model
self.K = model.K
self.dt_max = model.dt_max
if support is None:
self.support = (0.05, 0.95)
else:
assert len(support) == 2 and support[0] >= 0 and support[1] <= 1
self.support = (float(support[0]), float(support[1]))
self.support_width = self.support[1] - self.support[0]
assert self.support_width > 0
self.mu_0 = mu_0
self.lmbda_0 = lmbda_0
self.alpha_0 = alpha_0
self.beta_0 = beta_0
from pyhawkes.utils.utils import sample_nig
self.mu, self.tau = \
sample_nig(self.mu_0 * np.ones((self.K, self.K)),
self.lmbda_0 * np.ones((self.K, self.K)),
self.alpha_0 * np.ones((self.K, self.K)),
self.beta_0 * np.ones((self.K, self.K)))
def __init__(self, model, mu_0=0., lmbda_0=1., alpha_0=1., beta_0=1.):
self.model = model
self.K = model.K
self.dt_max = model.dt_max
self.mu_0 = mu_0
self.lmbda_0 = lmbda_0
self.alpha_0 = alpha_0
self.beta_0 = beta_0
from pyhawkes.utils.utils import sample_nig
self.mu, self.tau = \
sample_nig(self.mu_0 * np.ones((self.K, self.K)),
self.lmbda_0 * np.ones((self.K, self.K)),
self.alpha_0 * np.ones((self.K, self.K)),
self.beta_0 * np.ones((self.K, self.K)))
def __init__(self, model, mu_0=0., lmbda_0=1., alpha_0=1., beta_0=1.):
self.model = model
self.K = model.K
self.dt_max = model.dt_max
self.mu_0 = mu_0
self.lmbda_0 = lmbda_0
self.alpha_0 = alpha_0
self.beta_0 = beta_0
from pyhawkes.utils.utils import sample_nig
self.mu, self.tau = \
sample_nig(self.mu_0 * np.ones((self.K, self.K)),
self.lmbda_0 * np.ones((self.K, self.K)),
self.alpha_0 * np.ones((self.K, self.K)),
self.beta_0 * np.ones((self.K, self.K)))
def resample(self, data=[]):
"""
Resample the
: param data: a TxKxKxB array of parents. T time bins, K processes,
K parent processes, and B bases for each parent process.
"""
assert data is None or isinstance(data, list)
mu_post, lmbda_post, alpha_post, beta_post = self._get_conditional_distribution(
data)
from pyhawkes.utils.utils import sample_nig
self.mu, self.tau = \
sample_nig(mu_post, lmbda_post, alpha_post, beta_post)
assert np.isfinite(self.mu).all()
assert np.isfinite(self.tau).all()
def resample(self, data=[]):
# get posterior gamma distribution shapes
mu_post, tau_post = self._get_conditional_distribution(data)
# check
assert np.isfinite(self.mu).all()
assert np.isfinite(self.tau).all()
self.mu = mu_post
self.tau = tau_post
mu_post, lmbda_post, alpha_post, beta_post = self._get_conditional_distribution(
data)
from pyhawkes.utils.utils import sample_nig
self.mu, self.tau = \
sample_nig(mu_post, lmbda_post, alpha_post, beta_post)
assert np.isfinite(self.mu).all()
assert np.isfinite(self.tau).all()
def resample(self, data=[]):
"""
Resample the
:param data: a TxKxKxB array of parents. T time bins, K processes,
K parent processes, and B bases for each parent process.
"""
mu_0, lmbda_0, alpha_0, beta_0 = self.mu_0, self.lmbda_0, self.alpha_0, self.beta_0
assert data is None or isinstance(data, list)
# 0: count, # 1: Sum of scaled dt, #2: Sum of sq scaled dt
ss = np.zeros((3, self.K, self.K))
for d in data:
ss += d.compute_imp_suff_stats()
n = ss[0]
xbar = np.nan_to_num(ss[1] / n)
xvar = ss[2]
alpha_post = alpha_0 + n / 2.
# beta_post = beta_0 + 0.5 * xvar
# beta_post += 0.5 * lmbda_0 * n / (lmbda_0 + n) * (xbar-mu_0)**2
beta_post = beta_0 + 0.5 * xvar + 0.5 * lmbda_0 * n * (
xbar - mu_0)**2 / (lmbda_0 + n)
lmbda_post = lmbda_0 + n
mu_post = (lmbda_0 * mu_0 + n * xbar) / (lmbda_0 + n)
from pyhawkes.utils.utils import sample_nig
self.mu, self.tau = \
sample_nig(mu_post, lmbda_post, alpha_post, beta_post)
# Z is parent
# C is process
# S is event time
S = [x.S for x in self.model.data_list]
C = [x.C for x in self.model.data_list]
Z = [x.Z for x in self.model.data_list]
N_pts = 50
t = np.linspace(0, self.dt_max, N_pts)
pt = np.zeros(N_pts)
normal_sig = self.normal_sig
normal_mu = self.normal_mu
pt_prior = np.exp(-(t - normal_mu)**2 / (2 * normal_sig**2)) / np.sqrt(
2 * np.pi * normal_sig**2)
dt_max = self.dt_max
for k1 in range(self.K):
for k2 in range(self.K):
tt = np.zeros(N_pts)
gt = np.ones(N_pts)
for i in range(len(S)):
s, c, z = S[i], C[i], Z[i]
cind, pind = (c == k2), (c[z] == k1)
igmask = (z != -1) # no parent
inds = cind & pind & igmask
if ~np.all(~inds):
ds = s[inds] - s[z[inds]]
'''
if min(ds) < min(t):
print k1,k2
exit(0)
'''
ll = -utils.logit(
np.absolute(ds[None, :] - t[:, None]), dt_max)
# logit grows too fast
ll = np.minimum(ll, 100)
ll = np.maximum(ll, -100)
ll = (ll * self.tau[k1][k2] / 2 - self.mu[k1][k2])**2
tt = tt + np.sum(ll, 1)
gt[t > min(ds)] = 0.0
tt = np.cumsum(pt_prior * np.exp(tt - np.max(tt)) * gt)
if (tt == 0).all():
self.delay[k1][k2] = 0
#tt = np.cumsum(pt_prior)
#delay = t[np.flatnonzero(tt > np.random.uniform(0,tt[-1]))[0]]
#self.delay[k1][k2] = delay
else:
# exp grows too fast, normalize by e^-max(tt)
delay = -t[np.flatnonzero(
tt > np.random.uniform(0, tt[-1]))[0]]
self.delay[k1][k2] = delay
assert np.isfinite(self.mu).all()
assert np.isfinite(self.tau).all()