def test_sample_auto_batching(vectorized_model_fixture, xla_fixture, use_auto_batching_fixture): model, is_vectorized_model, core_shapes = vectorized_model_fixture num_samples = 10 num_chains = 4 if not is_vectorized_model and not use_auto_batching_fixture: with pytest.raises(Exception): pm.sample( model=model(), num_samples=num_samples, num_chains=num_chains, burn_in=1, step_size=0.1, xla=xla_fixture, use_auto_batching=use_auto_batching_fixture, ) else: trace = pm.sample( model=model(), num_samples=num_samples, num_chains=num_chains, burn_in=1, step_size=0.1, xla=xla_fixture, use_auto_batching=use_auto_batching_fixture, ) posterior = trace.posterior for rv_name, core_shape in core_shapes.items(): assert posterior[rv_name].shape == (num_chains, num_samples) + core_shape
def test_sampling(mixture, xla_fixture): model, n, k = mixture if xla_fixture: with pytest.raises(tf.errors.InvalidArgumentError): pm.sample(model, num_samples=100, num_chains=2, xla=xla_fixture) else: trace = pm.sample(model, num_samples=100, num_chains=2, xla=xla_fixture) if n == 1: assert trace.posterior["mixture/means"].shape == (2, 100, k) else: assert trace.posterior["mixture/means"].shape == (2, 100, n, k)
def test_sampling_log_likelihood(vectorized_model_fixture): model, is_vectorized_model, core_shapes = vectorized_model_fixture num_samples = 10 num_chains = 4 trace = pm.sample( model=model(), num_samples=num_samples, num_chains=num_chains, burn_in=1, step_size=0.1, include_log_likelihood=True, ) if is_vectorized_model: # only one log likeliood matrix assert trace.log_likelihood["model/x"].shape == (num_chains, num_samples) else: state, _ = pm.initialize_sampling_state(model()) assert trace.log_likelihood["model/x"].shape == ( num_chains, num_samples, *state.observed_values["model/x"].shape, )
def test_posterior_predictive(mixture): model, n, _ = mixture trace = pm.sample(model, num_samples=100, num_chains=2) ppc = pm.sample_posterior_predictive(model, trace).posterior_predictive if n == 1: assert ppc["mixture/mixture"].shape == (2, 100, 100) else: assert ppc["mixture/mixture"].shape == (2, 100, 100, n)
def test_sample_deterministics(simple_model_with_deterministic, xla_fixture): model = simple_model_with_deterministic() trace = pm.sample( model=model, num_samples=10, num_chains=4, burn_in=100, step_size=0.1, xla=xla_fixture ) norm = "simple_model_with_deterministic/simple_model/norm" determ = "simple_model_with_deterministic/determ" np.testing.assert_allclose(trace.posterior[determ], trace.posterior[norm] * 2)
def posterior_predictive_fixture(model_with_observed_fixture): num_samples = 40 num_chains = 3 (model, observed, core_ppc_shapes, observed_in_RV) = model_with_observed_fixture trace = pm.sample(model(), num_samples=num_samples, num_chains=num_chains, observed=observed) return model, observed, core_ppc_shapes, observed_in_RV, trace, num_samples, num_chains
def test_beta_sample(): @pm.model def model(): dist = yield pm.Beta("beta", 0, 1) return dist trace = pm.sample(model(), num_samples=1, burn_in=1) assert trace.posterior["model/beta"] is not None assert trace.posterior["model/__sigmoid_beta"] is not None
def test_sample(): model = pm.Model() @model.define def sample(cfg): mu = ed.Normal(0., 1., name="mu") trace = pm.sample(model) assert 0. == pytest.approx(trace["mu"].mean(), 1) assert 1. == pytest.approx(trace["mu"].std(), 1)
def test_compound_sampling(model_with_discrete_and_continuous, xla_fixture, seed): model = model_with_discrete_and_continuous() trace = pm.sample(model=model, sampler_type="compound", xla_fixture=xla_fixture, seed=seed) round_value = round( trace.posterior["model_with_discrete_and_continuous/disc"].mean().item( ), 1) np.testing.assert_allclose(round_value, 0.9, atol=0.1)
def test_discrete_sampling_bernoulli(model_with_discrete_bernoulli, xla_fixture, seed): model = model_with_discrete_bernoulli() trace = pm.sample(model=model, sampler_type="compound", xla_fixture=xla_fixture, seed=seed) round_value = round( trace.posterior["model_with_discrete_bernoulli/disc"].mean().item(), 1) # check to match the bernoulli prob parameter np.testing.assert_allclose(round_value, 0.9, atol=0.1)
def test_gp_invalid_prior(tf_seed): """Test if an error is thrown for invalid model prior""" @pm.model def invalid_model(gp, X, X_new): f = gp.prior("f", X) cond = yield gp.conditional("fcond", X_new, given={"X": X, "f": f}) with pytest.raises(ValueError, match=r"must be a numpy array or tensor"): gp = pm.gp.LatentGP(cov_fn=pm.gp.cov.ExpQuad(1.0, 1.0)) X = tf.random.normal((2, 5, 1)) X_new = tf.random.normal((2, 2, 1)) trace = pm.sample(invalid_model(gp, X, X_new), num_samples=1, burn_in=1, num_chains=1)
def test_sampling_with_deterministics_in_nested_models( deterministics_in_nested_models, xla_fixture ): ( model, expected_untransformed, expected_transformed, expected_deterministics, deterministic_mapping, ) = deterministics_in_nested_models trace = pm.sample( model=model(), num_samples=10, num_chains=4, burn_in=100, step_size=0.1, xla=xla_fixture ) for deterministic, (inputs, op) in deterministic_mapping.items(): np.testing.assert_allclose( trace.posterior[deterministic], op(*[trace.posterior[i] for i in inputs]), rtol=1e-6 )
def mc3_approach(T, width, height, N): shape = (height, width) x0 = np.random.randint(2, size=shape) with pm.model() as model: x = pm.Bernoulli('x', 0.5, shape=shape, testval=x0) magnetization = pm.Potential( 'm', -get_H(to_spins(x)) / T ) scaling = .0006 mul = int(height * width * 1.75) step = pm.BinaryMetropolis([x], scaling=scaling) trace = pm.sample(N * mul * 5, step=step, chains=1, tune=False) dataset = [to_two_color(2 * t['x'] - 1) for t in trace[::mul * 5]] # Print out the final percent magnetization lattice = 2 * trace[-1]['x'] - 1 print('Finished. Net magnetization: {:3.0%}' .format(abs(lattice.sum()) / lattice.size)) return dataset
def test_sampling_with_no_free_rvs(simple_model_no_free_rvs): model = simple_model_no_free_rvs() with pytest.raises(ValueError): trace = pm.sample(model=model, num_samples=1, num_chains=1, burn_in=1)
# 4. Sampling # ------------------------------------------------------------------------------ # begin_time = time.time() log.info("start") num_chains = 4 trace_tuning, trace = pm.sample( this_model, num_samples=int(args.num_samples), num_samples_binning=10, burn_in_min=10, burn_in=int(args.num_burn_in), use_auto_batching=False, num_chains=num_chains, xla=False, initial_step_size=0.00001, ratio_tuning_epochs=1.3, max_tree_depth=4, decay_rate=0.75, target_accept_prob=0.75, # num_steps_between_results = 9, # state=pm.evaluate_model_transformed(this_model)[1] # sampler_type="nuts", ) end_time = time.time() log.info("running time: {:.1f}s".format(end_time - begin_time)) # We also Sample the prior for the kde in the plots (optional) trace_prior = pm.sample_prior_predictive(this_model, sample_shape=(10, ),
@pymc4_linear_regression.define def process(cfg): c = ed.Uniform(low=cfg.cmin, high=cfg.cmax, name="c") m = ed.Normal(loc=cfg.mmu, scale=cfg.msigma, name="m") y = ed.Normal(loc=(m*cfg.x+c), scale=np.float32(cfg.sigma), name="y") return y # add observed data pymc4_linear_regression.observe(y=data) Nsamples = 2000 # final number of samples Nburn = 2000 # number of tuning samples pymc4_trace = pm4.sample(pymc4_linear_regression, num_results=Nsamples, num_burnin_steps=Nburn, step_size=0.01, num_leapfrog_steps=5) postsamples = np.vstack((pymc4_trace['m'], pymc4_trace['c'])).T print(postsamples) # plot posterior samples (if corner.py is installed) try: import corner # import corner.py except ImportError: sys.exit(1) print('Number of posterior samples is {}'.format(postsamples.shape[0])) fig = corner.corner(postsamples, labels=[r"$m$", r"$c$"], truths=[m, c]) fig.savefig('pymc4.png')
def test_sampling_unknown_sampler(simple_model): model = simple_model() with pytest.raises(KeyError): trace = pm.sample(model=model, sampler_type="unknown")
mvalue = yield pm4.Normal(name='m', loc=mmu, scale=msigma) # prior on m # the straight line model mu = cvalue + mvalue * x # the likelihood yield pm4.Normal(name='t_obs', loc=mu, scale=sigma, observed=data) Nsamples = 2000 # final number of samples Nburn = 2000 # number of tuning samples # perform the sampling pymc4_trace = pm4.sample( model(xtensor, datatensor), num_chains=1, burn_in=Nburn, num_samples=Nsamples, ) postsamples = np.vstack((pymc4_trace.posterior["model/m"].data.flatten(), pymc4_trace.posterior["model/c"].data.flatten())).T # plot posterior samples (if corner.py is installed) try: import corner # import corner.py except ImportError: sys.exit(1) print('Number of posterior samples is {}'.format(postsamples.shape[0])) fig = corner.corner(postsamples, labels=[r"$m$", r"$c$"], truths=[m, c])
import tensorflow as tf # For Random Variable operation from tensorflow_probability import edward2 as ed # For defining random variables J = 8 # No. of schools y = np.array([28., 8., -3., 7., -1., 1., 18., 12.]) sigma = np.array([15., 10., 16., 11., 9., 11., 10., 18.]) pymc4_non_centered_eight = pm4.Model(num_schools=J, y=y, sigma=sigma) @pymc4_non_centered_eight.define def process(cfg): mu = ed.Normal(loc=0., scale=10., name="mu") log_tau = ed.Normal(loc=5., scale=1., name="log_tau") theta_prime = ed.Normal(loc=tf.zeros(cfg.num_schools), scale=tf.ones(cfg.num_schools), name="theta_prime") theta = mu + tf.exp(log_tau) * theta_prime y = ed.Normal(loc=theta, scale=np.float32(cfg.sigma), name="y") return y pymc4_non_centered_eight.observe(y=y) pymc4_trace = pm4.sample(pymc4_non_centered_eight) pymc4_theta = pymc4_trace['mu'][:, np.newaxis] + np.exp( pymc4_trace['log_tau'])[:, np.newaxis] * pymc4_trace['theta_prime'] print(np.mean(pymc4_theta, axis=0))