def pymc3_dist(self, name, hypers): n = self.n p = self.p if(len(hypers) == 1): hyper_dist = hypers[0][0] hyper_name = hypers[0][1] idx = hypers[0][2] if(idx == 0): n = hyper_dist.pymc3_dist(hyper_name, []) else: p = hyper_dist.pymc3_dist(hyper_name, []) elif(len(hypers) == 2): hyper_dist_1 = hypers[0][0] hyper_name_1 = hypers[0][1] hyper_dist_2 = hypers[1][0] hyper_name_2 = hypers[1][1] n = hyper_dist_1.pymc3_dist(hyper_name_1, []) p = hyper_dist_2.pymc3_dist(hyper_name_2, []) if(self.num_elements==-1): return pm.Binomial(name, n=n, p=p) else: return pm.Binomial(name, n=n, p=p, shape=self.num_elements)
def get_bayesian_model(model_type, Y, shots, m_gates, mu_AB, cov_AB, alpha_ref, alpha_lower=0.5, alpha_upper=0.999, alpha_testval=0.9, p_lower=0.9, p_upper=0.999, p_testval=0.95, RvsI=None, IvsR=None, sigma_theta=0.004): # Bayesian model # from https://iopscience.iop.org/arti=RvsI, cle/10.1088/1367-2630/17/1/013042/pdf # see https://docs.pymc.io/api/model.html RB_model = pm.Model() with RB_model: total_shots = np.full(Y.shape, shots) #Priors for unknown model parameters alpha = pm.Uniform("alpha", lower=alpha_lower, upper=alpha_upper, testval=alpha_ref) BoundedMvNormal = pm.Bound(pm.MvNormal, lower=0.0) AB = BoundedMvNormal("AB", mu=mu_AB, testval=mu_AB, cov=np.diag(cov_AB), shape=(2)) if model_type == "hierarchical": GSP = AB[0] * alpha**m_gates + AB[1] theta = pm.Beta("GSP", mu=GSP, sigma=sigma_theta, shape=Y.shape[1]) # Likelihood (sampling distribution) of observations p = pm.Binomial("Counts_h", p=theta, observed=Y, n=total_shots) elif model_type == "tilde": p_tilde = pm.Uniform("p_tilde", lower=p_lower, upper=p_upper, testval=p_testval) GSP = AB[0] * (RvsI * alpha**m_gates + IvsR * (alpha * p_tilde)**m_gates) + AB[1] # Likelihood (sampling distribution) of observations p = pm.Binomial("Counts_t", p=GSP, observed=Y, n=total_shots) else: # defaul model "pooled" GSP = AB[0] * alpha**m_gates + AB[1] # Likelihood (sampling distribution) of observations p = pm.Binomial("Counts_p", p=GSP, observed=Y, n=total_shots) return RB_model
def _make_model(self): tumorInd = self.pheno['Tumor'] == 1 tumorTCs = self.pheno.loc[tumorInd, 'tcEst'].values tumorRes = self.pheno.loc[tumorInd, 'tcRes'].values nTumor = np.round(tumorTCs * tumorRes).astype(int) freeInd = self.pheno['Tumor'] == 0 freeTCs = self.pheno.loc[freeInd, 'tcEst'].values freeRes = self.pheno.loc[freeInd, 'tcRes'].values nFree = np.round(freeTCs * freeRes).astype(int) mu = np.mean(list(tumorRes) + list(freeRes)) sig = np.std(list(tumorRes) + list(freeRes)) alpha_gamma = mu**2 / sig beta_gamma = mu / sig with pm.Model() as model: u = pm.Uniform('u', 0, 1, testval = .5, shape = 2) v = pm.Gamma('v', alpha = alpha_gamma, beta = beta_gamma, testval = 100, shape = 2) alpha = pm.Deterministic('alpha', v * u) beta = pm.Deterministic('beta', v * (1 - u)) p = pm.Beta('p', alpha = alpha, beta = beta, shape = 2) obsTumor = [pm.Binomial('obsTumor' + str(i), n = tumorRes[i], p = p[0], observed = nTumor[i]) for i in range(len(nTumor))] obsFree = [pm.Binomial('obsFree' + str(i), n = freeRes[i], p = p[1], observed = nFree[i]) for i in range(len(nFree))] return model
def create_model(self, Pm, pol_br_init, delta): with pm.Model() as model: #set priors for parameters etal = pm.Normal("eta_l", mu=0, sigma=10) etad = pm.HalfNormal("eta_d", sigma=2) etah = pm.Deterministic("eta_h", etal + etad) tauy = pm.HalfNormal("tau_y", sigma=2) prg = pm.Uniform("prg", lower=self.qhigh, upper=1) prb = pm.Uniform("prb", lower=0, upper=self.qlow) etam = pm.Normal("etam", mu=0, sigma=10, shape=self.nm) beta = pm.Normal("beta", mu=0, sigma=10) #eqvars is a deterministic variable that computes the equilibrium and returns the stuff I need for the likelihood eqvars = pm.Deterministic( "eqvars", self.eqinfo(etah, etal, tauy, prg, prb, etam, beta, Pm, pol_br_init, delta)) peff = eqvars[0] rvoteprob1 = eqvars[1] rvoteprob2 = eqvars[2] #compute initial voter beliefs zdata = self.data['party_1'] * self.data['zr_1'] + ( 1 - self.data['party_1']) * self.data['zd_1'] mu_top = pipardata * (prg**zdata) * (1 - prg)**(1 - zdata) mu_bottom = mu_top + (1 - pipardata) * (prb**zdata) * (1 - prb)**( 1 - zdata) mu = mu_top / mu_bottom #mixture weights: [good type, bad type high effort, bad type low effort] my_w = [mu, (1 - mu) * peff, (1 - mu) * (1 - peff)] #component distributions (2-dimensional multivariate normals) mvcomp1 = pm.MvNormal("ydist", mu=[etah, etah], cov=np.identity(3) * (tauy**(-2)), shape=2) mvcomp2 = pm.MvNormal("ydist", mu=[etah, etal], cov=np.identity(3) * (tauy**(-2)), shape=2) mvcomp3 = pm.MvNormal("ydist", mu=[etal, etal], cov=np.identity(3) * (tauy**(-2)), shape=2) #likelihood Y_obs = pm.Mixture('Y', w=my_w, comp_dists=[mvcomp1, mccomp2, mccomp3], observed=Y) rvotes1 = pm.Binomial(n=self.data[rvotes_1] + self.data[dvotes_1], p=rvoteprob1, observed=self.data[rvotes_1]) rvotes2 = pm.Binomial(n=self.data[rvotes_2] + self.data[dvotes_2], p=rvoteprob1, observed=self.data[rvotes_2])
def fit_adj_pass_model(successes, attempts): ## inputs are two lists in the form: ## successes = [successful long passes, total successful passes] ## attempts = [attempted long passes, total attempted passes] ## returns: ## sl, a numpy array of shape (6000,N) containing 6000 posterior samples of success probabilites (N is the number of players in the ## original data frame who have registered non-zero expected succcesses) ## sb, an empty list ## kk, boolean indicating which players have actually registered non-zero expected successes ## 'adj_pass', character string indicating the model type. import numpy as np import pymc3 as pm import pymc3.distributions.transforms as tr import theano.tensor as tt LonCmp = successes[0] TotCmp = successes[1] LonAtt = attempts[0] TotAtt = attempts[1] kk = (LonCmp > 0) & np.isfinite(LonAtt) LonCmp = LonCmp[kk] LonAtt = LonAtt[kk] TotCmp = TotCmp[kk] TotAtt = TotAtt[kk] ShCmp = TotCmp - LonCmp ShAtt = TotAtt - LonAtt average_long_tendency = np.mean(LonAtt / TotAtt) N = np.sum(kk) def logp_ab(value): ''' prior density''' return tt.log(tt.pow(tt.sum(value), -5 / 2)) with pm.Model() as model: # Uninformative prior for alpha and beta ab_short = pm.HalfFlat('ab_short', shape=2, testval=np.asarray([1., 1.])) ab_long = pm.HalfFlat('ab_long', shape=2, testval=np.asarray([1., 1.])) pm.Potential('p(a_s, b_s)', logp_ab(ab_short)) pm.Potential('p(a_l, b_l)', logp_ab(ab_long)) lambda_short = pm.Beta('lambda_s', alpha=ab_short[0], beta=ab_short[1], shape=N) lambda_long = pm.Beta('lambda_l', alpha=ab_long[0], beta=ab_long[1], shape=N) y_short = pm.Binomial('y_s', p=lambda_short, observed=ShCmp, n=ShAtt) y_long = pm.Binomial('y_l', p=lambda_short * lambda_long, observed=LonCmp, n=LonAtt) approx = pm.fit(n=30000) s_sh = approx.sample(6000)['lambda_s'] s_lo = approx.sample(6000)['lambda_l'] sl = average_long_tendency * s_lo + (1 - average_long_tendency) * s_sh return [sl, [], kk, 'adj_pass']
def simple_bayes(splits, actions, temp=1.): with pm.Model() as model: r = pm.Normal('r', mu=0, sd=1) p = np.exp(r * splits) / (1 + np.exp(r * splits)) a = pm.Binomial('a', 1, p, observed=actions) trace = pm.sample(20000, init='map') return trace
def main(n, observed): ''' parameters -------- n : int number of trials observed: int observed number of success ''' with pm.Model() as exam_model: # Week uniform prior for prior prior = pm.Beta('prior', 0.5, 0.5) # Bernouli trials modeled using binomial distribution obs = pm.Binomial('obs', n=n, p=prior, observed=observed) # plot model design pm.model_to_graphviz(exam_model) # Use metropolis hasting for sampling step = pm.Metropolis() # sample from the prior distribution to get the posterior trace = pm.sample(5000, step) # plot posterior pm.plot_posterior(trace) # calculate gelman rubin stats pm.gelman_rubin(trace)
def test_single_observation(self): with pm.Model(): p = pm.Uniform("p", 0, 1) pm.Binomial("w", p=p, n=2, observed=1) inference_data = pm.sample(500, chains=2, return_inferencedata=True) assert inference_data
def exercise4(): with pm.Model() as basic_model: probabilities = [0.3, 0.7, 0.95] likelihood_params = np.array( [np.divide(1, 3) * (1 + 2 * prob) for prob in probabilities]) group = pm.Categorical('group', p=np.array([1, 1, 1])) p = pm.Deterministic('p', theano.shared(likelihood_params)[group]) positive_answers = pm.Binomial('positive_answers', n=num_questions, p=p, observed=[7]) trace = pm.sample(4000, progressbar=True) az.plot_trace(trace) plt.show() az.plot_posterior(trace) plt.show() az.summary(trace) return trace
def run(): data = sim() n_rooms = len(data) prior = [0.5, 0.25, 0.125, 0.0625, 0.03125] prior = [0.25, 0., 0.25, 0.25, 0.5] #p_find=np.array([0.25,0.25,0.25,0.25,0.25]) #p_find=tt.cast([0.25,0.25,0.25,0.25,0.25],'int64') p_find = theano.shared(np.array([0.25, 0.25, 0.25, 0.25, 0.25])) tmp_find = theano.shared(np.array([0.25, 0.25, 0.25, 0.25, 0.25])) datas = theano.shared(data) print(data) with pm.Model() as model: target_loc = pm.Categorical('target_loc', p=prior) #Likelihood #room_search=pm.DiscreteUniform('room_search',1,n_rooms) #p = pm.math.switch(theano.tensor.eq(room_search,target_loc),p_find[target_loc], 0) tmp_find = tmp_find * 0 tmp_find = tt.set_subtensor(tmp_find[target_loc], p_find[target_loc]) #theano.printing.Print('tmp_find')(tmp_find) y = pm.Binomial('y', p=tmp_find, n=[5, 1., 1., 10., 10.], observed=[0, 0, 0, 0, 0]) trace = pm.sample(5000, cores=4) pm.plots.traceplot(trace, combined=True) #pm.traceplot(trace, # combined=True, # prior=[target_loc.distribution]); plt.show() print(pm.summary(trace))
def _model_turnovers(self, off_index, def_index, home_index): off_turnover_rate = pm.Beta( "off_turnover_rate", mu=self.mu_turnover_rate, sigma=self.priors["off_turnover_rate_sigma"], shape=self.n_teams, ) def_turnover_rate = pm.Beta( "def_turnover_rate", mu=self.mu_turnover_rate, sigma=self.priors["def_turnover_rate_sigma"], shape=self.n_teams, ) home_turnover_rate = pm.Beta( "home_turnover_rate", mu=self.mu_turnover_rate - self.priors["home_turnover_rate_diff"], sigma=self.priors["home_turnover_rate_sigma"], ) away_turnover_rate = 2 * self.mu_turnover_rate - home_turnover_rate halfgames_turnover_rate = log5( self.mu_turnover_rate, off_turnover_rate[off_index], def_turnover_rate[def_index], pm.math.stack([home_turnover_rate, away_turnover_rate])[home_index], ) pm.Binomial( "turnovers", n=self.halfgames["possession_num"].to_numpy(), p=halfgames_turnover_rate, observed=self.halfgames["turnovers"].to_numpy(), )
def _model_off_rebs(self, off_index, def_index, home_index): off_off_reb_rate = pm.Beta( "off_off_reb_rate", mu=self.mu_off_reb_rate, sigma=self.priors["off_off_reb_rate_sigma"], shape=self.n_teams, ) def_off_reb_rate = pm.Beta( "def_off_reb_rate", mu=self.mu_off_reb_rate, sigma=self.priors["def_off_reb_rate_sigma"], shape=self.n_teams, ) home_off_reb_rate = pm.Beta( "home_off_reb_rate", mu=self.mu_off_reb_rate + self.priors["home_off_reb_rate_diff"], sigma=self.priors["home_off_reb_rate_sigma"], ) away_off_reb_rate = 2 * self.mu_off_reb_rate - home_off_reb_rate halfgames_off_reb_rate = log5( self.mu_off_reb_rate, off_off_reb_rate[off_index], def_off_reb_rate[def_index], pm.math.stack([home_off_reb_rate, away_off_reb_rate])[home_index], ) pm.Binomial( "off_rebs", n=(self.halfgames["off_rebs"] + self.halfgames["def_rebs"]).to_numpy(), p=halfgames_off_reb_rate, observed=self.halfgames["off_rebs"].to_numpy(), )
def _model_threes_attempted(self, off_index, def_index): off_three_attempt_rate = pm.Beta( "off_three_attempt_rate", mu=self.mu_three_attempt_rate, sigma=self.priors["off_three_attempt_rate_sigma"], shape=self.n_teams, ) def_three_attempt_rate = pm.Beta( "def_three_attempt_rate", mu=self.mu_three_attempt_rate, sigma=self.priors["def_three_attempt_rate_sigma"], shape=self.n_teams, ) halfgames_three_attempt_rate = log5( self.mu_three_attempt_rate, off_three_attempt_rate[off_index], def_three_attempt_rate[def_index], ) pm.Binomial( "threes_attempted", n=(self.halfgames["twos_attempted"] + self.halfgames["threes_attempted"]).to_numpy(), p=halfgames_three_attempt_rate, observed=self.halfgames["threes_attempted"].to_numpy(), )
def _model_twos_made(self, off_index, def_index, home_index): off_two_make_rate = pm.Beta( "off_two_make_rate", mu=self.mu_two_make_rate, sigma=self.priors["off_two_make_rate_sigma"], shape=self.n_teams, ) def_two_make_rate = pm.Beta( "def_two_make_rate", mu=self.mu_two_make_rate, sigma=self.priors["def_two_make_rate_sigma"], shape=self.n_teams, ) home_two_make_rate = pm.Beta( "home_two_make_rate", mu=self.mu_two_make_rate + self.priors["home_two_make_rate_diff"], sigma=self.priors["home_two_make_rate_sigma"], ) away_two_make_rate = 2 * self.mu_two_make_rate - home_two_make_rate halfgames_two_make_rate = log5( self.mu_two_make_rate, off_two_make_rate[off_index], def_two_make_rate[def_index], pm.math.stack([home_two_make_rate, away_two_make_rate])[home_index], ) pm.Binomial( "twos_made", n=self.halfgames["twos_attempted"].to_numpy(), p=halfgames_two_make_rate, observed=self.halfgames["twos_made"].to_numpy(), )
def mk_true_positive(df, se=[0.9, 1], sp=[0.9, 1]): data = df.copy() data.dropna(inplace=True) data['positive'] = data.positive.rolling(window=7).mean() data['total'] = data.total.rolling(window=7).mean() data.drop(data[data.total < data.positive].index) data.dropna(inplace=True) data = data.reset_index(drop=True) coords = {"date": data.index, "variables": ['total', 'positive']} with pm.Model(coords=coords) as model: pi = pm.Uniform('pi', lower=0, upper=1, dims='date') se = pm.Uniform('se', lower=se[0], upper=se[1], dims='date') sp = pm.Uniform('sp', lower=sp[0], upper=sp[1], dims='date') #se=pm.Normal('se',mu=0.95 sigma=None, tau=None, sd=None,dims='date') p = pi * se + (1 - pi) * (1 - sp) observed_positive = pm.Binomial('observed_positive', n=data.total.values, p=p, observed=data.positive.values, dims='date') obs_positive_trace = pm.sample(target_accept=0.95) return obs_positive_trace, data
def main(): with pm.Model() as model: # Using a strong prior. Meaning the mean is towards zero than towards 1 prior = pm.Beta('prior', 0.5, 3) output = pm.Binomial('output', n=100, observed=50, p=prior) step = pm.Metropolis() trace = pm.sample(1000, step=step) pm.traceplot(trace) pm.plot_posterior(trace, figsize=(5, 5), kde_plot=True, rope=[0.45, 0.55]) # Rope is an interval that you define # This is a value you eppect. You can check # If ROPE fall on HPD or not. If it falls, it means # our value is within HPD and may be increasing sample # size would make our mean estimate better. # gelman rubin pm.gelman_rubin(trace) # forestplot pm.forestplot(trace, varnames=['prior']) # summary [look at mc error here. This is the std error, should be low] pm.df_summary(trace) #autocorrelation pm.autocorrplot(trace) # effective size pm.effective_n(trace)['prior']
def get_bayesian_model_hierarchical( model_type, Y): # modified for accelerated BM with EPCest as extra parameter # Bayesian model # from https://iopscience.iop.org/article/10.1088/1367-2630/17/1/013042/pdf # see https://docs.pymc.io/api/model.html RBH_model = pm.Model() with RBH_model: #Priors for unknown model parameters alpha = pm.Uniform("alpha", lower=alpha_lower, upper=alpha_upper, testval=alpha_ref) BoundedMvNormal = pm.Bound(pm.MvNormal, lower=0.0) AB = BoundedMvNormal("AB", mu=mu_AB, testval=mu_AB, cov=np.diag(cov_AB), shape=(2)) # Expected value of outcome GSP = AB[0] * alpha**m_gates + AB[1] total_shots = np.full(Y.shape, shots) theta = pm.Beta("GSP", mu=GSP, sigma=sigma_theta, shape=Y.shape[1]) # Likelihood (sampling distribution) of observations p = pm.Binomial("Counts", p=theta, observed=Y, n=total_shots) return RBH_model
def test_waic(): """Test widely available information criterion calculation""" x_obs = np.arange(6) with pm.Model() as model: prob = pm.Beta('p', 1., 1., transform=None) pm.Binomial('x', 5, prob, observed=x_obs) step = pm.Metropolis() trace = pm.sample(100, step) calculated_waic = waic(trace, model) log_py = stats.binom.logpmf(np.atleast_2d(x_obs).T, 5, trace['p']).T lppd_i = np.log(np.mean(np.exp(log_py), axis=0)) vars_lpd = np.var(log_py, axis=0) waic_i = - 2 * (lppd_i - vars_lpd) actual_waic_se = np.sqrt(len(waic_i) * np.var(waic_i)) actual_waic = np.sum(waic_i) assert_almost_equal(np.asarray(calculated_waic.waic), actual_waic, decimal=2) assert_almost_equal(np.asarray(calculated_waic.waic_se), actual_waic_se, decimal=2)
def binomial_model(): n_samples = 100 xs = np.random.binomial(n=1, p=0.2, size=n_samples) with pm.Model() as model: p = pm.Beta('p', alpha=1, beta=1) pm.Binomial('xs', n=1, p=p, observed=xs) return model
def binom_model(df): # todo: make sure this works ok with pm.Model() as disaster_model: switchpoint = pm.DiscreteUniform('switchpoint', lower=df['t'].min(), upper=df['t'].max()) # Priors for pre- and post-switch probability of "yes"...is there a better prior? early_rate = pm.Beta('early_rate', 1, 1) late_rate = pm.Beta('late_rate', 1, 1) # Allocate appropriate probabilities to periods before and after current p = pm.math.switch(switchpoint >= df['t'].values, early_rate, late_rate) p = pm.Deterministic('p', p) successes = pm.Binomial('successes', n=df['n'].values, p=p, observed=df['category'].values) trace = pm.sample(10000) pm.traceplot(trace) plt.show()
def ice_cream_hierarchical_model(data): """Hierarchical model for ice cream shops""" n_owners = len(data["owner_idx"].unique()) with pm.Model() as model: logit_p_overall = pm.Normal("logit_p_overall", mu=0, sigma=1) logit_p_owner_mean = pm.Normal( "logit_p_owner_mean", mu=logit_p_overall, sigma=1, shape=(n_owners, ), ) logit_p_owner_scale = pm.Exponential("logit_p_owner_scale", lam=1 / 5.0, shape=(n_owners, )) logit_p_shop = pm.Normal( "logit_p_shop", mu=logit_p_owner_mean[data["owner_idx"]], sigma=logit_p_owner_scale[data["owner_idx"]], shape=(len(data), ), ) p_overall = pm.Deterministic("p_overall", pm.invlogit(logit_p_overall)) p_shop = pm.Deterministic("p_shop", pm.invlogit(logit_p_shop)) p_owner = pm.Deterministic("p_owner", pm.invlogit(logit_p_owner_mean)) like = pm.Binomial( "like", n=data["num_customers"], p=p_shop, observed=data["num_favs"], ) return model
def binomial_model(): n_samples = 100 xs = intX(np.random.binomial(n=1, p=0.2, size=n_samples)) with pm.Model() as model: p = pm.Beta("p", alpha=1, beta=1) pm.Binomial("xs", n=1, p=p, observed=xs) return model
def test_layers(self): with pm.Model() as model: a = pm.Uniform("a", lower=0, upper=1, shape=10) b = pm.Binomial("b", n=1, p=a, shape=10) avg = b.random(size=10000).mean(axis=0) npt.assert_array_almost_equal(avg, 0.5 * np.ones_like(b), decimal=2)
def add_observations(): with hierarchical_model.pymc_model: for i in range(hierarchical_model.n_groups): observations.append( pm.Binomial(f'y_{i}', n=hierarchical_model.y[i][:, 0], p=theta[i], observed=hierarchical_model.y[i][:, 1]))
def test_single_observation(self): with pm.Model(): p = pm.Uniform("p", 0, 1) pm.Binomial("w", p=p, n=2, observed=1) trace = pm.sample(500, chains=2) inference_data = from_pymc3(trace=trace) assert inference_data
def test_sample_node(self): n_samples = 100 xs = np.random.binomial(n=1, p=0.2, size=n_samples) with pm.Model(): p = pm.Beta('p', alpha=1, beta=1) pm.Binomial('xs', n=1, p=p, observed=xs) app = self.inference().approx app.sample_node(p).eval() # should be evaluated without errors
def test_layers(self): with pm.Model(rng_seeder=232093) as model: a = pm.Uniform("a", lower=0, upper=1, size=10) b = pm.Binomial("b", n=1, p=a, size=10) b_sampler = compile_rv_inplace([], b, mode="FAST_RUN") avg = np.stack([b_sampler() for i in range(10000)]).mean(0) npt.assert_array_almost_equal(avg, 0.5 * np.ones((10, )), decimal=2)
def ice_cream_store_model(data: pd.DataFrame) -> pm.Model: with pm.Model() as model: p = pm.Beta("p", alpha=2, beta=2, shape=(len(data), )) like = pm.Binomial("like", n=data["num_customers"], p=p, observed=data["num_favs"]) return model
def get_posterior(self, observed_data, use_ppc_samples=config.USE_PPC_SAMPLES): # ------------------------------------------------- # # CREATE BERNOULLI INPUT FROM SUCCESS PROPORTION # # ------------------------------------------------- # # Creates N_bernoulli_sims lots of (K x K) boolean grid mimicking # success rate in observed data. Required because pm.Bernoulli only # takes boolean data shaped (N x K x K) (this method is quite hacky) N_bernoulli_sims = 500 data = np.ones((config.K, config.K, N_bernoulli_sims)) change_to_zeros = np.round( (1 - self.p_wins) * N_bernoulli_sims).astype(int) data[change_to_zeros[:, :, None] > np.arange(data.shape[-1])] = 0 data = np.transpose(data, (2, 0, 1)) # Swap axes data = np.take(data, np.random.rand(data.shape[0]).argsort(), axis=0) # Shuffle on N axis # ------------------------------------------------- # # USE PYMC3 TO CREATE POSTERIOR AND SAMPLE FROM IT # # ------------------------------------------------- # model = pm.Model() with model: # Priors for unknown model parameters a = pm.Normal('a', mu=0, sd=10, shape=(config.K, 1)) b = pm.Normal('b', mu=0, sd=10, shape=(1, config.K)) offset = pm.Normal('offset', mu=0, sd=10) p = pm.Deterministic('p', self.sigmoid(a + b + offset)) # Likelihood (sampling distribution) of observations # L = pm.Bernoulli('L', p=p, observed=data) L = pm.Binomial('L', self.N_data, p, observed=self.s_with_obs) # draw posterior samples trace = pm.sample(config.TRACE_LENGTH, nuts_kwargs=dict(target_accept=.95), chains=config.N_MCMC_CHAINS) if use_ppc_samples: # Use samples from ppc to obtain posterior point estimates ppc = pm.sample_ppc(trace, samples=config.N_PPC_SAMPLES, model=model) # y_post = np.mean(ppc['L'], axis=(0, 1)) # USE IF USING BERNOULLI y_post = np.mean(ppc['L'], axis=0) / self.N_data # USE IF USING BINOMIAL else: # Use trace to obtain posterior point estimates a_post = np.array(np.mean(trace[:100]['a'], axis=0)) b_post = np.array(np.mean(trace[:100]['b'], axis=0)) offset_post = np.mean(trace[:100]['offset'], axis=0) y_post = self.sigmoid(a_post + b_post + offset_post) return y_post, model, trace
def test_n_obj_mc(self): n_samples = 100 xs = np.random.binomial(n=1, p=0.2, size=n_samples) with pm.Model(): p = pm.Beta('p', alpha=1, beta=1) pm.Binomial('xs', n=1, p=p, observed=xs) inf = self.inference(scale_cost_to_minibatch=True) # should just work inf.fit(10, obj_n_mc=10, obj_optimizer=self.optimizer)