def test_sample_after_set_data(self):
with pm.Model() as model:
x = pm.MutableData("x", [1.0, 2.0, 3.0])
y = pm.MutableData("y", [1.0, 2.0, 3.0])
beta = pm.Normal("beta", 0, 10.0)
pm.Normal("obs", beta * x, np.sqrt(1e-2), observed=y)
pm.sample(
1000,
tune=1000,
chains=1,
compute_convergence_checks=False,
)
# Predict on new data.
new_x = [5.0, 6.0, 9.0]
new_y = [5.0, 6.0, 9.0]
with model:
pm.set_data(new_data={"x": new_x, "y": new_y})
new_idata = pm.sample(
1000,
tune=1000,
chains=1,
compute_convergence_checks=False,
)
pp_trace = pm.sample_posterior_predictive(new_idata)
assert pp_trace.posterior_predictive["obs"].shape == (1, 1000, 3)
np.testing.assert_allclose(new_y,
pp_trace.posterior_predictive["obs"].mean(
("chain", "draw")),
atol=1e-1)
def time_glm_hierarchical(self):
with glm_hierarchical_model():
pm.sample(draws=20000,
cores=4,
chains=4,
progressbar=False,
compute_convergence_checks=False)
def test_reset_tuning(self):
with self.model:
tune = 50
chains = 2
start, step = pm.sampling.init_nuts(chains=chains, seeds=[1, 2])
pm.sample(draws=2, tune=tune, chains=chains, step=step, start=start, cores=1)
assert step.potential._n_samples == tune
assert step.step_adapt._count == tune + 1
def test_sample_does_not_set_seed(self):
random_numbers = []
for _ in range(2):
np.random.seed(1)
with self.model:
pm.sample(1, tune=0, chains=1)
random_numbers.append(np.random.random())
assert random_numbers[0] == random_numbers[1]
def test_metropolis_sampling(self):
"""Check if the Metropolis sampler can handle broadcasting."""
with pm.Model() as test_model:
test1 = pm.Normal("test1", mu=0.0, sigma=1.0, size=(1, 10))
test2 = pm.Normal("test2", mu=test1, sigma=1.0, size=(10, 10))
step = pm.Metropolis()
# TODO FIXME: Assert whatever it is we're testing
pm.sample(tune=5, draws=7, cores=1, step=step, compute_convergence_checks=False)
def test_spawn_densitydist_function():
with pm.Model() as model:
mu = pm.Normal("mu", 0, 1)
def func(x):
return -2 * (x ** 2).sum()
obs = pm.DensityDist("density_dist", logp=func, observed=np.random.randn(100))
pm.sample(draws=10, tune=10, step=pm.Metropolis(), cores=2, mp_ctx="spawn")
def time_overhead_sample(self, step):
with self.model:
pm.sample(
self.n_steps,
step=step(),
random_seed=1,
progressbar=False,
compute_convergence_checks=False,
)
def test_empirical_from_trace(another_simple_model):
with another_simple_model:
step = pm.Metropolis()
trace = pm.sample(100, step=step, chains=1, tune=0, return_inferencedata=False)
emp = Empirical(trace)
assert emp.histogram.shape[0].eval() == 100
trace = pm.sample(100, step=step, chains=4, tune=0, return_inferencedata=False)
emp = Empirical(trace)
assert emp.histogram.shape[0].eval() == 400
def test_sample_tune_len(self):
with self.model:
trace = pm.sample(draws=100, tune=50, cores=1, return_inferencedata=False)
assert len(trace) == 100
trace = pm.sample(
draws=100, tune=50, cores=1, return_inferencedata=False, discard_tuned_samples=False
)
assert len(trace) == 150
trace = pm.sample(draws=100, tune=50, cores=4, return_inferencedata=False)
assert len(trace) == 100
def test_remote_pipe_closed():
master_pid = os.getpid()
with pm.Model():
x = pm.Normal("x", shape=2, mu=0.1)
at_pid = at.as_tensor_variable(np.array(master_pid, dtype="int32"))
pm.Normal("y", mu=_crash_remote_process(x, at_pid), shape=2)
step = pm.Metropolis()
with pytest.raises(RuntimeError, match="Chain [0-9] failed"):
pm.sample(step=step, mp_ctx="spawn", tune=2, draws=2, cores=2, chains=2)
def test_spawn_densitydist_bound_method():
N = 100
with pm.Model() as model:
mu = pm.Normal("mu", 0, 1)
normal_dist = pm.Normal.dist(mu, 1, size=N)
def logp(x):
out = pm.logp(normal_dist, x)
return out
obs = pm.DensityDist("density_dist", logp=logp, observed=np.random.randn(N), size=N)
pm.sample(draws=10, tune=10, step=pm.Metropolis(), cores=2, mp_ctx="spawn")
def test_sample(self):
test_cores = [1]
with self.model:
for cores in test_cores:
for steps in [1, 10, 300]:
pm.sample(
steps,
tune=0,
step=self.step,
cores=cores,
random_seed=self.random_seed,
)
def run_DREAM(self,nsamples=100000):
model = pymc.Model()
with model:
params = pymc.Normal('params', mu=self.start_parameters,
sd=np.array([1.0
]*len(self.start_parameters)),
shape=(len(self.start_parameters)))
#params = pymc.Flat('params',shape=(len(self.start_parameters)))
global cost_function
cost_function = self.cost_function
error = pymc.Potential('error', DREAM_cost(params))
nseedchains = 10*len(self.model.parameters_rules())
step = pymc.Dream(variables=[params],
nseedchains=nseedchains,
blocked=True,
start_random=False,
save_history=True,
parallel=True,
adapt_crossover=False,
verbose=False,)
trace = pymc.sample(nsamples, step,
start=self.pso_results,
njobs=self.nchains,
use_mpi=False,
progressbar=False,)
cont_flag = True
while cont_flag:
cont_flag = False
conv_stats = gelman_rubin(trace)
for i in conv_stats['params']:
if i>1.2:
print "Parameters have not converged, will continue run."
print "Value so far is %s"%i
cont_flag = True
break
trace = pymc.sample(int(nsamples*.1), step,
#start=self.pso_results,
njobs=self.nchains,
use_mpi=False,
trace = trace,
progressbar=False,)
conv_stats = gelman_rubin(trace)
for i in conv_stats['params']:
print i,i<1.2
#pymc.traceplot(trace,vars=[params,error])
#plt.show()
return trace
def test_set_data_to_non_data_container_variables(self):
with pm.Model() as model:
x = np.array([1.0, 2.0, 3.0])
y = np.array([1.0, 2.0, 3.0])
beta = pm.Normal("beta", 0, 10.0)
pm.Normal("obs", beta * x, np.sqrt(1e-2), observed=y)
pm.sample(
1000,
tune=1000,
chains=1,
compute_convergence_checks=False,
)
with pytest.raises(TypeError) as error:
pm.set_data({"beta": [1.1, 2.2, 3.3]}, model=model)
error.match("The variable `beta` must be a `SharedVariable`")
def test_sample_posterior_predictive_w(self):
data0 = np.random.normal(0, 1, size=50)
warning_msg = "The number of samples is too small to check convergence reliably"
with pm.Model() as model_0:
mu = pm.Normal("mu", mu=0, sigma=1)
y = pm.Normal("y", mu=mu, sigma=1, observed=data0)
with pytest.warns(UserWarning, match=warning_msg):
trace_0 = pm.sample(10, tune=0, chains=2, return_inferencedata=False)
idata_0 = pm.to_inference_data(trace_0, log_likelihood=False)
with pm.Model() as model_1:
mu = pm.Normal("mu", mu=0, sigma=1, size=len(data0))
y = pm.Normal("y", mu=mu, sigma=1, observed=data0)
with pytest.warns(UserWarning, match=warning_msg):
trace_1 = pm.sample(10, tune=0, chains=2, return_inferencedata=False)
idata_1 = pm.to_inference_data(trace_1, log_likelihood=False)
with pm.Model() as model_2:
# Model with no observed RVs.
mu = pm.Normal("mu", mu=0, sigma=1)
with pytest.warns(UserWarning, match=warning_msg):
trace_2 = pm.sample(10, tune=0, return_inferencedata=False)
traces = [trace_0, trace_1]
idatas = [idata_0, idata_1]
models = [model_0, model_1]
ppc = pm.sample_posterior_predictive_w(traces, 100, models)
assert ppc["y"].shape == (100, 50)
ppc = pm.sample_posterior_predictive_w(idatas, 100, models)
assert ppc["y"].shape == (100, 50)
with model_0:
ppc = pm.sample_posterior_predictive_w([idata_0.posterior], None)
assert ppc["y"].shape == (20, 50)
with pytest.raises(ValueError, match="The number of traces and weights should be the same"):
pm.sample_posterior_predictive_w([idata_0.posterior], 100, models, weights=[0.5, 0.5])
with pytest.raises(ValueError, match="The number of models and weights should be the same"):
pm.sample_posterior_predictive_w([idata_0.posterior], 100, models)
with pytest.raises(
ValueError, match="The number of observed RVs should be the same for all models"
):
pm.sample_posterior_predictive_w([trace_0, trace_2], 100, [model_0, model_2])
def test_multiple_observed_rv(self, log_likelihood):
y1_data = np.random.randn(10)
y2_data = np.random.randn(100)
with pm.Model():
x = pm.Normal("x", 1, 1)
pm.Normal("y1", x, 1, observed=y1_data)
pm.Normal("y2", x, 1, observed=y2_data)
inference_data = pm.sample(
100,
chains=2,
return_inferencedata=True,
idata_kwargs={"log_likelihood": log_likelihood},
)
test_dict = {
"posterior": ["x"],
"observed_data": ["y1", "y2"],
"log_likelihood": ["y1", "y2"],
"sample_stats": ["diverging", "lp", "~log_likelihood"],
}
if not log_likelihood:
test_dict.pop("log_likelihood")
test_dict["~log_likelihood"] = []
if isinstance(log_likelihood, list):
test_dict["log_likelihood"] = ["y1", "~y2"]
fails = check_multiple_attrs(test_dict, inference_data)
assert not fails
def test_save_warmup(self, save_warmup, chains, tune, draws):
with pm.Model():
pm.Uniform("u1")
pm.Normal("n1")
idata = pm.sample(
tune=tune,
draws=draws,
chains=chains,
cores=1,
step=pm.Metropolis(),
discard_tuned_samples=False,
return_inferencedata=True,
idata_kwargs={"save_warmup": save_warmup},
)
warmup_prefix = "" if save_warmup and (tune > 0) else "~"
post_prefix = "" if draws > 0 else "~"
test_dict = {
f"{post_prefix}posterior": ["u1", "n1"],
f"{post_prefix}sample_stats": ["~tune", "accept"],
f"{warmup_prefix}warmup_posterior": ["u1", "n1"],
f"{warmup_prefix}warmup_sample_stats": ["~tune"],
"~warmup_log_likelihood": [],
"~log_likelihood": [],
}
fails = check_multiple_attrs(test_dict, idata)
assert not fails
if hasattr(idata, "posterior"):
assert idata.posterior.dims["chain"] == chains
assert idata.posterior.dims["draw"] == draws
if hasattr(idata, "warmup_posterior"):
assert idata.warmup_posterior.dims["chain"] == chains
assert idata.warmup_posterior.dims["draw"] == tune
def test_mv_missing_data_model(self):
data = ma.masked_values([[1, 2], [2, 2], [-1, 4], [2, -1], [-1, -1]],
value=-1)
model = pm.Model()
with model:
mu = pm.Normal("mu", 0, 1, size=2)
sd_dist = pm.HalfNormal.dist(1.0)
chol, *_ = pm.LKJCholeskyCov("chol_cov",
n=2,
eta=1,
sd_dist=sd_dist,
compute_corr=True)
y = pm.MvNormal("y", mu=mu, chol=chol, observed=data)
inference_data = pm.sample(100,
chains=2,
return_inferencedata=True)
# make sure that data is really missing
assert isinstance(y.owner.op,
(AdvancedIncSubtensor, AdvancedIncSubtensor1))
test_dict = {
"posterior": ["mu", "chol_cov"],
"observed_data": ["y"],
"log_likelihood": ["y"],
}
fails = check_multiple_attrs(test_dict, inference_data)
assert not fails
def get_traces_hierarchical(x, y, idxs, max_iter=100000):
""" sample hierarchical model """
idx_size = len(np.unique(idxs))
with pm.Model() as hierarchical_model:
# hyperpriors for group nodes, all uninformative
alpha_mu = pm.Normal('alpha_mu', mu=0., sd=100**2)
alpha_sigma = pm.Uniform('alpha_sigma', lower=0, upper=100)
beta_mu = pm.Normal('beta_mu', mu=0., sd=100**2)
beta_sigma = pm.Uniform('beta_sigma', lower=0, upper=100)
# Intercept for each testtype, distributed around group mean mu_a
# Above mu & sd are fixed value while below we plug in a common
# group distribution for all a & b (which are vectors of length idx_size).
# priors for alpha, beta and model error, uninformative
alpha = pm.Normal('alpha', mu=alpha_mu, sd=alpha_sigma, shape=idx_size)
beta = pm.Normal('beta', mu=beta_mu, sd=beta_sigma, shape=idx_size)
epsilon = pm.Uniform('epsilon', lower=0, upper=100)
# hierarchical linear model
y_est = alpha[idxs] + beta[idxs] * x
likelihood = pm.Normal('likelihood', mu=y_est, sd=epsilon, observed=y)
traces = pm.sample(max_iter, step=pm.Metropolis()
,start=pm.find_MAP(), progressbar=True)
return traces
def test_no_trace(self):
with pm.Model() as model:
x = pm.Data("x", [1.0, 2.0, 3.0])
y = pm.Data("y", [1.0, 2.0, 3.0])
beta = pm.Normal("beta", 0, 1)
obs = pm.Normal("obs", x * beta, 1, observed=y) # pylint: disable=unused-variable
idata = pm.sample(100, tune=100)
prior = pm.sample_prior_predictive(return_inferencedata=False)
posterior_predictive = pm.sample_posterior_predictive(
idata, return_inferencedata=False)
# Only prior
inference_data = to_inference_data(prior=prior, model=model)
test_dict = {"prior": ["beta"], "prior_predictive": ["obs"]}
fails = check_multiple_attrs(test_dict, inference_data)
assert not fails
# Only posterior_predictive
inference_data = to_inference_data(
posterior_predictive=posterior_predictive, model=model)
test_dict = {"posterior_predictive": ["obs"]}
fails = check_multiple_attrs(test_dict, inference_data)
assert not fails
# Prior and posterior_predictive but no trace
inference_data = to_inference_data(
prior=prior,
posterior_predictive=posterior_predictive,
model=model)
test_dict = {
"prior": ["beta"],
"prior_predictive": ["obs"],
"posterior_predictive": ["obs"],
}
fails = check_multiple_attrs(test_dict, inference_data)
assert not fails
def MCMC(model):
import time
with model:
n = 6000
START = time.time()
try:
start = pm.find_MAP()
except AssertionError:
return model, {'error':'AssertionError in pm.find_MAP()'}
init_time = time.time()-START
print 'Time to initialize: %ds' % (init_time)
START = time.time()
trace = pm.sample(n,pm.Metropolis(),start)
duration = time.time()-START
print 'Time to sample (MH): %ds' % (duration)
# START = time.time()
# trace = pm.sample(n,pm.Slice(),start)
# print 'Time to sample (Slice): %ds' % (time.time()-START)
# START = time.time()
# trace = pm.sample(n,pm.HamiltonianMC(),start)
# print 'Time to sample (HMC): %ds' % (time.time()-START)
# error_b, error_x, output = error(trace,model.data.A,model.data.x_true,
# model.data.b_obs,model.data.scaling)
# fig = pm.traceplot(trace)
# plot(error_b,error_x)
# plt.show()
return model, trace, init_time, duration
def test_sample_posterior_predictive_after_set_data_with_coords(self):
y = np.array([1.0, 2.0, 3.0])
with pm.Model() as model:
x = pm.MutableData("x", [1.0, 2.0, 3.0], dims="obs_id")
beta = pm.Normal("beta", 0, 10.0)
pm.Normal("obs",
beta * x,
np.sqrt(1e-2),
observed=y,
dims="obs_id")
idata = pm.sample(
10,
tune=100,
chains=1,
return_inferencedata=True,
compute_convergence_checks=False,
)
# Predict on new data.
with model:
x_test = [5, 6]
pm.set_data(new_data={"x": x_test}, coords={"obs_id": ["a", "b"]})
pm.sample_posterior_predictive(idata,
extend_inferencedata=True,
predictions=True)
assert idata.predictions["obs"].shape == (1, 10, 2)
assert np.all(
idata.predictions["obs_id"].values == np.array(["a", "b"]))
np.testing.assert_allclose(x_test,
idata.predictions["obs"].mean(
("chain", "draw")),
atol=1e-1)
def test_deterministic_of_observed_modified_interface(self):
rng = np.random.RandomState(4982)
meas_in_1 = pm.aesaraf.floatX(2 + 4 * rng.randn(100))
meas_in_2 = pm.aesaraf.floatX(5 + 4 * rng.randn(100))
with pm.Model(rng_seeder=rng) as model:
mu_in_1 = pm.Normal("mu_in_1", 0, 1, initval=0)
sigma_in_1 = pm.HalfNormal("sd_in_1", 1, initval=1)
mu_in_2 = pm.Normal("mu_in_2", 0, 1, initval=0)
sigma_in_2 = pm.HalfNormal("sd__in_2", 1, initval=1)
in_1 = pm.Normal("in_1", mu_in_1, sigma_in_1, observed=meas_in_1)
in_2 = pm.Normal("in_2", mu_in_2, sigma_in_2, observed=meas_in_2)
out_diff = in_1 + in_2
pm.Deterministic("out", out_diff)
trace = pm.sample(
100,
return_inferencedata=False,
compute_convergence_checks=False,
)
varnames = [v for v in trace.varnames if v != "out"]
ppc_trace = [
dict(zip(varnames, row)) for row in zip(*(trace.get_values(v) for v in varnames))
]
ppc = pm.sample_posterior_predictive(
return_inferencedata=False,
model=model,
trace=ppc_trace,
samples=len(ppc_trace),
var_names=[x.name for x in (model.deterministics + model.basic_RVs)],
)
rtol = 1e-5 if aesara.config.floatX == "float64" else 1e-3
npt.assert_allclose(ppc["in_1"] + ppc["in_2"], ppc["out"], rtol=rtol)
def test_shared_data_as_index(self):
"""
Allow pm.Data to be used for index variables, i.e with integers as well as floats.
See https://github.com/pymc-devs/pymc/issues/3813
"""
with pm.Model() as model:
index = pm.MutableData("index", [2, 0, 1, 0, 2])
y = pm.MutableData("y", [1.0, 2.0, 3.0, 2.0, 1.0])
alpha = pm.Normal("alpha", 0, 1.5, size=3)
pm.Normal("obs", alpha[index], np.sqrt(1e-2), observed=y)
prior_trace = pm.sample_prior_predictive(1000)
idata = pm.sample(
1000,
tune=1000,
chains=1,
compute_convergence_checks=False,
)
# Predict on new data
new_index = np.array([0, 1, 2])
new_y = [5.0, 6.0, 9.0]
with model:
pm.set_data(new_data={"index": new_index, "y": new_y})
pp_trace = pm.sample_posterior_predictive(
idata, var_names=["alpha", "obs"])
assert prior_trace.prior["alpha"].shape == (1, 1000, 3)
assert idata.posterior["alpha"].shape == (1, 1000, 3)
assert pp_trace.posterior_predictive["alpha"].shape == (1, 1000, 3)
assert pp_trace.posterior_predictive["obs"].shape == (1, 1000, 3)
def test_partial_trace_sample():
with pm.Model() as model:
a = pm.Normal("a", mu=0, sigma=1)
b = pm.Normal("b", mu=0, sigma=1)
idata = pm.sample(trace=[a])
assert "a" in idata.posterior
assert "b" not in idata.posterior
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 poisson_regression(targets, predictors, iters=2000):
""" Return the posterior of a Bayesian Poisson regression model.
This function takes the targets and predictors and builds a Poisson
regression model. The predictor coefficients are found by sampling
from the posterior using PyMC (NUTS in particular).
The posterior is returned as an MxN array, where M is the number of
samples and N is the number of predictors. The first column is the
coefficient for the first predictor and so on.
Requires PyMC3
"""
with pm.Model() as poisson_model:
# priors for coefficients
coeffs = pm.Uniform('coeffs', -10, 10, shape=(1, predictors.shape[1]))
p = t.exp(pm.sum(coeffs*predictors.values, 1))
obs = pm.Poisson('obs', p, observed=targets)
start = pm.find_MAP()
step = pm.NUTS(scaling=start)
poisson_trace = pm.sample(iters, step, start=start, progressbar=False)
return poisson_trace['coeffs'].squeeze()
def test_sample_deterministic():
with pm.Model() as model:
x = pm.HalfNormal("x", 1)
y = pm.Deterministic("y", x + 100)
idata = pm.sample(chains=1, draws=50, compute_convergence_checks=False)
np.testing.assert_allclose(idata.posterior["y"], idata.posterior["x"] + 100)
def bayesian_random_effects(data, labels, group, n_samples=2000, n_burnin=500):
import pymc as pm
#preparing the data
donors = data[group].unique()
donors_lookup = dict(zip(donors, range(len(donors))))
data['donor_code'] = data[group].replace(donors_lookup).values
n_donors = len(data[group].unique())
donor_idx = data['donor_code'].values
#setting up the model
with pm.Model() as hierarchical_model:
# Hyperpriors for group nodes
group_intercept_mean = pm.Normal('group intercept (mean)', mu=0., sd=100**2)
group_intercept_variance = pm.Uniform('group intercept (variance)', lower=0, upper=100)
group_slope_mean = pm.Normal('group slope (mean)', mu=0., sd=100**2)
group_slope_variance = pm.Uniform('group slope (variance)', lower=0, upper=100)
individual_intercepts = pm.Normal('individual intercepts', mu=group_intercept_mean, sd=group_intercept_variance, shape=n_donors)
individual_slopes = pm.Normal('individual slopes', mu=group_slope_mean, sd=group_slope_variance, shape=n_donors)
# Model error
residuals = pm.Uniform('residuals', lower=0, upper=100)
expression_est = individual_slopes[donor_idx] * data[labels[0]].values + individual_intercepts[donor_idx]
# Data likelihood
expression_like = pm.Normal('expression_like', mu=expression_est, sd=residuals, observed=data[labels[1]])
start = pm.find_MAP()
step = pm.NUTS(scaling=start)
hierarchical_trace = pm.sample(n_samples, step, start=start, progressbar=True)
mean_slope = hierarchical_trace['group slope (mean)'][n_burnin:].mean()
zero_percentile = percentileofscore(hierarchical_trace['group slope (mean)'][n_burnin:], 0)
#print "Mean group level slope was %g (zero was %g percentile of the posterior distribution)"%(mean_slope, zero_percentile)
#pm.summary(hierarchical_trace[n_burnin:], vars=['group slope (mean)'])
#pm.traceplot(hierarchical_trace[n_burnin:])
#selection = donors
#fig, axis = plt.subplots(2, 3, figsize=(12, 6), sharey=True, sharex=True)
#axis = axis.ravel()
#xvals = np.linspace(data[labels[0]].min(), data[labels[0]].max())
#for i, c in enumerate(selection):
# c_data = data.ix[data[group] == c]
# c_data = c_data.reset_index(drop = True)
# z = list(c_data['donor_code'])[0]
# for a_val, b_val in zip(hierarchical_trace['individual intercepts'][n_burnin::10][z], hierarchical_trace['individual slopes'][n_burnin::10][z]):
# axis[i].plot(xvals, a_val + b_val * xvals, 'g', alpha=.1)
# axis[i].plot(xvals, hierarchical_trace['individual intercepts'][n_burnin:][z].mean() + hierarchical_trace['individual slopes'][n_burnin:][z].mean() * xvals,
# 'g', alpha=1, lw=2.)
# axis[i].hexbin(c_data[labels[0]], c_data[labels[1]], mincnt=1, cmap=plt.cm.YlOrRd_r)
# axis[i].set_title(c)
# axis[i].set_xlabel(labels[0])
# axis[i].set_ylabel(labels[1])
#
#plt.show()
return mean_slope, zero_percentile
def bayesian_random_effects(data, labels, group, n_samples=2000, n_burnin=500):
import pymc as pm
#preparing the data
donors = data[group].unique()
donors_lookup = dict(zip(donors, range(len(donors))))
data['donor_code'] = data[group].replace(donors_lookup).values
n_donors = len(data[group].unique())
donor_idx = data['donor_code'].values
#setting up the model
with pm.Model() as hierarchical_model:
# Hyperpriors for group nodes
group_intercept_mean = pm.Normal('group intercept (mean)', mu=0., sd=100**2)
group_intercept_variance = pm.Uniform('group intercept (variance)', lower=0, upper=100)
group_slope_mean = pm.Normal('group slope (mean)', mu=0., sd=100**2)
group_slope_variance = pm.Uniform('group slope (variance)', lower=0, upper=100)
individual_intercepts = pm.Normal('individual intercepts', mu=group_intercept_mean, sd=group_intercept_variance, shape=n_donors)
individual_slopes = pm.Normal('individual slopes', mu=group_slope_mean, sd=group_slope_variance, shape=n_donors)
# Model error
residuals = pm.Uniform('residuals', lower=0, upper=100)
expression_est = individual_slopes[donor_idx] * data[labels[0]].values + individual_intercepts[donor_idx]
# Data likelihood
expression_like = pm.Normal('expression_like', mu=expression_est, sd=residuals, observed=data[labels[1]])
start = pm.find_MAP()
step = pm.NUTS(scaling=start)
hierarchical_trace = pm.sample(n_samples, step, start=start, progressbar=True)
mean_slope = hierarchical_trace['group slope (mean)'][n_burnin:].mean()
zero_percentile = percentileofscore(hierarchical_trace['group slope (mean)'][n_burnin:], 0)
print "Mean group level slope was %g (zero was %g percentile of the posterior distribution)"%(mean_slope, zero_percentile)
pm.summary(hierarchical_trace[n_burnin:], vars=['group slope (mean)'])
pm.traceplot(hierarchical_trace[n_burnin:])
selection = donors
fig, axis = plt.subplots(2, 3, figsize=(12, 6), sharey=True, sharex=True)
axis = axis.ravel()
xvals = np.linspace(data[labels[0]].min(), data[labels[0]].max())
for i, c in enumerate(selection):
c_data = data.ix[data[group] == c]
c_data = c_data.reset_index(drop = True)
z = list(c_data['donor_code'])[0]
for a_val, b_val in zip(hierarchical_trace['individual intercepts'][n_burnin::10][z], hierarchical_trace['individual slopes'][n_burnin::10][z]):
axis[i].plot(xvals, a_val + b_val * xvals, 'g', alpha=.1)
axis[i].plot(xvals, hierarchical_trace['individual intercepts'][n_burnin:][z].mean() + hierarchical_trace['individual slopes'][n_burnin:][z].mean() * xvals,
'g', alpha=1, lw=2.)
axis[i].hexbin(c_data[labels[0]], c_data[labels[1]], mincnt=1, cmap=plt.cm.YlOrRd_r)
axis[i].set_title(c)
axis[i].set_xlabel(labels[0])
axis[i].set_ylabel(labels[1])
plt.show()
return mean_slope, zero_percentile
def test_mixture_list_of_poissons(self):
with Model() as model:
w = Dirichlet("w",
floatX(np.ones_like(self.pois_w)),
shape=self.pois_w.shape)
mu = Gamma("mu", 1.0, 1.0, shape=self.pois_w.size)
Mixture(
"x_obs",
w,
[Poisson.dist(mu[0]), Poisson.dist(mu[1])],
observed=self.pois_x)
step = Metropolis()
trace = sample(5000,
step,
random_seed=self.random_seed,
progressbar=False,
chains=1)
assert_allclose(np.sort(trace["w"].mean(axis=0)),
np.sort(self.pois_w),
rtol=0.1,
atol=0.1)
assert_allclose(np.sort(trace["mu"].mean(axis=0)),
np.sort(self.pois_mu),
rtol=0.1,
atol=0.1)
def test_scalar_ode_2_param(self):
"""Test running model for a scalar ODE with 2 parameters"""
def system(y, t, p):
return p[0] * np.exp(-p[0] * t) - p[1] * y[0]
times = np.array(
[0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5]
)
yobs = np.array(
[0.31, 0.57, 0.51, 0.55, 0.47, 0.42, 0.38, 0.3, 0.26, 0.22, 0.22, 0.14, 0.14, 0.09, 0.1]
)[:, np.newaxis]
ode_model = DifferentialEquation(func=system, t0=0, times=times, n_states=1, n_theta=2)
with pm.Model() as model:
alpha = pm.HalfCauchy("alpha", 1)
beta = pm.HalfCauchy("beta", 1)
y0 = pm.LogNormal("y0", 0, 1)
sigma = pm.HalfCauchy("sigma", 1)
forward = ode_model(theta=[alpha, beta], y0=[y0])
y = pm.LogNormal("y", mu=pm.math.log(forward), sd=sigma, observed=yobs)
idata = pm.sample(100, tune=0, chains=1)
assert idata.posterior["alpha"].shape == (1, 100)
assert idata.posterior["beta"].shape == (1, 100)
assert idata.posterior["y0"].shape == (1, 100)
assert idata.posterior["sigma"].shape == (1, 100)
def test_issue_5043_autoconvert_coord_values(self):
coords = {"city": pd.Series(["Bonn", "Berlin"])}
with pm.Model(coords=coords) as pmodel:
# The model tracks coord values as (immutable) tuples
assert isinstance(pmodel.coords["city"], tuple)
pm.Normal("x", dims="city")
mtrace = pm.sample(
return_inferencedata=False,
compute_convergence_checks=False,
step=pm.Metropolis(),
cores=1,
tune=7,
draws=15,
)
# The converter must convert coord values them to numpy arrays
# because tuples as coordinate values causes problems with xarray.
converter = InferenceDataConverter(trace=mtrace)
assert isinstance(converter.coords["city"], np.ndarray)
converter.to_inference_data()
# We're not automatically converting things other than tuple,
# so advanced use cases remain supported at the InferenceData level.
# They just can't be used in the model construction already.
converter = InferenceDataConverter(
trace=mtrace,
coords={
"city":
pd.MultiIndex.from_tuples([("Bonn", 53111),
("Berlin", 10178)],
names=["name", "zipcode"])
},
)
assert isinstance(converter.coords["city"], pd.MultiIndex)
def test_sample(self):
x = np.random.normal(size=100)
y = x + np.random.normal(scale=1e-2, size=100)
x_pred = np.linspace(-3, 3, 200, dtype="float32")
with pm.Model():
x_shared = pm.MutableData("x_shared", x)
b = pm.Normal("b", 0.0, 10.0)
pm.Normal("obs", b * x_shared, np.sqrt(1e-2), observed=y)
prior_trace0 = pm.sample_prior_predictive(1000)
idata = pm.sample(1000, tune=1000, chains=1)
pp_trace0 = pm.sample_posterior_predictive(idata)
x_shared.set_value(x_pred)
prior_trace1 = pm.sample_prior_predictive(1000)
pp_trace1 = pm.sample_posterior_predictive(idata)
assert prior_trace0.prior["b"].shape == (1, 1000)
assert prior_trace0.prior_predictive["obs"].shape == (1, 1000, 100)
assert prior_trace1.prior_predictive["obs"].shape == (1, 1000, 200)
assert pp_trace0.posterior_predictive["obs"].shape == (1, 1000, 100)
np.testing.assert_allclose(x,
pp_trace0.posterior_predictive["obs"].mean(
("chain", "draw")),
atol=1e-1)
assert pp_trace1.posterior_predictive["obs"].shape == (1, 1000, 200)
np.testing.assert_allclose(x_pred,
pp_trace1.posterior_predictive["obs"].mean(
("chain", "draw")),
atol=1e-1)
def test_summary_0d_variable_model():
mu = -2.1
tau = 1.3
with Model() as model:
x = Normal('x', mu, tau, testval=.1)
step = Metropolis(model.vars, np.diag([1.]), blocked=True)
trace = pm.sample(100, step=step)
pm.summary(trace)
def test_summary_1d_variable_model():
mu = -2.1
tau = 1.3
with Model() as model:
x = Normal('x', mu, tau, shape=2, testval=[.1, .1])
step = Metropolis(model.vars, np.diag([1.]))
trace = pm.sample(100, step=step)
pm.summary(trace)
def foo(self, discrete):
student_ids = []
timestep_ids = []
y = []
ids = collections.defaultdict(itertools.count().next)
for t in range(0, len(self)):
student_ids += [ids[o.id] for o in self[t]]
timestep_ids += [t for o in self[t]]
y += [o.value for o in self[t]]
n_students = len(set(student_ids))
n_timesteps = len(self)
print student_ids, "!", n_students
with pm.Model() as hierarchical_model:
# Hyperpriors for group nodes
mu_student = pm.Normal('mu_student', mu=0., sd=100**2)
sigma_student = pm.Uniform('sigma_student', lower=0, upper=100)
#mu_timestep = pm.Normal('mu_beta', mu=0., sd=100**2)
#sigma_timestep = pm.Uniform('sigma_beta', lower=0, upper=100)
student = pm.Normal('student', mu=mu_student, sd=sigma_student, shape=n_students) #random effect
timestep = pm.Normal('timestep', mu=0, sd=100**2, shape=n_timesteps) #fixed effect
# Model error
eps = pm.Uniform('eps', lower=0, upper=100)
theta = student[student_ids] + timestep[timestep_ids]
# Data likelihood
if discrete:
ll = pm.Bernoulli('theta', p=self.invlogit(theta), observed=y)
else:
ll = pm.Normal('theta', mu=theta, sd=eps, observed=y)
with hierarchical_model:
print "Find MAP..."
start = pm.find_MAP()
#if discrete:
# step = pm.BinaryMetropolis(scaling=start)
# else:
print "NUTS..."
step = pm.NUTS(scaling=start)
print "Samples..."
hierarchical_trace = pm.sample(2000, step, start=start, progressbar=False)
print "done..."
print "Plot..."
pl.figure(figsize=(10,10))
f = pm.traceplot(hierarchical_trace[500:])
f.savefig("a.png")
return hierarchical_trace
def run_sig():
signal_responses = binom.rvs(100, 0.69, size=1)
noise_responses = binom.rvs(100, 0.30, size=1)
m = sig_detect(signal_responses, noise_responses, 1, 100)
with m:
#step = pm.Metropolis(blocked=False)
step = pm.HamiltonianMC()
start = pm.find_MAP()
#start = {'Pr. mean discrim.':0.0, 'Pr. mean bias':0.0,
# 'taud':0.001, 'tauc':0.001}
trace = pm.sample(5000, step, start, tune=500, njobs=2)
return trace[1000:]
def test_plots_multidimensional():
# Test single trace
from .models import multidimensional_model
start, model, _ = multidimensional_model()
with model as model:
h = np.diag(find_hessian(start))
step = Metropolis(model.vars, h)
trace = sample(3000, step, start)
traceplot(trace)
def run_pl():
x = arange(180)
x = concatenate((x,x,x,x))
xx = piecewise_predictor(x, 90, 50, 1, 2)
y = xx + 20*(np.random.randn(len(x)))
y = y-y.mean()
m = piecewise_linear(y,x)
with m:
step = pm.Metropolis()
#step = pm.NUTS()
trace = pm.sample(2000, step, {}, tune=50, njobs=1, progressbar=True)
return trace
def run_fixdur():
import cPickle
dur, fa, obs = cPickle.load(open('durtest.pickle'))
m = piecewise_durations(dur, fa, obs-1)
with m:
start = pm.find_MAP() #cPickle.load(open('fixdur_map.pickle'))
step = pm.Metropolis(vars=[m.named_vars['Mean_offset'],
m.named_vars['Mean_slope1'], m.named_vars['Mean_slope2'],
m.named_vars['Mean_split']], blocked=False)
step2 = pm.Metropolis(vars=[m.named_vars['Slope1'],
m.named_vars['Slope2'], m.named_vars['Offsets'], m.named_vars['Breakpoint']])
trace = pm.sample(5000, [step, step2], start, tune=1000, njobs=1,
progressbar=True)
return trace
def test_multichain_plots():
from pymc.examples import disaster_model as dm
with dm.model as model:
# Run sampler
step1 = Slice([dm.early_mean, dm.late_mean])
step2 = Metropolis([dm.switchpoint])
start = {'early_mean': 2., 'late_mean': 3., 'switchpoint': 50}
ptrace = sample(1000, [step1, step2], start, njobs=2)
forestplot(ptrace, vars=['early_mean', 'late_mean'])
autocorrplot(ptrace, vars=['switchpoint'])
def test_plots():
# Test single trace
from pymc.examples import arbitrary_stochastic as asmod
with asmod.model as model:
start = model.test_point
h = find_hessian(start)
step = Metropolis(model.vars, h)
trace = sample(3000, step, start)
forestplot(trace)
autocorrplot(trace)
def run_banova():
y = 10+hstack((np.random.randn(100),np.random.randn(100)+1,
np.random.randn(100)+2))
y = y-y.mean()
y = y/y.std()
x = concatenate(([1.0]*100,[0.0]*200))
X = vstack((x, np.roll(x,100), np.roll(x,200)))
m = oneway_banova(y.astype(float),X.astype(float))
start = {'offset': 0.0,
'alphas': array([0,1,2.])}
with m:
step = pm.Metropolis()
#step = pm.NUTS()
trace = pm.sample(150000, step, start, tune=1500, njobs=1, progressbar=True)
pm.traceplot(trace[::2])
show()
def sample_model_appc(model, steps, tune=None, njobs=4, observed=['Data']):
if tune is None:
tune = steps / 2
with model:
start = pm.find_MAP()
non_blocked_step = pm.Metropolis(
vars=[v for k, v in model.named_vars.iteritems()
if ('Obs_SD' in k) or ('Mean_' in k) and not (k in set(observed)) and not k.startswith('DNS')],
blocked=False)
blocked = pm.Metropolis(
vars=[v for k, v in model.named_vars.iteritems()
if not (('Obs_SD' in k) or ('Mean_' in k))
and not (k in set(observed)) and not k.startswith('DNS')],
blocked=True)
trace = pm.sample(
steps, [non_blocked_step, blocked], start,
tune=tune, njobs=njobs, progressbar=True)
return trace
def sample_model(model, steps, tune=None, njobs=1, observed=['Data']):
if tune is None:
tune = steps/2
with model:
start = pm.find_MAP() # cPickle.load(open('fixdur_map.pickle'))
non_blocked_step = pm.Metropolis(
vars=[v for k, v in model.named_vars.iteritems()
if ('Obs_SD' in k) or ('Mean_' in k) and not (k in set(observed))],
blocked=False)
blocked = pm.Metropolis(
vars=[v for k, v in model.named_vars.iteritems()
if not (('Obs_SD' in k) or ('Mean_' in k))
and not (k in set(observed))],
blocked=True)
trace = pm.sample(
steps, [non_blocked_step, blocked], start,
tune=tune, njobs=njobs, progressbar=True)
return trace
def run_best():
a = np.random.randn(10)
b = np.random.randn(10)+2
print 'A:', a.mean(), a.std()
print 'B:', b.mean(), b.std()
x_eval = np.linspace(-10,10,100)
m = best('A', a, 'B', b)
start = {'A Mean': b.mean(),
'A Std': a.std(),
'B Mean': a.mean(),
'B Std': b.std(),
'Nu-1': 100}
with m:
step = pm.Metropolis(blocked=False)
trace = pm.sample(10000, step, start, tune=1000, njobs=3, progressbar=False)
pm.traceplot(trace)
show()
return m, trace
def test_sample():
model, start, step, _ = simple_init()
test_samplers = [sample]
tr = sample(5, step, start, model=model)
test_traces = [None, tr]
if test_parallel:
test_samplers.append(psample)
with model:
for trace in test_traces:
for samplr in test_samplers:
for n in [0,1, 10, 300]:
yield samplr, n, step, {}
yield samplr, n, step, {}, trace
yield samplr, n, step, start
def get_traces_individual(x, y, max_iter=10000,quad=False):
""" sample individual model """
with pm.Model() as individual_model:
# priors for alpha, beta and model error, uninformative
alpha = pm.Normal('alpha', mu=0, sd=100**2)
beta = pm.Normal('beta', mu=0, sd=100**2)
epsilon = pm.Uniform('epsilon', lower=0, upper=100)
# configure model
y_est = alpha + beta * x
if quad:
gamma = pm.Normal('gamma', mu=0, sd=100**2)
y_est = alpha + beta * x + gamma * x ** 2
# calc likelihood and do sampling
likelihood = pm.Normal('likelihood', mu=y_est, sd=epsilon, observed=y)
traces = pm.sample(max_iter, step=pm.NUTS(), start=pm.find_MAP(), progressbar=True)
return traces
with pm.Model() as model:
params = pm.Flat('params', shape=(2))
#params =[0,1]
#log_like = likelihood(model.x, model.y)
like = pm.ArbLikelihood('like', likelihood(model.params))
#like = pm.DensityDist('like', logp, observed=(log_F))
#like = pm.Potential('like', likelihood(model.params))
like = pm.Deterministic('like', likelihood(model.params))
step = pm.Dream(blocked=True,start_random=False, save_history=False, parallel=True, history_file='ndim_banana_seed.npy')
start = [{'params':centroids[chain]} for chain in range(nchains)]
trace = pm.sample(10000, step, start=start, njobs=nchains,)
#pm.traceplot(trace,vars=['params','like'])
#plt.show()
#plt.savefig('trace.png')
#plt.clf()
x1 = []
x2 = []
cm = plt.cm.get_cmap('RdYlBu')
for i in range(nchains):
colors = trace['like'][i][:]
cNorm = plt.matplotlib.colors.Normalize(vmin=np.min(colors), vmax=np.max(colors))
plt.scatter(trace['params'][i][:,0], trace['params'][i][:,1],c=colors,cmap=cm,norm=cNorm)
x1.append(trace['params'][i][:,0])
x2.append(trace['params'][i][:,1])
x1 = np.asanyarray(x1)
x2 = np.asanyarray(x2)
term1 = (4- (2.1*(x**2)) + ((x**4)/3))*(x**2)
term2 = x*y
term3 = (-4 + (4*(y**2)))*(y**2)
summed = term1 + term2 + term3
print 'Cost: ',summed,' x: ',x,' y: ',y
return np.array(summed, dtype='float64')
model = pm.Model()
with model:
pm.Uniform('x', lower=-3, upper=3, dtype='float64')
pm.Uniform('y', lower=-2, upper=2, dtype='float64')
cost = likelihood(model.x, model.y)
pm.Normal('globalmin', mu=cost, sd=1e-4, observed=np.array([-1.0316]))
#pm.Normal('localmin1', mu=cost, sd=1e-4, observed=np.array([-.2155]))
step = pm.Dream(snooker=0)
trace = pm.sample(800000, step, njobs=5)
dictionary_to_pickle = {}
for dictionary in trace:
for var in dictionary:
dictionary_to_pickle[var] = trace[var]
pickle.dump(dictionary_to_pickle, open('2015_03_09_camelback_dream.p', 'wb'))
### Now we calculate the expected flux from SED Model
y_hat = FluxFromTheory(lTs,lMs,ldMenvbyMs,lRenv,ThetaCav,lMdbyMs,lRdo,lRdi,Zdisc,Bdisc,lalphad,lroCav,lroAmp,Inc,Av)/distance**2
#Data likelihood
y_like = pm.Normal('y_like',mu= y_hat, sd=ObservedDataSigma, observed=ObservedData)
# y_like = pm.T('y_like',mu= y_hat, nu=T_nu, lam=T_lam, observed=ObservedData) # T distribution for robustness
# Inference...
# start = pm.find_MAP() # Find starting value by optimization
start = {'lTs':0.5,'lMs':0.5,'ldMenvbyMs':0.8,'lRenv':0.5,'ThetaCav':0.5,'lMdbyMs':0.8,'lRdo':0.5,'lRdi':0.5,'Zdisc':0.5,'Bdisc':0.5,'lalphad':0.5,'lroCav':0.5,'lroAmp':0.5,'Inc':1,'Av':2.5,'distance':0.9}
# step = pm.NUTS(state=start) # Instantiate MCMC sampling algorithm
step = pm.Metropolis([lTs,lMs,ldMenvbyMs,lRenv,ThetaCav,lMdbyMs,lRdo,lRdi,Zdisc,Bdisc,lalphad,lroCav,lroAmp,Inc,Av,distance])
# step1 = pm.Slice([x,w,z])
# step2 = pm.Metropolis([z])
trace = pm.sample(1000, step, start=start, progressbar=True) # draw 1000 posterior samples using Sampling
# trace = pm.sample(10000, [step1,step2], start=start, progressbar=True) # draw 1000 posterior samples using Sampling
print('The trace plot')
fig = pm.traceplot(trace, model.vars[:-1]);
fig.show()
raw_input('enter to close..')
# fig = pm.traceplot(trace, lines={'x': 16, 'w': 12, 'z':3.6})
# fig.show()
# print TESTFindFromGrid(start['x'],start['w'],start['z'])
# print ydata
# print TESTFindFromGrid(np.mean(trace['x']),np.mean(trace['w']),np.mean(trace['z']))
coin = coin + [i] * flips
# Specify the model in PyMC
with pm.Model() as model:
# define the hyperparameters
mu = pm.Beta('mu', 2, 2)
kappa = pm.Gamma('kappa', 1, 0.1)
# define the prior
theta = pm.Beta('theta', mu * kappa, (1 - mu) * kappa, shape=len(N))
# define the likelihood
y = pm.Bernoulli('y', p=theta[coin], observed=y)
# Generate a MCMC chain
step = pm.Metropolis()
trace = pm.sample(5000, step, progressbar=False)
# Restricted models like this could be difficult to sample. This is related
# to the censoring comment in the book. One way to detect that something is
# wrong with the sampling is to compare the autocorrelation plot and the
# sampled values under different sampler, or you can try combinations of
# sampler like this
# step1 = pm.Metropolis([theta, mu])
# step2 = pm.Slice([kappa])
# trace = pm.sample(5000, [step1, step2], progressbar=False)
# or this (this combination was used to generate the figures)
# start = pm.find_MAP()
# step1 = pm.Metropolis([theta, mu])
# step2 = pm.NUTS([kappa])
s['p'],
map_est['p'],
model.logp(map_est)))
# By default `basinhopping` uses a gradient minimization technique,
# `fmin_bfgs`, resulting in inaccurate predictions many times. If we force
# `basinhoping` to use a non-gradient technique we get much better results
with model:
for i in range(n+1):
s = {'p': 0.5, 'surv_sim': i}
map_est = mc.find_MAP(start=s, vars=model.vars,
fmin=bh, minimizer_kwargs={"method": "Powell"})
print('surv_sim: %i->%i, p: %f->%f, LogP:%f'%(s['surv_sim'],
map_est['surv_sim'],
s['p'],
map_est['p'],
model.logp(map_est)))
# Confident in our MAP estimate we can sample from the posterior, making sure
# we use the `Metropolis` method for our discrete variables.
with model:
step1 = mc.step_methods.HamiltonianMC(vars=[p])
step2 = mc.step_methods.Metropolis(vars=[surv_sim])
with model:
trace = mc.sample(25000, [step1, step2], start=map_est)
mc.traceplot(trace);
''' Model underlying states '''
state = pm.Bernoulli('state', p=0.5, shape=len(day))
# Parameters
alpha = pm.Normal('alpha', mu=0, tau=1E-3, shape=len(mtag[0]))
beta = pm.Normal('beta', mu=0, tau=1E-3, shape=len(mtag[0]))
## Softmax
def invlogit(x):
return T.tensor.nnet.softmax(x)
theta = np.empty(len(day), object)
p_vec = np.empty(len(day), object)
track_lk = np.empty(len(day), object)
## empty theta
for i, j in enumerate(day):
theta[i] = alpha + T.dot(state[i], beta.T)
p_vec[i] = invlogit(theta[i])
# Data likelihood
track_lk[i] = pm.Dirichlet('track_lk',
a=p_vec[i], shape=len(mtag[0]),
observed=mtag[i])
with per_model:
# start = pm.find_MAP()
step = pm.Metropolis()
nsteps = 1000
trace = pm.sample(nsteps, step)
# THE MODEL
with pm.Model() as model:
# define the priors
beta0 = pm.Normal('beta0', mu=0, tau=1.0E-12)
beta1 = pm.Normal('beta1', mu=0, tau=1.0E-12)
tau = pm.Gamma('tau', 0.001, 0.001)
udf = pm.Uniform('udf', 0, 1)
tdf = 1 - tdf_gain * pm.log(1 - udf) # tdf in [1,Inf).
# define the likelihood
mu = beta0 + beta1 * zx
yl = pm.T('yl', mu=mu, lam=tau, nu=tdf, observed=zy)
# Generate a MCMC chain
start = pm.find_MAP()
step = [pm.Metropolis([rv]) for rv in model.unobserved_RVs]
trace = pm.sample(10000, step, start, progressbar=False)
# EXAMINE THE RESULTS
burnin = 1000
thin = 10
## Print summary for each trace
#pm.summary(trace[burnin::thin])
#pm.summary(trace)
## Check for mixing and autocorrelation
#pm.autocorrplot(trace[burnin::thin], vars =[tau])
#pm.autocorrplot(trace, vars =[tau])
## Plot KDE and sampled values for each parameter.
data = data.T
sd = np.array([[i for i in range(1,201)]], dtype='float64')
sd = sd.T
with model:
#The prior is a drawn from a uniform distribution from -5 to 15 for each of the 200 dimensions.
params = pm.Uniform('params', lower=-5.0, upper=15.0, shape=(200,1), dtype='float64')
#I can't get the multivariate distribution to run for some reason. I think a bunch of normal distributions with the correct mu and sds should work...
pm.Normal('true_dist', mu=params, sd=sd, observed=data)
#pm.MvNormal('true_dist', mu=params, tau=prec_matrix, observed=data)
#Algorithmic values given in paper (eps= b* in paper)
step = pm.Dream(DEpairs=1, snooker=.1, nseedchains=2000, eps=10e-6, nCR=3, multitry=5)
#njobs = number of chains
trace = pm.sample(400000, step, njobs=3)
dictionary_to_pickle = {}
for dictionary in trace:
for var in dictionary:
dictionary_to_pickle[var] = trace[var]
pickle.dump(dictionary_to_pickle, open('2015_03_17_mv_test_mtdreamzs.p', 'wb'))
print 'Saving trace to text...'
text.dump('2015_03_17_mv_test_mtdreamzs', trace)
print 'Trace saved successfully.'
#
# We will use NUTS to sample from the posterior as implemented by the `NUTS` step method class.
# In[6]:
with model:
step = pm.NUTS()
# The `sample` function takes a number of steps to sample, a step method, a starting point. It returns a trace object which contains our samples.
# In[7]:
with model:
trace = pm.sample(3000, step, start)
# Out[7]:
# To use more than one sampler, pass a list of step methods to `sample`.
#
# The trace object can be indexed by the variables in the model, returning an array with the first index being the sample index
# and the other indexes the shape of the parameter. Thus for this example:
# In[8]:
trace[y].shape
# Out[8]:
momp_like = pm.ArbLikelihood('momp_output', momp)
icrp = pm.Deterministic('icrp', icrp)
ecrp = pm.Deterministic('ecrp', ecrp)
momp = pm.Deterministic('momp', momp)
#error_like = pm.ArbLikelihood('like', error)
#Select point in parameter space to start
#start = pm.find_MAP()
#Select stepping method
nseedchains = 10*len(earm.parameters_rules())
step = pm.Dream(variables=[model.params], nseedchains=nseedchains, blocked=True, multitry=5, start_random=False, save_history=True, parallel=False, adapt_crossover=False, history_file='2015_04_30_earm_embedded_mtdreamzs_normal_prior_history.npy', crossover_file='2015_04_18_earm_embedded_mtdreamzs_normal_prior_crossovervals.npy')
old_trace = text.load('2015_04_30_earm_embedded_mtdreamzs_normal_prior')
trace = pm.sample(15000, step, njobs=3, trace=old_trace, use_mpi=False) #pass njobs=None to start multiple chains on different cpus
text.dump('2015_05_01_earm_embedded_mtdreamzs_normal_prior', trace)
dictionary_to_pickle = {}
for dictionary in trace:
for var in dictionary:
dictionary_to_pickle[var] = trace[var]
pickle.dump(dictionary_to_pickle, open('2015_05_01_earm_embedded_mtdreamzs_normal_prior.p', 'wb'))
from helper_fxns import convert_param_vec_dict_to_param_dict
from helper_fxns import merge_traces
from helper_fxns import print_convergence_summary
