def make_bernoulli(name, value=None, N=None, return_coeffs=False, fixed={}):
""" creates a Bernoulli random variable with a uniform parent
:param name: name of the variable
:param value: optional - list of observed values of the variable. May be a masked array - if
the variable has missing values
:param N: size of the variable (number of values). Either N or value must be specified
:param return_coeffs: if true, will return the parent Beta variable as well as the bernoulli
child. False by defaut.
:param fixed: optional dictionary of values of coefficients to be fixed.
:return: Bernoulli pymc random variable, or (if return_coeffs == True) a tuple
(bernoulli variable, a list with a single element - the Beta parent of the bernoulli)
"""
if value is None and N is None:
raise ValueError('either "value" or "N" must be specified')
if value is not None:
value = mask_missing(value)
parent_name = COEFFS_PREFIX + 'p(%s)' % name
parent = fixed.get(parent_name, pymc.Beta(parent_name, 1, 1))
if value is None:
child = pymc.Bernoulli(name, p=parent, value=np.zeros(N))
else:
child = pymc.Bernoulli(name, p=parent, observed=True, value=value)
set_levels_count(child, 2)
if return_coeffs:
return child, [parent]
else:
return child
def run_Bernoulli_Normal():
#Cluster 1
Uh1 = pm.Uniform('UnifH1', lower=-50, upper=50); # @UndefinedVariable
Nc1 = pm.Normal('NormC1', mu=Uh1, tau=1)#, observed=True, value=10); # @UndefinedVariable
#Cluster 2
Uh2 = pm.Uniform('UnifH2', lower=-50, upper=50); # @UndefinedVariable
Nc2 = pm.Normal('NormC2', mu=Uh2, tau=1)#, observed=True, value=10); # @UndefinedVariable
#Bernoulli Nodes
B1 = pm.Bernoulli('Bern1', 0.8); # @UndefinedVariable
B2 = pm.Bernoulli('Bern2', 0.8); # @UndefinedVariable
B3 = pm.Bernoulli('Bern3', 0.5); # @UndefinedVariable
#Points
p_N1 = pm.Lambda('p_Norm1', lambda k=B1, c1=Nc1, c2=Nc2: [c2,c1][int(k)]);
p_N2 = pm.Lambda('p_Norm2', lambda k=B2, c1=Nc1, c2=Nc2: [c1,c2][int(k)]);
p_N3 = pm.Lambda('p_Norm3', lambda k=B3, c1=Nc1, c2=Nc2: [c1,c2][int(k)]);
normalObs1 = pm.Normal('NormX1', mu=p_N1, tau=1, observed=True, value=-3); # @UndefinedVariable
normalObs2 = pm.Normal('NormX2', mu=p_N2, tau=1, observed=True, value=3); # @UndefinedVariable
normalObsZ = pm.Normal('NormZ', mu=p_N3, tau=1); # @UndefinedVariable
# @pm.stochastic(observed=True)
# def normalObs1(name='NormX1', parentVar=B1, parentVals=[Nc1,Nc2], value=8):
# return pm.normal_like(x=value, mu=parentVals[int(parentVar)], tau=1);
# @pm.stochastic(observed=True)
# def normalObs2(name='NormX2', parentVar=B2, parentVals=[Nc1,Nc2], value=2):
# return pm.normal_like(x=value, mu=parentVals[int(parentVar)], tau=1);
# @pm.stochastic(observed=False)
# def normalObsZ(name='NormZ', parentVar=B3, parentVals=[Nc1,Nc2], value=1):
# return pm.normal_like(x=value, mu=parentVals[int(parentVar)], tau=1);
# normalObs1 = pm.Normal('NormX1', mu=[Nc1,Nc2][int(B1)], tau=1, observed=True, value=2); # @UndefinedVariable
# normalObs2 = pm.Normal('NormX2', mu=[Nc1,Nc2][int(B2)], tau=1, observed=True, value=8); # @UndefinedVariable
# normalObsZ = pm.Normal('NormZ', mu=[Nc1,Nc2][int(B3)], tau=1); # @UndefinedVariable
return [Nc1,Nc2,B1,B2,B3,Uh1,Uh2,normalObs1,normalObs2,normalObsZ];
def run_Bernoulli_Normal():
#Cluster 1
Uh1 = pm.Uniform('UnifH1', lower=-50, upper=50)
# @UndefinedVariable
Nc1 = pm.Normal('NormC1', mu=Uh1,
tau=1) #, observed=True, value=10); # @UndefinedVariable
#Cluster 2
Uh2 = pm.Uniform('UnifH2', lower=-50, upper=50)
# @UndefinedVariable
Nc2 = pm.Normal('NormC2', mu=Uh2,
tau=1) #, observed=True, value=10); # @UndefinedVariable
#Bernoulli Nodes
B1 = pm.Bernoulli('Bern1', 0.8)
# @UndefinedVariable
B2 = pm.Bernoulli('Bern2', 0.8)
# @UndefinedVariable
B3 = pm.Bernoulli('Bern3', 0.5)
# @UndefinedVariable
#Points
p_N1 = pm.Lambda('p_Norm1', lambda k=B1, c1=Nc1, c2=Nc2: [c2, c1][int(k)])
p_N2 = pm.Lambda('p_Norm2', lambda k=B2, c1=Nc1, c2=Nc2: [c1, c2][int(k)])
p_N3 = pm.Lambda('p_Norm3', lambda k=B3, c1=Nc1, c2=Nc2: [c1, c2][int(k)])
normalObs1 = pm.Normal('NormX1', mu=p_N1, tau=1, observed=True, value=-3)
# @UndefinedVariable
normalObs2 = pm.Normal('NormX2', mu=p_N2, tau=1, observed=True, value=3)
# @UndefinedVariable
normalObsZ = pm.Normal('NormZ', mu=p_N3, tau=1)
# @UndefinedVariable
return [
Nc1, Nc2, B1, B2, B3, Uh1, Uh2, normalObs1, normalObs2, normalObsZ
]
def construct(self):
first = pymc.Bernoulli('F', .6, value=pl.ones(self.obs))
p_first = pymc.Lambda('p_F',
lambda R=R: pl.where(R, .005, .8),
doc='Pr[S|R]')
second = pymc.Bernoulli('S', p_first, value=pl.ones(self.obs))
p_G = mc.Lambda('p_G',
lambda S=S, R=R: pl.where(S, pl.where(R, .99, .9),
pl.where(R, .8, 0.)),
doc='Pr[G|S,R]')
G = mc.Bernoulli('G', p_G, value=G_obs, observed=True)
def coef_estimate(matrix, params, iters):
# using specified set of priors, create coefficients
coefs, term_list = create_coefs(
params=params,
priors={coef: pymc.Normal(coef, 0, 0.001)
for coef in params})
@pymc.deterministic
def probs(term_list=term_list):
probs = 1 / (1 + np.exp(-1 * sum(term_list))) # The logistic function
probs[np.diag_indices_from(probs)] = 0
# Manually cut off the top triangle:
probs[np.triu_indices_from(probs)] = 0
return probs
# Fitting
matrix[np.triu_indices_from(matrix)] = 0
max_attempts = 10
attempts = 0
while attempts < max_attempts:
try:
outcome = pymc.Bernoulli("outcome",
probs,
value=matrix,
observed=True)
break
except:
print("Encountered zero probability error number", attempts,
", trying again...")
if attempts >= max_attempts:
raise
attempts += 1
sim_outcome = pymc.Bernoulli("sim_outcome", probs)
args = [outcome, sim_outcome, probs]
# density_coef, density_term,
# block_coef, block_term]
for coef, info in coefs.items():
# Add both coefficient and term for each coefficient
for item in info:
args.append(item)
model = pymc.Model(args)
mcmc = pymc.MCMC(model)
mcmc.sample(iters, 1000, 50) # approx. 30 seconds
traces = diagnostics(coefs=coefs, mcmc=mcmc)
goodness_of_fit(mcmc=mcmc)
return {coef: np.mean(trace) for coef, trace in traces.items()}
def getModel():
nA, nB, nK, nT = 5, 2, 10, 10
# @UnusedVariable
nW = np.linspace(1, 9, nT)
# B = pm.Beta('Beta', alpha=[nA/nK]*nT, beta=[nB*(nK-1)/nK]*nT); #@UndefinedVariable
B = pm.Beta('Beta', alpha=nW, beta=[nB * (nK - 1) / nK] * nT)
#@UndefinedVariable
BernO = pm.Bernoulli('Bern_O1',
B,
observed=True,
value=[0, 1, 1, 1, 1, 0, 1, 1, 1, 1])
#@UndefinedVariable @UnusedVariable
# BernO2 = pm.Bernoulli('Bern_O2', B, observed=True, value=[1]*nT); #@UndefinedVariable @UnusedVariable
Bern = pm.Bernoulli('Bern', B)
#@UndefinedVariable
return pm.Model([B, Bern])
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, return_inferencedata=False, 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 run_Bernoulli_Normal():
B = pm.Bernoulli('Bern', 0.8)
# @UndefinedVariable
p_N1 = pm.Lambda('p_Norm', lambda k=B: [-5, 5][int(k)])
N = pm.Normal('Norm', mu=p_N1, tau=1)
# @UndefinedVariable
return [B, N]
def mcmcSimulations(temperature, failures):
'''Perform the MCMC-simulations'''
# Define the prior distributions for alpha and beta
# 'value' sets the start parameter for the simulation
# The second parameter for the normal distributions is the "precision",
# i.e. the inverse of the standard deviation
np.random.seed(1234)
beta = pm.Normal("beta", 0, 0.001, value=0)
alpha = pm.Normal("alpha", 0, 0.001, value=0)
# Define the model-function for the temperature
@pm.deterministic
def p(t=temperature, alpha=alpha, beta=beta):
return 1.0 / (1. + np.exp(beta * t + alpha))
# connect the probabilities in `p` with our observations through a
# Bernoulli random variable.
observed = pm.Bernoulli("bernoulli_obs", p, value=failures, observed=True)
# Combine the values to a model
model = pm.Model([observed, beta, alpha])
# Perform the simulations
map_ = pm.MAP(model)
map_.fit()
mcmc = pm.MCMC(model)
mcmc.sample(120000, 100000, 2)
# --- Show the resulting posterior distributions ---
alpha_samples = mcmc.trace('alpha')[:, None] # best to make them 1d
beta_samples = mcmc.trace('beta')[:, None]
return (alpha_samples, beta_samples)
def main():
# The parameters are the bounds of the Uniform.
p = pm.Uniform('p', lower=0, upper=1)
# set constants
p_true = 0.05 # remember, this is unknown.
N = 1500
# sample N Bernoulli random variables from Ber(0.05).
# each random variable has a 0.05 chance of being a 1.
# this is the data-generation step
occurrences = pm.rbernoulli(p_true, N)
print occurrences
print occurrences.sum()
# Occurrences.mean is equal to n/N.
print "What is the observed frequency in Group A? %.4f" % occurrences.mean(
)
print "Does this equal the true frequency? %s" % (occurrences.mean()
== p_true)
# include the observations, which are Bernoulli
obs = pm.Bernoulli("obs", p, value=occurrences, observed=True)
# To be explained in chapter 3
mcmc = pm.MCMC([p, obs])
mcmc.sample(18000, 1000)
plt.title(
"Posterior distribution of $p_A$, the true effectiveness of site A")
plt.vlines(p_true, 0, 90, linestyle="--", label="true $p_A$ (unknown)")
plt.hist(mcmc.trace("p")[:], bins=25, histtype="stepfilled", normed=True)
plt.legend()
plt.show()
def create_pymc_model(x_mat, y_vec, prior_sigma=5.0):
tau_mc = 1. / (prior_sigma**2)
(n, d) = np.shape(x_mat)
w_mc = list([])
x_mc = list([])
for i in np.arange(0, d):
w_mc[len(w_mc):] = [pymc.Normal('w' + str(i + 1) + '_mc', 0.0, tau_mc)]
x_mc[len(x_mc):] = [
pymc.Normal('x' + str(i + 1) + '_mc',
0.0,
1.0,
value=x_mat[:, i],
observed=True)
]
w_mc = np.array(w_mc, dtype=object)
x_mc = np.array(x_mc, dtype=object)
@pymc.deterministic
def pred_mu(w_mc=w_mc, x_mc=x_mc):
return sigmoid(np.dot(x_mc, np.transpose(w_mc)))
y_mc = pymc.Bernoulli('y_mc',
p=pred_mu,
value=np.array(
map(lambda val: 0 if val == -1 else +1, y_vec)),
observed=True)
return pymc.Model(
[pred_mu, pymc.Container(w_mc),
pymc.Container(x_mc), y_mc])
def Main():
# Plot Raw Data
plot_raw(challenger_data)
# Calculate observed values
observed = pm.Bernoulli("bernoulli_obs", p, value=D, observed=True)
# Create and sample from model
model = pm.Model([observed, beta, alpha])
# Once again, this code will be explored next chapter
map_ = pm.MAP(model)
map_.fit()
mcmc = pm.MCMC(model)
mcmc.sample(120000, 100000, 2)
alpha_samples = mcmc.trace('alpha')[:, None] # best to make them 1d
beta_samples = mcmc.trace('beta')[:, None]
# Do some plotting
plot_posterior(alpha_samples, beta_samples)
t = np.linspace(temperature.min() - 5, temperature.max() + 5, 50)[:, None]
p_t = logistic(t.T, beta_samples, alpha_samples)
mean_prob_t = p_t.mean(axis=0)
# vectorized bottom and top 2.5% quantiles for credible interval
qs = mquantiles(p_t, [0.025, 0.975], axis=0)
plot_against_data(t, mean_prob_t, qs)
plot_t_31(alpha_samples, beta_samples)
def pymc_linear_fit_perpointoutlier(data1, data2, data1err=None, data2err=None):
"""
Model 3 from http://astroml.github.com/book_figures/chapter8/fig_outlier_rejection.html
*IGNORES X ERRORS*
"""
if data1err is not None:
raise NotImplementedError("Currently this form of outlier rejection ignores X errors")
# Third model: marginalizes over the probability that each point is an outlier.
# define priors on beta = (slope, intercept)
@pymc.stochastic
def beta_M2(value=np.array([2., 100.])):
"""Slope and intercept parameters for a straight line.
The likelihood corresponds to the prior probability of the parameters."""
slope, intercept = value
prob_intercept = 1 + 0 * intercept
# uniform prior on theta = arctan(slope)
# d[arctan(x)]/dx = 1 / (1 + x^2)
prob_slope = np.log(1. / (1. + slope ** 2))
return prob_intercept + prob_slope
@pymc.deterministic
def model_M2(xi=data1, beta=beta_M2):
slope, intercept = beta
return slope * xi + intercept
# qui is bernoulli distributed
qi = pymc.Bernoulli('qi', p=1 - Pb, value=np.ones(len(data1)))
def outlier_likelihood(yi, mu, dyi, qi, Yb, sigmab):
"""likelihood for full outlier posterior"""
Vi = dyi ** 2
Vb = sigmab ** 2
#root2pi = np.sqrt(2 * np.pi)
logL_in = -0.5 * np.sum(qi * (np.log(2 * np.pi * Vi)
+ (yi - mu) ** 2 / Vi))
logL_out = -0.5 * np.sum((1 - qi) * (np.log(2 * np.pi * (Vi + Vb))
+ (yi - Yb) ** 2 / (Vi + Vb)))
return logL_out + logL_in
OutlierNormal = pymc.stochastic_from_dist('outliernormal',
logp=outlier_likelihood,
dtype=np.float,
mv=True)
y_outlier = OutlierNormal('y_outlier', mu=model_M2, dyi=data2,
Yb=Yb, sigmab=sigmab, qi=qi,
observed=True, value=yi)
M2 = dict(y_outlier=y_outlier, beta_M2=beta_M2, model_M2=model_M2,
qi=qi, Pb=Pb, Yb=Yb, log_sigmab=log_sigmab, sigmab=sigmab)
def simple_2model():
mu = -2.1
tau = 1.3
p = 0.4
with Model() as model:
x = pm.Normal("x", mu, tau=tau, initval=0.1)
pm.Deterministic("logx", at.log(x))
pm.Bernoulli("y", p)
return model.compute_initial_point(), model
def simple_2model():
mu = -2.1
tau = 1.3
p = .4
with Model() as model:
x = pm.Normal('x', mu, tau, testval=.1)
y = pm.Bernoulli('y', p)
return model.test_point, model
def performInference(graph, responses):
#this is a really hacky solution for now until I can spend more time figuring out how to do this more programatically
pStr = "p%s"
def _build_probabilities(cid):
#return memoized bernoulli variable
if "_bp" in graph[cid]: return graph[cid]["_bp"]
#hack since pymc seems to require ascii (and not unicode)
cida = str(cid).encode('ascii')
if graph[cid]["dependencies"]:
# process dependencies first
deps = map(_build_probabilities, graph[cid]["dependencies"])
cp = calculateProbability(pStr % cida, deps)
_bp = mc.Bernoulli(cida, cp, value=1)
else:
# roots get special treatment
_bp = mc.Bernoulli(cida, .5, value=1)
#memoize bernoulli variable
graph[cid]["_bp"] = _bp
return _bp
concepts = map(_build_probabilities, graph)
#variables = mc.Bernoulli('variables', .5, value=1)
#concepts.append(variables);
#pConditionals = calculateProbability('pConditionals', [variables])
#conditionals = mc.Bernoulli('conditionals', pConditionals, value=1)
#concepts.append(conditionals);
otherQuestions = []
for example in responses:
# more pymc ascii hacks
cida = str(example[0]).encode('ascii')
tmp = graph[example[0]]["_bp"]
prob = mc.Lambda(pStr % cida,
lambda tmp=tmp: pl.where(tmp, 1 - pS, pG))
otherQuestions.append(
mc.Bernoulli(cida, prob, value=example[1], observed=True))
##################some simple tests##########
model = mc.Model(concepts + otherQuestions)
samples = mc.MCMC(model)
knownNodes = []
samples.sample(1000)
for concept in concepts:
if concept.trace().mean() > 0.75:
knownNodes.append(concept.__name__)
return knownNodes
def trace(matrix,params,iters,burn,mu=0):
# using specified set of priors, create coefficients
coefs, term_list = create_coefs(params=params, priors={coef: pymc.Normal(coef, mu, 0.01) for coef in params})
@pymc.deterministic
def probs(term_list=term_list):
probs = 1 / (1 + np.exp(-1 * sum(term_list)))
probs = np.array([[prob if prob > 0 else 0 for prob in row] for row in probs])
probs[np.diag_indices_from(probs)] = 0
# Manually cut off the top triangle:
probs[np.triu_indices_from(probs)] = 0
return probs
# Fitting
matrix[np.triu_indices_from(matrix)] = 0
max_attempts = 50
attempts = 0
while attempts < max_attempts:
try:
outcome = pymc.Bernoulli("outcome", probs, value=matrix, observed=True)
break
except:
print("Encountered zero probability error number",attempts,", trying again...")
if attempts >= max_attempts:
raise ValueError("Something went wrong with the stochastic probabilities")
attempts += 1
sim_outcome = pymc.Bernoulli("sim_outcome", probs)
args = [outcome, sim_outcome, probs]
# density_coef, density_term,
# block_coef, block_term]
for coef, info in coefs.items():
# Add both coefficient and term for each coefficient
for item in info:
args.append(item)
model = pymc.Model(args)
mcmc = pymc.MCMC(model)
mcmc.sample(iter=iters, burn=burn, thin=50) # approx. 30 seconds
traces = diagnostics(coefs=coefs, mcmc=mcmc)
goodness_of_fit(mcmc=mcmc)
return traces
def cartesian_bernoulli_child(name,
parents,
value=None,
N=None,
return_coeffs=False,
fixed={}):
if value is None and N is None:
raise ValueError('either "value" or "N" must be specified')
if value is not None:
value = mask_missing(value)
ranges = [range(get_levels_count(p)) for p in parents]
parents2index = {}
coeffs = []
for i, parent_vals in enumerate(product(*ranges)):
parents2index[parent_vals] = i
parents_repr = ' '.join('%s=%s' % (parent, v)
for parent, v in zip(parents, parent_vals))
coeff_name = COEFFS_PREFIX + 'p(%s | %s)' % (name, parents_repr)
coeff = fixed.get(coeff_name, pymc.Uniform(coeff_name, 0, 1))
coeffs.append(coeff)
intify = lambda x: tuple(map(int, x))
@pymc.deterministic
def child_prob(parents=parents, coeffs=coeffs):
return np.array([
coeffs[parents2index[intify(parent_vals)]]
for parent_vals in zip(*parents)
])
child_prob.__name__ = 'p(%s)' % name
if value is None:
child = pymc.Bernoulli(name, p=child_prob, value=np.zeros(N))
else:
child = pymc.Bernoulli(name, p=child_prob, value=value, observed=True)
set_levels_count(child, 2)
if return_coeffs:
return child, coeffs + [child_prob]
else:
return child
def getModel():
nA, nB, nK, nT = 5, 2, 10, 10
# @UnusedVariable
nW = np.linspace(1, 9, nT)
# B = pm.Beta('Beta', alpha=[nA/nK]*nT, beta=[nB*(nK-1)/nK]*nT); #@UndefinedVariable
B = pm.Beta('Beta', alpha=nW, beta=[nB * (nK - 1) / nK] * nT)
#@UndefinedVariable
Bern = pm.Bernoulli('Bern', B)
#@UndefinedVariable
return pm.Model([B, Bern])
def _build_probabilities(cid):
#return memoized bernoulli variable
if "_bp" in graph[cid]: return graph[cid]["_bp"]
#hack since pymc seems to require ascii (and not unicode)
cida = str(cid).encode('ascii')
if graph[cid]["dependencies"]:
# process dependencies first
deps = map(_build_probabilities, graph[cid]["dependencies"])
cp = calculateProbability(pStr % cida, deps)
_bp = mc.Bernoulli(cida, cp, value=1)
else:
# roots get special treatment
_bp = mc.Bernoulli(cida, .5, value=1)
#memoize bernoulli variable
graph[cid]["_bp"] = _bp
return _bp
def main():
N = 100
p = pm.Uniform("freq_cheating", 0, 1)
true_answers = pm.Bernoulli("truths", p, size=N)
first_coin_flips = pm.Bernoulli("first_flips", 0.5, size=N)
second_coin_flips = pm.Bernoulli("second_flips", 0.5, size=N)
@pm.deterministic
def observed_proportion(t_a=true_answers,
fc=first_coin_flips,
sc=second_coin_flips):
result = t_a & fc | ~fc & sc
return float(sum(result)) / len(result)
X = 35
observations = pm.Binomial("obs",
N,
observed_proportion,
value=X,
observed=True)
model = pm.Model([
p, true_answers, first_coin_flips, second_coin_flips,
observed_proportion, observations
])
# To be explained in Chapter 3!
mcmc = pm.MCMC(model)
mcmc.sample(40000, 15000)
figsize(12.5, 3)
p_trace = mcmc.trace("freq_cheating")[:]
plt.hist(p_trace,
histtype="stepfilled",
normed=True,
alpha=0.85,
bins=30,
label="posterior distribution",
color="#348ABD")
plt.vlines([.05, .35], [0, 0], [5, 5], alpha=0.3)
plt.xlim(0, 1)
plt.legend()
plt.show()
def simple_2model():
mu = -2.1
tau = 1.3
p = .4
with Model() as model:
x = pm.Normal('x', mu, tau, testval=.1)
logx = pm.Deterministic('logx', log(x))
y = pm.Bernoulli('y', p)
return model.test_point, model
def get_Models():
#Full Model (Beta & Bernoulli)
nA, nB = 2, 1
aD = [0, 1, 1]
Beta = pm.Beta('Beta', alpha=nA, beta=nB)
# @UndefinedVariable
BernD = [
pm.Bernoulli('BernD_' + str(i), p=Beta, observed=True, value=aD[i])
for i in range(len(aD))
]
# @UndefinedVariable @UnusedVariable
BernQ = pm.Bernoulli('BernQ', p=Beta)
# @UndefinedVariable
#Collapsed Model (Bernoulli)
nA2 = nA + sum(aD)
nB2 = nB + len(aD) - sum(aD)
nP = nA2 / (nA2 + nB2)
BernQ2 = pm.Bernoulli('BernQ_2', p=nP)
# @UndefinedVariable
return np.concatenate([[Beta, BernQ, BernQ2], BernD])
class BinaryTestModel:
series = np.array([0,0,1,1,0,0,0,1,1,1])
fair = pymc.Bernoulli('fair', p=.5, value=1)
@pymc.deterministic
def coin(fair=fair):
if fair:
return .5
else:
return .1
# @stoch
# def coin(value=.5, fair=fair):
# """Return the probability of a tail on flipping a coin."""
# if fair is True:
# return pymc.beta_like(value, 1e6, 1e6)
# else:
# return pymc.uniform_like(value, .3, .7)
tail = pymc.Bernoulli('tail', p=coin, value=series, observed=True)
def outcomes(match_vars):
outcome_vars = []
for i in range(0,len(match_vars)):
outcome_vars.append(pm.Bernoulli('outcome_%i' % i,
match_vars[i],
value=[True],
observed=True,
plot=False))
return outcome_vars
def __init__(self, G=nx.balanced_tree(2, 3, create_using=nx.DiGraph())):
self.G = G
self.n = len(G)
roots = [n for n, d in G.in_degree().items() if d == 0]
# root random variables
self.roots = [pm.Bernoulli(str(v), 0.5, value=0) for v in roots]
self.node_top_sort = nx.topological_sort(G)
node_variables = dict(zip(roots, self.roots))
self.others = []
for node in self.node_top_sort:
if node not in roots:
Pa_v = [
node_variables[key] for key in node_variables.keys()
if key in G.predecessors(node)
]
weight = [
G[key][node]['weight'] for key in G.predecessors(node)
]
bias = G.node[node]['bias']
# energy = w*Pa(v) + bias
energy = pm.Lambda(
'energy_%d' % (node),
lambda Pa_v=Pa_v, weight=weight, bias=bias: pm.
LinearCombination('weighted_sum', x=Pa_v, y=weight) + bias)
# Pr(v=1) = sigmoid(energy)
# use pymc.Lambda deterministic function
sigmoid_cond_prob = pm.Lambda('sigmoid_%d_cond' % (node),
lambda energy=energy: 1 /
(1 + exp(-energy)))
node_variables[node] = pm.Bernoulli(str(node),
sigmoid_cond_prob,
value=0)
self.others.append(node_variables[node])
self.node_variables = node_variables
pm.MCMC.__init__(self, [self.roots, self.others])
def dice(data=None):
if data is None:
x = [pymc.rbernoulli(1.0 / 6.0) for i in range(0, 100)]
else:
x = data
prob = pymc.Uniform('prob', lower=0, upper=1)
d = pymc.Bernoulli('d', p=prob, value=x, observed=True)
return locals()
def logistic_bernoulli_child(name,
parents,
value=None,
N=None,
return_coeffs=False,
fixed={}):
if value is not None:
value = mask_missing(value)
N = N or len(value)
theta, all_coeffs = _linearised_many(parents, name, True, fixed)
child_prob = pymc.InvLogit('p(%s)' % name, theta)
if value is None:
child = pymc.Bernoulli(name, p=child_prob, value=np.zeros(N))
else:
child = pymc.Bernoulli(name, p=child_prob, value=value, observed=True)
set_levels_count(child, 2)
if return_coeffs:
return child, all_coeffs
else:
return child
def BIPBayes(pa, bip, mu, tau):
bippg = np.zeros(pa)
bippg[:bip] = 1
pbip = pm.Normal("pbip", mu, tau)
obsbip = pm.Bernoulli("obsbip", pbip, value=bippg, observed=True)
mcmc = pm.MCMC([pbip, obsbip])
mcmc.sample(20000, 7000)
sumstats = mcmc.stats()
loint = sumstats['pbip']['95% HPD interval'][0]
hiint = sumstats['pbip']['95% HPD interval'][1]
bip_trace = mcmc.trace('pbip')[:]
bip_trace = [x for x in bip_trace if (x > loint) and (x < hiint)]
return bip_trace
def HRBayes(pa, hr, alpha, beta):
hrpg = np.zeros(pa)
hrpg[:hr] = 1
phr = pm.Beta("phr", alpha, beta)
obshr = pm.Bernoulli("obshr", phr, value=hrpg, observed=True)
mcmc = pm.MCMC([phr, obshr])
mcmc.sample(20000, 7000)
sumstats = mcmc.stats()
loint = sumstats['phr']['95% HPD interval'][0]
hiint = sumstats['phr']['95% HPD interval'][1]
hr_trace = mcmc.trace('phr')[:]
hr_trace = [x for x in hr_trace if (x > loint) and (x < hiint)]
return hr_trace
