def test_datalogpt_multiple_shapes():
with pm.Model() as m:
x = pm.Normal("x", 0, 1)
z1 = pm.Potential("z1", x)
z2 = pm.Potential("z2", at.full((1, 3), x))
y1 = pm.Normal("y1", x, 1, observed=np.array([1]))
y2 = pm.Normal("y2", x, 1, observed=np.array([1, 2]))
y3 = pm.Normal("y3", x, 1, observed=np.array([1, 2, 3]))
# This would raise a TypeError, see #4803 and #4804
x_val = m.rvs_to_values[x]
m.datalogpt.eval({x_val: 0})
def test_point_logps_potential():
with pm.Model() as model:
x = pm.Flat("x", initval=1)
y = pm.Potential("y", x * 2)
logps = model.point_logps()
assert np.isclose(logps["y"], 2)
def setup_class(self):
super().setup_class()
self.samples = 1000
n = 4
mu1 = np.ones(n) * (1.0 / 2)
mu2 = -mu1
stdev = 0.1
sigma = np.power(stdev, 2) * np.eye(n)
isigma = np.linalg.inv(sigma)
dsigma = np.linalg.det(sigma)
w1 = stdev
w2 = 1 - stdev
def two_gaussians(x):
log_like1 = (-0.5 * n * at.log(2 * np.pi) - 0.5 * at.log(dsigma) -
0.5 * (x - mu1).T.dot(isigma).dot(x - mu1))
log_like2 = (-0.5 * n * at.log(2 * np.pi) - 0.5 * at.log(dsigma) -
0.5 * (x - mu2).T.dot(isigma).dot(x - mu2))
return at.log(w1 * at.exp(log_like1) + w2 * at.exp(log_like2))
with pm.Model() as self.SMC_test:
X = pm.Uniform("X", lower=-2, upper=2.0, shape=n)
llk = pm.Potential("muh", two_gaussians(X))
self.muref = mu1
with pm.Model() as self.fast_model:
x = pm.Normal("x", 0, 1)
y = pm.Normal("y", x, 1, observed=0)
def mixture_model(random_seed=1234):
"""Sample mixture model to use in benchmarks"""
np.random.seed(1234)
size = 1000
w_true = np.array([0.35, 0.4, 0.25])
mu_true = np.array([0.0, 2.0, 5.0])
sigma = np.array([0.5, 0.5, 1.0])
component = np.random.choice(mu_true.size, size=size, p=w_true)
x = np.random.normal(mu_true[component], sigma[component], size=size)
with pm.Model() as model:
w = pm.Dirichlet("w", a=np.ones_like(w_true))
mu = pm.Normal("mu", mu=0.0, sd=10.0, shape=w_true.shape)
enforce_order = pm.Potential(
"enforce_order",
at.switch(mu[0] - mu[1] <= 0, 0.0, -np.inf) +
at.switch(mu[1] - mu[2] <= 0, 0.0, -np.inf),
)
tau = pm.Gamma("tau", alpha=1.0, beta=1.0, shape=w_true.shape)
pm.NormalMixture("x_obs", w=w, mu=mu, tau=tau, observed=x)
# Initialization can be poorly specified, this is a hack to make it work
start = {
"mu": mu_true.copy(),
"tau_log__": np.log(1.0 / sigma**2),
"w_stickbreaking__": np.array([-0.03, 0.44]),
}
return model, start
def test_potential(self):
with pm.Model():
x = pm.Normal("x", 0.0, 1.0)
pm.Potential("z", pm.logp(pm.Normal.dist(x, 1.0), np.random.randn(10)))
inference_data = pm.sample(100, chains=2, return_inferencedata=True)
assert inference_data
def set_constraint(self):
"""
Creates the constraint object needed for the nested sampling
loops.
"""
import pymc, numpy
def do_likelihood(pars=self._priors):
p = {}
for key in self.names:
p[key] = pars[key]
if self.logLikelihood(p) > self.logLstar:
return 0
else:
return -numpy.inf
parents = {'pars': self._priors}
constraint = pymc.Potential(logp=do_likelihood,
name='constraint',
parents=parents,
doc='Likelihood constraint',
verbose=0,
cache_depth=2)
return constraint
def test_potentials_warning(self):
warning_msg = "The effect of Potentials on other parameters is ignored during"
with pm.Model() as m:
a = pm.Normal("a", 0, 1)
p = pm.Potential("p", a + 1)
with m:
with pytest.warns(UserWarning, match=warning_msg):
pm.sample_prior_predictive(samples=5)
def test_get_jaxified_logp():
with pm.Model() as m:
x = pm.Flat("x")
y = pm.Flat("y")
pm.Potential("pot", at.log(at.exp(x) + at.exp(y)))
jax_fn = get_jaxified_logp(m)
# This would underflow if not optimized
assert not np.isinf(jax_fn((np.array(5000.0), np.array(5000.0))))
def test_rvs_to_value_vars_nested():
# Test that calling rvs_to_value_vars in models with nested transformations
# does not change the original rvs in place. See issue #5172
with pm.Model() as m:
one = pm.LogNormal("one", mu=0)
two = pm.LogNormal("two", mu=at.log(one))
# We add potentials or deterministics that are not in topological order
pm.Potential("two_pot", two)
pm.Potential("one_pot", one)
before = aesara.clone_replace(m.free_RVs)
# This call would change the model free_RVs in place in #5172
res, _ = rvs_to_value_vars(m.potentials, apply_transforms=True)
after = aesara.clone_replace(m.free_RVs)
assert equal_computations(before, after)
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 test_potentials_warning(self):
warning_msg = "The effect of Potentials on other parameters is ignored during"
with pm.Model() as m:
a = pm.Normal("a", 0, 1)
p = pm.Potential("p", a + 1)
obs = pm.Normal("obs", a, 1, observed=5)
trace = az_from_dict({"a": np.random.rand(10)})
with pytest.warns(UserWarning, match=warning_msg):
pm.sample_posterior_predictive_w(samples=5, traces=[trace, trace], models=[m, m])
def new_player(name, sink=0.5, foul=1e-10):
player = {}
player['sink'] = pm.Beta(name + "_sink", alpha=3, beta=3, value=sink)
player['foul_end'] = pm.Beta(name + "_foul_end", alpha=3,
beta=3, value=foul)
vars = player.values()
player['balance'] = pm.Potential(logp = sum_less_than_one,
name = name + "_balance",
parents = {'vars': vars},
doc = name + "_balance")
return player
def setup_class(self):
super().setup_class()
self.data = np.random.normal(loc=0, scale=1, size=1000)
with pm.Model() as self.SMABC_test:
a = pm.Normal("a", mu=0, sigma=1)
b = pm.HalfNormal("b", sigma=1)
s = pm.Simulator("s", self.normal_sim, a, b, sum_stat="sort", observed=self.data)
self.s = s
with pm.Model() as self.SMABC_potential:
a = pm.Normal("a", mu=0, sigma=1, initval=0.5)
b = pm.HalfNormal("b", sigma=1)
c = pm.Potential("c", pm.math.switch(a > 0, 0, -np.inf))
s = pm.Simulator("s", self.normal_sim, a, b, observed=self.data)
def sample(self, N, T=50, burn=1000):
x = mc.Uniform('x', -np.ones(self.D), np.ones(self.D), value=np.zeros(self.D))
def sphere(x):
if (x**2).sum()>=1.:
return -np.inf
else:
return self.f(x)
p1 = mc.Potential(
logp = sphere,
name = 'sphere',
parents = {'x': x},
doc = 'Sphere potential',
verbose = 0)
chain = mc.MCMC([x])
chain.use_step_method(mc.AdaptiveMetropolis, x, delay=burn)
chain.sample(N*T+burn, thin=T, burn=burn)
return x.trace()
def test_discrete_rounding_proposal(self):
"""
Test that discrete variable values are automatically rounded
in SMC logp functions
"""
with pm.Model() as m:
z = pm.Bernoulli("z", p=0.7)
like = pm.Potential("like", z * 1.0)
smc = IMH(model=m)
smc.initialize_population()
smc._initialize_kernel()
assert smc.prior_logp_func(floatX(np.array([-0.51]))) == -np.inf
assert np.isclose(smc.prior_logp_func(floatX(np.array([-0.49]))), np.log(0.3))
assert np.isclose(smc.prior_logp_func(floatX(np.array([0.49]))), np.log(0.3))
assert np.isclose(smc.prior_logp_func(floatX(np.array([0.51]))), np.log(0.7))
assert smc.prior_logp_func(floatX(np.array([1.51]))) == -np.inf
def IndepSetPotential(self, v, N_v):
'''
N_v is neighbors of v
see descption in
https://pymc-devs.github.io/pymc/modelbuilding.html#the-potential-classhttps://pymc-devs.github.io/pymc/modelbuilding.html#the-potential-class
'''
def potential_logp(v, N_v):
if v + max(N_v) > 1:
return -Inf
else:
return self.beta * v
return pm.Potential(logp=potential_logp,
name="N_%d" % v,
parents={
'v': self.x[v],
'N_v': [self.x[w] for w in N_v]
},
doc='vertex potential term')
def test_tempered_logp_dlogp():
with pm.Model() as model:
pm.Normal("x")
pm.Normal("y", observed=1)
pm.Potential("z", at.constant(-1.0, dtype=aesara.config.floatX))
func = model.logp_dlogp_function()
func.set_extra_values({})
func_temp = model.logp_dlogp_function(tempered=True)
func_temp.set_extra_values({})
func_nograd = model.logp_dlogp_function(compute_grads=False)
func_nograd.set_extra_values({})
func_temp_nograd = model.logp_dlogp_function(tempered=True,
compute_grads=False)
func_temp_nograd.set_extra_values({})
x = np.ones(1, dtype=func.dtype)
npt.assert_allclose(func(x)[0], func_temp(x)[0])
npt.assert_allclose(func(x)[1], func_temp(x)[1])
npt.assert_allclose(func_nograd(x), func(x)[0])
npt.assert_allclose(func_temp_nograd(x), func(x)[0])
func_temp.set_weights(np.array([0.0], dtype=func.dtype))
func_temp_nograd.set_weights(np.array([0.0], dtype=func.dtype))
npt.assert_allclose(func(x)[0], 2 * func_temp(x)[0] - 1)
npt.assert_allclose(func(x)[1], func_temp(x)[1])
npt.assert_allclose(func_nograd(x), func(x)[0])
npt.assert_allclose(func_temp_nograd(x), func_temp(x)[0])
func_temp.set_weights(np.array([0.5], dtype=func.dtype))
func_temp_nograd.set_weights(np.array([0.5], dtype=func.dtype))
npt.assert_allclose(func(x)[0], 4 / 3 * (func_temp(x)[0] - 1 / 4))
npt.assert_allclose(func(x)[1], func_temp(x)[1])
npt.assert_allclose(func_nograd(x), func(x)[0])
npt.assert_allclose(func_temp_nograd(x), func_temp(x)[0])
def test_duplicate_vars():
with pytest.raises(ValueError) as err:
with pm.Model():
pm.Normal("a")
pm.Normal("a")
err.match("already exists")
with pytest.raises(ValueError) as err:
with pm.Model():
pm.Normal("a")
pm.Normal("a", transform=transforms.log)
err.match("already exists")
with pytest.raises(ValueError) as err:
with pm.Model():
a = pm.Normal("a")
pm.Potential("a", a**2)
err.match("already exists")
with pytest.raises(ValueError) as err:
with pm.Model():
pm.Binomial("a", 10, 0.5)
pm.Normal("a", transform=transforms.log)
err.match("already exists")
def another_simple_model():
_model = models.simple_model()[1]
with _model:
pm.Potential("pot", at.ones((10, 10)))
return _model
def sample(self, N: int, T: int = 1, burn: int = 1000) -> List:
"""
Returns N samples from the distribution defined by applying update_func on the demonstrations and preferences
observed thus far.
:param N: number of samples to draw.
:param T: if greater than 1, all samples except each T^{th} sample are discarded.
:param burn: how many samples before the chain converges; these initial samples are discarded.
:return: list of samples drawn.
"""
x = tt.vector()
x.tag.test_value = np.random.uniform(-1, 1, self.dim_features)
# define update function
start = time.time()
if self.update_func == "approx":
self.f = th.function(
[x],
tt.sum([
-tt.nnet.relu(
-self.beta_pref * tt.dot(self.phi_prefs[i], x))
for i in range(len(self.phi_prefs))
]) + tt.sum(self.beta_demo * tt.dot(self.phi_demos, x)))
elif self.update_func == "pick_best":
self.f = th.function(
[x],
tt.sum([
-tt.log(
tt.sum(
tt.exp(self.beta_pref *
tt.dot(self.phi_prefs[i], x))))
for i in range(len(self.phi_prefs))
]) + tt.sum(self.beta_demo * tt.dot(self.phi_demos, x)))
elif self.update_func == "rank":
self.f = th.function(
[x],
tt.sum( # summing across different queries
[
tt.sum( # summing across different terms in PL-update
-tt.log([
tt.
sum( # summing down different feature-differences in a single term in PL-update
tt.exp(self.beta_pref * tt.dot(
self.phi_prefs[i][j:, :] -
self.phi_prefs[i][j], x)))
for j in range(self.n_query)
])) for i in range(len(self.phi_prefs))
]) + tt.sum(self.beta_demo * tt.dot(self.phi_demos, x)))
print("Finished constructing sampling function in " +
str(time.time() - start) + "seconds")
# perform sampling
x = mc.Uniform('x',
-np.ones(self.dim_features),
np.ones(self.dim_features),
value=np.zeros(self.dim_features))
def sphere(x):
if (x**2).sum() >= 1.:
return -np.inf
else:
return self.f(x)
p = mc.Potential(logp=sphere,
name='sphere',
parents={'x': x},
doc='Sphere potential',
verbose=0)
chain = mc.MCMC([x])
chain.use_step_method(mc.AdaptiveMetropolis,
x,
delay=burn,
cov=np.eye(self.dim_features) / 5000)
chain.sample(N * T + burn, thin=T, burn=burn, verbose=-1)
samples = x.trace()
samples = np.array([x / np.linalg.norm(x) for x in samples])
# print("Finished MCMC after drawing " + str(N*T+burn) + " samples")
return samples
import numpy as np
import matplotlib.pyplot as plt
import pymc as pm
k = 3
ndata = 500
spread = 5
centres = np.array([-spread, 0, spread])
v = np.random.randint(0, k, ndata)
data = centres[v] + np.random.randn(ndata)
l_res = plt.hist(data)
plt.show()
a = pm.constant(np.array([1., 1., 1.]))
p = pm.Dirichlet('p', a=a, shape=k)
p_min_potential = pm.Potential('p_min_potential',
tt.switch(tt.min(p) < .1, -np.inf, 0))
means = pm.Normal('means', mu=[0, 0, 0], sd=15, shape=k)
order_means_potential = pm.Potential(
'order_means_potential',
ttswitch(means[1] - means[0] < 0, -np.inf, 0) +
ttswitch(means[2] - means[1] < 0, -np.inf, 0))
@pm.potential
def psi_i(x_lo=x[i], x_hi=x[i + 1]):
"""A pair potential"""
return -(x_lo - x_hi)**2
def psi_i_logp(x_lo=x[i], x_hi=x[i + 1]):
return -(x_lo - x_hi)**2
psi_i = pm.Potential(logp=psi_i_logp,
name='psi_i',
parents={
'x_lo': x[i],
'x_hi': x[i + 1]
},
doc='A pair potential',
verbose=0,
cache_depth=2)
# Just made this up to test the bit of code below
def fun(value, a=1):
return 2 * a + value
arguments = pm.DictContainer(dict(value=5, a=1))
# Here is the code from the paper.
L = pm.LazyFunction(fun, arguments)
print c,v
print "num_pathways:", len(pathways)
print "num_features:", len(features)
print "num_evidence:", len(evidence)
print "num_metfrag: ", len(metfrag_evidence)
rate_prior = 0.5
#eps = Beta('eps', 0.005, 1)
eps = 0.0001
ap = {p : Gamma('p_' + p, rate_prior, 1) for p in pathways}
bmp = {p : {feat : Gamma('b_{' + p + ',' + feat + '}', ap[p],1) for feat in path_dict[p]} for p in pathways}
y_bmp = {}
g = {}
def logp_f(f, b, eps):
if f in evidence:
return math.log(1 - math.e ** (-1 * b) + epsilon)
if f in metfrag_evidence:
a_p = (1.0 / (1 - metfrag_evidence[f])) - 1
return a_p * math.log(1 - math.e ** (-1 * b) + epsilon) - b
return math.log(eps) - b
psi = {}
for feat, pathways in reverse_path_dict.iteritems():
y_bmp[feat] = sum([bmp[pname][feat] for pname in pathways])
g[feat] = Bernoulli('g_' + feat, 1 - math.e ** (-y_bmp[feat]))
psi[feat] = pymc.Potential(logp = logp_f,
name = 'psi_' + feat,
parents = {'f' : feat, 'b' : y_bmp[feat], 'eps' : eps},
doc = 'hello world potential'
)
