def all_matches(matches, match_evaluator): match_vars = [] for i in range(0,len(matches)): match=matches[i] match_name = 'match_%i' % i if match.order == "unordered": order = pm.DiscreteUniform('match_%i_order' % i, lower=0, upper=len(match.players)*2 - 1) else: observed = match.order == "total" order = pm.DiscreteUniform('match_%i_order' % i, value=0, lower=0, observed=observed, upper=len(match.players) - 1) eval_func = match_evaluator.eval_with_order parents = {'players': match.players, 'winning_team': match.winning_team, 'order': order, 'foul_end': match.foul_end} match_var = pm.Deterministic(eval = eval_func, doc = match_name, name = match_name, parents = parents, plot=False, dtype=float); match_vars.append(match_var) return match_vars
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 init_mcModel(self): self.logpTrace = zeros(10) self.cnt = 0 #############init pymc model###################### #priors for rate constants k = pymc.Normal('k', zeros_like(self.k0), 1. / logkSigma**2) #modeled species concentrations Dmod = pymc.Deterministic(self.forwardSoln, 'modeled species concentrations', 'Dmod', {'k': k}, verbose=0, plot=False) #observed species concentrations Dobs = pymc.Stochastic(self.modelLogProbability, 'measured species concentrations', 'Dobs', {'Dmod': Dmod}, value=self.D, verbose=0, plot=False, observed=True) self.mcModel = pymc.Model([k, Dmod, Dobs]) self.mcmc = pymc.MCMC(self.mcModel)
def model_with_dims(): with pm.Model( coords={"city": ["Aachen", "Maastricht", "London", "Bergheim"] }) as pmodel: economics = pm.Uniform("economics", lower=-1, upper=1, shape=(1, )) population = pm.HalfNormal("population", sigma=5, dims=("city")) time = pm.ConstantData("time", [2014, 2015, 2016], dims="year") n = pm.Deterministic("tax revenue", economics * population[None, :] * time[:, None], dims=("year", "city")) yobs = pm.MutableData("observed", np.ones((3, 4))) L = pm.Normal("L", n, observed=yobs) compute_graph = { "economics": set(), "population": set(), "time": set(), "tax revenue": {"economics", "population", "time"}, "L": {"tax revenue"}, "observed": {"L"}, } plates = { "1": {"economics"}, "city (4)": {"population"}, "year (3)": {"time"}, "year (3) x city (4)": {"tax revenue"}, "3 x 4": {"L", "observed"}, } return pmodel, compute_graph, plates
def _create_kde_stochastic(self, kde, kde_name, param_names): ''' Creates custom pymc stochastic object based on a multivariate kernel density estimate (kde should be kde object from scipy). ''' # build kde stochastic logp = lambda value: kde.logpdf(value) random = lambda value: kde.resample(1).flatten() KDE = pymc.Stochastic(logp=logp, doc='multivariate KDE', value=random(0), name=kde_name, parents=dict(), random=random, trace=True, dtype=float, observed=False, plot=True) # build deterministics dependent on kde stochastic rvs = dict() eval_func_dict = dict() for i, pn in enumerate(param_names): eval_func_dict[pn] = lambda i=i, **kwargs: kwargs[kde_name][i] rvs[pn] = pymc.Deterministic(eval=eval_func_dict[pn], name=pn, parents={kde_name: KDE}, doc='model param %s' % pn, trace=True, dtype=float, plot=True) return KDE, rvs
def test_deterministic(): with pm.Model() as model: x = Normal('x', 0, 1) y = pm.Deterministic('y', x**2) assert model.y == y assert model['y'] == y
def make_model(cls): with pm.Model() as model: sd_mu = np.array([1, 2, 3, 4, 5]) sd_dist = pm.LogNormal.dist(mu=sd_mu, sigma=sd_mu / 10.0, size=5) chol_packed = pm.LKJCholeskyCov("chol_packed", eta=3, n=5, sd_dist=sd_dist) chol = pm.expand_packed_triangular(5, chol_packed, lower=True) cov = at.dot(chol, chol.T) stds = at.sqrt(at.diag(cov)) pm.Deterministic("log_stds", at.log(stds)) corr = cov / stds[None, :] / stds[:, None] corr_entries_unit = (corr[np.tril_indices(5, -1)] + 1) / 2 pm.Deterministic("corr_entries_unit", corr_entries_unit) return model
def _build_prior(self, name, Xs, jitter, **kwargs): self.N = int(np.prod([len(X) for X in Xs])) mu = self.mean_func(cartesian(*Xs)) chols = [cholesky(stabilize(cov(X), jitter)) for cov, X in zip(self.cov_funcs, Xs)] v = pm.Normal(name + "_rotated_", mu=0.0, sigma=1.0, size=self.N, **kwargs) f = pm.Deterministic(name, mu + at.flatten(kron_dot(chols, v))) return f
def test_deterministic(): with pm.Model() as model: x = pm.Normal("x", 0, 1) y = pm.Deterministic("y", x**2) assert model.y == y assert model["y"] == y
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 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, ) ppc_trace = pm.trace_to_dataframe( trace, varnames=[n for n in trace.varnames if n != "out"] ).to_dict("records") 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 model_with_different_descendants(): """ Model proposed by Michael to test variable selection functionality From here: https://github.com/pymc-devs/pymc/pull/5634#pullrequestreview-916297509 """ with pm.Model() as pmodel2: a = pm.Normal("a") b = pm.Normal("b") pm.Normal("c", a * b) intermediate = pm.Deterministic("intermediate", a + b) pred = pm.Deterministic("pred", intermediate * 3) obs = pm.ConstantData("obs", 1.75) L = pm.Normal("L", mu=1 + 0.5 * pred, observed=obs) return pmodel2
def simple_2model_continuous(): mu = -2.1 tau = 1.3 with Model() as model: x = pm.Normal("x", mu, tau=tau, initval=0.1) pm.Deterministic("logx", at.log(x)) pm.Beta("y", alpha=1, beta=1, size=2) return model.compute_initial_point(), model
def point_list_arg_bug_fixture() -> Tuple[pm.Model, pm.backends.base.MultiTrace]: with pm.Model() as pmodel: n = pm.Normal("n") trace = pm.sample(return_inferencedata=False) with pmodel: d = pm.Deterministic("d", n * 4) return pmodel, trace
def test_model_pickle_deterministic(tmpdir): """Tests that PyMC models are pickleable""" with pm.Model() as model: x = pm.Normal("x") z = pm.Normal("z") pm.Deterministic("w", x / z) pm.Normal("y", observed=1) cloudpickle.loads(cloudpickle.dumps(model))
def simple_2model(): mu = -2.1 tau = 1.3 p = 0.4 with Model() as model: x = pm.Normal("x", mu, tau=tau, initval=0.1) pm.Deterministic("logx", at.log(x)) pm.Bernoulli("y", p) return model.compute_initial_point(), model
def _create_bayesian_gbmodel(self, database, initial_parameters): """ Generates the PyMC model to sample within one GB model (no Reversible Jump) Arguments --------- database : dict Database of FreeSolv solvation free energy data initial_parameters : dict Dict containing the starting set of parameters for the model Returns ------- gbffmodel : dict A dict containing the nodes of a PyMC model to sample """ gbffmodel = dict() log_sigma_min = math.log(0.01) # kcal/mol log_sigma_max = math.log(10.0) # kcal/mol log_sigma_guess = math.log(0.2) cid_list = database.keys() def RMSE(**args): nmolecules = len(cid_list) error = np.zeros([nmolecules], np.float64) for (molecule_index, cid) in enumerate(cid_list): entry = database[cid] error[molecule_index] = args['dg_gbsa'][ molecule_index] - float(entry['expt']) mse = np.mean((error - np.mean(error))**2) return np.sqrt(mse) gbffmodel['log_sigma'] = pymc.Uniform('log_sigma', lower=log_sigma_min, upper=log_sigma_max, value=log_sigma_guess) gbffmodel['sigma'] = pymc.Lambda( 'sigma', lambda log_sigma=gbffmodel['log_sigma']: math.exp(log_sigma)) gbffmodel['tau'] = pymc.Lambda( 'tau', lambda sigma=gbffmodel['sigma']: sigma**(-2)) gbffmodel.update(self.parameter_model) gbffmodel_with_mols = self._add_parallel_gbffmodel(database, gbffmodel) gbffmodel_with_mols['RMSE'] = pymc.Deterministic( eval=RMSE, name='RMSE', parents={'dg_gbsa': gbffmodel_with_mols['dg_gbsa']}, doc='RMSE', dtype=float, trace=True, verbose=1) return gbffmodel_with_mols
def _build_prior(self, name, X, reparameterize=True, jitter=JITTER_DEFAULT, **kwargs): mu = self.mean_func(X) cov = stabilize(self.cov_func(X), jitter) if reparameterize: size = infer_size(X, kwargs.pop("size", None)) v = pm.StudentT(name + "_rotated_", mu=0.0, sigma=1.0, nu=self.nu, size=size, **kwargs) f = pm.Deterministic(name, mu + cholesky(cov).dot(v)) else: f = pm.MvStudentT(name, nu=self.nu, mu=mu, cov=cov, **kwargs) return f
def simple_2model(): mu = -2.1 tau = 1.3 p = .4 with Model() as model: x = pm.Normal('x', mu, tau, testval=.1) logx = pm.Deterministic('logx', log(x)) y = pm.Bernoulli('y', p) return model.test_point, model
def _build_prior(self, name, X, reparameterize=True, **kwargs): mu = self.mean_func(X) cov = stabilize(self.cov_func(X)) shape = infer_shape(X, kwargs.pop("shape", None)) if reparameterize: v = pm.Normal(name + "_rotated_", mu=0.0, sigma=1.0, size=shape, **kwargs) f = pm.Deterministic(name, mu + cholesky(cov).dot(v)) else: f = pm.MvNormal(name, mu=mu, cov=cov, size=shape, **kwargs) return f
def __init__(self, name="", model=None): super().__init__(name, model) assert pm.modelcontext(None) is self # 1) init variables with Var method self.register_rv(pm.Normal.dist(), "v1") self.v2 = pm.Normal("v2", mu=0, sigma=1) # 2) Potentials and Deterministic variables with method too # be sure that names will not overlap with other same models pm.Deterministic("d", at.constant(1)) pm.Potential("p", at.constant(1))
def _build_prior(self, name, X, reparameterize=True, **kwargs): mu = self.mean_func(X) cov = stabilize(self.cov_func(X)) shape = infer_shape(X, kwargs.pop("shape", None)) if reparameterize: chi2 = pm.ChiSquared(name + "_chi2_", self.nu) v = pm.Normal(name + "_rotated_", mu=0.0, sigma=1.0, size=shape, **kwargs) f = pm.Deterministic(name, (at.sqrt(self.nu) / chi2) * (mu + cholesky(cov).dot(v))) else: f = pm.MvStudentT(name, nu=self.nu, mu=mu, cov=cov, size=shape, **kwargs) return f
def test_autodetect_coords_from_model(self, use_context): pd = pytest.importorskip("pandas") df_data = pd.DataFrame(columns=["date"]).set_index("date") dates = pd.date_range(start="2020-05-01", end="2020-05-20") for city, mu in {"Berlin": 15, "San Marino": 18, "Paris": 16}.items(): df_data[city] = np.random.normal(loc=mu, size=len(dates)) df_data.index = dates df_data.index.name = "date" coords = {"date": df_data.index, "city": df_data.columns} with pm.Model(coords=coords) as model: europe_mean = pm.Normal("europe_mean_temp", mu=15.0, sigma=3.0) city_offset = pm.Normal("city_offset", mu=0.0, sigma=3.0, dims="city") city_temperature = pm.Deterministic("city_temperature", europe_mean + city_offset, dims="city") data_dims = ("date", "city") data = pm.ConstantData("data", df_data, dims=data_dims) _ = pm.Normal("likelihood", mu=city_temperature, sigma=0.5, observed=data, dims=data_dims) trace = pm.sample( return_inferencedata=False, compute_convergence_checks=False, cores=1, chains=1, tune=20, draws=30, step=pm.Metropolis(), ) if use_context: idata = to_inference_data(trace=trace) if not use_context: idata = to_inference_data(trace=trace, model=model) assert "city" in list(idata.posterior.dims) assert "city" in list(idata.observed_data.dims) assert "date" in list(idata.observed_data.dims) np.testing.assert_array_equal(idata.posterior.coords["city"], coords["city"]) np.testing.assert_array_equal(idata.observed_data.coords["date"], coords["date"]) np.testing.assert_array_equal(idata.observed_data.coords["city"], coords["city"])
def fakeDeterministicFromValue(tracevalue, eval=None, doc="", name="", parents={}): """Create a Deterministic object which will return tracevalue when it's trace method is called. """ if eval is None: eval = lambda: None v = pymc.Deterministic(eval, doc, name, parents) v.trace = lambda: tracevalue return v
def fixture_model(): with pm.Model() as model: n = 5 dim = 4 with pm.Model(): cov = pm.InverseGamma("cov", alpha=1, beta=1) x = pm.Normal("x", mu=np.ones((dim, )), sigma=pm.math.sqrt(cov), shape=(n, dim)) eps = pm.HalfNormal("eps", np.ones((n, 1)), shape=(n, dim)) mu = pm.Deterministic("mu", at.sum(x + eps, axis=-1)) y = pm.Normal("y", mu=mu, sigma=1, shape=(n, )) return model, [cov, x, eps, y]
def data(self, eight_schools_params, draws, chains): with pm.Model() as model: mu = pm.Normal("mu", mu=0, sd=5) tau = pm.HalfCauchy("tau", beta=5) eta = pm.Normal("eta", mu=0, sd=1, size=eight_schools_params["J"]) theta = pm.Deterministic("theta", mu + tau * eta) pm.Normal( "obs", mu=theta, sd=eight_schools_params["sigma"], observed=eight_schools_params["y"], ) trace = pm.sample(draws, chains=chains, return_inferencedata=False) return self.Data(model, trace)
def test_deterministic_samples(): aesara.config.on_opt_error = "raise" np.random.seed(13244) obs = np.random.normal(10, 2, size=100) obs_at = aesara.shared(obs, borrow=True, name="obs") with pm.Model() as model: a = pm.Uniform("a", -20, 20) b = pm.Deterministic("b", a / 2.0) c = pm.Normal("c", a, sigma=1.0, observed=obs_at) trace = sample_numpyro_nuts(chains=2, random_seed=1322, keep_untransformed=True) assert 8 < trace.posterior["a"].mean() < 11 assert np.allclose(trace.posterior["b"].values, trace.posterior["a"].values / 2)
def test_ignores_observed(self): observed = np.random.normal(10, 1, size=200) with pm.Model(): # Use a prior that's way off to show we're ignoring the observed variables observed_data = pm.Data("observed_data", observed) mu = pm.Normal("mu", mu=-100, sigma=1) positive_mu = pm.Deterministic("positive_mu", np.abs(mu)) z = -1 - positive_mu pm.Normal("x_obs", mu=z, sigma=1, observed=observed_data) prior = pm.sample_prior_predictive(return_inferencedata=False) assert "observed_data" not in prior assert (prior["mu"] < -90).all() assert (prior["positive_mu"] > 90).all() assert (prior["x_obs"] < -90).all() assert prior["x_obs"].shape == (500, 200) npt.assert_array_almost_equal(prior["positive_mu"], np.abs(prior["mu"]), decimal=4)
def build_linear_model(x_vals, data, sigma_squared=10.0): tau = 1.0 / sigma_squared B_0 = pm.Normal('B_0', mu=0.0, tau=tau, doc='line slope', rseed=0) B_1 = pm.Normal('B_1', mu=0.0, tau=tau, doc='line intercept', rseed=0) SI = pm.HalfNormal('SI', tau=tau, doc='line sigma', rseed=0) MU = pm.Deterministic( name='mus', eval=lambda B_0, B_1: B_0 * x_vals + B_1, parents={ 'B_0': B_0, 'B_1': B_1 }, doc='mu for line', plot=False, # rseed=0 NOTE: PyMC version 2.3.6 throws an error here. ) OUT = pm.Normal('accuracies', mu=MU, tau=1.0/SI**2, value=data, \ observed=True, rseed=0) return [B_0, B_1, SI, MU, OUT]
def test_transformed(self): n = 18 at_bats = 45 * np.ones(n, dtype=int) hits = np.random.randint(1, 40, size=n, dtype=int) draws = 50 with pm.Model() as model: phi = pm.Beta("phi", alpha=1.0, beta=1.0) kappa_log = pm.Exponential("logkappa", lam=5.0) kappa = pm.Deterministic("kappa", at.exp(kappa_log)) thetas = pm.Beta("thetas", alpha=phi * kappa, beta=(1.0 - phi) * kappa, size=n) y = pm.Binomial("y", n=at_bats, p=thetas, observed=hits) gen = pm.sample_prior_predictive(draws) assert gen.prior["phi"].shape == (1, draws) assert gen.prior_predictive["y"].shape == (1, draws, n) assert "thetas" in gen.prior.data_vars