def generate_posterior_predictive_gammas(self, n_per_sample=1, m=10):
new_gammas = []
for s in range(self.nSamp):
dmax = self.samples.delta[s].max()
njs = cu.counter(self.samples.delta[s], int(dmax + 1 + m))
ljs = njs + (njs == 0) * self.samples.eta[s] / m
new_zetas = gamma(
shape=self.samples.alpha[s],
scale=1. / self.samples.beta[s],
size=(m, self.nCol),
)
new_sigmas = np.hstack((
np.ones((m, 1)),
gamma(
shape=self.samples.xi[s],
scale=self.samples.tau[s],
size=(m, self.nCol - 1),
),
))
prob = ljs / ljs.sum()
deltas = cu.generate_indices(prob, n_per_sample)
zeta = np.vstack((self.samples.zeta[s], new_zetas))[deltas]
sigma = np.vstack((self.samples.sigma[s], new_sigmas))[deltas]
new_gammas.append(gamma(shape=zeta, scale=1 / sigma))
return np.vstack(new_gammas)
def generate_posterior_predictive_gammas(self, n_per_sample=2):
new_gammas = np.empty((self.nSamp, n_per_sample, self.nCol))
for i in range(self.nSamp):
dnew = cu.generate_indices(self.samples.pi[i], n_per_sample)
alpha = self.samples.alpha[i][dnew]
new_gammas[i] = gamma(shape=alpha)
return new_gammas.reshape(self.nSamp * n_per_sample, self.nCol)
def generate_posterior_predictive_gammas(self, n_per_sample):
dnew = np.array(list(map(lambda x: cu.generate_indices(x, n_per_sample), self.samples.pi)))
gnew = np.vstack([
gamma(zeta[delta], scale = 1 / sigma[delta])
for zeta, sigma, delta in
zip(self.samples.zeta, self.samples.sigma, dnew)
])
return gnew
def generate_posterior_predictive_gammas(self, n_per_sample = 10, m = 20):
new_gammas = []
for i in range(self.nSamp):
dmax = self.samples.delta[i].max()
njs = cu.counter(self.samples.delta[i], dmax + 1 + m)
ljs = njs + (njs == 0) * self.samples.eta[i] / m
# This part needs to be fixed.
new_alphas = self.generate_alpha_new(self.samples.mu[i], self.samples.Sigma[i], m)
prob = ljs / ljs.sum()
deltas = cu.generate_indices(prob, n_per_sample)
alpha = np.vstack((self.samples.alpha[i], new_alphas))[deltas]
new_gammas.append(gamma(shape = alpha))
new_gamma_arr = np.vstack(new_gammas)
return new_gamma_arr
def generate_posterior_predictive_gammas(self, n_per_sample=10, m=20):
new_gammas = []
for s in range(self.nSamp):
dmax = self.samples.delta[s].max()
njs = cu.counter(self.samples.delta[s], int(dmax + 1 + m))
ljs = njs + (njs == 0) * self.samples.eta[s] / m
gnew = binomial(size=(m, self.nCol), n=1, p=self.samples.rho[s])
anew = self.samples.alpha[s][0] * (
1 - gnew) + self.samples.alpha[s][1] * gnew
bnew = self.samples.beta[s][0] * (
1 - gnew) + self.samples.beta[s][1] * gnew
new_zetas = gamma(shape=anew, scale=1. / bnew, size=(m, self.nCol))
prob = ljs / ljs.sum()
deltas = cu.generate_indices(prob, n_per_sample)
zeta = np.vstack((self.samples.zeta[s], new_zetas))[deltas]
new_gammas.append(gamma(shape=zeta))
return np.vstack(new_gammas)
def generate_posterior_predictive_gammas(self, n_per_sample=1, m=10):
new_gammas = []
for s in range(self.nSamp):
dmax = self.samples.delta[s].max()
njs = np.bincount(self.samples.delta[s],
minlength=int(dmax + 1 + m))
ljs = njs + (njs == 0) * self.samples.eta[s] / m
new_zetas = gamma(
shape=self.samples.alpha[s],
scale=1. / self.samples.beta[s],
size=(m, self.nCat),
)
prob = ljs / ljs.sum()
deltas = generate_indices(prob, n_per_sample)
zeta = np.vstack((self.samples.zeta[s], new_zetas))[deltas]
new_gammas.append(gamma(shape=zeta))
return np.vstack(new_gammas)
def generate_posterior_predictive_gammas(self, n_per_sample = 1, m = 10):
new_gammas = []
for s in range(self.nSamp):
njs = np.bincount(
self.samples.delta[s],
minlength = int(self.samples.delta[s].max() + 1 + m),
)
ljs = njs + (njs == 0) * self.samples.eta[s] / m
new_zetas = np.exp(
+ self.samples.mu[s].reshape(1,self.nCol)
+ (cholesky(self.samples.Sigma[s]) @ normal(size = (self.nCol, m))).T
)
prob = ljs / ljs.sum()
deltas = generate_indices(prob, n_per_sample)
zeta = np.vstack((self.samples.zeta[s], new_zetas))[deltas]
new_gammas.append(gamma(shape = zeta))
return np.vstack(new_gammas)
def generate_posterior_predictive_probit(self, n_per_sample, m=20):
new_pVis = []
for i in range(self.nSamp):
dmax = self.samples.delta[i].max()
# njs = cu.counter(self.samples.delta[i], dmax + 1 + m)
# ljs = njs + (njs == 0) * self.samples.eta[i] / m
njs = cu.counter(self.samples.delta[i], dmax + 1)
ljs = njs
# new_mus = self.samples.mu0[i] + \
# self.samples.Sigma0[i] @ normal.rvs(size = (m, self.nCol))
# new_Sigmas =
prob = ljs / ljs.sum()
deltas = cu.generate_indices(prob, n_per_sample)
mus = self.samples.mu[i][deltas]
Sigmas = self.samples.Sigma[i][deltas]
for j in range(n_per_sample):
new_pVis.append(
mus[j] + cholesky(Sigmas[j]) @ normal(size=self.nCol - 1))
return self.invprobit(np.vstack(new_pVis))
def generate_posterior_predictive_gammas(self, n_per_sample=1, m=10):
new_gammas = []
for s in range(self.nSamp):
dmax = self.samples.delta[s].max()
njs = np.bincount(self.samples.delta[s],
minlength=int(dmax + 1 + m))
ljs = njs + (njs == 0) * self.samples.eta[s] / m
new_zetas = gamma(
shape=self.samples.alpha[s],
scale=1. / self.samples.beta[s],
size=(m, self.nCol + self.nCat),
)
new_sigmas = np.ones(new_zetas.shape)
new_sigmas[:, np.where(~self.sigma_unity)[0]] = gamma(
shape=self.samples.xi[s],
scale=1 / self.samples.tau[s],
size=(m, self.nSigma))
prob = ljs / ljs.sum()
deltas = cu.generate_indices(prob, n_per_sample)
zeta = np.vstack((self.samples.zeta[s], new_zetas))[deltas]
sigma = np.vstack((self.samples.sigma[s], new_sigmas))[deltas]
new_gammas.append(gamma(shape=zeta, scale=1 / sigma))
return np.vstack(new_gammas)
def generate_posterior_predictive_gammas(self, n_per_sample=1, m=10):
new_gammas = []
for s in range(self.nSamp):
dmax = self.samples.delta[s].max()
njs = np.bincount(self.samples.delta[s],
minlength=int(dmax + 1 + m))
ljs = njs + (njs == 0) * self.samples.eta[s] / m
new_log_zetas = normal()
new_zetas = normal(size=(m, self.nCol + self.nCat))
new_zetas = np.empty((m, self.nCol + self.nCat))
np.einsum(
'zy,jy->jz',
cholesky(self.samples.Sigma[s]),
normal(size=(m, self.nCol + self.nCat)),
out=new_zetas,
)
new_zetas += self.samples.mu[s][None, :]
np.exp(new_zetas, out=new_zetas)
prob = ljs / ljs.sum()
deltas = cu.generate_indices(prob, n_per_sample)
zeta = np.vstack((self.samples.zeta[s], new_zetas))[deltas]
new_gammas.append(gamma(shape=zeta))
return np.vstack(new_gammas)
