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
