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