def _impulse(self, dt, mu, tau): from pyhawkes.utils.utils import logit # map dt onto support x = self.translate_dt(dt) # get prob at scaled x Z = x * (1. - x) * np.sqrt(2 * np.pi / tau) return (1. / Z) * np.exp(-tau / 2. * (logit(x) - mu)**2)
def impulse(self, dt, k1, k2): """ Impulse response induced by an event on process k1 on the rate of process k2 at lag dt """ from pyhawkes.utils.utils import logit mu, tau, dt_max = self.mu[k1,k2], self.tau[k1,k2], self.dt_max Z = dt * (dt_max - dt)/dt_max * np.sqrt(2*np.pi/tau) return 1./Z * np.exp(-tau/2. * (logit(dt/dt_max) - mu)**2)
def impulse(self, dt, k1, k2): """ Impulse response induced by an event on process k1 on the rate of process k2 at lag dt """ from pyhawkes.utils.utils import logit mu, tau, dt_max = self.mu[k1, k2], self.tau[k1, k2], self.dt_max Z = dt * (dt_max - dt) / dt_max * np.sqrt(2 * np.pi / tau) return 1. / Z * np.exp(-tau / 2. * (logit(dt / dt_max) - mu)**2)
def impulse(self, dt, k1, k2, delay=0): """ Impulse response induced by an event on process k1 on the rate of process k2 at lag dt """ # delay added dt = dt - self.delay[k1][k2] from pyhawkes.utils.utils import logit mu, tau, dt_max = self.mu[k1, k2], self.tau[k1, k2], self.dt_max Z = dt * (dt_max - dt) / dt_max * np.sqrt(2 * np.pi / tau) temp = 1. / Z * np.exp(-tau / 2. * (logit(dt / dt_max) - mu)**2) # should be -inf temp[dt < 0] = 0 return temp
def meanfieldupdate_p(self, stepsize=1.0): """ Update p given the network parameters and the current variational parameters of the weight distributions. :return: """ logit_p = self.network.expected_log_p() - self.network.expected_log_notp() logit_p += self.network.kappa * self.network.expected_log_v() - gammaln(self.network.kappa) logit_p += gammaln(self.mf_kappa_1) - self.mf_kappa_1 * np.log(self.mf_v_1) logit_p += gammaln(self.kappa_0) - self.kappa_0 * np.log(self.nu_0) logit_p += self.mf_kappa_0 * np.log(self.mf_v_0) - gammaln(self.mf_kappa_0) # p_hat = logistic(logit_p) # self.mf_p = (1.0 - stepsize) * self.mf_p + stepsize * p_hat logit_p_hat = (1-stepsize) * logit(self.mf_p) + \ stepsize * logit_p # self.mf_p = logistic(logit_p_hat) self.mf_p = np.clip(logistic(logit_p_hat), 1e-8, 1-1e-8)
def meanfieldupdate_p(self, stepsize=1.0): """ Update p given the network parameters and the current variational parameters of the weight distributions. :return: """ logit_p = self.network.expected_log_p( ) - self.network.expected_log_notp() logit_p += self.network.kappa * self.network.expected_log_v( ) - gammaln(self.network.kappa) logit_p += gammaln( self.mf_kappa_1) - self.mf_kappa_1 * np.log(self.mf_v_1) logit_p += gammaln(self.kappa_0) - self.kappa_0 * np.log(self.nu_0) logit_p += self.mf_kappa_0 * np.log(self.mf_v_0) - gammaln( self.mf_kappa_0) # p_hat = logistic(logit_p) # self.mf_p = (1.0 - stepsize) * self.mf_p + stepsize * p_hat logit_p_hat = (1-stepsize) * logit(self.mf_p) + \ stepsize * logit_p # self.mf_p = logistic(logit_p_hat) self.mf_p = np.clip(logistic(logit_p_hat), 1e-8, 1 - 1e-8)
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()