def sample(self): if self.transform: sample = np.log( stats.invgamma(a=self._alpha, scale=self._beta).rvs(1)) else: sample = stats.invgamma(a=self._alpha, scale=self._beta).rvs(1) return sample
def invGamma(lower, upper, x0=[1, 5], showit=False): """ Arguments --------- lower, upper : float The upper and lower limits between which we want 98% of the probability x0 : list, length 2 Initial guesses for the parameters of the inverse gamma (a and scale) showit : bool Make a plot """ limits = [lower, upper] result = minimize(f, x0=x0, args=limits, method='L-BFGS-B', bounds=[(0, None), (0, None)], tol=1e-10) a, b = result.x if showit: import matplotlib.pyplot as plt fig, ax = plt.subplots(1, 1, constrained_layout=True) d = invgamma(a=a, scale=b) x = np.linspace(0.2 * limits[0], 2 * limits[1], 1000) ax.plot(x, d.pdf(x)) ax.vlines(limits, 0, d.pdf(x).max()) plt.show() return invgamma(a=a, scale=b)
def define_model(data): # Builds model object n = len(data) z = data.get('z') variable_names = ['surfaces', 'T', 'p_type', 'sigma_g', 'sigma_h'] known_params = { 'sigma_z_g': sigma_z_g, 'sigma_z_h': sigma_z_h, 'mu_h': mu_h, 'phi': phi } hyper_params = { 'alpha_type': array((1., 1., 1.)), 'prior_mu_g': -25. + zeros(n), 'prior_cov_g': 100. * eye(n), 'prior_mu_h': 30. + zeros(n), 'prior_cov_h': 100. * eye(n), 'a_g': 11, 'b_g': .1, 'a_h': 11, 'b_h': 40 } initials = { 'surfaces': [-25, 30] * ones((n, 2)), 'sigma_g': .1, 'sigma_h': 1, 'T': array([(0 if abs(z[i] + 25) > 1 else 1) for i in xrange(n)]) } #initials = {'sigma_g': sigma_g, # 'sigma_h': sigma_h, # 'T': T[:n], # 'g': g[:n], # 'h': h[:n]} priors = { 'p_type': dirichlet(hyper_params['alpha_type']), 'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']), 'sigma_h': stats.invgamma(hyper_params['a_h'], scale=hyper_params['b_h']), 'T': iid_dist(categorical(hyper_params['alpha_type']), n) } FCP_samplers = { 'p_type': p_type_step(), 'surfaces': surfaces_step(), 'sigma_g': sigma_ground_step(), 'sigma_h': sigma_height_step(), 'T': type_step() } model = Model() model.set_variable_names(variable_names) model.set_known_params(known_params) model.set_hyper_params(hyper_params) model.set_priors(priors) model.set_initials(initials) model.set_FCP_samplers(FCP_samplers) model.set_data(data) return model
def define_model(params_module, data): # Builds model object # Everything the gibbs sampler needs to know about. # Parameters and initialization values n = len(list(set(data.shot_id))) N = len(data) known_params = params_module.get_known_params(data) initials = params_module.get_initials(data) hyper_params = params_module.get_hyper_params(data) m_cover = params_module.m_cover m_type = params_module.m_type # Variables to be sampled (in this order) variable_names = ['h', 'g', 'T', 'C', 'noise_proportion', 'transition_var_g', 'transition_var_h'] priors = {'g': MVNormal(hyper_params['g']['mu'], hyper_params['g']['cov']), 'h': MVNormal(hyper_params['h']['mu'], hyper_params['h']['cov']), 'C': IID(Categorical(hyper_params['C']['p']), n), 'T': IID(Categorical(hyper_params['T']['p']), N), 'noise_proportion': beta(*hyper_params['noise_proportion']['alpha']), 'transition_var_g': stats.invgamma(hyper_params['transition_var_g']['a'], scale=hyper_params['transition_var_g']['b']), 'transition_var_h': stats.invgamma(hyper_params['transition_var_h']['a'], scale=hyper_params['transition_var_h']['b'])} FCP_samplers = {'g': ground_elev_step(), 'h': canopy_height_step(), 'C': cover_step(), 'T': type_step(), 'noise_proportion': noise_proportion_step(), 'transition_var_g': transition_var_g_step(), 'transition_var_h': transition_var_h_step()} sample_handlers = {'g': [indep_meanvar_handler()], 'h': [indep_meanvar_handler()], 'T': [discrete_handler(support=range(m_type), length=N)], 'C': [discrete_handler(support=range(m_cover), length=n)], 'noise_proportion': [raw_sample_handler()], 'transition_var_g': [raw_sample_handler()], 'transition_var_h': [raw_sample_handler()]} diagnostic_variable = 'noise_proportion' model = Model() model.set_variable_names(variable_names) model.set_known_params(known_params) model.set_hyper_params(hyper_params) model.set_priors(priors) model.set_initials(initials) model.set_FCP_samplers(FCP_samplers) model.set_sample_handlers(sample_handlers) model.set_diagnostic_variable(diagnostic_variable) model.set_data(data) return model
def __update_theta_1d(self, state_assignments): mu0, nu, alpha, beta = self.priors Y, L, theta = self.Y, self.L, self.theta z = state_assignments['z'] # z = mode_convolution(z, window=3) # need to update the parameters for each model for k in range(self.L): indexes = np.where(z == k)[0] ykk = Y[indexes] nk = len(ykk) # if ((nk == 0) and (len(self.queue) > 0)): # ykk = np.array([self.queue.pop()]) # nk = len(ykk) # y_bar = ykk[0] # samp_var = 2 if nk > 0: y_bar = np.mean(ykk) samp_var = np.var(ykk) # posterior sigma values alpha_post = alpha + nk / 2 beta_post = beta + nk * samp_var / 2 + (nk * nu) / ( nu + nk) * np.square(y_bar - mu0) / 2 # sample sigma sig = stats.invgamma(a=alpha_post, scale=beta_post).rvs() T = 1 / sig mu_post = (nu * mu0 + nk * y_bar) / (nu + nk) nu_post = nu + nk mu_samp = np.random.normal(mu_post, np.sqrt(sig / nu_post)) else: # if we don't have any data then we set the posterior to the value of the prior sig = stats.invgamma(a=alpha, scale=beta).rvs() T = 1 / sig mu_samp = np.random.normal(mu0, np.sqrt(sig / nu)) theta[k]['Cov'] = np.array([[sig]]) theta[k]['A'] = np.array([mu_samp]) return theta
def define_model(data): # Builds model object m = 3 n_points = len(data) n_shots = len(set(data['shot_id'])) variable_names = ['g', 'h', 'T', 'p_type', 'sigma_g', 'sigma_h'] known_params = {'sigma_z_g': sigma_z_g, 'sigma_z_h': sigma_z_h, 'mu_h': mu_h, 'phi': phi} hyper_params = {'alpha_type': array((0, 1., 1.)), 'prior_mu_g': -25.+zeros(n_shots), 'prior_cov_g': 100.*eye(n_shots), 'prior_mu_h': 30.+zeros(n_shots), 'prior_cov_h': 100.*eye(n_shots), 'a_g': 6, 'b_g': 1, 'a_h': 6, 'b_h': 1} initials = {} #initials = {'sigma_g': sigma_g, # 'sigma_h': sigma_h, # 'T': T[:n_shots], # 'g': g[:n_shots], # 'h': h[:n_shots]} priors = {'p_type': dirichlet(hyper_params['alpha_type']), 'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']), 'sigma_h': stats.invgamma(hyper_params['a_h'], scale=hyper_params['b_h']), 'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g']), 'h': mvnorm(hyper_params['prior_mu_h'], hyper_params['prior_cov_h']), 'T': iid_dist(categorical(hyper_params['alpha_type']/sum(hyper_params['alpha_type'])), n_points)} FCP_samplers = {'p_type': p_type_step(), 'g': ground_height_step(), 'h': canopy_height_step(), 'sigma_g': sigma_ground_step(), 'sigma_h': sigma_height_step(), 'T': type_step()} model = Model() model.set_variable_names(variable_names) model.set_known_params(known_params) model.set_hyper_params(hyper_params) model.set_priors(priors) model.set_initials(initials) model.set_FCP_samplers(FCP_samplers) model.set_data(data) return model
def test_1D_is_invgamma(self): # The 1-dimensional inverse Wishart with an identity scale matrix is # just an inverse gamma distribution. # Test variance, mean, pdf # Kolgomorov-Smirnov test for rvs np.random.seed(482974) sn = 500 dim = 1 scale = np.eye(dim) df_range = np.arange(5, 20, 2, dtype=float) X = np.linspace(0.1, 10, num=10) for df in df_range: iw = invwishart(df, scale) ig = invgamma(df / 2, scale=1. / 2) # Statistics assert_allclose(iw.var(), ig.var()) assert_allclose(iw.mean(), ig.mean()) # PDF assert_allclose(iw.pdf(X), ig.pdf(X)) # rvs rvs = iw.rvs(size=sn) args = (df / 2, 0, 1. / 2) alpha = 0.01 check_distribution_rvs('invgamma', args, alpha, rvs)
def __init__(self, alpha, beta): self.alpha = alpha self.beta = beta # set dist before calling super's __init__ self.dist = st.invgamma(alpha, scale=beta) super(InverseGamma, self).__init__()
def minimal_priors(): return [ lambda x: halfnorm(scale=1.).logpdf(np.sqrt(np.exp(x))) + x / 2.0 - np. log(2.0), lambda x: invgamma(a=5.0, scale=1.).logpdf(np.exp(x)) + x, lambda x: halfnorm(scale=1.).logpdf(np.sqrt(np.exp(x)) ) + x / 2.0 - np.log(2.0) ]
def fit_invgamma_dist(data, plot=False, x_range=None, num=100,label=""): """ Fits data to inverse gamma distribution. If plot is True it will return a plot. Otherwise it will return a scipy function. :param data: numpy array :param plot: Bool :param xrange: If none it will automatically find range. otherwise, you can set it. must be tuple: (1,2) :param num: the number of points to plot i.e. num from numpy.linspace :return: """ ig_dist = sps.invgamma.fit(data, floc=0) ig_dist = sps.invgamma(*ig_dist) if plot is False: return ig_dist if x_range is None: x_min = data.min() x_max = data.max() else: x_min = x_range[0] x_max = x_range[1] xs = np.linspace(x_min, x_max, num=num) plt.plot(xs, ig_dist.pdf(xs),label=label)
def fix_alpha(alpha, Sigma, Sigma_star): p = Sigma.shape[0] Sigma_12 = fractional_matrix_power(Sigma, 0.5) matrix = Sigma_12.T @ np.linalg.inv(Sigma_star) @ Sigma_12 lambdas = np.real(np.linalg.eigvals(matrix)) factorials = [1, 1, 2, 8] k = np.asarray([factorials[r] * np.sum(lambdas**r) for r in [1,1,2,3]]) t1 = 4*k[1]*k[2]**2 + k[3]*(k[2]-k[1]**2) t2 = k[3]*k[1] - 2*k[2]**2 chi_quantile = sps.chi2(p).ppf(1-alpha) if t1 < 10**(-5): a_new = 2 + (k[1]**2)/(k[2]**2) b_new = (k[1]**3)/k[2] + k[1] s1 = 2*k[1]*(k[3]*k[1] + k[2]*k[1]**2 - k[2]**2) s2 = 3*t2 + 2*k[2]*(k[2] + k[1]**2) alpha_star = 1 - sps.invgamma(a_new, scale = b_new).cdf(chi_quantile) elif t2 < 10**(-5): a_new = (k[1]**2)/k[2] b_new = k[2]/k[1] alpha_star = 1 - sps.gamma(a_new, scale = b_new).cdf(chi_quantile) else: a1 = 2*k[1]*(k[3]*k[1] + k[2]*k[1]**2 - k[2]**2)/t1 a2 = 3 + 2*k[2]*(k[2] + k[1]**2)/t2 alpha_star = 1 - sps.f(2*a1, 2*a2).cdf(a2*t2*chi_quantile/(a1*t1)) return alpha_star
def define_model(data): # Builds model object n = len(data) variable_names = ['g', 'sigma_g'] known_params = {'sigma_z_g': sigma_z_g, 'T': ones(n)} hyper_params = {'prior_mu_g': 0+zeros(n), 'prior_cov_g': 100*eye(n), 'a_g': 0., 'b_g': 0.} priors = {'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']), 'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g'])} initials = {'g': g[:n], 'sigma_g': sigma_g} FCP_samplers = {'g': ground_height_step(), 'sigma_g': sigma_ground_step()} model = Model() model.set_variable_names(variable_names) model.set_known_params(known_params) model.set_hyper_params(hyper_params) model.set_priors(priors) model.set_initials(initials) model.set_FCP_samplers(FCP_samplers) model.set_data(data) return model
def _recursive_priors(kernel, prior_list): if hasattr(kernel, "kernel"): # Unary operations _recursive_priors(kernel.kernel, prior_list) elif hasattr(kernel, "k1"): # Binary operations _recursive_priors(kernel.k1, prior_list) _recursive_priors(kernel.k2, prior_list) elif hasattr(kernel, "kernels"): # CompoundKernel for k in kernel.kernels: _recursive_priors(k, prior_list) else: name = type(kernel).__name__ if name in ["ConstantKernel", "WhiteKernel"]: # We use a half-normal prior distribution on the signal variance and # noise. The input x is sampled in log-space, which is why the # change of variables is necessary. # This prior assumes that the function values are standardized. # Note, that we do not know the structure of the kernel, which is # why this is just only a best guess. prior_list.append( lambda x: halfnorm(scale=2.0).logpdf(np.sqrt(np.exp(x))) + x / 2.0 - np.log(2.0), ) elif name in ["Matern", "RBF"]: # Here we apply an inverse gamma distribution to any lengthscale # parameter we find. We assume the input variables are normalized # to lie in [0, 1]. The specific values for a and scale were # obtained by fitting the 1% and 99% quantile to 0.15 and 0.8. prior_list.append( lambda x: invgamma(a=8.286, scale=2.4605).logpdf(np.exp(x)) + x, ) else: raise NotImplementedError( f"Unable to guess priors for this kernel: {kernel}.")
def test_1D_is_invgamma(self): # The 1-dimensional inverse Wishart with an identity scale matrix is # just an inverse gamma distribution. # Test variance, mean, pdf # Kolgomorov-Smirnov test for rvs np.random.seed(482974) sn = 500 dim = 1 scale = np.eye(dim) df_range = np.arange(5, 20, 2, dtype=float) X = np.linspace(0.1,10,num=10) for df in df_range: iw = invwishart(df, scale) ig = invgamma(df/2, scale=1./2) # Statistics assert_allclose(iw.var(), ig.var()) assert_allclose(iw.mean(), ig.mean()) # PDF assert_allclose(iw.pdf(X), ig.pdf(X)) # rvs rvs = iw.rvs(size=sn) args = (df/2, 0, 1./2) alpha = 0.01 check_distribution_rvs('invgamma', args, alpha, rvs)
def define_model(data): # Builds model object n = len(data) variable_names = ['g', 'sigma_g', 'p_type', 'T'] known_params = {'sigma_z_g': sigma_z_g} hyper_params = {'prior_mu_g': 0*ones(n), 'prior_cov_g': 100*eye(n), 'alpha_type': (1., 1.), 'a_g': 3., 'b_g': 1.} priors = {'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']), 'p_type': dirichlet(hyper_params['alpha_type']), 'T': iid_dist(categorical((1., 1.)), n), 'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g'])} #initials = {'g': g[:n], # 'sigma_g': sigma_g} FCP_samplers = {'g': ground_height_step(), 'p_type': p_type_step(), 'T': type_step(), 'sigma_g': sigma_ground_step()} model = Model() model.set_variable_names(variable_names) model.set_known_params(known_params) model.set_hyper_params(hyper_params) model.set_priors(priors) #model.set_initials(initials) model.set_FCP_samplers(FCP_samplers) model.set_data(data) return model
def define_model(data): # Builds model object n = len(data) variable_names = ['g', 'sigma_g'] known_params = {'sigma_z_g': sigma_z_g, 'T': ones(n)} hyper_params = { 'prior_mu_g': 0 + zeros(n), 'prior_cov_g': 100 * eye(n), 'a_g': 0., 'b_g': 0. } priors = { 'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']), 'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g']) } initials = {'g': g[:n], 'sigma_g': sigma_g} FCP_samplers = {'g': ground_height_step(), 'sigma_g': sigma_ground_step()} model = Model() model.set_variable_names(variable_names) model.set_known_params(known_params) model.set_hyper_params(hyper_params) model.set_priors(priors) model.set_initials(initials) model.set_FCP_samplers(FCP_samplers) model.set_data(data) return model
def init(self): self.sigma2 = np.apply_along_axis( lambda ab: invgamma(ab[0], scale=1 / ab[1]).rvs(P), 0, [[a0] + ak, [b0] + bk]).squeeze() # P * (K+1) self.beta = [] self.Gamma_0 = [] self.nu = [] self.mu_0 = [] for k in range(2): sigma2_k = self.sigma2[:, k + 1] # P self.beta.append( np.apply_along_axis(lambda sigma: norm(b0k[k], sigma).rvs(R), 0, [h * sigma2_k])) Gamma_0k = invwishart(dk[k], Q).rvs(1) # P * P self.Gamma_0.append(Gamma_0k) m_0k = np.ones(P) * self.m_0k[k] nu_k = multivariate_normal(m_0k, h1 * Gamma_0k).rvs(1).squeeze() # P self.nu.append(nu_k) self.mu_0.append(multivariate_normal(nu_k, h1 * Gamma_0k).rvs(1)) # P self.beta = np.array(self.beta) # K * R * P self.Gamma_0 = np.array(self.Gamma_0) # K * P * P self.nu = np.array(self.nu) # K * P self.mu_0 = np.array(self.mu_0) # K * P self.det_Q = np.linalg.det(Q) self.b_0_p = [] for j in range(P): self.b_0_p.append(b0 + sum(X[:, j]**2)) self.b_0_p = np.array(self.b_0_p)
def update_theta(Y, fwd_vals, params, priors, **kwargs): mu0, sig0, nu, Delta = priors # how many time to iterate these samples? num_iter = 1 L, theta = params['L'], params['theta'] z = fwd_vals['z'] Yk = [Y[np.where(z == j)[0]] for j in range(L)] # print(z) # system.exit(0) for i in range(num_iter): for k in range(0, L): ykk = Yk[k] sig2 = theta[k][1]**2 # update mu sig0_inv = 1 / sig0 SigHat = (sig0_inv + len(ykk) / (sig2))**-1 muHat = SigHat * (mu0 * sig0_inv + np.sum(ykk) / sig2) theta[k][0] = np.random.normal(loc=muHat, scale=np.sqrt(SigHat)) # update sigma nu_k = nu + len(ykk) / 2 nukDeltak = Delta + np.sum(np.square(ykk - theta[k][0])) / 2 theta[k][1] = np.sqrt( stats.invgamma(a=nu_k, scale=nukDeltak).rvs()) return theta
def define_model(data): # Builds model object n = len(data) z = data.get('z') variable_names = ['surfaces', 'T', 'p_type', 'sigma_g', 'sigma_h'] known_params = {'sigma_z_g': sigma_z_g, 'sigma_z_h': sigma_z_h, 'mu_h': mu_h, 'phi': phi} hyper_params = {'alpha_type': array((1., 1., 1.)), 'prior_mu_g': -25.+zeros(n), 'prior_cov_g': 100.*eye(n), 'prior_mu_h': 30.+zeros(n), 'prior_cov_h': 100.*eye(n), 'a_g': 11, 'b_g': .1, 'a_h': 11, 'b_h': 40} initials = {'surfaces': [-25, 30]*ones((n,2)), 'sigma_g': .1, 'sigma_h': 1, 'T': array([(0 if abs(z[i]+25)>1 else 1) for i in xrange(n)])} #initials = {'sigma_g': sigma_g, # 'sigma_h': sigma_h, # 'T': T[:n], # 'g': g[:n], # 'h': h[:n]} priors = {'p_type': dirichlet(hyper_params['alpha_type']), 'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']), 'sigma_h': stats.invgamma(hyper_params['a_h'], scale=hyper_params['b_h']), 'T': iid_dist(categorical(hyper_params['alpha_type']), n)} FCP_samplers = {'p_type': p_type_step(), 'surfaces': surfaces_step(), 'sigma_g': sigma_ground_step(), 'sigma_h': sigma_height_step(), 'T': type_step()} model = Model() model.set_variable_names(variable_names) model.set_known_params(known_params) model.set_hyper_params(hyper_params) model.set_priors(priors) model.set_initials(initials) model.set_FCP_samplers(FCP_samplers) model.set_data(data) return model
def generate_outcome_with_site(self): self._rnd = check_random_state(self.random_state) var_noise = 1.0 - self.var_x - self.var_z assert var_noise > 0.0 n_samples, n_features = self.data.shape # causal effect dem_data = get_volume_causes(self.known_causes) rv_x = stats.norm(loc=0.0, scale=0.5) coef_x = rv_x.rvs(size=n_features, random_state=self._rnd) coef_x = self._make_sparse(coef_x) causal_data = fit_regress_out(self.data, dem_data) mu_x = np.dot(causal_data.values, coef_x) contrib_x = np.sqrt(self.var_x) / np.std(mu_x, ddof=1) # confounding site_id = self.get_site_assignments(causal_data) # per group intercept and error variance intercepts = np.arange(1, self.num_sites + 1) err_var = stats.invgamma(a=3, loc=1).rvs(size=self.num_sites, random_state=self._rnd) LOG.info("Per-cluster intercepts: %s", intercepts) LOG.info("Per-cluster error variance: %s", err_var) mu_z_hidden = intercepts[site_id] contrib_z = np.sqrt(self.var_z * 0.9) / np.std(mu_z_hidden, ddof=1) rv_age = stats.norm(loc=0.0, scale=0.2) coef_age = rv_age.rvs(random_state=self._rnd) mu_age = dem_data.loc[:, "AGE"].values * coef_age contrib_age = np.sqrt(self.var_z * 0.1) / np.std(mu_age, ddof=1) noise = stats.norm.rvs(loc=np.zeros(n_samples), scale=err_var[site_id], random_state=self._rnd) contrib_noise = np.sqrt(var_noise) / np.std(noise, ddof=1) mu = np.stack([mu_x, mu_z_hidden, mu_age, noise], axis=1) contrib = np.array([contrib_x, contrib_z, contrib_age, contrib_noise]) # linear predictor eta = np.dot(mu, contrib) # center around 0 eta -= np.mean(eta) intercept = stats.logistic.ppf(self.prob_event) eta += intercept true_coef = pd.Series(coef_x, index=self.data.columns) true_coef.loc["Intercept"] = intercept outcome = self.logistic(eta) conf_hidden = pd.Series(mu_z_hidden, index=self.data.index, name="unobserved_confounder") confounders = pd.concat((conf_hidden, dem_data.loc[:, "AGE"]), axis=1) return outcome, true_coef, confounders
def params(D): A = Params() A.prior = Params() B = Params() B.prior = Params() S = Params() S.prior = Params() T = Params() T.prior = Params() (A.prior.m, A.prior.var) = (0.0, 10.0) (B.prior.m, B.prior.var) = (0.0, 10.0) (S.prior.p1, S.prior.p2) = (3.0, 1.0) (T.prior.p1, T.prior.p2) = (3.0, 1.0) A.prior.rv = norm(loc=A.prior.m, scale=np.sqrt(A.prior.var)) B.prior.rv = norm(loc=B.prior.m, scale=np.sqrt(A.prior.var)) S.prior.rv = invgamma(S.prior.p1/2, loc=0, scale=S.prior.p1*S.prior.p2/2) T.prior.rv = invgamma(T.prior.p1/2, loc=0, scale=T.prior.p1*T.prior.p2/2) ### Full conditionals A.cond = Params() B.cond = Params() S.cond = Params() T.cond = Params() # AR-1 without noise; regress X[1:] on X[:-1] A.cond.var = lambda (a, b, s, t, X, Y): 1/(1/A.prior.var + D.n/S.prior.p2) A.cond.m = lambda (a, b, s, t, X, Y): A.cond.var((a,b,s,t,X,Y))*(sum(X[1:]-b*X[:-1])/S.prior.p2 + A.prior.m/A.prior.var) B.cond.var = lambda (a, b, s, t, X, Y): 1/(1/B.prior.var + sum(X**2)/S.prior.p2) B.cond.m = lambda (a, b, s, t, X, Y): B.cond.var((a,b,s,t,X,Y))*(sum((X[1:]-a)*X[:-1])/S.prior.p2 + B.prior.m/B.prior.var) S.cond.a = lambda (a, b, s, t, X, Y): S.prior.p1 + D.n S.cond.b = lambda (a, b, s, t, X, Y): S.prior.p1*S.prior.p2 + sum((X[1:]-a-b*X[:-1])**2) # Regression of Y on X T.cond.a = lambda (a, b, s, t, X, Y): T.prior.p1 + D.n T.cond.b = lambda (a, b, s, t, X, Y): T.prior.p1*T.prior.p2 + sum((Y-X)**2) # conditional draws A.cond.rv = lambda theta: norm(loc=A.cond.m(theta), scale=np.sqrt(A.cond.var(theta))) B.cond.rv = lambda theta: norm(loc=B.cond.m(theta), scale=np.sqrt(B.cond.var(theta))) S.cond.rv = lambda theta: invgamma(S.cond.a(theta)/2, loc=0, scale=S.cond.b(theta)/2) T.cond.rv = lambda theta: invgamma(T.cond.a(theta)/2, loc=0, scale=T.cond.b(theta)/2) return ParamsHolder(A, B, S, T)
def sample(self, model, evidence): prior_mu_g, a_g, b_g = [model.hyper_params[var] for var in ['prior_mu_g', 'a_g', 'b_g']] g = evidence['g'] n = len(g) g_var_posterior = stats.invgamma(a_g + (n-1)/2., scale=b_g + sum((g[1:] - g[:-1])**2)/2.) g_var = g_var_posterior.rvs() return sqrt(g_var)
def make_widths(): np.random.seed(1) a = 10 b = 4000 precision_dist = stats.invgamma(a, scale=b) return precision_dist.rvs(n)**-0.5
def sample(self, model, evidence): prior_mu_h, a_h, b_h = [model.hyper_params[var] for var in ['prior_mu_h', 'a_h', 'b_h']] h = evidence['surfaces'][:,1] n = len(h) h_var_posterior = stats.invgamma(a_h + (n-1)/2., scale=b_h + sum((h[1:] - h[:-1])**2)/2.) h_var = h_var_posterior.rvs() return min(sqrt(h_var), 3)
def getline(stops): fit_alpha, fit_loc, fit_scale = stats.gamma.fit(stops) sort_stops = sorted(stops) length = len(sort_stops) y = np.empty(length) for i in range(length): number = (i - 0.5) / length new = stats.invgamma(fit_alpha, fit_loc, fit_scale) print(sort_stops[i], new.pdf(number))
def eval_logjoint(y: np.ndarray, x: np.ndarray, bet: np.ndarray, sig: np.ndarray, lam: float, v: np.ndarray, s: np.ndarray) -> float: m = np.zeros((y.shape[0], x.shape[0])) l = lam / np.var(x, 1) return np.sum(lm.eval_loglik(y, x, bet, sig)) \ + np.sum(lm.eval_norm(bet, m, sig / l)) \ + np.sum(invgamma(a=v / 2, scale=s / 2).logpdf(sig))
def sample_sigma2(state, VS=True): b = np.zeros(state['num_clusters_']) a = np.array( state['suffstats'].values()) / 2.0 + state['hyperparameters_']['a0k'] for cluster_id in state['cluster_ids_']: if (cluster_id == 0) and VS is True: continue b[cluster_id] = np.sum(state['beta'][np.where(state['assignment'] == cluster_id)]**2) / 2.0 + \ state['hyperparameters_']['b0k'] if VS is True: out = dict( zip(range(1, state['num_clusters_']), stats.invgamma(a=a[1:], scale=b[1:]).rvs())) out[0] = 0 else: out = dict( zip(range(0, state['num_clusters_']), stats.invgamma(a=a, scale=b).rvs())) return out
def sample(self, model, evidence): prior_mu_g, a_g, b_g = [ model.hyper_params[var] for var in ['prior_mu_g', 'a_g', 'b_g'] ] g = evidence['g'] n = len(g) g_var_posterior = stats.invgamma(a_g + (n - 1) / 2., scale=b_g + sum( (g[1:] - g[:-1])**2) / 2.) g_var = g_var_posterior.rvs() return sqrt(g_var)
def sample(self, model, evidence): prior_mu_h, a_h, b_h = [ model.hyper_params[var] for var in ['prior_mu_h', 'a_h', 'b_h'] ] h = evidence['surfaces'][:, 1] n = len(h) h_var_posterior = stats.invgamma(a_h + (n - 1) / 2., scale=b_h + sum( (h[1:] - h[:-1])**2) / 2.) h_var = h_var_posterior.rvs() return min(sqrt(h_var), 3)
def hs_step( lambda2: np.ndarray, tau2: np.ndarray, vi: np.ndarray, xi: np.ndarray, X: np.ndarray, y: np.ndarray, ): _, M = X.shape D_diag = tau2 * lambda2 beta = large_p_mvnormal_sampler(D_diag, X, y) beta2 = beta**2 lambda2 = invgamma(a=1, scale=1 / vi + beta2 / (2 * tau2)).rvs() tau2 = invgamma(a=(M + 1) / 2, scale=1 / xi + (beta2 / lambda2).sum() / 2).rvs() vi = invgamma(a=1, scale=1 + 1 / lambda2).rvs() xi = invgamma(a=1, scale=1 + 1 / tau2).rvs() return beta, lambda2, tau2, vi, xi
def sim_dataset(self, G0, lambdas): """ calculate the target Y based on the simulated dataset input: G0: level 0 data lambdas: unknown groups n_causes and n_units: int, dimensions of the dataset output: G: G0 in pandas format with colnames that indicate if its a cause or not tc: causal columns y01: binary target """ np.random.seed(self.seed) tc_ = npr.normal(loc=0, scale=0.5 * 0.5, size=self.true_causes) tc = np.hstack((tc_, np.repeat(0.0, self.confounders))) # True causes tau = stats.invgamma(3, 1).rvs(3, random_state=99) sigma = np.zeros(self.n_units) sigma = [ tau[0] if lambdas[j] == 0 else sigma[j] for j in range(len(sigma)) ] sigma = [ tau[1] if lambdas[j] == 1 else sigma[j] for j in range(len(sigma)) ] sigma = [ tau[2] if lambdas[j] == 2 else sigma[j] for j in range(len(sigma)) ] y0 = np.array(tc).reshape(1, -1).dot(np.transpose(G0)) l1 = lambdas.reshape(1, -1) y1 = (np.sqrt(np.var(y0)) / np.sqrt(0.4)) * (np.sqrt(0.4) / np.sqrt(np.var(l1))) * l1 e = npr.normal(0, sigma, self.n_units).reshape(1, -1) y2 = (np.sqrt(np.var(y0)) / np.sqrt(0.4)) * (np.sqrt(0.2) / np.sqrt(np.var(e))) * e p = 1 / (1 + np.exp(y0 + y1 + y2)) y01 = [npr.binomial(1, p[0][i], 1)[0] for i in range(len(p[0]))] y01 = np.asarray(y01) G, col = self.add_colnames(G0, tc) treatment = G.iloc[:, col].values.reshape(-1) G.drop(G.columns[col].values, axis=1, inplace=True) y = y0 + y1 + y2 logger.debug('... Covariates: %i', G.shape[1] - len(col)) logger.debug('... Target (y) : %f', np.sum(y01) / len(y01)) logger.debug('... Sample Size: %i', G.shape[0]) if len(col) == 1: T = G.iloc[:, col[0]].values logger.debug('... Proportion of T: %f', sum(T) / len(T)) logger.debug('Dataset - GWAS Done!') return G, y, treatment, tc_
def sample_fixed_effects(self, n_samples, summary_statistics): """samples from the posterior distribution of the fixed effects model parameters ---------- n_samples: int number of samples to draw summary_statistics: (int, np.array, np.array) number of observations per group, group specific means, group specific variances returns ------- np.array (n_samples, n_groups) mu_j/fixed effects np.array (n_samples, ) sigma_2/observation variances np.array (n_samples, ) mu np.array (n_samples, ) tau_2 """ n_observations, means, variances = summary_statistics n_groups = means.shape[0] # Sample from observation variance posterior a = n_observations * n_groups / 2.0 b = n_observations * variances.sum() / 2.0 sigma_2 = stats.invgamma(a=a, scale=b).rvs(n_samples) # Sample from the fixed effects fixed_effects = stats.norm().rvs( (n_samples, n_groups)) * (sigma_2[:, None] / n_observations)**0.5 + means[None, :] # sample the NIG prior tau_2 = stats.invgamma(a=self.a, scale=self.b).rvs(n_samples) mu = stats.norm().rvs(n_samples) * tau_2**0.5 return fixed_effects, mu, sigma_2, tau_2
def sample(self, model, evidence): g = evidence['g'] prior_mu_g = model.hyper_params['g']['mu'] a = model.hyper_params['transition_var_g']['a'] b = model.hyper_params['transition_var_g']['b'] max_var = model.hyper_params['transition_var_g']['max'] n = len(g) g_var_posterior = stats.invgamma(a + (n-1)/2., scale=b + sum((g[1:] - g[:-1])**2)/2.) g_var = g_var_posterior.rvs() return min(g_var, max_var)
def plot_inv_gamma(): print("mean", st.invgamma(2, scale=1e-9).mean()) x = np.linspace(0.0, 1, 1000) fig, ax = plt.subplots() f = lambda alpha, beta: st.invgamma.pdf(x, alpha, scale=beta) plot_pdf = lambda alpha, beta: ax.plot(x, f(alpha, beta), label=r'$\alpha$={0}, $\beta$={1}'. format(alpha, beta)) plot_pdf(2, 0.1) # plot_pdf(1., 1e-2) # plot_pdf(1.1, 1e-2) plt.legend(loc='upper right', frameon=False) ax.set(xlim=[0, 1], xlabel='x', ylabel='f(x)') plt.show()
def __init__(self, taylor_args, *args, **kwargs): # Initialize the baseclass super(TaylorRulePrior, self).__init__(*args, **kwargs) # r_loc = ordering[0] # pi_loc = ordering[1] # y_loc = ordering[2] npara = self.n * (self.n + 1) / 2 + self.n**2 * self.p + self.n * self.cons A0_r_start = self.n * (self.n + 1) / 2 - self.n A0_r_end = self.n * (self.n + 1) / 2 last_col_A0 = np.arange(A0_r_start, A0_r_end) A1_r_start = A0_r_end + (self.n - 1) * self.n * (self.p) + ( self.n - 1) * self.cons A1_r_end = A1_r_start + self.n last_col_A1 = np.arange(A1_r_start, A1_r_end) cons_Aplus = npara - 1 r_idx = np.r_[last_col_A0, last_col_A1, cons_Aplus] r_idx = np.asarray(r_idx, dtype=int) print('r_idx', r_idx) #r_idx = np.array([ 3, 4, 5, 14, 15, 16, 17]) self.r_idx = r_idx self.non_r_idx = np.ones((npara, ), dtype=bool) self.non_r_idx[r_idx] = False # drop out r variables self.sigma_con = self.sigma[self.non_r_idx, :][:, self.non_r_idx] self.mu_con = self.mu[self.non_r_idx] self.prior_con = multivariate_normal(self.mu_con, self.sigma_con) from scipy.stats import norm, beta, invgamma self.tlr = OrderedDict() self.tlr['r_star'] = taylor_args.pop( 'r_star', norm(loc=4 / 100, scale=0.5 / 100)) self.tlr['rho'] = taylor_args.pop('rho', norm(loc=0.75, scale=0.1)) self.tlr['alpha_pi'] = taylor_args.pop('alpha_pi', norm(loc=1.5, scale=0.25)) self.tlr['alpha_z'] = taylor_args.pop('alpha_z', norm(loc=1.0, scale=0.25)) self.tlr['sigma_R'] = taylor_args.pop('sigma_R', invgamma(10)) self.tlr['tau_1'] = taylor_args.pop('tau_1', norm(loc=0, scale=0.25)) self.tlr['tau_2'] = taylor_args.pop('tau_2', norm(loc=0, scale=0.25))
def sample(self, model, evidence): g = evidence['g'] prior_mu_g = model.hyper_params['g']['mu'] a = model.hyper_params['transition_var_g']['a'] b = model.hyper_params['transition_var_g']['b'] max_var = model.hyper_params['transition_var_g']['max'] n = len(g) g_var_posterior = stats.invgamma(a + (n - 1) / 2., scale=b + sum( (g[1:] - g[:-1])**2) / 2.) g_var = g_var_posterior.rvs() return min(g_var, max_var)
def updateQ_s(data, Q_m, Q_s): """ implements the update seen in 33.44 :param Q_m: Q of m optimal :param data: the samples :return: Q_s """ mean_sigma, var_sigma = Q_s.stats(moments='mv') mean_beta = 1 / mean_sigma**2 mu_sigma_data = np.sqrt(1 / (data.size * mean_beta)) S = np.std(data)**2 * data.size b_prime = 0.5 * (data.size * mu_sigma_data**2 + S) c_prime = data.size / 2 return stats.invgamma(a=b_prime, scale=c_prime)
def sample_posterior(priors, data, param_priors): mu0, sig0, alpha, beta = param_priors post_params = priors for observation in data: post_params = get_posterior_params(post_params, observation) mu_post, nu_post, alpha_post, beta_post = post_params sigma = stats.invgamma(a=alpha_post, scale=beta_post).rvs() tau = np.sqrt(1 / sigma) tau_post = 1 / sig0 + tau mu = np.random.normal(mu_post, 1 / tau_post) return mu, sigma
def sim_dataset(G0, lambdas, n_causes, n_units, randseed): ''' calculate the target Y based on the simulated dataset input: G0: level 0 data lambdas: unknown groups n_causes and n_units: int, dimensions of the dataset output: G: G0 in pandas format with colnames that indicate if its a cause or not tc: causal columns y01: binary target ''' np.random.seed(randseed) tc_ = npr.normal(loc=0, scale=0.5 * 0.5, size=int(n_causes * 0.1)) tc = np.hstack( (np.repeat(0.0, n_causes - int(n_causes * 0.1)), tc_)) #True causes tc.shuffle(tc) tau = stats.invgamma(3, 1).rvs(3, random_state=99) sigma = np.zeros(n_units) sigma = [ tau[0] if lambdas[j] == 0 else sigma[j] for j in range(len(sigma)) ] sigma = [ tau[1] if lambdas[j] == 1 else sigma[j] for j in range(len(sigma)) ] sigma = [ tau[2] if lambdas[j] == 2 else sigma[j] for j in range(len(sigma)) ] y0 = np.array(tc).reshape(1, -1).dot(np.transpose(G0)) l1 = lambdas.reshape(1, -1) y1 = (np.sqrt(np.var(y0)) / np.sqrt(0.4)) * (np.sqrt(0.4) / np.sqrt(np.var(l1))) * l1 e = npr.normal(0, sigma, n_units).reshape(1, -1) y2 = (np.sqrt(np.var(y0)) / np.sqrt(0.4)) * (np.sqrt(0.2) / np.sqrt(np.var(e))) * e y = y0 + y1 + y2 p = 1 / (1 + np.exp(y0 + y1 + y2)) y01 = np.zeros(len(p[0])) y01 = [npr.binomial(1, p[0][i], 1)[0] for i in range(len(p[0]))] y01 = np.asarray(y01) G = add_colnames(G0, tc) return G, tc, y01
def sample(self, model, evidence): h = evidence['h'] prior_mu_h = model.hyper_params['h']['mu'] a = model.hyper_params['transition_var_h']['a'] b = model.hyper_params['transition_var_h']['b'] max_var = model.hyper_params['transition_var_h']['max'] phi = model.known_params['phi'] mu = model.known_params['mu_h'] n = len(h) h_var_posterior = stats.invgamma(a + (n-1)/2., scale=b + sum(((h[1:]-mu) - phi*(h[:-1]-mu))**2)/2.) h_var = h_var_posterior.rvs() return min(h_var, max_var)
def test_CovDiagonalGammaPrior(seeded_rng): cov_np = np.diag(np.exp(np.random.normal(size=m))) cov = CovDiagonalGammaPrior(size=m, sigma=np.diag(cov_np), alpha=1.5, beta=1e-10) ig = invgamma(1.5, scale=1e-10) # compute the naive version logdet_np, sinv_np, sinvx_np = logdet_sinv_np(X, cov_np) penalty_np = np.sum(ig.logpdf(1 / np.diag(cov_np))) assert_allclose(logdet_np, cov.logdet, rtol=rtol) assert_allclose(sinv_np, cov.solve(eye), rtol=rtol) assert_allclose(sinvx_np, cov.solve(X_tf), rtol=rtol) assert_allclose(penalty_np, cov.logp, rtol=rtol)
def main(): """ Main CLI handler. """ parser = argparse.ArgumentParser(description=__description__) parser.add_argument("--version", action="version", version="%(prog)s " + __version__) parser.add_argument("alpha", type=float, default=3.00, help="Alpha parameter value [default=%(default)s].") parser.add_argument("beta", type=float, default=0.001, help="Beta parameter value [default=%(default)s].") parser.add_argument("-f", "--input-format", type=str, default="newick", choices=["nexus", "newick"], help="Input data format (default='%(default)s')") args = parser.parse_args() args.output_prefix = None args.show_plot_on_screen = True a = args.alpha b = args.beta rv = invgamma(a, loc=0, scale=b) print("Mean: {}".format(rv.mean())) print("Variance: {}".format(rv.var())) fig, ax = plt.subplots(1, 1) x = np.linspace(invgamma.ppf(0.01, a, scale=b), invgamma.ppf(0.99, a, scale=b), 100) ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') ax.plot(x, invgamma.pdf(x, a, scale=b), 'r-', lw=5, alpha=0.6, label='invgamma pdf') spdw.render_output(args, "InverseGamma")
def initialize(self): # InvGamma RV with beta=1, alpha=1 IG = invgamma(1) self.U = numpy.empty([self.K,self.I]) self.S_U = numpy.empty([self.K,self.I]) for k in range(0,self.K): for i in range(0,self.I): self.U[k][i] = random.normalvariate(0,1) self.S_U[k][i] = IG.rvs() self.V = numpy.empty([self.K,self.J]) self.S_V = numpy.empty([self.K,self.J]) for k in range(0,self.K): for j in range(0,self.J): self.V[k][j] = random.normalvariate(0,1) self.S_V[k][j] = IG.rvs() self.R = self.X - numpy.dot(self.U.transpose(),self.V) return
def check_eta_samples(test_model, samples): from pyglm.internals.activation import GaussianNoiseActivation if not isinstance(test_model.activation_model, GaussianNoiseActivation): return alpha_eta = test_model.activation_model.alpha_0 beta_eta = test_model.activation_model.beta_0 # Convert samples to arrays eta_samples = np.array([s.activation_model.eta for s in samples]) eta_mean = eta_samples.mean(0) eta_std = eta_samples.std(0) eta_dist = invgamma(a=alpha_eta, scale=beta_eta) # Make Q-Q plots fig = plt.figure() # w_ax = fig.add_subplot(121) # probplot(w_samples[:,0,0,0], dist=w_dist, plot=w_ax) fig.add_subplot(122) _, bins, _ = plt.hist(eta_samples[:,0], 50, normed=True, alpha=0.2) bincenters = 0.5*(bins[1:]+bins[:-1]) plt.plot(bincenters, eta_dist.pdf(bincenters), 'r--', linewidth=1) plt.show()
### Priors # In[136]: a0 = [0.0, 10.0] b0 = [0.0, 10.0] s20 = [3.0, 1.0] # In[137]: ap = norm(loc=a0[0], scale=np.sqrt(a0[1])) bp = norm(loc=b0[0], scale=np.sqrt(b0[1])) s2p = invgamma(s20[0]/2, loc=0, scale=s20[0]*s20[1]/2) # In[138]: x = np.linspace(norm.ppf(0.01), norm.ppf(0.99), 100) plt.plot(x, ap.pdf(x), 'b-', lw=5, alpha=0.6) plt.title('alpha prior') plt.show() plt.plot(x, bp.pdf(x), 'b-', lw=5, alpha=0.6) plt.title('beta prior') plt.show() x = np.linspace(invgamma.ppf(0.01, s20[0]/2), invgamma.ppf(0.99, s20[1]/2), 100) plt.plot(x, s2p.pdf(x), 'b-', lw=5, alpha=0.6)
def define_model(data): # Builds model object # Known values from simulation (can use to initialize sampler/skip burn-in) p = pickle.load(open('../data/sims/simulation_delta_0.pkl', 'rb')) g = p['g'] h = p['h'] T = p['T'] sigma_g = p['sigma_g'] sigma_h = p['sigma_h'] # Also needed for known parameters (so load the right pkl dummy!) phi = p['phi'] mu_h = p['mu_h'] sigma_z_g = p['sigma_z_g'] sigma_z_h = p['sigma_z_h'] n = len(data) z = data.get('z') variable_names = ['g', 'h', 'T', 'p_type', 'sigma_g', 'sigma_h'] known_params = {'sigma_z_g': sigma_z_g, 'sigma_z_h': sigma_z_h, 'mu_h': mu_h, 'phi': phi} hyper_params = {'alpha_type': array((1., 1., 1.)), 'prior_mu_g': -25.+zeros(n), 'prior_cov_g': 100.*eye(n), 'prior_mu_h': 30.+zeros(n), 'prior_cov_h': 100.*eye(n), 'a_g': 11, 'b_g': .1, 'a_h': 11, 'b_h': 40} #initials = {'g': -25+zeros(n), # 'sigma_g': .1, # 'sigma_h': 1, # 'T': array([(0 if abs(z[i]+25)>1 else 1) for i in xrange(n)])} initials = {'sigma_g': sigma_g, 'sigma_h': sigma_h, 'p_type': array((0, .5, .5)), 'T': T[:n], 'g': g[:n], 'h': h[:n]} priors = {'p_type': dirichlet(hyper_params['alpha_type']), 'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']), 'sigma_h': stats.invgamma(hyper_params['a_h'], scale=hyper_params['b_h']), 'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g']), 'h': mvnorm(hyper_params['prior_mu_h'], hyper_params['prior_cov_h']), 'T': iid_dist(categorical(hyper_params['alpha_type']), n)} FCP_samplers = {'p_type': p_type_step(), 'g': ground_height_step(), 'h': canopy_height_step(), 'sigma_g': sigma_ground_step(), 'sigma_h': sigma_height_step(), 'T': type_step()} model = Model() model.set_variable_names(variable_names) model.set_known_params(known_params) model.set_hyper_params(hyper_params) model.set_priors(priors) model.set_initials(initials) model.set_FCP_samplers(FCP_samplers) model.set_data(data) return model
def __init__(self, alpha, beta) : """ """ self.alpha = alpha self.beta = beta self.dist = invgamma(alpha, scale = beta) self.co = log((beta**alpha)/ gamma(alpha))
samples, logs = metropolis.metropolis(x, mu, sigma, n_samples=2500) plt.plot(samples[:,0], samples[:,1], '.') plt.savefig('samples.pdf') plt.clf() plt.plot(logs) plt.savefig('logprobs.pdf') plt.clf() # let's do a metropolis sampler for the exam scores data alpha=3 beta=50 mu0 = 80 sig20 = 16 muprior=st.norm(loc=mu0, scale=sqrt(sig20)) sig2prior = st.invgamma(alpha,scale=beta) def proposal(y, std): return st.multivariate_normal.rvs(mean=y, cov=std*np.eye(len(y))) def propLogDensity(x): return muprior.logpdf(x[0])+sig2prior.logpdf(x[1])+st.norm.logpdf(scores,loc=x[0],scale=sqrt(x[1])).sum() def metropolis(x0, s, n_samples): """ Use the Metropolis algorithm to sample from posterior. Parameters ---------- x0 : ndarray of shape (2,) The first entry is mu, the second entry is sigma2 s : float > 0 The standard deviation parameter for the proposal function n_samples : int
def chi2inv(p, v): return st.invgamma(v/2,scale=2).ppf(p)
def _kstest(self, alpha, beta, samples): # Uses the Kolmogorov-Smirnov test for goodness of fit. ks, _ = stats.kstest(samples, stats.invgamma(alpha, scale=beta).cdf) # Return True when the test passes. return ks < 0.02
def var_post_dist(self): post_n, post_d = self.var_post_params return stats.invgamma(post_n, scale=post_d / 2.0)
def define_model(data): # Builds model object # Encapsulates everything the gibbs sampler needs to know about. # Data and dimensions N = len(data) # Number of data points shot_id = data.get('shot_id') n = len(set(shot_id)) # Number of shots print data.filepath if 'Cedar2' in data.filepath: import params_cedar2 as params elif 'Cedar4' in data.filepath: import params_cedar4 as params elif 'SERC1' in data.filepath: import params_serc1 as params elif 'SERC3' in data.filepath: import params_serc3 as params elif 'SERC5' in data.filepath: import params_serc5 as params elif 'zeta' in data.filepath: import params_zeta as params elif 'eta' in data.filepath: import params_eta as params elif 'matlas' in data.filepath: import params_matlas as params else: import params_default as params # Parameters and initialization values known_params = params.get_known_params(data) initials = params.get_initials(data) hyper_params = params.get_hyper_params(data) m_cover = params.m_cover m_type = params.m_type # Variables to be sampled (in this order) variable_names = ['h', 'g', 'T', 'C', 'noise_proportion', 'transition_var_g', 'transition_var_h'] priors = {'g': MVNormal(hyper_params['g']['mu'], hyper_params['g']['cov']), 'h': MVNormal(hyper_params['h']['mu'], hyper_params['h']['cov']), 'C': IID(Categorical(hyper_params['C']['p']), n), 'T': IID(Categorical(hyper_params['T']['p']), N), 'noise_proportion': Dirichlet(hyper_params['noise_proportion']['alpha']), 'transition_var_g': stats.invgamma(hyper_params['transition_var_g']['a'], scale=hyper_params['transition_var_g']['b']), 'transition_var_h': stats.invgamma(hyper_params['transition_var_h']['a'], scale=hyper_params['transition_var_h']['b'])} FCP_samplers = {'g': ground_elev_step(), 'h': canopy_height_step(), 'C': cover_step(), 'T': type_step(), 'noise_proportion': noise_proportion_step(), 'transition_var_g': transition_var_g_step(), 'transition_var_h': transition_var_h_step()} sample_handlers = {'g': [indep_meanvar_handler()], 'h': [indep_meanvar_handler()], 'T': [discrete_handler(support=range(m_type), length=N)], 'C': [discrete_handler(support=range(m_cover), length=n)], 'noise_proportion': [raw_sample_handler()], 'transition_var_g': [raw_sample_handler()], 'transition_var_h': [raw_sample_handler()]} diagnostic_variable = 'noise_proportion' model = Model() model.set_variable_names(variable_names) model.set_known_params(known_params) model.set_hyper_params(hyper_params) model.set_priors(priors) model.set_initials(initials) model.set_FCP_samplers(FCP_samplers) model.set_sample_handlers(sample_handlers) model.set_diagnostic_variable(diagnostic_variable) model.set_data(data) return model