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)