def fit(self, X, y):
self.model = pm.Model()
with self.model:
prob = pm.Uniform('prob', lower=0.03, upper=0.97)
xi = pm.Bernoulli(
'xi', p=prob,
shape=X.shape[1]) # inclusion probability for each variable
alpha = pm.Normal('alpha', mu=0.0, sd=5.0) # Intercept
beta = pm.Normal(
'beta', mu=0.0, sd=1.0,
shape=X.shape[1]) # Prior for the non-zero coefficients
p = pm.math.dot(
X, xi * beta
) # Deterministic function to map the stochastics to the output
y_obs = pm.Bernoulli('y_obs', invlogit(p + alpha),
observed=y) # Data likelihood
with self.model:
self.trace = pm.sample(2000,
random_seed=4816,
cores=1,
progressbar=False,
chains=1)
return None
def fit(self, X, y):
self.model = pm.Model()
with self.model:
xi = pm.Bernoulli(
'xi', .05,
shape=X.shape[1]) # inclusion probability for each variable
alpha = pm.Cauchy('alpha', alpha=0, beta=2.0) # Intercept
coeff_shape = pm.Exponential("coeff_shape", lam=0.05)
beta = pm.Cauchy(
'beta', alpha=0, beta=coeff_shape,
shape=X.shape[1]) # Prior for the non-zero coefficients
p = pm.math.dot(
X, xi * beta
) # Deterministic function to map the stochastics to the output
y_obs = pm.Bernoulli('y_obs', invlogit(p + alpha),
observed=y) # Data likelihood
with self.model:
self.trace = pm.sample(4000,
random_seed=4816,
cores=1,
progressbar=False,
chains=1)
return None
def part2():
with pm.Model() as model:
G1 = pm.Bernoulli('G1', 0.5)
## p(G2|G1)
G2_p = pm.Deterministic('G2_p', pm.math.switch(G1, 0.9, 0.1))
G2 = pm.Bernoulli('G2', G2_p)
## p(G3|G1)
G3_p = pm.Deterministic('G3_p', pm.math.switch(G1, 0.9, 0.1))
G3 = pm.Bernoulli('G3', G3_p)
X2 = pm.Normal('X2', mu=pm.math.switch(G2, 60, 50), sd=3.16)
X3 = pm.Normal('X3', mu=pm.math.switch(G3, 60, 50), sd=3.16)
trace = pm.sample(400000, tune=50, progressbar=True)
X2_50 = 0
G1 = 0
X3_50 = 0
for sample in trace:
if 49.5 <= sample['X2'] <= 50.5:
X2_50 += 1
if sample['G1'] == 1:
G1 += 1
if 49.5 <= sample['X3'] <= 50.5:
X3_50 += 1
print "X2:", X2_50, " G1:", G1, " X3:", X3_50
print "P(G1==2|X2==50): ", G1/X2_50
print "P(X3==50|X2==50): ", X3_50/X2_50
def generate_global_distribution(constraints, N):
hyperedges = foulis_randall_product()
hyperedges_tallies = zeros(12)
global_distribution = zeros(16)
while sum(global_distribution) < N:
with pm.Model():
pm.Uniform('C', 0.0, 1.0)
pm.Bernoulli('A', 0.5)
pm.Bernoulli('B', 0.5)
pm.Bernoulli('X', 0.5)
pm.Bernoulli('Y', 0.5)
S = pm.sample(N, tune=0, step=pm.Metropolis())
c = S.get_values('C')
a = S.get_values('A')
b = S.get_values('B')
x = S.get_values('X')
y = S.get_values('Y')
for i in range(0, N):
if (c[i] < constraints[x[i]][y[i]][a[i], b[i]]):
for edge in get_hyperedges(hyperedges,
[a[i], b[i], x[i], y[i]]):
hyperedges_tallies[edge] += 1
global_distribution[get_vertex(a[i], b[i], x[i], y[i])] += 1
z = [0, 1]
for a, b, x, y in product(z, z, z, z):
summed_tally = (sum(hyperedges_tallies[e]
for e in get_hyperedges(hyperedges, [a, b, x, y])))
global_distribution[get_vertex(a, b, x, y)] /= summed_tally
global_distribution *= 3
return global_distribution
def fun_infer_model_Bernoulli(df,
samples=10,
tune=100,
Krange=np.arange(2, 20),
path="./",
name=""):
ch = 1
N = df.shape[0]
Q = df.shape[1]
for K in Krange:
with pm.Model() as model:
learner = pm.Bernoulli('learner', shape=(N, K))
question = pm.Bernoulli('question',
a=np.repeat(.1, K),
shape=(Q, K))
x = pm.math.dot(learner, question.T)
results = pm.Bernoulli('rezults', p=x, shape=(N, Q), observed=df)
for RV in model.basic_RVs:
print(RV.name, RV.logp(model.test_point))
model_to_graphviz(model)
with model:
trace = pm.sample(samples,
chains=ch,
tune=tune,
discard_tuned_samples=True)
a = pm.math.dot(trace['learner'].mean(0),
trace['question'][:, :].mean(0).T)
pd.DataFrame(a.eval()).to_csv(path + name + "estim_" + str(K) + ".txt",
sep="\t")
print("finished: " + str(K))
return model
def get_chains(obs, obs_train, true_train):
'''
these arrays are n_galaxies x n_classifiers, and are 0 for isolated, 1 for merger.
'''
obs_classes, obj_ids, cfer_ids = make_flat(obs)
a_00, b_00, a_11, b_11 = get_beta_pars(true_train, obs_train)
n_cfers, n_obj = obs.shape
with pm.Model() as explicit_model:
f_M = pm.Beta('fM', alpha=0.5, beta=0.5)
r_Is = pm.Beta('rI', alpha=a_00, beta=b_00, shape=n_cfers)
r_Ms = pm.Beta('rM', alpha=a_11, beta=b_11, shape=n_cfers)
#the "real" data
true_class = pm.Bernoulli('true_class', f_M, shape=n_obj)
N_M_true = pm.Deterministic('N_M', TT.sum(true_class))
p_obs_1 = TT.switch(TT.eq(true_class[obj_ids], 1), r_Ms[cfer_ids],
1 - r_Is[cfer_ids])
observed = pm.Bernoulli('observed', p_obs_1, observed=obs_classes)
with explicit_model:
trace = pm.sample(draws=5000)
return trace.get_values('fM'), trace.get_values('rI'), trace.get_values(
'rM'), trace.get_values('true_class')
def model_fit_using_se(data,
u_dim,
method='mcmc',
num_iter=10,
num_sample=1000):
search_dim = data['search'].shape[1]
num_obs = data['search'].shape[0]
cov_u, mu_u = np.eye(u_dim), np.zeros(u_dim)
cov_nlp, mu_nlp = np.eye(search_dim), np.zeros(search_dim)
cov_nlp = np.loadtxt("similarity_matrix.csv",
dtype='float32',
delimiter=',')
with pm.Model() as model:
u = pm.MvNormal('u', mu=mu_u, cov=cov_u, shape=(num_obs, u_dim))
search = data[
'search'] #pm.MvNormal('search',mu=mu_search,cov=cov_search,observed=data['search'])
#Incoming edge to self esteem
u_se = pm.MvNormal('u_se', mu=mu_u, cov=cov_u, shape=u_dim)
search_se = pm.MvNormal('search_se',
mu=mu_nlp,
cov=cov_nlp,
shape=search_dim)
#self esteem as a function of its parents
se_mean = tt.nnet.nnet.sigmoid(
tt.dot(search, search_se) + tt.dot(u, u_se))
se = pm.Bernoulli('se', p=se_mean, observed=data['se'])
#Incoming edge to suicide ideation
u_si = pm.MvNormal('u_si', mu=mu_u, cov=cov_u, shape=u_dim)
search_si = pm.MvNormal('search_si',
mu=mu_nlp,
cov=cov_nlp,
shape=search_dim)
#se_si_sig = pm.Normal('se_si_sig',mu=0,tau=1)
se_si = pm.HalfNormal('se_si', sigma=1) #se_si_sig**2)
si_mean = tt.nnet.nnet.sigmoid(
tt.dot(search, search_si) + tt.dot(u, u_si) + se_si * se)
si = pm.Bernoulli('si', p=si_mean, observed=data['si'])
mf = pm.fit(n=num_iter)
#trace = pm.sample()
trace = mf.sample(num_sample)
#pm.traceplot(trace)
#trace = pm.sample()
# se_mean = pm.Uniform('se_mean',lower=0,upper=1,size=num_obs)
# se = pm.Bernoulli('se',p=se_mean, observed = data["se"])
# si_me
# si = pm.Bernoulli('si',p= ,observed = data["si"])
return trace
def posterior_mcmc(self, data):
"""
Find posterior distribution for the numerical method of solution
"""
with pm.Model() as ab_model:
# priors
mua = pm.distributions.continuous.Beta('muA',
alpha=self.alpha_prior,
beta=self.beta_prior)
mub = pm.distributions.continuous.Beta('muB',
alpha=self.alpha_prior,
beta=self.beta_prior)
# likelihoods
pm.Bernoulli('likelihoodA', mua, observed=data[0])
pm.Bernoulli('likelihoodB', mub, observed=data[1])
# find distribution of difference
pm.Deterministic('lift', mub - mua)
# find distribution of effect size
sigma_a = pm.Deterministic('sigmaA', np.sqrt(mua * (1 - mua)))
sigma_b = pm.Deterministic('sigmaB', np.sqrt(mub * (1 - mub)))
pm.Deterministic('effect_size', (mub - mua) /
(np.sqrt(0.5 * (sigma_a**2 + sigma_b**2))))
start = pm.find_MAP()
step = pm.Slice()
trace = pm.sample(self.iterations, step=step, start=start)
bins = np.linspace(0, 1, self.resolution)
mua = np.histogram(trace['muA'][500:], bins=bins, normed=True)
mub = np.histogram(trace['muB'][500:], bins=bins, normed=True)
sigma_a = np.histogram(trace['sigmaA'][500:], bins=bins, normed=True)
sigma_b = np.histogram(trace['sigmaB'][500:], bins=bins, normed=True)
rvs = trace['lift'][500:]
bins = np.linspace(
np.min(rvs) - 0.2 * abs(np.min(rvs)),
np.max(rvs) + 0.2 * abs(np.max(rvs)), self.resolution)
lift = np.histogram(rvs, bins=bins, normed=True)
rvs = trace['effect_size'][500:]
bins = np.linspace(
np.min(rvs) - 0.2 * abs(np.min(rvs)),
np.max(rvs) + 0.2 * abs(np.max(rvs)), self.resolution)
pes = np.histogram(rvs, bins=bins, normed=True)
posterior = {
'muA': mua,
'muB': mub,
'sigmaA': sigma_a,
'sigmaB': sigma_b,
'lift': lift,
'es': pes,
'prior': self.prior()
}
return posterior
def pymc3_dist(self, name, hypers):
p = self.p
if(len(hypers) == 1):
hyper_dist = hypers[0][0]
hyper_name = hypers[0][1]
p = hyper_dist.pymc3_dist(hyper_name, [])
if(self.num_elements==-1):
return pm.Bernoulli(name, p=p)
else:
return pm.Bernoulli(name, p=p, shape=self.num_elements)
def get_model():
conf = bayes_workshop.conf.get_conf()
(cols, data) = bayes_workshop.data.get_data()
demo_subj_id = 8
i_demo_trials = (data[:, cols.index("i_subj")] == demo_subj_id)
demo_data = data[i_demo_trials, :]
(n_trials, _) = demo_data.shape
i_modality = demo_data[:, cols.index("i_modality")]
responses = demo_data[:, cols.index("target_longer")]
cmp_dur = demo_data[:, cols.index("target_duration")]
i_audio = (i_modality == 0)
i_visual = (i_modality == 1)
with pm.Model() as model:
alpha = pm.Normal("alpha", mu=conf.standard_ms, sd=50.0)
beta = pm.HalfNormal("beta", sd=100.0)
delta_alpha = pm.Normal("delta_alpha", mu=0.0, sd=20.0)
delta_beta = pm.Normal("delta_beta", mu=0.0, sd=40.0)
alpha_audio = alpha + (delta_alpha / 2.0)
alpha_visual = alpha - (delta_alpha / 2.0)
beta_audio = beta + (delta_beta / 2.0)
beta_visual = beta - (delta_beta / 2.0)
theta_audio = bayes_workshop.utils.logistic(x=cmp_dur[i_audio],
alpha=alpha_audio,
beta=beta_audio)
theta_visual = bayes_workshop.utils.logistic(x=cmp_dur[i_visual],
alpha=alpha_visual,
beta=beta_visual)
obs_audio = pm.Bernoulli("obs_audio",
p=theta_audio,
observed=responses[i_audio])
obs_visual = pm.Bernoulli("obs_visual",
p=theta_visual,
observed=responses[i_visual])
return model
def fit(self, X, y):
self.model = pm.Model()
with self.model:
xi = pm.Bernoulli("xi", .05, shape=X.shape[1]) # inclusion probability for each variable
alpha = pm.StudentT("alpha", nu=3, mu=0.0, sd=5.0) # Intercept
beta = pm.StudentT("beta", nu=3, mu=0.0, sd=1.0, shape=X.shape[1]) # Prior for the non-zero coefficients
p = pm.math.dot(X, xi * beta) # Deterministic function to map the stochastics to the output
y_obs = pm.Bernoulli("y_obs", invlogit(p + alpha), observed=y) # Data likelihood
with self.model:
self.trace = pm.sample(2000, random_seed=4816, cores=1, progressbar=False, chains=1)
return None
def _build_model(self, data):
data = _data_df2dict(data)
with pm.Model() as model:
# Priors
k = pm.Normal('k',
mu=0.01,
sd=1.,
shape=2,
transform=Ordered(),
testval=[0.01, 0.02])
p = pm.Beta('p', alpha=1 + 4, beta=1 + 4)
α = pm.Exponential('alpha', lam=1)
ϵ = 0.01
# Value functions
VA = pm.Deterministic('VA', data['A'] * self._df(k, p, data['DA']))
VB = pm.Deterministic('VB', data['B'] * self._df(k, p, data['DB']))
# Choice function: psychometric
P_chooseB = pm.Deterministic(
'P_chooseB', choice_func_psychometric(α, ϵ, VA, VB))
# Likelihood of observations
r_likelihood = pm.Bernoulli('r_likelihood',
p=P_chooseB,
observed=data['R'])
return model
def fit(self, X, y):
"""Fit the Imputer to the dataset by fitting bayesian model.
Args:
X (pd.Dataframe): dataset to fit the imputer.
y (pd.Series): response, which is eventually imputed.
Returns:
self. Instance of the class.
"""
y = y.astype("category").cat
y_cat_l = len(y.codes.unique())
# bayesian logistic regression. Mutliple categories not supported yet
if y_cat_l != 2:
err = "Only two categories supported. Multinomial coming soon."
raise ValueError(err)
nc = len(X.columns)
# initialize model for bayesian logistic reg. Default vals for priors
# assume data is scaled and centered. Convergence can struggle or fail
# if not the case and proper values for the priors are not specified
# separately, also assumes each beta is normal and "independent"
# while betas likely not independent, this is technically a rule of OLS
with pm.Model() as fit_model:
alpha = pm.Normal("alpha", self.am, sd=self.asd)
beta = pm.Normal("beta", self.bm, sd=self.bsd, shape=nc)
p = pm.invlogit(alpha + beta.dot(X.T))
score = pm.Bernoulli("score", p, observed=y.codes)
params = {"model": fit_model, "labels": y.categories}
self.statistics_ = {"param": params, "strategy": self.strategy}
return self
def rasch_model(dataset):
"""Defines the mcmc model for Rasch estimation.
Args:
dataset: [n_items, n_participants] 2d array of measured responses
Returns:
model: PyMC3 model to run
"""
n_items, n_people = dataset.shape
observed = dataset.astype('int')
rasch_pymc_model = pm.Model()
with rasch_pymc_model:
# Ability Parameters (Standardized Normal)
ability = pm.Normal("Ability", mu=0, sigma=1, shape=n_people)
# Difficuly multilevel prior
sigma_difficulty = pm.HalfNormal('Difficulty_SD', sigma=1, shape=1)
difficulty = pm.Normal("Difficulty",
mu=0,
sigma=sigma_difficulty,
shape=n_items)
# Compute the probabilities
kernel = ability[None, :] - difficulty[:, None]
probabilities = pm.Deterministic("PL_Kernel", pm.math.invlogit(kernel))
# Get the log likelihood
log_likelihood = pm.Bernoulli("Log_Likelihood",
p=probabilities,
observed=observed)
return rasch_pymc_model
def define_linreg_model(llj_data):
"""
Defines a model with parameters to derive probabilities of an LLJ event
for a given value of the predictor variable
:param llj_data:
:return:
"""
predictor = llj_data[:, 0]
llj_events = llj_data[:, 1]
with pm.Model() as model:
# Define probability distribution with a logistic function,
# with parameters drawn from a normal distribution
beta = pm.Normal("beta", mu=0, tau=0.001, testval=0)
alpha = pm.Normal("alpha", mu=0, tau=0.001, testval=0)
p = pm.Deterministic("p", 1.0/(1. + tt.exp(beta*predictor + alpha)))
# Use a Bernoulli random variable to connect the probabilities to
# the observations
observed = pm.Bernoulli("bernoulli_obs", p, observed=llj_events)
start = pm.find_MAP()
step = pm.Metropolis()
trace = pm.sample(120000, step=step, start=start)
burned_trace = trace[100000::2]
alpha_samples = burned_trace["alpha"][:, None]
beta_samples = burned_trace["beta"][:, None]
pred_vals = np.linspace(predictor.min()-5, predictor.max()+5, 50)[:,
None]
p_pred = logistic(pred_vals.T, beta_samples, alpha_samples)
mean_prob_pred = p_pred.mean(axis=0)
return alpha_samples, beta_samples, mean_prob_pred, pred_vals, p_pred
def create_model(self):
with pm.Model() as self.model:
self.mean = pm.gp.mean.Zero()
# covariance function
l_L = pm.Gamma("l_L", alpha=2, beta=2, shape = self.dim)
# informative, positive normal prior on the period
eta_L = pm.HalfNormal("eta_L", sd=5)
self.cov_L = eta_L * pm.gp.cov.ExpQuad(self.dim, l_L)
# covariance function
l_H = pm.Gamma("l_H", alpha=2, beta=2, shape = self.dim)
delta = pm.Normal("delta", sd=10)
# informative, positive normal prior on the period
eta_H = pm.HalfNormal("eta_H", sd=5)
self.cov_H = eta_H * pm.gp.cov.ExpQuad(self.dim, l_H)
K_LL = self.cov_L(self.X_L)
K_HH = delta**2*self.cov_L(self.X_H) + self.cov_H(self.X_H)
K_LH = delta*self.cov_L(self.X_L, self.X_H)
K1 = tt.concatenate([K_LL, K_LH], axis = 1)
K2 = tt.concatenate([K_LH.T, K_HH], axis = 1)
self.K_stable = pm.gp.util.stabilize(tt.concatenate([K1,K2], axis = 0))
v = pm.Normal("fp_rotated_", mu=0.0, sd=1.0, shape=pm.gp.util.infer_shape(self.X))
fp = pm.Deterministic("fp", self.mean(self.X) + tt.slinalg.cholesky(self.K_stable).dot(v))
p = pm.Deterministic("p", pm.math.invlogit(fp))
y = pm.Bernoulli("y", p=p, observed=self.Y)
def build_softmax_linear(X, y, force_softmax=False):
"""
Sample from Bayesian Softmax Linear Regression
"""
num_features = X.shape[1]
num_classes = len(np.unique(y))
logistic_regression = num_classes == 2
Xt = theano.shared(X)
if logistic_regression and not force_softmax:
print('running logistic regression')
with pm.Model() as model:
W = pm.Normal('W', 0, sd=1e6, shape=num_features)
b = pm.Flat('b')
logit = Xt.dot(W) + b
p = tt.nnet.sigmoid(logit)
observed = pm.Bernoulli('obs', p=p, observed=y)
else:
with pm.Model() as model:
W = pm.Normal('W', 0, sd=1e6, shape=(num_features, num_classes))
b = pm.Flat('b', shape=num_classes)
logit = Xt.dot(W) + b
p = tt.nnet.softmax(logit)
observed = pm.Categorical('obs', p=p, observed=y)
return model
def test_model_shared_variable(self):
x = np.random.randn(100)
y = x > 0
x_shared = theano.shared(x)
y_shared = theano.shared(y)
with pm.Model() as model:
coeff = pm.Normal("x", mu=0, sd=1)
logistic = pm.Deterministic("p", pm.math.sigmoid(coeff * x_shared))
obs = pm.Bernoulli("obs", p=logistic, observed=y_shared)
trace = pm.sample(100)
x_shared.set_value([-1, 0, 1.0])
y_shared.set_value([0, 0, 0])
samples = 100
with model:
post_pred = pm.sample_posterior_predictive(trace,
samples=samples,
var_names=["p", "obs"])
expected_p = np.array(
[logistic.eval({coeff: val}) for val in trace["x"][:samples]])
assert post_pred["obs"].shape == (samples, 3)
assert np.allclose(post_pred["p"], expected_p)
def test_aesara_switch_broadcast_edge_cases(self):
# Tests against two subtle issues related to a previous bug in Aesara where aet.switch would not
# always broadcast tensors with single values https://github.com/pymc-devs/aesara/issues/270
# Known issue 1: https://github.com/pymc-devs/pymc3/issues/4389
data = np.zeros(10)
with pm.Model() as m:
p = pm.Beta("p", 1, 1)
obs = pm.Bernoulli("obs", p=p, observed=data)
# Assert logp is correct
npt.assert_allclose(
obs.logp(m.test_point),
np.log(0.5) * 10,
)
# Known issue 2: https://github.com/pymc-devs/pymc3/issues/4417
# fmt: off
data = np.array([
1.35202174, -0.83690274, 1.11175166, 1.29000367, 0.21282749,
0.84430966, 0.24841369, 0.81803141, 0.20550244, -0.45016253,
])
# fmt: on
with pm.Model() as m:
mu = pm.Normal("mu", 0, 5)
obs = pm.TruncatedNormal("obs", mu=mu, sigma=1, lower=-1, upper=2, observed=data)
# Assert dlogp is correct
npt.assert_allclose(m.dlogp([mu])({"mu": 0}), 2.499424682024436, rtol=1e-5)
def get_beta_bernoulli_dpmixture(X, params):
n_doc, n_feat = X.shape
n_comp = params['n_trunc']
with pm.Model() as model:
# sample P ~ DP(G0)
beta = pm.Beta('beta',
1.,
params['dp_alpha'],
shape=n_comp)
p_comp = pm.Deterministic(
'p_comp',
beta * tt.concatenate([[1], tt.extra_ops.cumprod(1 - beta)[:-1]]))
pkw = pm.Beta('pkw',
alpha=params['pkw_beta_dist_alpha'],
beta=params['pkw_beta_dist_beta'],
shape=(n_comp, n_feat))
# sample X ~ P
z = pm.Categorical('z',
p=p_comp,
shape=n_doc)
x = pm.Bernoulli('x',
p=pkw[z],
shape=(n_doc, n_feat),
observed=X)
return model
def _build_BPF(self):
print('start building the Bayesian probabilistic model')
self.x_u = theano.shared(self.train_u)
self.x_i = theano.shared(self.train_i)
self.y_r = theano.shared(self.train_r)
self.y_r_ui = theano.shared(np.array(self.nn_r_ui))
assert (len(self.y_r.get_value()) == len(self.y_r_ui.get_value()))
with pm.Model() as self.bncf: #define the prior and likelihood
b_u = pm.Normal('b_u', 0, sd=1, shape=self.shape[0])
b_i = pm.Normal('b_i', 0, sd=1, shape=self.shape[1])
u = pm.Normal('u', 0, sd=1)
tY = pm.Deterministic(
'tY',
tt.add(
tt.add(tt.add(b_u[self.x_u], b_i[self.x_i]), self.y_r_ui),
u))
#tY = pm.Deterministic('tY', ((b_u[self.x_u]+b_i[self.x_i])+self.y_r_ui)+u)#b_u+b_i+u+nn_r_ui
nY = pm.Deterministic('nY', pm.math.sigmoid(tY))
# likelihood of observed data
Y = pm.Bernoulli(
'Y', nY,
observed=self.y_r) #total_size=self.y_r.get_value().shape[0]
with self.bncf: #inference
approx = pm.fit(n=1000, method=pm.ADVI())
self.trace = approx.sample(draws=500)
with self.bncf: #posterior prediction
ppc = pm.sample_posterior_predictive(self.trace, progressbar=True)
self.by_r_ui = ppc['Y'].mean(axis=0)
print('done building the Bayesian probabilistic model')
def bayes_variance_model(data, var=True):
'''
Implement a model that predicts individual choices based on
non-linearly transformed contrast samples.
If var == True the variance of the ten contrast samples is
explicitly modeled. If False it is ommited.
'''
basic_model = pm.Model()
contrast = get_contrast(data)
response = (data.response + 1) / 2.
with basic_model:
# Priors for unknown model parameters
beta_time = pm.Normal('time', mu=0, sd=10, shape=10)
offset = pm.Normal('offset', mu=0, sd=0.05)
alpha = pm.Normal('alpha', mu=0, sd=2)
transformed = contrast**pm.math.exp(alpha) - 0.5**pm.math.exp(alpha)
weighted = transformed * beta_time[np.newaxis, :]
# Expected value of outcome
mu = weighted.mean(1) + offset
if var:
beta_std = pm.Normal('std', mu=0, sd=.35)
stdc = (transformed).std(1) / transformed.std(1).mean()
mu += beta_std * beta_time.mean() * stdc
ps = pm.math.invlogit(mu)
# Likelihood (sampling distribution) of observations
Y_obs = pm.Bernoulli('Y_obs', ps, observed=response)
return basic_model
def _build_model(self, data):
data = _data_df2dict(data)
with pm.Model() as model:
# Priors
# NOTE: we need another variable if we deal with losses, which goes
# to the value function
β = pm.Bound(pm.Normal, lower=0)('beta', mu=1, sd=1000)
γ = pm.Bound(pm.Normal, lower=0)('gamma', mu=0, sd=1000)
τ = pm.Bound(pm.Normal, lower=0)('tau', mu=0, sd=1000)
# TODO: pay attention to the choice function & it's params
α = pm.Exponential('alpha', lam=1)
ϵ = 0.01
value_diff = (self._value_function(γ, data['B']) -
self._value_function(γ, data['A']))
time_diff = (self._time_weighing_function(τ, data['DB']) -
self._time_weighing_function(τ, data['DA']))
diff = value_diff - β * time_diff
# Choice function: psychometric
P_chooseB = pm.Deterministic('P_chooseB',
choice_func_psychometric2(α, ϵ, diff))
# Likelihood of observations
r_likelihood = pm.Bernoulli('r_likelihood',
p=P_chooseB,
observed=data['R'])
return model
def test_model_shared_variable(self):
rng = np.random.RandomState(9832)
x = rng.randn(100)
y = x > 0
x_shared = aesara.shared(x)
y_shared = aesara.shared(y)
with pm.Model(rng_seeder=rng) as model:
coeff = pm.Normal("x", mu=0, sd=1)
logistic = pm.Deterministic("p", pm.math.sigmoid(coeff * x_shared))
obs = pm.Bernoulli("obs", p=logistic, observed=y_shared)
trace = pm.sample(100,
return_inferencedata=False,
compute_convergence_checks=False)
x_shared.set_value([-1, 0, 1.0])
y_shared.set_value([0, 0, 0])
samples = 100
with model:
post_pred = pm.sample_posterior_predictive(trace,
samples=samples,
var_names=["p", "obs"])
expected_p = np.array(
[logistic.eval({coeff: val}) for val in trace["x"][:samples]])
assert post_pred["obs"].shape == (samples, 3)
npt.assert_allclose(post_pred["p"], expected_p)
def add_observations():
with hierarchical_model.pymc_model:
for i in range(hierarchical_model.n_groups):
observations.append(
pm.Bernoulli(f'y_{i}',
theta[i],
observed=hierarchical_model.y[i]))
def create_model(self):
with pm.Model() as self.model:
self.mean = pm.gp.mean.Zero()
# covariance function
l = pm.Gamma("l_L", alpha=2, beta=2, shape = self.dim)
# informative, positive normal prior on the period
eta = pm.HalfNormal("eta_L", sd=5)
self.cov = eta * pm.gp.cov.ExpQuad(self.dim, l)
Kuu = self.cov(self.Xu)
Kuf = self.cov(self.Xu, self.X)
Luu = tt.slinalg.cholesky(pm.gp.util.stabilize(Kuu))
vu = pm.Normal("u_rotated_", mu=0.0, sd=1.0, shape=pm.gp.util.infer_shape(self.Xu))
u = pm.Deterministic("u", Luu.dot(vu))
Luuinv_u = pm.gp.util.solve_lower(Luu,u)
A = pm.gp.util.solve_lower(Luu, Kuf)
Qff = tt.dot(tt.transpose(A),A)
Kffd = self.cov(self.X, diag=True)
Lamd = pm.gp.util.stabilize(tt.diag(tt.clip(Kffd - tt.diag(Qff) + self.sigma**2, 0.0, np.inf)))
v = pm.Normal("fp_rotated_", mu=0.0, sd=1.0, shape=pm.gp.util.infer_shape(self.X))
fp = pm.Deterministic("fp", tt.dot(tt.transpose(A), Luuinv_u) + tt.sqrt(Lamd).dot(v))
p = pm.Deterministic("p", pm.math.invlogit(fp))
y = pm.Bernoulli("y", p=p, observed=self.Y)
def fit(self, matches, target):
lineups = set(matches['t1_lineup'].unique()).union(
matches['t2_lineup'].unique())
self.lineup_f2id = dict(enumerate(
lineups, 0)) # start from 0 for zero-based indexing
self.lineup_id2f = {v: k for k, v in self.lineup_f2id.items()}
t1 = matches['t1_lineup'].map(self.lineup_id2f)
t2 = matches['t2_lineup'].map(self.lineup_id2f)
# threshold_date = str(datetime.datetime.strptime(matches['date'].max(), '%Y-%m-%d %H:%M') -\
# datetime.timedelta(days=self.time_span))
# t1_older = matches[matches['date'] <= threshold_date]['t1_lineup'].map(self.lineup_id2f)
# t2_older = matches[matches['date'] <= threshold_date]['t2_lineup'].map(self.lineup_id2f)
# t1_newer = matches[matches['date'] > threshold_date]['t1_lineup'].map(self.lineup_id2f)
# t2_newer = matches[matches['date'] > threshold_date]['t2_lineup'].map(self.lineup_id2f)
t_num = len(lineups) # number of teams
# obs_older = target[matches['date'] <= threshold_date]
# obs_newer = target[matches['date'] > threshold_date]
# modeling older observations
with pm.Model() as model:
sigma = pm.HalfFlat('sigma', shape=t_num)
alpha = pm.Normal('alpha', mu=0, sigma=sigma, shape=t_num)
theta = pm.Deterministic('theta', alpha[t1] - alpha[t2])
y = pm.Bernoulli('y', logit_p=theta, observed=target)
self.trace = pm.sample(self.fit_iters, tune=self.tune)
'''# modeling newer observations
def fun_infer_model_test(df,
question,
tune=100,
samples=10,
K=2,
path="./",
name="",
run=1):
ch = 1
N = df.shape[0]
Q = df.shape[1]
with pm.Model() as model:
learner = pm.Uniform('learner', shape=(N, K))
x = pm.math.dot(learner, question.T)
results = pm.Bernoulli('rezults', p=x, shape=(N, Q), observed=df)
if run:
with model:
trace = pm.sample(samples,
chains=ch,
tune=tune,
discard_tuned_samples=True)
pd.DataFrame(trace['learner'].mean(0)).to_csv(
path + name + "learner_fixed_question" + str(K) + ".txt", sep="\t")
print("finished: " + str(K))
return [model, trace]
def Two_Parameter_Model(Path, N_people, SEED, Max_pump=128):
'''
Path: Path where your record file exist.
N_people: The Number of participants you have.
SEED: Set radnom seed of MCMC sampling.
Max_pump: Maxiumum trial of your BART setting. My setting is 128.
'''
traces_gamma = []
traces_beta = []
for part in range(1, N_people + 1):
with pm.Model() as total_model:
start_time = time.time()
p = 0.15
obs = BernData(part, Max_pump, Path)
#Pth participant
gamma_plus = pm.Uniform("gamma_plus", 0, 10)
beta = pm.Uniform("beta", 0, 10)
omega_k = -gamma_plus / np.log(1 - p)
for i in range(len(obs)):
for l in range(Max_pump):
theta_lk = 1 / (1 + np.exp(beta * (l - omega_k)))
prob = pm.Bernoulli("prob_{}_{}".format(i, l),
p=theta_lk,
observed=obs[i][l])
_trace = pm.sample_smc(1000, cores=6, random_seed=SEED)
print("Sampling end:", part,
"--- %s seconds ---" % (time.time() - start_time))
traces_gamma.append(_trace["gamma_plus"])
traces_beta.append(_trace["beta"])
return traces_gamma, traces_beta
def main(n_chains=3):
np.random.seed(113)
x_train, y_train_onehot = prepare_data(train=True,
onehot=True,
take_first=500)
print(f"Using {len(x_train)} train samples.")
model = pm.Model()
with model:
w = pm.Bernoulli('w', p=0.5, shape=(784, 10))
logit_vec = tt.dot(x_train, w)
proba = softmax(logit_vec)
y_obs = pm.Multinomial('y_obs', n=1, p=proba, observed=y_train_onehot)
trace = None
if os.path.exists(fpath_trace):
with open(fpath_trace, 'rb') as f:
trace = pickle.load(f)
if trace.nchains != n_chains:
print(
f"Reset previous progress {trace} to match n_chains={n_chains}"
)
trace = None
trace = pm.sample(draws=3,
njobs=1,
chains=n_chains,
tune=0,
trace=trace)
if trace.nchains == n_chains:
# we didn't stop the training process
with open(fpath_trace, 'wb') as f:
pickle.dump(trace, f)
convergence_plot(trace=trace, train=True)
