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)
